- Lock/Condition：使用Lock/Condition实现线程同步，与wait()/notify()方法不同的是，Condition对象可以创建多个，一个Lock对象可以对应多个Condition对象。生产者和消费者线程共同对应一个Lock对象，当共享队列为空时，消费者线程调用Condition对象的await()方法阻塞自己，当有新数据加入时，生产者线程调用Condition对象的signal()方法唤醒一个消费者线程。

- Semaphore：Semaphore是一种计数信号量，可用于控制同时访问共享资源的线程数。当一个线程访问共享资源时，它需要获取一个许可证，如果许可证不可用，则线程将被阻塞。Semaphore可以用来实现生产者消费者模型，当共享队列为空时，消费者线程获取不到许可证，会被阻塞，当有新数据加入时，生产者线程释放一个许可证，唤醒一个消费者线程。

除了以上三种线程同步机制以外，还有很多方法都可以用于实现生产者消费者模型，具体使用哪种，可以根据实际情况选择。

四、代码实现

本文将使用wait()/notify()方法来实现生产者消费者模型（笔者知道这是最简单的，没办法，谁让这个省事呢，别骂了别骂了QAQ）

4.1先创建一个Storage类实现缓冲区


/**
 * 对应生产者消费者模型中的缓冲区
 *
 * @date: 2023/8/4
 */
public class Storage {
    private int mMaxCount=20;
    private int mCount=0;
 
    /**
     * @description 生产商品，同步方法，注意synchronized关键字
     * @time 2023/8/4 14:25
     */
    public synchronized void produce(){
        // 判断缓冲区里数据是否达到最大值
        // 达到最大值则需要发出提示并令当前线程wait
        while(mCount==mMaxCount){
            // 线程wait操作注意捕获InterruptedException
            try {
                System.out.println("库存已经满了，停止生产");
                this.wait();
            } catch (InterruptedException e) {
                System.out.println(e.getMessage());
                throw new RuntimeException(e);
            }
        }
        // 生产产品，产品数量加1
        mCount++;
        System.out.println("生产线程"+Thread.currentThread().getName()+"生产了一件产品" +
                "，当前库存数量："+mCount);
        // 唤醒其它处于wait的线程
        // 要注意notify方法执行后不会立即释放对象锁，而是在当前synchronized代码块
        // 执行完毕之后才释放（虽然该方法中notify后面没有语句了)
        this.notifyAll();
    }
 
    /**
     * @description 消耗商品，同步方法，注意synchronized关键字
     *        take方法基本可以说就是produce相反的实现，看懂produce这个就很好理解
     * @time 2023/8/4 14:32
     */
    public synchronized void take(){
        // 判断当前数据是否为0
        // 为0则需要发出提示并令当前线程wait
        while (mCount==0){
            try {
                System.out.println("库存为0，停止消耗");
                this.wait();
            } catch (InterruptedException e) {
                System.out.println(e.getMessage());
                throw new RuntimeException(e);
            }
        }
        mCount--;
        System.out.println("消耗线程"+Thread.currentThread().getName()+"消耗了一件产品" +
                ",当前库存数量："+mCount);
        this.notifyAll();
    }
}

4.2再创建生产者和消费者类


/**
 * 生产者类
 * @date: 2023/8/4
 */
public class Producer implements Runnable{
    private Storage mStorage;
    public Producer(Storage storage) {
        mStorage = storage;
    }
 
    @Override
    public void run() {
        while(true){
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                System.out.println(e.getMessage());
                throw new RuntimeException(e);
            }
            // 调用Storage类里的produce方法实现生产产品功能
            mStorage.produce();
        }
    }
}
 
 
 
 
/**
 * 消费者类
 * @date: 2023/8/4
 */
public class Consumer implements Runnable{
    private Storage mStorage;
 
    public Consumer(Storage storage) {
        mStorage = storage;
    }
 
