林炳文Evankaka原創作品。轉載請注明出處http://blog.csdn.net/evankaka

        寫在前面的話：此文只能說是java多線程的一個入門，其實Java里頭線程完全可以寫一本書了，但是如果最基本的你都學掌握好，又怎么能更上一個臺階呢？如果你覺得此文很簡單，那推薦你看看Java并發包的的線程池（Java并發編程與技術內幕:線程池深入理解），或者看這個專欄：Java并發編程與技術內幕。你將會對Java里頭的高并發場景下的線程有更加深刻的理解。

目錄(?)[-]

1. 一擴展javalangThread類
2. 二實現javalangRunnable接口
3. 三Thread和Runnable的區別
4. 四線程狀態轉換
5. 五線程調度
6. 六常用函數說明
1. 使用方式
2. 為什么要用join方法
7. 七常見線程名詞解釋
8. 八線程同步
9. 九線程數據傳遞

        本文主要講了java中多線程的使用方法、線程同步、線程數據傳遞、線程狀態及相應的一些線程函數用法、概述等。在這之前，首先讓我們來了解下在操作系統中進程和線程的區別：

　　進程：每個進程都有獨立的代碼和數據空間（進程上下文），進程間的切換會有較大的開銷，一個進程包含1--n個線程。（進程是資源分配的最小單位）

　　線程：同一類線程共享代碼和數據空間，每個線程有獨立的運行棧和程序計數器(PC)，線程切換開銷小。（線程是cpu調度的最小單位）

　　線程和進程一樣分為五個階段：創建、就緒、運行、阻塞、終止。

　　多進程是指操作系統能同時運行多個任務（程序）。

　　多線程是指在同一程序中有多個順序流在執行。

在java中要想實現多線程，有兩種手段，一種是繼續Thread類，另外一種是實現Runable接口.(其實準確來講，應該有三種，還有一種是實現Callable接口，并與Future、線程池結合使用，此文這里不講這個，有興趣看這里Java并發編程與技術內幕:Callable、Future、FutureTask、CompletionService )

一、擴展java.lang.Thread類

這里繼承Thread類的方法是比較常用的一種，如果說你只是想起一條線程。沒有什么其它特殊的要求，那么可以使用Thread.（筆者推薦使用Runable，后頭會說明為什么）。下面來看一個簡單的實例

[java] view plain copy

 

 

1. package com.multithread.learning;  
2. /** 
3.  *@functon 多線程學習 
4.  *@author 林炳文 
5.  *@time 2015.3.9 
6.  */  
7. class Thread1 extends Thread{  
8.     private String name;  
9.     public Thread1(String name) {  
10.        this.name=name;  
11.     }  
12.     public void run() {  
13.         for (int i = 0; i < 5; i++) {  
14.             System.out.println(name + "運行  :  " + i);  
15.             try {  
16.                 sleep((int) Math.random() * 10);  
17.             } catch (InterruptedException e) {  
18.                 e.printStackTrace();  
19.             }  
20.         }  
21.          
22.     }  
23. }  
24. public class Main {  
25.   
26.     public static void main(String[] args) {  
27.         Thread1 mTh2=new Thread1("A");  
28.         Thread1 mTh3=new Thread1("B");  
29.         mTh2.start();  
30.         mTh3.start();  
31.   
32.     }  
33.   
34. }  

輸出：

A運行  :  0
B運行  :  0
A運行  :  1
A運行  :  2
A運行  :  3
A運行  :  4
B運行  :  1
B運行  :  2
B運行  :  3
B運行  :  4

再運行一下：

A運行  :  0
B運行  :  0
B運行  :  1
B運行  :  2
B運行  :  3
B運行  :  4
A運行  :  1
A運行  :  2
A運行  :  3
A運行  :  4

但是start方法重復調用的話，會出現java.lang.IllegalThreadStateException異常。

[java] view plain copy

 

 

1. Thread1 mTh2=new Thread1("A");  
2. Thread1 mTh3=mTh2;  
3. mTh2.start();  
4. mTh3.start();  

輸出：

Exception in thread "main" java.lang.IllegalThreadStateException
    at java.lang.Thread.start(Unknown Source)
    at com.multithread.learning.Main.main(Main.java:31)
