ReentrantLock你了解多少？

最新推荐文章于 2023-11-20 16:54:36 发布
最新推荐文章于 2023-11-20 16:54:36 发布
阅读量1w 收藏 2
点赞数 4
分类专栏： Java基础 文章标签： java 多线程 并发编程 多进程 Java 编程 语言 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WODESHENNI/article/details/106405803
版权

文章目录

内容简介

ReentrantLock类的使用。
ReentrantReadWriteLock类的使用。

4.1 使用ReentrantLock类

在多线程中，可以使用synchronized来实现线程之间的同步互斥，在JDK1.5中新增了ReentrantLock类也可打到同样的效果，并在拓展功能上更强大，比如：嗅探锁定、多路分支通知等，使用上比synchronized更加灵活，下面我们在学习中来任务两者的异同吧！

4.1.1 使用ReentrantLock实现同步

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

lock()获取锁，unlock()释放锁。

public class MyThread extends Thread {
    private MyService myService;
    public MyThread(MyService myService) {
        this.myService = myService;
    }
    @Override
    public void run() {
        myService.testMethod();
    }
}

public class Run {
    public static void main(String[] args) {
        MyService myService = new MyService();
        MyThread m1 = new MyThread(myService);
        MyThread m2 = new MyThread(myService);
        MyThread m3 = new MyThread(myService);
        MyThread m4 = new MyThread(myService);
        MyThread m5 = new MyThread(myService);
        m1.start();
        m2.start();
        m3.start();
        m4.start();
        m5.start();
    }
}

ThreadNameThread-1 0
ThreadNameThread-1 1
ThreadNameThread-0 0
ThreadNameThread-0 1
ThreadNameThread-3 0
ThreadNameThread-3 1
ThreadNameThread-4 0
ThreadNameThread-4 1
ThreadNameThread-2 0
ThreadNameThread-2 1

从打印结果来看，当一个线程调用unlock()方法释放锁后，其他线程抢到锁继续执行，下面我们继续做个试验：

