JAVA多线程（五）用lock、synchronized、阻塞队列三种方法实现生产者消费者模式

柔情只为你懂 2022-05-24 03:18 48阅读 0赞

（转自：[https://blog.csdn.net/antony9118/article/details/51500278][https_blog.csdn.net_antony9118_article_details_51500278] 侵删）

这篇博客算是上一篇[JAVA多线程（三）生产者消费者模式及实现方法][JAVA]的补充。用三种方法（lock、synchronized、阻塞队列）实现生产者消费者模式。具体内容是：生产者产生随机数（为了方便阅读结果，我把随机数限定在10以内的整数），消费者读取并打印。

# 1 阻塞队列实现生产者消费者模式 #

阻塞队列是最简单的实现方法

import java.util.concurrent.BlockingQueue;
    import java.util.concurrent.LinkedBlockingQueue;
    import java.util.logging.Level;
    import java.util.logging.Logger;
    import java.util.Random;
    
    public class BlockingQueuePattern { 
    
        public static void main(String args[]){
    
         //阻塞队列
         BlockingQueue sharedQueue = new LinkedBlockingQueue();
    
         //创建生产者线程和消费者线程
         Thread prodThread = new Thread(new Producer(sharedQueue));
         Thread consThread = new Thread(new Consumer(sharedQueue));
    
         //启动生产者线程和消费者线程
         prodThread.start();
         consThread.start();
        }
    }
    
    //生产者类
    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 {
                    //产生10以内的随机整数放入阻塞队列
                    Random random = new Random();
                    int ProdRandom=random.nextInt(10);
                    System.out.println("Produced: " + ProdRandom);
                    sharedQueue.put(ProdRandom);
                } catch (InterruptedException ex) {
                    Logger.getLogger(Producer.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        }
    }
    
    //消费者类
    class Consumer implements Runnable{ 
    
        private final BlockingQueue sharedQueue;
    
        public Consumer (BlockingQueue sharedQueue) {
            this.sharedQueue = sharedQueue;
        }
    
        @Override
        public void run() {
            while(true){
                try {
                    System.out.println("Consumed: "+ sharedQueue.take());
                } catch (InterruptedException ex) {
                    Logger.getLogger(Consumer.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        }
    } 
    Output：
    Produced: 4
    Produced: 7
    Produced: 8
    Consumed: 4
    Consumed: 7
    Produced: 6
    Consumed: 8
    Consumed: 6
    Produced: 1
    Produced: 7
    Consumed: 1
    Consumed: 7
    Produced: 3
    Produced: 5
    Consumed: 3
    Consumed: 5
    Produced: 9
    Produced: 7
    Consumed: 9
    Consumed: 7

# 2 lock实现生产者消费者模式 #

既然不用JAVA提供给我们的现成的阻塞队列，我们不如自己创建一个队列，代码如下:

import java.util.LinkedList;
    import java.util.Random;
    import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class OptimisticLockPattern {
        public static void main(String[] args){     
             SelfQueue selfqueue = new SelfQueue();
    
             //创建生产者线程和消费者线程
             Thread prodThread = new Thread(new Producer(selfqueue));
             Thread consThread = new Thread(new Consumer(selfqueue));
    
             //启动生产者线程和消费者线程
             prodThread.start();
             consThread.start();
        }
    }
    
    
    class SelfQueue{
        int max = 5;
        LinkedList<Integer> ProdLine = new LinkedList<Integer>();
        Lock lock = new ReentrantLock(); 
        Condition full = lock.newCondition();  
        Condition empty = lock.newCondition();
    
        public void produce(int ProdRandom){       
            try {
                lock.lock();
                while(max == ProdLine.size()){
                    System.out.println("存储量达到上限，请等待");
                    full.await();
                }
                ProdLine.add(ProdRandom);
                empty.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally{
                lock.unlock();
            }
        } 
    
        public int consume(){  
            int m = 0;
            try {
                lock.lock();
                while(ProdLine.size() == 0){
                    System.out.println("队列是空的，请稍候");
                    empty.await();
                }
                m = ProdLine.removeFirst();
                full.signal(); 
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally{
                lock.unlock();
                return m;
            }
        }
    }
    
    //生产者
    class Producer implements Runnable{
        private final SelfQueue selfqueue;
    
        public Producer(SelfQueue selfqueue) {
              this.selfqueue = selfqueue;
        }
    
        public void run() {
          for (int i = 0; i < 10; i++) {
                Random random = new Random();
                int ProdRandom=random.nextInt(10);
                System.out.println("Produced: " + ProdRandom);
                selfqueue.produce(ProdRandom);          
          }
      }
    }
    
    //消费者
    class Consumer implements Runnable{
        private final SelfQueue selfqueue;
    
        public Consumer(SelfQueue selfqueue) {
              this.selfqueue = selfqueue;
        }
    
        public void run() {
          while(true) {
                  System.out.println("Consumed: "+ selfqueue.consume());
          }
      }
    }
    Output:
    Produced: 1
    Produced: 9
    Consumed: 1
    Consumed: 9
    队列是空的，请稍候
    Produced: 9
    Produced: 1
    Consumed: 9
    Produced: 8
    Consumed: 1
    Consumed: 8
    队列是空的，请稍候
    Produced: 6
    Produced: 8
    Consumed: 6
    Produced: 4
    Consumed: 8
    Produced: 4
    Consumed: 4
    Produced: 0
    Consumed: 4
    Consumed: 0
    队列是空的，请稍候

# 3 synchronized实现生产者消费者模式 #

synchronized不需要自己手动解锁，这里用到了前面提过的[wait()&notify()][JAVA]方法。

import java.util.Random;
    
    public class PessimisticLockPattern { 
        public static void main(String[] args){     
             SelfQueue selfqueue = new SelfQueue();
    
             //创建生产者线程和消费者线程
             Thread prodThread = new Thread(new Producer(selfqueue));
             Thread consThread = new Thread(new Consumer(selfqueue));
    
             //启动生产者线程和消费者线程
             prodThread.start();
             consThread.start();
        }
    }
    
    
    class SelfQueue{ 
        int index = 0; 
        int[] ProdLine = new int[6];
    
        public synchronized void produce(int ProdRandom){
            while(index == ProdLine.length){
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            this.notify();
            ProdLine[index] = ProdRandom;
            index++;
        }
    
        public synchronized int consume(){
            while(index == 0){
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            this.notify();
            index--;
            return ProdLine[index];
        }
    }
    
    //生产者
    class Producer implements Runnable{ 
        private final SelfQueue selfqueue;
    
        public Producer(SelfQueue selfqueue) {
            this.selfqueue = selfqueue;
      }
    
      public void run() {
        for (int i = 0; i < 10; i++) {
                Random random = new Random();
                int ProdRandom = random.nextInt(10);
            System.out.println("Produced: " + ProdRandom);
                selfqueue.produce(ProdRandom);          
        }
    }
    }
    
    //消费者
    class Consumer implements Runnable{ 
        private final SelfQueue selfqueue;
    
      public Consumer(SelfQueue selfqueue) {
            this.selfqueue = selfqueue;
      }
    
      public void run() {
        while(true) {
              System.out.println("Consumed: "+ selfqueue.consume());
        }
    }
    }
    Output:
    Produced: 3
    Produced: 3
    Consumed: 3
    Produced: 8
    Produced: 3
    Consumed: 3
    Produced: 2
    Produced: 6
    Consumed: 3
    Produced: 7
    Produced: 8
    Produced: 1
    Produced: 9
    Consumed: 6
    Consumed: 9
    Consumed: 1
    Consumed: 8
    Consumed: 7
    Consumed: 2
    Consumed: 8

[https_blog.csdn.net_antony9118_article_details_51500278]: https://blog.csdn.net/antony9118/article/details/51500278
[JAVA]: http://blog.csdn.net/antony9118/article/details/51481884