ColorfulC ·Java 多線程
本小節我們將學習 Java 多線程，通過本小節的學習，你將了解到什么是線程，如何創建線程，創建線程有哪幾種方式，線程的狀態、生命周期等內容。掌握多線程的代碼編寫，并理解線程生命周期等內容是本小節學習的重點。
1. 什么是線程
要了解什么是線程，就要先了解進程的概念。
進程，是指計算機中已運行的程序，它是一個動態執行的過程。假設我們電腦上同時運行了瀏覽器、QQ 以及代碼編輯器三個軟件，這三個軟件之所以同時運行，就是進程所起的作用。
線程是操作系統能夠進行運算調度的最小單位。大部分情況下，它被包含在進程之中，是進程中的實際運作單位。也就是說一個進程可以包含多個線程， 因此線程也被稱為輕量級進程。
如果你還是對于進程和線程的概念有所困惑，推薦一篇比較優秀的文章，有助于幫助你理解進程和線程的概念。
2. 創建線程
在 Java 中，創建線程有以下 3 種方式：
- 繼承
Thread類，重寫run()方法，該方法代表線程要執行的任務； - 實現
Runnable接口，實現run()方法，該方法代表線程要執行的任務； - 實現
Callable接口，實現call()方法，call()方法作為線程的執行體，具有返回值，并且可以對異常進行聲明和拋出。
下面我們分別來看下這 3 種方法的具體實現。
2.1 Thread 類
Thread 類是一個線程類，位于 java.lang 包下。
2.1.1 構造方法
Thread 類的常用構造方法如下：
Thread()：創建一個線程對象；Thread(String name)：創建一個指定名稱的線程對象；Thread(Runnable target)：創建一個基于Runnable接口實現類的線程對象；Thread(Runnable target, String name)：創建一個基于Runnable接口實現類，并具有指定名稱的線程對象。
2.1.2 常用方法
void run()：線程相關的代碼寫在該方法中，一般需要重寫；
void start()：啟動當前線程；
static void sleep(long m)：使當前線程休眠 m 毫秒；
void join()：優先執行調用 join() 方法的線程。
Tips：
run()方法是一個非常重要的方法，它是用于編寫線程執行體的方法，不同線程之間的一個最主要區別就是run()方法中的代碼是不同的。
可翻閱官方文檔以查看更多 API。
2.1.3 實例
通過繼承 Thread 類創建線程可分為以下 3 步：
- 定義
Thread類的子類，并重寫該類的run()方法。run()方法的方法體就代表了線程要完成的任務； - 創建
Thread子類的實例，即創建線程對象； - 調用線程對象的
start方法來啟動該線程。
具體實例如下：
/**
* @author colorful@TaleLin
*/
public class ThreadDemo1 extends Thread {
/**
* 重寫 Thread() 的方法
*/
@Override
public void run() {
System.out.println("這里是線程體");
// 當前打印線程的名稱
System.out.println(getName());
}
public static void main(String[] args) {
// 實例化 ThreadDemo1 對象
ThreadDemo1 threadDemo1 = new ThreadDemo1();
// 調用 start() 方法，以啟動線程
threadDemo1.start();
}
}
運行結果：
這里是線程體
Thread-0
小伙伴們可能會有疑問，上面這樣的代碼，和普通的類實例化以及方法調用有什么區別的，下面我們來看一個稍微復雜些的實例：
/**
* @author colorful@TaleLin
*/
public class ThreadDemo2 {
/**
* 靜態內部類
*/
static class MyThread extends Thread {
private int i = 3;
MyThread(String name) {
super(name);
}
@Override
public void run() {
while (i > 0) {
System.out.println(getName() + " i = " + i);
i--;
}
}
}
public static void main(String[] args) {
// 創建兩個線程對象
MyThread thread1 = new MyThread("線程1");
MyThread thread2 = new MyThread("線程2");
// 啟動線程
thread1.start();
thread2.start();
}
}
運行結果：
線程2 i = 3
線程1 i = 3
線程1 i = 2
線程2 i = 2
線程1 i = 1
線程2 i = 1
代碼中我們是先啟動了線程 1，再啟動了線程 2 的，觀察運行結果，線程并不是按照我們所預想的順序執行的。這里就要劃重點了，不同線程，執行順序是隨機的。如果你再執行幾次代碼，可以觀察到每次的運行結果都可能不同：
2.2 Runnable 接口
2.2.1 為什么需要 Runnable 接口
通過實現 Runnable 接口的方案來創建線程，要優于繼承 Thread 類的方案，主要有以下原因：
- Java 不支持多繼承，所有的類都只允許繼承一個父類，但可以實現多個接口。如果繼承了
Thread類就無法繼承其它類，這不利于擴展； - 繼承
Thread類通常只重寫run()方法，其他方法一般不會重寫。繼承整個Thread類成本過高，開銷過大。
2.2.2 實例
通過實現 Runnable 接口創建線程的步驟如下：
- 定義
Runnable接口的實現類，并實現該接口的run()方法。這個run()方法的方法體同樣是該線程的線程執行體； - 創建
Runnable實現類的實例，并以此實例作為Thread的target來創建Thread對象，該Thread對象才是真正的線程對象； - 調用線程對象的
start方法來啟動該線程。
具體實例如下：
/**
* @author colorful@TaleLin
*/
public class RunnableDemo1 implements Runnable {
private int i = 5;
@Override
public void run() {
while (i > 0) {
System.out.println(Thread.currentThread().getName() + " i = " + i);
i--;
}
}
public static void main(String[] args) {
// 創建兩個實現 Runnable 實現類的實例
RunnableDemo1 runnableDemo1 = new RunnableDemo1();
RunnableDemo1 runnableDemo2 = new RunnableDemo1();
// 創建兩個線程對象
Thread thread1 = new Thread(runnableDemo1, "線程1");
Thread thread2 = new Thread(runnableDemo2, "線程2");
// 啟動線程
thread1.start();
thread2.start();
}
}
運行結果：
線程1 i = 5
線程1 i = 4
線程1 i = 3
線程1 i = 2
線程2 i = 5
線程1 i = 1
線程2 i = 4
線程2 i = 3
線程2 i = 2
線程2 i = 1
2.3 Callable 接口
2.3.1 為什么需要 Callable 接口
繼承 Thread 類和實現 Runnable 接口這兩種創建線程的方式都沒有返回值。所以，線程執行完畢后，無法得到執行結果。為了解決這個問題，Java 5 后，提供了 Callable 接口和 Future 接口，通過它們，可以在線程執行結束后，返回執行結果。
2.3.2 實例
通過實現 Callable 接口創建線程步驟如下：
- 創建
Callable接口的實現類，并實現call()方法。這個call()方法將作為線程執行體，并且有返回值； - 創建
Callable實現類的實例，使用FutureTask類來包裝Callable對象，這個FutureTask對象封裝了該Callable對象的call()方法的返回值； - 使用
FutureTask對象作為Thread對象的 target 創建并啟動新線程； - 調用
FutureTask對象的get()方法來獲得線程執行結束后的返回值。
具體實例如下：
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
* @author colorful@TaleLin
*/
public class CallableDemo1 {
static class MyThread implements Callable<String> {
@Override
public String call() { // 方法返回值類型是一個泛型，在上面 Callable<String> 處定義
return "我是線程中返回的字符串";
}
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
// 常見實現類的實例
Callable<String> callable = new MyThread();
// 使用 FutureTask 類來包裝 Callable 對象
FutureTask<String> futureTask = new FutureTask<>(callable);
// 創建 Thread 對象
Thread thread = new Thread(futureTask);
// 啟動線程
thread.start();
// 調用 FutureTask 對象的 get() 方法來獲得線程執行結束后的返回值
String s = futureTask.get();
System.out.println(s);
}
}
運行結果：
我是線程中返回的字符串
3. 線程休眠
在前面介紹 Thread 類的常用方法時，我們介紹了 sleep() 靜態方法，該方法可以使當前執行的線程睡眠（暫時停止執行）指定的毫秒數。
線程休眠的實例如下：
/**
* @author colorful@TaleLin
*/
public class SleepDemo implements Runnable {
@Override
public void run() {
for (int i = 1; i <= 5; i ++) {
// 打印語句
System.out.println(Thread.currentThread().getName() + ":執行第" + i + "次");
try {
// 使當前線程休眠
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
// 實例化 Runnable 的實現類
SleepDemo sleepDemo = new SleepDemo();
// 實例化線程對象
Thread thread = new Thread(sleepDemo);
// 啟動線程
thread.start();
}
}
運行結果：
Thread-0:執行第1次
Thread-0:執行第2次
Thread-0:執行第3次
Thread-0:執行第4次
Thread-0:執行第5次
4. 線程的狀態和生命周期
java.lang.Thread.Starte 枚舉類中定義了 6 種不同的線程狀態：
NEW：新建狀態，尚未啟動的線程處于此狀態；RUNNABLE：可運行狀態，Java 虛擬機中執行的線程處于此狀態；BLOCK：阻塞狀態，等待監視器鎖定而被阻塞的線程處于此狀態；WAITING：等待狀態，無限期等待另一線程執行特定操作的線程處于此狀態；TIME_WAITING：定時等待狀態，在指定等待時間內等待另一線程執行操作的線程處于此狀態；TERMINATED：結束狀態，已退出的線程處于此狀態。
值得注意的是，一個線程在給定的時間點只能處于一種狀態。這些狀態是不反映任何操作系統線程狀態的虛擬機狀態。
線程的生命周期，實際上就是上述 6 個線程狀態的轉換過程。下圖展示了一個完整的生命周期：
5. 小結
通過本小節的學習，我們知道了線程是操作系統能夠進行運算調度的最小單位。線程也被稱為輕量級進程。在 Java 中，可以以 3 種方式創建線程，分別是繼承 Thread 類、實現 Runnable 接口以及實現 Callable 接口?？梢允褂渺o態方法 sleep() 讓線程休眠。線程狀態有 6 種，也有資料上說線程有 5 種，這部分內容我們按照 Java 源碼中的定義 6 種來記憶即可。
2025 imooc.com All Rights Reserved |