一 多執行緒相關命令介紹

1 wait()  sleep()

 (1)這兩個方法來自不同的類分別是wait()來自Thread，sleep()來自Object。

 (2) 最主要是sleep方法沒有釋放鎖，sleep使當前執行緒進入停滯狀態（阻塞當前執行緒），讓出cpu的使用、目的是不讓當前執行緒   獨自霸佔該程序所獲的CPU資源，以留一定時間給其他執行緒執行的機會執行緒雖然休眠了，但是物件的機鎖並木有被釋放，其         他執行緒無法訪問這個物件（即使睡著也持有物件鎖）。

      而wait方法釋放了鎖，使得其他執行緒可以使用同步控制塊或者方法。當一個執行緒執行到wait()方法時，它就進入到一個和該對   象相關的等待池中，同時失去（釋放）了物件鎖（暫時失去物件鎖，wait(long timeout)超時時間到後還需要返還物件鎖），從而    其他執行緒可以訪問；

 (3) wait，notify和notifyAll只能在同步控制方法或者同步控制塊裡面使用，而sleep可以在任何地方使用

               synchronized(x){

                         x.notify()

                       //或者wait()

               }

    synchronized程式碼被執行期間，執行緒可以呼叫物件的wait()方法，釋放物件鎖標誌，進入等待狀態。

   (4) sleep必須捕獲異常，而wait，notify和notifyAll不需要捕獲異常。

2 notify()  notifyAll()

(1) wait()使用notify或者notifyAlll或者指定睡眠時間來喚醒當前等待池中的執行緒。

(2) notify()通知等待佇列中的第一個執行緒，notifyAll()通知的是等待佇列中的所有執行緒。

3 join()

    等待該執行緒終止。

    等待呼叫join()方法的執行緒結束。比如t.join(),用於等待t執行緒執行結束。

4 yield()

暫停當前正在執行的執行緒。

yield()的作用是讓步。它能讓當前執行緒由“執行狀態”進入到“就緒狀態”，從而讓其它具有相同優先順序的等待執行緒獲取執行權；但是，並不能保證在當前執行緒呼叫yield()之後，其它具有相同優先順序的執行緒就一定能獲得執行權；也有可能是當前執行緒又進入到“執行狀態”繼續執行。

二 Demo

1 wait()  sleep()

public class ThreadDemo implements Runnable{
    
    public void do1() throws Exception{
        synchronized(this){
            
             System.out.println("11111111111111111");
        }
    }
    
    public void do2() throws Exception{
        synchronized(this){
            //Thread.sleep(2000);
            this.wait();
            System.out.println("22222222222222222");
        }
    }
    
