Java多线程编程核心技术总结——Lock的使用（四）

最新推荐文章于 2023-01-25 11:24:11 发布
最新推荐文章于 2023-01-25 11:24:11 发布
阅读量238 收藏
点赞数
分类专栏： Java多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zy52002520/article/details/80893228
版权

①使用ReentrantLock类

1.使用ReentrandLock实现同步

示例代码：

public class MyService {
    private Lock lock = new ReentrantLock();
    public void testMethod() {
        lock.lock();
        for (int i = 0; i < 5; i++) {
            System.out.println("ThreadName=" + Thread.currentThread().getName() + (" " + (i + 1)));
        }
        lock.unlock();
    }
}

class MyThread extends Thread {
    private MyService service;

    public MyThread(MyService service) {
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.testMethod();
    }
}

class Run {
    public static void main(String[] args) {
        MyService service = new MyService();
        MyThread a1 = new MyThread(service);
        MyThread a2 = new MyThread(service);
        MyThread a3 = new MyThread(service);
        MyThread a4 = new MyThread(service);
        a1.start();
        a2.start();
        a3.start();
        a4.start();
    }
}

运行结果：


2.使用Condition实现等待/通知

示例代码：

public class MyService {
    private Lock     lock      = new ReentrantLock();
    public Condition condition = lock.newCondition();

