Java 多執行緒程式設計

Java給多執行緒程式設計提供了內建的支援。一個多執行緒程式包含兩個或多個能併發執行的部分。

程式的每一部分都稱作一個執行緒，並且每個執行緒定義了一個獨立的執行路徑。

多執行緒是多工的一種特別的形式。多執行緒比多工需要更小的開銷。

這裡定義和執行緒相關的另一個術語：

程序：一個程序包括由作業系統分配的記憶體空間，包含一個或多個執行緒。
一個執行緒不能獨立的存在，它必須是程序的一部分。
一個程序一直執行，直到所有的非守候執行緒都結束執行後才能結束。

多執行緒能滿足程式設計師編寫非常有效率的程式來達到充分利用CPU的目的，因為CPU的空閒時間能夠保持在最低限度。

一個執行緒的生命週期

執行緒經過其生命週期的各個階段。

新狀態: 一個新產生的執行緒從新狀態開始了它的生命週期。它保持這個狀態知道(直到)程式start這個執行緒。

執行狀態:當一個新狀態的執行緒被start以後，執行緒就變成可執行狀態，一個執行緒在此狀態下被認為是開始執行其任務

就緒狀態:當一個執行緒等待另外一個執行緒執行一個任務的時候，該執行緒就進入就緒狀態。
當另一個執行緒給就緒狀態的執行緒傳送訊號時，該執行緒才重新切換到執行狀態。

休眠狀態: 由於一個執行緒的時間片用完了，該執行緒從執行狀態進入休眠狀態。
當時間間隔到期或者等待的時間發生了，該狀態的執行緒切換到執行狀態。

終止狀態: 一個執行狀態的執行緒完成任務或者其他終止條件發生，該執行緒就切換到終止狀態。

執行緒的優先順序

每一個Java執行緒都有一個優先順序，這樣有助於作業系統確定執行緒的排程順序。
Java優先順序在MIN_PRIORITY（1）和MAX_PRIORITY（10）之間的範圍內。預設情況下，每一個執行緒都會分配一個優先順序NORM_PRIORITY（5）。

具有較高優先順序的執行緒對程式更重要，並且應該在低優先順序的執行緒之前分配處理器時間。
然而，執行緒優先順序不能保證執行緒執行的順序，而且非常依賴於平臺。

建立一個執行緒

Java提供了兩種建立執行緒方法：

通過實現Runable介面；
通過繼承Thread類本身。

通過實現Runnable介面來建立執行緒

建立一個執行緒，最簡單的方法是建立一個實現Runnable介面的類。

為了實現Runnable，一個類只需要執行一個方法呼叫run()，宣告如下：

public void run()

你可以重寫該方法，重要的是理解的run()可以呼叫其他方法，使用其他類，並宣告變數，就像主執行緒一樣。

在建立一個實現Runnable介面的類之後，你可以在類中例項化一個執行緒物件。

Thread定義了幾個構造方法，下面的這個是我們經常使用的：

Thread(Runnable threadOb,String threadName);

這裡，threadOb 是一個實現Runnable 介面的類的例項，並且 threadName指定新執行緒的名字。

新執行緒建立之後，你呼叫它的start()方法它才會執行。

void start();

下面是一個建立執行緒並開始讓它執行的例項：

// 建立一個新的執行緒

class NewThread implements Runnable{

Thread t;
NewThread(){
//建立第二個新執行緒

t = new Thread(this,"Demo Thread");
System.out.println("Child thread:" + t);
t.start(); //開始執行緒

}

// 第二個執行緒入口

public void run(){
try{

for(int i=5;i>0;i--){
System.out.println("Child Thread:" + i);
//暫停執行緒
Thread.sleep(50);
}

}catch(InterruptedException e){
System.out.println("Child interrupted");
}

System.out.println("Exiting child thread");
}
}

public class ThreadDemo{

public static void main(String args[]){
new NewThread(); //建立一個新執行緒

try{
for(int i = 5;i>0;i--){
System.out.println("Main Thread:" + i);
Thread.sleep(100);
}
}catch(InterruptedException e){
System.out.println("Main thread interrupted");
}
System.out.println("Main thread exiting.");
}

}

編譯以上程式執行結果如下：

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.

通過繼承Thread來建立執行緒

建立一個執行緒的第二種方法是建立一個新的類，該類繼承Thread類，然後建立一個該類的例項。

繼承類必須重寫run()方法，該方法是新執行緒的入口點。它也必須呼叫start()方法才能執行。

// 通過繼承 Thread 建立執行緒
class NewThread extends Thread {
NewThread() {
// 建立第二個新執行緒
super("Demo Thread");
System.out.println("Child thread: " + this);
start(); // 開始執行緒
}

// 第二個執行緒入口
public void run() {
try {
for(int i = 5; i > 0; i--) {
System.out.println("Child Thread: " + i);
// 讓執行緒休眠一會
Thread.sleep(50);
}
} catch (InterruptedException e) {
System.out.println("Child interrupted.");
}
System.out.println("Exiting child thread.");
}
}