    @Override
    public void run(){
        try{
            do1();
        } catch(Exception e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) throws Exception {
        ThreadDemo threadDemo = new ThreadDemo();
        Thread t = new Thread(threadDemo);
        t.start();
        threadDemo.do2();
    }
    
}

執行結果：

假如執行的是this.wait()，結果是

11111111111111111

假如執行的是Thread.sleep(2000)，結果是

22222222222222222
11111111111111111

分析：

在main()方法裡（在主執行緒）開啟了一個子執行緒（t.start()）,接著執行了方法do2()。自此，主執行緒和子執行緒交替輪流執行，由於子執行緒剛啟動，所以do2()方法會先被執行。必須注意的是，在方法do1()和do2()中都使用了同步鎖（synchronized(this)）,且都是同一個物件鎖，而do1()執行在子執行緒，do2()執行在主執行緒，可想而知，主執行緒和子執行緒可能會因為同一個物件鎖而發生阻塞。

好的，再來看具體的程式碼。假如執行的是this.wait()，那麼主執行緒中的do2()走到this.wait(),執行緒方法wait()會使當前執行緒也就是主執行緒進入等待池中也就是執行緒停滯了，那麼其它執行緒有機會得到cpu排程，而且放棄了物件鎖，那麼使得其它執行緒能夠得到該物件鎖從而能夠執行加了同步鎖的程式碼塊。（特別注意這裡，執行緒進入等待池和放棄同步鎖帶來不一樣的東西）由於主執行緒停滯，所以子執行緒得以執行，由於主執行緒放棄了同步鎖，所以子執行緒執行到do1()方法時能夠進入同步程式碼塊，打印出結果。

假如執行的是Thread.sleep(2000)，那麼同樣首先主執行緒do2()走到Thread.sleep(2000)，那麼此時主執行緒就開始睡眠，但是睡眠的同時也並沒有放棄鎖，導致的結果是雖然主執行緒睡眠讓子執行緒有被排程的機會但是主執行緒還保持著同步鎖所以讓子執行緒無法執行do1()裡的同步程式碼塊，所以結果是要一直等到2s結束，主執行緒重新得到排程執行完do2()後放棄了鎖，子執行緒再執行do1()。

2 wait()  notify()  notifyAll()

wait()與notify()

public class ThreadDemo {
    
static class ThreadA extends Thread{
   public ThreadA(String name) {
       super(name);
   }
   public void run() {
       synchronized (this) {
           System.out.println(Thread.currentThread().getName()+"  notify()");
           // 喚醒當前的wait執行緒
           notify();
       }
   }
}

public static void main(String[] args) {
        ThreadA t1 = new  ThreadA("t1");
        synchronized(t1) {
            try {
                // 啟動執行緒t1
                t1.start();


                // 主執行緒進入等待池
                System.out.println(Thread.currentThread().getName()+" wait()");
                t1.wait();

               //主執行緒等待t1通過notify()喚醒
                System.out.println(Thread.currentThread().getName()+" continue");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

執行結果：

main wait()
t1  notify()
main continue

分析：

主執行緒通過 new ThreadA("t1") 新建執行緒t1 ，隨後通過synchronized(t1)獲取t1物件的同步鎖，然後呼叫t1.start()啟動執行緒t1。
主執行緒執行t1.wait() 釋放t1物件的鎖並且進入等待(阻塞)狀態。等待t1物件上的執行緒通過notify() 或 notifyAll()將其喚醒。
執行緒t1執行之後，通過synchronized(this)獲取當前物件的鎖；接著呼叫notify()喚醒當前物件上的等待執行緒，也就是喚醒主執行緒。
執行緒t1執行完畢之後，釋放當前物件的鎖，緊接著，主執行緒獲取t1物件的鎖，然後接著執行。

* 注意jdk的解釋中，說wait()的作用是讓“當前執行緒”等待，而“當前執行緒”是指正在cpu上執行的執行緒。
這也意味著，雖然t1.wait()是通過“執行緒t1”呼叫的wait()方法，但是呼叫t1.wait()的地方是在主執行緒main中。而主執行緒必須是當前執行緒，也就是執行狀態，才可以執行t1.wait()。所以，此時的“當前執行緒是主執行緒main。因此，t1.wait()是讓主執行緒等待，而不是執行緒t1。

wait()與notifyAll()

public class ThreadDemo {
    private static Object obj = new Object();
    
    public static void main(String[] args) {
        ThreadA t1 = new ThreadA("t1");
        ThreadA t2 = new ThreadA("t2");
        ThreadA t3 = new ThreadA("t3");
        t1.start();
        t2.start();
        t3.start();
        try {
        System.out.println(Thread.currentThread().getName()+ " sleep(3000)");
        Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (obj) {
        // 喚醒執行緒
        System.out.println(Thread.currentThread().getName() + " notifyAll()");
        obj.notifyAll();
        }
    }
    
    static class ThreadA extends Thread {
        public ThreadA(String name) {
            super(name);
        }
        public void run() {
            synchronized (obj) {
                try {
                    // 執行緒進入等待池
                    System.out.println(Thread.currentThread().getName() + " wait");
                     obj.wait();


                    // 喚醒當前的wait執行緒
                    System.out.println(Thread.currentThread().getName() + " continue");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

執行結果：

t1 wait
main sleep    (3000)
t3 wait
t2 wait
main notifyAll()
t2 continue
t3 continue
t1 continue

分析：

主執行緒中新建並且啟動了3個執行緒t1, t2和t3。
主執行緒通過sleep(3000)休眠3秒。在主執行緒休眠3秒的過程中，我們假設t1, t2和t3這3個執行緒都運行了。以t1為例，當它執行的時候，它會執行obj.wait()等待其它執行緒通過notify()或額nofityAll()來喚醒它；相同的道理，t2和t3也會等待其它執行緒通過nofity()或nofityAll()來喚醒它們。
主執行緒休眠3秒之後，接著執行。執行 obj.notifyAll() 喚醒obj上的等待執行緒，即喚醒t1, t2和t3這3個執行緒。 緊接著，主執行緒的synchronized(obj)執行完畢之後，主執行緒釋放obj鎖。這樣，t1, t2和t3就可以獲取obj鎖而繼續運行了。
 

3 join()

public class ThreadDemo extends Thread {

    public ThreadDemo(String name){
        super(name);
    }

    @Override
    public void run(){
        for(int i=1;i<5;i++){
            System.out.println(this.getName() + "    do" + i);
        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        ThreadDemo t=new ThreadDemo("子執行緒");
        t.start();
        //呼叫t執行緒的join方法，等待t執行緒執行完畢
        t.join();
        System.out.println("主執行緒");
    }
}

執行結果：

子執行緒 do1
子執行緒 do2
子執行緒 do3
子執行緒 do4
主執行緒

分析：

主執行緒中新建並且啟動了執行緒t，呼叫t.join()，主執行緒會等t執行緒執行完再執行。

4 yield()

public class ThreadDemo {
    
    public static void main(String[] args) {
        YieldThread t1 = new YieldThread("執行緒A");
        YieldThread t2 = new YieldThread("執行緒B");
        t1.start();
        t2.start();
    }
    
   static class YieldThread extends Thread {
        private String name;

        public YieldThread(String name) {
            this.name = name;
        }

        @Override
        public void run() {
            for (int i = 1; i <= 4; i++) {
                System.out.println(name + "   " + i);
                if (i == 2) {
                 Thread.yield();
                }
           }
       }
    }
}

執行結果：

執行緒A   1
執行緒A   2
執行緒B   1
執行緒B   2
執行緒B   3
執行緒B   4
執行緒A   3
執行緒A   4

分析：

這只是其中之一的一個執行結果，隨機會有好幾種執行結果。當i==2時，執行Thread.yield()會暫停當前執行緒，進入就緒狀態，不過也有可能該執行緒再次進入執行狀態，這也是導致上述demo有多種執行結果的原因之一。

三 總結&注意

(1) 在Java.lang.Thread類中，提供了sleep()，而java.lang.Object類中提供了wait()， notify()和notifyAll()方法來操作執行緒

(2) Thread.sleep()方法是一個靜態方法，它暫停的是當前執行的執行緒。

(3) wait方法必須正在同步環境下使用，比如synchronized方法或者同步程式碼塊。如果不在同步條件下使用，會丟擲IllegalMonitorStateException異常。

(4）注意持有鎖和cpu排程的區別，執行緒持有鎖代表擁有該鎖物件對應的資源的使用權，其它執行緒再無法使用該資源；而cpu排程是cpu排程策略來控制的，與是否持鎖並無關係。比如執行sleep時持有鎖但不會被cpu排程。

很多知識都是通過前輩部落格整理而來，前輩比較好的程式碼demo也會借鑑用來展示說明，比如介紹比較全面的執行緒相關命令介紹