Java線程總結(轉)
作者的blog:(http://blog.matrix.org.cn/page/Kaizen)
首先要理解線程首先須要了解一些主要的東西，我們如今所使用的大多數操作系統都屬於多任務，分時操作系統。正是因為這樣的操作系統的出現才有了多線程這個概念。我們使用的windows,linux就屬於此列。
什麽是分時操作系統呢。通俗一點與就是能夠同一時間運行多個程序的操作系統，在自己的電腦上面。你是不是一邊聽歌，一邊聊天還一邊看網頁呢？但實際上。並不上cpu在同一時候運行這些程序，cpu僅僅是將時間分割為時間片，然後將時間片分配給這些程序。獲得時間片的程序開始運行，不等運行完畢，下個程序又獲得時間片開始運行，這樣多個程序輪流運行一段時間，因為如今cpu的快速計算能力，給人的感覺就像是多個程序在同一時候運行一樣。
一般能夠在同一時間內運行多個程序的操作系統都有進程的概念.一個進程就是一個運行中的程序,而每一個進程都有自己獨立的一塊內存空間,一組系統資源.在進程概念中,每一個進程的內部數據和狀態都是完全獨立的.因此能夠想像創建並運行一個進程的系統開像是比較大的，所以線程出現了。在java中。程序通過流控制來運行程序流,程序中單個順序的流控制稱為線程,多線程則指的是在單個程序中能夠同一時候運行多個不同的線程,運行不同的任務.多線程意味著一個程序的多行語句能夠看上去差點兒在同一時間內同一時候運行.（你能夠將前面一句話的程序換成進程，進程是程序的一次運行過程,是系統運行程序的基本單位）
線程與進程類似,是一段完畢某個特定功能的代碼,是程序中單個順序的流控制;但與進程不同的是,同類的多個線程是共享一塊內存空間和一組系統資源,而線程本身的數據通常僅僅有微處理器的寄存器數據,以及一個供程序運行時使用的堆棧.所以系統在產生一個線程,或者在各個線程之間切換時,負擔要比進程小的多,正因如此,線程也被稱為輕負荷進程(light-weight process).一個進程中能夠包括多個線程.
多任務是指在一個系統中能夠同一時候運行多個程序,即有多個獨立運行的任務,每一個任務相應一個進程。同進程一樣,一個線程也有從創建,運行到消亡的過程,稱為線程的生命周期.用線程的狀態(state)表明線程處在生命周期的哪個階段.線程有創建,可運行,運行中,堵塞,死亡五中狀態.通過線程的控制與調度可使線程在這幾種狀態間轉化每一個程序至少自己主動擁有一個線程,稱為主線程.當程序載入到內存時,啟動主線程.
[線程的運行機制以及調度模型]
java中多線程就是一個類或一個程序運行或管理多個線程運行任務的能力。每一個線程能夠獨立於其它線程而獨立運行，當然也能夠和其它線程協同運行，一個類控制著它的全部線程。能夠決定哪個線程得到優先級，哪個線程能夠訪問其它類的資源，哪個線程開始運行，哪個保持休眠狀態。
以下是線程的機制圖：
線程的狀態表示線程正在進行的活動以及在此時間段內所能完畢的任務.線程有創建,可運行,運行中,堵塞,死亡五中狀態.一個具有生命的線程,總是處於這五種狀態之中的一個：
1.創建狀態
使用new運算符創建一個線程後,該線程僅僅是一個空對象,系統沒有分配資源,稱該線程處於創建狀態(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就插了進來，這樣非常可能導致意外的結果。
解決的方法非常easy，就是將對數據進行操作方法聲明為synchronized,當方法被該keyword聲明後，也就意味著，假設這個數據被加鎖，僅僅有一個對象得到這個數據的鎖的時候該對象才幹對這個數據進行操作。也就是當你存款的時候。這筆賬戶在其它地方是不能進行操作的，僅僅有你存款完畢。銀行管理人員將賬戶解鎖。其它人才幹對這個賬戶進行操作。
改動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的線程，還須要自己多做總結
Java線程總結(轉)