A運行  :  0
A運行  :  1
A運行  :  2
A運行  :  3
A運行  :  4

二、實現java.lang.Runnable接口

采用Runnable也是非常常見的一種，我們只需要重寫run方法即可。下面也來看個實例。

[java] view plain copy

 

 

1. /** 
2.  *@functon 多線程學習 
3.  *@author 林炳文 
4.  *@time 2015.3.9 
5.  */  
6. package com.multithread.runnable;  
7. class Thread2 implements Runnable{  
8.     private String name;  
9.   
10.     public Thread2(String name) {  
11.         this.name=name;  
12.     }  
13.   
14.     @Override  
15.     public void run() {  
16.           for (int i = 0; i < 5; i++) {  
17.                 System.out.println(name + "運行  :  " + i);  
18.                 try {  
19.                     Thread.sleep((int) Math.random() * 10);  
20.                 } catch (InterruptedException e) {  
21.                     e.printStackTrace();  
22.                 }  
23.             }  
24.           
25.     }  
26.       
27. }  
28. public class Main {  
29.   
30.     public static void main(String[] args) {  
31.         new Thread(new Thread2("C")).start();  
32.         new Thread(new Thread2("D")).start();  
33.     }  
34.   
35. }  

輸出：

C運行  :  0
D運行  :  0
D運行  :  1
C運行  :  1
D運行  :  2
C運行  :  2
D運行  :  3
C運行  :  3
D運行  :  4
C運行  :  4

總結：

實現Runnable接口比繼承Thread類所具有的優勢：

1）：適合多個相同的程序代碼的線程去處理同一個資源

2）：可以避免java中的單繼承的限制

3）：增加程序的健壯性，代碼可以被多個線程共享，代碼和數據獨立

4）：線程池只能放入實現Runable或callable類線程，不能直接放入繼承Thread的類

提醒一下大家：main方法其實也是一個線程。在java中所以的線程都是同時啟動的，至于什么時候，哪個先執行，完全看誰先得到CPU的資源。

在java中，每次程序運行至少啟動2個線程。一個是main線程，一個是垃圾收集線程。因為每當使用java命令執行一個類的時候，實際上都會啟動一個ＪＶＭ，每一個ｊＶＭ實習在就是在操作系統中啟動了一個進程。

四、線程狀態轉換

五、線程調度

線程的調度

 注意：Thread中suspend()和resume()兩個方法在JDK1.5中已經廢除，不再介紹。因為有死鎖傾向。

六、常用函數說明

①sleep(long millis): 在指定的毫秒數內讓當前正在執行的線程休眠（暫停執行）

②join():指等待t線程終止。

使用方式。

join是Thread類的一個方法，啟動線程后直接調用，即join()的作用是：“等待該線程終止”，這里需要理解的就是該線程是指的主線程等待子線程的終止。也就是在子線程調用了join()方法后面的代碼，只有等到子線程結束了才能執行。

 

[java] view plain copy

 

 

1. Thread t = new AThread(); t.start(); t.join();  

 

為什么要用join()方法

在很多情況下，主線程生成并起動了子線程，如果子線程里要進行大量的耗時的運算，主線程往往將于子線程之前結束，但是如果主線程處理完其他的事務后，需要用到子線程的處理結果，也就是主線程需要等待子線程執行完成之后再結束，這個時候就要用到join()方法了。

不加join。

[java] view plain copy

 

 

1. /** 
2.  *@functon 多線程學習,join 
3.  *@author 林炳文 
4.  *@time 2015.3.9 
5.  */  
6. package com.multithread.join;  
7. class Thread1 extends Thread{  
8.     private String name;  
9.     public Thread1(String name) {  
10.         super(name);  
11.        this.name=name;  
12.     }  
13.     public void run() {  
14.         System.out.println(Thread.currentThread().getName() + " 線程運行開始!");  
15.         for (int i = 0; i < 5; i++) {  
16.             System.out.println("子線程"+name + "運行 : " + i);  
17.             try {  
18.                 sleep((int) Math.random() * 10);  
19.             } catch (InterruptedException e) {  
20.                 e.printStackTrace();  
21.             }  
22.         }  
23.         System.out.println(Thread.currentThread().getName() + " 線程運行結束!");  
24.     }  
25. }  
26.   
27. public class Main {  
28.   
29.     public static void main(String[] args) {  
30.         System.out.println(Thread.currentThread().getName()+"主線程運行開始!");  
31.         Thread1 mTh2=new Thread1("A");  
32.         Thread1 mTh3=new Thread1("B");  
33.         mTh2.start();  
34.         mTh3.start();  
35.         System.out.println(Thread.currentThread().getName()+ "主線程運行結束!");  
36.   
37.     }  
38.   
39. }  

