1. 首先我们根据梳理我们之前Android（java）学习笔记70中，关于生产者和消费者程序思路：
2. 下面我们就要重点介绍这个等待唤醒机制：
（1）第一步：还是先通过代码体现出等待唤醒机制
下面是测试类：
package cn.itcast_05; /*
* 分析：
* 资源类：Student
* 设置学生数据:SetThread(生产者)
* 获取学生数据：GetThread(消费者)
* 测试类:StudentDemo
*
* 问题1：按照思路写代码，发现数据每次都是:null---0
* 原因：我们在每个线程中都创建了新的资源,而我们要求的时候设置和获取线程的资源应该是同一个
* 如何实现呢?
* 在外界把这个数据创建出来，通过构造方法传递给其他的类。
*
* 问题2：为了数据的效果好一些，我加入了循环和判断，给出不同的值,这个时候产生了新的问题
* A:同一个数据出现多次
* B:姓名和年龄不匹配
* 原因：
* A:同一个数据出现多次
* CPU的一点点时间片的执行权，就足够你执行很多次。
* B:姓名和年龄不匹配
* 线程运行的随机性
* 线程安全问题：
* A:是否是多线程环境 是
* B:是否有共享数据 是
* C:是否有多条语句操作共享数据 是
* 解决方案：
* 加锁。
* 注意：
* A:不同种类的线程都要加锁。
* B:不同种类的线程加的锁必须是同一把。
*
* 问题3:虽然数据安全了，但是呢，一次一大片不好看，我就想依次的一次一个输出。
* 如何实现呢?
* 通过Java提供的等待唤醒机制解决。
*
* 等待唤醒：
* Object类中提供了三个方法：
* wait():等待
* notify():唤醒单个线程
* notifyAll():唤醒所有线程
* 为什么这些方法不定义在Thread类中呢?
* 这些方法的调用必须通过锁对象调用，而我们刚才使用的锁对象是任意锁对象。
* 所以，这些方法必须定义在Object类中。
*/
public class StudentDemo {
public static void main(String[] args) {
//创建资源
Student s = new Student(); //设置和获取的类
SetThread st = new SetThread(s);
GetThread gt = new GetThread(s); //线程类
Thread t1 = new Thread(st);
Thread t2 = new Thread(gt); //启动线程
t1.start();
t2.start();
}
}
下面是生产者线程类：
package cn.itcast_05;
public class SetThread implements Runnable {
private Student s;
private int x = 0;
public SetThread(Student s) {
this.s = s;
}
@Override
public void run() {
while (true) {
synchronized (s) {
//判断有没有
if(s.flag){
try {
s.wait(); //t1等着，释放锁
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if (x % 2 == 0) {
s.name = "林青霞";
s.age = 27;
} else {
s.name = "刘意";
s.age = 30;
}
x++; //x=1
//修改标记
s.flag = true;
//唤醒线程
s.notify(); //唤醒t2,唤醒并不表示你立马可以执行，必须还得抢CPU的执行权。
}
//t1有，或者t2有
}
}
}
下面是消费者线程类：
package cn.itcast_05;
public class GetThread implements Runnable {
private Student s;
public GetThread(Student s) {
this.s = s;
}
@Override
public void run() {
while (true) {
synchronized (s) {
if(!s.flag){
try {
s.wait(); //t2就等待了。立即释放锁。将来醒过来的时候，是从这里醒过来的时候
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(s.name + "---" + s.age);
//林青霞---27
//刘意---30
//修改标记
s.flag = false;
//唤醒线程
s.notify(); //唤醒t1
}
}
}
}
Student类：
package cn.itcast_05;
public class Student {
String name;
int age;
boolean flag; // 默认情况是没有数据，默认是false，如果是true，说明有数据
}
（2）接下来我们对唤醒机制代码进行优化：
下面是测试类：
package cn.itcast_07; /*
* 分析：
* 资源类：Student
* 设置学生数据:SetThread(生产者)
* 获取学生数据：GetThread(消费者)
* 测试类:StudentDemo
*
* 问题1：按照思路写代码，发现数据每次都是:null---0
* 原因：我们在每个线程中都创建了新的资源,而我们要求的时候设置和获取线程的资源应该是同一个
* 如何实现呢?
* 在外界把这个数据创建出来，通过构造方法传递给其他的类。
*
* 问题2：为了数据的效果好一些，我加入了循环和判断，给出不同的值,这个时候产生了新的问题
* A:同一个数据出现多次
* B:姓名和年龄不匹配
* 原因：
* A:同一个数据出现多次
* CPU的一点点时间片的执行权，就足够你执行很多次。
* B:姓名和年龄不匹配
* 线程运行的随机性
* 线程安全问题：
* A:是否是多线程环境 是
* B:是否有共享数据 是
* C:是否有多条语句操作共享数据 是
* 解决方案：
* 加锁。
* 注意：
* A:不同种类的线程都要加锁。
* B:不同种类的线程加的锁必须是同一把。
*
* 问题3:虽然数据安全了，但是呢，一次一大片不好看，我就想依次的一次一个输出。
* 如何实现呢?
* 通过Java提供的等待唤醒机制解决。
*
* 等待唤醒：
* Object类中提供了三个方法：
* wait():等待
* notify():唤醒单个线程
* notifyAll():唤醒所有线程
* 为什么这些方法不定义在Thread类中呢?
* 这些方法的调用必须通过锁对象调用，而我们刚才使用的锁对象是任意锁对象。
* 所以，这些方法必须定义在Object类中。
*
* 最终版代码中：
* 把Student的成员变量给私有的了。
* 把设置和获取的操作给封装成了功能，并加了同步。
* 设置或者获取的线程里面只需要调用方法即可。
*/
public class StudentDemo {
public static void main(String[] args) {
//创建资源
Student s = new Student(); //设置和获取的类
SetThread st = new SetThread(s);
GetThread gt = new GetThread(s); //线程类
Thread t1 = new Thread(st);
Thread t2 = new Thread(gt); //启动线程
t1.start();
t2.start();
}
}
生产者线程类：
package cn.itcast_07;
public class SetThread implements Runnable {
private Student s;
private int x = 0;
public SetThread(Student s) {
this.s = s;
}
@Override
public void run() {
while (true) {
if (x % 2 == 0) {
s.set("林青霞", 27);
} else {
s.set("刘意", 30);
}
x++;
}
}
}
消费者线程类：
package cn.itcast_07;
public class GetThread implements Runnable {
private Student s;
public GetThread(Student s) {
this.s = s;
}
@Override
public void run() {
while (true) {
s.get();
}
}
}
Student类，同时Student内部封装了Student的两个同步方法（生产Student 和 消费Student）
package cn.itcast_07;
public class Student {
private String name;
private int age;
private boolean flag; // 默认情况是没有数据，如果是true，说明有数据
public synchronized void set(String name, int age) {
// 如果有数据，就等待
if (this.flag) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 设置数据
this.name = name;
this.age = age;
// 修改标记
this.flag = true;
this.notify();
}
public synchronized void get() {
// 如果没有数据，就等待
if (!this.flag) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 获取数据
System.out.println(this.name + "---" + this.age);
// 修改标记
this.flag = false;
this.notify();
}
}
3. sleep和wait的区别有:
（1）这两个方法来自不同的类，分别是Thread和Object
（2）最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
（3）wait，notify 和 notifyAll 只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用。
synchronized(x){
x.notify()
//或者wait()
}
（4）sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常。