Carson带你学Java:解决生产者消费者问题的五种实现方式

Posted Carson带你学Android

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Carson带你学Java:解决生产者消费者问题的五种实现方式相关的知识,希望对你有一定的参考价值。


1. 简介

生产者 & 消费者之间存在 强耦合问题


2. 解决方案

采用 生产者 & 消费者 模式,具体介绍如下:


3. 具体解决方式介绍

方式1:wait() / notify()

// Object类里的两个方法,所有Object子类都可使用这2个方法
// 对象的监视器对锁对象的锁定(也就是代码中的lock对象),注意是调用锁对象的wait() / nofity()
public class Test  
    private static Integer count = 0; 
    private final Integer FULL = 5; 
    private static String lock = "lock"; 
 
    public static void main(String[] args)  
        Test t = new Test(); 
        new Thread(t.new Producer()).start(); 
        new Thread(t.new Consumer()).start(); 
        new Thread(t.new Producer()).start(); 
        new Thread(t.new Consumer()).start(); 
     
 
    class Producer implements Runnable  
        @Override 
        public void run()  
            for (int i = 0; i < 5; i++)  
                try  
                    Thread.sleep(1000); 
                 catch (InterruptedException e1)   
                    e1.printStackTrace(); 
                 
                synchronized (lock)  
                    while (count == FULL)  
                        try  
                            lock.wait(); 
                         catch (InterruptedException e)   
                            e.printStackTrace(); 
                         
                     
                    count++; 
                    System.out.println("生产者"+Thread.currentThread().getName() 
                            + "已生产完成,商品数量:" + count); 
                    lock.notifyAll(); 
                 
             
         
     
 
    class Consumer implements Runnable  
        @Override 
        public void run()  
            for (int i = 0; i < 5; i++)  
                try  
                    Thread.sleep(1000); 
                 catch (InterruptedException e1)  
                    e1.printStackTrace(); 
                 
                synchronized (lock)  
                    while (count == 0)  
                        try  
                            lock.wait(); 
                         catch (InterruptedException e)  
                            e.printStackTrace(); 
                         
                     
                    count--; 
                    System.out.println("消费者"+Thread.currentThread().getName() 
                            + "已消费,剩余商品数量:" + count); 
                    lock.notifyAll(); 
                 
             
         
     



// 测试结果

生产者Thread-0已生产完成,商品数量:1 
生产者Thread-2已生产完成,商品数量:2 
消费者Thread-1已消费,剩余商品数量:1 
消费者Thread-3已消费,剩余商品数量:0 
生产者Thread-0已生产完成,商品数量:1 
消费者Thread-3已消费,剩余商品数量:0 
生产者Thread-2已生产完成,商品数量:1 
消费者Thread-1已消费,剩余商品数量:0 
生产者Thread-0已生产完成,商品数量:1 
生产者Thread-2已生产完成,商品数量:2 
消费者Thread-1已消费,剩余商品数量:1 
消费者Thread-3已消费,剩余商品数量:0 
生产者Thread-0已生产完成,商品数量:1 
消费者Thread-1已消费,剩余商品数量:0 
生产者Thread-2已生产完成,商品数量:1 
消费者Thread-3已消费,剩余商品数量:0 
生产者Thread-0已生产完成,商品数量:1 
消费者Thread-1已消费,剩余商品数量:0 
生产者Thread-2已生产完成,商品数量:1 
消费者Thread-3已消费,剩余商品数量:0

方式2:await() / signal()

// 对wait()/notify()的改进,功能更加强大、更适用于高级用户
// synchronized 托管给JVM执行
// 而lock是Java写的控制锁的代码

import java.util.concurrent.locks.Condition; 
import java.util.concurrent.locks.Lock; 
import java.util.concurrent.locks.ReentrantLock; 
 
public class Test  
    private static Integer count = 0;// 缓冲区 
    private final Integer FULL = 5; 
    final Lock lock = new ReentrantLock(); // 此处采用 ReentrantLock,获得可重入锁 
    final Condition put = lock.newCondition(); 
    final Condition get = lock.newCondition(); 
 
    public static void main(String[] args)  
 
        Test t = new Test(); 
        new Thread(t.new Producer()).start(); 
        new Thread(t.new Consumer()).start(); 
        new Thread(t.new Consumer()).start(); 
        new Thread(t.new Producer()).start(); 
     
 
    // 生产者 
    class Producer implements Runnable  
        @Override 
        public void run()  
            for (int i = 0; i < 5; i++)  
                try  
                    Thread.sleep(1000); 
                 catch (InterruptedException e1)   
                    e1.printStackTrace(); 
                 
                //加锁 
                lock.lock(); 
                try  
                    while (count == FULL)  
                        try  
                            put.await(); 
                         catch (InterruptedException e)   
                            e.printStackTrace(); 
                         
                     
                    count++; 
                    System.out.println("生产者" + Thread.currentThread().getName() 
                            + "已生产完成,商品数量: " + count); 
                    //通知消费者,现在可以消费 
                    get.signal(); 
                 finally  
                    lock.unlock(); 
                 
             
         
     
 
    // 消费者 
    class Consumer implements Runnable  
 
        @Override 
        public void run()  
            for (int i = 0; i < 5; i++)  
                try  
                    Thread.sleep(1000); 
                 catch (InterruptedException e1)   
                    e1.printStackTrace(); 
                 
                lock.lock(); 
                try  
                    while (count == 0)  
                        try  
                            get.await(); 
                         catch (Exception e)   
                            e.printStackTrace(); 
                         
                     
                    count--; 
                    System.out.println("消费者" + Thread.currentThread().getName() 
                            + "已消费,剩余商品数量: " + count); 
                    put.signal(); 
                 finally  
                    lock.unlock(); 
                 
             
         
     


