JUC-how to use blockingQueue(synchronousQueue) to realize Producer consumer model

最新推荐文章于 2023-05-04 15:51:56 发布

原创最新推荐文章于 2023-05-04 15:51:56 发布 · 261 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

java 同时被 2 个专栏收录

89 篇文章

订阅专栏

后端

18 篇文章

订阅专栏

本文通过两个示例介绍了Java中的生产者消费者模式。首先，使用ReentrantLock和Condition实现了一个简单的共享数据类，模拟库存管理。然后，通过SynchronousQueue展示了阻塞队列如何自动管理线程的阻塞和唤醒，实现生产者和消费者的同步。这两个例子展示了在多线程环境下如何有效地控制资源的生产和消费。

only code

tradation Demo

package JavaAdvanced;

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

/**
 * @author 韦海涛
 * @version 1.0
 * @date 4/7/2021 9:40 AM
 */
class ShareData{
    private int number = 0;
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void increment(){
        lock.lock();
        try {
            //生产者
            //如果当前库存不为0时。也就是当前仓库还有存货 则不需要进行生产
            while ( number>=10){
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName()+"\t"+number);
            //通知唤醒
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }

    public void decrement(){
        lock.lock();
        try {
            //消费者
            //如果当前资源为0则等待
            while (number==0){
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName()+"\t"+number);
            //通知唤醒
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }
}
public class ProConsumer_TraditionDemo {
    public static void main(String[] args) {
        ShareData shareData = new ShareData();

        //生产
        new Thread(()->{
            for (int i = 0; i < 100; i++) {
                shareData.increment();
            }
        },"pro").start();

        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        for (int j = 0; j < 10; j++) {
            //消费1
            new Thread(()->{
                for (int i = 0; i < 10; i++) {
                    shareData.decrement();
                }
            },"cust"+j).start();
        }

    }
}

useSynchronousQueueDemo:

package JavaAdvanced;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;

/**
 * @author 韦海涛
 * @version 1.0
 * @date 4/7/2021 8:48 AM
 *
 *  ---对用生产者-消费者模式---
 *  当阻塞队列是空的时候，从队列中获取元素的操作将会被阻塞--商品被卖光了
 *  当阻塞队列是满的时候，往队列里添加元素的操作将会被阻塞--仓库已满
 *
 * 1.阻塞队列
 *  1.1阻塞队列有咩有好的一面
 *      在某些情况会挂起线程，一旦条件满足，被挂起的线程又会被自动唤醒
 *      我们不需要关系什么时候需要阻塞线程，什么时候需要唤醒线程
 *  1.2不得不阻塞.该如何管理
 *      使用blockingQueue
 */
public class BolckingQueueDemo {
    public static void main(String[] args) {

        SynchronousQueue<String> synchronousQueue = new SynchronousQueue<>();
        new Thread(()->{
            try {
                System.out.println(Thread.currentThread().getName()+"\t put 1");
                synchronousQueue.put("1");

                System.out.println(Thread.currentThread().getName()+"\t put 2");
                synchronousQueue.put("2");

                System.out.println(Thread.currentThread().getName()+"\t put 3");
                synchronousQueue.put("3");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"AAAA").start();

        new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(3);

                System.out.println(Thread.currentThread().getName()+"\t take 1");
                System.out.println(Thread.currentThread().getName()+"\t"+synchronousQueue.take());

                System.out.println(Thread.currentThread().getName()+"\t take 2");
                System.out.println(Thread.currentThread().getName()+"\t"+synchronousQueue.take());

                System.out.println(Thread.currentThread().getName()+"\t take 3");
                System.out.println(Thread.currentThread().getName()+"\t"+synchronousQueue.take());
                synchronousQueue.take();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"BBB").start();
   }
}