Java:使用wait()与notify()实现线程间协作-阿里云开发者社区

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

2017-11-22 821

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介：

使用 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 Athlete implements Runnable {
     private final int id;
     private Game game;

     public Athlete( int id, Game game) {
       this.id = id;
       this.game = game;
    }

     public boolean equals(Object o) {
       if (!(o instanceof Athlete))
         return false;
      Athlete athlete = (Athlete) o;
       return id == athlete.id;
    }

     public String toString() {
   return "Athlete<" + id + ">";
    }

     public int hashCode() {
       return new Integer(id).hashCode();
    }

     public void run() {
       try {
        game.prepare( this);
      } catch (InterruptedException e) {
        System.out.println( this + " quit the game");
      }
    }
}

public class Game implements Runnable {
     private Set<Athlete> players = new HashSet<Athlete>();
     private boolean start = false;

     public void addPlayer(Athlete one) {
players.add(one);
    }

     public void removePlayer(Athlete one) {
players.remove(one);
    }

     public Collection<Athlete> getPlayers() {
   return Collections.unmodifiableSet(players);
    }

     public void prepare(Athlete athlete) throws InterruptedException {
      System.out.println(athlete + " ready!");
       synchronized ( this) {
         while (!start)
        wait();
         if (start)
        System.out.println(athlete + " go!");
      }
    }

     public synchronized void go() {
      notifyAll();
    }

     public void ready() {
      Iterator<Athlete> iter = getPlayers().iterator();
       while (iter.hasNext())
         new Thread(iter.next()).start();
    }

     public void run() {
start = false;
      System.out.println( "Ready......");
      System.out.println( "Ready......");
System.out.println( "Ready......");
ready();
      start = true;
      System.out.println( "Go!");
      go();
    }

     public static void 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!

3. 模拟忙等待过程

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

BusyWaiting.java

import java.util.concurrent.TimeUnit;

class MyObject implements Runnable {
     private Monitor monitor;

     public MyObject(Monitor monitor) {
       this.monitor = monitor;
    }

     public void run() {
   try {
      TimeUnit.SECONDS.sleep(3);
      System.out.println( "i'm going.");
      monitor.gotMessage();
      } catch (InterruptedException e) {
      e.printStackTrace();
}
    }
}

class Monitor implements Runnable {
     private volatile boolean go = false;

     public void gotMessage() throws InterruptedException {
go = true;
    }

     public void watching() {
   while (go == false)
    ;
System.out.println( "He has gone.");
    }

     public void run() {
watching();
    }
}

public class BusyWaiting {
     public static void 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 MyObject implements Runnable {
     private Monitor monitor;

     public MyObject(Monitor monitor) {
       this.monitor = monitor;
    }

     public void run() {
       try {
      TimeUnit.SECONDS.sleep(3);
      System.out.println( "i'm going.");
    monitor.gotMessage();
      } catch (InterruptedException e) {
    e.printStackTrace();
      }
    }
}

class Monitor implements Runnable {
     private volatile boolean go = false;

     public synchronized void gotMessage() throws InterruptedException {
      go = true;
notify();
    }

     public synchronized void watching() throws InterruptedException {
   while (go == false)
    wait();
System.out.println( "He has gone.");
    }

     public void run() {
   try {
      watching();
} catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
}

public class Wait {
     public static void 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.

本文转自zhangjunhd51CTO博客，原文链接：http://blog.51cto.com/zhangjunhd/71387，如需转载请自行联系原作者

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

热门文章

最新文章

相关课程

相关电子书

相关实验场景