线程同步–生产者与消费者模式

生产者与消费者模式简单介绍：

生产者线程生产物品，然后将物品放置在一个空缓冲区中供消费者线程消费。消费者线程从缓冲区中获得物品，然后释放缓冲区。当生产者线程生产物品时，如果没有空缓冲区可用，那么生产者线程必须等待消费者线程释放出一个空缓冲区。当消费者线程消费物品时，如果没有满的缓冲区，那么消费者线程将被阻塞，直到新的物品被生产出来

以示例来说明问题：

以下程序参考至： http://www.iteye.com/topic/256991

首先是产品类：

Java代码 收藏代码

package consumerandproducter;  


/** 
 * 单纯的产品类 
 * @author google 
 * 
 */  
public class Product {  
    private int productId=0;  
    public Product(int id){  
        this.productId=id;  
    }  
    public int getProductId() {  
        return productId;  
    }  
    public String toString(){  
        return "product "+productId;  
    }  
}  

再是仓库（缓冲区）：

Java代码 收藏代码

package consumerandproducter;  

/** 
 * 模拟缓冲区，以栈为数据结构，先进后出 
 * @author google 
 * 
 */  
public class StoreHouse {  
    private int base=0;  
    private int top=0;  
    private Product[] products=new Product[10];  

    /** 
     * 入栈 
     * @param product 
     */  
    public synchronized  void push (Product product) {  
        while(top==products.length){  
            //当前的线程已经放弃对资源的占有，唤醒已经被wait的线程,唤醒的线程由JVM决定，不按优先级确定  
            notify();  
            try {  
                System.out.println("仓库已满，正在等待消费……");  
                wait();//此线程处于等待状态  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
        }  
        products[top]=product;  
        top++;  
    }  

    /** 
     * 出栈 
     * @return 
     */  
    public synchronized Product pop(){  
        Product product=null;  
        while(top==base){  
            notify();  
            try {  
                System.out.println("仓库已空，正在等待生产……");  
                wait();  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
        }  
        top--;  
        product=products[top];  
        products[top]=null;  
        return product;  
    }  
}  

接着是消费者：

Java代码 收藏代码

package consumerandproducter;  

public class Consumer implements Runnable {  
    private String consumerName;  
    //保留有缓冲区对象的引用,以便消费产品  
    private StoreHouse storeHouse;  

    public Consumer(String consumerName, StoreHouse storeHouse) {  
        this.consumerName = consumerName;  
        this.storeHouse = storeHouse;  
    }  

    public void run() {  
        while(true){  
            System.out.println("消费者"+consumerName+"已经消费"+storeHouse.pop());  
            try {  
                Thread.sleep(2000);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  

    }  

    public String getConsumerName() {  
        return consumerName;  
    }  
    public void setConsumerName(String consumerName) {  
        this.consumerName = consumerName;  
    }  

}  

然后是生产者：

Java代码 收藏代码

package consumerandproducter;  

/** 
 * 生产者类 
 * @author google 
 *  
 */  
public class Producter implements Runnable {  
    private String producterName;  

    //  保留有缓冲区对象的引用,以便将生产的产品放入缓冲区  
    private StoreHouse storeHouse;  

    public Producter(String producterName, StoreHouse storeHouse) {  
        this.producterName = producterName;  
        this.storeHouse = storeHouse;  
    }  


    public String getProducterName() {  
        return producterName;  
    }  


    public void setProducterName(String producterName) {  
        this.producterName = producterName;  
    }  

    public void producterProduct(){  
        //生产产品，并放入到仓库中  
        int i=0;  
        while(true){  
            i++;  
            Product product=new Product(i);  
            storeHouse.push(product);  
            System.out.println(producterName+"生产了");  
            try {  
                Thread.sleep(2000);  
            } catch (InterruptedException e) {  
                return;  
            }  
        }  
    }  

    public void run() {  
        producterProduct();  
    }  

}  

测试类：

Java代码 收藏代码

package consumerandproducter;  

import sun.security.krb5.internal.crypto.t;  

public class Test {  
    public static void main(String[] args) {  
        StoreHouse storeHouse=new StoreHouse();  
        Producter producter=new Producter("生产者",storeHouse);  
        Consumer consumer=new Consumer("消费者",storeHouse);  
        Thread t1=new Thread(producter);  
        Thread t2=new Thread(consumer);  
        t1.start();  
        t2.start();  
        /** 
         * ~输出(随机抽取输出，每次测试的结果可能都有稍许不同)： 
         *  
                生产者生产了 
                消费者消费者已经消费product 1 
                生产者生产了 
                消费者消费者已经消费product 2 
                生产者生产了 
                消费者消费者已经消费product 3 
                生产者生产了 
                消费者消费者已经消费product 4 
                ........... 
                仓库已空，正在等待生产…… 
                生产者生产了 
                生产者生产了 
                生产者生产了 
                生产者生产了 
                ......... 
                仓库已满，正在等待消费…… 
            消费者消费者已经消费product 14 
            消费者消费者已经消费product 13 
            消费者消费者已经消费product 12 
            消费者消费者已经消费product 11 
            消费者消费者已经消费product 10 
                ...... 

         */  
    }  
}  

小结：

此问题主要是考察java间多线程通信与资源同步, 其中主要是对于notify与wait方法的使用上，还有对于线程间资源的共享，利用synchronized关键字，对共享资源的锁定，以达到线程同步的效果。