java 22 - 17 多线程之等待唤醒机制（接16）

先来一张图，看看什么叫做等待唤醒机制

接上一章的例子。

例子：学生信息的录入和获取

　　* 资源类：Student 
　　* 设置学生数据:SetThread(生产者)
　　* 获取学生数据：GetThread(消费者)
　　* 测试类:StudentDemo

* 资源类：Student （为了使用等待唤醒机制，添加了个布尔类型的变量，默认为flase）

 public class Student {
     String name;
     int age;
     boolean flag; // 默认情况是没有数据，如果是true，说明有数据
 }

* 设置学生数据:SetThread(生产者)

 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 = 23;
                 } else {
                     s.name = "李四";
                     s.age = 24;
                 }
                 x++; //x=1

                 //修改标记
                 s.flag = true;
                 //唤醒线程
                 s.notify(); //唤醒t2,唤醒并不表示你立马可以执行，必须还得抢CPU的执行权。
             }
             //t1有，或者t2有
         }
     }
 }

* 获取学生数据：GetThread(消费者)

 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);
                 //张三---23
                 //李四---24

                 //修改标记
                 s.flag = false;
                 //唤醒线程
                 s.notify(); //唤醒t1
             }
         }
     }
 }

* 测试类:StudentDemo

 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();
     }
 }

来，依次分析这段代码：

①假设消费者GetThread先抢到了CPU的资源：

则先执行这段代码：

     public void run() {
         while (true) { //true，进来
             synchronized (s) {
                 if(!s.flag){ //因为是消费者先进来，所以里面没有“包子”，而s.flag的默认值是flase，这里取反，就true，进来
                     try {
                         s.wait(); //没“包子”，等待，并且释放锁。下次唤醒它的时候，是从这里唤醒，并不是从头开始执行
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                 }

                 System.out.println(s.name + "---" + s.age);

                 s.flag = false;

                 s.notify();
             }
         }
     }

②由于消费者在等待，并且释放了锁。则消费者和生产者继续抢CPU的资源，而消费者抢到的话，依旧等待，直到生产者（SetThread）抢到CPU的资源：

    public void run() {
        while (true) {
            synchronized (s) {

                if(s.flag){//判断有没有“包子”，这时候是没有的，s.flag = false，执行下面的if语句
                    try {
                        s.wait(); //t1等着，释放锁
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //首先x = 0，先录入张三
                if (x % 2 == 0) {
                    s.name = "张三";
                    s.age = 23;
                } else {
                    s.name = "李四";
                    s.age = 24;
                }
                x++; //x=1
//这时候已经有“包子”了，就修改标志
                s.flag = true;
                //唤醒线程
                s.notify(); //唤醒t2,唤醒并不表示你立马可以执行，必须还得抢CPU的执行权。
            }
            //t1继续抢到执行权，或者t2抢到执行权
        }
    }

③若是t1继续抢到执行权：

   synchronized (s) {

                 if(s.flag){//这个时候已经有了张三这个“包子”，而且flag = true;，所以进来
                     try {
                         s.wait(); //t1等待，并且释放锁，t1和t2抢占CPU资源，t1抢到继续等待，t2抢到就执行t2
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                 }

④t2抢到执行权：

1     public void run() {
 2         while (true) { //true，进来
 3             synchronized (s) {
 4                 if(!s.flag){ //有“包子”，这时候的flag = true ,!s.flag = flase;不进来
 5                     try {
 6                         s.wait();
 7                     } catch (InterruptedException e) {
 8                         e.printStackTrace();
 9                     }
10                 }
11                 //消费“包子”
12                 System.out.println(s.name + "---" + s.age);
13
14                 //修改标记
15                 s.flag = false;
16                 //唤醒线程t1
17                 s.notify();
18             }
　　　　　　　　　　//唤醒t1,唤醒并不表示你立马可以执行，必须还得抢CPU的执行权。

19 } 
20 }