JAVA_线程同步_生产者消费者问题

 1 public class ProducerConsumer {
 2     public static void main(String[] args) {
 3         SyncStack ss = new SyncStack();
 4         Producer p = new Producer(ss);
 5         Consumer c = new Consumer(ss);
 6         new Thread(p).start();
 7         new Thread(p).start();
 8         new Thread(p).start();
 9         new Thread(c).start();
10     }
11 }
12
13 class WoTou {
14     int id;
15     WoTou(int id) {
16         this.id = id;
17     }
18     public String toString() {
19         return "WoTou : " + id;
20     }
21 }
22
23 class SyncStack {
24     int index = 0;
25     WoTou[] arrWT = new WoTou[6];
26
27     public synchronized void push(WoTou wt) {
28         while(index == arrWT.length) {
29             try {
30                 this.wait();
31             } catch (InterruptedException e) {
32                 e.printStackTrace();
33             }
34         }
35         this.notifyAll();
36         arrWT[index] = wt;
37         index ++;
38     }
39
40     public synchronized WoTou pop() {
41         while(index == 0) {
42             try {
43                 this.wait();
44             } catch (InterruptedException e) {
45                 e.printStackTrace();
46             }
47         }
48         this.notifyAll();
49         index--;
50         return arrWT[index];
51     }
52 }
53
54 class Producer implements Runnable {
55     SyncStack ss = null;
56     Producer(SyncStack ss) {
57         this.ss = ss;
58     }
59
60     public void run() {
61         for(int i=0; i<20; i++) {
62             WoTou wt = new WoTou(i);
63             ss.push(wt);
64 System.out.println("生产了:" + wt);
65             try {
66                 Thread.sleep((int)(Math.random() * 200));
67             } catch (InterruptedException e) {
68                 e.printStackTrace();
69             }
70         }
71     }
72 }
73
74 class Consumer implements Runnable {
75     SyncStack ss = null;
76     Consumer(SyncStack ss) {
77         this.ss = ss;
78     }
79
80     public void run() {
81         for(int i=0; i<60; i++) {
82             WoTou wt = ss.pop();
83 System.out.println("消费了: " + wt);
84             try {
85                 Thread.sleep((int)(Math.random() * 1000));
86             } catch (InterruptedException e) {
87                 e.printStackTrace();
88             }
89         }
90     }
91 }
时间: 2024-12-23 19:07:33

JAVA_线程同步_生产者消费者问题的相关文章

线程同步之生产者消费者

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

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

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

linux中的线程同步:生产者、消费者问题

#include <stdio.h> #include <semaphore.h> #include <unistd.h> #include <stdlib.h> #include <pthread.h> #define BUFFER_COUNT 5 int Buffer[BUFFER_COUNT]; //指针数组 int front = 0; int tail = 0; sem_t SemProd; sem_t SemCon; void* pr

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

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

进程_线程 之(五) --- 生产者消费者

同步锁 acquire([timeout])/release():  调用关联的锁的相应方法. wait([timeout]):   调用这个方法将使线程进入Condition的等待池等待通知,并释放锁.使用前线程必须已获得锁定,否则将抛出异常. notify():   调用这个方法将从等待池挑选一个线程并通知,收到通知的线程将自动调用acquire()尝试获得锁定(进入锁定池):其他线程仍然在等待池中.调用这个方法不会释放锁定.使用前线程必须已获得锁定,否则将抛出异常. notifyAll()

Java线程同步模型-生产者与消费者

Java生产者与消费者模型是经典Java线程同步模型,涉及使用同步锁控制生产者线程和消费者线程同步运行问题.同步对象是仓库资源,生产者线程生产向仓库中生产商品,消费者线程从仓库中消费商品,当生产者线程生产的商品达到仓库的90%时,生产者线程停止生产并通知消费者线程开始消费,当消费者线程消耗到仓库的10%时,消费者线程停止消费并通知生产者线程恢复生产,如此循环往复过程. 如下图解: T1时刻分析 T2时刻 T3时刻 T4时刻 上图的分析,T3同T1时刻相同场景,T2同T2时刻相同场景,程序如此循环

Linux多线程之同步2 &mdash;&mdash; 生产者消费者模型

思路 生产者和消费者(互斥与同步).资源用队列模拟(要上锁,一个时间只能有一个线程操作队列). m个生产者.拿到锁,且产品不满,才能生产.当产品满,则等待,等待消费者唤醒.当产品由空到不空,通知消费者.n个消费者.拿到锁,且有产品,才能消费.当产品空,则等待,等待生产者唤醒.当产品由满到不满,通知生产者.    生产者条件:队列不满消费者条件:队列不空因此有两个条件变量. 代码 /**********************************************************

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

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

python 线程同步:生产/消费者模式

Python中的Queue对象提供了对线程同步的支持,使用queue对象可以实现多生产者和多消费者形成的先进先出的队列. 每个生产者将数据放入队列,而每个消费者依次从队列中取出数据. # coding:utf-8 import threading,time,Queue class Producer(threading.Thread):     def __init__(self,threadname):         threading.Thread.__init__(self,name=th