日期：2020-12-04 10:33作者：北大青鳥西安建大IT學院
Java給多線程編程提供了內置的支持。一個多線程程序包含兩個或多個能并發運行的部分。程序的每一部分都稱作一個線程，并且每個線程定義了一個獨立的執行路徑。
多線程是多任務的一種特別的形式。多線程比多任務需要更小的開銷。
這里定義和線程相關的另一個術語：進程：一個進程包括由操作系統分配的內存空間，包含一個或多個線程。一個線程不能獨立的存在，它必須是進程的一部分。一個進程一直運行，直到所有的非守候線程都結束運行后才能結束。
多線程能滿足程序員編寫非常有效率的程序來達到充分利用CPU的目的，因為CPU的空閑時間能夠保持在最低限度。
線程經過其生命周期的各個階段。下圖顯示了一個線程完整的生命周期。
新建狀態: 一個新產生的線程從新狀態開始了它的生命周期。它保持這個狀態直到程序start這個線程。
運行狀態:當一個新狀態的線程被start以后，線程就變成可運行狀態，一個線程在此狀態下被認為是開始執行其任務
就緒狀態:當一個線程等待另外一個線程執行一個任務的時候，該線程就進入就緒狀態。當另一個線程給就緒狀態的線程發送信號時，該線程才重新切換到運行狀態。
休眠狀態: 由于一個線程的時間片用完了，該線程從運行狀態進入休眠狀態。當時間間隔到期或者等待的事件發生了，該狀態的線程切換到運行狀態。
終止狀態: 一個運行狀態的線程完成任務或者其他終止條件發生，該線程就切換到終止狀態。
每一個Java線程都有一個優先級，這樣有助于操作系統確定線程的調度順序。Java優先級在MIN_PRIORITY（1）和MAX_PRIORITY（10）之間的范圍內。默認情況下，每一個線程都會分配一個優先級NORM_PRIORITY（5）。
具有較高優先級的線程對程序更重要，并且應該在低優先級的線程之前分配處理器時間。然而，線程優先級不能保證線程執行的順序，而且非常依賴于平臺。
Java提供了三種創建線程方法：
通過實現Runnable接口；
通過繼承Thread類本身；
通過 Callable 和 Future 創建線程。
創建一個線程，最簡單的方法是創建一個實現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類，然后創建一個該類的實例。
繼承類必須重寫run()方法，該方法是新線程的入口點。它也必須調用start()方法才能執行。該方法盡管被列為一種多線程實現方式，但是本質上也是實現了 Runnable 接口的一個實例。
// 通過繼承 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.");
}
}
編譯以上程序運行結果如下：
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類的一些重要方法：
| 序號 | 方法描述 |
|---|---|
| 1 |
public void start() 使該線程開始執行；Java 虛擬機調用該線程的 run 方法。 |
| 2 |
public void run() 如果該線程是使用獨立的 Runnable 運行對象構造的，則調用該 Runnable 對象的 run 方法；否則，該方法不執行任何操作并返回。 |
| 3 |
public final void setName(String name) 改變線程名稱，使之與參數 name 相同。 |
| 4 |
public final void setPriority(int priority) 更改線程的優先級。 |
| 5 |
public final void setDaemon(boolean on) 將該線程標記為守護線程或用戶線程。 |
| 6 |
public final void join(long millisec) 等待該線程終止的時間最長為 millis 毫秒。 |
| 7 |
public void interrupt() 中斷線程。 |
| 8 |
public final boolean isAlive() 測試線程是否處于活動狀態。 |
測試線程是否處于活動狀態。 上述方法是被Thread對象調用的。下面的方法是Thread類的靜態方法。
| 序號 | 方法描述 |
|---|---|
| 1 |
public static void yield() 暫停當前正在執行的線程對象，并執行其他線程。 |
| 2 |
public static void sleep(long millisec) 在指定的毫秒數內讓當前正在執行的線程休眠（暫停執行），此操作受到系統計時器和調度程序精度和準確性的影響。 |
| 3 |
public static boolean holdsLock(Object x) 當且僅當當前線程在指定的對象上保持監視器鎖時，才返回 true。 |
| 4 |
public static Thread currentThread() 返回對當前正在執行的線程對象的引用。 |
| 5 |
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 文件代碼：
// 文件名 : 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 文件代碼：
// 文件名 : 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(bye);
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
Starting thread3...
Hello
Hello
Starting thread4...
Hello
Hello
main() is ending...
實例
public class CallableThreadTest implements Callable<Integer> {
public static void main(String[] args)
{
CallableThreadTest ctt = new CallableThreadTest();
FutureTask<Integer> ft = new FutureTask<>(ctt);
for(int i = 0;i < 100;i++)
{
System.out.println(Thread.currentThread().getName()+" 的循環變量i的值"+i);
if(i==20)
{
new Thread(ft,"有返回值的線程").start();
}
}
try
{
System.out.println("子線程的返回值："+ft.get());
} catch (InterruptedException e)
{
e.printStackTrace();
} catch (ExecutionException e)
{
e.printStackTrace();
}
}
@Override
public Integer call() throws Exception
{
int i = 0;
for(;i<100;i++)
{
System.out.println(Thread.currentThread().getName()+" "+i);
}
return i;
}
}
在多線程編程時，你需要了解以下幾個概念：
線程同步
線程間通信
線程死鎖
線程控制：掛起、停止和恢復
有效利用多線程的關鍵是理解程序是并發執行而不是串行執行的。例如：程序中有兩個子系統需要并發執行，這時候就需要利用多線程編程。
通過對多線程的使用，可以編寫出非常高效的程序。不過請注意，如果你創建太多的線程，程序執行的效率實際上是降低了，而不是提升了。
請記住，上下文的切換開銷也很重要，如果你創建了太多的線程，CPU花費在上下文的切換的時間將多于執行程序的時間！