    public void await() {
        try {
            lock.lock();
            System.out.println(" await时间为" + System.currentTimeMillis());
            condition.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void signal() {
        try {
            lock.lock();
            System.out.println("signal时间为" + System.currentTimeMillis());
            condition.signal();
        } finally {
            lock.unlock();
        }
    }
}

class ThreadA extends Thread {
    private MyService service;

    public ThreadA(MyService service) {
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.await();
    }
}

class Run {
    public static void main(String[] args) throws Exception {
        MyService service = new MyService();
        ThreadA a = new ThreadA(service);
        a.start();
        Thread.sleep(3000);
        service.signal();
    }
}
运行结果：


3.使用多个Condition实现通知部分线程

示例代码：

public class MyService {
    private Lock     lock       = new ReentrantLock();
    public Condition conditionA = lock.newCondition();
    public Condition conditionB = lock.newCondition();

    public void awaitA() {
        try {
            lock.lock();
            System.out.println("begin awaitA 时间为" + System.currentTimeMillis() + " ThreadName=" + Thread.currentThread().getName());
            conditionA.await();
            System.out.println(" end awaitA 时间为" + System.currentTimeMillis() + " ThreadName=" + Thread.currentThread().getName());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void awaitB() {
        try {
            lock.lock();
            System.out.println("begin awaitB 时间为" + System.currentTimeMillis() + " ThreadName=" + Thread.currentThread().getName());
            conditionB.await();
            System.out.println(" end awaitB 时间为" + System.currentTimeMillis() + " ThreadName=" + Thread.currentThread().getName());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void singalAll_A() {
        try {
            lock.lock();
            System.out.println(" signalAll_A 时间为" + System.currentTimeMillis() + " ThreadName=" + Thread.currentThread().getName());
            conditionA.signalAll();
        } finally {
            lock.unlock();
        }
    }

    public void singalAll_B() {
        try {
            lock.lock();
            System.out.println(" signalAll_B 时间为" + System.currentTimeMillis() + " ThreadName=" + Thread.currentThread().getName());
            conditionB.signalAll();
        } finally {
            lock.unlock();
        }
    }
}

class ThreadA extends Thread {
    private MyService service;

    public ThreadA(MyService service) {
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.awaitA();
    }
}

class ThreadB extends Thread {
    private MyService service;

    public ThreadB(MyService service) {
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.awaitB();
    }
}

class Run {
    public static void main(String[] args) throws Exception {
        MyService service = new MyService();
        ThreadA a = new ThreadA(service);
        a.setName("A");
        a.start();
        ThreadB b = new ThreadB(service);
        b.setName("B");
        b.start();
        Thread.sleep(3000);
        service.singalAll_A();
    }
}

运行结果：

 

4.方法getHoldCount()、getQueueLength()和getWaitQueueLength()测试

     --方法getHoldCount()的作用是查询当前线程保持锁定的个数，也就是调用lock方法的次数

示例代码：

public class Service {
    private ReentrantLock lock = new ReentrantLock();

    public void serviceMethod1() {
        try {
            lock.lock();
            System.out.println("serviceMethod1 getHoldCount=" + lock.getHoldCount());
            serviceMethod2();
        } finally {
            lock.unlock();
        }
    }

    public void serviceMethod2() {
        try {
            lock.lock();
            System.out.println("serviceMethod2 getHoldCount=" + lock.getHoldCount());
        } finally {
            lock.unlock();
        }
    }
}

class Run {
    public static void main(String args[]) {
        Service service = new Service();
        service.serviceMethod1();
    }
}
运行结果：


   

  --方法getQueueLenght()的作用是返回等待次锁定的线程估计数，比如有5个线程，1个线程首先执行await()方法，那么调用返回值是4

示例代码：

public class Service {
    public ReentrantLock lock = new ReentrantLock();

    public void serviceMethod1() {
        try {
            lock.lock();
            System.out.println("Threadname=" + Thread.currentThread().getName() + "进入方法! ");
            Thread.sleep(Integer.MAX_VALUE);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

class Run {
    public static void main(String[] args) throws Exception {
        final Service service = new Service();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                service.serviceMethod1();
            }
        };
        Thread[] threadArray = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threadArray[i] = new Thread(runnable);
        }
        for (int i = 0; i < 10; i++) {
            threadArray[i].start();
        }
        Thread.sleep(2000);
        System.out.println("有线程数:" + service.lock.getQueueLength() + "在等待获取锁!");
    }
}
运行结果：


   --方法getWaitQueueLength(Condition condition)的作用是返回等待与此所动相关的给定条件Condition的线程估计数

示例代码：

public class Service {
    private ReentrantLock lock        = new ReentrantLock();
    private Condition     newCondtion = lock.newCondition();

    public void waitMethod() {
        try {
            lock.lock();
            newCondtion.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void notifyMethod() {
        try {
            lock.lock();
            System.out.println("有" + lock.getWaitQueueLength(newCondtion) + "个线程正在等待newCondition");
            newCondtion.signal();
        } finally {
            lock.unlock();
        }
    }
}

class Run {
    public static void main(String[] args) throws Exception {
        final Service service = new Service();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                service.waitMethod();
            }
        };
        Thread[] threadArray = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threadArray[i] = new Thread(runnable);
        }
        for (int i = 0; i < 10; i++) {
            threadArray[i].start();
        }
        Thread.sleep(2000);
        service.notifyMethod();
    }
}

运行结果：


5.方法hasQueuedThread()、hasQueuedThreads()和hasWaiters()的测试

     --boolean hasQueuedThread(Thread thread) 的作用是查询指定的线程是否正在等待获取此锁定。

示例代码：

public class Service {
    public ReentrantLock lock        = new ReentrantLock();
    public Condition     newConditon = lock.newCondition();

    public void waitMethod() {
        try {
            lock.lock();
            Thread.sleep(Integer.MAX_VALUE);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

class Run {
    public static void main(String[] args) throws Exception {
        final Service service = new Service();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                service.waitMethod();
            }
        };
        Thread threadA = new Thread(runnable);
        threadA.start();
        Thread.sleep(500);
        Thread threadB = new Thread(runnable);
        threadB.start();
        Thread.sleep(500);
        System.out.println(service.lock.hasQueuedThread(threadA));
        System.out.println(service.lock.hasQueuedThread(threadB));
        System.out.println(service.lock.hasQueuedThreads());
    }
}
运行结果：


     --boolean hasWaiters(Condition condition)的作用是查询是否有线程正在等待与此锁定有关的condition条件。

示例代码：

public class Service {
    private ReentrantLock lock         = new ReentrantLock();
    private Condition     newCondition = lock.newCondition();

    public void waitMethod() {
        try {
            lock.lock();
            newCondition.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void notityMethod() {
        try {
            lock.lock();
            System.out.println("有没有线程正在等待newCondition? " + lock.hasWaiters(newCondition) + " 线程数是多少? " + lock.getWaitQueueLength(newCondition));
            newCondition.signal();
        } finally {
            lock.unlock();
        }
    }
}

class Run {
    public static void main(String[] args) throws Exception {
        final Service service = new Service();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                service.waitMethod();
            }
        };
        Thread[] threadArray = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threadArray[i] = new Thread(runnable);
        }
        for (int i = 0; i < 10; i++) {
            threadArray[i].start();
        }
        Thread.sleep(2000);
        service.notityMethod();
    }
}

运行结果：


其他：

    --方法boolean isFair() 的作用是判断是不是公平锁。

    --方法boolean isHeldByCurrentThread()的作用是查询当前线程是否保持锁定。

    --方法boolean isLocked() 的作用是查询此锁定是否由任意线程保持。

    --方法void lockInterruptibly()作用是：如果当前线程未被中断，则获取锁定，如果已经被中断则出现异常。

    --方法boolean tryLock()的作用是，仅在调用时锁定未被另一个线程保持的情况下，才获取该锁。

    --方法boolean tryLock(long timeout,TimeUnit unit)的作用是，如果锁定在给定等待时间内没有被另一个线程保持，且当前线程未被中断，则获取该锁

    


参考：《Java多线程编程核心技术》--机械工业出版社 高洪岩 著


  


93_Ryan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程系列九-lock
a314773862的博客
12-27 199
Lock 是java.util.concurrent.locks包下常用类。Lock只是一个接口 public interface Lock { void lock(); void lockInterruptibly() throws InterruptedException; boolean tryLock(); boolean tryLock(long time,
Java多线程问题--方法getHoldCount()、getQueueLength()和getWaitQueueLength()的用法和区别
樊先知樊先知的博客
01-17 1198
本文内容部分引自《Java多线程编程核心技术》，感谢作者！！！ 代码地址：https://github.com/xianzhixianzhixian/thread.git 方法getHoldCount()、getQueueLength()和getWaitQueueLength()用法和区别 1、lock.getHoldCount()作用是查询当前线程保持锁定的个数，也就是调用lock()...
ReentrantLock中一些方法介绍使用
weixin_43960044的博客
11-05 401
Lock中一些方法介绍使用 一、.getHoldCount(); .getQueueLength();.getWaitQueueLength(condition); lock.getHoldCount(); 返回当前保持此锁的线程个数，即调用lock() 方法的次数 lock.getQueueLength(); 返回正在等待获取此锁的线程个数，例如：有5个线程使用此锁，其中一个线程调用了await() 其他线程都在等待，则该方法返回4. lock.getWaitQueueLength(condition)
代码基本零侵入实现各种中间件分布式锁
yx_yancy1992的博客
01-25 316
各种中间件分布式锁的实现以及业务代码零侵入，开箱即用，方法自调用，各种拓展等。
java8看不到源码-dlock:一种有效可靠的分布式锁
06-04
java8 看不到源码DLock - 分布式锁 DLock 是 Java 实现的、有效且可靠的分布式锁。 它使用Redis存储锁对象，通过[Lua](脚本)对锁进行原子操作。基于Redis的过期机制，DLock实现了锁[租借](以保证释放。为了提供高性能，DLock采用进程级锁模型并使用变体 CLH 队列来管理锁竞争者。 要求：+、 +（需要Redis Set -> NX PX命令） 建筑学 特征 原子锁操作 一个锁操作对应一个 Lua 脚本。 由于 Redis 可以原子地执行 Lua 脚本，因此锁定、释放和扩展租用等锁定操作将是原子的。 重入能力 变量holdCount由本地DLock 对象维护。 重新进入locker时holdCount加1，离开locker时减1。 锁租 在Redis的过期机制的基础上，集成锁租约，在锁柜崩溃后释放锁。 也就是说，永远不会发生无限锁定。 高性能锁模型 使用无锁变体 CLH 队列来维护竞争线程。 并且重试线程会周期性的唤醒CLH队列的头线程进行重试，这样每个进程只有一个线程可以参与锁竞争，避免了不必要的锁竞争。 同时，还为吞吐量提供了不公平锁。 快速
Java多线程基础——Lock类
08-31
Java多线程基础中的Lock类提供了比`synchronized`更强大的同步控制能力。Lock是一个接口，它定义了比`synchronized`更灵活的锁定机制，允许更细粒度的控制。在Java 1.5及之后的版本中引入，Lock类的主要目的是提高...
Java练手小项目——多线程聊天室.zip
最新发布
01-14
【Java练手小项目——多线程...通过这个“Java练手小项目——多线程聊天室”，你可以深入了解Java多线程的原理和实践，同时学习到网络编程和并发集合的运用，这对于提升你的Java编程技能和解决实际问题的能力大有裨益。
Java多线程死锁示例
08-27
首先，我们来看标题中的关键点——“Java多线程死锁示例”。死锁是多线程编程中的一种异常状态，通常发生在两个或多个线程之间，每个线程都在等待另一个线程释放它需要的资源，从而形成一个无解的循环等待。在这种...
javaduoxiancheng.rar_多线程 java
09-24
"javaduoxiancheng.rar_多线程 java"这个压缩包文件可能包含了关于Java多线程编程的相关资料和示例代码，帮助开发者深入理解和实践Java的多线程同步机制。 首先，我们需要了解Java中线程的创建方式。Java提供了两种...
java多线程案例——未完成
08-21
Java多线程是Java编程中的一个重要领域，它允许程序同时执行多个任务，从而提高系统效率和资源利用率。在这个未完成的案例中，我们可能正在探讨如何在Java中创建和管理线程，以及处理多线程环境下的并发问题。下面是...
Lock作用及其使用
梵高
08-25 432
而非公平锁就是一种随机的分配，不关乎先后顺序，非公平锁会随机分配一个处于就绪状态的线程来获取锁并执行相应的逻辑。这种锁既然叫读写锁，表示也是两个锁，一个是读操作相关的，是共享锁；公平锁和非公平锁各有优劣，公平锁需要维护一个队列，需要知道各个线程进入就绪状态的顺序，而非公平锁则不需要，只需要每次随机分配一个已经处于就绪状态的线程即可。那么实际上，JDK同样考虑到这一点，提供了一种读写锁ReentrantReadWriteLock的支持，它可以限定读锁和写锁，在不同的锁下有不同的互斥效果。
JAVA多线程-Lock的使用（三）-Lock与Condiition相关的方法
绝版灬小伙的博客
02-21 839
Lock与Condiition相关的方法     1、int lock.getHoldCount()：查询当前线程保持锁定的个数，也就是调用lock()方法的次数     2、int lock.getQueueLength()：返回正在等待获取此锁定的线程估计数。           比如：有5个线程，有一个首先执行await()方法，那么调用该方法后返回值为4，说明有4个线程同时在等待lo
重入锁ReentrantLock常用方法（一）
Morgan_Xiang的专栏
06-04 1534
        重入锁ReentrantLock常用方法        1. int getHoldCount()             Queries the number of holds on this lock by the current thread.            查询当前线程保持此锁定的个数，即调用lock()方法的次数。public class ReentrantLoc...
java多线程之Lock类的使用
sunpy
09-26 6167
1.ReentrantLock类的使用    1.1ReentrantLock实现线程间同步 public class MyService { private Lock lock=new ReentrantLock(); public void service(){ lock.lock(); for(int i=0;i<5;i++){ System.out.println
使用 @Lock 注解实现Spring JAP锁
热门推荐
Terry_Long的博客
01-09 1万+
JPA 2.0增加了6种新的锁模式，其中两个是乐观锁。JPA 2.0也允许悲观锁，并增加了3种悲观锁，第6种锁模式是无锁。  下面是新增的两个乐观锁模式：  1、OPTIMISTIC：它和READ锁模式相同，JPA 2.0仍然支持READ锁模式，但明确指出在新应用程序中推荐使用OPTIMISTIC。  2、OPTIMISTIC_FORCE_INCREMENT：它和WRITE锁模式
浅谈Java(SpringBoot)基于zookeeper的分布式锁实现
weixin_44782075的博客
05-08 554
通过zookeeper实现分布式锁 1、创建zookeeper的client 首先通过CuratorFrameworkFactory创建一个连接zookeeper的连接CuratorFramework client public class CuratorFactoryBean implements FactoryBean<CuratorFramework>, Initializing...
Lock中的一些方法及其作用
泽宇的博客
07-04 1341
1：getHoldCount() 查询当前线程保持锁定的个数，也就是调用lock()方法的次数。2：getQueueLength() 返回正等待获取锁定的线程估计数。比如有5个线程，1个线程首先执行await()方法，那么在调用方法后返回值是4，说明有4个线程同时在等待lock的释放。3：getWaitQueueLength(Condition con) 返回等待与此锁定相关的给定条件Condit...
关于Semaphore的getQueueLength（）和hasQueuedThreads（）作用
qq_30908729的博客
08-02 1291
Semaphore的getQueueLength（）和hasQueuedThreads（）作用 答： 方法getQueueLength（）的作用:http://www.yayihouse.com/yayishuwu/chapter/1394
java dubbo 分布式锁_浅谈Java(SpringBoot)基于zookeeper的分布式锁实现
weixin_28786193的博客
02-28 212
通过zookeeper实现分布式锁1、创建zookeeper的client首先通过CuratorFrameworkFactory创建一个连接zookeeper的连接CuratorFramework clientpublic class CuratorFactoryBean implements FactoryBean, InitializingBean, DisposableBean {priva...
Java多线程基础：创建与概念模型详解
文档没有详细讲述线程状态控制、临界资源、对象锁和死锁，以及互斥和同步的概念，但这些都是Java多线程编程的重要部分。例如，线程状态控制涉及线程的生命周期（新建、就绪、运行、阻塞和死亡），而临界资源和锁则...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值