Java并发机制的底层实现原理--Java并发编程的艺术

package pv;

import java.util.*;

public class ProudectAndCoummer {
     //定义一个常量 表示生产者 生产到10会停止生产 等 消费者拿走小于10后 再进行生产
    final static  int MAX_VALUE = 10;
    //将生产出产品 存入到一个 队列中 
   volatile static Queue<String> produceStack  = new LinkedList<>();

    public static void main(String[] args) {

       Thread t1  = new Thread(){
                //生产者
             @Override
             public void run() {


                 while (true){
                     synchronized (produceStack){
                     if(produceStack.size()==MAX_VALUE){
                         try {
                             System.out.println("生产者：已经生产到最大值，线程暂停，等待拿走后再继续生产");
                             produceStack.wait();


                         } catch (InterruptedException e) {
                             e.printStackTrace();
                         }
                     }else {

                             try {
                             //生产者 的sleep 时间为50 消费者为 200 可以转化为，多个消费者对一个生产者的
                                 Thread.sleep(50);
                                 produceStack.add("产品");
                                 System.out.println("生产者：生产一个产品放到队列上，当前有"+produceStack.size()+"个产品");
                                 produceStack.notify();
                             } catch (InterruptedException e) {
                                 e.printStackTrace();
                             }
                         }


                     }


             }

             }
         };
        Thread t2   = new Thread(){
           @Override
           public void run() {

               while (true){

                   synchronized (produceStack){
                   if(produceStack.size()==0){
                       System.out.println("消费者：已经没有产品了通知生产者补货");
                       produceStack.notify();
                   }else {


                           try {
                               Thread.currentThread().sleep(200);
                               System.out.println("消费者：拿走一个货物,当前有"+produceStack.size()+"个产品");
                               produceStack.poll();
                           } catch (InterruptedException e) {
                               e.printStackTrace();
                           }

                       }

                   }

               }



           }
       };
  //两个线程开始运行，因为设置的 循环结束时间为while （true） 因此 理论上达到，两者一直在工作，
  // 生产者 生产产品到10后停止， 等待消费者去消费，当产品为0后 ，消费者唤醒线程因为只有两个线程，抛去主线程，
  // 通知生产者去生产产品
  t1.start();
  t2.start();
    }


控制台输出如下：
消费者：拿走一个货物,当前有3个产品
生产者：生产一个产品放到队列上，当前有3个产品
生产者：生产一个产品放到队列上，当前有4个产品
生产者：生产一个产品放到队列上，当前有5个产品
生产者：生产一个产品放到队列上，当前有6个产品
消费者：拿走一个货物,当前有6个产品
生产者：生产一个产品放到队列上，当前有6个产品
生产者：生产一个产品放到队列上，当前有7个产品
生产者：生产一个产品放到队列上，当前有8个产品
生产者：生产一个产品放到队列上，当前有9个产品
生产者：生产一个产品放到队列上，当前有10个产品
生产者：已经生产到最大值，线程暂停，等待拿走后再继续生产
消费者：拿走一个货物,当前有10个产品
消费者：拿走一个货物,当前有9个产品
消费者：拿走一个货物,当前有8个产品
消费者：拿走一个货物,当前有7个产品

        ReentrantLock r=new ReentrantLock(); //构造方法中添加 Boolean 值，默认为 非公平锁
    //    public ReentrantLock() {
    //    sync = new NonfairSync();
   // }
   
    fnal ReentrantLock lock = this.lock；
    
    
    try{
        //进行的操作 
    
    }
    finally{  //最后使用finally 把锁的所有权释放掉，防止因为 try 捕获到异常，导致锁 无法释放
      lock.unlock（）；
    }
  
   
  // Condition则是将wait、notify、notifyAll等操作转化为相 应的对象，将复杂而晦涩的同步操作转变为直观可控的对象行为。

        Condition condition = r.newCondition(); //通过condition 来使用 锁的状态进一步修饰
        condition.await();
        condition.signal();