輸出結果：
main主線程運行開始!
main主線程運行結束!
B 線程運行開始!
子線程B運行 : 0
A 線程運行開始!
子線程A運行 : 0
子線程B運行 : 1
子線程A運行 : 1
子線程A運行 : 2
子線程A運行 : 3
子線程A運行 : 4
A 線程運行結束!
子線程B運行 : 2
子線程B運行 : 3
子線程B運行 : 4
B 線程運行結束!
發現主線程比子線程早結束

加join

[java] view plain copy

 

 

1. public class Main {  
2.   
3.     public static void main(String[] args) {  
4.         System.out.println(Thread.currentThread().getName()+"主線程運行開始!");  
5.         Thread1 mTh2=new Thread1("A");  
6.         Thread1 mTh3=new Thread1("B");  
7.         mTh2.start();  
8.         mTh3.start();  
9.         try {  
10.             mTh2.join();  
11.         } catch (InterruptedException e) {  
12.             e.printStackTrace();  
13.         }  
14.         try {  
15.             mTh3.join();  
16.         } catch (InterruptedException e) {  
17.             e.printStackTrace();  
18.         }  
19.         System.out.println(Thread.currentThread().getName()+ "主線程運行結束!");  
20.   
21.     }  
22.   
23. }  

運行結果：
main主線程運行開始!
A 線程運行開始!
子線程A運行 : 0
B 線程運行開始!
子線程B運行 : 0
子線程A運行 : 1
子線程B運行 : 1
子線程A運行 : 2
子線程B運行 : 2
子線程A運行 : 3
子線程B運行 : 3
子線程A運行 : 4
子線程B運行 : 4
A 線程運行結束!
主線程一定會等子線程都結束了才結束

③yield():暫停當前正在執行的線程對象，并執行其他線程。

        Thread.yield()方法作用是：暫停當前正在執行的線程對象，并執行其他線程。

         yield()應該做的是讓當前運行線程回到可運行狀態，以允許具有相同優先級的其他線程獲得運行機會。因此，使用yield()的目的是讓相同優先級的線程之間能適當的輪轉執行。但是，實際中無法保證yield()達到讓步目的，因為讓步的線程還有可能被線程調度程序再次選中。

 

結論：yield()從未導致線程轉到等待/睡眠/阻塞狀態。在大多數情況下，yield()將導致線程從運行狀態轉到可運行狀態，但有可能沒有效果。可看上面的圖。

[cpp] view plain copy

 

 

1. /** 
2.  *@functon 多線程學習 yield 
3.  *@author 林炳文 
4.  *@time 2015.3.9 
5.  */  
6. package com.multithread.yield;  
7. class ThreadYield extends Thread{  
8.     public ThreadYield(String name) {  
9.         super(name);  
10.     }  
11.    
12.     @Override  
13.     public void run() {  
14.         for (int i = 1; i <= 50; i++) {  
15.             System.out.println("" + this.getName() + "-----" + i);  
16.             // 當i為30時，該線程就會把CPU時間讓掉，讓其他或者自己的線程執行（也就是誰先搶到誰執行）  
17.             if (i ==30) {  
18.                 this.yield();  
19.             }  
20.         }  
21.       
22. }  
23. }  
24.   
25. public class Main {  
26.   
27.     public static void main(String[] args) {  
28.           
29.         ThreadYield yt1 = new ThreadYield("張三");  
30.         ThreadYield yt2 = new ThreadYield("李四");  
31.         yt1.start();  
32.         yt2.start();  
33.     }  
34.   
35. }  

運行結果：

第一種情況：李四（線程）當執行到30時會CPU時間讓掉，這時張三（線程）搶到CPU時間并執行。

