Java多線程剖析

時間 2019-11-06

標籤 java 多線程剖析欄目 Java 简体版

原文原文鏈接

問題的原因源自於一道簡單的面試題：題目要求以下：前端

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

解決問題前咱們前補充一些基本知識：面試

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()方法就能夠實現多線程操做了，可是一個類只能繼承一個父類，這是此方法的侷限。ide

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

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

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();
    }
}