【多线程和并发】生产者/消费者问题的多种实现方式

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接： https://blog.csdn.net/Soldier49Zed/article/details/102680891

一、用阻塞队列实现

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingDeque;

/**
 * @Author: Soldier49Zed
 * @Date: 2019/10/22 13:35
 * @Description:
 */

//Producer Class in Java
class Producer implements Runnable {
    private final BlockingQueue sharedQueue;

    public Producer(BlockingQueue sharedQueue) {
        this.sharedQueue = sharedQueue;
    }

    @Override
    public void run() {
        for (int i = 0;i < 10;i++){
            try {
                System.out.println("Produced: " + i);
                sharedQueue.put(i);
            }catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
}

//Consumer Class in Java
class Consumer implements Runnable{

    private final BlockingQueue sharedQueue;

    public Consumer(BlockingQueue sharedQueue) {
        this.sharedQueue = sharedQueue;
    }

    @Override
    public void run() {
        while (true){
            try {
                int i = (Integer) sharedQueue.take();
                System.out.println("Consumed: " + i);
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
}

public class ProducerConsumerPattern {
    public static void main(String[] args) {
        //Creating shared object
        BlockingQueue sharedQueue = new LinkedBlockingDeque();

        //Creating Producer and Consumer  Thread
        Thread prodThread = new Thread(new Producer(sharedQueue));
        Thread consThread = new Thread(new Consumer(sharedQueue));

        //Starting producer and Consumer thread
        prodThread.start();
        consThread.start();
    }
}

二、使用Object的wait()和notify()实现

PriorityQueue<Integer> queue = new PriorityQueue<Integer>(10);//充当缓冲区


    class Consumer extends Thread {
        @Override
        public void run() {
            while (true) {
                synchronized (queue) {
                    while (queue.size() == 0) { //队列空的条件下阻塞
                        try {
                            queue.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                            queue.notify();
                        }
                    }
                    queue.poll();//每次移走队首元素
                    queue.notify();
                }
            }
        }
    }

    class Producer extends Thread {
        @Override
        public void run() {
            while (true) {
                synchronized (queue) {
                    while (queue.size() == 10) {//队列满了的条件下阻塞
                        try {
                            queue.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                            queue.notify();
                        }
                    }
                    queue.offer(1);//每次插入一个元素
                    queue.notify();
                }
            }
        }
    }

三、使用Condition实现

    private PriorityQueue<Integer> queue = new PriorityQueue<Integer>(10);
    private Lock lock = new ReentrantLock();
    private Condition notFull = lock.newCondition();
    private Condition notEmpty = lock.newCondition();
    
    class Consumer extends Thread{
        @Override
        public void run() {
            while (true){
                lock.lock();
                try{
                    while (queue.size() == 0){
                        try{
                            notEmpty.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    queue.poll();//每次移走队首元素
                    notFull.signal();
                }finally {
                    lock.unlock();
                }
            }
        }
    }
    
    class Producer extends Thread{
        @Override
        public void run() {
            while (true){
                lock.lock();
                try {
                    while (queue.size() == 10){
                        try{
                            notFull.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    queue.offer(1);//每次插入一个元素
                    notEmpty.signal();
                }finally {
                    lock.unlock();
                }
            }
        }
    }