线程：sleep()、wait()、yield()和join()方法

        1.sleep()和wait()
        这两个方法都可以让调用它的线程沉睡(sleep)/停止运行(wait)指定的时间，到了这个时间，线程就会自动醒来，变为可运行状态（RUNNABLE）。

        public static native void sleep(long millis) throws InterruptedException;  
        public static void sleep(long millis, int nanos) throws InterruptedException

        public final void wait() throws InterruptedException
        public final native void wait(long timeout) throws InterruptedException;  
        public final void wait(long timeout, int nanos) throws InterruptedException

        Parameters:
        millis - the length of time to sleep in milliseconds.毫秒数
        nanos - 0-999999 additional nanoseconds to sleep.纳秒数

        调用sleep()方法并不会让线程释放它所持有的同步锁；而且在这期间它也不会阻碍其它线程的运行。
        当调用了某个对象的wait()方法时，当前运行的线程就会转入WAITING状态，等待别的线程再次调用这个对象的notify()或者notifyAll()方法唤醒它，或者到了指定的最大等待时间，线程自动醒来。如果线程调用了某个对象的wait()方法，这个线程就会释放这个对象所持有的同步资源(不会释放其他对象的同步锁)。jdk api doc：The current thread must own this object's monitor. The thread releases ownership of this monitor and waits until another thread notifies threads waiting on this object's monitor to wake up either through a call to the notify method or the notifyAll method

1. package edu.hust.test;
3. public class ThreadSleep implements Runnable {
4.     /*
5.      * 让线程睡眠的理由很多，比如(1)认为该线程运行得太快，需要减缓一下，以便和其他线程协调；(2)查询当时的股票价格，每睡5分钟查询一次，可以节省带宽，而且即时性要求也不那么高。
6.      * 注意：时间的精确性。线程醒来之后不会马上运行，而要等待cpu给其分配时间片。因此sleep()中指定的时间并不是线程不运行的精确时间！所以不能依赖sleep()方法提供十分精确的定时。
7.      * 我们可以看到很多应用程序用sleep()作为定时器，实际是不精确的。
8.      * 
9.      * 
10.      * Thread.sleep(5 * 1000)和Thread.currentThread().sleep(5 * 1000)没区别：都表示让当前线程sleep 5秒.
11.      * 一个是通过类获取静态方法,一个是通过实例对象获得静态方法(sleep()为静态方法).
12.      * 
13.      * 注意：sleep并不是Thread的一个STATE
14.      */
15.     public void execute() {
16.         synchronized(this) {
17.             try {
18.                 System.out.println(Thread.currentThread().getName() + ", sleep()前");
19.                 Thread.sleep(1000);
20.                 System.out.println(Thread.currentThread().getName() + ", sleep()后");
21.             } catch (InterruptedException e) {
22.                 System.out.println(Thread.currentThread().getName() + ", 谁把我吵醒了.....");
23.             }
24.             //此处如果使用System.err, 会有很意外的结果。System.out和System.err的区别请见blog
25.             System.out.println(Thread.currentThread().getName() + ", run()结束..进入TERMINATED状态");
26.         }
27.     }
28.     
29.     public void run() {
30.         execute();
31.     }
32.     
33.     public static void main(String[] args) throws InterruptedException {
34.         ThreadSleep threadSleep = new ThreadSleep();
35.         Thread[] threads = new Thread[5];
36.         
37.         System.out.println(Thread.currentThread().getName() + "线程的状态为：" + Thread.currentThread().getState());
38.         
39.         for (Thread thread : threads) {
40.             thread = new Thread(threadSleep);
41.             thread.start();
42.             if ("Thread-1".equals(thread.getName()) || "Thread-3".equals(thread.getName()))
43.                 thread.interrupt();
44.         }
45.     }
46.     /*
47.      * 某次运行结果：
48.      * main线程的状态为：RUNNABLE
49.      * Thread-1, sleep()前
50.      * Thread-1, 谁把我吵醒了.....
51.      * Thread-1, run()结束..进入TERMINATED状态
52.      * 
53.      * Thread-3, sleep()前
54.      * Thread-3, 谁把我吵醒了.....
55.      * Thread-3, run()结束..进入TERMINATED状态
56.      * 
57.      * Thread-0, sleep()前
58.      * Thread-0, sleep()后
59.      * Thread-0, run()结束..进入TERMINATED状态
60.      * 
61.      * Thread-2, sleep()前
62.      * Thread-2, sleep()后
63.      * Thread-2, run()结束..进入TERMINATED状态
64.      * 
65.      * Thread-4, sleep()前
66.      * Thread-4, sleep()后
67.      * Thread-4, run()结束..进入TERMINATED状态
68.      * 
69.      * 从运行结果可以得出很多结论, 其中之一是：调用sleep()方法并不会让线程释放它所持有的同步锁；而且在这期间它也不会阻碍其它线程的运行。
70.      * 
71.      * */
72. }

