黑马程序员技术交流社区

标题: 等待唤醒机制---线程间通信普通版与优化版 [打印本页]
作者: 追逐    时间: 2014-3-18 19:56
标题: 等待唤醒机制---线程间通信普通版与优化版
本帖最后由 追逐 于 2014-3-21 19:36 编辑

1，普通版
/*
        线程间通信
        其实就是多个线程在操作同一个资源
        只是操作的动作不同
        
        
        
wait();
notify();
notifyAll();

都是用在同步中，因为要对持有监视器（锁）的线程操作。
所以要使用在同步中，因为只有同步才具有锁。

为什么这些操作线程的方法要定义Object类中呢？
因为这些方法在操作同步中线程时，都必须要标识它们所操作线程持有的锁
只有同一个锁上的被等待线程。可以被同一个锁上的notify唤醒
不可以对不同锁中的线程进行唤醒。

也就是说。等待和唤醒必须是同一个锁。

而锁可以是任意对象，所以可以被任意对象调用的方法定义在Object类中
        
*/
  1. //定义一个资源类
  2. class Person {
  3.         String name;
  4.         String sex;
  5.         boolean b = false; //定义一个标记
  6. }

  8. //定义一个输入类
  9. class Input implements Runnable {
  10.         
  11.         private Person p; //定义一个资源类的对象
  12.         Input(Person p) {
  13.                         this.p = p;
  14.         }
  15.         
  16.         //建立run方法
  17.         public void run() {
  18.                 int x = 0;
  19.                 while(true) {
  20.                         synchronized(p) { //因为线程出现安全隐患问题。所以加上同步
  21.                                 if(p.b)
  22.                                         //假如标记为真。就wait();进入等待状态
  23.                                         try {p.wait();} catch(InterruptedException e) {}
  24.                                 if(x == 0) {
  25.                                         p.name = "shasha";
  26.                                         p.sex = "girl";
  27.                                 } else {
  28.                                         p.name = "志志";
  29.                                         p.sex = "男";
  30.                                 }
  31.                                 x = (x + 1) % 2;
  32.                                 p.b = true; //把标记改为真。
  33.                                 p.notify(); //唤醒等待的程序
  34.                         }
  35.                 }
  36.         }
  37.         
  38. }

  40. //定义一个输出类
  41. class Output implements Runnable {
  42.         
  43.         private Person p;
  44.         Output(Person p) {
  45.                 this.p = p;
  46.         }
  47.         
  48.         public void run() {
  49.                 while(true) {
  50.                         synchronized(p) { //因为对象p是唯一的。所以把p定义为同步锁
  51.                                 if(!p.b)
  52.                                         try {p.wait();} catch(InterruptedException e) {}
  53.                                 System.out.println(p.name + "run ...." + p.sex);
  54.                                 p.b = false; //把标记改为假
  55.                                 p.notify(); //唤醒等待的线程
  56.                         }
  57.                 }
  58.         }
  59.         
  60. }

  62. //定义一个调试类
  63. class InputOutputDemo {
  64.         public static void main(String[] args) {
  65.                 Person p = new Person(); //建立资源类
  66.                 Input in = new Input(p); //把资源类对象当做实参传递给输入类的构造函数
  67.                 Output ou = new Output(p); //把资源类对象当做实参传递给输出类的构造函数
  68.                 Thread t1 = new Thread(in);
  69.                 Thread t2 = new Thread(ou);
  70.                 t1.start();
  71.                 t2.start();
  72.         }
  73. }




  78. 2，优化后的代码（优化版）
  79. //定义一个资源类
  80. class Person1 {
  81.         private String name;
  82.         private String sex;
  83.         boolean b = false; //定义一个标记
  84.         //在资源类中定义一个赋值函数，但是有可能在赋值的时候出现问题。所以使用同步，变成同步函数
  85.         public synchronized void set(String name, String sex) {
  86.                 if(b)
  87.                         //假如标记为真。就wait();进入等待状态
  88.                         try {this.wait();} catch(InterruptedException e) {}
  89.                 this.name = name;
  90.                 this.sex = sex;
  91.                 this.b = true;
  92.                 this.notify();
  93.         }
  94.         
  95.         public synchronized void out() {
  96.                 if(!b)
  97.                         try {this.wait();} catch(InterruptedException e) {}
  98.                 System.out.println(name + "run......" + sex);
  99.                 this.b = false;
  100.                 this.notify();
  101.         }
  102.         
  103. }

  105. //定义一个输入类
  106. class Input1 implements Runnable {
  107.         
  108.         private Person1 p; //定义一个资源类的对象
  109.         Input1(Person1 p) {
  110.                         this.p = p;
  111.         }
  112.         
  113.         //建立run方法
  114.         public void run() {
  115.                 int x = 0;
  116.                 while(true) {
  117.                         if(x == 0) {
  118.                                 p.set("meimei", "girl");
  119.                         } else {
  120.                                 p.set("志志", "男");
  121.                         }
  122.                         x = (x + 1) % 2;
  123.                 }
  124.         }
  125.         
  126. }

  128. //定义一个输出类
  129. class Output1 implements Runnable {
  130.         
  131.         private Person1 p;
  132.         Output1(Person1 p) {
  133.                 this.p = p;
  134.         }
  135.         
  136.         public void run() {
  137.                 while(true) {
  138.                         p.out();
  139.                 }
  140.         }
  141.         
  142. }

  144. //定义一个调试类
  145. class InputOutputDemo1 {
  146.         public static void main(String[] args) {
  147.                 Person1 p = new Person1();
  148.                 new Thread(new Input1(p)).start();
  149.                 new Thread(new Output1(p)).start();
  150.         }
  151. }
复制代码






欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2