Java:使用wait()与notify()实现线程间协作

http://zhangjunhd.blog.51cto.com/113473/71387

使用wait()与notify()/notifyAll()可以使得多个任务之间彼此协作。

  

1. wait()与notify()/notifyAll()

  

调用sleep()和yield()的时候锁并没有被释放，而调用wait()将释放锁。这样另一个任务（线程）可以获得当前对象的锁，从而进入它的synchronized方法中。可以通过notify()/notifyAll()，或者时间到期，从wait()中恢复执行。

  

只能在同步控制方法或同步块中调用wait()、notify()和notifyAll()。如果在非同步的方法里调用这些方法，在运行时会抛出IllegalMonitorStateException异常。

  

2.模拟单个线程对多个线程的唤醒

  

模拟线程之间的协作。Game类有2个同步方法prepare()和go()。标志位start用于判断当前线程是否需要wait()。Game类的实例首先启动所有的Athele类实例，使其进入wait()状态，在一段时间后，改变标志位并notifyAll()所有处于wait状态的Athele线程。

  

Game.java

  

package concurrency;
  
  import java.util.Collection;
  import java.util.Collections;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.Set;
  
  class Athleteimplements Runnable {
      privatefinalint id;
      private Game game;
  
      public Athlete(int id, Game game) {
        this.id = id;
        this.game = game;
      }
  
      publicboolean equals(Object o) {
        if (!(oinstanceof Athlete))
          returnfalse;
        Athlete athlete = (Athlete) o;
        return id == athlete.id;
      }
  
      public String toString() {
        return"Athlete<" + id +">";
      }
  
      publicint hashCode() {
        returnnew Integer(id).hashCode();
      }
  
      publicvoid run() {
        try {
          game.prepare(this);
        } catch  (InterruptedException e) {
          System.out.println(this +" quit the game");
        }
      }
    }
  
  publicclass Gameimplements Runnable {
      private Set<Athlete> players =new HashSet<Athlete>();
      privateboolean start =false;
  
      publicvoid addPlayer(Athlete one) {
        players.add(one);
      }
  
      publicvoid removePlayer(Athlete one) {
        players.remove(one);
      }
  
      public Collection<Athlete> getPlayers()  {
        return Collections.unmodifiableSet(players);
      }
  
      publicvoid prepare(Athlete athlete)throws InterruptedException {
        System.out.println(athlete + " ready!");
        synchronized (this) {
          while (!start)
          wait();
          if (start)
            System.out.println(athlete + " go!");
        }
      }
  
      publicsynchronizedvoid go() {
        notifyAll();
      }
      
      publicvoid ready() {
        Iterator<Athlete> iter =  getPlayers().iterator();
        while (iter.hasNext())
          new Thread(iter.next()).start();
      }
  
      publicvoid run() {
        start = false;
        System.out.println("Ready......");
        System.out.println("Ready......");
        System.out.println("Ready......");
        ready();//ps：就是这里，ready处理所有线程运行。但是也许不立即执行。就做下面的start=true了
        start = true;
        System.out.println("Go!");
        go();
      }
  
      publicstaticvoid main(String[]  args) {
        Game game = new Game();
        for (int i = 0; i < 10; i++)
          game.addPlayer(new Athlete(i, game));
        new Thread(game).start();
      }
  }

  

结果：
  Ready......
  Ready......
  Ready......
  Athlete<0> ready!
  Athlete<1> ready!
  Athlete<2> ready!
  Athlete<3> ready!
  Athlete<4> ready!
  Athlete<5> ready!
  Athlete<6> ready!
  Athlete<7> ready!
  Athlete<8> ready!
  Athlete<9> ready!
  Go!
  Athlete<9> go!
  Athlete<8> go!
  Athlete<7> go!
  Athlete<6> go!
  Athlete<5> go!
  Athlete<4> go!
  Athlete<3> go!
  Athlete<2> go!
  Athlete<1> go!
  Athlete<0> go!

  ps：原作者的这个例子是有瑕疵的。因为线程start之后不一定立即执行。 而这时候标志start 设置成true后才执行的，就不会出现下面打印的结果。

实际上 我在我机器上实验 从来就没有能出现累死原作者的结果。 不过 这个例子还是能够看出原作者所要表达的意思的。

3.模拟忙等待过程

  

MyObject类的实例是被观察者，当观察事件发生时，它会通知一个Monitor类的实例（通知的方式是改变一个标志位）。而此Monitor类的实例是通过忙等待来不断的检查标志位是否变化。

  

BusyWaiting.java

  

import java.util.concurrent.TimeUnit;
  
  class MyObjectimplements Runnable {
      private Monitor monitor;
  
      public MyObject(Monitor monitor) {
        this.monitor = monitor;
      }
  
      publicvoid run() {
        try {
          TimeUnit.SECONDS.sleep(3);
          System.out.println("i'm going.");
          monitor.gotMessage();
        } catch  (InterruptedException e) {
          e.printStackTrace();
        }
      }
  }
  
  class Monitorimplements Runnable {
      privatevolatileboolean go =false;
  
      publicvoid gotMessage()throws InterruptedException {
        go = true;
      }
  
      publicvoid watching() {
        while (go ==false)
          ;
        System.out.println("He has gone.");
      }
  
      publicvoid run() {
        watching();
      }
  }
  
  publicclass BusyWaiting {
      publicstaticvoid main(String[]  args) {
        Monitor monitor = new Monitor();
        MyObject o = new MyObject(monitor);
        new Thread(o).start();
        new Thread(monitor).start();
      }
  }

  

结果：

  

i'm going.

  

He has gone.

  

4.使用wait()与notify()改写上面的例子

  

下面的例子通过wait()来取代忙等待机制，当收到通知消息时，notify当前Monitor类线程。

  

Wait.java

  

package concurrency.wait;
  
  import java.util.concurrent.TimeUnit;
  
  class MyObjectimplements Runnable {
      private Monitor monitor;
  
      public MyObject(Monitor monitor) {
        this.monitor = monitor;
      }
  
      publicvoid run() {
        try {
          TimeUnit.SECONDS.sleep(3);
          System.out.println("i'm going.");
          monitor.gotMessage();
        } catch  (InterruptedException e) {
          e.printStackTrace();
        }
      }
  }
  
  class Monitorimplements Runnable {
      privatevolatileboolean go =false;
  
      publicsynchronizedvoid gotMessage()throws InterruptedException {
        go = true;
        notify();
      }
  
      publicsynchronizedvoid watching()throws InterruptedException {
        while (go ==false)
          wait();
        System.out.println("He has gone.");
      }
  
      publicvoid run() {
        try {
          watching();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
  }
  
  publicclass Wait {
      publicstaticvoid main(String[]  args) {
        Monitor monitor = new Monitor();
        MyObject o = new MyObject(monitor);
        new Thread(o).start();
        new Thread(monitor).start();
      }
  }

  

结果：

  

i'm going.

  

He has gone.