Java線程總結

版權申明,獲得授權轉載必須保留以下申明和鏈接:
作者的blog:( http://blog.matrix.org.cn/page/Kaizen)

在論壇上面常常看到初學者對線程的無可奈何，所以總結出了下面一篇文章，希望對一些正在學習使用java線程的初學者有所協助。

首先要理解線程首先需要瞭解一些基本的東西，我們現在所使用的大多數作業系統都屬於多任務，分時作業系統。正是由於這種作業系統的出現才有了多線程這個概念。我們使用的windows,linux就屬於此列。什麼是分時作業系統呢，通俗一點與就是可以同一時間執行多個程式的作業系統，在自己的電腦上面，你是不是一邊聽歌，一邊聊天還一邊看網頁呢？但實際上，並不上cpu在同時執行這些程式，cpu只是將時間切割為時間片，然後將時間片分配給這些程式，獲得時間片的程式開始執行，不等執行完畢，下個程式又獲得時間片開始執行，這樣多個程式輪流執行一段時間，由於現在cpu的高速計算能力，給人的感覺就像是多個程式在同時執行一樣。
一般可以在同一時間內執行多個程式的作業系統都有進程的概念.一個進程就是一個執行中的程式,而每一個進程都有自己獨立的一塊記憶體空間,一組系統資源.在進程概念中,每一個進程的內部資料和狀態都是完全獨立的.因此可以想像建立並執行一個進程的系統開像是比較大的，所以線程出現了。在java中，程式通過流量控制來執行程式流,程式中單個順序的流量控制稱為線程,多線程則指的是在單個程式中可以同時運行多個不同的線程,執行不同的任務.多線程意味著一個程式的多行語句可以看上去幾乎在同一時間內同時運行.（你可以將前面一句話的程式換成進程，進程是程式的一次執行過程,是系統運行程式的基本單位）

線程與進程相似,是一段完成某個特定功能的代碼,是程式中單個順序的流量控制;但與進程不同的是,同類的多個線程是共用一塊記憶體空間和一組系統資源,而線程本身的資料通常只有微處理器的寄存器資料,以及一個供程式執行時使用的堆棧.所以系統在產生一個線程,或者在各個線程之間切換時,負擔要比進程小的多,正因如此,線程也被稱為輕負荷進程(light-weight process).一個進程中可以包含多個線程.

多任務是指在一個系統中可以同時運行多個程式,即有多個獨立啟動並執行任務,每個任務對應一個進程，同進程一樣,一個線程也有從建立,運行到消亡的過程,稱為線程的生命週期.用線程的狀態(state)表明線程處在生命週期的哪個階段.線程有建立,可運行,運行中,阻塞,死亡五中狀態.通過線程的控制與調度可使線程在這幾種狀態間轉化每個程式至少自動擁有一個線程,稱為主線程.當程式載入到記憶體時,啟動主線程.

[線程的運行機制以及調度模型]
java中多線程就是一個類或一個程式執行或管理多個線程執行任務的能力，每個線程可以獨立於其他線程而獨立運行，當然也可以和其他線程協同運行，一個類控制著它的所有線程，可以決定哪個線程得到優先順序，哪個線程可以訪問其他類的資源，哪個線程開始執行，哪個保持休眠狀態。
下面是線程的機製圖：

線程的狀態表示線程進行中的活動以及在此時間段內所能完成的任務.線程有建立,可運行,運行中,阻塞,死亡五中狀態.一個具有生命的線程,總是處於這五種狀態之一：
1.建立狀態
使用new運算子建立一個線程後,該線程僅僅是一個Null 物件,系統沒有分配資源,稱該線程處於建立狀態(new thread)
2.可運行狀態
使用start()方法啟動一個線程後,系統為該線程分配了除CPU外的所需資源,使該線程處於可運行狀態(Runnable)
3.運行中狀態
Java運行系統通過調度選中一個Runnable的線程,使其佔有CPU並轉為運行中狀態(Running).此時,系統真正執行線程的run()方法.
4.阻塞狀態
一個正在啟動並執行線程因某種原因不能繼續運行時,進入阻塞狀態(Blocked)
5.死亡狀態
線程結束後是死亡狀態(Dead)

同一時刻如果有多個線程處於可運行狀態,則他們需要排隊等待CPU資源.此時每個線程自動獲得一個線程的優先順序(priority),優先順序的高低反映線程的重要或緊急程度.可運行狀態的線程按優先順序排隊,線程調度依據優先順序基礎上的"先到先服務"原則.
線程調度管理器負責線程排隊和CPU線上程間的分配,並由線程調度演算法進行調度.當線程調度管理器選種某個線程時,該線程獲得CPU資源而進入運行狀態.

線程調度是先佔式調度,即如果在當前線程執行過程中一個更高優先順序的線程進入可運行狀態,則這個線程立即被調度執行.先佔式調度分為:獨佔式和分時方式.
獨佔方式下,當前執行線程將一直執行下去,直 到執行完畢或由於某種原因主動放棄CPU,或CPU被一個更高優先順序的線程搶佔
分時方式下,當前運行線程獲得一個時間片,時間到時,即使沒有執行完也要讓出CPU,進入可運行狀態,等待下一個時間片的調度.系統選中其他可運行狀態的線程執行
分時方式的系統使每個線程工作若干步,實現多線程同時運行

另外請注意下面的線程調度規則（如果有不理解，不急，往下看）：
①如果兩個或是兩個以上的線程都修改一個對象，那麼把執行修改的方法定義為被同步的（Synchronized）,如果對象更新影響到唯讀方法，那麼只度方法也應該定義為同步的
②如果一個線程必須等待一個對象狀態發生變化，那麼它應該在對象內部等待，而不是在外部等待，它可以調用一個被同步的方法，並讓這個方法調用wait()
③每當一個方法改變某個對象的狀態的時候，它應該調用notifyAll()方法，這給等待隊列的線程提供機會來看一看執行環境是否已發生改變
④記住wait(),notify(),notifyAll()方法屬於Object類，而不是Thread類，仔細檢查看是否每次執行wait()方法都有相應的notify()或notifyAll()方法，且它們作用與相同的對象 在java中每個類都有一個主線程，要執行一個程式，那麼這個類當中一定要有main方法，這個man方法也就是java class中的主線程。你可以自己建立線程，有兩種方法，一是繼承Thread類，或是實現Runnable介面。一般情況下，最好避免繼承，因為java中是單根繼承，如果你選用繼承，那麼你的類就失去了彈性，當然也不能全然否定繼承Thread,該方法編寫簡單,可以直接操作線程,適用於單重繼承情況。至於選用那一種，具體情況具體分析。

eg.繼承Thread

public class MyThread_1 extends Thread
{
public void run()
{
//some code 
}
}

eg.實現Runnable介面

public class MyThread_2 implements Runnable
{
public void run()
{
//some code 
}
}

當使用繼承建立線程，這樣啟動線程：

new MyThread_1().start()

當使用實現介面建立線程，這樣啟動線程：

new Thread(new MyThread_2()).start()

注意，其實是建立一個線程執行個體，並以實現了Runnable介面的類為參數傳入這個執行個體，當執行這個線程的時候，MyThread_2中run裡面的代碼將被執行。
下面是完成的例子：

public class MyThread implements Runnable
{ 

public void run()
{ 
System.out.println("My Name is "+Thread.currentThread().getName()); 
} 
public static void main(String[] args)
{
new Thread(new MyThread()).start(); 
}
} 

執行後將列印出：
My Name is Thread-0

你也可以建立多個線程，像下面這樣

new Thread(new MyThread()).start();
new Thread(new MyThread()).start();
new Thread(new MyThread()).start();

那麼會列印出：
My Name is Thread-0
My Name is Thread-1
My Name is Thread-2

看了上面的結果，你可能會認為線程的執行順序是依次執行的，但是那隻是一般情況，千萬不要用以為是線程的執行機制；影響線程執行順序的因素有幾點：首先看看前面提到的優先順序別

public class MyThread implements Runnable
{ 

public void run()
{ 
System.out.println("My Name is "+Thread.currentThread().getName()); 
} 
public static void main(String[] args)
{
Thread t1=new Thread(new MyThread());
Thread t2=new Thread(new MyThread());
Thread t3=new Thread(new MyThread());
t2.setPriority(Thread.MAX_PRIORITY);//賦予最高優先順序
t1.start();
t2.start();
t3.start();
}
} 

再看看結果：
My Name is Thread-1
My Name is Thread-0
My Name is Thread-2

線程的優先順序分為10級，分別用1到10的整數代表，預設情況是5。上面的t2.setPriority(Thread.MAX_PRIORITY)等價與t2.setPriority(10）
然後是線程程式本身的設計，比如使用sleep,yield,join，wait等方法（詳情請看JDKDocument)

public class MyThread implements Runnable
{ 
public void run()
{ 
try
{
int sleepTime=(int)(Math.random()*100);//產生隨機數字，
Thread.currentThread().sleep(sleepTime);//讓其休眠一定時間，時間又上面sleepTime決定
//public static void sleep(long millis)throw InterruptedException （API）
System.out.println(Thread.currentThread().getName()+" 睡了 "+sleepTime);
}catch(InterruptedException ie)//由於線程在休眠可能被中斷，所以調用sleep方法的時候需要捕捉異常
{
ie.printStackTrace();
} 
} 
public static void main(String[] args)
{
Thread t1=new Thread(new MyThread());
Thread t2=new Thread(new MyThread());
Thread t3=new Thread(new MyThread());
t1.start();
t2.start();
t3.start();
}
}

執行後觀察其輸出：

Thread-0 睡了 11
Thread-2 睡了 48
Thread-1 睡了 69

上面的執行結果是隨機的，再執行很可能出現不同的結果。由於上面我在run中添加了休眠語句，當線程休眠的時候就會讓出cpu，cpu將會選擇執行處於runnable狀態中的其他線程，當然也可能出現這種情況，休眠的Thread立即進入了runnable狀態，cpu再次執行它。
[線程組概念]
線程是可以被組織的，java中存線上程組的概念，每個線程都是一個線程組的成員,線程組把多個線程整合為一個對象,通過線程組可以同時對其中的多個線程進行操作,如啟動一個線程組的所有線程等.Java的線程組由java.lang包中的Thread——Group類實現.
ThreadGroup類用來管理一組線程,包括:線程的數目,線程間的關係,線程正在執行的操作,以及線程將要啟動或終止時間等.線程組還可以包含線程組.在Java的應用程式中,最高層的線程組是名位main的線程組,在main中還可以加入線程或線程組,在mian的子線程組中也可以加入線程和線程組,形成線程組和線程之間的樹狀繼承關係。像上面建立的線程都是屬於main這個線程組的。
借用上面的例子，main裡面可以這樣寫：

public static void main(String[] args)
{
/***************************************
ThreadGroup(String name) 
ThreadGroup(ThreadGroup parent, String name) 
***********************************/
ThreadGroup group1=new ThreadGroup("group1");
ThreadGroup group2=new ThreadGroup(group1,"group2");
Thread t1=new Thread(group2,new MyThread());
Thread t2=new Thread(group2,new MyThread());
Thread t3=new Thread(group2,new MyThread());
t1.start();
t2.start();
t3.start();
}

線程組的嵌套，t1,t2,t3被加入group2,group2加入group1。
另外一個比較多就是關於線程同步方面的，試想這樣一種情況，你有一筆存款在銀行，你在一家銀行為你的賬戶存款，而你的妻子在另一家銀行從這個賬戶提款，現在你有1000塊在你的賬戶裡面。你存入了1000，但是由於另一方也在對這筆存款進行操作，人家開始執行的時候只看到賬戶裡面原來的1000元，當你的妻子提款1000元後，你妻子所在的銀行就認為你的賬戶裡面沒有錢了，而你所在的銀行卻認為你還有2000元。
看看下面的例子：

class BlankSaving //儲蓄賬戶
{
private static int money=10000;
public void add(int i)
{
money=money+i;
System.out.println("Husband 向銀行存入了 [￥"+i+"]");
}
public void get(int i)
{
money=money-i;
System.out.println("Wife 向銀行取走了 [￥"+i+"]");
if(money<0)
System.out.println("餘額不足！"); 
}
public int showMoney()
{
return money;
}
} 


class Operater implements Runnable
{
String name;
BlankSaving bs;
public Operater(BlankSaving b,String s)
{
name=s;
bs=b;



}
public static void oper(String name,BlankSaving bs)
{



if(name.equals("husband"))
{
try
{
for(int i=0;i<10;i++)
{
Thread.currentThread().sleep((int)(Math.random()*300));
bs.add(1000);
}
}catch(InterruptedException e){}
}else
{
try
{



for(int i=0;i<10;i++)
{
Thread.currentThread().sleep((int)(Math.random()*300));
bs.get(1000);
}
}catch(InterruptedException e){}
}
}
public void run()
{
oper(name,bs);
} 
}
public class BankTest 
{
public static void main(String[] args)throws InterruptedException
{
BlankSaving bs=new BlankSaving();
Operater o1=new Operater(bs,"husband");
Operater o2=new Operater(bs,"wife");
Thread t1=new Thread(o1);
Thread t2=new Thread(o2);
t1.start();
t2.start();
Thread.currentThread().sleep(500);
}



}

下面是其中一次的執行結果：

---------first--------------
Husband 向銀行存入了 [￥1000]
Wife 向銀行取走了 [￥1000]
Wife 向銀行取走了 [￥1000]
Husband 向銀行存入了 [￥1000]
Wife 向銀行取走了 [￥1000]
Husband 向銀行存入了 [￥1000]
Wife 向銀行取走了 [￥1000]
Husband 向銀行存入了 [￥1000]
Wife 向銀行取走了 [￥1000]
Husband 向銀行存入了 [￥1000]
Husband 向銀行存入了 [￥1000]
Wife 向銀行取走了 [￥1000]
Husband 向銀行存入了 [￥1000]
Husband 向銀行存入了 [￥1000]
Wife 向銀行取走了 [￥1000]
Wife 向銀行取走了 [￥1000]
Husband 向銀行存入了 [￥1000]
Wife 向銀行取走了 [￥1000]
Wife 向銀行取走了 [￥1000]
Husband 向銀行存入了 [￥1000]

看到了嗎，這可不是正確的需求，在husband還沒有結束操作的時候，wife就插了進來，這樣很可能導致意外的結果。解決辦法很簡單，就是將對資料進行操作方法聲明為synchronized,當方法被該關鍵字聲明後，也就意味著，如果這個資料被加鎖，只有一個對象得到這個資料的鎖的時候該對象才能對這個資料進行操作。也就是當你存款的時候，這筆賬戶在其他地方是不能進行操作的，只有你存款完畢，銀行管理員將賬戶解鎖，其他人才能對這個賬戶進行操作。
修改public static void oper(String name,BlankSaving bs)為public static void oper(String name,BlankSaving bs)，再看看結果:

Husband 向銀行存入了 [￥1000]
Husband 向銀行存入了 [￥1000]
Husband 向銀行存入了 [￥1000]
Husband 向銀行存入了 [￥1000]
Husband 向銀行存入了 [￥1000]
Husband 向銀行存入了 [￥1000]
Husband 向銀行存入了 [￥1000]
Husband 向銀行存入了 [￥1000]
Husband 向銀行存入了 [￥1000]
Husband 向銀行存入了 [￥1000]
Wife 向銀行取走了 [￥1000]
Wife 向銀行取走了 [￥1000]
Wife 向銀行取走了 [￥1000]
Wife 向銀行取走了 [￥1000]
Wife 向銀行取走了 [￥1000]
Wife 向銀行取走了 [￥1000]
Wife 向銀行取走了 [￥1000]
Wife 向銀行取走了 [￥1000]
Wife 向銀行取走了 [￥1000]
Wife 向銀行取走了 [￥1000]

當丈夫完成操作後，妻子才開始執行操作，這樣的話，對共用對象的操作就不會有問題了。
[wait and notify]
你可以利用這兩個方法很好的控制線程的執行流程，當線程調用wait方法後，線程將被掛起，直到被另一線程喚醒（notify）或則是如果wait方法指定有時間得話，在沒有被喚醒的情況下，指定時間時間過後也將自動被喚醒。但是要注意一定，被喚醒並不是指馬上執行，而是從組塞狀態變為可運行狀態，其是否運行還要看cpu的調度。
案例代碼：

class MyThread_1 extends Thread
{
Object lock;
public MyThread_1(Object o)
{
lock=o;
}
public void run()
{
try
{
synchronized(lock)
{
System.out.println("Enter Thread_1 and wait");
lock.wait();
System.out.println("be notified");
}
}catch(InterruptedException e){}
}
}
class MyThread_2 extends Thread
{
Object lock;
public MyThread_2(Object o)
{
lock=o;
}
public void run()
{
synchronized(lock)
{
System.out.println("Enter Thread_2 and notify");
lock.notify();
}
}
}
public class MyThread
{ 
public static void main(String[] args)
{
int[] in=new int[0];//notice
MyThread_1 t1=new MyThread_1(in);
MyThread_2 t2=new MyThread_2(in);
t1.start();
t2.start();
}
}

執行結果如下：
Enter Thread_1 and wait
Enter Thread_2 and notify
Thread_1 be notified

可能你注意到了在使用wait and notify方法得時候我使用了synchronized塊來封裝這兩個方法，這是由於調用這兩個方法的時候線程必須獲得鎖，也就是上面代碼中的lock[]，如果你不用synchronized封裝這兩個方法的得話，又或則鎖不一是同一把，比如在MyThread_2中synchronized(lock)改為synchronized(this),那麼執行這個程式的時候將會拋出java.lang.IllegalMonitorStateException執行期異常。另外wait and notify方法是Object中的，並不在Thread這個類中。最後你可能注意到了這點：int[] in=new int[0];為什麼不是建立new Object而是一個0長度的數組，那是因為在java中建立一個0長度的數組來充當鎖更加高效。

Thread作為java中一重要組成部分，當然還有很多地方需要更深刻的認識，上面只是對Thread的一些常識和易錯問題做了一個簡要的總結，若要真正的掌握java的線程，還需要自己多做總結