Java多執行緒詳解總結
阿新 • • 發佈：2020-07-16
### 一、基本概念
**程式(program)**: 是為完成特定任務、用某種語言編寫的一組指令的集合。即指一 段靜態的程式碼，靜態物件。
**程序(process)**:是程式的一次執行過程，或是正在執行的一個程式。是一個動態 的過程：有它自身的產生、存在和消亡的過程。——生命週期
- 執行中的QQ，執行中的MP3播放器
- 程式是靜態的，程序是動態的
- 程序作為資源分配的單位，系統在執行時會為每個程序分配不同的記憶體區域
**執行緒(thread):**程序可進一步細化為執行緒，是一個程式內部的一條執行路徑。
- 若一個程序同一時間並行執行多個執行緒，就是支援多執行緒的
- 執行緒作為排程和執行的單位，每個執行緒擁有獨立的執行棧和程式計數器(pc)，執行緒切換的開 銷小
- 一個程序中的多個執行緒共享相同的記憶體單元/記憶體地址空間->它們從同一堆中分配物件，可以 訪問相同的變數和物件。這就使得執行緒間通訊更簡便、高效。但多個執行緒操作共享的系統資 源可能就會帶來安全的隱患。
#### 1. 單核CPU和多核CPU的理解
- 單核CPU，其實是一種假的多執行緒，因為在一個時間單元內，也只能執行一個執行緒 的任務。例如：雖然有多車道，但是收費站只有一個工作人員在收費，只有收了費 才能通過，那麼CPU就好比收費人員。如果有某個人不想交錢，那麼收費人員可以 把他“掛起”（晾著他，等他想通了，準備好了錢，再去收費）。但是因為CPU時 間單元特別短，因此感覺不出來。
- 如果是多核的話，才能更好的發揮多執行緒的效率。（現在的伺服器都是多核的）
- 一個Java應用程式java.exe，其實至少有三個執行緒：**main()主執行緒，gc() 垃圾回收執行緒，異常處理執行緒。**當然如果發生異常，會影響主執行緒。
#### 2. 並行與併發
並行：多個CPU同時執行多個任務。比如：多個人同時做不同的事
併發：一個CPU(採用時間片)同時執行多個任務。比如：秒殺、多個人做同一件事
#### 3. 使用多執行緒的優點
- 提高應用程式的響應。對圖形化介面更有意義，可增強使用者體驗。
- 提高計算機系統CPU的利用率
- 改善程式結構。將既長又複雜的程序分為多個執行緒，獨立執行，利於理解和 修改
#### 4. 何時需要多執行緒
- 程式需要同時執行兩個或多個任務
- 程式需要實現一些需要等待的任務時，如使用者輸入、檔案讀寫
操作、網路操作、搜尋等
- 需要一些後臺執行的程式時
### 二、多執行緒的實現
在Java之中，如果要想實現多執行緒的程式，那麼就必須依靠一個執行緒的主體類（就好比主類的概念一樣，表示的是一個執行緒的主類），但是這個執行緒的主體類在定義的時候也需要有一些特殊的要求，這個類可以**繼承Thread類**或**實現Runnable介面**來完成定義。
#### 1. 繼承Thread類
- 定義子類繼承Thread類
- **子類中重寫Thread類中的run方法**
- 建立Thread子類物件，即建立了執行緒物件
- **呼叫執行緒物件start方法：1啟動執行緒，2呼叫run方法**
**要想啟動執行緒必須依靠Thread類的start()方法執行，執行緒啟動之後會預設呼叫了run()方法**、
```java
package com.atguigu.java;
/**
* @author MD
* @create 2020-07-10 16:58
*/
// 1.
class Mythread extends Thread{
// 2.
@Override
public void run() {
for (int i = 0; i < 50 ; i++) {
if (i % 2 == 0){
System.out.println(Thread.currentThread().getName() + ":"+i);
}
}
}
}
public class ThreadTest {
public static void main(String[] args) {
// 3.
Mythread mythread = new Mythread();
//4.
mythread.start();
// 這個仍然是在main執行緒中執行
for (int i = 0; i < 50 ; i++) {
if (i % 2 != 0){
System.out.println(Thread.currentThread().getName() + ":"+i);
}
}
}
}
/*
注意：
1. 如果自己手動呼叫run()方法，那麼就只是普通方法，沒有啟動多執行緒模式。
2. run()方法由JVM呼叫，什麼時候呼叫，執行的過程控制都有作業系統的CPU排程決定。
3. 想要啟動多執行緒，必須呼叫start方法。
4. 一個執行緒物件只能呼叫一次start()方法啟動，如果重複呼叫了，則將丟擲以上 的異常“IllegalThreadStateException”
*/
// 也可以使用匿名內部類簡單的寫
new Thread(){
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0)
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}.start();
```
#### 2. Thread類的有關方法
- void start(): 啟動執行緒，並執行物件的run()方法
- run(): 執行緒在被排程時執行的操作
- String getName(): 返回執行緒的名稱
- void setName(String name):設定該執行緒名稱
- static Thread currentThread(): 返回當前執行緒。在Thread子類中就 是this，通常用於主執行緒和Runnable實現類
- static void yield()：執行緒讓步
- 暫停當前正在執行的執行緒，把執行機會讓給優先順序相同或更高的執行緒
- 若佇列中沒有同優先順序的執行緒，忽略此方法
- join() ：當某個程式執行流中呼叫其他執行緒的 join() 方法時，呼叫執行緒將 被阻塞，直到 join() 方法加入的 join 執行緒執行完為止
- 低優先順序的執行緒也可以獲得執行
- static void sleep(long millis)：(指定時間:毫秒)
- 令當前活動執行緒在指定時間段內放棄對CPU控制,使其他執行緒有機會被執行,時間到後 重排隊。
- 丟擲InterruptedException異常
```java
/**
* 測試Thread中常用的方法
* 1. start():啟動當前程序，並且呼叫當前程序的run()方法
* 2. run()：通常需要重寫Thread類中的此方法，將建立的執行緒要執行的操作宣告在這個方法中
* 3. currentThread(): 靜態方法，返回當前程式碼的執行緒
* 4. getName():獲取當前執行緒的名字
* 5. setName()： 設定當前執行緒的名字
* 6. yield(): 釋放當前cpu的執行權
* 7. join(): 線上程A中呼叫執行緒B的join()，此時執行緒A就進入到了阻塞的狀態，直到執行緒B執行完成，執行緒A才結束阻塞狀態
* 8. sleep(): 讓當前的執行緒睡眠指定的時間
*
* @author MD
* @create 2020-07-10 20:34
*/
class Method extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0)
System.out.println(Thread.currentThread().getName() + ":" + i);
if (i % 4 == 0)
yield();
}
}
}
public class ThreadMethodTest {
public static void main(String[] args) {
Method method = new Method();
method.setName("執行緒一：");
method.start();
// 給主執行緒命名
Thread.currentThread().setName("主執行緒：");
for (int i = 0; i < 100; i++) {
if (i % 2 == 0)
System.out.println(Thread.currentThread().getName() + ":" + i);
if (i == 10) {
try {
method.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
```
#### 3. 執行緒的優先順序
**執行緒的優先順序等級**
- MAX_PRIORITY：10
- MIN _PRIORITY：1
- NORM_PRIORITY：5 預設的 main()
**方法：**
- getPriority() ：返回執行緒優先值
- setPriority(int newPriority) ：改變執行緒的優先順序
注意：
- 執行緒建立時繼承父執行緒的優先順序
- 低優先順序只是獲得排程的概率低，並非一定是在高優先順序執行緒之後才被呼叫
```java
mythread.setPriority(Thread.MAX_PRIORITY);
mythread.start();
// 設定主執行緒的優先順序，最低
Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
```
#### 4. 實現Runnable介面
- **定義子類，實現Runnable介面。**
- **子類中重寫Runnable介面中的run方法。**
- **通過Thread類含參構造器建立執行緒物件。**
- **將Runnable介面的子類物件作為實際引數傳遞給Thread類的構造器中。**
- **呼叫Thread類的start方法：開啟執行緒，呼叫Runnable子類介面的run方法**
```java
package com.atguigu.java;
/**
* @author MD
* @create 2020-07-10 21:53
*/
// 1. 定義子類，實現Runnable介面。
class Mthread implements Runnable{
// 2. 子類中重寫Runnable介面中的run方法。
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0)
System.out.println(Thread.currentThread().getName() +":"+i);
}
}
}
public class ThreadTest1 {
public static void main(String[] args) {
// 3. 通過Thread類含參構造器建立執行緒物件。
Mthread mthread = new Mthread();
// 4. 將Runnable介面的子類物件作為實際引數傳遞給Thread類的構造器中。
Thread t1 = new Thread(mthread);
//5. 呼叫Thread類的start方法：開啟執行緒，呼叫Runnable子類介面的run方法
t1.start();
// 再啟動一個執行緒
Thread t2 = new Thread(mthread);
t2.start();
}
}
```
#### 5. 比較建立執行緒的兩種方式
- 多執行緒的兩種實現方式都需要一個執行緒的主類，而這個類可以實現Runnable介面或繼承Thread類，不管使用何種方式都必須在子類之中覆寫run()方法，此方法為執行緒的主方法；
- Thread類是Runnable介面的子類，而且使用Runnable介面可以避免單繼承侷限，以及更加方便的實現**資料共享的概念** ,開發中常用
```java
class MyThread implements Runnable {
@Override
public void run() { // 執行緒的主方法
// 執行緒操作方法
}
}
MyThread mt = new MyThread();
new Thread(mt).start();
//
class MyThread extends Thread {
@Override
public void run() { // 執行緒的主方法
// 執行緒操作方法
}
}
MyThread mt = new MyThread();
mt.start();
```
### 三、執行緒的生命週期
要想實現多執行緒，必須在主執行緒中建立新的執行緒物件。Java語言使用Thread類 及其子類的物件來表示執行緒，在它的一個完整的生命週期中通常要經歷如下的五 種狀態：
- **新建**： 當一個Thread類或其子類的物件被宣告並建立時，新生的執行緒物件處於新建 狀態
- **就緒**：處於新建狀態的執行緒被start()後，將進入執行緒佇列等待CPU時間片，此時它已 具備了執行的條件，只是沒分配到CPU資源
- **執行**：當就緒的執行緒被排程並獲得CPU資源時,便進入執行狀態， run()方法定義了線 程的操作和功能
- **阻塞**：在某種特殊情況下，被人為掛起或執行輸入輸出操作時，讓出 CPU 並臨時中 止自己的執行，進入阻塞狀態
- **死亡**：執行緒完成了它的全部工作或執行緒被提前強制性地中止或出現異常導致結束
### 四、執行緒的同步與死鎖
多個執行緒執行的不確定性引起執行結果的不穩定
多個執行緒對賬本的共享，會造成操作的不完整性，會破壞資料
#### 1. 同步問題
模擬火車站售票程式，開啟三個視窗售票
```java
package com.atguigu.java;
/**
* @author MD
* @create 2020-07-11 9:25
*/
class Window implements Runnable{
private int ticket = 100;
@Override
public void run() {
while (true){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (ticket >