线程的挂起和唤醒

1. 线程的挂起和唤醒
      挂起实际上是让线程进入“非可执行”状态下，在这个状态下CPU不会分给线程时间片，进入这个状态可以用来暂停一个线程的运行；在线程挂起后，可以通过重新唤醒线程来使之恢复运行。

挂起的原因可能是如下几种情况：
     （1）通过调用sleep()方法使线程进入休眠状态，线程在指定时间内不会运行。
     （2）通过调用join()方法使线程挂起，使自己等待另一个线程的结果，直到另一个线程执行完毕为止。
     （3）通过调用wait()方法使线程挂起，直到线程得到了notify()和notifyAll()消息，线程才会进入“可执行”状态。
     （4）使用suspend挂起线程后，可以通过resume方法唤醒线程。
      虽然suspend和resume可以很方便地使线程挂起和唤醒，但由于使用这两个方法可能会造成死锁，因此，这两个方法被标识为  deprecated（抗议）标记 ，这表明在以后的jdk版本中这两个方法可能被删除，所以尽量不要使用这两个方法来操作线程。

      调用sleep()、yield()、suspend()的时候并没有被释放锁

        yield() 使得线程放弃当前分得的 CPU 时间，但是不使线程阻塞，即线程仍处于可执行状态，随时可能再次分得 CPU 时间。调用 yield() 的效果等价于调度程序认为该线程已执行了足够的时间从而转到另一个线程

      调用wait()的时候释放当前对象的锁

      wait()方法表示，放弃当前对资源的占有权，一直等到有线程通知，才会运行后面的代码。

      notify()方法表示，当前的线程已经放弃对资源的占有，通知等待的线程来获得对资源的占有权，但是只有一个线程能够从wait状态中恢复，然后继续运行wait()后面的语句。

      notifyAll()方法表示，当前的线程已经放弃对资源的占有，通知所有的等待线程从wait()方法后的语句开始运行。

       当第一个线程运行完毕以后释放对象上的锁此时如果该对象没有再次使用notify语句，则即便该对象已经空闲，其他wait状态等待的线程由于没有得到该对象的通知，继续处在wait状态，直到这个对象发出一个notify或notifyAll，它们等待的是被notify或notifyAll，而不是锁。 

2.等待和锁实现资源竞争
      等待机制与锁机制是密切关联的，对于需要竞争的资源，首先用synchronized确保这段代码只能一个线程执行，可以再设置一个标志位condition判断该资源是否准备好，如果没有，则该线程释放锁，自己进入等待状态，直到接收到notify，程序从wait处继续向下执行。

1. synchronized(obj) {
   
2. 　　while(!condition) {
   
3. 　　 obj.wait();
   
4. 　　}
   
5. 　　obj.doSomething();
   
6. }

以上程序表示只有一个线程A获得了obj锁后，发现条件condition不满足，无法继续下一处理，于是线程A释放该锁，进入wait()。

      在另一线程B中，如果B更改了某些条件，使得线程A的condition条件满足了，就可以唤醒线程A：

1. synchronized(obj) {
   
2. 　condition = true;
   
3. 　obj.notify();
   
4. }

需要注意的是：
　　# 调用obj的wait(), notify()方法前，必须获得obj锁，也就是必须写在synchronized(obj) {...} 代码段内。
　　# 调用obj.wait()后，线程A就释放了obj的锁，否则线程B无法获得obj锁，也就无法在synchronized(obj) {...} 代码段内唤醒A。
　　# 当obj.wait()方法返回后，线程A需要再次获得obj锁，才能继续执行。
　　#  如果A1,A2,A3都在obj.wait()，则B调用obj.notify()只能唤醒A1,A2,A3中的一个(具体哪一个由JVM决定) 。
　　# obj.notifyAll()则能全部唤醒A1,A2,A3，但是要继续执行obj.wait()的下一条语句，必须获得obj锁，因此，A1,A2,A3只有一个有机会获得锁继续执行，例如A1，其余的需要等待A1释放obj锁之后才能继续执行。
　　# 当B调用obj.notify/notifyAll的时候，B正持有obj锁，因此，A1,A2,A3虽被唤醒，但是仍无法获得obj锁。直到B退出synchronized块，释放obj锁后，A1,A2,A3中的一个才有机会获得锁继续执行。