// 测试结果
生产者Thread-3已生产完成,商品数量: 1 
生产者Thread-0已生产完成,商品数量: 2 
消费者Thread-1已消费,剩余商品数量: 1 
消费者Thread-2已消费,剩余商品数量: 0 
生产者Thread-3已生产完成,商品数量: 1 
生产者Thread-0已生产完成,商品数量: 2 
消费者Thread-1已消费,剩余商品数量: 1 
消费者Thread-2已消费,剩余商品数量: 0 
生产者Thread-0已生产完成,商品数量: 1 
生产者Thread-3已生产完成,商品数量: 2 
消费者Thread-1已消费,剩余商品数量: 1 
消费者Thread-2已消费,剩余商品数量: 0 
生产者Thread-0已生产完成,商品数量: 1 
生产者Thread-3已生产完成,商品数量: 2 
消费者Thread-2已消费,剩余商品数量: 1 
消费者Thread-1已消费,剩余商品数量: 0 
生产者Thread-3已生产完成,商品数量: 1 
生产者Thread-0已生产完成,商品数量: 2 
消费者Thread-2已消费,剩余商品数量: 1 
消费者Thread-1已消费,剩余商品数量: 0

方式3:(BlockingQueue)阻塞队列 系列方法

// 下面主要使用其中的 put()、take()
// put():将指定元素插入此队列中,将等待可用的空间(若有必要)
// take():获取并移除此队列的头部,在指定的等待时间前等待可用的元素(若有必要)

import java.util.concurrent.ArrayBlockingQueue; 
import java.util.concurrent.BlockingQueue; 
 
public class Test  
    private static Integer count = 0; 
    final BlockingQueue<Integer> bq = new ArrayBlockingQueue<Integer>(5);// 容量为5的阻塞队列 
 
    public static void main(String[] args)  
        Test t = new Test(); 
        new Thread(t.new Producer()).start(); 
        new Thread(t.new Consumer()).start(); 
        new Thread(t.new Consumer()).start(); 
        new Thread(t.new Producer()).start(); 
     
 
// 生产者
    class Producer implements Runnable  
        @Override 
        public void run()  
            for (int i = 0; i < 5; i++)  
                try  
                    Thread.sleep(1000); 
                 catch (Exception e)  
                    e.printStackTrace(); 
                 
                try  
                    bq.put(1); 
                    count++; 
                    System.out.println("生产者" + Thread.currentThread().getName() 
                            + "已生产完成,商品数量:" + count); 
                 catch (InterruptedException e)  
                    e.printStackTrace(); 
                 
             
         
     
 
// 消费者
    class Consumer implements Runnable  
 
        @Override 
        public void run()  
            for (int i = 0; i < 5; i++)  
                try  
                    Thread.sleep(1000); 
                 catch (InterruptedException e1)  
                    e1.printStackTrace(); 
                 
                try  
                    bq.take(); 
                    count--; 
                    System.out.println("消费者" + Thread.currentThread().getName() 
                            + "已消费,剩余商品数量:" + count); 
                 catch (Exception e)  
                    e.printStackTrace(); 
                 
             
         
     

方式4:信号量 系列方法(Semaphore)

// 实例使用
import java.util.concurrent.Semaphore; 
 
public class Test  
    int count = 0; 
    final Semaphore put = new Semaphore(5);// 初始令牌个数 
    // 注:同步令牌(notFull.acquire())必须在互斥令牌(mutex.acquire())前面获得;若先得到互斥锁再发生等待,会造成死锁。
    final Semaphore get = new Semaphore(0); 
    final Semaphore mutex = new Semaphore(1); 
 
    public static void main(String[] args)  
        Test t = new Test(); 
        new Thread(t.new Producer()).start(); 
        new Thread(t.new Consumer()).start(); 
        new Thread(t.new Consumer()).start(); 
        new Thread(t.new Producer()).start(); 
     
 
    class Producer implements Runnable  
        @Override 
        public void run()  
            for (int i = 0; i < 5; i++)  
                try  
                    Thread.sleep(1000); 
                 catch (Exception e)  
                    e.printStackTrace(); 
                 
                try  
                    put.acquire();// 注意顺序 
                    mutex.acquire(); 
                    count++; 
                    System.out.println("生产者" + Thread.currentThread().getName() 
                            + "已生产完成,商品数量:" + count); 
                 catch (Exception e)  
                    e.printStackTrace(); 
                 finally  
                    mutex.release(); 
                    get.release(); 
                 
 
             
         
     
 
    class Consumer implements Runnable  
 
        @Override 
        public void run()  
            for (int i = 0; i < 5; i++)  
                try  
                    Thread.sleep(1000); 
                 catch (InterruptedException e1)  
                    e1.printStackTrace(); 
                 
                try  
                    get.acquire();// 注意顺序 
                    mutex.acquire(); 
                    count--; 
                    System.out.println("消费者" + Thread.currentThread().getName() 
                            + "已消费,剩余商品数量:" + count); 
                 catch (Exception e)  
                    e.printStackTrace(); 
                 finally  
                    mutex.release(); 
                    put.release(); 
                 
             
         
     


