juc-09-控制并发流程工具类

signalAll() 和 signal() 区别

• signalAll() 会唤起所有的正在等待的线程
• 但是 signal() 是公平的，只会唤起那个等待时间最长的线程。

Condition与 Object 的 wait, notify, notifyAll 对比：

1. Condition 的 await，signal, singalAll 与 Object 的 wait, notify, notifyAll 都可以实现线程之间的通信，两者在使用上也是非常类似，都需要先获取锁之后才能调用，而不同的是 Object wait,notify 对应的是 synchronized 方式的锁，Condition await，singal 则对应的是 ReentrantLock （实现 Lock 接口的锁对象）对应的锁
2. Condition是通过 Lock接口的 lock.newCondition() 新建一个Condition实例，而且 Lock实例可以新建多个Condition实例

注意： 在执行 Condition 的 await 和 signal 等方法之前，得要先持有condition相关联的 Lock。

简述Conditiond使用步骤：

1. 线程1 持有condition相关联的lock，当要等待某个条件时候，它就去执行 condition.await() 方法，一旦执行了 await() 方法，线程1就会释放当前线程所占用的lock，进入阻塞状态。
2. 通常会有另外一个线程，假设是线程2，抢到condition相关联的lock，去执行对应的条件，直到这个条件达成的时候，线程2就会去执行 condition.signal() 方法，这时JVM就会从被阻塞的线程里找，找到那些等待该 condition 的线程，线程1 如果能够从await()方法返回的话一定是该线程获取了与condition相关联的lock，它的线程状态就会变成 Runnable 可执行状态。

public class ConditionDemo {
    // 可生产的最大数量
    private final int maxCount = 5;
    // 当前已有数量
    private int curCount;
    // lock
    private Lock lock = new ReentrantLock();
    // lock新建一个 notFull 的 Condition，
    // 如果notFull.await()  表示已达到最大生产数量，生产者阻塞等待
    private Condition notFull = lock.newCondition();

    // lock新建一个 notEmpty 的 Condition，
    // 如果notEmpty.await()  表示当前数量为空，消费者阻塞等待
    private Condition notEmpty = lock.newCondition();

    public static void main(String[] args) {
 ConditionDemo demo = new ConditionDemo();
 for (int i = 0; i < 3; i++) {
     Producer producer = new Producer(demo);
     new Thread(producer, "生产者P" + (i+1)).start();
 }
 for (int i = 0; i < 2; i++) {
     Consumer consumer = new Consumer(demo);
     new Thread(consumer, "消费者C" + (i+1)).start();
 }
    }

    
    public void produce() {
 //获取锁
 lock.lock();
 try {
     // 抢到锁
     while (curCount >= maxCount) {
  System.out.println(Thread.currentThread().getName() + "生产已满，等待消费--");
  // notFull.await()  表示已达到最大生产数量，生产者阻塞等待
  this.notFull.await();
     }
     this.curCount++;
     System.out.println(Thread.currentThread().getName() + "生产，当前数量--" + curCount);
     this.notEmpty.signal();
 } catch (InterruptedException e) {
     e.printStackTrace();
 } finally {
     //释放锁
     lock.unlock();
 }
    }

    
    public void consume() {
 //获取锁
 lock.lock();
 try {
     // 抢到锁
     while (curCount <= 0) {
  System.out.println(Thread.currentThread().getName() + "无货消费，等待生产====");
  // notEmpty.await()  表示当前数量为空，消费者阻塞等待
  this.notEmpty.await();
     }
     this.curCount--;
     System.out.println(Thread.currentThread().getName() + "消费，当前剩余数量--" + curCount);
     this.notFull.signal();
 } catch (InterruptedException e) {
     e.printStackTrace();
 } finally {
     //释放锁
     lock.unlock();
 }
    }

}

//生产者
class Producer implements Runnable {
    private ConditionDemo demo;

    public Producer(ConditionDemo demo) {
 this.demo = demo;
    }

    @Override
    public void run() {
 while (true) {

     try {
  // 生产者生产
  this.demo.produce();
  TimeUnit.MILLISECONDS.sleep((long) (Math.random()*1500));//模拟生产耗时
     } catch (InterruptedException e) {
  e.printStackTrace();
     }
 }
    }
}

//消费者
class Consumer implements Runnable {
    private ConditionDemo demo;

    public Consumer(ConditionDemo demo) {
 this.demo = demo;
    }

    @Override
    public void run() {
 while (true) {

     try {
  // 消费者消费
  this.demo.consume();
  TimeUnit.MILLISECONDS.sleep((long) (Math.random()*1000));//模拟消费耗时
     } catch (InterruptedException e) {
  e.printStackTrace();
     }
 }
    }
}

生产者P1生产，当前数量--1
生产者P2生产，当前数量--2
生产者P3生产，当前数量--3
消费者C2消费，当前剩余数量--2
消费者C1消费，当前剩余数量--1
消费者C2消费，当前剩余数量--0
生产者P2生产，当前数量--1
消费者C1消费，当前剩余数量--0
消费者C2无货消费，等待生产====
生产者P3生产，当前数量--1
消费者C2消费，当前剩余数量--0
生产者P1生产，当前数量--1
生产者P3生产，当前数量--2
生产者P2生产，当前数量--3
消费者C1消费，当前剩余数量--2
...