程式師世界 >> 編程語言 >> JAVA編程 >> JAVA綜合教程 >> java 多線程剖析，java剖析

java 多線程剖析，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();
    }
}