前言
在BlockingQueue队列中,每当我们put和take元素时,当队列满时或空时,各自会阻塞,而这个阻塞方用的是Condition接口的await();与我们平时直接用Object的wait方法和notify方法大同小异,我将通过源码和一些例子来分析Condtion用法和它与Object的wait、notify之间的区别和各自的优点。
在JDK源码中有段解释是:
The key property that waiting for a condition provides is that it atomically releases the associated lock and suspends the current thread, just like Object.wait
Condition执行等待(阻塞)方法提供的关键属性是,它会原子地释放相关的锁,并挂起当前线程,就像object.wait一样。
由于Condition是一个接口,而实现这个接口的ConditionObject又是AbstractQueuedLongSynchronizer抽象类的内部类,所以,得到这个ConditionObject实例并不能直接newCondition,而是配合着AbstractQueuedLongSynchronizer方法使用,所以理解这层关系成了理解Condition的关键。
简单用法
下面是模拟Blockqueue写的一个关于Condition的用法,关于BlockQueue,大家可以参考java基础:java.util.concurrent.BlockingQueue,用法与wait和notify类似。
创建一个队列,生产者往队列里put元素,如果队列已满,则阻塞,无法继续添加数据。然后再有一个消费者取数据,每取出一个数据,就用Condition.signal()方法唤醒阻塞方法,让生产者可以继续put元素。
当队列为空时,再取元素就会开成阻塞,当再有生产者往队列里加数据时,也会唤醒取数据的阻塞方法。这样就形成了带阻塞的数据模型。
package com.company.condition;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
/**
* Created by wxwall on 2017/5/31.
*/
public class ConditionDemo {
public static void main(String[] args) throws InterruptedException {
//创建一个队列
Queue queue = new Queue(3);
//创建一个生产者,往队列里put数据
Produce produce = new Produce(queue);
Thread t = new Thread(produce);
t.start();
//Thread.sleep(3000);
//创建一个消费者,用来取数据
Consumer consumer = new Consumer(queue);
Thread t1 = new Thread(consumer);
t1.start();
}
static class Produce implements Runnable{
Queue q = null;
public Produce(Queue queue){
this.q = queue;
}
@Override
public void run() {
try {
long begin = System.currentTimeMillis();
for (int i = 0;i<10;i++){
q.put(new String("aa"));
q.put(new String("bb"));
q.put(new String("cc"));
}
System.out.println("耗时:" + (System.currentTimeMillis() - begin));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
static class Consumer implements Runnable{
Queue q = null;
public Consumer(Queue queue){
this.q = queue;
}
@Override
public void run() {
try {
for (int i = 0 ;i<10;i ++){
Object obj1 = q.take();
Object obj2 = q.take();
Object obj3 = q.take();
System.out.println((String)obj1.toString() + " " + (String)obj2.toString() + " " + (String)obj3.toString());
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
/**
* 创建一个简单的数组队列
*/
private static class Queue {
ReentrantLock lock = new ReentrantLock();
Condition condition = lock.newCondition();
Object obj [] = null;
private int size = 0;
private int consInt = 0;
public Queue(Integer obj){
this.obj = new Object[obj];
}
//往队列里加数据
public void put(Object obj) throws InterruptedException {
//获得锁
lock.lock();
try {
if(size > this.obj.length -1){
//如果队列满了就阻塞
condition.await();
}
this.obj[size] = obj;
size ++;
//如果队列空了,添加元素后要通知take,唤醒condition
condition.signal();
}finally {
lock.unlock();
}
}
public Object take(){
lock.lock();
try{
if(size == 0 ){
try {
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
Object obj = this.obj[size - 1];
size --;
condition.signal();
return obj;
}finally {
lock.unlock();
}
}
}
}
执行结果(因为没有用链表实现队列,所以结果并不是FIFO形式)
cc bb aa
cc bb aa
cc bb aa
cc bb aa
cc bb aa
cc bb aa
aa aa cc
cc bb bb
cc bb aa
cc bb aa
耗时:1
另外注意的一点是,BlockingQueue的实现ArrayBlockingQueue的put方法和take方法,分别用的是两个不同的condition实例,源码如下:
/** Condition for waiting takes */
private final Condition notEmpty;
/** Condition for waiting puts */
private final Condition notFull;
上面代码模型如图所示:
Paste_Image.png下面用实现一个简单的wait、notify模型
package com.company.condition;
import java.util.concurrent.locks.Condition;
/**
* Created by wxwall on 2017/5/29.
*/
public class ConditionTest {
public static void main(String[] args) throws InterruptedException {
Condition condition;
Integer a = 2;
Thread t1 = new Thread(new ThreadCondition(a));
Thread t2 = new Thread(new ThreadCondition(a));
t1.start();
t2.start();
}
public static class ThreadCondition implements Runnable{
Integer a = 0;
public ThreadCondition(Integer a){
this.a = a;
}
@Override
public void run() {
try {
int i = 0;
while(i < 3){
synchronized (a){
a.notify();
System.out.println(Thread.currentThread().getName());
a.wait();
System.out.println("wait被唤醒");
}
i++;
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
下面是输出结果:
Thread-0
Thread-1
wait被唤醒
Thread-0
wait被唤醒
Thread-1
wait被唤醒
Thread-0
wait被唤醒
Thread-1
wait被唤醒
与notify、wait方法的区别
Condition 将 Object 监视器方法(wait、notify 和 notifyAll)分解成截然不同的对象,以便通过将这些对象与任意 Lock 实现组合使用,为每个对象提供多个等待 set (wait-set)。其中,Lock 替代了 synchronized 方法和语句的使用,Condition 替代了 Object 监视器方法的使用。
在同一个monitor中Conditioin可以存在多个实例,在生产者和消费者模型里比较常见。
而wait,notify和notifyAll必须在同步块或者同步方法中进行(synchronized块或者synchronized方法)
-
wait()、notify()和notifyAll()方法是本地方法,并且为final方法,无法被重写。
-
调用某个对象的wait()方法能让当前线程阻塞,并且当前线程必须拥有此对象的monitor(即锁)
-
调用某个对象的notify()方法能够唤醒一个正在等待这个对象的monitor的线程,如果有多个线程都在等待这个对象的monitor,则只能唤醒其中一个线程;
-
调用notifyAll()方法能够唤醒所有正在等待这个对象的monitor的线程;
JDK原文整理如下
Condition 实现可以提供不同于 Object 监视器方法的行为和语义,比如受保证的通知排序,或者在执行通知时不需要保持一个锁。如果某个实现提供了这样特殊的语义,则该实现必须记录这些语义。
注意,Condition 实例只是一些普通的对象,它们自身可以用作 synchronized 语句中的目标,并且可以调用自己的 wait 和 notification 监视器方法。获取 Condition 实例的监视器锁或者使用其监视器方法,与获取和该 Condition 相关的 Lock或使用其 waiting和 signalling 方法没有什么特定的关系。为了避免混淆,建议除了在其自身的实现中之外,切勿以这种方式使用 Condition 实例。
为何这三个不是Thread类声明中的方法,而是Object类中声明的方法(当然由于Thread类继承了Object类,所以Thread也可以调用者三个方法)?
由于每个对象都拥有monitor(即锁),所以让当前线程等待某个对象的锁,当然应该通过这个对象来操作了。而不是用当前线程来操作,因为当前线程可能会等待多个线程的锁,如果通过线程来操作,就非常复杂了。
网友评论