例1：单个线程对多个线程的唤醒
      假设只有一个Game对象，但有3个人要玩，由于只有一个游戏资源，必须必然依次玩。

1. /**
   
2.  * 玩游戏的人.
   
3.  * @version V1.0 ,2011-4-8
   
4.  * @author xiahui
   
5.  */
   
6. public class Player implements Runnable {
   
7.     private final int id;
   
8.     private Game game;
   
9. 
   
10.     public Player(int id, Game game) {
    
11.         this.id = id;
    
12.         this.game = game;
    
13.     }
    
14. 
    
15. 
    
16.     public String toString() {
    
17.         return "Athlete<" + id + ">";
    
18.     }
    
19. 
    
20.     public int hashCode() {
    
21.         return new Integer(id).hashCode();
    
22.     }
    
23.     
    
24.     public void playGame() throws InterruptedException{
    
25.         System.out.println(this.toString() + " ready!");
    
26.         game.play(this);
    
27.     }
    
28. 
    
29.     public void run() {
    
30.         try {
    
31.             playGame();
    
32.         } catch (InterruptedException e) {
    
33.             System.out.println(this + " quit the game");
    
34.         }
    
35.     }
    
36. }

游戏类，只实例化一个

1. import java.util.HashSet;
   
2. import java.util.Iterator;
   
3. import java.util.Set;
   
4. 
   
5. /**
   
6.  * 游戏类.
   
7.  * @version V1.0 ,2011-4-8
   
8.  * @author xiahui
   
9.  */
   
10. public class Game implements Runnable {
    
11.     private boolean start = false;
    
12. 
    
13.     public void play(Player player) throws InterruptedException {
    
14.         synchronized (this) {
    
15.             while (!start)
    
16.                 wait();
    
17.             if (start)
    
18.                 System.out.println(player + " have played!");
    
19.         }
    
20.     }
    
21. 
    
22.     //通知所有玩家
    
23.     public synchronized void beginStart() {
    
24.         start = true;
    
25.         notifyAll();
    
26.     }
    
27. 
    
28.     public void run() {
    
29.         start = false;
    
30.         System.out.println("Ready......");
    
31.         System.out.println("Ready......");
    
32.         System.out.println("game start");
    
33.         beginStart();//通知所有玩家游戏准备好了
    
34.     }
    
35. 
    
36.     public static void main(String[] args) {
    
37.         Set<Player> players = new HashSet<Player>();
    
38.         //实例化一个游戏
    
39.         Game game = new Game();
    
40.         
    
41.         //实例化3个玩家
    
42.         for (int i = 0; i < 3; i++)
    
43.             players.add(new Player(i, game));
    
44.         
    
45.         //启动3个玩家
    
46.         Iterator<Player> iter = players.iterator();
    
47.         while (iter.hasNext())
    
48.             new Thread(iter.next()).start();
    
49.         Thread.sleep(100);
    
50.         
    
51.         //游戏启动
    
52.         new Thread(game).start();
    
53.     }
    
54. }

程序先启动玩家，三个玩家竞争玩游戏，但只能有一个进入play，其他二个等待，进入的玩家发现游戏未准备好，所以wait，等游戏准备好后，依次玩。
运行结果

1. Athlete<0> ready!
2. Athlete<1> ready!
3. Athlete<2> ready!
4. Ready......
5. Ready......
6. game start
7. Athlete<2> have played!
8. Athlete<1> have played!
9. Athlete<0> have played!

3.一次唤醒一个线程
      一次唤醒所有玩家，但只有一个玩家能玩，不如一个一个唤醒
将上面的代码修改如下

1.     public void play(Player player) throws InterruptedException {
   
2.         synchronized (this) {
   
3.             while (!start)
   
4.                 wait();
   
5.             if (start){
6.                 System.out.println(player + " have played!");
   
7.                 notify();//玩完后，通知下一个玩家来玩
8.             }
   
9.         }
   
10.     }
    
