生产者与消费者问题解决：解决先打印出消费的情况

有bug 的代码（马士兵老师讲解的）：

<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();//唤醒在此对象监视器上等待的单个线程，当前对象为syncstack
        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>  

解决方法：

http://blog.csdn.net/u013243986/article/details/48755183

看过 http://blog.csdn.net/thinkpadshi/article/details/8163751     下面的评论说:    感觉你的代码有问题啊，两个run()方法里面的打印语句的执行先后问题，假设开始在消费时index==0;这时wait()了，生产者便抢到锁，index+1;同时叫醒消费者，这个时候要是消费者先于生产者的打印了一条消费了0个，之后再打印生产了0个怎么办？？！,我执行后也发现这样的问题,如果把100毫秒改为10毫秒,会有更多这样的情况产生.

于是自己改了下博主的代码:

package deadLockThread;  
  
public class SX {  
    public static void main(String[] args) {  
        ProductList pl = new ProductList();  
        Factory f = new Factory(pl);  
        Consumer c = new Consumer(pl);  
  
        Thread t1 = new Thread(f);  
        Thread t2 = new Thread(c);  
  
        t1.start();  
        t2.start();  
  
    }  
}  
  
class Product {  
    private int id;  
  
    Product(int id) {  
        this.id = id;  
    }  
  
    @Override  
    public String toString() {  
        return "Product [id=" + id + "]";  
    }  
  
}  
  
class ProductList {  
    int index = 0;  
    private Product[] p = new Product[6];  
  
    public synchronized void push(Product pr) {  
  
        while (index == p.length) {  
            try {  
                this.wait();  
            } catch (InterruptedException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }  
        }  
        this.notify();  
        p[index] = pr;  
        <span style="color:#ff0000;">System.out.println("生产了" + p[index]);</span>  
        index++;  
  
    }  
  
    public synchronized Product pop() {  
  
        while (index == 0) {  
            try {  
                this.wait();  
            } catch (InterruptedException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }  
        }  
        this.notify();  
        index--;  
        <span style="color:#ff0000;">System.out.println("消费了" + p[index]);</span>  
        return p[index];  
  
    }  
}  
  
class Factory implements Runnable {  
  
    private ProductList pl = null;  
  
    Factory(ProductList pl) {  
        this.pl = pl;  
    }  
  
    @Override  
    public void run() {  
        // TODO Auto-generated method stub  
        for (int i = 0; i < 20; i++) {  
            Product p = new Product(i);  
            pl.push(p);  
            try {  
                Thread.sleep(10);  
            } catch (InterruptedException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }  
        }  
  
    }  
}  
  
class Consumer implements Runnable {  
    private ProductList pl = null;  
  
    Consumer(ProductList pl) {  
        this.pl = pl;  
    }  
  
    @Override  
    public void run() {  
        // TODO Auto-generated method stub  
        for (int i = 0; i < 20; i++) {  
            Product p = pl.pop();  
            try {  
                Thread.sleep(10);  
            } catch (InterruptedException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }  
        }  
  
    }  
}

我就只是改动了  输出的位置 这是由于System.out.println()函数不是立刻就打印的,它要调用其他的函数来完成输出,所以System.out.println("生产了" + p[index]);  还有 System.out.println("消费了" + p[index]);具体的打印时间就不确定了.   但是如果把输出打印放在同步代码块里面,就不会有这样的问题.因为会完成打印之后才会执行下一步.