juc包：使用 juc 包下的显式 Lock 实现线程间通信
一、前置知识
线程间通信三要素：
多线程+判断+操作+通知+资源类。
上面的五个要素，其他三个要素就是普通的多线程程序问题，那么通信就需要线程间的互相通知，往往伴随着何时通信的判断逻辑。
在 java 的 Object 类里就提供了对应的方法来进行通知，同样的，保证安全的判断采用隐式的对象锁，也就是 synchronized 关键字实现。这块内容在：
已经写过。
二、使用 Lock 实现线程间通信
那么，我们知道 juc 包里提供了显式的锁，即 Lock 接口的各种实现类，如果想用显式的锁来实现线程间通信问题，唤醒方法就要使用对应的 Conditon 类的 await 和 signalAll 方法。（这两个方法名字也能看得出来，对应 Object 类的 wait 和 notifyAll）
Condition 对象的获取可以通过具体的 Lock 实现类的对象的 newCondition 方法获得。
public class Communication2 {
public static void main(String[] args) {
Container container = new Container();
new Thread(()->{
for (int i = 0; i < 10; i++){
container.increment();
}
},"生产者1").start();
new Thread(()->{
for (int i = 0; i < 10; i++){
container.decrenment();
}
},"消费者1").start();
new Thread(()->{
for (int i = 0; i < 10; i++){
container.increment();
}
},"生产者2").start();
new Thread(()->{
for (int i = 0; i < 10; i++){
container.decrenment();
}
},"消费者2").start();
new Thread(()->{
for (int i = 0; i < 10; i++){
container.increment();
}
},"生产者3").start();
new Thread(()->{
for (int i = 0; i < 10; i++){
container.decrenment();
}
},"消费者3").start();
}
}
class Container{
private int count = 0;
private Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
public void increment(){
lock.lock();
try {
while (count != 0){
condition.await();
}
count++;
System.out.println(Thread.currentThread().getName() + " "+count);
condition.signalAll();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void decrenment(){
lock.lock();
try{
while (count == 0){
condition.await();
}
count--;
System.out.println(Thread.currentThread().getName()+ " " + count);
condition.signalAll();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
输出也没有任何问题。
这里面我们模拟了 3 个生产者和 3 个消费者，进行对一个资源类，其实就是一个数字 count 的操作，并使用 Condition 类来进行唤醒操作。
从目前代码的用法来看， juc 包的 Lock 接口实现类和之前使用 synchronized + Object 类的线程通信方法是一样的，但是并发包的开发工具给了他更多的灵活性。灵活在哪？
三、唤醒特定线程
新技术解决了旧问题，这个方法解决的问题就是，在生产者消费者问题里：有时候我们并不想唤醒所有的对面伙伴，而只想要唤醒特定的一部分，这时候该怎么办呢？
如果没有显式的 lock，我们的思路可能是：
- 采用一个标志对象，可以是一个数值或者别的；
- 当通信调用 signalAll 的时候，其他线程都去判断这个标志，从而决定自己应不应该工作。
这种实现是可行的，但是本质上其他线程都被唤醒，然后一直阻塞+判断，其实还是在竞争。那么 Condition 类其实就已经提供了对应的方法，来完成这样的操作：
我们看这样一个需求：
- 同样是多线程操作、需要通信。但是我们要指定各个线程交替的顺序，以及指定唤醒的时候是指定哪个具体线程，这样就不会存在唤醒所有线程然后他们之间互相竞争了。
- 具体说是：AA 打印 5 次，BB 打印 10 次， CC 打印 15次，然后接着从 AA 开始一轮三个交替。
代码如下：
public class TakeTurnPrint {
public static void main(String[] args) {
ShareResource resource = new ShareResource();
new Thread(()->{resource.printA();},"A").start();
new Thread(()->{resource.printB();},"B").start();
new Thread(()->{resource.printC();},"C").start();
}
}
/**
* 资源
*/
class ShareResource{
private int signal = 0;//0-A,1-B,2-C
private Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
private Condition condition1 = lock.newCondition();
private Condition condition2 = lock.newCondition();
public void printA(){
lock.lock();
try{
while (signal != 0){
condition.await();//精准
}
for (int i = 0; i < 5; i++){
System.out.println(Thread.currentThread().getName() + " " + i);
}
signal = 1;//精准
condition1.signal();//精准指定下一个
}catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();
}
}
public void printB(){
lock.lock();
try{
while (signal != 1){
condition1.await();//精准
}
for (int i = 0; i < 10; i++){
System.out.println(Thread.currentThread().getName() + " " + i);
}
signal = 2;//精准
condition2.signal();//精准指定下一个
}catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();
}
}
public void printC(){
lock.lock();
try{
while (signal != 2){
condition2.await();//精准
}
for (int i = 0; i < 15; i++){
System.out.println(Thread.currentThread().getName() + " " + i);
}
signal = 0;//精准
condition.signal();//精准指定下一个
}catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();
}
}
}
其中，使用三个 Condition 对象，用一个 signal 的不同值，来通知不同的线程。