第二種情況：李四（線程）當執行到30時會CPU時間讓掉，這時李四（線程）搶到CPU時間并執行。

sleep()和yield()的區別
        sleep()和yield()的區別):sleep()使當前線程進入停滯狀態，所以執行sleep()的線程在指定的時間內肯定不會被執行；yield()只是使當前線程重新回到可執行狀態，所以執行yield()的線程有可能在進入到可執行狀態后馬上又被執行。
        sleep 方法使當前運行中的線程睡眼一段時間，進入不可運行狀態，這段時間的長短是由程序設定的，yield 方法使當前線程讓出 CPU 占有權，但讓出的時間是不可設定的。實際上，yield()方法對應了如下操作：先檢測當前是否有相同優先級的線程處于同可運行狀態，如有，則把 CPU  的占有權交給此線程，否則，繼續運行原來的線程。所以yield()方法稱為“退讓”，它把運行機會讓給了同等優先級的其他線程
       另外，sleep 方法允許較低優先級的線程獲得運行機會，但 yield()  方法執行時，當前線程仍處在可運行狀態，所以，不可能讓出較低優先級的線程些時獲得 CPU 占有權。在一個運行系統中，如果較高優先級的線程沒有調用 sleep 方法，又沒有受到 I\O 阻塞，那么，較低優先級線程只能等待所有較高優先級的線程運行結束，才有機會運行。 

④setPriority(): 更改線程的優先級。

　　　　MIN_PRIORITY = 1
  　　   NORM_PRIORITY = 5
           MAX_PRIORITY = 10

用法：

Thread4 t1 = new Thread4("t1");
Thread4 t2 = new Thread4("t2");
t1.setPriority(Thread.MAX_PRIORITY);
t2.setPriority(Thread.MIN_PRIORITY);

⑤interrupt():不要以為它是中斷某個線程！它只是線線程發送一個中斷信號，讓線程在無限等待時（如死鎖時）能拋出拋出，從而結束線程，但是如果你吃掉了這個異常，那么這個線程還是不會中斷的！

⑥wait()

Obj.wait()，與Obj.notify()必須要與synchronized(Obj)一起使用，也就是wait,與notify是針對已經獲取了Obj鎖進行操作，從語法角度來說就是Obj.wait(),Obj.notify必須在synchronized(Obj){...}語句塊內。從功能上來說wait就是說線程在獲取對象鎖后，主動釋放對象鎖，同時本線程休眠。直到有其它線程調用對象的notify()喚醒該線程，才能繼續獲取對象鎖，并繼續執行。相應的notify()就是對對象鎖的喚醒操作。但有一點需要注意的是notify()調用后，并不是馬上就釋放對象鎖的，而是在相應的synchronized(){}語句塊執行結束，自動釋放鎖后，JVM會在wait()對象鎖的線程中隨機選取一線程，賦予其對象鎖，喚醒線程，繼續執行。這樣就提供了在線程間同步、喚醒的操作。Thread.sleep()與Object.wait()二者都可以暫停當前線程，釋放CPU控制權，主要的區別在于Object.wait()在釋放CPU同時，釋放了對象鎖的控制。

    單單在概念上理解清楚了還不夠，需要在實際的例子中進行測試才能更好的理解。對Object.wait()，Object.notify()的應用最經典的例子，應該是三線程打印ABC的問題了吧，這是一道比較經典的面試題，題目要求如下：

    建立三個線程，A線程打印10次A，B線程打印10次B,C線程打印10次C，要求線程同時運行，交替打印10次ABC。這個問題用Object的wait()，notify()就可以很方便的解決。代碼如下：

 

[java] view plain copy

 

 

