多线程实现生产者消费者

最新推荐文章于 2024-04-15 17:02:22 发布
最新推荐文章于 2024-04-15 17:02:22 发布
阅读量429 收藏
点赞数 1
分类专栏： 并发编程 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/achiberx/article/details/73180797
版权

一、采用synchronized锁以及wait notify方法实现
1.wait()的作用是让当前线程进入等待状态，同时，wait()也会让当前线程释放它所持有的锁。“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法”，当前线程被唤醒(进入“就绪状态”)
2.notify()和notifyAll()的作用，则是唤醒当前对象上的等待线程；notify()是唤醒单个线程，而notifyAll()是唤醒所有的线程。
3.wait(long timeout)让当前线程处于“等待(阻塞)状态”，“直到其他线程调用此对象的notify()方法或 notifyAll() 方法，或者超过指定的时间量”，当前线程被唤醒(进入“就绪状态”)。

//主类
public class WaitAndNotify {
    public static void main(String[] args) {
        Person person = new Person();
        new Thread(new Consumer("消费者一", person)).start();
        new Thread(new Consumer("消费者二", person)).start();
        new Thread(new Consumer("消费者三", person)).start();

        new Thread(new Producer("生产者一", person)).start();
        new Thread(new Producer("生产者二", person)).start();
        new Thread(new Producer("生产者 三", person)).start();
    }
}