public class ExtendThread {
public static void main(String args[]) {
new NewThread(); // 建立一個新執行緒
try {
for(int i = 5; i > 0; i--) {
System.out.println("Main Thread: " + i);
Thread.sleep(100);
}
} catch (InterruptedException e) {
System.out.println("Main thread interrupted.");
}
System.out.println("Main thread exiting.");
}
}

Thread 方法

Thread類的一些重要方法：

public void start()
使該執行緒開始執行；Java 虛擬機器呼叫該執行緒的 run 方法。

public void run()
如果該執行緒是使用獨立的 Runnable 執行物件構造的，則呼叫該 Runnable 物件的 run 方法；否則，該方法不執行任何操作並返回。

public final void setName(String name)
改變執行緒名稱，使之與引數 name 相同。

public final void setPriority(int priority)
更改執行緒的優先順序。

public final void setDaemon(boolean on)
將該執行緒標記為守護執行緒或使用者執行緒。

public final void join(long millisec)
等待該執行緒終止的時間最長為 millis 毫秒。

public void interrupt()
中斷執行緒。

public final boolean isAlive()
測試執行緒是否處於活動狀態。

測試執行緒是否處於活動狀態。 上述方法是被Thread物件呼叫的。下面的方法是Thread類的靜態方法。

public static void yield()
暫停當前正在執行的執行緒物件，並執行其他執行緒。

public static void sleep(long millisec)
在指定的毫秒數內讓當前正在執行的執行緒休眠（暫停執行），此操作受到系統計時器和排程程式精度和準確性的影響。

public static boolean holdsLock(Object x)
當且僅當當前執行緒在指定的物件上保持監視器鎖時，才返回 true。

public static Thread currentThread()
返回對當前正在執行的執行緒物件的引用。

public static void dumpStack()
將當前執行緒的堆疊跟蹤列印至標準錯誤流。

例項
如下的ThreadClassDemo 程式演示了Thread類的一些方法：

// 檔名 : DisplayMessage.java
// 通過實現 Runnable 介面建立執行緒
public class DisplayMessage implements Runnable
{
private String message;
public DisplayMessage(String message)
{
this.message = message;
}
public void run()
{
while(true)
{
System.out.println(message);
}
}
}

// 檔名 : GuessANumber.java
// 通過繼承 Thread 類建立執行緒

public class GuessANumber extends Thread
{
private int number;
public GuessANumber(int number)
{
this.number = number;
}
public void run()
{
int counter = 0;
int guess = 0;
do
{
guess = (int) (Math.random() * 100 + 1);
System.out.println(this.getName()
+ " guesses " + guess);
counter++;
}while(guess != number);
System.out.println("** Correct! " + this.getName()
+ " in " + counter + " guesses.**");
}
}

// 檔名 : ThreadClassDemo.java
public class ThreadClassDemo
{
public static void main(String [] args)
{
Runnable hello = new DisplayMessage("Hello");
Thread thread1 = new Thread(hello);
thread1.setDaemon(true);
thread1.setName("hello");
System.out.println("Starting hello thread...");
thread1.start();

Runnable bye = new DisplayMessage("Goodbye");
Thread thread2 = new Thread(hello);
thread2.setPriority(Thread.MIN_PRIORITY);
thread2.setDaemon(true);
System.out.println("Starting goodbye thread...");
thread2.start();

System.out.println("Starting thread3...");
Thread thread3 = new GuessANumber(27);
thread3.start();
try
{
thread3.join();
}catch(InterruptedException e)
{
System.out.println("Thread interrupted.");
}
System.out.println("Starting thread4...");
Thread thread4 = new GuessANumber(75);

thread4.start();
System.out.println("main() is ending...");
}
}

執行結果如下，每一次執行的結果都不一樣。

Starting hello thread...
Starting goodbye thread...
Hello
Hello
Hello
Hello
Hello
Hello
Hello
Hello
Hello
Thread-2 guesses 27
Hello
** Correct! Thread-2 in 102 guesses.**
Hello
Starting thread4...
Hello
Hello
..........remaining result produced.

執行緒的幾個主要概念:

在多執行緒程式設計時，你需要了解以下幾個概念：

執行緒同步
執行緒間通訊
執行緒死鎖
執行緒控制：掛起、停止和恢復

多執行緒的使用

有效利用多執行緒的關鍵是理解程式是併發執行而不是序列執行的。例如：程式中有兩個子系統需要併發執行，這時候就需要利用多執行緒程式設計。

通過對多執行緒的使用，可以編寫出非常高效的程式。不過請注意，如果你建立太多的執行緒，程式執行的效率實際上是降低了，而不是提升了。

請記住，上下文的切換開銷也很重要，如果你建立了太多的執行緒，CPU花費在上下文的切換的時間將多於執行程式的時間！