Java多线程-Condition

Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set（wait-set）。其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。先看一个关于Condition使用的简单实例：public class ConditionTest {
public static void main（String[] args） {
final Lock lock = new ReentrantLock（）;
final Condition condition = lock.newCondition（）;

Thread thread1 = new Thread（new Runnable（） {
@Override
public void run（） {
try {
lock.lock（）;
System.out.println（"我需要等一个信号"+this）;
condition.await（）;
System.out.println（"我拿到一个信号"+this）;
} catch （Exception e） {
// TODO: handle exception
} finally{
lock.unlock（）;
}

}
}, "thread1"）;
thread1.start（）;
Thread thread2 = new Thread（new Runnable（） {
@Override
public void run（） {
try {
lock.lock（）;
System.out.println（"我拿到了锁"）;
Thread.sleep（500）;
System.out.println（"我发出一个信号"）;
condition.signal（）;
} catch （Exception e） {
// TODO: handle exception
} finally{
lock.unlock（）;
}

}
}, "thread2"）;
thread2.start（）;
}
}运行结果：1 我需要等一个信号com.luchao.traditionalthread.ConditionTest$1@10bc3c9
2 我拿到了锁
3 我发出一个信号
4 我拿到一个信号com.luchao.traditionalthread.ConditionTest$1@10bc3c9可以看到，Condition的执行方式，是当在线程1中调用await方法后，线程1将释放锁，并且将自己沉睡，等待唤醒，线程2获取到锁后，开始做事，完毕后，调用Condition的signal方法，唤醒线程1，线程1恢复执行。以上说明Condition是一个多线程间协调通信的工具类，使得某个，或者某些线程一起等待某个条件（Condition）,只有当该条件具备（ signal 或者 signalAll方法被带调用）时，这些等待线程才会被唤醒，从而重新争夺锁。Condition与传统线程通信有些类似，它的使用更广，可以将多个线程进行通信，以完成更加复杂的通信。用Condition替换传统线程通信，在前面的传统有一个子线程和主线程交替运行50次的实例，使用Condition也可以完成。代码如下：public class ConditionCommuniction {
public static void main（String[] args） {
final Business business = new Business（）;
new Thread（new Runnable（） {
@Override
public void run（） {
for （int i = 0; i < 50; i++） {
business.sub（i）;
}
}
}）.start（）;
for （int i = 0; i < 50; i++） {
business.main（i）;
}
}

static class Business{
private Lock lock = new ReentrantLock（）;
private boolean isMain = true;
private Condition condition = lock.newCondition（）;
public void main（int i）{
lock.lock（）;
try {
while（！isMain）{
condition.await（）;
}
for （int j = 0; j < 100; j++） {
System.out.println（"main is looping :" + j +" in " + i）;
}
isMain = false;
condition.signal（）;
} catch （Exception e） {
// TODO: handle exception
} finally{
lock.unlock（）;
}
}
public void sub（int i）{
lock.lock（）;
try {
while（isMain）{
condition.await（）;
}
for （int j = 0; j < 10; j++） {
System.out.println（"sub is looping :" + j +" in " + i）;
}
isMain = true;
condition.signal（）;
} catch （Exception e） {
// TODO: handle exception
} finally{
lock.unlock（）;
}
}
}
}在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（）;
}
}
}这就是多个Condition的强大之处，假设缓存队列中已经存满，那么阻塞的肯定是写线程，唤醒的肯定是读线程，相反，阻塞的肯定是读线程，唤醒的肯定是写线程，那么假设只有一个Condition会有什么效果呢，缓存队列中已经存满，这个Lock不知道唤醒的是读线程还是写线程了，如果唤醒的是读线程，皆大欢喜，如果唤醒??是写线程，那么线程刚被唤醒，又被阻塞了，这时又去唤醒，这样就浪费了很多时间。将上面主线程和子线程交替运行的程序进行扩展，三个线程交替运行，代码如下：public class ThreeConditionCommunication {
public static void main（String[] args） {
final Business business = new Business（）;
new Thread（new Runnable（） {

@Override
public void run（） {
for （int i = 0; i < 50; i++） {
business.sub1（i）;
}
}
}）.start（）;
new Thread（new Runnable（） {

@Override
public void run（） {
for （int i = 0; i < 50; i++） {
business.sub2（i）;
}
}
}）.start（）;
for （int i = 0; i < 50; i++） {
business.main（i）;
}
}
static class Business{
Lock lock = new ReentrantLock（）;
Condition main = lock.newCondition（）;
Condition sub1 = lock.newCondition（）;
Condition sub2 = lock.newCondition（）;
int runNum = 1;

public void main（int i）{
lock.lock（）;
try {
while（runNum！=1）{
main.await（）;//主线程等待
}
for （int j = 0; j < 100; j++） {
System.out.println（"main is looping of "+j+" in "+i）;
}
runNum = 2;
sub1.signal（）;//唤醒子线程1
} catch （Exception e） {
// TODO: handle exception
} finally{
lock.unlock（）;
}
}
public void sub1（int i）{
lock.lock（）;
try {
while（runNum！=2）{
sub1.await（）;//子线程1等待
}
for （int j = 0; j < 10; j++） {
System.out.println（"sub1 is looping of "+j+" in "+i）;
}
runNum = 3;
sub2.signal（）;//唤醒子线程2
} catch （Exception e） {
// TODO: handle exception
} finally{
lock.unlock（）;
}
}
public void sub2（int i）{
lock.lock（）;
try {
while（runNum！=3）{
sub2.await（）;//子线程2等待
}
for （int j = 0; j < 20; j++） {
System.out.println（"sub2 is looping of "+j+" in "+i）;
}
runNum = 1;
main.signal（）;//唤醒主线程
} catch （Exception e） {
// TODO: handle exception
} finally{
lock.unlock（）;
}
}
}
}由此可见，Condition在多线程通信的强大作用，可以大大提高程序效率。本文永久更新链接地址：http://www.linuxidc.com/Linux/2016-02/128683.htm