// 测试结果
生产者Thread-0已生产完成,商品数量:1 
消费者Thread-2已消费,剩余商品数量:0 
生产者Thread-3已生产完成,商品数量:1 
消费者Thread-1已消费,剩余商品数量:0 
生产者Thread-0已生产完成,商品数量:1 
生产者Thread-3已生产完成,商品数量:2 
消费者Thread-2已消费,剩余商品数量:1 
消费者Thread-1已消费,剩余商品数量:0 
生产者Thread-0已生产完成,商品数量:1 
生产者Thread-3已生产完成,商品数量:2 
消费者Thread-2已消费,剩余商品数量:1 
消费者Thread-1已消费,剩余商品数量:0 
生产者Thread-0已生产完成,商品数量:1 
生产者Thread-3已生产完成,商品数量:2 
消费者Thread-2已消费,剩余商品数量:1 
消费者Thread-1已消费,剩余商品数量:0 
生产者Thread-0已生产完成,商品数量:1 
生产者Thread-3已生产完成,商品数量:2 
消费者Thread-2已消费,剩余商品数量:1 
消费者Thread-1已消费,剩余商品数量:0

方式5:PipedInputStream / PipedOutputStream

import java.io.IOException; 
import java.io.PipedInputStream; 
import java.io.PipedOutputStream; 
 
public class Test  
    final PipedInputStream pis = new PipedInputStream(); 
    final PipedOutputStream pos = new PipedOutputStream(); 
 
    public static void main(String[] args)  
        Test t = new Test(); 
        new Thread(t.new Producer()).start(); 
        new Thread(t.new Consumer()).start(); 
     
 
    class Producer implements Runnable  
 
        @Override 
        public void run()  
            try  
                pis.connect(pos); 
             catch (IOException e)  
                e.printStackTrace(); 
             
            try  
                while (true)  // 不断的产生数据 
                    int n = (int) (Math.random() * 255); 
                    System.out.println("生产者" + Thread.currentThread().getName() 
                            + "已生产完成,商品数量:" + n); 
                    pos.write(n); 
                    pos.flush(); 
                 
             catch (IOException e)  
                e.printStackTrace(); 
             finally  
                try  
                    pis.close(); 
                    pos.close(); 
                 catch (IOException e)  
                    e.printStackTrace(); 
                 
             
 
         
     
 
    class Consumer implements Runnable  
 
        @Override 
        public void run()  
            int n; 
            try  
                while (true)  
                    n = pis.read(); 
                    System.out.println("消费者" + Thread.currentThread().getName() 
                            + "已消费,剩余商品数量:" + n); 
                 
             catch (IOException e)  
                e.printStackTrace(); 
             finally  
                try  
                    pis.close(); 
                    pos.close(); 
                 catch (IOException e)  
                    e.printStackTrace(); 
                 
 
             
         
     


// 测试结果
生产者Thread-0已生产完成,商品数量:6 
生产者Thread-0已生产完成,商品数量:158 
生产者Thread-0已生产完成,商品数量:79 
生产者Thread-0已生产完成,商品数量:119 
生产者Thread-0已生产完成,商品数量:93 
生产者Thread-0已生产完成,商品数量:213 
生产者Thread-0已生产完成,商品数量:151 
生产者Thread-0已生产完成,商品数量:101 
生产者Thread-0已生产完成,商品数量:125 
生产者Thread-0已生产完成,商品数量:109 
生产者Thread-0已生产完成,商品数量:67 
生产者Thread-0已生产完成,商品数量:109 
生产者Thread-0已生产完成,商品数量:132 
生产者Thread-0已生产完成,商品数量:139 
... 

至此,关于Java解决生产者、消费者问题的五种实现方式讲解完毕。


欢迎关注Carson_Ho的CSDN博客

博客链接:https://carsonho.blog.csdn.net/


请点赞!因为你的鼓励是我写作的最大动力!

以上是关于Carson带你学Java:解决生产者消费者问题的五种实现方式的主要内容,如果未能解决你的问题,请参考以下文章

Carson带你学Java:解决生产者消费者问题的五种实现方式

Carson带你学Java:泛型知识知多少

Carson带你学Android:手把手带你入门神秘的Rxjava

Carson带你学Java:关于String类的必知必会!

Carson带你学Java:深入解析引用类型-强软弱虚

Carson带你学Java:深入解析引用类型-强软弱虚