线程学习之消费者生产者

一种方案：

用synchronize，+flag while判断；在生产者的时候，如果为false则进行生产 ，然后改变false为true，唤醒所有线程；如果为true，则让当前线程进入等待；

在消费者的时候，如果为true 则进行消费，然后改变true为false，唤醒所有线程；如果为false，则让当前线程进入等待；

 

public class Resource   {
    private int count =0;
    private boolean flag =false;
    /**
     *
     */
    public synchronized void create(){
        while(flag){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        count++;
        flag =true;
        System.out.println("生产了 "+count);
        notifyAll();

    }
    public synchronized  void destory(){
        while (!flag){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        flag =false;
        System.out.println("消费了 "+count);
        notifyAll();
    }

2.用ReentrantLock  锁

/**
 * Copyright (C), 2015-2019, XXX有限公司
 * FileName: resource
 * Author:   Administrator
 * Date:     2019/6/21 0021 上午 9:30
 * Description: 消费者生产者的问题
 * History:
 * <author>          <time>          <version>          <desc>
 * 作者姓名           修改时间           版本号              描述
 */
package nettyPra.threadXX.product_consumer;

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

public class Resource   {
    private int count =0;
    private boolean flag =false;
    private ReentrantLock lock =new ReentrantLock();

    //使用lock建立生产者的condition对象
    private Condition condition_pro = lock.newCondition();
    //使用lock建立消费者的condition对象
    private Condition condition_con = lock.newCondition();
    

    /**
     * 使用reentrantLock 实现生产_消费者模式
     */
   public void create_lock(Lock lock){
       try {
           lock.lock();
           while (flag){
               condition_pro.await();
           }
           count++;
           System.out.println("生产者生产 "+count);
           condition_con.signal();
           flag =true;
       } catch (Exception e) {
           e.printStackTrace();
       } finally {
           lock.unlock();
       }

   }

    /**
     * 消费者
     */
   public void  destory_lock(){
       try {
           lock.lock();
           while (!flag){
               condition_con.await();
           }

           System.out.println("消费者消费  "+count);
           condition_pro.signal();
           flag =false;
       } catch (Exception e) {
           e.printStackTrace();
       } finally {
           lock.unlock();
       }
   }
   
}