4.1.5ReentrantLock与Condition选择性的唤醒线程

package demo;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
* Created by sunyifeng on 17/10/18.
*/
public class MyService {
private Lock lock = new ReentrantLock();
private Condition conditionA = lock.newCondition();
private Condition conditionB = lock.newCondition();

public void awaitA() {
try {
lock.lock();
System.out.println("awaitA开始等待的时间为：" + System.currentTimeMillis());
conditionA.await();   // FIXME:等同于wait
System.out.println("awaitA结束等待的时间为：" + System.currentTimeMillis());
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
System.out.println("awaitA锁释放了");
}
}

public void awaitB() {
try {
lock.lock();
System.out.println("awaitB开始等待的时间为：" + System.currentTimeMillis());
conditionB.await();   // FIXME:等同于wait
System.out.println("awaitB结束等待的时间为：" + System.currentTimeMillis());
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
System.out.println("awaitB锁释放了");
}
}

public void signalA(){
try {
lock.lock();
System.out.println("开始通知锁A的时间为：" + System.currentTimeMillis());
conditionA.signalAll(); // FIXME:等同于notify
} finally {
lock.unlock();
}
}

public void signalB(){
try {
lock.lock();
System.out.println("开始通知锁B的时间为：" + System.currentTimeMillis());
conditionB.signalAll(); // FIXME:等同于notify
} finally {
lock.unlock();
}
}
}

package demo;

/**
* Created by sunyifeng on 17/10/18.
*/
public class ThreadA extends Thread {
private MyService myService;

public ThreadA(MyService myService) {
super();
this.myService = myService;
}

@Override
public void run() {
super.run();
myService.awaitA();
}
}

package demo;

/**
* Created by sunyifeng on 17/10/18.
*/
public class ThreadB extends Thread {
private MyService myService;

public ThreadB(MyService myService) {
super();
this.myService = myService;
}

@Override
public void run() {
super.run();
myService.awaitB();
}
}

package demo;

/**
* Created by sunyifeng on 17/10/18.
*/
public class Run {
public static void main(String[] args) throws InterruptedException {
MyService myService = new MyService();
ThreadA threadA = new ThreadA(myService);
threadA.setName("A");
threadA.start();
ThreadB threadB = new ThreadB(myService);
threadB.setName("B");
threadB.start();
//
Thread.sleep(3000);
myService.signalA();
}
}

运行结果：

awaitA开始等待的时间为：1508299350742

awaitB开始等待的时间为：1508299350743

开始通知锁A的时间为：1508299353747

awaitA结束等待的时间为：1508299353748

awaitA锁释放了

程序分析：

有两个线程都是等待状态，condition有选择性的唤醒了线程A，线程B仍然处于等待状态。