ProducerConsumerDemo

package algorithm;

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) {
            }
        }
    }
}

Output:

p1生产WT0
p2生产WT0
c1消费WT0
c2消费WT0
p2生产WT1
p1生产WT1
p2生产WT2
p2生产WT3
p2生产WT4
p2生产WT5
c2消费WT5
p2生产WT6
c1消费WT6
p1生产WT2
c2消费WT2
p1生产WT3
c2消费WT3
p2生产WT7
c1消费WT7
p1生产WT4
c2消费WT4
p1生产WT5
c2消费WT5
p2生产WT8
c1消费WT8
p2生产WT9
c1消费WT9
p1生产WT6
p2生产WT10
c2消费WT6
c1消费WT10
p2生产WT11
p2生产WT12
c2消费WT11
c1消费WT12
p2生产WT13
c2消费WT13
p2生产WT14
c1消费WT14
p1生产WT7
c1消费WT7
p2生产WT15
c2消费WT15
p2生产WT16
p2生产WT17
c2消费WT16
c1消费WT17
p2生产WT18
c2消费WT18
p2生产WT19
p2生产WT20
c1消费WT19
c2消费WT20
p2生产WT21
p1生产WT8
c2消费WT21
p2生产WT22
c2消费WT8
c1消费WT22
p1生产WT9
c2消费WT9
p1生产WT10
c1消费WT10
p1生产WT11
c2消费WT11
p2生产WT23
c2消费WT23
p2生产WT24
c1消费WT24
p1生产WT12
c1消费WT12
p2生产WT25
c2消费WT25
p2生产WT26
p2生产WT27
c1消费WT26
c1消费WT27
p1生产WT13
c1消费WT13
p1生产WT14
c2消费WT14
p2生产WT28
c2消费WT28
p2生产WT29
c1消费WT29
p2生产WT30
c2消费WT30
p2生产WT31
p2生产WT32
c1消费WT31
c2消费WT32
p2生产WT33
c1消费WT33
p2生产WT34
c2消费WT34
p2生产WT35
c1消费WT35
p1生产WT15
c1消费WT15
p1生产WT16
p2生产WT36
c2消费WT16
c2消费WT36
p1生产WT17
c2消费WT17
p2生产WT37
c1消费WT37
p1生产WT18
c1消费WT18
p1生产WT19
c2消费WT19
p1生产WT20
c1消费WT20
p1生产WT21
p1生产WT22
c2消费WT21
c1消费WT22
p1生产WT23
c1消费WT23
p1生产WT24
c2消费WT24
p1生产WT25
c2消费WT25
p2生产WT38
p1生产WT26
c2消费WT38
c2消费WT26
p1生产WT27
c2消费WT27
p1生产WT28
c1消费WT28
p1生产WT29
c2消费WT29
p1生产WT30
c2消费WT30
p1生产WT31
c1消费WT31
p1生产WT32
c2消费WT32
p1生产WT33
c1消费WT33
p1生产WT34
p2生产WT39
c2消费WT34
c2消费WT39
p1生产WT35
p1生产WT36
c1消费WT35
p2生产WT40
c2消费WT36
p2生产WT41
c2消费WT40
c2消费WT41
p2生产WT42
c1消费WT42
p2生产WT43
p1生产WT37
c1消费WT43
p1生产WT38
c2消费WT37
c1消费WT38
p2生产WT44
c2消费WT44
p2生产WT45
c1消费WT45
p2生产WT46
c1消费WT46
p2生产WT47
c2消费WT47
p2生产WT48
c1消费WT48
p1生产WT39
c1消费WT39
p2生产WT49
c2消费WT49
p2生产WT50

http://ixhong.iteye.com/blog/2228623

时间: 2024-12-23 05:35:56

ProducerConsumerDemo的相关文章

Java多线程技术学习笔记(二)

目录: 线程间的通信示例 等待唤醒机制 等待唤醒机制的优化 线程间通信经典问题:多生产者多消费者问题 多生产多消费问题的解决 JDK1.5之后的新加锁方式 多生产多消费问题的新解决办法 sleep和wait的区别 停止线程的方式 守护线程 线程的其他知识点 一.线程间的通信示例 返目录回 多个线程在处理同一资源,任务却不同. 假设有一堆货物,有一辆车把这批货物往仓库里面运,另外一辆车把前一辆车运进仓库的货物往外面运.这里货物就是同一资源,但是两辆车的任务却不同,一个是往里运,一个是往外运. 下面