public class MyService {
    private Lock lock = new ReentrantLock();
    public void methodA() {
        try {
            lock.lock();
            System.out.println("methodA begin threadNAME=" + Thread.currentThread().getName() + " Time=" + System.currentTimeMillis());
            Thread.sleep(2000);
            System.out.println("methodA   end threadNAME=" + Thread.currentThread().getName() + " Time=" + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void methodB() {
        try {
            lock.lock();
            System.out.println("methodB begin threadNAME=" + Thread.currentThread().getName() + " Time=" + System.currentTimeMillis());
            Thread.sleep(2000);
            System.out.println("methodB   end threadNAME=" + Thread.currentThread().getName() + " Time=" + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

public class ThreadA extends Thread {
    private MyService myService;
    public ThreadA(MyService myService) {
        this.myService = myService;
    }
    @Override
    public void run() {
        myService.methodA();
    }
}

public class ThreadAA extends Thread {
    private MyService myService;
    public ThreadAA(MyService myService) {
        this.myService = myService;
    }
    @Override
    public void run() {
        myService.methodA();
    }
}

public class ThreadB extends Thread {
    private MyService myService;
    public ThreadB(MyService myService) {
        this.myService = myService;
    }
    @Override
    public void run() {
        myService.methodB();
    }
}

public class ThreadBB extends Thread {
    private MyService myService;
    public ThreadBB(MyService myService) {
        this.myService = myService;
    }
    @Override
    public void run() {
        myService.methodB();
    }
}

public class Run {
    public static void main(String[] args) throws InterruptedException {
        MyService myService = new MyService();
        ThreadA a = new ThreadA(myService);
        a.setName("a");
        a.start();
        ThreadAA aa = new ThreadAA(myService);
        aa.setName("aa");
        aa.start();
        Thread.sleep(100);
        ThreadB b = new ThreadB(myService);
        b.setName("b");
        b.start();
        ThreadBB bb = new ThreadBB(myService);
        bb.setName("bb");
        bb.start();
    }
}

methodA begin threadNAME=a Time=1590990695499
methodA   end threadNAME=a Time=1590990697502
methodA begin threadNAME=aa Time=1590990697502
methodA   end threadNAME=aa Time=1590990699506
methodB begin threadNAME=bb Time=1590990699506
methodB   end threadNAME=bb Time=1590990701507
methodB begin threadNAME=b Time=1590990701507
methodB   end threadNAME=b Time=1590990703509

验证结果：调用lock()代码的线程就持有了对象监视器，其他线程只有等待持有锁的线程释放。

4.1.2 使用Condition实现等待/通知

synchronized与wait()，notify()或notifyAll()方法相结合，可以实现等待/通知模式。（对wait()，notify()或notifyAll()需要了解的可以看看一文详解wait与notify）
ReentrantLock也可以实现同样的功能，但需要借助与Condition对象。Condition是JDK5中出现的，它有更好的灵活性，比如实现多路通知功能，也就是在一个Lock对象里面可以创建多个Condition（即对象监视器）实例，线程对象可以注册在指定的Condition中，从而有选择的进行通知，在调度线程上更加灵活。
使用nodify()/notifyAll()方法进行通知时，被通知的线程是JVM随机选择的。ReentrantLock结合Condition类是可以实现选择性通知。
synchronize就相当于整个Lock对象中只有一个单一的Condition对象，所有线程都注册在它一个对象的身上，notifyAll()时，需要通知所有的等待该对象的线程，JVM随机唤醒其中一个。

Object与Condition对比
调用Condition.await方法前，如果没有持有合适的锁，则会报java.lang.IllegalMonitorStateException的异常，我们可以通过ReentrantLock.lock()来获取锁。

下面我们使用Condition来实现一个等待通知模式：

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

    public void await() {
        try {
            lock.lock();
            System.out.println("await start 时间为：" + System.currentTimeMillis());
            condition.await();
            System.out.println("await end   时间为：" + System.currentTimeMillis());
        } 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();
        }
    }
}

public class MyThread extends Thread {
    private MyService myService;
    public MyThread(MyService myService) {
        this.myService = myService;
    }
    @Override
    public void run() {
        myService.await();
    }
}

public class Run {
    public static void main(String[] args) throws InterruptedException {
        MyService myService = new MyService();
        MyThread myThread = new MyThread(myService);
        myThread.start();
        Thread.sleep(3000);
        myService.signal();
    }
}

await start 时间为：1590995422964
signal时间为：1590995425971
await end   时间为：1590995425971

1）Object中的wait()方法相当于Condition类中的await()。
2）Object中的wait(long timeout)相当于Condition中的await(long time,TimeUnit unit)。
3）Object中的notify()相当于Condition中的signal()。
4）Object中的notifyAll()相当于Condition中的signalAll()。

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

如何使用单个Condition来通知所有线程呢？

public class MyService {
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    public void awaitA() {
        try {
            lock.lock();
            System.out.println("begin awaitA time = " + System.currentTimeMillis() + " thread Name = " + Thread.currentThread().getName());
            condition.await();
            System.out.println("  end awaitA time = " + System.currentTimeMillis() + " thread Name = " + Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void awaitB() {
        try {
            lock.lock();
            System.out.println("begin awaitB time = " + System.currentTimeMillis() + " thread Name = " + Thread.currentThread().getName());
            condition.await();
            System.out.println("  end awaitB time = " + System.currentTimeMillis() + " thread Name = " + Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void signalAll() {
        try {
            lock.lock();
            System.out.println("   signalAll time = " + System.currentTimeMillis() + " thread Name = " + Thread.currentThread().getName());
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }
}

public class ThreadA extends Thread {
    private MyService myService;
    public ThreadA(MyService myService) {
        this.myService = myService;
    }
    @Override
    public void run() {
        myService.awaitA();
    }
}

public class ThreadB extends Thread {
    private MyService myService;
    public ThreadB(MyService myService) {
        this.myService = myService;
    }
    @Override
    public void run() {
        myService.awaitB();
    }
}


public class Run {
    public static void main(String[] args) throws InterruptedException {
        MyService myService = new MyService();
        ThreadA a = new ThreadA(myService);
        a.setName("a");
        a.start();
        ThreadB b = new ThreadB(myService);
        b.setName("b");
        b.start();
        Thread.sleep(2000);
        myService.signalAll();
    }
}

begin awaitB time = 1590998606632 thread Name = b
begin awaitA time = 1590998606632 thread Name = a
   signalAll time = 1590998608626 thread Name = main
  end awaitB time = 1590998608626 thread Name = b
  end awaitA time = 1590998608626 thread Name = a

那么如何使用多个Condition通知部分线程呢？

public class MyService {
    private Lock lock = new ReentrantLock();
    private Condition conditionA = lock.newCondition();
    private Condition conditionB = lock.newCondition();
    public void awaitA() {
        try {
            lock.lock();
            System.out.println("begin awaitA time = " + System.currentTimeMillis() + " thread Name = " + Thread.currentThread().getName());
            conditionA.await();
            System.out.println("  end awaitA time = " + System.currentTimeMillis() + " thread Name = " + Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void awaitB() {
        try {
            lock.lock();
            System.out.println("begin awaitB time = " + System.currentTimeMillis() + " thread Name = " + Thread.currentThread().getName());
            conditionB.await();
            System.out.println("  end awaitB time = " + System.currentTimeMillis() + " thread Name = " + Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void signalAllA() {
        try {
            lock.lock();
            System.out.println("  signalAllA time = " + System.currentTimeMillis() + " thread Name = " + Thread.currentThread().getName());
            conditionA.signalAll();
        } finally {
            lock.unlock();
        }
    }
    public void signalAllB() {
        try {
            lock.lock();
            System.out.println("  signalAllB time = " + System.currentTimeMillis() + " thread Name = " + Thread.currentThread().getName());
            conditionA.signalAll();
        } finally {
            lock.unlock();
        }
    }
}

public class ThreadA extends Thread {
    private MyService myService;
    public ThreadA(MyService myService) {
        this.myService = myService;
    }
    @Override
    public void run() {
        myService.awaitA();
    }
}

public class ThreadB extends Thread {
    private MyService myService;
    public ThreadB(MyService myService) {
        this.myService = myService;
    }
    @Override
    public void run() {
        myService.awaitB();
    }
}


public class Run {
    public static void main(String[] args) throws InterruptedException {
        MyService myService = new MyService();
        ThreadA a = new ThreadA(myService);
        a.setName("a");
        a.start();
        ThreadB b = new ThreadB(myService);
        b.setName("b");
        b.start();
        Thread.sleep(1000);
        myService.signalAllA();
        Thread.sleep(1000);
        myService.signalAllB();
    }
}

begin awaitB time = 1590999063461 thread Name = b
begin awaitA time = 1590999063485 thread Name = a
  signalAllA time = 1590999064453 thread Name = main
  end awaitA time = 1590999064453 thread Name = a
  signalAllB time = 1590999065453 thread Name = main

4.1.4 使用Condition实现生产者/消费者模式

单生产者与单消费者代码示例：

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

    public void set() {
        try {
            lock.lock();
            while (hasValue == true) {
                condition.await();
            }
            System.out.println("打印★");
            hasValue = true;
            condition.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void get() {
        try {
            lock.lock();
            while (hasValue == false) {
                condition.await();
            }
            System.out.println("打印☆");
            hasValue = false;
            condition.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

public class ThreadA extends Thread {
    private MyService myService;
    public ThreadA(MyService myService) {
        this.myService = myService;
    }
    @Override
    public void run() {
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            myService.set();
        }
    }
}

public class ThreadB extends Thread {
    private MyService myService;
    public ThreadB(MyService myService) {
        this.myService = myService;
    }
    @Override
    public void run() {
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            myService.get();
        }
    }
}

public class Run {
    public static void main(String[] args) {
        MyService myService = new MyService();
        ThreadA a = new ThreadA(myService);
        a.start();
        ThreadB b = new ThreadB(myService);
        b.start();
    }
}

···
打印☆
打印★
打印☆
打印★
打印☆
打印★
···

那么多生产与多消费怎么控制呢 ？

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

    public void set() {
        try {
            lock.lock();
            while (hasValue == true) {
                System.out.println("有可能★★连续");
                condition.await();
            }
            System.out.println("打印★");
            hasValue = true;
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void get() {
        try {
            lock.lock();
            while (hasValue == false) {
                System.out.println("有可能☆☆连续");
                condition.await();
            }
            System.out.println("打印☆");
            hasValue = false;
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

public class ThreadA extends Thread {
    private MyService myService;
    public ThreadA(MyService myService) {
        this.myService = myService;
    }
    @Override
    public void run() {
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            myService.set();
        }
    }
}

public class ThreadB extends Thread {
    private MyService myService;
    public ThreadB(MyService myService) {
        this.myService = myService;
    }
    @Override
    public void run() {
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            myService.get();
        }
    }
}

public class Run {
    public static void main(String[] args) {
        MyService myService = new MyService();
        ThreadA[] a = new ThreadA[10];
        ThreadB[] b = new ThreadB[10];
        for (int i = 0; i < 10; i++) {
            a[i] = new ThreadA(myService);
            b[i] = new ThreadB(myService);
            a[i].start();
            b[i].start();
        }
    }
}

...
打印★
有可能★★连续
打印☆
打印★
有可能★★连续
有可能★★连续
有可能★★连续
有可能★★连续
有可能★★连续
有可能★★连续
打印☆
有可能☆☆连续
...

4.1.9 公平锁与非公平锁

Lock分为公平锁和非公平锁。
公平锁：线程获取锁的顺序是按照线程加锁的顺序来分配的，即FIFO（先进先出）。
非公平锁：随机获得锁。

那么下面我们就用代码来了解两种锁的特性吧。
非公平锁示例：

public class Service {
    private ReentrantLock lock;

    public Service(boolean isFair) {
        this.lock = new ReentrantLock(isFair);
    }
    public void serviceMethod(){
        try {
            lock.lock();
            System.out.println("ThreadName="+Thread.currentThread().getName()+"获取锁");
        }finally {
            lock.unlock();
        }
    }
}

public class Run {
    public static void main(String[] args) {
        final Service service = new Service(false);
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("★线程" + Thread.currentThread().getName() + "开始执行");
                service.serviceMethod();
            }
        };
        Thread[] threads = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threads[i] = new Thread(runnable);
        }
        for (int i = 0; i < threads.length; i++) {
            threads[i].start();
        }
    }
}

★线程Thread-0开始执行
ThreadName=Thread-0获取锁
★线程Thread-2开始执行
★线程Thread-1开始执行
ThreadName=Thread-2获取锁
★线程Thread-4开始执行
ThreadName=Thread-4获取锁
★线程Thread-5开始执行
★线程Thread-8开始执行
ThreadName=Thread-5获取锁
★线程Thread-9开始执行
ThreadName=Thread-9获取锁
★线程Thread-3开始执行
ThreadName=Thread-3获取锁
ThreadName=Thread-1获取锁
ThreadName=Thread-8获取锁
★线程Thread-7开始执行
ThreadName=Thread-7获取锁
★线程Thread-6开始执行
ThreadName=Thread-6获取锁

非公平锁的运行结果基本上是乱序的，先启动的线程不代表先获得锁。

公平锁示例：
修改Run.java代码如下

public class Run {
    public static void main(String[] args) {
        final Service service = new Service(true);
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("★线程" + Thread.currentThread().getName() + "开始执行");
                service.serviceMethod();
            }
        };
        Thread[] threads = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threads[i] = new Thread(runnable);
        }
        for (int i = 0; i < threads.length; i++) {
            threads[i].start();
        }
    }
}

★线程Thread-1开始执行
★线程Thread-2开始执行
ThreadName=Thread-1获取锁
★线程Thread-5开始执行
★线程Thread-6开始执行
ThreadName=Thread-2获取锁
ThreadName=Thread-5获取锁
★线程Thread-0开始执行
★线程Thread-4开始执行
ThreadName=Thread-6获取锁
★线程Thread-8开始执行
ThreadName=Thread-0获取锁
★线程Thread-9开始执行
ThreadName=Thread-4获取锁
ThreadName=Thread-8获取锁
ThreadName=Thread-9获取锁
★线程Thread-3开始执行
ThreadName=Thread-3获取锁
★线程Thread-7开始执行
ThreadName=Thread-7获取锁

观察执行结果可以发现，启动的顺序与获得锁的顺序一致。

4.1.10 ReentrantLock中方法的使用

4.1.10.1 getHoldCount()

getHoldCount()查询当前线程保持锁定的个数，也就是获取当前线程调用lock()的次数。
示例代码：

public class Service {
    private ReentrantLock lock = new ReentrantLock();
    private void serviceMethod1() {
        try {
            lock.lock();
            System.out.println("serviceMethod1 getHoldCount=" + lock.getHoldCount());
            serviceMethod2();
        } finally {
            lock.unlock();
        }
    }
    private void serviceMethod2() {
        try {
            lock.lock();
            System.out.println("serviceMethod2 getHoldCount=" + lock.getHoldCount());
        } finally {
            lock.unlock();
        }
    }
    public static void main(String[] args) {
        Service service = new Service();
        service.serviceMethod1();
    }
}

serviceMethod1 getHoldCount=1
serviceMethod2 getHoldCount=2
4.1.10.2 getQueueLength()

getQueueLength()返回正等待获取此锁定的线程估计数。
代码示例：

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

    public void serviceMethod1() {
        try {
            lock.lock();
            System.out.println("ThreadName=" + Thread.currentThread().getName());
            Thread.sleep(10000);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        final Service service = new Service();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                service.serviceMethod1();
            }
        };
        Thread[] threads = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threads[i] = new Thread(runnable);
        }
        for (int i = 0; i < 10; i++) {
            threads[i].start();
        }
        Thread.sleep(2000);
        System.out.println("有" + service.lock.getQueueLength() + "个线程在等待获取锁！");
    }
}

ThreadName=Thread-0
有9个线程在等待获取锁！
···
4.1.10.3 getWaitQueueLength(Condition condition)

getWaitQueueLength(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 (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

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

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

有10个线程正在等待newCondition
4.1.10.4 hasQueuedThreads()、hasQueuedThread()

boolean hasQueuedThread(Thread thread)查询指定线程是否正在等待获取此锁定。
boolean hasQueuedThreads()查询是否有线程正在等待获取此锁定。
代码示例：

public class Service {
    private ReentrantLock lock = new ReentrantLock();
    public void waitMethod() {
        try {
            lock.lock();
            System.out.println("threadName="+ Thread.currentThread().getName());
            Thread.sleep(5000);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        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());
    }
}

threadName=Thread-0
false
true
true
threadName=Thread-1
4.1.10.5 hasWaiters()

查询是否有线程正在等候与此锁定有关的condition条件。
代码示例：

public class Service {
    private ReentrantLock lock = new ReentrantLock();
    private Condition newCondition = lock.newCondition();
    public void waitMethod() {
        try {
            lock.lock();
            newCondition.await();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void notifyMethod() {
        try {
            lock.lock();
            if (lock.hasWaiters(newCondition)) {
                System.out.println("存在正在等待newCondition的线程，线程数：" + lock.getWaitQueueLength(newCondition));
                newCondition.signalAll();
            }
        } finally {
            lock.unlock();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        final Service service = new Service();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                service.waitMethod();
            }
        };
        Thread[] threads = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threads[i] = new Thread(runnable);
        }
        for (int i = 0; i < 10; i++) {
            threads[i].start();
        }
        Thread.sleep(2000);
        service.notifyMethod();
    }
}

存在正在等待newCondition的线程，线程数：10
4.1.10.6 isFair()

判断是否是公平锁。

    /**
     * Creates an instance of {@code ReentrantLock} with the
     * given fairness policy.
     *
     * @param fair {@code true} if this lock should use a fair ordering policy
     */
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

    /**
     * Returns {@code true} if this lock has fairness set true.
     *
     * @return {@code true} if this lock has fairness set true
     */
    public final boolean isFair() {
        return sync instanceof FairSync;
    }
4.1.10.6 isHeldByCurrentThread()

查询当前线程是否持有该锁。

public class Service {
    private ReentrantLock lock ;

    public Service(boolean isFair) {
        lock = new ReentrantLock(isFair);
    }
    public void serviceMethod(){
        try {
            System.out.println(lock.isHeldByCurrentThread());
            lock.lock();
            System.out.println(lock.isHeldByCurrentThread());
        }finally {
            lock.unlock();
        }
    }
    public static void main(String[] args) {
        final Service service = new Service(true);
        new Runnable() {
            @Override
            public void run() {
                service.serviceMethod();
            }
        }.run();
    }
}

false
true
4.1.10.7 isLocked()

查询锁定是否由任意线程持有。

public class Service {
    private ReentrantLock lock ;

    public Service(boolean isFair) {
        lock = new ReentrantLock(isFair);
    }
    public void serviceMethod(){
        try {
            System.out.println(lock.isLocked());
            lock.lock();
            System.out.println(lock.isLocked());
        }finally {
            lock.unlock();
        }
    }
    public static void main(String[] args) {
        final Service service = new Service(true);
        new Runnable() {
            @Override
            public void run() {
                service.serviceMethod();
            }
        }.run();
    }
}

false
true
4.1.10.7 lockInterruptibly()

如果当前线程未被中断，则获取锁定，如果已经被中断则出现异常。

public class Service {
    private ReentrantLock lock = new ReentrantLock();
    public void serviceMethod() {
        try {
            lock.lockInterruptibly();
            System.out.println("lock begin " + Thread.currentThread().getName());
            for (int i = 0; i < Integer.MAX_VALUE / 10; i++) {
            }
            System.out.println("lock   end " + Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        final Service service = new Service();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                service.serviceMethod();
            }
        };
        new Thread(runnable).start();
        Thread.sleep(500);
        Thread threadB = new Thread(runnable);
        threadB.start();
        threadB.interrupt();
    }
}

lock begin Thread-0
lock   end Thread-0
java.lang.InterruptedException
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:1220)
	at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:335)
4.1.10.7 tryLock()

调用时锁定未被另一个线程持有的情况下，才获取该锁定。

public class Service {
    private ReentrantLock lock = new ReentrantLock();
    public void getLock() {
        if (lock.tryLock()) {
            System.out.println(Thread.currentThread().getName() + " 获得锁");
        } else {
            System.out.println(Thread.currentThread().getName() + " 未获得锁");
        }
    }
    public static void main(String[] args) {
        final Service service  = new Service();
        Runnable runnable = new Runnable(){
            @Override
            public void run() {
                service.getLock();
            }
        };
        Thread threadA = new Thread(runnable);
        threadA.start();
        Thread threadB = new Thread(runnable);
        threadB.start();
    }
}

Thread-0 获得锁
Thread-1 未获得锁
4.1.10.7 tryLock(long timeout, TimeUnit unit)

如果锁定在给定等待时间内没有被另一个线程持有，且当前线程未被终端，则获取该锁定。

public class Service {
    private ReentrantLock lock = new ReentrantLock();
    public void getLock() {
        try {
            if (lock.tryLock(3, TimeUnit.SECONDS)) {
                System.out.println(Thread.currentThread().getName() + " 获得锁的时间：" + System.currentTimeMillis());
                Thread.sleep(4000);
            } else {
                System.out.println(Thread.currentThread().getName() + " 未获得锁时间：" + System.currentTimeMillis());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
    public static void main(String[] args) {
        final Service service = new Service();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "调用时间：" + System.currentTimeMillis());
                service.getLock();
            }
        };
        Thread threadA = new Thread(runnable);
        threadA.start();
        Thread threadB = new Thread(runnable);
        threadB.start();
    }
}

Thread-0调用时间：1593673259015
Thread-0 获得锁的时间：1593673259016
Thread-1调用时间：1593673259015
Thread-1 未获得锁时间：1593673262017
4.1.10.7 awaitUninterruptibly()
public class Service {
    private ReentrantLock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    public void testMethod() {
        try {
            lock.lock();
            System.out.println("wait begin");
            condition.await();
            System.out.println("wait end");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        final Service service = new Service();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                service.testMethod();
            }
        };
        Thread thread = new Thread(runnable);
        thread.start();
        Thread.sleep(1000);
        thread.interrupt();
    }
}

wait begin
java.lang.InterruptedException
	at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.reportInterruptAfterWait(AbstractQueuedSynchronizer.java:2014)
	at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2048)

在sleep状态下，停止某一线程，会进入catch语句，并清除停止状态值，使之变成false。对于Thread基础不是很扎实的话，可以看看Thread基础回顾一下。

修改代码如下：

public class Service {
    private ReentrantLock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    public void testMethod() {
        try {
            lock.lock();
            System.out.println("wait begin");
            condition.awaitUninterruptibly();
            System.out.println("wait end");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        final Service service = new Service();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                service.testMethod();
            }
        };
        Thread thread = new Thread(runnable);
        thread.start();
        Thread.sleep(1000);
        thread.interrupt();
    }
}

wait begin

对比结果：awaitUninterruptibly()与await()作用相同，但不会再等待过程中响应中断。

4.1.16 使用Condition实现顺序执行

使用Condition对象可以对线程执行的业务进行排序规划。
代码如下：

public class Run {
    volatile private static int nextPrintWho = 1;
    private static ReentrantLock lock = new ReentrantLock();
    private static Condition conditionA = lock.newCondition();
    private static Condition conditionB = lock.newCondition();
    private static Condition conditionC = lock.newCondition();

    public static void main(String[] args) {
        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    lock.lock();
                    while (nextPrintWho != 1) {
                        conditionA.await();
                    }
                    System.out.println("threadA" + nextPrintWho);
                    nextPrintWho = 2;
                    conditionB.signalAll();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        });
        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    lock.lock();
                    while (nextPrintWho != 2) {
                        conditionB.await();
                    }
                    System.out.println("threadB" + nextPrintWho);
                    nextPrintWho = 3;
                    conditionC.signalAll();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        });
        Thread threadC = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    lock.lock();
                    while (nextPrintWho != 3) {
                        conditionC.await();
                    }
                    System.out.println("threadC" + nextPrintWho);
                    nextPrintWho = 1;
                    conditionA.signalAll();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        });
        Thread[] threadsA = new Thread[5];
        Thread[] threadsB = new Thread[5];
        Thread[] threadsC = new Thread[5];
        for (int i = 0; i < 5; i++) {
            threadsA[i] = new Thread(threadA);
            threadsB[i] = new Thread(threadB);
            threadsC[i] = new Thread(threadC);
            threadsA[i].start();
            threadsB[i].start();
            threadsC[i].start();
        }
    }
}

threadA1
threadB2
threadC3
threadA1
threadB2
threadC3
threadA1
threadB2
threadC3
threadA1
threadB2
threadC3
threadA1
threadB2
threadC3

4.2 使用ReentrantReadWriteLock

ReentrantLock具有完全互斥排他的效果，即同一时间只有一个线程在执行ReentrantLock.lock()方法后面的任务。这样做虽然保证了实例变量的线程安全性，但效率却是非常低下的，所以在JDK中提供了一种读写锁ReentrantReadWriteLock类，在某些不需要操作实例变量的方法中，完全可以使用读写锁来提升代码运行速度。

读写锁表示也有两个锁，一个是读操作相关的锁，也称为共享锁；另一个是写操作相关的锁，也叫排他锁。也就是多个读锁之间不互斥，读锁与写锁互斥，写锁与写锁互斥。即多个线程可以同时进行读取操作，但是同一时刻只允许一个线程进行写操作。

4.2.1 读读共享

public class Service {
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private void read() {
        try {
            lock.readLock().lock();
            System.out.println(Thread.currentThread().getName() + " 获取到读锁 " + System.currentTimeMillis());
            Thread.sleep(5000);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.readLock().unlock();
        }
    }

    public static void main(String[] args) {
        final Service service = new Service();
        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                service.read();
            }
        });
        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                service.read();
            }
        });
        threadA.start();
        threadB.start();
    }
}