1. /** 
2.  * wait用法 
3.  * @author DreamSea  
4.  * @time 2015.3.9  
5.  */  
6. package com.multithread.wait;  
7. public class MyThreadPrinter2 implements Runnable {     
8.         
9.     private String name;     
10.     private Object prev;     
11.     private Object self;     
12.     
13.     private MyThreadPrinter2(String name, Object prev, Object self) {     
14.         this.name = name;     
15.         this.prev = prev;     
16.         this.self = self;     
17.     }     
18.     
19.     @Override    
20.     public void run() {     
21.         int count = 10;     
22.         while (count > 0) {     
23.             synchronized (prev) {     
24.                 synchronized (self) {     
25.                     System.out.print(name);     
26.                     count--;    
27.                       
28.                     self.notify();     
29.                 }     
30.                 try {     
31.                     prev.wait();     
32.                 } catch (InterruptedException e) {     
33.                     e.printStackTrace();     
34.                 }     
35.             }     
36.     
37.         }     
38.     }     
39.     
40.     public static void main(String[] args) throws Exception {     
41.         Object a = new Object();     
42.         Object b = new Object();     
43.         Object c = new Object();     
44.         MyThreadPrinter2 pa = new MyThreadPrinter2("A", c, a);     
45.         MyThreadPrinter2 pb = new MyThreadPrinter2("B", a, b);     
46.         MyThreadPrinter2 pc = new MyThreadPrinter2("C", b, c);     
47.              
48.              
49.         new Thread(pa).start();  
50.         Thread.sleep(100);  //確保按順序A、B、C執行  
51.         new Thread(pb).start();  
52.         Thread.sleep(100);    
53.         new Thread(pc).start();     
54.         Thread.sleep(100);    
55.         }     
56. }    

輸出結果：

 

ABCABCABCABCABCABCABCABCABCABC

     先來解釋一下其整體思路，從大的方向上來講，該問題為三線程間的同步喚醒操作，主要的目的就是ThreadA->ThreadB->ThreadC->ThreadA循環執行三個線程。為了控制線程執行的順序，那么就必須要確定喚醒、等待的順序，所以每一個線程必須同時持有兩個對象鎖，才能繼續執行。一個對象鎖是prev，就是前一個線程所持有的對象鎖。還有一個就是自身對象鎖。主要的思想就是，為了控制執行的順序，必須要先持有prev鎖，也就前一個線程要釋放自身對象鎖，再去申請自身對象鎖，兩者兼備時打印，之后首先調用self.notify()釋放自身對象鎖，喚醒下一個等待線程，再調用prev.wait()釋放prev對象鎖，終止當前線程，等待循環結束后再次被喚醒。運行上述代碼，可以發現三個線程循環打印ABC，共10次。程序運行的主要過程就是A線程最先運行，持有C,A對象鎖，后釋放A,C鎖，喚醒B。線程B等待A鎖，再申請B鎖，后打印B，再釋放B，A鎖，喚醒C，線程C等待B鎖，再申請C鎖，后打印C，再釋放C,B鎖，喚醒A。看起來似乎沒什么問題，但如果你仔細想一下，就會發現有問題，就是初始條件，三個線程按照A,B,C的順序來啟動，按照前面的思考，A喚醒B，B喚醒C，C再喚醒A。但是這種假設依賴于JVM中線程調度、執行的順序。
    wait和sleep區別
共同點： 
1. 他們都是在多線程的環境下，都可以在程序的調用處阻塞指定的毫秒數，并返回。 
2. wait()和sleep()都可以通過interrupt()方法 打斷線程的暫停狀態 ，從而使線程立刻拋出InterruptedException。 
   如果線程A希望立即結束線程B，則可以對線程B對應的Thread實例調用interrupt方法。如果此刻線程B正在wait/sleep /join，則線程B會立刻拋出InterruptedException，在catch() {} 中直接return即可安全地結束線程。 
   需要注意的是，InterruptedException是線程自己從內部拋出的，并不是interrupt()方法拋出的。對某一線程調用 interrupt()時，如果該線程正在執行普通的代碼，那么該線程根本就不會拋出InterruptedException。但是，一旦該線程進入到 wait()/sleep()/join()后，就會立刻拋出InterruptedException 。 
不同點： 
1. Thread類的方法：sleep(),yield()等 
   Object的方法：wait()和notify()等 
2. 每個對象都有一個鎖來控制同步訪問。Synchronized關鍵字可以和對象的鎖交互，來實現線程的同步。 
   sleep方法沒有釋放鎖，而wait方法釋放了鎖，使得其他線程可以使用同步控制塊或者方法。 
