生产者和消费者模式--java设计模式

生产者和消费者：

          就犹如在快餐店点餐一样，有多个打饭的，有不定时的人来买饭，买饭的人从快餐店自动取餐，如果快餐的库存数量达到下限值时，自动启动打饭的，补充盒饭。

         通过while循环的方式，传入变量isStop，来判断是否结束当前while循环。    

package jquery.test.interview;

import java.util.Vector;

public class Productor<T> implements Runnable {
    
    private volatile Vector<T> v;
    
    private volatile boolean flg = true;
    private volatile boolean procFlg = true;
    
    public Productor(Vector<T> v){
         this.v = v;
    }
    
    /**
     * 生产产品
     * @return
     */
    public void createProduct(){
        synchronized(v){
            while(flg){
                System.out.println("库存产品数....1.." + v.size());
                if((v.isEmpty() || v.size() < 3) && procFlg){
                    System.out.println("库存紧张，开始生产......");
                    v.add((T)"product1.....");
                    v.add((T)"product2.....");
                    v.add((T)"product3.....");
                    v.add((T)"product4.....");
                    v.add((T)"product5.....");
                }
                //开始等待
                try {
                    System.out.println("库存产品数...2..." + v.size());
                    v.notifyAll();
                    v.wait();
                } catch (InterruptedException e) {
                    v.notifyAll();
                }
            }
            if(!flg){
                System.out.println("-------------stop proc ---");
                v.notifyAll();
            }
        }
    }

    @Override
    public void run() {
        createProduct();
    }
    
    public void stop(){
        flg = false;
    }
    
    public void stopProc(){
        procFlg = false;
    }

}

package jquery.test.interview;

import java.util.Vector;

public class Customer<T> implements Runnable {
    
    private volatile Vector<T> vector;
    
    private volatile boolean flag2 = true;
    
    public Customer(Vector<T> vector){
        this.vector = vector;
    }
    
    public  void getProduct(){
        synchronized(vector){
            System.out.println("-----stop---customer--222222222-");
            while(flag2){
                System.out.println("-----flag2----^^^^-");
                if(null == vector || vector.isEmpty()){
                    try {
                        System.out.println("--没有产品等待中.....");
                        vector.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else{
                    System.out.println("--获取产品使用....." + vector.get(0));
                    vector.remove(0);
                    vector.notify();
                }
            }
            if(!flag2){
                System.out.println("-----stop---customer---");
                vector.notifyAll();
            }
        }
    }

    @Override
    public void run() {
        getProduct();
    }
    
    public void stop(){
        flag2 = false;
    }

}

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        Vector<String> product = new Vector<String>();
        ExecutorService pool = Executors.newCachedThreadPool();
        Productor proc = new Productor(product);
        pool.submit(proc);
        Productor proc2 = new Productor(product);
        pool.submit(proc2);
        List<Customer> cusGroup = new ArrayList<Customer>();
        for(int i =0;i<1;i++){
            Customer cus = new Customer(product);
            cusGroup.add(cus);
            pool.submit(cus);
        }
        Thread.sleep(1000*1);
        proc.stopProc();     // 终止生产
        proc2.stopProc();    // 终止生产
        cusGroup.forEach(cus -> cus.stop());  //关闭客户
        proc.stop();        // 关闭生产者，（先关闭消费者，要不然消费者没法关闭）
        proc2.stop();       // 关闭生产者，（先关闭消费者，要不然消费者没法关闭）
        Thread.sleep(1000*2);
        pool.shutdown();
        System.out.println("-------------结束");
    }