java 多線程剖析，java剖析

java 多線程剖析，java剖析

問題的緣由源自於一道簡單的面試題：題目要求如下：

建立三個線程，A線程列印10次A，B線程列印10次B,C線程列印10次C，要求線程同時運行，交替列印10次ABC。

解決問題前我們前補充一些基本知識：

Runnable和Thread線程的啟動

線程的起動並不是簡單的調用了你的RUN方法,而是由一個線程調度器來分別調用你的所有線程的RUN方法,
我們普通的RUN方法如果沒有執行完是不會返回的,也就是會一直執行下去,這樣RUN方法下面的方法就不可能會執行了,可是線程裡的RUN方法卻不一樣,它只有一定的CPU時間,執行過後就給別的線程了,這樣反覆的把CPU的時間切來切去,因為切換的速度很快,所以我們就感覺是很多線程在同時運行一樣.

你簡單的調用run方法是沒有這樣效果的,所以你必須調用Thread類的start方法來啟動你的線程.所以你啟動線程有兩種方法
一是寫一個類繼承自Thread類,然後重寫裡面的run方法,用start方法啟動線程
二是寫一個類實現Runnable介面,實現裡面的run方法,用new Thread(Runnable target).start()方法來啟動

這兩種方法都必須實現RUN方法,這樣線程起動的時候,線程管理器好去調用你的RUN方法.

start()和run()的關係

通過調用Thread類的start()方法來啟動一個線程， 
這時此線程是處於就緒狀態， 
並沒有運行。 
然後通過此Thread類調用方法run()來完成其運行操作的， 
這裡方法run()稱為線程體， 
它包含了要執行的這個線程的內容， 
Run方法運行結束， 
此線程終止， 
而CPU再運行其它線程， 

而如果直接用Run方法， 
這隻是調用一個方法而已， 
程式中依然只有主線程--這一個線程， 
其程式執行路徑還是只有一條， 
這樣就沒有達到寫線程的目的。 

區別

Thread類是在java.lang包中定義的。一個類只要繼承了Thread類同時覆寫了本類中的run()方法就可以實現多線程操作了，但是一個類只能繼承一個父類，這是此方法的局限。

實現Runnable介面相對於繼承Thread類來說，有如下顯著的好處： 

(1)適合多個相同程式碼的線程去處理同一資源的情況，把虛擬CPU（線程）同程式的代碼，資料有效分離，較好地體現了物件導向的設計思想。 

(2)可以避免由於Java的單繼承特性帶來的局限。我們經常碰到這樣一種情況，即當我們要將已經繼承了某一個類的子類放入多線程中，由於一個類不能同時有兩個父類，所以不能用繼承Thread類的方式，那麼，這個類就只能採用實現Runnable介面的方式了。 

(3)有利於程式的健壯性，代碼能夠被多個線程共用，代碼與資料是獨立的。當多個線程的執行代碼來自同一個類的執行個體時，即稱它們共用相同的代碼。多個線程操作相同的資料，與它們的代碼無關。當共用訪問相同的對象是，即它們共用相同的資料。當線程被構造時，需要的代碼和資料通過一個對象作為建構函式實參傳遞進去，這個對象就是一個實現了Runnable介面的類的執行個體。 

我在測試中發現，繼承Thread的時候線程是順序的，實現Runnable的時候確實不確定順序的

wait和notify以及sleep

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同時，釋放了對象鎖的控制。

對於sleep()方法，我們首先要知道該方法是屬於Thread類中的。而wait()方法，則是屬於Object類中的。

sleep()方法導致了程式暫停執行指定的時間，讓出cpu該其他線程，但是他的監控狀態依然保持者，當指定的時間到了又會自動回復運行狀態。

在調用sleep()方法的過程中，線程不會釋放對象鎖。

而當調用wait()方法的時候，線程會放棄對象鎖，進入等待此對象的等待鎖定池，只有針對此對象調用notify()方法後本線程才進入對象鎖定池準備

有了這下知識之後，下面我們來解決問題吧

題目剖析

從題目我們可以得到幾個要點：

1：線程同時運行：但是對線程的啟動沒有做要求

2：每個線程列印十次對應的字母

3：交替列印：意味著三個線程的的列印操作有嚴格的順序性

思路分析