3. wait，notify和notifyAll只能在同步控制方法或者同步控制塊里面使用，而sleep可以在任何地方使用 
4. sleep必須捕獲異常，而wait，notify和notifyAll不需要捕獲異常
所以sleep()和wait()方法的最大區別是：
　　　　sleep()睡眠時，保持對象鎖，仍然占有該鎖；
　　　　而wait()睡眠時，釋放對象鎖。
　　但是wait()和sleep()都可以通過interrupt()方法打斷線程的暫停狀態，從而使線程立刻拋出InterruptedException（但不建議使用該方法）。
sleep（）方法
sleep()使當前線程進入停滯狀態（阻塞當前線程），讓出CUP的使用、目的是不讓當前線程獨自霸占該進程所獲的CPU資源，以留一定時間給其他線程執行的機會;
　　 sleep()是Thread類的Static(靜態)的方法；因此他不能改變對象的機鎖，所以當在一個Synchronized塊中調用Sleep()方法是，線程雖然休眠了，但是對象的機鎖并木有被釋放，其他線程無法訪問這個對象（即使睡著也持有對象鎖）。
　　在sleep()休眠時間期滿后，該線程不一定會立即執行，這是因為其它線程可能正在運行而且沒有被調度為放棄執行，除非此線程具有更高的優先級。 
wait（）方法
wait()方法是Object類里的方法；當一個線程執行到wait()方法時，它就進入到一個和該對象相關的等待池中，同時失去（釋放）了對象的機鎖（暫時失去機鎖，wait(long timeout)超時時間到后還需要返還對象鎖）；其他線程可以訪問；
　　wait()使用notify或者notifyAlll或者指定睡眠時間來喚醒當前等待池中的線程。
　　wiat()必須放在synchronized block中，否則會在program runtime時扔出”java.lang.IllegalMonitorStateException“異常。

線程類的一些常用方法： 

　　sleep(): 強迫一個線程睡眠Ｎ毫秒。 
　　isAlive(): 判斷一個線程是否存活。 
　　join(): 等待線程終止。 
　　activeCount(): 程序中活躍的線程數。 
　　enumerate(): 枚舉程序中的線程。 
    currentThread(): 得到當前線程。 
　　isDaemon(): 一個線程是否為守護線程。 
　　setDaemon(): 設置一個線程為守護線程。(用戶線程和守護線程的區別在于，是否等待主線程依賴于主線程結束而結束) 
　　setName(): 為線程設置一個名稱。 
　　wait(): 強迫一個線程等待。 
　　notify(): 通知一個線程繼續運行。 
　　setPriority(): 設置一個線程的優先級。

八、線程同步

1、synchronized關鍵字的作用域有二種： 
1）是某個對象實例內，synchronized aMethod(){}可以防止多個線程同時訪問這個對象的synchronized方法（如果一個對象有多個synchronized方法，只要一個線程訪問了其中的一個synchronized方法，其它線程不能同時訪問這個對象中任何一個synchronized方法）。這時，不同的對象實例的synchronized方法是不相干擾的。也就是說，其它線程照樣可以同時訪問相同類的另一個對象實例中的synchronized方法； 
2）是某個類的范圍，synchronized static aStaticMethod{}防止多個線程同時訪問這個類中的synchronized static 方法。它可以對類的所有對象實例起作用。 

2、除了方法前用synchronized關鍵字，synchronized關鍵字還可以用于方法中的某個區塊中，表示只對這個區塊的資源實行互斥訪問。用法是: synchronized(this){/*區塊*/}，它的作用域是當前對象； 

3、synchronized關鍵字是不能繼承的，也就是說，基類的方法synchronized f(){} 在繼承類中并不自動是synchronized f(){}，而是變成了f(){}。繼承類需要你顯式的指定它的某個方法為synchronized方法； 

Java對多線程的支持與同步機制深受大家的喜愛，似乎看起來使用了synchronized關鍵字就可以輕松地解決多線程共享數據同步問題。到底如何？――還得對synchronized關鍵字的作用進行深入了解才可定論。

總的說來，synchronized關鍵字可以作為函數的修飾符，也可作為函數內的語句，也就是平時說的同步方法和同步語句塊。如果再細的分類，synchronized可作用于instance變量、object reference（對象引用）、static函數和class literals(類名稱字面常量)身上。