1. package edu.hust.test;
3. class MyThread1 implements Runnable {
4.     private Object obj;
5.     public MyThread1(Object o) {
6.         obj = o;
7.     }
8.     
9.     public void run() {
10.         synchronized (obj) { //这里是给obj对象(也就是str="爱吃土豆")加锁, 如写成synchronized (this), 则表示是给myThread1加锁.
11.             try {
12.                 System.out.println("MyThread1进入wait状态");
13.                 obj.wait();
14.                 System.out.println("MyThread1被notify");
15.             } catch (InterruptedException e) {
16.                 System.err.println("谁把我吵醒了.....");
17.             }
18.         }
19.     }
20. }
22. class MyThread2 implements Runnable {
23.     private Object obj;
24.     public MyThread2(Object o) {
25.         obj = o;
26.     }
27.     
28.     public void run() {
29.         synchronized (obj) {  //这里是给obj对象(也就是str="爱吃土豆")加锁, 如写成synchronized (this), 则表示是给myThread2加锁.
30.             System.out.println("MyThread2调用notify()方法");
31.             obj.notify();
32.         }
33.     }
34. }
36. public class ThreadWait {
37.     public static void main(String[] args) {
38.         //错误的写法, 这里myThread1和myThread2操作的是两个不同的对象.
39.         //Thread myThread1 = new Thread(new MyThread1(new String("爱吃土豆")));
40.         //Thread myThread2 = new Thread(new MyThread2(new String("爱吃土豆")));
41.         
42.         //正确的写法, 这里myThread1和myThread2操作的是同一个对象.
43.         String str = "爱吃土豆";
44.         Thread myThread1 = new Thread(new MyThread1(str));
45.         Thread myThread2 = new Thread(new MyThread2(str));
46.         myThread1.start();
47.         myThread2.start();
48.     }
49.     
50.     /*
51.      * 运行结果：
52.      * MyThread1进入wait状态
53.      * MyThread2调用notify()方法
54.      * MyThread1被notify
55.      * 
56.      * 这里使用了synchronized块来包装某个实例对象(String str = "爱吃土豆")的wait()和notify()方法, 这是由于调用这两个方法的时候线程必须获得同步锁.
57.      * 如果synchronized包装的不是同一个实例对象的wait()和notify()方法, 则表示给wait()和notify()加的锁不是同一把锁,eg：将synchronized(lock)改为synchronized(this).
58.      * 将会抛出java.lang.IllegalMonitorStateException, 告诉你current thread not owner.
59.      * 
60.      * */
61.     
62.     /*
63.      * 摘录：
64.      * 多线程常用的一些方法: wait(),wait(long),notify(),notifyAll()
65.      * wait()      是使持有对象锁的线程释放锁;
66.      * wait(long)  是使持有对象锁的线程释放锁时间为long(毫秒)后,再次获得锁,wait()和wait(0)等价;
67.      * notify()    是唤醒一个正在等待该对象锁的线程,如果等待的线程不止一个,那么被唤醒的线程由jvm确定;
68.      * notifyAll   是唤醒所有正在等待该对象锁的线程.
69.      * 
70.      * 应该优先使用notifyAll()方法, 因为唤醒所有线程比唤醒一个线程更容易让jvm找到最适合被唤醒的线程.
71.      * 对于上述方法,只有在当前线程中才能使用,否则报运行时错误java.lang.IllegalMonitorStateException: current thread not owner.
72.      * 从实现角度来分析：
73.      * 在线程调用wait()方法时，需要把它放到一个同步段里，否则将会出现"java.lang.IllegalMonitorStateException: current thread not owner"的异常。
74.      * 
75.      * */
76.     
77. }

