生产者消费者问题

import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.BlockingQueue;

public class TestProducerAndConsumer {

 @SuppressWarnings("unchecked")

 public static void main(String[] args) {

 BlockingQueue q = new ArrayBlockingQueue(2);

 Producer p = new Producer(q);

 Consumer c1 = new Consumer(q);

 Consumer c2 = new Consumer(q);

 new Thread(p).start();

 new Thread(c1).start();

 new Thread(c2).start();

class Consumer implements Runnable {

 private final BlockingQueue queue;

 Consumer(BlockingQueue q) {

 queue = q;

 public void run() {

 try {

 while (true) {

 consume(queue.take());

 } catch (InterruptedException ex) {

 ex.printStackTrace();

 void consume(Object x) {

 System.out.println("Consumer");

class Producer implements Runnable {

 @SuppressWarnings("unchecked")

 private final BlockingQueue queue;

 @SuppressWarnings("unchecked")

 Producer(BlockingQueue q) {

 queue = q;

 @SuppressWarnings("unchecked")

 public void run() {

 try {

 while (true) {

 queue.put(produce());

 } catch (InterruptedException ex) {

 ex.printStackTrace();

 Object produce() {

 System.out.println("Producer");

 return new Object();

public class ProducerConsumer {

 public static void main(String[] args) {

 SyncStack ss = new SyncStack();

 Producer p = new Producer(ss);

 Consumer c = new Consumer(ss);

 new Thread(p).start();

 new Thread(p).start();

 new Thread(p).start();

 new Thread(c).start();

class WoTou {

 int id; 

 WoTou(int id) {

 this.id = id;

 public String toString() {

 return "WoTou : " + id;

class SyncStack {

 int index = 0;

 WoTou[] arrWT = new WoTou[6];

 public synchronized void push(WoTou wt) {

 while(index == arrWT.length) {

 try {

 this.wait();

 } catch (InterruptedException e) {

 e.printStackTrace();

 this.notifyAll(); 

 arrWT[index] = wt;

 index ++;

 public synchronized WoTou pop() {

 while(index == 0) {

 try {

 this.wait();

 } catch (InterruptedException e) {

 e.printStackTrace();

 this.notifyAll();

 index--;

 return arrWT[index];

class Producer implements Runnable {

 SyncStack ss = null;

 Producer(SyncStack ss) {

 this.ss = ss;

 public void run() {

 for(int i=0; i i++) {

 WoTou wt = new WoTou(i);

 ss.push(wt);

System.out.println("生产了：" + wt);

 try {

 Thread.sleep((int)(Math.random() * 200));

 } catch (InterruptedException e) {

 e.printStackTrace();

class Consumer implements Runnable {

 SyncStack ss = null;

 Consumer(SyncStack ss) {

 this.ss = ss;

 public void run() {

 for(int i=0; i i++) {

 WoTou wt = ss.pop();

System.out.println("消费了: " + wt);

 try {

 Thread.sleep((int)(Math.random() * 1000));

 } catch (InterruptedException e) {

 e.printStackTrace();

}

生产者消费者问题-代码详解（Java多线程） 你好我是辰兮，很高兴你能来阅读，本篇是整理了Java多线程中常见的生产者消费者问题，也是面试手写代码的高频问题，分享获取新知，大家共同进步！
Linux线程编程之生产者消费者问题【转】 转自：http://www.cnblogs.com/clover-toeic/p/4029269.html      本文基于顺序循环队列，给出Linux生产者/消费者问题的多线程示例，并讨论编程时需要注意的事项。