生产者消费者实例

package com.ixhong.base.thread.base;

public class ProducerConsumer {
   public static void main(String[] args) {
      SyncStack ss = new SyncStack();

      new Thread(new Producer(ss, "p1")).start();
      new Thread(new Consumer(ss, "c1")).start();
      new Thread(new Producer(ss, "p2")).start();
      new Thread(new Consumer(ss, "c2")).start();
   }
}

class WoTou {
   private int id;

   public WoTou(int id) {
      this.id = id;
   }

   public int getId() {
      return id;
   }

   public String toString() {
      return "WT" + getId();
   }
}

class SyncStack {
   private int index = 0;
   private WoTou[] arrWT = new WoTou[6];

   public synchronized void push(WoTou wt) {
      while (index == arrWT.length) {
         try {
            this.wait();
         } catch (InterruptedException e) {}
      }
      this.notifyAll();
      arrWT[index++] = wt;
   }

   public synchronized WoTou pop() {
      while (index == 0) {
         try {
            this.wait();
         } catch (InterruptedException e) {}
      }
      this.notifyAll();
      return arrWT[--index];
   }
}

class Producer implements Runnable {
   private SyncStack ss = null;
   private String name;

   public Producer(SyncStack ss, String name) {
      this.ss = ss;
      this.name = name;
   }

   public String getName() {
      return name;
   }

   public void run() {
      for (int i = 0; i < 60; i++) {
         WoTou wt = new WoTou(i);
         ss.push(wt);
         System.out.println(getName() + "生产" + wt);
         try {
            Thread.sleep((long) (Math.random() * 100));
         } catch (InterruptedException e) {}
      }
   }
}

class Consumer implements Runnable {
    private SyncStack ss = null;
    private String name;

   public Consumer(SyncStack ss, String name) {
      this.ss = ss;
      this.name = name;
   }

   public String getName() {
      return name;
   }

   public void run() {
      for (int i = 0; i < 60; i++) {
         WoTou wt = ss.pop();
         System.out.println(getName() + "消费" + wt);
         try {
            Thread.sleep((long) (Math.random() * 400));
         } catch (InterruptedException e) {}
      }
   }
}
时间: 2024-10-21 19:57:11

生产者消费者实例的相关文章

用条件变量来解决生产者消费者问题

在上一篇文章中,我使用了匿名信号量 什么是条件变量? 我们可以设想一个场景:线程A需要某个条件成立才能继续执行,否则一直等待下去,而线程B执行过程中使线程的执行条件成立,并且唤醒A. 举个例子,在生产者消费者模型中,消费者如果看到缓冲区为空时,就等待,而生产者往缓冲区添加完数据后,唤醒消费者. 其中这个场景中,可以POSIX的条件变量来实现. 以下是条件变量所需要的函数 pthread_cond_init pthread_cond_destroy pthread_cond_wait pthrea

使用阻塞队列实现生产者-消费者模型

1.生产者-消费者问题 生产者消费者问题也称作有界缓冲区(bounded-buffer)问题, 是操作系统中一个经典的线程同步问题,问题描述如下: 生产者在生产产品提供给若干个消费者去消费,为了使生产者和消费者能并发执行,在两者之间设置一个具有多个缓冲区,生产者将它生产的产品放入缓冲区中,消费者可以从缓冲区中取走产品进行消费,两个进程共享一个公共的固定大小的缓冲区. 显然生产者和消费者之间必须保持同步,即不允许消费者到一个空的缓冲区中取产品,也不允许生产者向一个已经放入产品的缓冲区中再次投放产品

聊聊并发(十)生产者消费者模式

本文首发于InfoQ   作者:方腾飞  校对:张龙 在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题.该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度. 为什么要使用生产者和消费者模式 在线程世界里,生产者就是生产数据的线程,消费者就是消费数据的线程.在多线程开发当中,如果生产者处理速度很快,而消费者处理速度很慢,那么生产者就必须等待消费者处理完,才能继续生产数据.同样的道理,如果消费者的处理能力大于生产者,那么消费者就必须等待生产者.为了解决这种生产消费能力

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

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

生产者消费者问题的java实现

生产者和消费者是多线程经典的问题,生产者和消费者问题的核心是同步的问题,同步问题的核心是要保证同一个资源被多个线程并发访问时的完整性,常用的方法是采用信号或加锁机制,保证资源在任一时刻只能被一个线程访问.这一问题用java来实现的话主要有4种方式.1.wait()/notify():2.await()/signal(); 3.blockingQuene 4.PipedInputStream/pipedOutputStream 下面分别来实现. 1.利用wait()和notify()来实现 Wai

java多线程解决生产者消费者问题_java

本文实例讲述了java多线程解决生产者消费者问题的方法.分享给大家供大家参考.具体分析如下: 题目是这样的: 采用Java 多线程技术,设计实现一个符合生产者和消费者问题的程序.对一个对象(枪膛)进行操作,其最大容量是12颗子弹.生产者线程是一个压入线程,它不断向枪膛中压入子弹:消费者线程是一个射出线程,它不断从枪膛中射出子弹. 要求: (1)给出分析过程说明. (2)程序输出,要模拟体现对枪膛的压入和射出操作: (2)设计程序时应考虑到两个线程的同步问题. 这个和著名的生产者消费者问题几乎是一

python 多线程笔记(6)-- 生产者/消费者模式(续)

  用 threading.Event() 也可以实现生产者/消费者模式 (自己拍脑袋想出来的,无法知道其正确性,请大神告知为谢!)   import threading import time import random products = 20 class Producer(threading.Thread): '''生产者''' ix = [0] # 生产者实例个数 # 闭包,必须是数组,不能直接 ix = 0 def __init__(self): super().__init__()

python 多线程笔记(5)-- 生产者/消费者模式

  我们已经知道,对公共资源进行互斥访问,可以使用Lock上锁,或者使用RLock去重入锁.   但是这些都只是方便于处理简单的同步现象,我们甚至还不能很合理的去解决使用Lock锁带来的死锁问题. 要解决更复杂的同步问题,就必须考虑别的办法了.   threading提供的Condition对象提供了对复杂线程同步问题的支持. Condition被称为条件变量,除了提供与Lock类似的acquire和release方法外,还提供了wait和notify方法.   使用Condition的主要方式

并发编程(二):分析Boost对 互斥量和条件变量的封装及实现生产者消费者问题

请阅读上篇文章<并发编程实战: POSIX 使用互斥量和条件变量实现生产者/消费者问题>.当然不阅读亦不影响本篇文章的阅读. Boost的互斥量,条件变量做了很好的封装,因此比"原生的"POSIX mutex,condition variables好用.然后我们会通过分析boost相关源码看一下boost linux是如何对pthread_mutex_t和pthread_cond_t进行的封装. 首先看一下condition_variable_any的具体实现,代码路径:/