最近學習併發程式設計遇到不少問題，就順手總結了有關多執行緒的幾個常用的方法

sleep()

sleep()方法屬於Thread類，主要的作用是讓當前執行緒停止執行，把cpu讓給其他執行緒執行，但不會釋放物件鎖和監控的狀態，到了指定時間後執行緒又會自動恢復執行狀態

注意：執行緒睡眠到期自動甦醒，並返回到可執行狀態，不是執行狀態。sleep()中指定的時間是執行緒不會執行的最短時間。因此，sleep()方法不能保證該執行緒睡眠到期後就開始執行

• 另外

  • Thread.sleep()方法是一個靜態方法

  • Java有兩種sleep方法,一個只有一個毫秒引數,另一個有毫秒和納秒
    個引數第三代

sleep(long millis)

or

sleep(long millis, int nanos)

1//此try語句塊放在run方法內
2try {
3            Thread.sleep(1000);
4       } catch (InterruptedException e) {
5            // TODO 自動生成的 catch 塊
6            e.printStackTrace();
7       }

wait() notify()

wait()屬於Object類，與sleep()的區別是當前執行緒會釋放鎖，進入等待此物件的等待鎖定池。比方說，執行緒A呼叫Obj.wait(),執行緒A就會停止執行，而轉為等待狀態。至於等待多長時間? 那就看其他執行緒是否呼叫Obj.notify().其優勢顯而易見，成為多個執行緒之間進行通訊的有手段！

注意：它必須包含在Synchronzied語句中，無論是wait()還是notify()都需要首先獲得目標的物件的一個監視器

• 先來解釋一下 "Synchronzied" 
  是一種同步鎖。作用是實現執行緒間同步，對同步的程式碼加鎖，使得每一次，只能有一執行緒進入同步塊，從而保證執行緒間的安全性

它修飾的物件有以下幾種：

• 修飾一個程式碼塊，被修飾的程式碼塊稱為同步語句塊，其作用的範圍是大括號{}括起來的部分,進入同步程式碼前要獲得給定物件的鎖

• 修飾一個例項方法，進入同步程式碼前要獲得當前例項的鎖

• 修飾一個靜態方法，進入同步程式碼前要獲得當前類的鎖

先給大家一個例子：

 1public class SimpleWN
 
 {
 2    public static int count=0;
 3    public static class one implements Runnable{
 4        @Override
 5        public void run() {
 6            for (int i = 0; i < 100; i++) {
 7                synchronized (this) {
 8                    count++;
 9                }
10            }                           
11        }   
12    }
13    public static void main(String[] args) throws InterruptedException {
14        Thread t1=new Thread(new one());
15        Thread t2=new Thread(new one());
16        t1.start();
17        t2.start();
18        t1.join();
19        t2.join();
20        System.out.println(count);
21    }
22}

不知道大家看出這段程式碼有一個嚴重錯誤。程式碼17，18行，兩個執行緒例項的不是同一個物件，這也意味兩個執行緒使用的是兩把不同的鎖，沒法保證同步。多執行幾次就會發現有時候結果並不是200

更正做法：

1    one oo=new one();
2    Thread t1=new Thread(oo);
3    Thread t2=new Thread(oo);

舉例說明程式中應用wait() 和 notify()：

 1public class SimpleWN {
 2    final static Object object=new Object();
 3    public static class one extends Thread{
 4        @Override
 5        public void run() {
 6            synchronized (object) {
 7                System.out.println("T1 開始");
 8                try {
 9                    System.out.println("T1 等待");
10                    object.wait();
11                } catch (InterruptedException e) {
12                    e.printStackTrace();
13                }
14                System.out.println("T1 結束");
15            }                   
16        }   
17    }
18    public static class two extends Thread{
19        @Override
20        public void run() {
21            synchronized (object) {
22                System.out.println("T2 開始");
23                System.out.println("釋放一個執行緒");
24                object.notify();
25                System.out.println("T2 結束");
26            }                   
27        }   
28    }
29    public static void main(String[] args) throws InterruptedException {
30        Thread t1=new one();
31        Thread t2=new two();
32        t1.start();
33        t2.start();
34        t1.join();
35        t2.join();
36    }
37}

執行結果:

1T1 開始
2T1 等待
3T2 開始
4釋放一個執行緒
5T2 結束
6T1 結束

join()

在某些情況下，子執行緒需要進行大量的耗時運算，主執行緒可能會在子執行緒執行結束之前結束，但是如果主執行緒又需要用到子執行緒的結果，換句話說，就是主執行緒需要在子執行緒執行之後再結束。這就需要用到join()方法

 1public class BigJoin {
 2    public static int count;
 3    public static class AddThread implements Runnable{
 4        @Override
 5        public void run() {
 6            for (int i = 0; i < 1000000000; i++) {
 7                count++;
 8            }   
 9        }   
10    }
11    public static void main(String[] args) throws InterruptedException {
12        // TODO 自動生成的方法存根
13        AddThread addThread=new AddThread();
14        Thread t1=new Thread(addThread);
15        t1.start();
16        t1.join();
17        System.out.println(count);
18    }
19}

yield()

中文意思：放棄，屈服
一個執行緒呼叫yield()意味著告訴虛擬機器自己非常樂於助人，可以把自己的位置讓給其他執行緒(這只是暗示，並不表絕對)。但得注意，讓出cpu並不代表當前執行緒不執行了。當前執行緒讓出cpu後，還會進行cpu資源的爭奪，但是能不能再次分配到，就不一定了

 1public class SimpleYield extends Thread{
 2    String name=null;
 3    public  SimpleYield(String name) {
 4        super(name);
 5    }
 6    @Override
 7    public void run() {
 8        // TODO 自動生成的方法存根
 9        for(int i=1;i<=10;i++){
10            System.out.println(this.getName()+i);
11            if(i==5){
12                this.yield();
13            }
14        }
15    }
16    public static void main(String[] args) throws InterruptedException {
17        SimpleYield t1=new SimpleYield("小花");
18        SimpleYield t2=new SimpleYield("小草");
19        t1.start();
20        t2.start();
21    }
22}

執行結果：這只是其中一種結果，執行緒(小花)的執行到2時把cpu讓給執行緒(小草)並執行,接下來-執行緒(小草)的執行到2時把cpu讓給執行緒(小花)並執行

1小花1
2小花2
3小草1
4小草2
5小花3
6小花4
7小草3
8小草4