三种方式实现生产者和消费者模式

朴灿烈づ我的快乐病毒、 2022-05-31 03:11 216阅读 0赞

## 方式一：同步关键字实现 ##

//用同步实现wait/notifyAll
    public class Stroge {
        private LinkedList<String> list;
        private int maxSize;
    
        public Stroge(LinkedList<String> list, int maxSize) {
            this.list = list;
            this.maxSize = maxSize;
        }
    
        public void produce() {
            try {
                synchronized (list) {
                    while (list.size() == maxSize) {
                        list.wait();
                    }
                    list.add("生产一个任务");
                    System.out.println(Thread.currentThread().getName() + "生产一个");
                    list.notifyAll();
                }
            } catch (InterruptedException e) {
            }
        }
    
        public String consume() {
    
            try {
                synchronized (list) {
                    while (list.size() == 0) {
                        list.wait();
                    }
                    String consume = list.remove();
                    System.out.println(Thread.currentThread().getName() + "消费一个");
                    list.notifyAll();
                    return consume;
                }
            } catch (InterruptedException e) {
                return null;
            }
        }
    
        public static void main(String[] args) {
            LinkedList<String> linkedList = new LinkedList<>();
    
            Stroge stroge = new Stroge(linkedList, 10);
            Consumer consumer1 = new Consumer(stroge);
            Consumer consumer2 = new Consumer(stroge);
            Producer producer1 = new Producer(stroge);
            Producer producer2 = new Producer(stroge);
            Thread consumerThread1 = new Thread(consumer1);
            Thread consumerThread2 = new Thread(consumer2);
            Thread produceThread1 = new Thread(producer1);
            Thread produceThread2 = new Thread(producer2);
            consumerThread1.start();
            consumerThread2.start();
            produceThread1.start();
            produceThread2.start();
    
    
        }
    }
    
    class Producer implements Runnable {
    
        private Stroge stroge;
    
        public Producer(Stroge stroge) {
            this.stroge = stroge;
        }
    
        public void run() {
            while (true) {
                stroge.produce();
            }
        }
    
    }
    
    class Consumer implements Runnable {
        private Stroge stroge;
    
        public Consumer(Stroge stroge) {
            this.stroge = stroge;
        }
    
        public void run() {
            while (true) {
                stroge.consume();
            }
        }
    
    }

## 方式二：锁实现 ##

//锁实现
    public class Stroge {
        private ReentrantLock lock = new ReentrantLock();
        private Condition full = lock.newCondition();
        private Condition empty = lock.newCondition();
        private LinkedList<String> list;
        private int maxSize;
    
        public Stroge(LinkedList<String> list, int maxSize) {
            this.list = list;
            this.maxSize = maxSize;
        }
    
        public void produce() {
            try {
                lock.lock();
                //满了则则阻塞
                while (list.size() == maxSize) {
                    full.await();
                }
                list.add("生产一个任务");
                System.out.println(Thread.currentThread().getName() + "生产一个");
                empty.signal();
    
            } catch (InterruptedException r) {
    
            } finally {
                lock.unlock();
            }
        }
    
        public String consume() {
            try {
                lock.lock();
                //为空则阻塞
                while (list.size() == 0) {
                    empty.await();
                }
                String consume = list.remove();
                System.out.println(Thread.currentThread().getName() + "消费一个");
                full.signal();
                return consume;
            } catch (InterruptedException e) {
                return null;
            } finally {
                lock.unlock();
            }
    
        }
    
        public static void main(String[] args) {
            LinkedList<String> linkedList = new LinkedList<>();
            Stroge stroge = new Stroge(linkedList, 10);
            Consumer consumer1 = new Consumer(stroge);
            Consumer consumer2 = new Consumer(stroge);
            Producer producer1 = new Producer(stroge);
            Producer producer2 = new Producer(stroge);
            Thread consumerThread1 = new Thread(consumer1);
            Thread consumerThread2 = new Thread(consumer2);
            Thread produceThread1 = new Thread(producer1);
            Thread produceThread2 = new Thread(producer2);
            consumerThread1.start();
            consumerThread2.start();
            produceThread1.start();
            produceThread2.start();
    
        }
    }
    
    class Producer implements Runnable {
    
        private Stroge stroge;
    
        public Producer(Stroge stroge) {
            this.stroge = stroge;
        }
    
        public void run() {
            while (true) {
                stroge.produce();
            }
        }
    
    }
    
    class Consumer implements Runnable {
        private Stroge stroge;
    
        public Consumer(Stroge stroge) {
            this.stroge = stroge;
        }
    
        public void run() {
            while (true) {
                stroge.consume();
            }
        }
    
    }

## 方式三：阻塞队列实现 ##

public class Stroge {
        private LinkedBlockingQueue<String> queue = new LinkedBlockingQueue<>(10);
    
        public void produce() {
            try {
                //满了则会阻塞
                queue.put("生产了一个任务");
                System.out.println(Thread.currentThread().getName() + "生产一个");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
        }
    
        public String consume() {
            try {
                //空了则会阻塞
                String consume = queue.take();
                System.out.println(Thread.currentThread().getName() + "消费一个");
                return consume;
            } catch (InterruptedException e) {
                e.printStackTrace();
                return null;
            }
    
        }
    
        public static void main(String[] args) {
            Stroge stroge = new Stroge();
            Producer producer = new Producer(stroge);
            Consumer consumer = new Consumer(stroge);
            Thread consumer1 = new Thread(consumer);
            Thread producer1 = new Thread(producer);
            Producer producer2 = new Producer(stroge);
            Consumer consumer2 = new Consumer(stroge);
            Thread consumer22 = new Thread(consumer2);
            Thread producer22 = new Thread(producer2);
            consumer1.start();
            producer1.start();
            consumer22.start();
            producer22.start();
        }
    }
    
    class Producer implements Runnable {
        private Stroge stroge;
    
        public Producer(Stroge stroge) {
            this.stroge = stroge;
        }
    
        public void run() {
            while (true) {
                stroge.produce();
            }
        }
    
    }
    
    class Consumer implements Runnable {
    
        private Stroge stroge;
    
        public Consumer(Stroge stroge) {
            this.stroge = stroge;
        }
    
        public void run() {
            while (true) {
                stroge.consume();
            }
        }
    }