在進一步闡述之前，我們需要明確幾點：

A．無論synchronized關鍵字加在方法上還是對象上，它取得的鎖都是對象，而不是把一段代碼或函數當作鎖――而且同步方法很可能還會被其他線程的對象訪問。

B．每個對象只有一個鎖（lock）與之相關聯。

C．實現同步是要很大的系統開銷作為代價的，甚至可能造成死鎖，所以盡量避免無謂的同步控制。

接著來討論synchronized用到不同地方對代碼產生的影響：

假設P1、P2是同一個類的不同對象，這個類中定義了以下幾種情況的同步塊或同步方法，P1、P2就都可以調用它們。

1．  把synchronized當作函數修飾符時，示例代碼如下：

Public synchronized void methodAAA()

{

//….

}

這也就是同步方法，那這時synchronized鎖定的是哪個對象呢？它鎖定的是調用這個同步方法對象。也就是說，當一個對象P1在不同的線程中執行這個同步方法時，它們之間會形成互斥，達到同步的效果。但是這個對象所屬的Class所產生的另一對象P2卻可以任意調用這個被加了synchronized關鍵字的方法。

上邊的示例代碼等同于如下代碼：

public void methodAAA()

{

synchronized (this)      //  (1)

{

       //…..

}

}

 (1)處的this指的是什么呢？它指的就是調用這個方法的對象，如P1。可見同步方法實質是將synchronized作用于object reference。――那個拿到了P1對象鎖的線程，才可以調用P1的同步方法，而對P2而言，P1這個鎖與它毫不相干，程序也可能在這種情形下擺脫同步機制的控制，造成數據混亂：（

2．同步塊，示例代碼如下：

            public void method3(SomeObject so)

              {

                     synchronized(so)

{

       //…..

}

}

這時，鎖就是so這個對象，誰拿到這個鎖誰就可以運行它所控制的那段代碼。當有一個明確的對象作為鎖時，就可以這樣寫程序，但當沒有明確的對象作為鎖，只是想讓一段代碼同步時，可以創建一個特殊的instance變量（它得是一個對象）來充當鎖：

class Foo implements Runnable

{

       private byte[] lock = new byte[0];  // 特殊的instance變量

    Public void methodA()

{

       synchronized(lock) { //… }

}

//…..

}

注：零長度的byte數組對象創建起來將比任何對象都經濟――查看編譯后的字節碼：生成零長度的byte[]對象只需3條操作碼，而Object lock = new Object()則需要7行操作碼。

3．將synchronized作用于static 函數，示例代碼如下：

      Class Foo

{

public synchronized static void methodAAA()   // 同步的static 函數

{

//….

}

public void methodBBB()

{

       synchronized(Foo.class)   //  class literal(類名稱字面常量)

}

       }

