Java并发控制：ReentrantLock Condition使用详解

最新推荐文章于 2023-12-19 23:40:17 发布
最新推荐文章于 2023-12-19 23:40:17 发布
阅读量210 收藏
点赞数
分类专栏： 高并发

生产者-消费者（producer-consumer）问题，也称作有界缓冲区（bounded-buffer）问题，两个进程共享一个公共的固定大小的缓冲区。
其中一个是生产者，用于将消息放入缓冲区；另外一个是消费者，用于从缓冲区中取出消息。
问题出现在当缓冲区已经满了，而此时生产者还想向其中放入一个新的数据项的情形，其解决方法是让生产者此时进行休眠，等待消费者从缓冲区中取走了一个或者多个数据后再去唤醒它。
同样地，当缓冲区已经空了，而消费者还想去取消息，此时也可以让消费者进行休眠，等待生产者放入一个或者多个数据时再唤醒它。

Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set （wait-set）。

其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。

在Condition中，用await()替换wait()，用signal()替换notify()，用signalAll()替换notifyAll()，传统线程的通信方式，Condition都可以实现，这里注意，Condition是被绑定到Lock上的，要创建一个Lock的Condition必须用newCondition()方法。

这样看来，Condition和传统的线程通信没什么区别，Condition的强大之处在于它可以为多个线程间建立不同的Condition，下面引入API中的一段代码，加以说明。

代码：

复制代码 
class BoundedBuffer {
   final Lock lock = new ReentrantLock();//锁对象
   final Condition notFull  = lock.newCondition();//写线程条件 
   final Condition notEmpty = lock.newCondition();//读线程条件 

   final Object[] items = new Object[100];//缓存队列
   int putptr/*写索引*/, takeptr/*读索引*/, count/*队列中存在的数据个数*/;

   public void put(Object x) throws InterruptedException {
     lock.lock();
     try {
       while (count == items.length)//如果队列满了 
         notFull.await();//阻塞写线程
       items[putptr] = x;//赋值 
       if (++putptr == items.length) putptr = 0;//如果写索引写到队列的最后一个位置了，那么置为0
       ++count;//个数++
       notEmpty.signal();//唤醒读线程
     } finally {
       lock.unlock();
     }
   }

   public Object take() throws InterruptedException {
     lock.lock();
     try {
       while (count == 0)//如果队列为空
         notEmpty.await();//阻塞读线程
       Object x = items[takeptr];//取值 
       if (++takeptr == items.length) takeptr = 0;//如果读索引读到队列的最后一个位置了，那么置为0
       --count;//个数--
       notFull.signal();//唤醒写线程
       return x;
     } finally {
       lock.unlock();
     }
   } 
 }
复制代码

这是一个处于多线程工作环境下的缓存区，缓存区提供了两个方法，put和take，put是存数据，take是取数据，内部有个缓存队列，具体变量和方法说明见代码，

这个缓存区类实现的功能：有多个线程往里面存数据和从里面取数据，其缓存队列(先进先出后进后出)能缓存的最大数值是100，多个线程间是互斥的，

当缓存队列中存储的值达到100时，将写线程阻塞，并唤醒读线程，当缓存队列中存储的值为0时，将读线程阻塞，并唤醒写线程，这也是ArrayBlockingQueue的内部实现。

下面分析一下代码的执行过程：

        1. 一个写线程执行，调用put方法；

        2. 判断count是否为100，显然没有100；

        3. 继续执行，存入值；

        4. 判断当前写入的索引位置++后，是否和100相等，相等将写入索引值变为0，并将count+1；

        5. 仅唤醒读线程阻塞队列中的一个；

        6. 一个读线程执行，调用take方法；

        7. ……

        8. 仅唤醒写线程阻塞队列中的一个。

        这就是多个Condition的强大之处，假设缓存队列中已经存满，那么阻塞的肯定是写线程，唤醒的肯定是读线程，相反，阻塞的肯定是读线程，唤醒的肯定是写线程，那么假设只有一个Condition会有什么效果呢，缓存队列中已经存满，这个Lock不知道唤醒的是读线程还是写线程了，如果唤醒的是读线程，皆大欢喜，如果唤醒的是写线程，那么线程刚被唤醒，又被阻塞了，这时又去唤醒，这样就浪费了很多时间。

Condition的应用：

