package com.lock.condition.test;
import java.util.LinkedList;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class LockConditionTest {
  // 生產 和 消費 的最大總數
  public static int totalCount = 10;
  // 已經生產的產品數
  public static volatile int hasProduceCount = 0;
  // 已經消費的產品數
  public static volatile int hasConsumeCount = 0;
  // 容器最大容量
  public static int containerSize = 3;
  // 使用公平策略的可重入鎖，便于觀察演示結果
  public static ReentrantLock lock = new ReentrantLock(true);
  public static Condition notEmpty = lock.newCondition();
  public static Condition notFull = lock.newCondition();
  // 容器
  public static LinkedList<integer> container = new LinkedList<integer>();
  // 用于標識產品
  public static AtomicInteger idGenerator = new AtomicInteger();
  public static void main(String[] args) {
    Thread p1 = new Thread(new Producer(), "p-1");
    Thread p2 = new Thread(new Producer(), "p-2");
    Thread p3 = new Thread(new Producer(), "p-3");
    Thread c1 = new Thread(new Consumer(), "c-1");
    Thread c2 = new Thread(new Consumer(), "c-2");
    Thread c3 = new Thread(new Consumer(), "c-3");
    c1.start();
    c2.start();
    c3.start();
    p1.start();
    p2.start();
    p3.start();
    try{
      c1.join();
      c2.join();
      c3.join();
      p1.join();
      p2.join();
      p3.join();
    }catch(Exception e){
    }
    System.out.println(" done. ");
  }
  static class Producer implements Runnable{
    @Override
    public void run() {
      while(true){
        lock.lock();
        try{
          // 容器滿了，需要等待非滿條件
          while(container.size() >= containerSize){
            notFull.await();
          }
          // 到這里表明容器未滿，但需要再次判斷是否已經完成了任務
          if(hasProduceCount >= totalCount){
            System.out.println(Thread.currentThread().getName()+" producer exit");
            return ;
          }
          int product = idGenerator.incrementAndGet();
          // 把生產出來的產品放入容器
          container.addLast(product);
          System.out.println(Thread.currentThread().getName() + " product " + product);
          hasProduceCount++;
          // 通知消費線程可以去消費了
          notEmpty.signal();
        } catch (InterruptedException e) {
        }finally{
          lock.unlock();
        }
      }
    }
  }
  static class Consumer implements Runnable{
    @Override
    public void run() {
      while(true){
        lock.lock();
        try{
          if(hasConsumeCount >= totalCount){
            System.out.println(Thread.currentThread().getName()+" consumer exit");
            return ;
          }
          // 一直等待有產品了，再繼續(xù)往下消費
          while(container.isEmpty()){
            notEmpty.await(2, TimeUnit.SECONDS);
            if(hasConsumeCount >= totalCount){
              System.out.println(Thread.currentThread().getName()+" consumer exit");
              return ;
            }
          }
          Integer product = container.removeFirst();
          System.out.println(Thread.currentThread().getName() + " consume " + product);
          hasConsumeCount++;
          // 通知生產線程可以繼續(xù)生產產品了
          notFull.signal();
        } catch (InterruptedException e) {
        }finally{
          lock.unlock();
        }
      }
    }
  }
}

p-1 product 1
p-3 product 2
p-2 product 3
c-3 consume 1
c-2 consume 2
c-1 consume 3
p-1 product 4
p-3 product 5
p-2 product 6
c-3 consume 4
c-2 consume 5
c-1 consume 6
p-1 product 7
p-3 product 8
p-2 product 9
c-3 consume 7
c-2 consume 8
c-1 consume 9
p-1 product 10
p-3 producer exit
p-2 producer exit
c-3 consume 10
c-2 consumer exit
c-1 consumer exit
p-1 producer exit
c-3 consumer exit
 done.