线程通信之生产者消费者阻塞队列版

class MyResource {    private volatile boolean FLAG = true; //默认开启,进行生产+消费    private AtomicInteger atomicInteger = new AtomicInteger();

    BlockingQueue<String> blockingQueue = null;

    public MyResource(BlockingQueue<String> blockingQueue) {        this.blockingQueue = blockingQueue;    }

    public void myProduct() throws Exception {        String data = null;        boolean retValue;        while (FLAG) {            data  = atomicInteger.incrementAndGet()+"";            retValue = blockingQueue.offer(data,2L, TimeUnit.SECONDS);            if(retValue) {                System.out.println(Thread.currentThread().getName() +"\t 插入队列" + data +"成功");            } else {                System.out.println(Thread.currentThread().getName() +"\t 插入队列" + data +"失败");            }            TimeUnit.SECONDS.sleep(1);        }        System.out.println(Thread.currentThread().getName()+"\t 大老板叫停了,表示FLAG = false,生产动作结束");    }

    public void myConsumer() throws Exception {        String result = null;        while(FLAG) {            result = blockingQueue.poll(2L,TimeUnit.SECONDS);            if(null == result || result.equalsIgnoreCase("")) {                FLAG = false;                System.out.println(Thread.currentThread().getName()+"\t超过2秒钟没有取到蛋糕,消费退出");                System.out.println();                System.out.println();                return ;            }            System.out.println(Thread.currentThread().getName()+"\t消费队列"+result +"成功");

        }    }

    public void stop() {        this.FLAG = false;    }}

public class ProductConsumer_BlockQueueDemo {    public static void main(String[] args){        MyResource myResource = new MyResource(new ArrayBlockingQueue<String>(10));        new Thread(() ->{            System.out.println(Thread.currentThread().getName()+"\t生产线程启动");            try {                myResource.myProduct();            } catch (Exception e) {                e.printStackTrace();            }

        },"product").start();

        new Thread(() ->{            System.out.println(Thread.currentThread().getName()+"\t消费线程启动");            try {                myResource.myConsumer();            } catch (Exception e) {                e.printStackTrace();            }

        },"consumer").start();        //暂停一会儿线程        try {TimeUnit.SECONDS.sleep(5);} catch (InterruptedException e) { e.printStackTrace(); }        System.out.println();        System.out.println();        System.out.println();        System.out.println("5秒时间到,大老板main线程叫停,活动结束");        myResource.stop();    }}

运行结果见下图:

原文地址:https://www.cnblogs.com/liuyi13535496566/p/12154242.html

时间: 2024-07-31 00:47:48

线程通信之生产者消费者阻塞队列版的相关文章

Condition线程通信_生产者消费者案例

①Condition 接口描述了可能会与锁有关联的条件变量. 这些变量在用 法上与使用 Object.wait 访问的隐式监视器类似,但提供了更强大的 功能. 需要特别指出的是,单个 Lock 可能与多个 Condition 对象关 联. 为了避免兼容性问题,Condition 方法的名称与对应的 Object 版 本中的不同.② 在 Condition 对象中,与 wait.notify 和 notifyAll 方法对应的分别是 await.signal 和 signalAll.③ Condi

java 线程 生产者-消费者与队列,任务间使用管道进行输入、输出 讲解示例 --thinking java4

package org.rui.thread.block2; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; import java.util.concurrent.LinkedB

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

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

LabVIEW之生产者/消费者模式--队列操作 彭会锋

LabVIEW之生产者/消费者模式--队列操作 彭会锋 本文章主要是对学习LabVIEW之生产者/消费者模式的学习笔记,其中涉及到同步控制技术-队列.事件.状态机.生产者-消费者模式,这几种技术在在本章中都会有侧重点的进行介绍和总结! 队列同步技术-操作函数 同步控制技术可以实现在多个VI之间或者同一VI 不同县城之间同步任务和交换数据:在LabVIEW中提供了‘同步’函数选板,包括通知器.队列.信号量.集合点.事件.首次调用函数,本文主要关注同步控制技术之队列技术: 队列操作函数: 1 “获取

线程通信(生产者与消费者问题)

1.线程通信的必要性 多线程不仅共享资源,而且相互牵制向前运行. 2.线程通信的方法(都是在Object中定义) 3个方法: 1)    wait() 可运行转入阻塞状态,放锁 2)    notify() 阻塞转入可运行状态,获得锁 3)    notifyAll() 所有调用wait方法而被挂起的线程重新启动,有个条件:wait与notifyAll必须是属于同一个对象 必须在同步方法或同步代码块中使用 3.共享资源类(仓库) 注:共享资源(产品),牵制信息(产品有无)  package co

线程安全的生产者消费者四种实现方法

问题描述 在IT技术面试过程中,我们经常会遇到生产者消费者问题(Producer-consumer problem), 这是多线程并发协作问题的经典案例.场景中包含三个对象,生产者(Producer),消费者(Consumer)以及一个固定大小的缓冲区(Buffer).生产者的主要作用是不断生成数据放到缓冲区,消费者则从缓冲区不断消耗数据.该问题的关键是如何线程安全的操作共享数据块,保证生产者线程和消费者线程可以正确的更新数据块,主要考虑 1. 生产者不会在缓冲区满时加入数据. 2. 消费者应当

线程同步之生产者消费者

前言: 前面因时间关系,未将“生产者消费者问题”实例的介绍发布在博客随笔中,故本文作为对之前“多线程”一文的补充.概念: 生产者消费者问题(Bounded-buffer problem),是一个多线程同步问题的经典案例.这个案例中主要实现的是两个角色协同对同一资源进行访问.生产者的主要作用是生成一定量的数据放到缓冲区中,然后重复此过程.与此同时,消费者也在缓冲区消耗这些数据.该问题的关键就是要保证生产者不会在缓冲区满时加入数据,消费者也不会在缓冲区中空时消耗数据. 设计:本博客前面关于多线程的文

并发通信、生产者消费者模型

多进程之间通信的限制 看一个例子: import multiprocessing as mp data=666 def func(): global data data=222 p=mp.Process(target=func) p.start() p.join() print(data) >>>666 可以看到,声明为global的data也没有发生变化,输出结果仍然是666,这正是多进程之间通信的限制,各个进程之间是相互独立的,互不干扰的内存空间.因此如果想要空想数据就必须开辟一段共

基于线程实现的生产者消费者模型(Object.wait(),Object.notify()方法)

需求背景 利用线程来模拟生产者和消费者模型 系统建模 这个系统涉及到三个角色,生产者,消费者,任务队列,三个角色之间的关系非常简单,生产者和消费者拥有一个任务队列的引用,生产者负责往队列中放置对象(id),消费者负责从队列中获取对象(id),其关联关系如下 方案1 因为是多线程操作,所以对任务的存取都要使用线程同步加锁机制,看一下我们的TaskQueue类,两个主方法都加了synchronized修饰,这就意味着,一个时间点只可能有一个线程对这个方法进行操作 TaskQueue类代码 [java