复制代码 
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Main {
    static class NumberWrapper {
        public int value = 1;
    }

    public static void main(String[] args)  {
        //初始化可重入锁
        final Lock lock = new ReentrantLock();

        //第一个条件当屏幕上输出到3
        final Condition reachThreeCondition = lock.newCondition();
        //第二个条件当屏幕上输出到6
        final Condition reachSixCondition = lock.newCondition();

        //NumberWrapper只是为了封装一个数字，一边可以将数字对象共享，并可以设置为final
        //注意这里不要用Integer, Integer 是不可变对象
        final NumberWrapper num = new NumberWrapper();
        //初始化A线程
        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                //需要先获得锁
                lock.lock();
                try {
                    System.out.println("threadA start write");
                    //A线程先输出前3个数
                    while (num.value <= 3) {
                        System.out.println(num.value);
                        num.value++;
                    }
                    //输出到3时要signal，告诉B线程可以开始了
                    reachThreeCondition.signal();
                } finally {
                    lock.unlock();
                }
                lock.lock();
                try {
                    //等待输出6的条件
                    reachSixCondition.await();
                    System.out.println("threadA start write");
                    //输出剩余数字
                    while (num.value <= 9) {
                        System.out.println(num.value);
                        num.value++;
                    }

                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }

        });


        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    lock.lock();

                    while (num.value <= 3) {
                        //等待3输出完毕的信号
                        reachThreeCondition.await();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
                try {
                    lock.lock();
                    //已经收到信号，开始输出4，5，6
                    System.out.println("threadB start write");
                    while (num.value <= 6) {
                        System.out.println(num.value);
                        num.value++;
                    }
                    //4，5，6输出完毕，告诉A线程6输出完了
                    reachSixCondition.signal();
                } finally {
                    lock.unlock();
                }
            }

        });

        //启动两个线程
        threadB.start();
        threadA.start();
    }
}
复制代码
  View Code

基本思路就是首先要A线程先写1，2，3，这时候B线程应该等待reachThredCondition信号，而当A线程写完3之后就通过signal告诉B线程“我写到3了，该你了”，

这时候A线程要等reachSixCondition信号，同时B线程得到通知，开始写4，5，6，写完4，5，6之后B线程通知A线程reachSixCondition条件成立了，这时候A线程就开始写剩下的7，8，9了。

Java官方提供的例子：

复制代码 
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Main {
    public static void main(String[] args)  {
        final BoundedBuffer boundedBuffer = new BoundedBuffer();

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("t1 run");
                for (int i=0;i<20;i++) {
                    try {
                        System.out.println("putting..");
                        boundedBuffer.put(Integer.valueOf(i));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }

        }) ;

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i=0;i<20;i++) {
                    try {
                        Object val = boundedBuffer.take();
                        System.out.println(val);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }

        }) ;

        t1.start();
        t2.start();
    }

    /**
     * BoundedBuffer 是一个定长100的集合，当集合中没有元素时，take方法需要等待，直到有元素时才返回元素
     * 当其中的元素数达到最大值时，要等待直到元素被take之后才执行put的操作
     * @author yukaizhao
     *
     */
    static class BoundedBuffer {
        final Lock lock = new ReentrantLock();
        final Condition notFull = lock.newCondition();
        final Condition notEmpty = lock.newCondition();

        final Object[] items = new Object[100];
        int putptr, takeptr, count;

        public void put(Object x) throws InterruptedException {
            System .out.println("put wait lock");
            lock.lock();
            System.out.println("put get lock");
            try {
                while (count == items.length) {
                    System.out.println("buffer full, please wait");
                    notFull.await();
                }

                items[putptr] = x;
                if (++putptr == items.length)
                    putptr = 0;
                ++count;
                notEmpty.signal();
            } finally {
                lock.unlock();
            }
        }
        
        public Object take() throws InterruptedException {
            System.out.println("take wait lock");
            lock.lock();
            System.out.println("take get lock");
            try {
                while (count == 0) {
                    System.out.println("no elements, please wait");
                    notEmpty.await();
                }
                Object x = items[takeptr];
                if (++takeptr == items.length)
                    takeptr = 0;
                --count;
                notFull.signal();
                return x;
            } finally {
                lock.unlock();
            }
        }
    }
}
复制代码
  View Code

也可以修改t1,t2线程里面的循环，改成大于100，可能会碰到集合已满的情况。

这个示例中BoundedBuffer是一个固定长度的集合，

这个在其put操作时，如果发现长度已经达到最大长度，那么要等待notFull信号才能继续put，如果得到notFull信号会像集合中添加元素，并且put操作会发出notEmpty的信号，

而在其take方法中如果发现集合长度为空，那么会等待notEmpty的信号，接受到notEmpty信号才能继续take，同时如果拿到一个元素，那么会发出notFull的信号。

Condition与Object中的wati,notify,notifyAll区别：

