Java-线程间通讯

/*
* 线程间通讯：
* 其实就是多个线程在操作同一个资源
* 但是操作的动作不同
*/

class Res{
   private String name;
   private String sex;
   private boolean flag = false;

   public synchronized void set(String name,String sex) {
       if(flag) {
           try {
               this.wait();
           } catch (InterruptedException e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
           }
       }

       this.name = name;
       this.sex = sex;
       flag = true;
       this.notify();
   }
   public synchronized void out() {
       if(!flag) {
           try {
               this.wait();
           } catch (InterruptedException e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
           }
       }
       this.name = name;
       this.sex = sex;
       flag = false;
       this.notify();
       System.out.println("name:"+name+"--sex:"+sex);
   }
}

class Input implements Runnable{
   private Res r;
   Object obj = new Object();
   Input(Res r){
       this.r = r;
   }
   public void run() {
       int x = 0;
//       boolean b = true;
       while(true) {
//           synchronized(r) {//Input.class) {//obj) {
//               if(r.flag)
//                   try {
//                       r.wait();
//                   } catch (InterruptedException e) {
//                       // TODO Auto-generated catch block
//                       e.printStackTrace();
//                   }
               if(x==0) {
               r.set("mike", "man");
//           b = false;
           }else {
               r.set("lili", "woman");
//           b = true;
           }
           x = (x+1)%2;
//           r.flag = true;
//           r.notify();
//           }

       }
   }
}

class Output implements Runnable{
   private Res r;
//   Object obj = new Object();
   Output(Res r){
       this.r = r;
   }
   public void run() {
       while(true) {
//           synchronized(r) {//Input.class) {//obj) {
//               if(!r.flag)
//                   try {
//                       r.wait();
//                   } catch (InterruptedException e) {
//                       // TODO Auto-generated catch block
//                       e.printStackTrace();
//                   }
//               System.out.println(r.name+"--"+r.sex);
//               r.flag = false;
//               r.notify();
//           }
           r.out();
       }
   }
}

public class ThreadsDemo {

   public static void main(String[] args) {
       // TODO Auto-generated method stub
       Res r = new Res();

//       Input in = new Input(r);
//       Output out = new Output(r);
//
//       Thread t1 = new Thread(in);
//       Thread t2 = new Thread(out);
//
//       t1.start();
//       t2.start();
       new Thread(new Input(r)).start();
       new Thread(new Output(r)).start();

}

}
/*
* notifyAll();
* wait();
* notify();
*
* 都使用在同步中，因为要对持有监视器（锁）的线程操作
* 所以要使用在同步中，因为同步才具有锁的概念
*
* 为什么这些操作线程的方法要定义在object类中呢？
* 因为这些方法在操作同步中线程时，都必须要标识他们所操作线程持有的锁
* 只有同一个锁上的被等待线程，可以被同一个锁上的notify唤醒
* 不可以对不同锁中的线程进行唤醒
*
* 也就是说，等待和唤醒必须是同一个锁
*
* 而锁可以是任意对象，所以可以被任意对象调用的方法定义Object类中
*/

猜你喜欢