   代碼中的methodBBB()方法是把class literal作為鎖的情況，它和同步的static函數產生的效果是一樣的，取得的鎖很特別，是當前調用這個方法的對象所屬的類（Class，而不再是由這個Class產生的某個具體對象了）。

記得在《Effective Java》一書中看到過將 Foo.class和 P1.getClass()用于作同步鎖還不一樣，不能用P1.getClass()來達到鎖這個Class的目的。P1指的是由Foo類產生的對象。

可以推斷：如果一個類中定義了一個synchronized的static函數A，也定義了一個synchronized 的instance函數B，那么這個類的同一對象Obj在多線程中分別訪問A和B兩個方法時，不會構成同步，因為它們的鎖都不一樣。A方法的鎖是Obj這個對象，而B的鎖是Obj所屬的那個Class。

九、線程數據傳遞

在傳統的同步開發模式下，當我們調用一個函數時，通過這個函數的參數將數據傳入，并通過這個函數的返回值來返回最終的計算結果。但在多線程的異步開發模式下，數據的傳遞和返回和同步開發模式有很大的區別。由于線程的運行和結束是不可預料的，因此，在傳遞和返回數據時就無法象函數一樣通過函數參數和return語句來返回數據。

9.1、通過構造方法傳遞數據 
在創建線程時，必須要建立一個Thread類的或其子類的實例。因此，我們不難想到在調用start方法之前通過線程類的構造方法將數據傳入線程。并將傳入的數據使用類變量保存起來，以便線程使用(其實就是在run方法中使用)。下面的代碼演示了如何通過構造方法來傳遞數據： 

[java] view plain copy

 

 

1.    
2. package mythread;   
3. public class MyThread1 extends Thread   
4. {   
5. private String name;   
6. public MyThread1(String name)   
7. {   
8. this.name = name;   
9. }   
10. public void run()   
11. {   
12. System.out.println("hello " + name);   
13. }   
14. public static void main(String[] args)   
15. {   
16. Thread thread = new MyThread1("world");   
17. thread.start();   
18. }   
19. }   

由于這種方法是在創建線程對象的同時傳遞數據的，因此，在線程運行之前這些數據就就已經到位了，這樣就不會造成數據在線程運行后才傳入的現象。如果要傳遞更復雜的數據，可以使用集合、類等數據結構。使用構造方法來傳遞數據雖然比較安全，但如果要傳遞的數據比較多時，就會造成很多不便。由于Java沒有默認參數，要想實現類似默認參數的效果，就得使用重載，這樣不但使構造方法本身過于復雜，又會使構造方法在數量上大增。因此，要想避免這種情況，就得通過類方法或類變量來傳遞數據。 

9.2、通過變量和方法傳遞數據 
向對象中傳入數據一般有兩次機會，第一次機會是在建立對象時通過構造方法將數據傳入，另外一次機會就是在類中定義一系列的public的方法或變量（也可稱之為字段）。然后在建立完對象后，通過對象實例逐個賦值。下面的代碼是對MyThread1類的改版，使用了一個setName方法來設置 name變量： 

[java] view plain copy

 

 

1.    
2. package mythread;   
3. public class MyThread2 implements Runnable   
4. {   
5. private String name;   
6. public void setName(String name)   
7. {   
8. this.name = name;   
9. }   
10. public void run()   
11. {   
12. System.out.println("hello " + name);   
13. }   
14. public static void main(String[] args)   
15. {   
16. MyThread2 myThread = new MyThread2();   
17. myThread.setName("world");   
18. Thread thread = new Thread(myThread);   
19. thread.start();   
20. }   
21. }   

9.3、通過回調函數傳遞數據 

上面討論的兩種向線程中傳遞數據的方法是最常用的。但這兩種方法都是main方法中主動將數據傳入線程類的。這對于線程來說，是被動接收這些數據的。然而，在有些應用中需要在線程運行的過程中動態地獲取數據，如在下面代碼的run方法中產生了3個隨機數，然后通過Work類的process方法求這三個隨機數的和，并通過Data類的value將結果返回。從這個例子可以看出，在返回value之前，必須要得到三個隨機數。也就是說，這個 value是無法事先就傳入線程類的。 

[java] view plain copy

 

 

1.    
2. package mythread;   
3. class Data   
4. {   
5. public int value = 0;   
6. }   
7. class Work   
8. {   
9. public void process(Data data, Integer numbers)   
10. {   
11. for (int n : numbers)   
12. {   
13. data.value += n;   
14. }   
15. }   
16. }   
17. public class MyThread3 extends Thread   
18. {   
19. private Work work;   
20. public MyThread3(Work work)   
21. {   
22. this.work = work;   
23. }   
24. public void run()   
25. {   
26. java.util.Random random = new java.util.Random();   
27. Data data = new Data();   
28. int n1 = random.nextInt(1000);   
29. int n2 = random.nextInt(2000);   
30. int n3 = random.nextInt(3000);   
31. work.process(data, n1, n2, n3); // 使用回調函數   
32. System.out.println(String.valueOf(n1) + "+" + String.valueOf(n2) + "+"   
33. + String.valueOf(n3) + "=" + data.value);   
34. }   
35. public static void main(String[] args)   
36. {   
37. Thread thread = new MyThread3(new Work());   
38. thread.start();   
39. }   
40. }   

  好了，Java多線程的基礎知識就講到這里了，有興趣研究多線程的推薦直接看java的源碼，你將會得到很大的提升！

林炳文Evankaka原創作品。轉載請注明出處http://blog.csdn.net/evankaka