1.Condition中的await()方法相当于Object的wait()方法，Condition中的signal()方法相当于Object的notify()方法，Condition中的signalAll()相当于Object的notifyAll()方法。
不同的是，Object中的这些方法是和同步锁捆绑使用的；而Condition是需要与互斥锁/共享锁捆绑使用的。

2.Condition它更强大的地方在于：能够更加精细的控制多线程的休眠与唤醒。对于同一个锁，我们可以创建多个Condition，在不同的情况下使用不同的Condition。
例如，假如多线程读/写同一个缓冲区：当向缓冲区中写入数据之后，唤醒"读线程"；当从缓冲区读出数据之后，唤醒"写线程"；并且当缓冲区满的时候，"写线程"需要等待；当缓冲区为空时，"读线程"需要等待。 
如果采用Object类中的wait(),notify(),notifyAll()实现该缓冲区，当向缓冲区写入数据之后需要唤醒"读线程"时，不可能通过notify()或notifyAll()明确的指定唤醒"读线程"，而只能通过notifyAll唤醒所有线程(但是notifyAll无法区分唤醒的线程是读线程，还是写线程)。 但是，通过Condition，就能明确的指定唤醒读线程。

chuixue24
关注
专栏目录
Java进阶：ReentrantLock和Condition基本使用
qq_28834355的博客
10-20 3358
1. 概述 Java除了使用synchronized锁之外，还可以使用ReentrantLock实现独占锁。ReentrantLock使用起来更加灵活，也提供了更丰富的功能。 2. 加锁解锁 验证加锁之前，先来看一段没加锁的代码 public class ReentrantLockApp { static class MyTest{ public volatile int num = 0; //自增 public void incr(){
线程安全（七）ReentrantLock 简介、Condition 条件变量、锁的工作原理、synchronized 与 Lock 的区别
最新发布
ACGkaka的博客
07-17 1034
线程安全（七）ReentrantLock 简介、Condition 条件变量、锁的工作原理、synchronized 与 Lock 的区别
Java技术——ReentrantLock的Condition的作用以及使用
热门推荐
关于Android开发的一些技术点总结 ╮(￣▽￣”)╭
06-30 1万+
0. 前言 之前知道ReentrantLock类有一个newCondition()，用于获取Lock上的一个条件，还可以多次newCondition()获得多个条件，Condition可用于线程间通信。是对比ReentrantLock和Synchronized关键字的区别时学习到的。但是有次面试被问到有没有用到过ReentrantLock的Condition，瞬间懵逼了。所以搜集了些资...
java ReentrantLock Condition
weixin_30847939的博客
03-23 47
sychronized、wait、notify、notifyAll、sleep 在多线程环境下，为了防止多个线程同时调用同一个方法、修改同一份变量，造成数据读取结果混乱，可以使用synchronized关键字，对一个方法或者代码块实现同步调用，即只能一个线程调用完此方法后，下一个线程才能调用此方法。 当synchronized修饰的是一个类方法时，使用的是此类的Monitor实现同步...
Java中condition的用法,ReentrantLock中的Condition用法
weixin_29129833的博客
03-14 340
Condition：条件，这个在ReentrantLock中该怎么使用？如果不了解ReentrantLock的可以先看一下ReentrantLock。总体来说可以类比为synchronized、wait和notify之间的用法。我们还是举例来说明：LinkedBlockingDeque(链接阻塞双端队列，属于JUC包)的put和take方法。先说说看代码大概的思路：1、在put插入数据的时候，当队...
Java多线程中ReentrantLock与Condition详解
08-28
Java多线程中ReentrantLock与Condition详解 ReentrantLock是Java多线程中一种高级的锁机制，它实现了Lock接口，提供了与synchronized相同的并发性和内存语义，但添加了一些特性，如锁投票、定时锁等候和可中断锁...
java并发编程专题（五）----详解（JUC）ReentrantLock
08-18
Java并发编程中的ReentrantLock是Java并发包（java.util.concurrent，简称JUC）中的一个重要的锁机制，它是Lock接口的一个具体实现，提供了比synchronized更强大的锁定功能和更细粒度的控制。ReentrantLock的主要...
java ReentrantLock详解.docx
06-26
`ReentrantLock`是Java并发编程中的一种高级锁机制，它是`java.util.concurrent.locks`包中的类，提供了比`synchronized`关键字更丰富的功能和更细粒度的控制。相较于`synchronized`，`ReentrantLock`的主要优势在于...
详解Java多线程编程中互斥锁ReentrantLock类的用法
09-02
在Java多线程编程中，ReentrantLock提供了更灵活的锁管理机制，相比synchronized，它允许更细粒度的控制，并且提供了更多的同步原语。以下是一些使用ReentrantLock的关键点： 1. **可重入性**：ReentrantLock允许一...
Java并发工具AQS条件队列Condition实现详解
lt_xiaodou的博客
08-23 468
当阻塞唤醒（即从LockSupport.park()放回）之后，且查询到当前线程结点已在锁队列上时，说明此时已有其他线程成功调用了signal()或signalAll()，然后执行争夺锁的操作并把之前的锁状态还原回去，即通过acquireQueued()完成。当有线程在这个Condition上调用了signal时，就会把线程从条件队列转移到它锁关联的那个AQS的锁队列上，并且将它唤醒（此时，阻塞循环中的判断是否在锁队列的条件就会满足，导致跳出循环）。最先开始等待的线程位于头结点，最后等待的线程位于尾结点。
java retlock_java ReentrantLock Condition
weixin_42502957的博客
02-28 143
sychronized、wait、notify、notifyAll、sleep在多线程环境下，为了防止多个线程同时调用同一个方法、修改同一份变量，造成数据读取结果混乱，可以使用synchronized关键字，对一个方法或者代码块实现同步调用，即只能一个线程调用完此方法后，下一个线程才能调用此方法。当synchronized修饰的是一个类方法时，使用的是此类的Monitor实现同步(锁)。当sync...
Java ReentrantLock--Condition
杀神lwz的博客
12-19 142
虽然Node对象有prev和next，但是在ConditionObject中是不会使用这两个属性的，只要在Condition队列中，这两个属性都是null。4、在获取锁资源后，要确认是否在获取锁资源的阶段被中断过，如果被中断过，并且不是 THROW_IE，那就确保interruptMode是REINTERRUPT。awaitNanos：仅仅是在await方法的基础上，做了一点点的改变，整体的逻辑思想都是一样的。挂起线程时，传入要阻塞的时间，时间到了，自动唤醒，走添加到AQS队列的逻辑。
Java 锁系列（四）——ReentrantLock源码Condition实现分析
玖涯博客
11-02 423
一、Condition 概述 Condition 是个接口，依赖于 Lock 接口的实现，基本的方法就是 await() 和 signal() 方法，是在 java 1.5 中才出现的，用于替代 Object 的 wait()、notify() 实现线程间的协作，相比使用 Object 的 wait()、notify()，使用 Condition 的 await()、signal() 这种方式实现线程间协作更加安全和高效。因此通常来说比较推荐使用Condition，阻塞队列实际上是使用了Condition来
Java多线程（九）之ReentrantLock与Condition（转）
mfkzhounb的专栏
08-11 97
java.util.concurrent.lock 中的 Lock 框架是锁定的一个抽象，它允许把锁定的实现作为 Java 类，而不是作为语言的特性来实现。这就为 Lock 的多种实现留下了空间，各种实现可能有不同的调度算法、性能特性或者锁定语义。 ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，但是添加了类似锁投票、定时锁等候和可...
JAVA并发： ReentrantLock之Condition
wangbo199308的博客
09-23 517
1 Condition的基本使用 在前面学习synchronized 的时候，有讲到 wait/notify的基本使用，结合 synchronized可以实现对线程间的通信，JUC并发包里面提供的同样的功能。 Condition 是一个多线程协调通信的工具类里面提供了await/signal方法，可以让某些线程一起等待某个条件（condition），只有满足条件时，线程才会被唤醒。 1.1 简单案例 public class LockConditionDemo { private static R
java锁之ReentrantLock及Condition
冰血ANG的博客
09-08 1469
ReentrantLock及Condition配合使用机制
Java8 ReentrantLock Condition运用
weixin_43858151的博客
12-29 2159
Java8 ReentrantLock Condition在LinkedBlockingQueue中的使用场景1.持有的锁2.插入元素3.获取元素4.经验总结 在LinkedBlockingQueue中的使用场景 下面以LinkedBlockingQueue为例，分析ReentrantLock和Condition的作用。 1.持有的锁 /** Lock held by take, poll, etc */ private final ReentrantLock takeLock = new Reentra
【java学习积累】ReentrantLock Condition的使用
xiangzaixiansheng的博客
06-23 2067
一、ReentrantLock 的方法介绍 下面列举一些常见的ReentrantLock的方法。 int getHoldCount()：查询当前线程保持此锁定的个数，也就是调用lock()方法的次数。 int getQueueLength()：返回正等待获取此锁定的线程估计数。比如有5个线程，1个线程首先执行await()方法，那么在调用getQueueLength方法后返回值是4，说明有4...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值