java condition 例子_java condition学习

Condition是在java 1.5中才出现的，它用来替代传统的Object的wait()、notify()实现线程间的协作，相比使用Object的wait()、notify()，使用Condition1的await()、signal()这种方式实现线程间协作更加安全和高效。

为啥更安全和高效呢？

简单说，他的作用是使得某些线程一起等待某个条件(Condition)，只有当该条件具备(signal 或者 signalAll方法被调用)时，这些等待线程才会被唤醒，从而重新争夺锁。

感觉就是说这个线程，它原来是想要获取这个锁的，但是时机未到， 先不去抢这个锁，然后时机到了，就去抢锁了。

Condition是个接口，基本的方法就是await()和signal()方法；

它的实现是哪个呢？AbstractQueuedSynchronizer里面的ConditionObject

Condition依赖于Lock接口，生成一个Condition的基本代码是lock.newCondition()

调用Condition的await()和signal()方法，都必须在lock保护之内，就是说必须在lock.lock()和lock.unlock之间才可以使用

Conditon中的await()对应Object的wait()；

Condition中的signal()对应Object的notify()；

Condition中的signalAll()对应Object的notifyAll()。

Object里面的这个wait(),这个notify(),这个notifyAll()怎么使用呢？

例子：

package com.study.controller;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.ReentrantLock;

public class TestCondition {

public static void main(String[] args) {

final ReentrantLock reentrantLock = new ReentrantLock();

final Condition condition = reentrantLock.newCondition();

new Thread(new Runnable() {

@Override

public void run() {

reentrantLock.lock();

System.out.println(Thread.currentThread().getName() + "拿到锁了");

System.out.println(Thread.currentThread().getName() + "等待信号");

try {

condition.await();

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + "拿到信号");

System.out.println(Thread.currentThread().getName() + "释放锁");

reentrantLock.unlock();

}

}, "线程1").start();

new Thread(new Runnable() {

@Override

public void run() {

reentrantLock.lock();

System.out.println(Thread.currentThread().getName() + "拿到锁了");

try {

System.out.println(Thread.currentThread().getName() + "拿到锁后，sleep 3000");

Thread.sleep(3000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + "发出信号");

condition.signalAll();

try {

Thread.sleep(3000);

System.out.println(Thread.currentThread().getName() + "发出信后，sleep 3000");

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + "释放锁");

reentrantLock.unlock();

}

}, "线程2").start();

}

}

image.png

结果是线程1先拿到锁，然后await(await会释放锁)了，线程2就能获取到锁了，

线程2signalAll了后，又sleep了3s，然后释放锁，线程1在线程2释放锁之后才

拿到信号，说明signalAll(所有线程都能在锁被释放后，拿到这个锁)后，别的线程需要在这个锁完全空出来之后，才能拿到这个信号(就是拿到了这个锁),然后去获取这个锁。

假设把线程2的condition.signalAll();删除掉，线程1就拿不到锁了。

如果有三个线程，两个线程拿到锁之后await，最后一个线程拿到锁之后notify一下，释放锁，那么await的两个线程，只会有一个线程拿到锁，另外一个线程就会惨惨的等着notify。

public interface Condition {

//使当前线程加入 await() 等待队列中，并释放当锁，当其他线程调用signal()会重新请求锁。与Object.wait()类似。

void await() throws InterruptedException;

//调用该方法的前提是，当前线程已经成功获得与该条件对象绑定的重入锁，否则调用该方法时会抛出IllegalMonitorStateException。

//调用该方法后，结束等待的唯一方法是其它线程调用该条件对象的signal()或signalALL()方法。等待过程中如果当前线程被中断，该方法仍然会继续等待，同时保留该线程的中断状态。

void awaitUninterruptibly();

// 调用该方法的前提是，当前线程已经成功获得与该条件对象绑定的重入锁，否则调用该方法时会抛出IllegalMonitorStateException。

//nanosTimeout指定该方法等待信号的的最大时间(单位为纳秒)。若指定时间内收到signal()或signalALL()则返回nanosTimeout减去已经等待的时间；

//若指定时间内有其它线程中断该线程，则抛出InterruptedException并清除当前线程的打断状态；若指定时间内未收到通知，则返回0或负数。

long awaitNanos(long nanosTimeout) throws InterruptedException;

//与await()基本一致，唯一不同点在于，指定时间之内没有收到signal()或signalALL()信号或者线程中断时该方法会返回false;其它情况返回true。

boolean await(long time, TimeUnit unit) throws InterruptedException;

//适用条件与行为与awaitNanos(long nanosTimeout)完全一样，唯一不同点在于它不是等待指定时间，而是等待由参数指定的某一时刻。

boolean awaitUntil(Date deadline) throws InterruptedException;

//唤醒一个在 await()等待队列中的线程。与Object.notify()相似

void signal();

//唤醒 await()等待队列中所有的线程。与object.notifyAll()相似

void signalAll();

}