1：每個線程列印不同的字母，操作類似，可以用統一的類來實現，並且用不用的自己初始化

2：線程之間之間有先後性，列印A的線程列印了，列印B的線程才能列印，然後到C，迴圈

如何保證線程之間的執行順序的有序性是本題目的痛點，

痛點突破

列印的線程應該在列印一次A之後就應該進入等待狀態，直到列印C的線程列印一次C之後在重新執行

列印B、C的線程也類似

簡單思路

定義三個Object遍曆a，b，c，每個線程同時獲得這三個對象鎖才列印對應的字母一次，列印一次後釋放另外兩個對象的鎖

問題

每個線程都要同時獲得三個對象鎖才能列印，那個第一個線程列印完，如果只是釋放另外兩個對象的鎖，那個就沒有線程可以繼續列印了；

如果三個都釋放，那意味著當前線程可以繼續列印了。

所以，用三個對象鎖的思路似乎是行不通了

正確的思路之一（可能還有其他思路）

每個線程只有同時獲得自己和自己的首碼對象的鎖（例如A的首碼是C，B的是A），才能列印一次自己的字母，然後釋放自己首碼對象的鎖，進入自己前端對象的等待線程池裡面，等待自己首碼對象被喚醒之後才能繼續列印

那麼自己首碼對象什麼時候被喚醒呢？

很簡單的思路，列印A的線程在列印一次A之後進入等待C對象的線程池裡面，那麼只要列印C的線程在列印自己的時候喚醒一下自己就好了，這樣列印A的線程就可以在列印C的線程列印一次C之後馬上可以列印一次A；

列印完一次自己後，馬上喚醒自己，然後釋放自己首碼對象的鎖，進入自己前端對象的等待線程池裡面，讓自己的尾碼線程可以馬上列印，依次迴圈，問題好像已經解決了。

潛在問題

由於每個線程只擁有兩個鎖，並且只等待一個鎖，那麼對線程的啟動順序還是有要求的。假如啟動的順序是ACB，我們來分析一下：

線程A：一開始獲得AC兩個鎖，列印A，喚醒A，進入等待C被喚醒的線程池，釋放AC

線程B：一開始獲得AB兩個鎖，列印B，喚醒B，進入等待A被喚醒的線程池，釋放AB

線程C：一開始獲得BC兩個鎖，列印C，喚醒C，進入等待B被喚醒的線程池，釋放BC

這完全是沒有問題的，所以我們必須保證列印ABC對應的線程順序啟動

做法很簡單：啟動A後短暫sleep一下就好，如果只是這樣

        new Thread(aThread).start();//        Thread.sleep(10);        new Thread(bThread).start();//        Thread.sleep(10);        new Thread(cThread).start();//        Thread.sleep(10);

如果你的類是implements Runnable的話，那個著三個線程啟動的順序是沒有保證的，

當然，你可以改成extends Thread，這樣的話這三個線程就是順序啟動的。

下面是完整的實現代碼：

/**  *  * @author 戚偉傑  * @version 2015年11月20日 上午10:15:07   */public class MyThreadPrint implements Runnable{    private String name;    private Object prev;    private Object self;    public MyThreadPrint(String name,Object prev,Object self) {        // TODO Auto-generated constructor stub        this.name = name;        this.prev = prev;        this.self = self;    }    @Override    public void run() {        // TODO Auto-generated method stub        int count = 10;        while(count>0){            synchronized (prev) {                synchronized (self) {                    System.out.print(name);                    count--;//                    self.notify();                }                try {                    prev.wait();                } catch (InterruptedException e) {                    // TODO Auto-generated catch block                    e.printStackTrace();                }            }        }    }    public static void main(String[] args) throws InterruptedException{        Object a = new Object();         Object b = new Object();        Object c = new Object();        MyThreadPrint aThread = new MyThreadPrint("a",c,a);        MyThreadPrint bThread = new MyThreadPrint("b",a,b);        MyThreadPrint cThread = new MyThreadPrint("c",b,c);        new Thread(aThread).start();//        Thread.sleep(10);        new Thread(bThread).start();//        Thread.sleep(10);        new Thread(cThread).start();//        Thread.sleep(10);//        aThread.run();//        bThread.run();//        cThread.run();    }}

p