黑马程序员技术交流社区

标题: 线程间的唤醒 [打印本页]
作者: 小虎199406    时间: 2015-7-21 20:17
标题: 线程间的唤醒
  1. package com.itheima2;

  3. public class TheadTest {


  6.         public static void main(String[] args) {
  7.                
  8.                 Res r = new Res();
  9.                
  10.                 Input in = new Input(r);
  11.                 Output out = new Output(r);

  13.                 Thread t1 = new Thread(in);
  14.                 Thread t2 = new Thread(out);
  15.                
  16.                 t1.start();
  17.                 t2.start();

  19.         }

  21. }
  22. class Input implements Runnable        //往资源中存入值
  23. {
  24.         private Res r;
  25.        
  26.         Input(Res r){
  27.                
  28.                 this.r = r;
  29.                
  30.         }
  31.         public void run() {
  32.        
  33.                 int x= 0;
  34.                 while(true)
  35.                 {
  36.                   synchronized(r){
  37.                        
  38.                           if(r.flag)
  39.                                 try {        //如果r为true时则等待
  40.                                         r.wait();  
  41.                                 } catch (InterruptedException e) {
  42.                        
  43.                                         e.printStackTrace();
  44.                                 }
  45.                           
  46.                           if(x==0){
  47.                                   r.name = "mike";
  48.                                   r.sex = "man";
  49.                           }else{
  50.                                   r.name ="丽丽";
  51.                                   r.sex = "女女女女";
  52.                           }
  53.                         //  x++;
  54.                         //   x=x%2;
  55.                         x= (x+1)%2;
  56.                          r.flag= true;
  57.                          r.notify();      //唤醒r锁属上等待的线程  即唤醒Output中等待的线程
  58.                           
  59.                   }
  60.                   
  61.                 }
  62.         }
  63.        
  64. }

  66. class Output implements Runnable       //输出资源中的值
  67. {
  68.     private Res r;
  69.   
  70.     Output(Res r){
  71.             this.r = r;
  72.     }
  73.         public void run() {
  74.                
  75.                 while(true){
  76.                        
  77.                         synchronized(r){
  78.                                
  79.                                 if(!r.flag)   
  80.                                         try {       //如果r为false时则等待
  81.                                                 r.wait();
  82.                                         } catch (InterruptedException e) {
  83.                                                
  84.                                                 e.printStackTrace();
  85.                                         }
  86.                                
  87.                                
  88.                                 System.out.println(r.name+"::::::"+r.sex);
  89.                                 r.flag=false;
  90.                                 r.notify();       //唤醒r锁属上等待的线程  即唤醒Input中等待的线程
  91.                         }

  93.                 }
  94.         }
  95.        
  96. }
  97. class Res            //被多个线程共同操作的资源
  98. {
  99.           String name;  
  100.           String sex;
  101.           boolean flag = false;

  103. }
复制代码
wait();
  notify();
  notifyAll();

  都是用在同步中,因为要对持有监视器(锁)的线程操作.
  所以要使用在同步中,因为只有同步才有锁.

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

也就是说等待和唤醒必须是同属一个锁的线程

  而锁可以是任意对象,所以可以被任意对象叼哦有那个的方法定义在Object类中





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