java多线程详解

转自:线程间通信.等待唤醒机制.生产者消费者问题(Lock,Condition).停止线程和守护线程.线程优先级 1  线程间通信 1.1  线程间通信 其实就是多个线程在操作同一个资源,但是操作的动作不同. 比如一个线程给一个变量赋值,而另一个线程打印这个变量. 1.2  等待唤醒机制 wait():将线程等待,释放了CPU执行权,同时将线程对象存储到线程池中. notify():唤醒线程池中一个等待的线程,若线程池有多个等待的线程,则任意唤醒一个. notifyAll():唤醒线程池中,所有

黑马程序员——java基础---多线程(二)

------Java培训.Android培训.iOS培训..Net培训.期待与您交流! -------  线程间的通信:简单来说,就是多个线程在操作同一资源,但操作的动作不同. 试想一下,对于同一个资源做不同的操作,这势必会在操作的过程中产生矛盾.为了避免这种情况的发生,就需要用的synchronized来保证,每次对共享资源的操作,只能是一条线程在进行.在用到同步的时候,就会因需求问题用到wait().notify().notifyAll()这三个方法. wait()方法:作用是使调用线程自动

黑马程序员——多线程

一.概述 (一)进程 正在执行中的程序,每一个进程执行都有一个执行顺序.该顺序是一个执行路径,或者叫一个控制单元. (二)线程 进程中的一个独立的控制单元.线程在控制着进程的执行.一个进程中至少有一个线程.只要进程中有一个线程在执行,进程就不会结束. (三)多线程 在java虚拟机启动的时候会有一个java.exe的执行程序,也就是一个进程.该进程中至少有一个线程负责java程序的执行.而且这个线程运行的代码存在于main方法中.该线程称之为主线程.JVM启动除了执行一个主线程,还有负责垃圾回收

黑马程序员---Java多线程

---------------------- Android开发.java培训.期待与您交流! ---------------------- 线程与进程是程序运行中体现的两个名词,它包含这不同的程序域.进程指的是一个正在运行的程序,如:360,QQ运行时就是不同的两个进程.当你打开windows任务管理器时,看到的每个进程就是此时windows中正在运行的程序.线程则就是进程中的一个个独立的控制单元,线程控制着进程的执行,也就是说每个正在运行的程序中就包括着很多的线程. 主线程:Java虚拟机运

Java高新技术——多线程与并发库(上)

本系列文章旨在分享Java5多线程与并法库的高级应用示例,所用到的大多数类均在java.util.concurrent包下. 传统线程技术回顾 package ustc.lichunchun.thread; /* * 创建线程的两种传统方式 */ public class TraditionalThread { public static void main(String[] args) { //在Thread子类覆盖的run方法中编写运行代码 Thread t1 = new Thread(){

黑马程序员_Java基础:多线程总结

------- android培训.java培训.期待与您交流! ---------- 一.多线程的概念 进程和线程经常会被人混淆,那是因为对它们的概念不明确.就拿我们平时使用的操作系统来说,它是多任务的操作系统,而多线程就是实现多任务的一种方式. 进程是指一个内存中运行的应用程序,每个进程都有自己独立的一块内存空间,一个进程中可以启动多个线程.比如在Windows系统中,一个运行的exe就是一个进程.  线程是指进程中的一个执行流程,一个进程中可以运行多个线程.比如平时下载的软件迅雷进程中可以

黑马程序员--多线程同步的一层对象/二层对象/三层对象写法对比

------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 前言: 在面向对象的思想下,线程的写法根据要创建的对象层级可以分为三种写法: 1,一层对象写法:采用extends Thread,复写父类的run()方法,直接建立一个线程实例对象的方式,这种方式简单,适用于单任务的单线程需求.在此不做过多讨论; 2,二层对象写法:采用implements Runnable接口,复写接口的run()方法,得到二级对象--通常称为任务对象;再通过将二级对象传入(

多线程同步(Lock)

实例 模仿生产者和消费者的模式 先来个两个线程的 class ProducerConsumerDemo { public static void main(String[] args) { Res r=new Res(); Pro in=new Pro(r); Cou out=new Cou(r); Thread t1=new Thread(in); Thread t2=new Thread(out); t1.start(); t2.start(); } } class Res { privat