程序師世界是廣大編程愛好者互助、分享、學習的平台,程序師世界有你更精彩!
首頁
編程語言
C語言|JAVA編程
Python編程
網頁編程
ASP編程|PHP編程
JSP編程
數據庫知識
MYSQL數據庫|SqlServer數據庫
Oracle數據庫|DB2數據庫
 程式師世界 >> 編程語言 >> 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();
    }
}
復制代碼

p

  1. 上一頁:
  2. 下一頁:
Copyright © 程式師世界 All Rights Reserved