11.     //通知一个玩家
    
12.     public synchronized void beginStart() {
    
13.         start = true;
    
14.         notify();
    
15.     }

4.suspend挂起
      该方法已不建议使用，例子如下
例2：suspend方法进行挂起和唤醒

1. /**
   
2.  * suspend方法进行挂起和唤醒.
   
3.  * @version V1.0 ,2011-3-27 
   
4.  * @author xiahui
   
5.  */
   
6. public class SuspendThread implements Runnable{
   
7.     public void run() {
   
8.         try {
   
9.             Thread.sleep(10);
   
10.         } catch (Exception e) {
    
11.             System.out.println(e);
    
12.         }
    
13.         for (int i = 0; i <= 1; i ) {
    
14.             System.out.println(Thread.currentThread().getName() ":" i);
    
15.         }
    
16.     }
    
17. 
    
18.     public static void main(String args[]) throws Exception {
    
19.         Thread th1 = new Thread(new SuspendThread(),"thread1");
    
20.         Thread th2 = new Thread(new SuspendThread(),"thread2");
    
21.         System.out.println("Starting " th1.getName() "...");
    
22.         th1.start();
    
23.         System.out.println("Suspending " th1.getName() "...");
    
24.         //Suspend the thread.
    
25.         th1.suspend();
    
26.         th2.start();
    
27.         th2.join();
    
28.         // Resume the thread.
    
29.         th1.resume();
    
30.     }
    
31. }

运行结果

1. Starting thread1...
   
2. Suspending thread1...
   
3. thread2:0
   
4. thread2:1
   
5. thread1:0
   
6. thread1:1

注意：
      如果注释掉//th2.join();则thread2运行后，主线程会直接执行thread1的resume，运行结果可能会是

1. Starting thread1...
   
2. Suspending thread1...
   
3. thread1:0
   
4. thread1:1
   
5. thread2:0
   
6. thread2:1

多线程争取一个对象，某些情况下， 可以替代static静态变量

import java.util.*;

class Widget...{}
class WidgetMaker extends Thread...{
    List<Widget> finishedWidgets=new ArrayList<Widget>();
    public void run()...{
        try...{
            while(true)...{
                Thread.sleep(5000);//act busy
                Widget w=new Widget();
                //也就是说需要5秒钟才能新产生一个Widget，这决定了一定要用notify而不是notifyAll
                //因为上面两行代码不是同步的，如果用notifyAll则所有线程都企图冲出wait状态
                //第一个线程得到了锁，并取走了Widget（这个过程的时间小于5秒，新的Widget还没有生成）
                //并且解开了锁，然后第二个线程获得锁(因为用了notifyAll其他线程不再等待notify语句
                //，而是等待finishedWidgets上的锁，一旦锁放开了，他们就会竞争运行)，运行
                //finishedWidgets.remove(0)，但是由于finishedWidgets现在还是空的，
                //于是产生异常
                //***********这就是为什么下面的那一句不能用notifyAll而是要用notify
                                
                synchronized(finishedWidgets)...{
                    finishedWidgets.add(w);
                    finishedWidgets.notify(); //这里只能是notify而不能是notifyAll
                }
            }
        }
        catch(InterruptedException e)...{}
    }
    
    public Widget waitForWidget()...{
        synchronized(finishedWidgets)...{
            if(finishedWidgets.size()==0)...{
                try...{
                    finishedWidgets.wait();
                }
                catch(InterruptedException e)
                ...{}
            }
            return finishedWidgets.remove(0);
        }
    }
}
public class WidgetUser extends Thread...{
    private WidgetMaker maker;
    public WidgetUser(String name,WidgetMaker maker)...{
        super(name);
        this.maker=maker;
    }
    public void run()...{
        Widget w=maker.waitForWidget();
        System.out.println(getName()+"got a widget");
    }
   

    public static void main(String[] args) ...{
        WidgetMaker maker=new WidgetMaker();
        maker.start();
        new WidgetUser("Lenny",maker).start();
        new WidgetUser("Moe",maker).start();
        new WidgetUser("Curly",maker).start();

    }

}