//生产者
public class Producer implements Runnable {
    private Person person;
    private String producerName;
    public Producer(String producerName, Person person) {
        this.producerName = producerName;
        this.person = person;
    }
    public void run() {
        while(true) {
            try {
                person.produce();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//消费者
public class Consumer implements Runnable {
    private Person person;
    private String consumerName;
    public Consumer(String consumerName, Person person) {
        this.consumerName = consumerName;
        this.person = person;
    }
    public void run()
    {
        while(true) {
            try
            {
                person.consume();
            } catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }   
    }
}

//Person 类
public class Person {
    private int foodNum = 0;
    private Object synObject = new Object();
    private final int MAX_NUM = 10;
    public void produce() throws InterruptedException 
    {
        synchronized (synObject) {
            while(foodNum == MAX_NUM)
            {
                System.out.println("ThreadId: " + Thread.currentThread().getId() + "  box is full, size = " + foodNum);
                synObject.wait();
            }
            foodNum++;
            System.out.println("produce success foodNum = " + foodNum);
            synObject.notifyAll();
        }
    }
    public void consume() throws InterruptedException 
    {
        synchronized (synObject) {
            while(foodNum == 0) {
                System.out.println("ThreadId: " + Thread.currentThread().getId() + "   box is empty, size = " + foodNum);
                synObject.wait();
            }
            foodNum--;
            System.out.println("consume success foodNum = " + foodNum);
            synObject.notifyAll();
        }
    }
}

二、采用Lock锁以及await和signal方法是实现

//主类
public class AwaitAndSignal{
    public static void main(String[] args) {
        Person person = new Person();
        new Thread(new Consumer("消费者一", person)).start();
        new Thread(new Consumer("消费者二", person)).start();
        new Thread(new Consumer("消费者三", person)).start();

        new Thread(new Producer("生产者一", person)).start();
        new Thread(new Producer("生产者二", person)).start();
        new Thread(new Producer("生产者 三", person)).start();
    }
}
//生产者
public class Producer implements Runnable {
    private Person person;
    private String producerName;
    public Producer(String producerName, Person person) {
        this.producerName = producerName;
        this.person = person;
    }
    public void run() {
        while(true) {
            try {
                person.produce();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//消费者
public class Consumer implements Runnable {
    private Person person;
    private String consumerName;
    public Consumer(String consumerName, Person person) {
        this.consumerName = consumerName;
        this.person = person;
    }
    public void run()
    {
        while(true)
        {
            try
            {
                person.consume();
            } catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
    }
}

//Person 类
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class Person {
    private int foodNum = 0;
    private ReentrantLock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    private final int MAX_NUM = 10;
    public void produce() throws InterruptedException 
    {
        lock.lock();
        try 
        {
            while(foodNum == MAX_NUM)
            {
                System.out.println("ThreadId: " + Thread.currentThread().getId() + "  box is full, size = " + foodNum);
                condition.await();
            }
            foodNum++;
            System.out.println("produce success foodNum = " + foodNum);
            condition.signalAll();
        }catch(InterruptedException e) {
            e.printStackTrace();
        }finally
        {
            lock.unlock();
        }
    }
    public void consume() throws InterruptedException 
    {
        lock.lock();
        try
        {
            while(foodNum == 0) {
                System.out.println("ThreadId: " + Thread.currentThread().getId() + "   box is empty, size = " + foodNum);
                condition.await();
            }
            foodNum--;
            System.out.println("consume success foodNum = " + foodNum);
            condition.signalAll();
        }catch(InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

三。下面是用ConcurrentLinkedQueue实现的， 我觉得是有bug的，先放在这里。
非阻塞队列
基于链接节点的、无界的、线程安全。此队列按照 FIFO（先进先出）原则对元素进行排序。队列的头部 是队列中时间最长的元素。队列的尾部 是队列中时间最短的元素。新的元素插入到队列的尾部，队列检索操作从队列头部获得元素。当许多线程共享访问一个公共 collection 时，ConcurrentLinkedQueue 是一个恰当的选择。此队列不允许 null 元素。

import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class NoBlockQueue {
    private static ConcurrentLinkedQueue<Integer> concurrentLinkedQueue = new ConcurrentLinkedQueue<Integer>();
    private static ReentrantLock lock = new ReentrantLock();
    //private static Condition condition = lock.newCondition();

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(6);
        executorService.submit(new Producer("producer1"));
        executorService.submit(new Producer("producer2"));
        executorService.submit(new Producer("producer3"));
        executorService.submit(new Consumer("consumer1"));
        executorService.submit(new Consumer("consumer2"));
        executorService.submit(new Consumer("consumer3"));
    }
    static class Producer implements Runnable {
        private String name;
        int cnt = 0;
        public Producer(String name) {
            this.name = name;
        }
        public void run() {
            while(true) {
                System.out.println(name + " start producer " + cnt + "  " + Thread.currentThread().getId());
                concurrentLinkedQueue.add(cnt++);
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }
    }
    static class Consumer implements Runnable {
        private String name;
        public Consumer(String name) {
            this.name = name;
        }
        public void run() {
            while(true) 
            {
                //我觉得这里是有bug， 可能一个线程判断不空，但是取的时候已经为空了，如果给concurrentLinkedQueue加锁有限制了并发！
                if(concurrentLinkedQueue.isEmpty()) {
                    System.out.println("concurrentLinkedQueue is empty!");
                } else {
                    System.out.println(name + " Consumer " + concurrentLinkedQueue.poll());
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

四。利用LinkedBlockingQueue实现生产者消费者问题。
按 FIFO（先进先出）排序元素。队列的头部 是在队列中时间最长的元素。队列的尾部 是在队列中时间最短的元素。新元素插入到队列的尾部，并且队列检索操作会获得位于队列头部的元素。链接队列的吞吐量通常要高于基于数组的队列，但是在大多数并发应用程序中，其可预知的性能要低。

注意：

1、必须要使用take()方法在获取的时候达成阻塞结果
2、使用poll()方法将产生非阻塞效果

public class BlockingQueue{
    //阻塞队列，FIFO
    private static LinkedBlockingQueue<Integer> concurrentLinkedQueue = new LinkedBlockingQueue<Integer>();

 public static void main(String[] args) {  
     ExecutorService executorService = Executors.newFixedThreadPool(6);  

     executorService.submit(new Producer("producer1"));  
     executorService.submit(new Producer("producer2"));  
     executorService.submit(new Producer("producer3"));  
     executorService.submit(new Consumer("consumer1"));  
     executorService.submit(new Consumer("consumer2"));  
     executorService.submit(new Consumer("consumer3"));  
 }  

 static class Producer implements Runnable {
     private String name;  
     int cnt = 0;
     public Producer(String name) {  
         this.name = name;  
     }

     public void run() {  
          while(true) {
             System.out.println(name+ "  生产： " + cnt);
             //concurrentLinkedQueue.add(i);  
             try {
                concurrentLinkedQueue.put(cnt++);
                Thread.sleep(3000); //模拟慢速的生产，产生阻塞的效果
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            }
         }
     }  
 }  

 static class Consumer implements Runnable {  
     private String name;  

     public Consumer(String name) {  
         this.name = name;  
     }  
     public void run() {  
         while(true) {
             try {          
                //必须要使用take()方法在获取的时候阻塞
                  System.out.println(name+"消费： " +  concurrentLinkedQueue.take()); 
                  Thread.sleep(2000);
                  //使用poll()方法 将产生非阻塞效果
                  //System.out.println(name+"消费： " +  concurrentLinkedQueue.poll());  
                  //还有一个超时的用法，队列空时，指定阻塞时间后返回，不会一直阻塞
                  //System.out.println(name+" Consumer " +  concurrentLinkedQueue.poll(300, TimeUnit.MILLISECONDS));                    
            } catch (Exception e) {
                e.printStackTrace();
            }  
         }
     }  
 }  
}

在并发编程中，一般推荐使用阻塞队列，这样实现可以尽量地避免程序出现意外的错误。阻塞队列使用最经典的场景就是socket客户端数据的读取和解析，读取数据的线程不断将数据放入队列，然后解析线程不断从队列取数据解析。还有其他类似的场景，只要符合生产者-消费者模型的都可以使用阻塞队列。

使用非阻塞队列，虽然能即时返回结果（消费结果），但必须自行编码解决返回为空的情况处理（以及消费重试等问题）。
另外他们都是线程安全的，不用考虑线程同步问题。

acceptedwwh
关注
专栏目录
java多线程实现生产者消费者问题
12-08
用java多线程，实现生产者消费者同步和互斥的问题，操作系统中的经典问题
多线程：线程通信：生产者和消费者(等待唤醒机制)代码实现
weixin_53622554的博客
03-30 710
概述1.生产者消费者模式是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们 对多线程编程的理解更加深刻。2.所谓生产者消费者问题，实际上主要是包含了两类线程：一类是生产者线程用于生产数据一类是消费者线程用于消费数据3.为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为Object类的等待和唤醒方法。
java多线程并发 ： 生产者-消费者模型的三种实现方式
火星男孩的分享空间
05-10 2941
生产者生产数据到缓冲区中，消费者从缓冲区中取数据。 如果缓冲区已经满了，则生产者线程阻塞； 如果缓冲区为空，那么消费者线程阻塞。 方式一：synchronized、wait和notify package day4; //wait 和 notify public class ProducerConsumerWithWaitNofity { public static void main(String[] args) { Resource resource = new Resource
多线程实现生产者和消费者模型
fw150104010012的博客
10-10 255
多线程，生产者消费者模型
day21_多线程01【实现多线程-线程同步-生产者消费者】
weixin_42929213的博客
01-03 701
实现多线程-线程同步-生产者消费者
wpf窗体多线程实现生产者消费者模型
10-31
在给定的“wpf窗体多线程实现生产者消费者模型”中，我们将探讨如何利用C#的线程和信号量来实现这一模式，以及如何通过回调函数在工作线程中更新WPF窗体的UI。 首先，理解生产者消费者模型的基本概念至关重要。生产...
Linux 多线程实现生产者消费者模式.pdf
08-20
Linux多线程实现生产者消费者模式涉及到操作系统中的多个重要知识点，包括多线程编程、生产者消费者模型、互斥量、条件变量等。在Linux环境下，这些功能可以通过POSIX线程（pthread）库来实现。下面详细解释这些知识...
JAVA多线程实现生产者消费者的实例详解
08-30
JAVA多线程实现生产者消费者的实例详解 JAVA多线程实现生产者消费者是指在JAVA编程语言中使用多线程技术来实现生产者消费者模型的实例详解。生产者消费者模型是指在计算机科学中的一种经典模式，描述了生产者和消费...
Java多线程实现生产者消费者
05-29
本示例中的“生产者-消费者”模型是一种经典的多线程问题，它模拟了实际生产环境中的资源分配与消耗过程。下面我们将详细探讨如何在Java中实现这个模型。 首先，我们要理解生产者-消费者模型的基本概念。在这个模型...
Java多线程 BlockingQueue实现生产者消费者模型详解
08-25
Java多线程BlockingQueue实现生产者消费者模型详解 Java多线程中，生产者消费者模型是非常重要的一种设计模式，它可以解决多线程之间的数据传输问题。在Java中，我们可以使用BlockingQueue来实现生产者消费者模型，...
【Linux】多线程——生产者和消费者模型
zxj20041003的博客
07-28 639
存在多个消费者，消费者对于商品的一次消费是小量的而且时间是不确定的，供货商一次生产的商品是大量的且时间是确定的（在工人的上班时间才能操作机械生产）。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。其次，我们要明确的是，生产者生产数据的过程可能漫长且独立的，消费者消费（处理）数据的时候可能漫长且独立的。
＜ Linux ＞ 多线程（生产者消费者模型）
bit_zyx的博客
03-13 1727
目录 1、生产者消费者模型 生产者消费者模型的例子 生产者消费者模型的特点 生产者消费者模型的优点 2、基于BlockingQueue的生产者消费者模型 概念 模拟实现基于阻塞队列的生产消费模型 基于计算任务的生产者消费者模型（并发）
多线程的同步问题的经典案例生产者-消费者模式剖析
唐欢
04-23 1132
生产者－消费者问题（Producer-Consumer Problem）也称有限缓冲问题（Bounded-Buffer Problem），是一个多线程同步问题的经典案例。 生产者－消费者问题描述了两个访问共享缓冲区的线程，即生产者线程和消费者线程，在实际运行时会发生的问题。生产者线程的主要功能是生成一定量的数据放到缓冲区中，然后重复此过程。消费者线程的主要功能是从缓冲区提取（或消耗）数据。
C++实现生产者与消费者的多线程程序
DevCharm的博客
08-26 124
本文将分别介绍生产者和消费者的实现，以及如何使用多线程来协调它们之间的交互。一旦收到信号并满足条件，就会添加数据到缓冲区，并通知所有等待的线程。它应该有一个从缓冲区中取出数据的方法，以及一个线程函数，用于创建一个线程并在其中循环调用消费者方法。它应该有一个向缓冲区添加数据的方法，以及一个线程函数，用于创建一个线程并在其中循环调用生产者方法。方法分别创建了生产者和消费者线程，并将它们的引用传递给了对应的类。最后，我们需要定义一个协调器类，用于启动生产者和消费者线程，并协调它们的交互。方法使用了一个条件变量。
多线程-生产者和消费者模式的四种实现
Fly_Fly_Zhang的博客
05-29 6827
什么是生产者和消费者模式： 生产者和消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此并不直接通信，而是通过阻塞队列进行通信，所以生产者生产完数据后不用等待消费者进行处理，而是直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列中获取数据，阻塞队列就相当于一个缓冲区，平衡生产者和消费者的处理能力。 wait/notify和synchronized配合实现： 生产者...
多线程之生产者消费者模式
aaaPostcard的博客
10-22 2363
线程之间的协作，生产者和消费者线程模式的介绍。
一文理解java多线程之生产者消费者模型（三种实现）
qq_43800449的博客
04-12 3637
生产者和消费者之间通过一个缓冲区来进行交互，生产者负责生成数据，然后存入缓冲区；消费者则负责消费数据，从缓冲区获取。生产者和消费者只和缓冲区交互，没有直接联系。其中的同步互斥关系：生产者之间互斥，消费者之间也互斥生产者与消费者之间既又同步也有互斥（缓冲区满时，只能消费完再生产；缓冲区空时，只能生产完再消费）注意：缓存区要先进先出，所以一般用队列实现为什么要用生产者-消费者模型？
Java多线程（实现多线程、线程同步、生产者消费者）
yqqの博客
03-12 527
概述生产者消费者模式是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻。所谓生产者消费者问题，实际上主要是包含了两类线程：​ 一类是生产者线程用于生产数据​ 一类是消费者线程用于消费数据为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为Object类的等待和唤醒方法方法名说明。
java:多线程解决生产者消费者问题
最新发布
qq_55630615的博客
04-15 837
一个简单的多线程问题,当处理逻辑不完善时,容易出现所有线程都在等待的死锁情况.我在一开始写的时候,使用的是notify()方法,这会导致每次只唤醒一条线程,但如果之前出现了消费者或生产者的连续抢到cpu控制权情况,之前沉睡的线程就并不止有一条,最终导致全部等待的死锁情况.贴两张运行结果直观一点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值