生产者消费者 ProducerConsumer

生产者消费者是常见的同步问题。一个队列,头部生产数据,尾部消费数据,队列的长度为固定值。当生产的速度大于消费的速度时,队列逐渐会填满,这时就会阻塞住。当尾部消费了数据之后,生产者就可以继续生产了。

生产者

package com.example;

import java.util.List;

public class Producer {

    private List<String> list;

    public Producer(List<String> list){
        this.list = list;
    }

    public void produce(String str){
        synchronized (list){
            if(list.size() >= ProducerConsumer.LIST_SIZE){
                try {
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            list.add(0, str);
            System.out.println("produce item:"+str);
        }
    }
}

消费者

package com.example;

import java.util.List;

public class Producer {

    private List<String> list;

    public Producer(List<String> list){
        this.list = list;
    }

    public void produce(String str){
        synchronized (list){
            if(list.size() >= ProducerConsumer.LIST_SIZE){
                try {
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            list.add(0, str);
            System.out.println("produce item:"+str);
        }
    }
}

测试类

package com.example;

import java.util.ArrayList;
import java.util.List;

public class ProducerConsumer {

    public static int LIST_SIZE = 3;

    public static void main(String[] args){
        producerConsumerTest();
    }

    private static void producerConsumerTest(){
        List<String> list = new ArrayList<String>();
        final Producer producer = new Producer(list);
        final Consumer consumer = new Consumer(list);

        new Thread(new Runnable() {
            @Override
            public void run() {
                int count = 0;
                while(true){
                    count++;
                    producer.produce("num"+count);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                while(true){
                    int count = 0;
                    while(true){
                        consumer.consume();
                        try {
                            Thread.sleep(2500);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }).start();

    }

}

运行结果:

数据超过3个时候就不能生产了,需要等待消费者。

  

时间: 2024-12-10 10:25:03

生产者消费者 ProducerConsumer的相关文章

Java 线程池 +生产者消费者+MySQL读取300 万条数据

1.1需求 数据库300 万条用户数据 ,遍历获取所有用户, 各种组合关联, 获取到一个新的json ,存到redis 上. 1.2 难点 数据库比较多, 不可能单线程查询所有的数据到内存. 1.3解决办法 多线程读取, 生产者 每次获取200 条数据, 消费者去消费.(这里 主要是根据MySQL分页去获取下一个200 条数据) 1.4 代码 1.4.1 调用方法 /** * 线程启动 */ public void update() { //redis操作类 HashRedisUtil redi

Linux线程编程之生产者消费者问题

前言 本文基于顺序循环队列,给出Linux生产者/消费者问题的多线程示例,并讨论编程时需要注意的事项.文中涉及的代码运行环境如下: 本文假定读者已具备线程同步的基础知识. 一  顺序表循环队列 1.1 顺序循环队列定义 队列是一种运算受限的先进先出线性表,仅允许在队尾插入(入队),在队首删除(出队).新元素入队后成为新的队尾元素,元素出队后其后继元素就成为队首元素. 队列的顺序存储结构使用一个数组和两个整型变量实现,其结构如下: 1 struct Queue{ 2 ElemType elem[M

多线程设计模式:Producer-Consumer生产者-消费者模式的C++

我们这里介绍的Producer-Consumer生产者-消费者模式是多线程设计模式中很著名的一个设计模式.说到生产者消费者问题,大部分人都不会陌生,OS课的经典问题,并且其本身就是一个计算机编程中常见的问题.对于它的应用,可以举出无数的例子,小到一个多线程程序对队列的共享互斥操作,大到目前流行的中间件产品,诸如BEA的BMQ(BEA Message Queue),IBM的MQ Serious等中间件就是将生产者消费者问题应用通用化体系化的结果. 实际上,生产者消费者模式跟我们之前的多线程设计模式

经典进程同步问题一:生产者-消费者问题(The producer-consumer problem)

(注:参考教材:计算机操作系统第四版 西安电子科技大学出版社) 问题描述:一群生产者进程在生产产品,并将这些产品提供给消费者去消费.为了使生产者进程与消费者进程能够并发进行,在两者之间设置一个具有n个缓冲区的缓冲池,生产者进程将产品放入一个缓冲区中:消费者可以从一个缓冲区取走产品去消费.尽管所有的生产者进程和消费者进程是以异方式运行,但它们必须保持同步:当一个缓冲区为空时不允许消费者去取走产品,当一个缓冲区满时也不允许生产者去存入产品. 解决方案:我们这里利用一个一个数组buffer来表示这个n

java实现生产者消费者问题(转)

引言 生产者和消费者问题是线程模型中的经典问题:生产者和消费者在同一时间段内共用同一个存储空间,如下图所示,生产者向空间里存放数据,而消费者取用数据,如果不加以协调可能会出现以下情况: 生产者消费者图 存储空间已满,而生产者占用着它,消费者等着生产者让出空间从而去除产品,生产者等着消费者消费产品,从而向空间中添加产品.互相等待,从而发生死锁. JAVA解决线程模型的三种方式 1.wait()和notify() import java.util.LinkedList; public class P

java生产者消费者模型

import java.util.Queue;import java.util.concurrent.LinkedBlockingQueue; public class Consumer extends Thread {    private String product;    private Queue<String> storeHouse = new LinkedBlockingQueue<String>();        public Consumer(){      

【操作系统】经典的同步问题(生产者消费者问题, 哲学家进餐问题, 读写问题)

用专业术语来说, 进程是程序的一次动态执行.说简单点, 就是进程是系统中的某个任务.操作系统中有多个任务需要执行, 那么怎样执行才能使它们同步呢? 即如何让任务并发执行互不影响呢? 这就引出了进程同步中的经典问题: 生产者消费者问题, 哲学家进餐问题, 读写问题 生产者-消费者问题 有一群生产者进程在生产产品, 并将这些产品提供给消费者进程取消费. 为使生产者进程与消费者进程能并发进行, 在两者间设置了一个具有n个缓冲区的缓冲池, 生产者进程将其所生产的产品翻入缓冲区中, 消费者进程可从一个缓冲

生产者消费者问题、Java实现

来,今天尝试把这个问题搞定.还是这种节奏,看一个问题要先从历史看.全局看,这样我们才能真正掌握其全貌,最终各个击破,了然于胸! 我们先来温习下如下概念: 1. 基础概念 基本的 程序 - Program 程序是静态的源代码或目标程序,是一个没有生命的实体. 进程 - Process 当CPU赋予程序生命时也即操作系统执行它时,程序成为了一个活动的实体(但不是可执行的实体),称为进程 - 进行中的程序. 进程是程序的一个实例: 是计算机分配资源的基本单位: 是线程的容器: 线程 - Thread

Java 多线程学习笔记:生产者消费者问题

前言:最近在学习Java多线程,看到ImportNew网上有网友翻译的一篇文章<阻塞队列实现生产者消费者模式>.在文中,使用的是Java的concurrent包中的阻塞队列来实现.在看完后,自行实现阻塞队列. (一)准备 在多线程中,生产者-消费者问题是一个经典的多线程同步问题.简单来说就是有两种线程(在这里也可以做进程理解)——生产者和消费者,他们共享一个固定大小的缓存区(如一个队列).生产者负责产生放入新数据,消费者负责取出缓存区的数据.具体介绍请参考 Producer-consumer