1.概述
转载：java高并发系列 - 第13天:JUC中的Condition对象
- synchronized中实现线程等待和唤醒
- Condition简介及常用方法介绍及相关示例
- 使用Condition实现生产者消费者
- 使用Condition实现同步阻塞队列
Object对象中的wait()，notify()方法，用于线程等待和唤醒等待中的线程，大家应该比较熟悉，想再次了解的朋友可以移步到java高并发系列 - 第6天:线程的基本操作
2.synchronized中等待和唤醒线程示例
public class ObjectLockDemoTest {
static Object lock = new Object();
public static class T1 extends Thread {
@Override
public void run() {
System.out.println(System.currentTimeMillis() + "," + this.getName() + "准备获取锁!");
synchronized (lock) {
System.out.println(System.currentTimeMillis() + "," + this.getName() + "获取锁成功!");
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(System.currentTimeMillis() + "," + this.getName() + "释放锁成功!");
}
}
public static class T2 extends Thread {
@Override
public void run() {
System.out.println(System.currentTimeMillis() + "," + this.getName() + "准备获取锁!");
synchronized (lock) {
System.out.println(System.currentTimeMillis() + "," + this.getName() + "获取锁成功!");
lock.notify();
System.out.println(System.currentTimeMillis() + "," + this.getName() + " notify!");
try {
TimeUnit.SECONDS.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(System.currentTimeMillis() + "," + this.getName() + "准备释放锁!");
}
System.out.println(System.currentTimeMillis() + "," + this.getName() + "释放锁成功!");
}
}
public static void main(String[] args) throws InterruptedException {
T1 t1 = new T1();
t1.setName("t1");
t1.start();
TimeUnit.SECONDS.sleep(5);
T2 t2 = new T2();
t2.setName("t2");
t2.start();
}
}输出：
1606481560031,t1准备获取锁!
1606481560031,t1获取锁成功!
1606481565037,t2准备获取锁!
1606481565037,t2获取锁成功!
1606481565037,t2 notify!
1606481570038,t2准备释放锁!
1606481570038,t2释放锁成功!
1606481570039,t1释放锁成功!代码结合输出的结果我们分析一下：
- 线程t1先获取锁，然后调用了wait()方法将线程置为等待状态，然后会释放lock的锁
- 主线程等待5秒之后，启动线程t2，t2获取到了锁，结果中1、3行时间相差5秒左右
- t2调用lock.notify()方法，准备将等待在lock上的线程t1唤醒，notify()方法之后又休眠了5秒，看一下输出的5、8可知，notify()方法之后，t1并不能立即被唤醒，需要等到t2将synchronized块执行完毕，释放锁之后，t1才被唤醒
- wait()方法和notify()方法必须放在同步块内调用（synchronized块内），否则会报错
3.Condition使用简介
在了解Condition之前，需要先了解一下重入锁ReentrantLock，可以移步到：java高并发系列 - 第12天JUC:ReentrantLock重入锁。
任何一个java对象都天然继承于Object类，在线程间实现通信的往往会应用到Object的几个方法，比如wait()、wait(long timeout)、wait(long timeout, int nanos)与notify()、notifyAll()几个方法实现等待/通知机制，同样的， 在java Lock体系下依然会有同样的方法实现等待/通知机制。
从整体上来看Object的wait和notify/notify是与对象监视器配合完成线程间的等待/通知机制，而Condition与Lock配合完成等待通知机制，前者是java底层级别的，后者是语言级别的，具有更高的可控制性和扩展性。两者除了在使用方式上不同外，在功能特性上还是有很多的不同：
- Condition能够支持不响应中断，而通过使用Object方式不支持
- Condition能够支持多个等待队列（new 多个Condition对象），而Object方式只能支持一个
- Condition能够支持超时时间的设置，而Object不支持
Condition由ReentrantLock对象创建，并且可以同时创建多个，Condition接口在使用前必须先调用ReentrantLock的lock()方法获得锁，之后调用Condition接口的await()将释放锁，并且在该Condition上等待，直到有其他线程调用Condition的signal()方法唤醒线程，使用方式和wait()、notify()类似。
示例代码：
public class Demo2 {
static ReentrantLock lock = new ReentrantLock();
static Condition condition = lock.newCondition();
public static class T1 extends Thread {
@Override
public void run() {
System.out.println(System.currentTimeMillis() + "," + this.getName() + "准备获取锁!");
lock.lock();
try {
System.out.println(System.currentTimeMillis() + "," + this.getName() + "获取锁成功!");
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
System.out.println(System.currentTimeMillis() + "," + this.getName() + "释放锁成功!");
}
}
public static class T2 extends Thread {
@Override
public void run() {
System.out.println(System.currentTimeMillis() + "," + this.getName() + "准备获取锁!");
lock.lock();
try {
System.out.println(System.currentTimeMillis() + "," + this.getName() + "获取锁成功!");
condition.signal();
System.out.println(System.currentTimeMillis() + "," + this.getName() + " signal!");
try {
TimeUnit.SECONDS.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(System.currentTimeMillis() + "," + this.getName() + "准备释放锁!");
} finally {
lock.unlock();
}
System.out.println(System.currentTimeMillis() + "," + this.getName() + "释放锁成功!");
}
}
public static void main(String[] args) throws InterruptedException {
T1 t1 = new T1();
t1.setName("t1");
t1.start();
TimeUnit.SECONDS.sleep(5);
T2 t2 = new T2();
t2.setName("t2");
t2.start();
}
}输出：
1606481868491,t1准备获取锁!
1606481868491,t1获取锁成功!
1606481873494,t2准备获取锁!
1606481873495,t2获取锁成功!
1606481873495,t2 signal!
1606481878496,t2准备释放锁!
1606481878496,t2释放锁成功!
1606481878496,t1释放锁成功!输出的结果和使用synchronized关键字的实例类似。
Condition.await()方法和Object.wait()方法类似，当使用Condition.await()方法时，需要先获取Condition对象关联的ReentrantLock的锁，在Condition.await()方法被调用时，当前线程会释放这个锁，并且当前线程会进行等待（处于阻塞状态）。在signal()方法被调用后，系统会从Condition对象的等待队列中唤醒一个线程，一旦线程被唤醒，被唤醒的线程会尝试重新获取锁，一旦获取成功，就可以继续执行了。因此，在signal被调用后，一般需要释放相关的锁，让给其他被唤醒的线程，让他可以继续执行。
3.2 实现方法顺序调用
public class ConditionDemo {
static ReentrantLock lock = new ReentrantLock();
static Condition condition1= lock.newCondition();
static Condition condition2 = lock.newCondition();
static Condition condition3 = lock.newCondition();
public void method1(){
lock.lock();
try {
System.out.println("准备处理method1");
condition1.await();
System.out.println("method1");
condition2.signal();
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();
}
}
public void method2(){
lock.lock();
try {
System.out.println("准备处理method2");
condition2.await();
System.out.println("method3");
condition3.signal();
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();
}
}
public void method3(){
lock.lock();
try {
System.out.println("准备处理method3");
condition1.signal();
condition3.await();
System.out.println("method3");
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();
}
}
}测试类如下
private ConditionDemo conditionDemo = new ConditionDemo();
/**
* 测试点：测试使用 Condition 实现方法的顺序调用
*
* 准备处理method1
* 准备处理method2
* 准备处理method3
* method1
* method3
* method3
*
* 参考：https://www.bilibili.com/video/BV1TL4y1t7Ln/?spm_id_from=pageDriver
*/
@Test
public void method1() {
new Thread(() ->{
conditionDemo.method1();
}).start();
new Thread(() ->{
conditionDemo.method2();
}).start();
new Thread(() ->{
conditionDemo.method3();
}).start();
LockSupport.park(this);
}4.Condition常用方法
4.1 Condition接口提供的常用方法有
和Object中wait类似的方法
名称 | 解释 |
void await() throws InterruptedException | 当前线程进入等待状态，如果其他线程调用condition的signal或者signalAll方法并且当前线程获取Lock从await方法返回，如果在等待状态中被中断会抛出被中断异常； |
long awaitNanos(long nanosTimeout) | 当前线程进入等待状态直到被通知，中断或者超时； |
boolean await(long time, TimeUnit unit) | 同第二种，支持自定义时间单位，false：表示方法超时之后自动返回的，true：表示等待还未超时时，await方法就返回了（超时之前，被其他线程唤醒了） |
boolean awaitUntil(Date deadline) | 前线程进入等待状态直到被通知，中断或者到了某个时间 |
oid awaitUninterruptibly(); | 当前线程进入等待状态，不会响应线程中断操作，只能通过唤醒的方式让线程继续 |
4.2 和Object的notify/notifyAll类似的方法
名称 | 解释 |
void signal() | 唤醒一个等待在condition上的线程，将该线程从等待队列中转移到同步队列中，如果在同步队列中能够竞争到Lock则可以从等待方法中返回。 |
void signalAll() | 与1的区别在于能够唤醒所有等待在condition上的线程 |
4.3 Condition.await()过程中被打断
public class Demo {
static ReentrantLock lock = new ReentrantLock();
static Condition condition = lock.newCondition();
public static class T1 extends Thread {
@Override
public void run() {
lock.lock();
try {
condition.await();
} catch (InterruptedException e) {
System.out.println("中断标志：" + this.isInterrupted());
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
public static void main(String[] args) throws InterruptedException {
T1 t1 = new T1();
t1.setName("t1");
t1.start();
TimeUnit.SECONDS.sleep(2);
//给t1线程发送中断信号
System.out.println("1、t1中断标志：" + t1.isInterrupted());
t1.interrupt();
System.out.println("2、t1中断标志：" + t1.isInterrupted());
}
}输出
1、t1中断标志：false
2、t1中断标志：true
中断标志：false
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)
at com.java.thread.demo.lock.object.Demo$T1.run(Demo.java:19)调用condition.await()之后，线程进入阻塞中，调用t1.interrupt()，给t1线程发送中断信号，await()方法内部会检测到线程中断信号，然后触发 InterruptedException异常，线程中断标志被清除。从输出结果中可以看出，线程t1中断标志的变换过程：false->true->false
4.4 await(long time, TimeUnit unit)超时之后自动返回
public class Demo {
static ReentrantLock lock = new ReentrantLock();
static Condition condition = lock.newCondition();
public static class T1 extends Thread {
@Override
public void run() {
lock.lock();
try {
System.out.println(System.currentTimeMillis() + "," + this.getName() + ",start");
boolean r = condition.await(2, TimeUnit.SECONDS);
System.out.println(r);
System.out.println(System.currentTimeMillis() + "," + this.getName() + ",end");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
public static void main(String[] args) throws InterruptedException {
T1 t1 = new T1();
t1.setName("t1");
t1.start();
}
}输出
1606482349237,t1,start
false
1606482351243,t1,endt1线程等待2秒之后，自动返回继续执行，最后await方法返回false，await返回false表示超时之后自动返回
4.5 await(long time, TimeUnit unit)超时之前被唤醒
public class Demo {
static ReentrantLock lock = new ReentrantLock();
static Condition condition = lock.newCondition();
public static class T1 extends Thread {
@Override
public void run() {
lock.lock();
try {
System.out.println(System.currentTimeMillis() + "," + this.getName() + ",start");
boolean r = condition.await(5, TimeUnit.SECONDS);
System.out.println(r);
System.out.println(System.currentTimeMillis() + "," + this.getName() + ",end");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
public static void main(String[] args) throws InterruptedException {
T1 t1 = new T1();
t1.setName("t1");
t1.start(); //休眠1秒之后，唤醒t1线程
TimeUnit.SECONDS.sleep(1);
lock.lock();
try {
condition.signal();
} finally {
lock.unlock();
}
}
}输出
1606482446573,t1,start
true
1606482447578,t1,endt1线程中调用 condition.await(5,TimeUnit.SECONDS);方法会释放锁，等待5秒，主线程休眠1秒，然后获取锁，之后调用signal()方法唤醒t1，输出结果中发现await后过了1秒（1、3行输出结果的时间差），await方法就返回了，并且返回值是true。true表示await方法超时之前被其他线程唤醒了。
4.6 long awaitNanos(long nanosTimeout)超时返回
public class Demo {
static ReentrantLock lock = new ReentrantLock();
static Condition condition = lock.newCondition();
public static class T1 extends Thread {
@Override
public void run() {
lock.lock();
try {
System.out.println(System.currentTimeMillis() + "," + this.getName() + ",start");
long r = condition.awaitNanos(TimeUnit.SECONDS.toNanos(5));
System.out.println(r);
System.out.println(System.currentTimeMillis() + "," + this.getName() + ",end");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
public static void main(String[] args) throws InterruptedException {
T1 t1 = new T1();
t1.setName("t1");
t1.start();
}
}输出
1606482528851,t1,start
-4607604
1606482533857,t1,endawaitNanos参数为纳秒，可以调用TimeUnit中的一些方法将时间转换为纳秒。
t1调用await方法等待5秒超时返回，返回结果为负数，表示超时之后返回的。
4.7 waitNanos(long nanosTimeout)超时之前被唤醒
public class Demo {
static ReentrantLock lock = new ReentrantLock();
static Condition condition = lock.newCondition();
public static class T1 extends Thread {
@Override
public void run() {
lock.lock();
try {
System.out.println(System.currentTimeMillis() + "," + this.getName() + ",start");
long r = condition.awaitNanos(TimeUnit.SECONDS.toNanos(5));
System.out.println(r);
System.out.println(System.currentTimeMillis() + "," + this.getName() + ",end");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
public static void main(String[] args) throws InterruptedException {
T1 t1 = new T1();
t1.setName("t1");
t1.start(); //休眠1秒之后，唤醒t1线程
TimeUnit.SECONDS.sleep(1);
lock.lock();
try {
condition.signal();
} finally {
lock.unlock();
}
}
}输出
1606482601337,t1,start
3999189664
1606482602341,t1,endt1中调用await休眠5秒，主线程休眠1秒之后，调用signal()唤醒线程t1，await方法返回正数，表示返回时距离超时时间还有多久，将近4秒，返回正数表示，线程在超时之前被唤醒了。
其他几个有参的await方法和无参的await方法一样，线程调用interrupt()方法时，这些方法都会触发InterruptedException异常，并且线程的中断标志会被清除。
4.8 同一个锁支持创建多个Condition
使用两个Condition来实现一个阻塞队列的例子：
import java.util.LinkedList;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class BlockingQueueDemo<E> {
int size; //阻塞队列最大容量
ReentrantLock lock = new ReentrantLock();
LinkedList<E> list = new LinkedList<>(); //队列底层实现
Condition notFull = lock.newCondition(); //队列满时的等待条件
Condition notEmpty = lock.newCondition(); //队列空时的等待条件
public BlockingQueueDemo(int size) {
this.size = size;
}
public void enqueue(E e) throws InterruptedException {
lock.lock();
try {
while (list.size() == size) //队列已满,在notFull条件上等待
notFull.await();
list.add(e); //入队:加入链表末尾
System.out.println("入队：" + e);
notEmpty.signal(); //通知在notEmpty条件上等待的线程
} finally {
lock.unlock();
}
}
public E dequeue() throws InterruptedException {
E e;
lock.lock();
try {
while (list.size() == 0) //队列为空,在notEmpty条件上等待
notEmpty.await();
e = list.removeFirst(); //出队:移除链表首元素
System.out.println("出队：" + e);
notFull.signal(); //通知在notFull条件上等待的线程
return e;
} finally {
lock.unlock();
}
}
public static void main(String[] args) {
BlockingQueueDemo<Integer> queue = new BlockingQueueDemo<>(2);
for (int i = 0; i < 10; i++) {
int data = i;
new Thread(new Runnable() {
@Override
public void run() {
try {
queue.enqueue(data);
} catch (InterruptedException e) {
}
}
}).start();
}
for (int i = 0; i < 10; i++) {
new Thread(new Runnable() {
@Override
public void run() {
try {
Integer data = queue.dequeue();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
}
}输出
入队：0
入队：1
出队：0
入队：2
出队：1
出队：2
入队：3
入队：4
出队：3
入队：5
出队：4
入队：6
出队：5
入队：7
出队：6
入队：8
出队：7
入队：9
出队：8
出队：9代码非常容易理解，创建了一个阻塞队列，大小为3，队列满的时候，会被阻塞，等待其他线程去消费，队列中的元素被消费之后，会唤醒生产者，生产数据进入队列。上面代码将队列大小置为1，可以实现同步阻塞队列，生产1个元素之后，生产者会被阻塞，待消费者消费队列中的元素之后，生产者才能继续工作。
5.Object的监视器方法与Condition接口的对比
对比项 | Object监视器方法 | Condition |
前置条件 | 获取对象的锁 | 调用Lock.lock获取锁，调用Lock.newCondition()获取Condition对象 |
调用方式 | 直接调用，如：object.wait() | 直接调用，如：condition.await() |
等待队列个数 | 一个 | 多个，使用多个condition实现 |
当前线程释放锁并进入等待状态 | 支持 | 支持 |
当前线程释放锁进入等待状态中不响应中断 | 不支持 | 支持 |
当前线程释放锁并进入超时等待状态 | 支持 | 支持 |
当前线程释放锁并进入等待状态到将来某个时间 | 不支持 | 支持 |
唤醒等待队列中的一个线程 | 支持 | 支持 |
唤醒等待队列中的全部线程 | 支持 | 支持 |
6.总结
- 使用condition的步骤：创建condition对象，获取锁，然后调用condition的方法
- 一个ReentrantLock支持床多个condition对象
- void await()throwsInterruptedException;方法会释放锁，让当前线程等待，支持唤醒，支持线程中断
- void awaitUninterruptibly();方法会释放锁，让当前线程等待，支持唤醒，不支持线程中断
- long awaitNanos(longnanosTimeout) throws InterruptedException;参数为纳秒，此方法会释放锁，让当前线程等待，支持唤醒，支持中断。超时之后返回的，结果为负数；超时之前被唤醒返回的，结果为正数（表示返回时距离超时时间相差的纳秒数）
- boolean await(longtime,TimeUnitunit)throws InterruptedException;方法会释放锁，让当前线程等待，支持唤醒，支持中断。超时之后返回的，结果为false；超时之前被唤醒返回的，结果为true
- boolean awaitUntil(Datedeadline)throws InterruptedException;参数表示超时的截止时间点，方法会释放锁，让当前线程等待，支持唤醒，支持中断。超时之后返回的，结果为false；超时之前被唤醒返回的，结果为true
- void signal();会唤醒一个等待中的线程，然后被唤醒的线程会被加入同步队列，去尝试获取锁
- void signalAll();会唤醒所有等待中的线程，将所有等待中的线程加入同步队列，然后去尝试获取锁
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
