java多线程之生产者消费者经典问题 - 很不错的范例

<span style="font-size:14px;">/**生产者消费者问题,涉及到几个类 

 * 第一,这个问题本身就是一个类,即主类 

 * 第二,既然是生产者、消费者,那么生产者类和消费者类就是必须的 

 * 第三,生产什么,消费什么,所以物品类是必须的,这里是馒头类 

 * 第四,既然是线程,那么就不是一对一的,也就是说不是生产一个消费一个,既然这样,多生产的往哪里放, 

 *      现实中就是筐了,在计算机中也就是数据结构,筐在数据结构中最形象的就是栈了,因此还要一个栈类 

 */  

package thread;  

  

public class ProduceConsume {  

  

    public static void main(String[] args) {  

        SyncStack ss = new SyncStack();//建造一个装馒头的框  

        Producer p = new Producer(ss);//新建一个生产者,使之持有框  

        Consume c = new Consume(ss);//新建一个消费者,使之持有同一个框  

        Thread tp = new Thread(p);//新建一个生产者线程  

        Thread tc = new Thread(c);//新建一个消费者线程  

        tp.start();//启动生产者线程  

        tc.start();//启动消费者线程  

    }  

  

}  

  

//馒头类  

class SteamBread{  

    int id;//馒头编号  

    SteamBread(int id){  

        this.id = id;  

    }  

    public String toString(){  

        return "steamBread:"+id;  

    }  

}  

  

//装馒头的框,栈结构  

class SyncStack{  

    int index = 0;  

    SteamBread[] stb = new SteamBread[6];//构造馒头数组,相当于馒头筐,容量是6  

      

    //放入框中,相当于入栈  

    public synchronized void push(SteamBread sb){  

        while(index==stb.length){//筐满了,即栈满,  

            try {  

                this.wait();//让当前线程等待  

            } catch (InterruptedException e) {  

                // TODO Auto-generated catch block  

                e.printStackTrace();  

            }  

        }  

        this.notify();//唤醒在此对象监视器上等待的单个线程,即消费者线程  

        stb[index] = sb;  

        this.index++;  

    }  

      

    //从框中拿出,相当于出栈  

    public synchronized SteamBread pop(){  

        while(index==0){//筐空了,即栈空  

            try {  

                this.wait();  

            } catch (InterruptedException e) {  

                // TODO Auto-generated catch block  

                e.printStackTrace();  

            }  

        }  

        this.notify();  

        this.index--;//push第n个之后,this.index++,使栈顶为n+1,故return之前要减一  

        return stb[index];  

    }  

}  

  

//生产者类,实现了Runnable接口,以便于构造生产者线程  

class Producer implements Runnable{  

    SyncStack ss = null;  

    Producer(SyncStack ss){  

        this.ss = ss;  

    }  

    @Override  

    public void run() {  

        // 开始生产馒头  

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

            SteamBread stb = new SteamBread(i);  

            ss.push(stb);  

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

            try {  

                Thread.sleep(10);//每生产一个馒头,睡觉10毫秒  

            } catch (InterruptedException e) {  

                // TODO Auto-generated catch block  

                e.printStackTrace();  

            }  

        }  

    }  

}  

  

//消费者类,实现了Runnable接口,以便于构造消费者线程  

class Consume implements Runnable{  

    SyncStack ss = null;  

    public Consume(SyncStack ss) {  

        super();  

        this.ss = ss;  

    }  

    @Override  

    public void run() {  

        // TODO Auto-generated method stub  

        for(int i=0;i<20;i++){//开始消费馒头  

            SteamBread stb = ss.pop();  

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

            try {  

                Thread.sleep(100);//每消费一个馒头,睡觉100毫秒。即生产多个,消费一个  

            } catch (InterruptedException e) {  

                // TODO Auto-generated catch block  

                e.printStackTrace();  

            }  

        }  

    }     

}</span>  

运行结果:



你可能感兴趣的:(thread,消费者,计算机,package,public)