1. package edu.hust.test;
3. public class ThreadWait2 implements Runnable {
4.     
5.     private Object monitor1 = new Object();
6.     private Object monitor2 = new Object();
7.     
8.     public void run() {
9.         synchronized (monitor1) {
10.             System.out.println("monitor1被锁住了");
11.             synchronized (monitor2) {
12.                 System.out.println("monitor2被锁住了");
13.                 try {
14.                     System.out.println("monitor2进入wait()状态");
15.                     monitor2.wait();
16.                 } catch (InterruptedException e) {
17.                     System.out.println("谁把我吵醒了.....");
18.                 }
19.             }
20.         }
21.     }
22.     
23.     public void getMonitor() throws InterruptedException {
24.         Thread.sleep(3 * 1000); //让main Thread延迟3秒执行, 使myThread获得足够时间进行线程初始化
25.         synchronized (monitor2) {
26.             System.out.println("我取得了monitor2");
27.         }
28.         
29.         synchronized (monitor1) {
30.             System.out.println("我取得了monitor1");
31.         }
32.     }
33.     
34.     public static void main(String[] args) {
35.         ThreadWait2 threadWait2 = new ThreadWait2();
36.         Thread myThread = new Thread(threadWait2);
37.         myThread.start();
38.         try {
39.             threadWait2.getMonitor();
40.         } catch (InterruptedException e) {
41.             System.out.println("谁把我吵醒了.....");
42.         }
43.     }
44.     /*
45.      * 因为wait()方法没有被notify(), 所以程序不会自动结束. 但运行结果不会改变了：
46.      * monitor1被锁住了
47.      * monitor2被锁住了
48.      * monitor2进入wait()状态
49.      * 我取得了monitor2
50.      * 
51.      * 分析：System.out.println("我取得了monitor1")这句话永远不会得到执行, 因为wait()被调用时只释放了monitor2的锁, 并没有释放monitor1的锁.
52.      * */
53. }

        2. yield()
        让当前运行Thread放弃其所占用的cpu时间片，以便让其他Thread运行。用yield()方法的目的是让Thread能适当地轮转。但是，并不能保证达到此效果！因为，即使当前Thread放弃时间片，可是还有可能再次被JVM选中！也就是连任。

        3. join()

1. package edu.hust.test;
3. public class ThreadJoin {
4.     public void run() {
5.         System.out.println("普通打印语句1");
6.         System.out.println("普通打印语句2");
7.     }
8.     
9.     public static void main(String[] args) throws InterruptedException {
10.         Thread myThread = new Thread() {
11.             public void run() {
12.                 try {
13.                     Thread.sleep(1000);
14.                 } catch (InterruptedException e) {
15.                     System.err.println("谁把我吵醒了.....");
16.                 }
17.                 System.out.println("线程：" + Thread.currentThread().getName() + " 启动了");
18.             }
19.         };
20.         myThread.start();
21.         myThread.join();
22.         
23.         new ThreadSeq().run();
24.     }
25.     /*
26.      * 没有t.join(), 运行结果为：
27.      * 普通打印语句1
28.      * 普通打印语句2
29.      * 线程：Thread-0 启动了
30.      * 
31.      * 加入t.join(), 运行结果为：
32.      * 线程：Thread-0 启动了
33.      * 普通打印语句1
34.      * 普通打印语句2
35.      * 
36.      * join()：让当前Thread加入到myThread线程的尾部，意味着myThread线程运行结束之前，当前Thread不会运行。
37.      * */
38. }