Java之十三 Java多線程
你必定知道多任務處理，由於它實際上被全部的現代操做系統所支持。然而，多任務處理有兩種大相徑庭的類型：基於進程的和基於線程的。認識二者的不一樣是十分重要的。對不少讀者，基於進程的多任務處理是更熟悉的形式。進程(process)本質上是一個執行的程序。所以，基於進程(process-based)的多任務處理的特色是容許你的計算機同時運行兩個或更多的程序。舉例來講，基於進程的多任務處理使你在運用文本編輯器的時候能夠同時運行Java編譯器。在基於進程的多任務處理中，程序是調度程序所分派的最小代碼單位。在基於線程(thread-based)的多任務處理環境中，線程是最小的執行單位。這意味着一個程序能夠同時執行兩個或者多個任務的功能。例如，一個文本編輯器能夠在打印的同時格式化文本。因此，多進程程序處理「大圖片」，而多線程程序處理細節問題。 程序員
多線程程序比多進程程序須要更少的管理費用。進程是重量級的任務，須要分配它們本身獨立的地址空間。進程間通訊是昂貴和受限的。進程間的轉換也是很須要花費的。另外一方面，線程是輕量級的選手。它們共享相同的地址空間而且共同分享同一個進程。線程間通訊是便宜的，線程間的轉換也是低成本的。當Java程序使用多進程任務處理環境時，多進程程序不受Java的控制，而多線程則受Java控制。 編程
多線程幫助你寫出CPU最大利用率的高效程序，由於空閒時間保持最低。這對Java運行的交互式的網絡互連環境是相當重要的，由於空閒時間是公共的。舉個例子來講，網絡的數據傳輸速率遠低於計算機處理能力，本地文件系統資源的讀寫速度遠低於CPU的處理能力，固然，用戶輸入也比計算機慢不少。在傳統的單線程環境中，你的程序必須等待每個這樣的任務完成之後才能執行下一步——儘管CPU有不少空閒時間。多線程使你可以得到並充分利用這些空閒時間。若是你在Windows98 或Windows 2000這樣的操做系統下有編程經驗，那麼你已經熟悉了多線程。然而，Java管理線程使多線程處理尤爲方便，由於不少細節對你來講是易於處理的。安全
|
Java運行系統在不少方面依賴於線程，全部的類庫設計都考慮到多線程。實際上，Java使用線程來使整個環境異步。這有利於經過防止CPU循環的浪費來減小無效部分。 數據結構
爲更好的理解多線程環境的優點能夠將它與它的對照物相比較。單線程系統的處理途徑是使用一種叫做輪詢的事件循環方法。在該模型中，單線程控制在一無限循環中運行，輪詢一個事件序列來決定下一步作什麼。一旦輪詢裝置返回信號代表，已準備好讀取網絡文件，事件循環調度控制管理到適當的事件處理程序。直到事件處理程序返回，系統中沒有其餘事件發生。這就浪費了CPU時間。這致使了程序的一部分獨佔了系統，阻止了其餘事件的執行。 總的來講， 單線程環境， 當一個線程由於等待資源時阻塞（block，掛起執行），整個程序中止運行。 多線程
Java多線程的優勢在於取消了主循環/輪詢機制。一個線程能夠暫停而不影響程序的其餘部分。例如，當一個線程從網絡讀取數據或等待用戶輸入時產生的空閒時間能夠被利用到其餘地方。多線程容許活的循環在每一幀間隙中沉睡一秒而不暫停整個系統。在Java程序中出現線程阻塞，僅有一個線程暫停，其餘線程繼續運行。 併發
線程存在於好幾種狀態。線程能夠正在運行（running）。只要得到CPU時間它就能夠運行。運行的線程能夠被掛起（suspend），並臨時中斷它的執行。一個掛起的線程能夠被恢復（resume）， 容許它從中止的地方繼續運行。一個線程能夠在等待資源時被阻塞（block）。異步
在任什麼時候候，線程能夠終止（terminate），這當即中斷了它的運行。一旦終止，線程不能被恢復。編輯器
|
Java給每一個線程安排優先級以決定與其餘線程比較時該如何對待該線程。線程優先級是詳細說明線程間優先關係的整數。做爲絕對值，優先級是毫無心義的；當只有一個線程時，優先級高的線程並不比優先權低的線程運行的快。相反，線程的優先級是用來決定什麼時候從一個運行的線程切換到另外一個。這叫「上下文轉換」(context switch)。決定上下文轉換髮生的規則很簡單：
· 線程能夠自動放棄控制。在I/O未決定的狀況下，睡眠或阻塞由明確的讓步來完成。在這種假定下，全部其餘的線程被檢測，準備運行的最高優先級線程被授予CPU。
· 線程能夠被高優先級的線程搶佔。在這種狀況下，低優先級線程不主動放棄，處理器只是被先佔——不管它正在幹什麼——處理器被高優先級的線程佔據。基本上，一旦高優先級線程要運行，它就執行。這叫作有優先權的多任務處理。
當兩個相同優先級的線程競爭CPU週期時，情形有一點複雜。對於Windows98這樣的操做系統，等優先級的線程是在循環模式下自動劃分時間的。對於其餘操做系統，例如Solaris 2.x，等優先級線程相對於它們的對等體自動放棄。若是不這樣，其餘的線程就不會運行。
警告：不一樣的操做系統下等優先級線程的上下文轉換可能會產生錯誤。
|
由於多線程在你的程序中引入了一個異步行爲，因此在你須要的時候必須有增強同步性的方法。舉例來講，若是你但願兩個線程相互通訊並共享一個複雜的數據結構，例如鏈表序列，你須要某些方法來確保它們沒有相互衝突。也就是說，你必須防止一個線程寫入數據而另外一個線程正在讀取鏈表中的數據。爲此目的，Java在進程間同步性的老模式基礎上實行了另外一種方法：管程（monitor）。管程是一種由C.A.R.Hoare首先定義的控制機制。
你能夠把管程想象成一個僅控制一個線程的小盒子。一旦線程進入管程，全部線程必須等待直到該線程退出了管程。用這種方法，管程能夠用來防止共享的資源被多個線程操縱。
不少多線程系統把管程做爲程序必須明確的引用和操做的對象。Java提供一個清晰的解決方案。沒有「Monitor」類；相反，每一個對象都擁有本身的隱式管程，當對象的同步方法被調用時管程自動載入。一旦一個線程包含在一個同步方法中，沒有其餘線程能夠調用相同對象的同步方法。這就使你能夠編寫很是清晰和簡潔的多線程代碼，由於同步支持是語言內置的。
|
在你把程序分紅若干線程後，你就要定義各線程之間的聯繫。用大多數其餘語言規劃時，你必須依賴於操做系統來確立線程間通訊。這樣固然增長花費。然而，Java提供了多線程間談話清潔的、低成本的途徑——經過調用全部對象都有的預先肯定的方法。Java的消息傳遞系統容許一個線程進入一個對象的一個同步方法，而後在那裏等待，直到其餘線程明確通知它出來。
|
Java的多線程系統創建於Thread類，它的方法，它的共伴接口Runnable基礎上。Thread類封裝了線程的執行。既然你不能直接引用運行着的線程的狀態，你要經過它的代理處理它，因而Thread 實例產生了。爲建立一個新的線程，你的程序必須擴展Thread 或實現Runnable接口。
Thread類定義了好幾種方法來幫助管理線程。本章用到的方法如表13-1所示：
到目前爲止，本書所應用的例子都是用單線程的。本章剩餘部分解釋如何用Thread 和Runnable 來建立、管理線程。讓咱們從全部Java程序都有的線程：主線程開始。
|
當Java程序啓動時，一個線程馬上運行，該線程一般叫作程序的主線程（main thread），由於它是程序開始時就執行的。主線程的重要性體如今兩方面：
· 它是產生其餘子線程的線程
· 一般它必須最後完成執行，由於它執行各類關閉動做。
儘管主線程在程序啓動時自動建立，但它能夠由一個Thread對象控制。爲此，你必須調用方法currentThread()得到它的一個引用，currentThread()是Thread類的公有的靜態成員。
它的一般形式以下：
static Thread currentThread( )
該方法返回一個調用它的線程的引用。一旦你得到主線程的引用，你就能夠像控制其餘線程那樣控制主線程。
讓咱們從複習下面例題開始：
// Controlling the mainThread.
class CurrentThreadDemo {
public static void main(String args[]) {
Thread t = Thread.currentThread();
System.out.println("Current thread:" + t);
// change the name of the thread
t.setName("My Thread");
System.out.println("After name change:" + t);
try {
for(int n = 5; n > 0; n--) {
System.out.println(n);
Thread.sleep(1000);
}
} catch (InterruptedException e) {
System.out.println("Main threadinterrupted");
}
}
}
在本程序中，當前線程（天然是主線程）的引用經過調用currentThread()得到，該引用保存在局部變量t中。而後，程序顯示了線程的信息。接着程序調用setName()改變線程的內部名稱。線程信息又被顯示。而後，一個循環數從5開始遞減，每數一次暫停一秒。暫停是由sleep()方法來完成的。Sleep()語句明確規定延遲時間是1毫秒。注意循環外的try/catch塊。
Thread類的sleep()方法可能引起一個InterruptedException異常。這種情形會在其餘線程想要打攪沉睡線程時發生。本例只是打印了它是否被打斷的消息。在實際的程序中，你必須靈活處理此類問題。下面是本程序的輸出：
Current thread:Thread[main,5,main]
After name change: Thread[MyThread,5,main]
5
4
3
2
1
注意t做爲語句println()中參數運用時輸出的產生。該顯示順序：線程名稱，優先級以及組的名稱。默認狀況下，主線程的名稱是main。它的優先級是5，這也是默認值，main也是所屬線程組的名稱。一個線程組（thread group）是一種將線程做爲一個總體集合的狀態控制的數據結構。這個過程由專有的運行時環境來處理，在此就不贅述了。線程名改變後，又被輸出。此次，顯示了新的線程名。
讓咱們更仔細的研究程序中Thread類定義的方法。 sleep()方法按照毫秒級的時間指示使線程從被調用到掛起。它的一般形式以下：
static void sleep(longmilliseconds) throws InterruptedException
掛起的時間被明肯定義爲毫秒。該方法可能引起InterruptedException異常。
sleep()方法還有第二種形式，顯示以下，該方法容許你指定時間是以毫秒仍是以納秒爲週期。
static void sleep(long milliseconds,int nanoseconds) throws InterruptedException
第二種形式僅當容許以納秒爲時間週期時可用。
如上述程序所示，你能夠用setName()設置線程名稱，用getName()來得到線程名稱（該過程在程序中沒有體現）。這些方法都是Thread 類的成員，聲明以下：
final void setName(StringthreadName)
final String getName( )
這裏，threadName 特指線程名稱。
|
大多數狀況，經過實例化一個Thread對象來建立一個線程。Java定義了兩種方式：
· 實現Runnable 接口。
· 能夠繼承Thread類。
下面的兩小節依次介紹了每一種方式。
|
建立線程的最簡單的方法就是建立一個實現Runnable接口的類。Runnable抽象了一個執行代碼單元。你能夠經過實現Runnable接口的方法建立每個對象的線程。爲實現 Runnable 接口，一個類僅需實現一個run()的簡單方法，該方法聲明以下：
public void run( )
在run()中能夠定義代碼來構建新的線程。理解下面內容是相當重要的：run()方法可以像主線程那樣調用其餘方法，引用其餘類，聲明變量。僅有的不一樣是run()在程序中確立另外一個併發的線程執行入口。當run()返回時，該線程結束。
在你已經建立了實現Runnable接口的類之後，你要在類內部實例化一個Thread類的對象。Thread 類定義了好幾種構造函數。咱們會用到的以下：
Thread(Runnable threadOb, String threadName)
該構造函數中，threadOb是一個實現Runnable接口類的實例。 這定義了線程執行的起點。
新線程的名稱由threadName定義。創建新的線程後，它並不運行直到調用了它的start()方法，該方法在Thread 類中定義。本質上，start() 執行的是一個對run()的調用。 Start（）方法聲明以下：
void start( )
下面的例子是建立一個新的線程並啓動它運行：
// Create a second thread.
class NewThread implements Runnable {
Thread t;
NewThread(){
// Createa new, second thread
t = newThread(this, "Demo Thread");
System.out.println("Child thread: " + t);
t.start(); // Start the thread
}
// This isthe entry point for the second thread.
public voidrun() {
try {
for(inti = 5; i > 0; i--) {
System.out.println("Child Thread: " + i);
Thread.sleep(500);
}
} catch(InterruptedException e) {
System.out.println("Child interrupted.");
}
System.out.println("Exiting child thread.");
}
}
class ThreadDemo {
publicstatic void main(String args[]) {
newNewThread(); // create a new thread
try {
for(inti = 5; i > 0; i--) {
System.out.println("Main Thread: " + i);
Thread.sleep(1000);
}
} catch(InterruptedException e) {
System.out.println("Main thread interrupted.");
}
System.out.println("Main thread exiting.");
}
}
在NewThread 構造函數中，新的Thread對象由下面的語句建立：
t = new Thread(this, "Demo Thread");
經過前面的語句this 代表在this對象中你想要新的線程調用run()方法。而後，start() 被調用，以run()方法爲開始啓動了線程的執行。這使子線程for循環開始執行。調用start()以後，NewThread 的構造函數返回到main()。當主線程被恢復，它到達for 循環。兩個線程繼續運行，共享CPU，直到它們的循環結束。該程序的輸出以下：
Child thread: Thread[Demo Thread,5,main]
Main Thread: 5
Child Thread: 5
Child Thread: 4
Main Thread: 4
Child Thread: 3
Child Thread: 2
Main Thread: 3
Child Thread: 1
Exiting child thread.
Main Thread: 2
Main Thread: 1
Main thread exiting.
如前面提到的，在多線程程序中，一般主線程必須是結束運行的最後一個線程。實際上，一些老的JVM，若是主線程先於子線程結束，Java的運行時間系統就可能「掛起」。
前述程序保證了主線程最後結束，由於主線程沉睡週期1000毫秒，而子線程僅爲500毫秒。
這就使子線程在主線程結束以前先結束。簡而言之，你將看到等待線程結束的更好途徑。
|
建立線程的另外一個途徑是建立一個新類來擴展Thread類，而後建立該類的實例。當一個類繼承Thread時，它必須重載run()方法，這個run()方法是新線程的入口。它也必須調用start()方法去啓動新線程執行。下面用擴展thread類重寫前面的程序：
// Create a second thread by extending Thread
class NewThread extends Thread {
NewThread(){
// Createa new, second thread
super("Demo Thread");
System.out.println("Child thread: " + this);
start();// Start the thread
}
// This isthe entry point for the second thread.
public voidrun() {
try {
for(inti = 5; i > 0; i--) {
System.out.println("Child Thread: " + i);
Thread.sleep(500);
}
} catch(InterruptedException e) {
System.out.println("Child interrupted.");
}
System.out.println("Exiting child thread.");
}
}
class ExtendThread {
publicstatic void main(String args[]) {
newNewThread(); // create a new thread
try {
for(inti = 5; i > 0; i--) {
System.out.println("Main Thread: " + i);
Thread.sleep(1000);
}
} catch(InterruptedException e) {
System.out.println("Main thread interrupted.");
}
System.out.println("Main thread exiting.");
}
}
該程序生成和前述版本相同的輸出。子線程是由實例化NewThread對象生成的，該對象從Thread類派生。注意NewThread 中super()的調用。該方法調用了下列形式的Thread構造函數：
public Thread(String threadName)
這裏，threadName指定線程名稱。
|
到這裏，你必定會奇怪爲何Java有兩種建立子線程的方法，哪種更好呢。全部的問題都歸於一點。Thread類定義了多種方法能夠被派生類重載。對於全部的方法，唯一的必須被重載的是run()方法。這固然是實現Runnable接口所需的一樣的方法。不少Java程序員認爲類僅在它們被增強或修改時應該被擴展。所以，若是你不重載Thread的其餘方法時，最好只實現Runnable 接口。這固然由你決定。然而，在本章的其餘部分，咱們應用實現runnable接口的類來建立線程。
|
到目前爲止，咱們僅用到兩個線程：主線程和一個子線程。然而，你的程序能夠建立所需的更多線程。例如，下面的程序建立了三個子線程：
// Create multiple threads.
class NewThread implementsRunnable {
String name; // name of thread
Thread t;
NewThread(String threadname) {
name = threadname;
t = new Thread(this, name);
System.out.println("New thread: "+ t);
t.start(); // Start the thread
}
// This is the entry point for thread.
public void run() {
try {
for(int i = 5; i > 0; i--) {
System.out.println(name + ":" + i);
Thread.sleep(1000);
}
} catch (InterruptedException e) {
System.out.println(name +"Interrupted");
}
System.out.println(name + "exiting.");
}
}
class MultiThreadDemo {
public static void main(String args[]) {
newNewThread("One"); // start threads
new NewThread("Two");
new NewThread("Three");
try {
// wait for other threads to end
Thread.sleep(10000);
} catch (InterruptedException e) {
System.out.println("Main thread Interrupted");
}
System.out.println("Main threadexiting.");
}
}
程序輸出以下所示：
New thread: Thread[One,5,main]
New thread: Thread[Two,5,main]
New thread:Thread[Three,5,main]
One: 5
Two: 5
Three: 5
One: 4
Two: 4
Three: 4
One: 3
Three: 3
Two: 3
One: 2
Three: 2
Two: 2
One: 1
Three: 1
Two: 1
One exiting.
Two exiting.
Three exiting.
Main thread exiting.
如你所見，一旦啓動，全部三個子線程共享CPU。注意main()中對sleep(10000)的調用。這使主線程沉睡十秒確保它最後結束。
|
如前所述，一般你但願主線程最後結束。在前面的例子中，這點是經過在main()中調用sleep()來實現的，通過足夠長時間的延遲以確保全部子線程都先於主線程結束。然而，這不是一個使人滿意的解決方法，它也帶來一個大問題：一個線程如何知道另外一線程已經結束？幸運的是，Thread類提供了回答此問題的方法。
有兩種方法能夠斷定一個線程是否結束。第一，能夠在線程中調用isAlive()。這種方法由Thread定義，它的一般形式以下：
final boolean isAlive( )
若是所調用線程仍在運行，isAlive()方法返回true，若是不是則返回false。 但isAlive（）不多用到，等待線程結束的更經常使用的方法是調用join()，描述以下：
final void join( ) throwsInterruptedException
該方法等待所調用線程結束。該名字來自於要求線程等待直到指定線程參與的概念。
join()的附加形式容許給等待指定線程結束定義一個最大時間。下面是前面例子的改進版本。運用join()以確保主線程最後結束。一樣，它也演示了isAlive()方法。
// Using join() to wait forthreads to finish.
class NewThread implementsRunnable {
String name; // name of thread
Thread t;
NewThread(String threadname) {
name = threadname;
t = new Thread(this, name);
System.out.println("New thread: "+ t);
t.start(); // Start the thread
}
// This is the entry point for thread.
public void run() {
try {
for(int i = 5; i > 0; i--) {
System.out.println(name + ":" + i);
Thread.sleep(1000);
}
} catch (InterruptedException e) {
System.out.println(name + "interrupted.");
}
System.out.println(name + "exiting.");
}
}
class DemoJoin {
public static void main(String args[]) {
NewThread ob1 = newNewThread("One");
NewThread ob2 = newNewThread("Two");
NewThread ob3 = new NewThread("Three");
System.out.println("Thread One isalive: "
+ ob1.t.isAlive());
System.out.println("Thread Two isalive: "
+ ob2.t.isAlive());
System.out.println("Thread Three isalive: "
+ ob3.t.isAlive());
// wait for threads to finish
try {
System.out.println("Waiting forthreads to finish.");
ob1.t.join();
ob2.t.join();
ob3.t.join();
} catch (InterruptedException e) {
System.out.println("Main threadInterrupted");
}
System.out.println("Thread One isalive: "
+ ob1.t.isAlive());
System.out.println("Thread Two isalive: "
+ ob2.t.isAlive());
System.out.println("Thread Three isalive: "
+ ob3.t.isAlive());
System.out.println("Main threadexiting.");
}
}
程序輸出以下所示:
New thread: Thread[One,5,main]
New thread: Thread[Two,5,main]
New thread:Thread[Three,5,main]
Thread One is alive: true
Thread Two is alive: true
Thread Three is alive: true
Waiting for threads to finish.
One: 5
Two: 5
Three: 5
One: 4
Two: 4
Three: 4
One: 3
Two: 3
Three: 3
One: 2
Two: 2
Three: 2
One: 1
Two: 1
Three: 1
Two exiting.
Three exiting.
One exiting.
Thread One is alive: false
Thread Two is alive: false
Thread Three is alive: false
Main thread exiting.
如你所見，調用join()後返回，線程終止執行。
|
線程優先級被線程調度用來斷定什麼時候每一個線程容許運行。理論上，優先級高的線程比優先級低的線程得到更多的CPU時間。實際上，線程得到的CPU時間一般由包括優先級在內的多個因素決定（例如，一個實行多任務處理的操做系統如何更有效的利用CPU時間）。
一個優先級高的線程天然比優先級低的線程優先。舉例來講，當低優先級線程正在運行，而一個高優先級的線程被恢復（例如從沉睡中或等待I/O中），它將搶佔低優先級線程所使用的CPU。
理論上，等優先級線程有同等的權利使用CPU。但你必須當心了。記住，Java是被設計成能在不少環境下工做的。一些環境下實現多任務處理從本質上與其餘環境不一樣。爲安全起見，等優先級線程偶爾也受控制。這保證了全部線程在無優先級的操做系統下都有機會運行。實際上，在無優先級的環境下，多數線程仍然有機會運行，由於不少線程不可避免的會遭遇阻塞，例如等待輸入輸出。遇到這種情形，阻塞的線程掛起，其餘線程運行。
可是若是你但願多線程執行的順利的話，最好不要採用這種方法。一樣，有些類型的任務是佔CPU的。對於這些支配CPU類型的線程，有時你但願可以支配它們，以便使其餘線程能夠運行。
設置線程的優先級，用setPriority()方法，該方法也是Tread 的成員。它的一般形式爲：
final void setPriority(int level)
這裏，level指定了對所調用的線程的新的優先權的設置。Level的值必須在MIN_PRIORITY到MAX_PRIORITY範圍內。一般，它們的值分別是1和10。要返回一個線程爲默認的優先級，指定NORM_PRIORITY，一般值爲5。這些優先級在Thread中都被定義爲final型變量。
你能夠經過調用Thread的getPriority()方法來得到當前的優先級設置。該方法以下：
final int getPriority( )
當涉及調度時，Java的執行能夠有本質上不一樣的行爲。Windows 95/98/NT/2000 的工做或多或少如你所願。但其餘版本可能工做的徹底不一樣。大多數矛盾發生在你使用有優先級行爲的線程，而不是協同的騰出CPU時間。最安全的辦法是得到可預先性的優先權，Java得到跨平臺的線程行爲的方法是自動放棄對CPU的控制。
下面的例子闡述了兩個不一樣優先級的線程，運行於具備優先權的平臺，這與運行於無優先級的平臺不一樣。一個線程經過Thread.NORM_PRIORITY設置了高於普通優先級兩級的級數，另外一線程設置的優先級則低於普通級兩級。兩線程被啓動並容許運行10秒。每一個線程執行一個循環，記錄反覆的次數。10秒後，主線程終止了兩線程。每一個線程通過循環的次數被顯示。
// Demonstrate thread priorities.
class clicker implements Runnable {
int click =0;
Thread t;
privatevolatile boolean running = true;
publicclicker(int p) {
t = newThread(this);
t.setPriority(p);
}
public void run() {
while(running) {
click++;
}
}
public voidstop() {
running =false;
}
public voidstart() {
t.start();
}
}
class HiLoPri {
publicstatic void main(String args[]) {
Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
clickerhi = new clicker(Thread.NORM_PRIORITY + 2);
clickerlo = new clicker(Thread.NORM_PRIORITY - 2);
lo.start();
hi.start();
try { Thread.sleep(10000);
} catch(InterruptedException e) {
System.out.println("Main thread interrupted.");
}
lo.stop();
hi.stop();
// Waitfor child threads to terminate.
try {
hi.t.join();
lo.t.join();
} catch(InterruptedException e) {
System.out.println("InterruptedExceptioncaught");
}
System.out.println("Low-priority thread: " + lo.click);
System.out.println("High-priority thread: " + hi.click);
}
}
該程序在Windows 98下運行的輸出，代表線程確實上下轉換，甚至既不屈從於CPU，也不被輸入輸出阻塞。優先級高的線程得到大約90%的CPU時間。
Low-priority thread: 4408112
High-priority thread: 589626904
固然，該程序的精確的輸出結果依賴於你的CPU的速度和運行的其餘任務的數量。當一樣的程序運行於無優先級的系統，將會有不一樣的結果。
上述程序還有個值得注意的地方。注意running前的關鍵字volatile。儘管volatile 在下章會被很仔細的討論，用在此處以確保running的值在下面的循環中每次都獲得驗證。
while (running) {
click++;
}
若是不用volatile，Java能夠自由的優化循環：running的值被存在CPU的一個寄存器中，每次重複不必定須要複檢。volatile的運用阻止了該優化，告知Java running能夠改變，改變方式並不以直接代碼形式顯示。
|
當兩個或兩個以上的線程須要共享資源，它們須要某種方法來肯定資源在某一刻僅被一個線程佔用。達到此目的的過程叫作同步（synchronization）。像你所看到的，Java爲此提供了獨特的，語言水平上的支持。
同步的關鍵是管程（也叫信號量semaphore）的概念。管程是一個互斥獨佔鎖定的對象，或稱互斥體（mutex）。在給定的時間，僅有一個線程能夠得到管程。當一個線程須要鎖定，它必須進入管程。全部其餘的試圖進入已經鎖定的管程的線程必須掛起直到第一個線程退出管程。這些其餘的線程被稱爲等待管程。一個擁有管程的線程若是願意的話能夠再次進入相同的管程。
若是你用其餘語言例如C或C++時用到過同步，你會知道它用起來有一點詭異。這是由於不少語言它們本身不支持同步。相反，對同步線程，程序必須利用操做系統源語。幸運的是Java經過語言元素實現同步，大多數的與同步相關的複雜性都被消除。
你能夠用兩種方法同步化代碼。二者都包括synchronized關鍵字的運用，下面分別說明這兩種方法。
|
Java中同步是簡單的，由於全部對象都有它們與之對應的隱式管程。進入某一對象的管程，就是調用被synchronized關鍵字修飾的方法。當一個線程在一個同步方法內部，全部試圖調用該方法（或其餘同步方法）的同實例的其餘線程必須等待。爲了退出管程，並放棄對對象的控制權給其餘等待的線程，擁有管程的線程僅需從同步方法中返回。
爲理解同步的必要性，讓咱們從一個應該使用同步卻沒有用的簡單例子開始。下面的程序有三個簡單類。首先是Callme，它有一個簡單的方法call( )。call( )方法有一個名爲msg的String參數。該方法試圖在方括號內打印msg 字符串。有趣的事是在調用call( ) 打印左括號和msg字符串後，調用Thread.sleep(1000)，該方法使當前線程暫停1秒。
下一個類的構造函數Caller，引用了Callme的一個實例以及一個String，它們被分別存在target 和 msg 中。構造函數也建立了一個調用該對象的run( )方法的新線程。該線程當即啓動。 Caller類的run( )方法經過參數msg字符串調用Callme實例target的call( ) 方法。 最後，Synch類由建立Callme的一個簡單實例和Caller的三個具備不一樣消息字符串的實例開始。Callme的同一實例傳給每一個Caller實例。
// This program is not synchronized.
class Callme {
voidcall(String msg) {
System.out.print("[" + msg);
try {
Thread.sleep(1000);
}catch(InterruptedException e) {
System.out.println("Interrupted");
}
System.out.println("]");
}
}
class Caller implements Runnable {
String msg;
Callmetarget;
Thread t;
publicCaller(Callme targ, String s) {
target =targ;
msg = s;
t = newThread(this);
t.start();
}
public voidrun() {
target.call(msg);
}
}
class Synch {
publicstatic void main(String args[]) {
Callmetarget = new Callme();
Callerob1 = new Caller(target, "Hello");
Callerob2 = new Caller(target, "Synchronized");
Caller ob3= new Caller(target, "World");
// waitfor threads to end
try {
ob1.t.join();
ob2.t.join();
ob3.t.join();
} catch(InterruptedException e) {
System.out.println("Interrupted");
}
}
}
該程序的輸出以下：
Hello[Synchronized[World]
]
]
在本例中，經過調用sleep( )，call( )方法容許執行轉換到另外一個線程。該結果是三個消息字符串的混合輸出。該程序中，沒有阻止三個線程同時調用同一對象的同一方法的方法存在。這是一種競爭，由於三個線程爭着完成方法。例題用sleep( )使該影響重複和明顯。
在大多數狀況，競爭是更爲複雜和不可預知的，由於你不能肯定什麼時候上下文轉換會發生。這使程序時而運行正常時而出錯。爲達到上例所想達到的目的，必須有權連續的使用call( )。也就是說，在某一時刻，必須限制只有一個線程能夠支配它。爲此，你只需在call() 定義前加上關鍵字synchronized，以下：
class Callme {
synchronizedvoid call(String msg) {
...
這防止了在一個線程使用call( )時其餘線程進入call( )。 在synchronized加到call( )前面之後，程序輸出以下：
[Hello]
[Synchronized]
[World]
任什麼時候候在多線程狀況下，你有一個方法或多個方法操縱對象的內部狀態，都必須用synchronized關鍵字來防止狀態出現競爭。記住，一旦線程進入實例的同步方法，沒有其餘線程能夠進入相同實例的同步方法。然而，該實例的其餘不一樣步方法卻仍然能夠被調用。
|
儘管在建立的類的內部建立同步方法是得到同步的簡單和有效的方法，但它並不是在任什麼時候候都有效。這其中的緣由，請跟着思考。假設你想得到不爲多線程訪問設計的類對象的同步訪問，也就是，該類沒有用到synchronized方法。並且，該類不是你本身，而是第三方建立的，你不能得到它的源代碼。這樣，你不能在相關方法前加synchronized修飾符。怎樣才能使該類的一個對象同步化呢？很幸運，解決方法很簡單：你只需將對這個類定義的方法的調用放入一個synchronized塊內就能夠了。
下面是synchronized語句的普通形式：
synchronized(object) {
// statements tobe synchronized
}
其中，object是被同步對象的引用。若是你想要同步的只是一個語句，那麼不須要花括號。一個同步塊確保對object成員方法的調用僅在當前線程成功進入object管程後發生。
下面是前面程序的修改版本，在run( )方法內用了同步塊：
// This program uses a synchronized block.
class Callme {
voidcall(String msg) {
System.out.print("["+ msg);
try {
Thread.sleep(1000);
} catch(InterruptedException e) {
System.out.println("Interrupted");
}
System.out.println("]");
}
}
class Caller implements Runnable {
String msg;
Callmetarget;
Thread t;
publicCaller(Callme targ, String s) {
target =targ;
msg = s;
t = newThread(this);
t.start();
}
//synchronize calls to call()
public voidrun() {
synchronized(target) { // synchronized block
target.call(msg);
}
}
}
class Synch1 {
publicstatic void main(String args[]) {
Callmetarget = new Callme();
Callerob1 = new Caller(target, "Hello");
Callerob2 = new Caller(target, "Synchronized");
Callerob3 = new Caller(target, "World");
// waitfor threads to end
try {
ob1.t.join();
ob2.t.join();
ob3.t.join();
} catch(InterruptedException e) {
System.out.println("Interrupted");
}
}
}
這裏，call( )方法沒有被synchronized修飾。而synchronized是在Caller類的run( )方法中聲明的。這能夠獲得上例中一樣正確的結果，由於每一個線程運行前都等待先前的一個線程結束。
|
上述例題無條件的阻塞了其餘線程異步訪問某個方法。Java對象中隱式管程的應用是很強大的，可是你能夠經過進程間通訊達到更微妙的境界。這在Java中是尤其簡單的。
像前面所討論過的，多線程經過把任務分紅離散的和合乎邏輯的單元代替了事件循環程序。線程還有第二優勢：它遠離了輪詢。輪詢一般由重複監測條件的循環實現。一旦條件成立，就要採起適當的行動。這浪費了CPU時間。舉例來講，考慮經典的序列問題，當一個線程正在產生數據而另外一個程序正在消費它。爲使問題變得更有趣，假設數據產生器必須等待消費者完成工做才能產生新的數據。在輪詢系統，消費者在等待生產者產生數據時會浪費不少CPU週期。一旦生產者完成工做，它將啓動輪詢，浪費更多的CPU時間等待消費者的工做結束，如此下去。很明顯，這種情形不受歡迎。
爲避免輪詢，Java包含了經過wait()，notify( )和notifyAll( )方法實現的一個進程間通訊機制。這些方法在對象中是用final方法實現的，因此全部的類都含有它們。這三個方法僅在synchronized方法中才能被調用。儘管這些方法從計算機科學遠景方向上來講具備概念的高度先進性，實際中用起來是很簡單的：
· wait( ) 告知被調用的線程放棄管程進入睡眠直到其餘線程進入相同管程而且調用notify( )。
· notify( ) 恢復相同對象中第一個調用 wait( ) 的線程。
· notifyAll( ) 恢復相同對象中全部調用 wait( ) 的線程。具備最高優先級的線程最早運行。
這些方法在Object中被聲明，以下所示：
final void wait( ) throws InterruptedException
final void notify( )
final void notifyAll( )
wait( )存在的另外的形式容許你定義等待時間。
下面的例子程序錯誤的實行了一個簡單生產者/消費者的問題。它由四個類組成：Q，設法得到同步的序列；Producer，產生排隊的線程對象；Consumer，消費序列的線程對象；以及PC，建立單個Q，Producer，和Consumer的小類。
// An incorrect implementation of a producer andconsumer.
class Q {
int n;
synchronized int get() {
System.out.println("Got: " + n);
return n;
}
synchronized void put(int n) {
this.n =n;
System.out.println("Put: " + n);
}
}
class Producer implements Runnable {
Q q;
Producer(Qq) {
this.q =q;
newThread(this, "Producer").start();
}
public voidrun() {
int i =0;
while(true) {
q.put(i++);
}
}
}
class Consumer implements Runnable {
Q q;
Consumer(Qq) {
this.q =q;
newThread(this, "Consumer").start();
}
public voidrun() {
while(true) {
q.get();
}
}
}
class PC {
publicstatic void main(String args[]) {
Q q = newQ();
new Producer(q);
newConsumer(q);
System.out.println("Press Control-C to stop.");
}
}
儘管Q類中的put( )和get( )方法是同步的，沒有東西阻止生產者超越消費者，也沒有東西阻止消費者消費一樣的序列兩次。這樣，你就獲得下面的錯誤輸出（輸出將隨處理器速度和裝載的任務而改變）：
Put: 1
Got: 1
Got: 1
Got: 1
Got: 1
Got: 1
Put: 2
Put: 3
Put: 4
Put: 5
Put: 6
Put: 7
Got: 7
生產者生成1後，消費者依次得到一樣的1五次。生產者在繼續生成2到7，消費者沒有機會得到它們。
用Java正確的編寫該程序是用wait()和notify( )來對兩個方向進行標誌，以下所示：
// A correct implementation of a producer andconsumer.
class Q {
int n;
booleanvalueSet = false;
synchronized int get() {
if(!valueSet)
try {
wait();
}catch(InterruptedException e) {
System.out.println("InterruptedException caught");
}
System.out.println("Got: " + n);
valueSet = false;
notify();
returnn;
}
synchronized void put(int n) {
if(valueSet)
try {
wait();
}catch(InterruptedException e) {
System.out.println("InterruptedException caught");
}
this.n= n;
valueSet = true;
System.out.println("Put: " + n);
notify();
}
}
class Producer implements Runnable {
Q q;
Producer(Qq) {
this.q =q;
newThread(this, "Producer").start();
}
public voidrun() {
int i =0;
while(true) {
q.put(i++);
}
}
}
class Consumer implements Runnable {
Q q;
Consumer(Q q) {
this.q = q;
newThread(this, "Consumer").start();
}
public voidrun() {
while(true) {
q.get();
}
}
}
class PCFixed {
publicstatic void main(String args[]) {
Q q = newQ();
newProducer(q);
newConsumer(q);
System.out.println("Press Control-C to stop.");
}
}
內部get( ), wait( )被調用。這使執行掛起直到Producer 告知數據已經預備好。這時，內部get( ) 被恢復執行。獲取數據後，get( )調用notify( )。這告訴Producer能夠向序列中輸入更多數據。在put( )內，wait( )掛起執行直到Consumer取走了序列中的項目。當執行再繼續，下一個數據項目被放入序列，notify( )被調用，這通知Consumer它應該移走該數據。
下面是該程序的輸出，它清楚的顯示了同步行爲：
Put: 1
Got: 1
Put: 2
Got: 2
Put: 3
Got: 3
Put: 4
Got: 4
Put: 5
Got: 5
|
須要避免的與多任務處理有關的特殊錯誤類型是死鎖（deadlock）。死鎖發生在當兩個線程對一對同步對象有循環依賴關係時。例如，假定一個線程進入了對象X的管程而另外一個線程進入了對象Y的管程。若是X的線程試圖調用Y的同步方法，它將像預料的同樣被鎖定。而Y的線程一樣但願調用X的一些同步方法，線程永遠等待，由於爲到達X，必須釋放本身的Y的鎖定以使第一個線程能夠完成。死鎖是很難調試的錯誤，由於：
· 一般，它極少發生，只有到兩線程的時間段恰好符合時才能發生。
· 它可能包含多於兩個的線程和同步對象（也就是說，死鎖在比剛講述的例子有更多複雜的事件序列的時候能夠發生）。
爲充分理解死鎖，觀察它的行爲是頗有用的。下面的例子生成了兩個類，A和B，分別有foo( )和bar( )方法。這兩種方法在調用其餘類的方法前有一個短暫的停頓。主類，名爲Deadlock，建立了A和B的實例，而後啓動第二個線程去設置死鎖環境。foo( )和bar( )方法使用sleep()強迫死鎖現象發生。
// An example of deadlock.
class A {
synchronized void foo(B b) {
Stringname = Thread.currentThread().getName();
System.out.println(name + " entered A.foo");
try {
Thread.sleep(1000);
}catch(Exception e) {
System.out.println("A Interrupted");
}
System.out.println(name + " trying to call B.last()");
b.last();
}
synchronized void last() {
System.out.println("Inside A.last");
}
}
class B {
synchronized void bar(A a) {
Stringname = Thread.currentThread().getName();
System.out.println(name + " entered B.bar");
try {
Thread.sleep(1000);
}catch(Exception e) {
System.out.println("B Interrupted");
}
System.out.println(name + " trying to call A.last()");
a.last();
}
synchronized void last() {
System.out.println("Inside A.last");
}
}
class Deadlock implements Runnable {
A a = newA();
B b = newB();
Deadlock(){
Thread.currentThread().setName("MainThread");
Thread t= new Thread(this, "RacingThread");
t.start();
a.foo(b);// get lock on a in this thread.
System.out.println("Back in main thread");
}
public voidrun() {
b.bar(a);// get lock on b in other thread.
System.out.println("Back in other thread");
}
public staticvoid main(String args[]) {
newDeadlock();
}
}
運行程序後，輸出以下：
MainThread entered A.foo
RacingThread entered B.bar
MainThread trying to call B.last()
RacingThread trying to call A.last()
由於程序死鎖，你須要按CTRL-C來結束程序。在PC機上按CTRL-BREAK （或在Solaris下按CTRL-\）你能夠看到全線程和管程緩衝堆。你會看到RacingThread在等待管程a時佔用管程b，同時，MainThread佔用a等待b。該程序永遠都不會結束。像該例闡明的，你的多線程程序常常被鎖定，死鎖是你首先應檢查的問題。
|
有時，線程的掛起是頗有用的。例如，一個獨立的線程能夠用來顯示當日的時間。若是用戶不但願用時鐘，線程被掛起。在任何情形下，掛起線程是很簡單的，一旦掛起，從新啓動線程也是一件簡單的事。
掛起，終止和恢復線程機制在Java 2和早期版本中有所不一樣。儘管你運用Java 2的途徑編寫代碼，你仍需瞭解這些操做在早期Java環境下是如何完成的。例如，你也許須要更新或維護老的代碼。你也須要了解爲何Java 2會有這樣的變化。由於這些緣由，下面內容描述了執行線程控制的原始方法，接着是Java2的方法。
|
先於Java2的版本，程序用Thread定義的suspend() 和 resume() 來暫停和再啓動線程。
它們的形式以下：
final void suspend( )
final void resume( )
下面的程序描述了這些方法：
// Using suspend() and resume().
class NewThread implements Runnable {
Stringname; // name of thread
Thread t;
NewThread(String threadname) {
name =threadname;
t = newThread(this, name);
System.out.println("New thread: " + t);
t.start(); // Start the thread
}
// This isthe entry point for thread.
public voidrun() {
try {
for(inti = 15; i > 0; i--) {
System.out.println(name + ": " + i);
Thread.sleep(200);
}
} catch(InterruptedException e) {
System.out.println(name + " interrupted.");
}
System.out.println(name + " exiting.");
}
}
class SuspendResume {
publicstatic void main(String args[]) {
NewThreadob1 = new NewThread("One");
NewThreadob2 = new NewThread("Two");
try {
Thread.sleep(1000);
ob1.t.suspend();
System.out.println("Suspending thread One");
Thread.sleep(1000);
ob1.t.resume();
System.out.println("Resuming thread One");
ob2.t.suspend();
System.out.println("Suspending thread Two");
Thread.sleep(1000);
ob2.t.resume();
System.out.println("Resuming thread Two");
} catch(InterruptedException e) {
System.out.println("Main thread Interrupted");
}
// waitfor threads to finish
try {
System.out.println("Waiting for threads to finish.");
ob1.t.join();
ob2.t.join();
}catch (InterruptedException e) {
System.out.println("Main thread Interrupted");
}
System.out.println("Mainthread exiting.");
}
}
程序的部分輸出以下：
New thread: Thread[One,5,main]
One: 15
New thread: Thread[Two,5,main]
Two: 15
One: 14
Two: 14
One: 13
Two: 13
One: 12
Two: 12
One: 11
Two: 11
Suspending thread One
Two: 10
Two: 9
Two: 8
Two: 7
Two: 6
Resuming thread One
Suspending thread Two
One: 10
One: 9
One: 8
One: 7
One: 6
Resuming thread Two
Waiting for threads to finish.
Two: 5
One: 5
Two: 4
One: 4
Two: 3
One: 3
Two: 2
One: 2
Two: 1
One: 1
Two exiting.
One exiting.
Main thread exiting.
Thread類一樣定義了stop() 來終止線程。它的形式以下：
void stop( )
一旦線程被終止，它不能被resume() 恢復繼續運行。
|
Thread定義的suspend()，resume()和stop()方法看起來是管理線程的完美的和方便的方法，它們不能用於新Java版本的程序。下面是其中的緣由。Thread類的suspend()方法在Java 2中不被同意，由於suspend()有時會形成嚴重的系統故障。假定對關鍵的數據結構的一個線程被鎖定的狀況，若是該線程在那裏掛起，這些鎖定的線程並無放棄對資源的控制。其餘的等待這些資源的線程可能死鎖。
Resume()方法一樣不被贊同。它不引發問題，但不能離開suspend()方法而獨立使用。
Thread類的stop()方法一樣在Java 2中受到反對。這是由於該方法可能致使嚴重的系統故障。設想一個線程正在寫一個精密的重要的數據結構且僅完成一個零頭。若是該線程在此刻終止，則數據結構可能會停留在崩潰狀態。
由於在Java 2中不能使用suspend()，resume()和stop()方法來控制線程，你也許會想那就沒有辦法來中止，恢復和結束線程。其實否則。相反，線程必須被設計以使run()方法按期檢查以來斷定線程是否應該被掛起，恢復或終止它本身的執行。有表明性的，這由創建一個指示線程狀態的標誌變量來完成。只要該標誌設爲「running」，run()方法必須繼續讓線程執行。若是標誌設爲「suspend」，線程必須暫停。若設爲「stop」，線程必須終止。
固然，編寫這樣的代碼有不少方法，但中心主題對全部的程序應該是相同的。 下面的例題闡述了從Object繼承的wait()和notify()方法怎樣控制線程的執行。該例與前面講過的程序很像。然而，不被贊同的方法都沒有用到。讓咱們思考程序的執行。
NewTread 類包含了用來控制線程執行的布爾型的實例變量suspendFlag。它被構造函數初始化爲false。Run()方法包含一個監測suspendFlag的同步聲明的塊。若是變量是true，wait()方法被調用以掛起線程。Mysuspend()方法設置suspendFlag爲true。Myresume()方法設置suspendFlag爲false而且調用notify()方法來喚起線程。最後，main()方法被修改以調用mysuspend()和myresume()方法。
// Suspending and resuming a thread for Java2
class NewThread implements Runnable {
Stringname; // name of thread
Thread t;
booleansuspendFlag;
NewThread(String threadname) {
name =threadname;
t = newThread(this, name);
System.out.println("New thread: " + t);
suspendFlag = false;
t.start(); // Start the thread
}
// This isthe entry point for thread.
public voidrun() {
try {
for(inti = 15; i > 0; i--) {
System.out.println(name + ": " + i);
Thread.sleep(200);
synchronized(this) {
while(suspendFlag) {
wait();
}
}
}
} catch(InterruptedException e) {
System.out.println(name+ " interrupted.");
}
System.out.println(name + " exiting.");
}
voidmysuspend() {
suspendFlag = true;
}
synchronized void myresume() {
suspendFlag = false;
notify();
}
}
class SuspendResume {
publicstatic void main(String args[]) {
NewThreadob1 = new NewThread("One");
NewThreadob2 = new NewThread("Two");
try {
Thread.sleep(1000);
ob1.mysuspend();
System.out.println("Suspending thread One");
Thread.sleep(1000);
ob1.myresume();
System.out.println("Resuming thread One");
ob2.mysuspend();
System.out.println("Suspending thread Two");
Thread.sleep(1000);
ob2.myresume();
System.out.println("Resuming thread Two");
} catch(InterruptedException e) {
System.out.println("Main thread Interrupted");
}
// waitfor threads to finish
try {
System.out.println("Waiting for threads to finish.");
ob1.t.join();
ob2.t.join();
}catch (InterruptedException e) {
System.out.println("Main thread Interrupted");
}
System.out.println("Main thread exiting.");
}
}
該程序的輸出與前面的程序相同。此書的後面部分，你將看到用Java 2機制控制線程的更多例子。儘管這種機制不像老方法那樣「乾淨」，然而，它是確保運行時不發生錯誤的方法。它是全部新的代碼必須採用的方法。
|
若是你和大多數程序員同樣， 那麼在語言中加入多線程支持對你來講是很新鮮的事物。
有效運用這種支持的關鍵是併發思考而不是連續思考。例如，當你的程序有兩個能夠並行執行的子系統，建立它們各自的線程。仔細的運用多線程，你能編寫出很是有效的程序。
然而要注意：若是你建立太多的線程，你可能會減弱而不是增強程序的性能。記住，上下文轉換是須要開銷的。若是你建立了太多的線程，更多的CPU時間會用於上下文轉換而不是用來執行程序。
|
1. 思考現實生活中，咱們有沒有同時處理兩件事情的狀況？
2. 在同時處理兩件事情時，每次作一件仍是兩件事情？
|
在本章中，咱們主要學習了：
u 線程的概念；
u 線程創建的運行；
u 線程的同步及死鎖；
|
英文 全文 中文
Thread Thread 線程
Runnable Runnable 可運行接口
Deadlock Deadlock 死鎖
|
- 1. (十三)java多線程之Timer
- 2. Java多線程（十三）：線程池
- 3. (十)java多線程之CountDownLatch
- 4. Java入門教程十三(多線程)
- 5. Java JDK1.8（十三） - 多線程之線程安全詳解
- 6. 十三、Java多線程之線程池 Executor
- 7. 【java多線程】Java多線程之ThreadLocal
- 8. Java Review（三十7、多線程）
- 9. java多線程快速入門（十三）
- 10. Java多線程（三）
- 更多相關文章...
- • C# 多線程 - C#教程
- • SQLite - Java - SQLite教程
- • Java 8 Stream 教程
- • Java Agent入門實戰（三）-JVM Attach原理與使用
-
每一个你不满意的现在，都有一个你没有努力的曾经。