    @Override
    public void run() {
        while (true){
            try {
                Thread.sleep(700);
            } catch (InterruptedException e) {
                System.out.println(e.getMessage());
                throw new RuntimeException(e);
            }
            // 调用Storage类里的take方法实现消耗产品功能
            mStorage.take();
        }
    }
}

4.3在主函数中开始执行


public class MySynTest {
    public static void main(String[] args) {
        Storage mStorage=new Storage();
        Producer mProducer=new Producer(mStorage);
        Consumer mConsumer=new Consumer(mStorage);
 
        // 分别新建三个生产者线程和消费者线程
        Thread producer1=new Thread(mProducer,"Producer1");
        Thread producer2=new Thread(mProducer,"Producer2");
        Thread producer3=new Thread(mProducer,"Producer3");
 
        Thread consumer1=new Thread(mConsumer,"Consumer1");
        Thread consumer2=new Thread(mConsumer,"Consumer2");
        Thread consumer3=new Thread(mConsumer,"Consumer3");
 
        producer1.start();
        producer2.start();
        producer3.start();
        consumer1.start();
        consumer2.start();
        consumer3.start();
    }
}

4.4代码执行结果

截取了部分运行结果如下所示：

可以看出，代码成功实现了生产者消费者模型，并没有出现数据竞争和缓冲区数据溢出的现象。

五、要点解析

5.1用while而不是if

关于produce方法和take方法中，判断缓冲区数据是否溢出或为0时，为什么要用while而不是常用的条件判断语句if，网络上有很多解答，笔者在这里只谈谈自己的一点浅显的理解，有不当之处还望包涵。


 
        // 关键代码在这
        while(mCount==mMaxCount){
            // 线程wait操作注意捕获InterruptedException
            try {
                System.out.println("库存已经满了，停止生产");
                this.wait();
            } catch (InterruptedException e) {
                System.out.println(e.getMessage());
                throw new RuntimeException(e);
            }
        }

理解这个问题之前，首先要明确，当线程执行了wait方法，然后被其它线程通过notify唤醒后，是会继续执行wait方法后面的语句的；知道这个前提后我们再来分析此处为何要用while而不是if

从上图中可以看出，使用while时，wait方法执行后还需要再次判断一下while中的条件，而使用if时，wait方法执行完成后直接进入了后面的mCount++语句。

在当前线程处于等待状态期间，若有其它生产线程进行了mCount++操作导致产品数量恰好达到了最大值，使用while的线程会再次判断该条件并停止生产，而使用if的线程则由于没有再次判断该条件会继续生产产品，导致缓冲区数据溢出。这也就是为什么此处需要使用while而不是if作为条件pan

5.2关于sleep的说明

wait方法和sleep方法的区别网络上有很多介绍的，大致意思是：sleep方会令当前线程休眠，释放CPU资源但并不释放锁，此时其他线程无法访问该对象；而wait方法则会令当前线程进入阻塞状态并释放锁，此时其它处于就绪状态线程会竞争该锁。

但是上面的前提在于sleep方法要写在synchronized代码块里面才有上述作用，写在synchronized代码块外面的时候，sleep就和锁没什么关系了，单纯只是让当前线程休眠指定时间，其他线程此时可以访问当前对象。

比如这里producer和comsumer类里面的Thread.sleep就只是让线程休眠一段时间，用来模拟生产（或消耗）产品所需的时间，并不涉及到对锁的控制。


while(true){
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                System.out.println(e.getMessage());
                throw new RuntimeException(e);
            }
            // 调用Storage类里的produce方法实现生产产品功能
            mStorage.produce();
        }

六、后记

本文实现java生产者消费者模型的方式比较简单，用到了最基础的wait和notify方法，其它更加复杂一些的实现方式笔者也还在学习中，读者可以先自行探索。

笔者萌新一枚，如有错漏之处还望多多包涵。

本文参考文章如下：

经典并发同步模式：生产者-消费者设计模式 - 知乎

【Java】生产者消费者模式的实现_Mlib的博客-CSDN博客

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Cpp五条/article/detail/661640