Thread-1 获取到读锁 1593755228144
Thread-0 获取到读锁 1593755228144

4.2.2 写写互斥

public class Service {
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private void read() {
        try {
            lock.writeLock().lock();
            System.out.println(Thread.currentThread().getName() + " 获取到写锁 " + System.currentTimeMillis());
            Thread.sleep(5000);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.writeLock().unlock();
        }
    }

    public static void main(String[] args) {
        final Service service = new Service();
        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                service.read();
            }
        });
        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                service.read();
            }
        });
        threadA.start();
        threadB.start();
    }
}

Thread-0 获取到写锁 1593755364185
Thread-1 获取到读锁 1593755369185

writeLock()在同一时间只允许一个线程执行lock后面的方法。

4.2.3 读写互斥

public class Service {
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private void read() {
        try {
            lock.readLock().lock();
            System.out.println(Thread.currentThread().getName() + " 获取到读锁 " + System.currentTimeMillis());
            Thread.sleep(5000);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.readLock().unlock();
        }
    }

    private void write() {
        try {
            lock.writeLock().lock();
            System.out.println(Thread.currentThread().getName() + " 获取到写锁 " + System.currentTimeMillis());
            Thread.sleep(5000);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.writeLock().unlock();
        }
    }

    public static void main(String[] args) {
        final Service service = new Service();
        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                service.read();
            }
        });
        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                service.write();
            }
        });
        threadA.start();
        threadB.start();
    }
}

