synchronized并发控制

用线程实现：包子铺做包子消费者吃包子。

第一步创建包子类
/*资源类：包子类

• 设置包子的属性
• 皮
• 陷
• 包子的状态：有true 没有false
• **/

public class BaoZI {
//皮
String pi;
//陷
String xian;
//包子的状态：有true 没有false ，设置初始值为false没有包子
boolean flag=false;

}
}

生产者（包子铺）类

：是一个线程类，可以继承Thread

• 设置线程任务run：生产包子

• 对包子的状态进行排断

• true：有包子

• 包子铺调用wait方法进入等待状态
  

• false：没有包子

•  包子铺生产包子
  

•  增加一些趣味性：交替生产两种包子
  

•         有两种状态（i%2==0）
  

•  包子铺生产好了包子
  

•  修改包子的状态为true
  

•  唤醒吃货线程，让吃货线程吃包子
  

• 注意：包子铺线程和包子线程关系————》通信（互斥）

• 必须同时同步技术保证两个线程只能有一个在执行

• 锁对象必须保证唯一，可以使用包子对象作为锁对象

• 包子铺类和吃货的类就需要把包子对象作为参数传递进来

•   1.需要在成员位置创建一个包子变量
  

•   2.使用带参构造方法，为这个包子变量赋值
  

• */

  public class BaoZipu extends Thread {
  // 1.需要在成员位置创建一个包子变量
  private BaoZI bz;

   // 2.使用带参构造方法，为这个包子变量赋值
   public BaoZipu(BaoZI bz) {
  
   	this.bz = bz;
   }
  
   // 设置线程任务run：生产包子
   public void run() {
   	// 定义一个变量
   	int count = 0;
   	// 让包子一直生产包子
   	while (true) {
  
   		// 必须同时同步技术保证两个线程只能有一个在执行
   	synchronized (bz) {
   		// 判断有没有包子
   		if (bz.flag == true) {
   		// 包子调用wait方法进入等待状态
   		try {
   			bz.wait();
   		} catch (InterruptedException e) {
   			e.printStackTrace();
   		}
   	}
   	// 唤醒之后执行，包子铺生产包子
   	// 增加一些趣味性，交替生产两种包子
   	if (count % 2 == 0) {
   				// 生产薄皮三鲜馅包子
   				bz.pi = "薄皮";
   				bz.xian = "三鲜馅";
   			} else {
   				// 生产冰皮嫦娥肉包子
   				bz.pi = "冰皮";
   				bz.xian = "嫦娥肉";
   			}
   			count++;
   			System.out.println("包子铺正在生产：" + bz.pi + bz.xian + "包子");
   			// 生产包子需要睡三秒钟
   			try {
   				Thread.sleep(3000);
   			} catch (InterruptedException e) {
   				e.printStackTrace();
   			}
   			// 包子铺生产好了包子
   			// 修改包子的状态为true
   			bz.flag = true;
   			// 唤醒吃货线程，让包子线程吃包子
   			bz.notify();
   			System.out.println("包子铺已经生产好了" + bz.pi + bz.xian
   					+ "包子，吃货可以开吃吃了");
   		}
   	}
   }
  

  }

/*消费者（吃货）类：

是一个线程类，可以继承Thread

• 设置线程任务run：吃包子
• 对包子的状态进行判断
• false：没有包子

•   吃货调用wait方法进入等待状态
  

• true：有包子
• 吃货吃包子
• 吃货吃完包子
• 修改包子的状态为false没有
• 吃货唤醒包子线程，生产包子

* */
public class Chi extends Thread {
	// 1.需要在成员位置创建一个包子变量
	private BaoZI bz;

	// 2.使用带参构造方法，为这个包子变量赋值
	public Chi(BaoZI bz) {

		this.bz = bz;
	}

	// 设置线程任务
	public void run() {
		// 使用死循环，让吃货一直吃包子
		while (true) {
			// 必须同时同步技术保证两个线程只能有一个执行
			synchronized (bz) {
				if (bz.flag == false) {

					// false：没有包子
					// 吃货调用wait方法进入等待状态
					try {
						bz.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				// 被唤醒之后执行代码，吃包子
				System.out.println("吃货正在吃" + bz.pi + bz.xian + "的包子");
				// 吃货吃完包子
				// * 修改包子的状态为false没有
				bz.flag = false;
				// 吃货唤醒包子铺线程，生产包子
				bz.notify();
				System.out.println("吃货已经把" + bz.pi + bz.xian
						+ " 的包子吃完了，包子铺开始做包子");
				System.out.println("-------------------------------------");
			}
		}
	}
}

/*

* 测试类

• 包含main方法，程序执行入口，启动程序

• 创建包子对象

• 创建包子铺线程，开启生产包子，

• 常见吃货线程，开启，吃包子*/

   public class Test {
      public static void main(String[] args) {
   	BaoZI bz=new BaoZI();
   	new BaoZipu(bz).start();
   	new Chi(bz).start();
  

  }
  }