java 通信

• 线程通信
  * 涉及的类
  * 1：生产者线程类
  * 2：消费者线程类
  * 3：产品类
  * 4：测试类
  *
  * 步骤
  * 生产者生产1个产品，消费者消费1个产品
  * 问题：
  * 1：生产者和消费者没有达到1次效果，出现多次连续
  * 2：要保证先生产，后消费
  * 3：没有产品 已解决
  * 4:如何保证产品交替的生产和消费，保证线程的公平性
  * 4.1：如何保证仓库是否有产品
  * 4.2：如何保证先生产，后消费
  * 5:线程通信的前提是同步（加锁）
  * 加锁的对象，即是通信的对象
  * wait() 等待
  * notify() 唤醒一个正在等待的线程
  * notifyAll() 唤醒所有正在等待的线程

public class Test {
	public static void main(String[] args) {
		
		//0 创建一个产品对象
		 Product product = new Product();
		
		//1:创建生产者的线程
		  ProductRunn pr = new ProductRunn(product);
		  Thread t1 = new Thread(pr, "生产者");
		//2:创建消费者的线程
		  ConsumeRunn cr = new ConsumeRunn(product);
		  Thread t2 = new Thread(cr, "消费者");
		  //3:启动线程
		  t1.start();
		  t2.start();
		
		
	}

}

/*
 * 消费者线程类
 * 
 */
public class ConsumeRunn implements Runnable {
	private Product product;
	
	

	public ConsumeRunn(Product product) {
		this.product = product;
	}



	@Override
	public void run() {
		
		while(true){
			synchronized (product) {
			//消费者在消费产品之前，先判断仓库是否有产品，有就消费，没有就等待
			if(!product.isFlag()){
				try {
					product.wait(); //开始等待，阻塞式
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			
			
				System.out.println("消费者消费了"+product.getColor()+"的"+product.getName());
				//改变flag的状态值
				product.setFlag(false);
				//唤醒生产者
				//product.notify();
				product.notifyAll();
			}
		}
	}

}

/*
 * 产品类
 *  1：产品名称
 *  2：产品颜色
 *  
 *  白色的包子，黑色的馒头
 * 
 */
public class Product {
	private String name;
	private String color;
	
	
	private boolean flag = false; //代表仓库没有产品的
	
	public Product(String name, String color) {
		super();
		this.name = name;
		this.color = color;
	}
	public Product() {
		super();
		// TODO Auto-generated constructor stub
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	public boolean isFlag() {
		return flag;
	}
	public void setFlag(boolean flag) {
		this.flag = flag;
	}
}

/*
 * 生产者线程
 * 
 */
public class ProductRunn implements Runnable {

	private Product product;  //声明一个产品
	
	
	
	public ProductRunn(Product product) {
		this.product = product;
	}



	@Override
	public void run() {
		
		int i = 0; //计次
		while(true){
			synchronized (product) {
			//生产产品之前，先判断是否有产品
			if(product.isFlag()){
				//表示仓库有产品，生产者开始等待
				try {
					product.wait();//等待  阻塞式方法
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			
		
			
				if(i%2==0){
					//生产产品
					product.setName("包子");
					//模拟真实生产环节，休眠
					try {
						Thread.sleep(100L);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					product.setColor("白色");
				}else{
					//生产产品
					product.setName("馒头");
					//模拟真实生产环节，休眠
					try {
						Thread.sleep(100L);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					product.setColor("黑色");
				}
				i++; //i++表示，馒头和包子交替生产
				//改变flag的状态值
				product.setFlag(true);
				//唤醒消费者
				//product.notify();//一次唤醒一个线程
				product.notifyAll();//一次唤醒多个线程
				
				System.out.println("生产者生产了"+product.getColor()+"的"+product.getName());
				
			}
		}
	}

}