Thread-0 获取到读锁 1593756165771
Thread-1 获取到写锁 1593756170771

4.2.4 读写互斥

修改以上代码的main方法如下：

	public static void main(String[] args) throws InterruptedException {
        final Service service = new Service();
        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                service.read();
            }
        });
        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                service.write();
            }
        });
        threadB.start();
        Thread.sleep(1000);
        threadA.start();
    }

Thread-1 获取到写锁 1593756318244
Thread-0 获取到读锁 1593756323244

从以上实验结果看来，“读写”，“写读”，“写写”都是互斥的，“读读”是异步非互斥的。

参考文献

《Java多线程编程核心技术》高红岩

人生逆旅我亦行人
关注
  • 4
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
介绍几种等待多线程任务执行完毕的方法
liuqinhou的博客
10-12 2492
java 多线程
几种等待多线程任务执行完毕的方法
MayMatrix 的博客
09-25 6627
CountDownLatch和Cyclicbarrier概念、区别及原理 1、概念   CountDownLatch:具有计数器的功能，等待其他线程执行完毕，主线程在继续执行，用于监听某些初始化操作，并且线程进行阻塞，等初始化执行完毕后，通知主线程继续工作执行。值得注意的是CountDownLatch计数的次数一定要与构造器传入的数字一致，比如构造器传入的是3，则countDown()一定要执行3次，否则线程将一直阻塞。CountDownLatch通常用来控制线程等待，它可以让线程等待倒计时结束，.
for循环内线程池并发执行任务，等到子线程全部处理完任务，主线程在执行java的实现方式
cbb
04-03 5564
当计数器减为 0 时，所有子线程的任务都已经执行完毕，主线程可以执行后续代码。在主线程中，调用 CountDownLatch.await() 方法阻塞等待所有子线程的任务执行完毕，直到计数器减为 0 才继续执行后续代码。请注意，在使用自定义线程池时，需要考虑线程安全、并发访问等问题，并在代码中正确处理异常。请注意，在实际应用中，您还需要考虑线程安全、并发访问等问题，并在代码中正确处理异常。请注意，在使用以上方法时，仍然需要考虑线程安全、并发访问等问题，并在代码中正确处理异常。
Java多线程如何保证线程池里的线程都执行完毕
bernardGao94的博客
10-15 2071
背景： 项目中为了提高性能常常会引入多线程，当我们使用线程池时有时要满足“当线程池里的线程都执行完毕后才能进行下一步”这种业务场景，例如：当多线程操作一个文件时要保证所有线程都运行完毕才能保证文件的完整；当用多线程给一个对象的多个属性进行赋值时要保证线程都运行完毕才将此对象返回，否则就会出现对象属性不全。 实现方式： 1、使用isTerminated方法 2、使用CountDownLatch 3...
java等待线程执行完毕_Java多线程--等待所有子线程执行完的五种方法
weixin_35208812的博客
02-17 6572
方法一:用sleep方法让主线程睡眠一段时间，当然这个睡眠时间是主观的时间，是我们自己定的，这个方法不推荐，但是在这里还是写一下，毕竟是解决方法方法二:Thread的join()方法等待所有的子线程执行完毕，主线程在执行，thread.join()把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执...
腾讯面试题 你了解ReentrantLock吗？
01-20
腾讯面试题 你了解ReentrantLock吗？ ReetrantLock是一个可重入的独占锁，主要有两个特性，一个是支持公平锁和非公平锁，一个是可重入。 ReetrantLock实现依赖于AQS(AbstractQueuedSynchronizer)(不懂得话可以看我上...
教你完全理解ReentrantLock重入锁
10-16
同时，要了解其内部是如何通过AQS（AbstractQueuedSynchronizer）来管理锁的状态和线程等待队列，以及如何通过tryAcquire和tryRelease方法实现锁的获取和释放。通过深入学习这些概念，开发者可以更好地设计和优化多...
ReentrantLock实现原理详解
08-31
了解ReentrantLock的实现原理，有助于我们在并发编程中更好地选择和使用锁，以提高程序的并发性能和可维护性。无论是synchronized还是ReentrantLock，正确理解和使用锁是并发编程的基础，也是避免线程安全问题的...
第15讲 synchronized和ReentrantLock有什么区别呢？1
08-03
除了了解基本使用和案例外，深入理解它们的底层实现，如锁膨胀、降级，以及轻量级锁、重量级锁、自旋锁和偏斜锁等概念，对于成为一个合格的Java并发开发者至关重要。同时，掌握java.util.concurrent.locks包中的其他...
ReentrantLock源码详解--条件锁
08-25
ReentrantLock源码详解--条件锁 ReentrantLock源码详解中最重要的一个部分就是条件锁，条件锁是指在获取锁之后发现当前业务...通过了解条件锁的原理和实现，我们可以更好地使用ReentrantLock来编写高效的并发程序。
Java多线程--等待所有子线程执行完的五种方法.docx
09-14
Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法
Java 判断线程池所有任务是否执行完毕的操作
08-24
主要介绍了Java 判断线程池所有任务是否执行完毕的操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
java线程池开发的时候如何让主线程等待子线程执行结束后结束
别人笑我太疯癫，我笑他人看不穿。
01-02 3815
我们在直接使用Thread线程类的时候可以用join方法解决主线程等待子线程执行完毕的需求，但是在实际开发中我们用的大多是线程池，没有join方法给我们调用。这种情况JAVA提供了两种解决方法。
java 等待线程池结束_等待线程池中任务执行完毕做优雅关闭
weixin_42519170的博客
03-05 4085
背景在Java开发中，如果涉及多线程，会经常使用到线程池，本期不额外讲述线程池本身相关的东西。考虑一种场景，如果我们提交给线程池的任务都相对比较耗时，而在任务启动运行后，如果后续有需求的变更，要重新部署业务。这时，需要关闭当前的执行实例或者重启，如果直接kill实例而任务又包含多个复杂的逻辑，可能导致一些非预期的后果。因此，类似情况下，需要等线程池中已有任务尽量执行完毕，来避免带来意料以外的问题。...
java线程池主线程等待子线程执行完成
2301_78145669的博客
05-16 1490
系列方法可以帮助我们等待一个子线程的结束。处理完后再把那段逻辑的处理结果进行汇。被动式指主线程被动的等待子线程的结。有没有另外一种方法可以等待子线程结束。那么主线程如何等待子线程工作完成呢。他的作用是判断线程是否已经执行结束。这 里是得益于我们用了一个阻塞队列。是异步的去执行需要执行的内容的。以上几种情况都是针对子线程只有。拿到什么我们是不必去关心的。包里面提供了好多有用的东东。我们只需要在子线程执行之前。可以等待所有子线程执行结。今天讨论一个入门级的话题。本程序的数据有可能是如下。
java主线程等待子线程池执行完再执行
最新发布
weixin_43873239的博客
11-20 414
是 Java 中用于等待线程池中的所有任务执行完毕的方法。这个方法通常用于在程序结束前确保所有任务都已经完成，例如在服务器关闭之前。来阻塞当前线程，直到所有任务完成执行，或者超时，或者当前线程被中断。方法来等待线程池中的所有任务执行完毕。以下是一个简单的示例。如果等待过程中当前线程被中断，它会抛出。如果线程池在指定的时间内关闭，或者调用。来创建一个线程池，并使用。在Java中，你可以使用。如果超时期限到达，返回。
面试官：如何让主线程等待所有的子线程执行结束之后再执行？我懵了
阳阳的博客
09-09 6866
使用Thread的join方法 package com.qcy.testThreadFinish; /** * @author qcy * @create 2020/09/09 17:05:23 */ public class Case1 { public static void main(String[] args) throws InterruptedException { Thread t1 = new Thread(() -> {
线程池 ThreadPoolExecutor
梦之旅的博客
03-31 553
线程池 ThreadPoolExecutor ThreadPoolExecutor是线程池类的基本实现，其他线程池的扩展基本都是基础于改类，这个类是学好线程池的基础，下面来看下改类实现的接口。 1. Executor 线程池根接口，该接口只提供了一个方法 void execute(Runnable command); 提交要运行的任务 2. ExecutorService 执行服务类，该接口继承了Executor接口并提供了对线程池操作的扩展方法，如果shutdown（）关闭线程池，shutdownNo
五分钟带你玩转多线程（四）多线程等待所有子线程执行完的五种方法
java100001的博客
05-08 815
方法二:Thread的join()方法 =================== 等待所有的子线程执行完毕，主线程在执行，thread.join()把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执行线程B。 方法三:等待多线程完成的CountDownLatch =========================== 注意:countDownLatch不可能重新初始化或者修改CountDownLatch对.
你了解过哪些同步器？请分别介绍下。
03-31
4. ReentrantLock：一个重入锁同步器，它可以重复进入同一个锁，避免死锁等问题。 5. ReadWriteLock：一个读写锁同步器，它可以控制多个线程同时读取一个资源，但是只允许一个线程写入资源。 以上是同步器的几种...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

人生逆旅我亦行人

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值