Android（java）学习笔记71：生产者和消费者之等待唤醒机制

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不需要捕获异常。