多线程-线程通讯之-管程法（生产者-消费者-缓存区）

package com.demo3;

 
import java.util.Vector;

/**
 * 管程法
 * 
 * 1.生产者--生产phone
 * 2.消费者--消费phone
 * 3.产品：phone
 * 4.缓存区
 * 		4.1 当生产者手机生产出来 -- 通知消费者
 * 	    4.2 当消费者消费完手机--通知生产者生产
 *      4.3 当消费者消费完成手机，需要等待生产者生产数据后再进行消费
 *      4.4 当生产者生产的手机未被消费，则需要等待消费者消费后继续生产 
 *
 */

public class PCtest {
    
            public static void main(String[] args) {
                        
                Buffer buffer = new Buffer();

                Producer producer = new Producer(buffer);
                Consumer consumer = new Consumer(buffer);
                
                
                new Thread(producer).start();
                new Thread(consumer).start();
                
                
            }
}


/**
 * 手机--产品
 * @author MSI-NB
 *
 */
class Phone{
    private int id;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public Phone(int id) {
        this.id = id;
    }
    
     
     
}



/**
 * 生产者
 */
class Producer implements   Runnable  {
    private Buffer buffer;
     
    private Phone phone;
    
    
    public Phone getPhone() {
        return phone;
    }


    public void setPhone(Phone phone) {
        this.phone = phone;
    } 
    public Buffer getBuffer() {
        return buffer;
    }


    public void setBuffer(Buffer buffer) {
        this.buffer = buffer;
    } 
    public Producer(Buffer buffer) {
        this.buffer = buffer;
         
    }


    @Override
    public void run() {  
        for(int i=0; i<100; i++ ) {
            
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        
            
            buffer.push(new Phone(i));
            System.out.println("生产了第"  + i + "个手机");
        } 
    } 
}

/**
 *  消费者
 */
class Consumer implements   Runnable  { 
    
    
    @Override
    public void run() {
        for(int i =0; i<100;i++) {
            
 
            
            
            getBuffer().pop();
            System.out.println("消费了第" + i  + "个手机");
        } 
    }
    
    
    
    private Buffer buffer;
    
    
    public Buffer getBuffer() {
        return buffer;
    }


    public void setBuffer(Buffer buffer) {
        this.buffer = buffer;
    }


    public Consumer(Buffer buffer) {
        this.buffer = buffer;
    }


    

    
    
    
}



/**
 * 缓存区
 */
class Buffer    {
    
    
    private Vector<Phone>   phones = new Vector<Phone>();
    
 
    public Vector<Phone> getPhones() {
        return phones;
    }

    public void setPhones(Vector<Phone> phones) {
        this.phones = phones;
    }
    
    
    /**
     * 生产
     */
    public synchronized void push(Phone   phones) {
        
        /**
         * 当生产者生产的手机未被消费，则需要等待消费者消费后继续生产 
         */ 
        if( getPhones().size()  ==100) {
            try {
                this.wait();
                
                System.out.println("生产者等待");
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }   
        getPhones().add(phones);
        this.notifyAll();
        
    }
    
    /**
     * 消费
     */
    public  synchronized void pop() {
        //当消费者消费完成手机，需要等待生产者生产数据后再进行消费
        if( getPhones().size()  == 0) {
            try {
                this.wait();
                
                System.out.println("消费者等待"); 
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
        } 
        
        
        int nums = getPhones().size();
        getPhones().remove(--nums);
        this.notifyAll();
    }
    

 
    
    
}