Java 并發編程基礎小結
一、并發編程中的一些核心思想
1. 為什么需要多線程
計算機發展初期都是以進程為維度分配內存、文件句柄以及安全證書等資源，同時多個進程之間采用一些比較粗粒度的通信機制來交換數據，包括：
- 套接字
- 信號處理器
- 共享內存
基于并發編程實戰的思想：
高效做事的人，總能在串行性和異步性之間找到一個合理的平衡點，程序也是如此。
于是操作系統就引入多進程運行的調度機制，例如：在一個單核的計算機上進程1得到CPU執行權，隨后進入IO任務阻塞掛起，此時進程2、進程3先后在此阻塞期間獲得CPU執行權執行任務:
基于上述基礎上，考慮到每一個進程都獨有各自的內存空間和文件句柄等資源，以如此龐大級別的單位處理一些單一的工作而在CPU之間進行頻繁切換開銷是非常不客觀的，于是就有了輕量級調度單位——多線程。
以多線程調度為例，假設進程1、進程2分別對應讀取定時讀取網絡數據、定時寫入數據到網絡系統日志，按照多線程維度將二者合并，最終的進程交由CPU執行，我們就可以得到這樣一個場景：
- CPU執行到線程1，讀取網絡數據，IO阻塞，讓出CPU。
- 線程2寫入之前的網絡系統日志到磁盤，進行write調用時切換到內核態，讓出CPU。
- 線程1完成數據，進程終端輸出結果，讓出CPU。
- 線程2write調用返回，繼續進行下一次的寫入......
2. 多線程有哪些優勢
如上面所說，多線程存在如下優勢：
- 輕量：以線程為單位構成進程，共享進程范圍內的資源，例如內存、文件句柄等。
- 返回多核處理器的強大能力：操作系統以更輕量級的線程為單位進行高效的調度和切換，在設計合理的情況下，可以大大提升CPU的利用率。
- 建模簡單性：利用多線程技術，可以將復雜的異步任務組合的同步工作流(例如JDK8中的CompleteFuture工具類)，并利用多線程分別執行這些任務，在指定時機進行同步交互。
- 異步事件簡化處理：有了多線程的概念之后，早期嘗試過用BIO技術即一個線程分配一個客戶端socket，好在現代Unix系統提出epoll、io_uring的良好設計，使得多線程技術有了更好的發揮。
3. 并發編程需要關注的問題
(1) 安全性問題
首先是線程安全性問題，因為多線程共享了一塊進程的數據，如果沒有充分的做好線程間的同步，就會出現一些意外的情況，就例如下面這段代碼，多線程操作一個num，因為自增操作非復合操作且多線程操作彼此不可見，出現意外結果：
private staticint num = 0;
public static void main(String[] args) throws InterruptedException {
CountDownLatch countDownLatch = new CountDownLatch(2);
new Thread(() -> {
for (int i = 0; i < 100_0000; i++) {
num++;
}
countDownLatch.countDown();
}).start();
new Thread(() -> {
for (int i = 0; i < 100_0000; i++) {
num++;
}
countDownLatch.countDown();
}).start();
countDownLatch.await();
System.out.println(num);//輸出1499633
}同樣的，如果沒有良好的同步機制，編譯器、處理器都可以針對指令進行任意順序和時間執行，同時在處理器或者寄存器緩存線程變量的情況下的修改操作，其他處理器的線程是無法看到其修改操作，也會導致邏輯運算上的錯亂：
(2) 活躍性問題
線程活躍性問題即線程未能按照預期的時許執行，導致線程持續的活躍最典型的表現就是無限循環，打滿CPU。例如并發環境下兩個CPU分別執行線程0和線程1的邏輯，即：
- 線程0執行無限循環，只要val變為true則終止無限循環，
- 線程1休眠一段時間后將val修改為true。
對于java并發編程而言，如果沒有添加保證可見性的關鍵字進行修飾，線程1的修改操作對于線程0來說是不可見的，此時就會出現下圖所示的線程1修改僅對自己可見，并不會即使刷新到CPU多核共享內存L3 Cache，進而導致線程0無限循環，也就是我們所說的活躍性問題：
對應我們也可以出示例代碼，同時筆者也會在后續的文章中來補充說明這一點的解決方案：
private staticboolean val = false;
public static void main(String[] args) {
CountDownLatch countDownLatch = new CountDownLatch(2);
new Thread(() -> {
while (!val) {//下方線程操作對于線程1不可見，進行無限循環
}
System.out.println("thread-1 executed finished");
countDownLatch.countDown();
}).start();
new Thread(() -> {
ThreadUtil.sleep(5, TimeUnit.SECONDS);
val = true;
System.out.println("設置val為true");
countDownLatch.countDown();
}).start();
try {
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}通常來說活躍性問題都是由以下幾種錯誤導致：
- 死鎖：即兩個線程互相等待對象持有的資源進入阻塞
- 活鎖：上述的活躍性問題就是最經典的活鎖
- 線程饑餓：因為線程過多或者某些原因導致某個線程長時間未能分配到CPU時間片，導致任務遲遲無法結束，這就是典型的線程饑餓問題
(3) 性能問題
這一點是老生常態了，應對并發安全的手段就是保證可見性和互斥，這涉及CPU緩存更新和臨界資源維度的把控和并發運算技巧，一般來說導致多線程性能瓶頸的幾種原因可分為：
同步機制抑制了某些編譯器的優化，例如synchronized關鍵字。
共享變量在多處理器之間不同線程執行，線程切換時處理器的緩存數據局部性失效，使得開銷大部分時間都在處理線程調度而非運算，這也會導致程序的執行性能下降。
多線程并發處理時切換線程時產生保存和恢復上下文的開銷。
二、JVM視角下的進程和線程
如下圖所示，可以看出線程是比進程更小的單位，進程是獨立的，彼此之間不會干擾，但是線程在同一個進程中共享堆區和方法區，雖然開銷較小，但是資源之間管理和分配處理相對于進程之間要更加小心。
三、多線程常見問題
1. 程序計數器、虛擬機棧、本地方法棧為什么線程中是各自獨立的
- 程序計數器私有的原因：學過計算機組成原理的小伙伴應該都知曉，程序計數器用于記錄當前下一條要執行的指令的單元地址，JVM也一樣，有了程序計數器才能保證在多線程的情況下，這個線程被掛起再被恢復時，我們可以根據程序計數器找到下一次要執行的指令的位置。
- 虛擬機棧私有的原因：每一個Java線程在執行方法時，都會創建一個棧幀用于保存局部變量、常量池引用、操作數棧等信息，在這個方法調用到完成前，它對應的信息都會基于棧幀保存在虛擬機棧上。
- 本地方法棧私有的原因：和虛擬機棧類似，只不過本地方法棧保存的native方法的信息。
所以為了保證局部變量不被別的線程訪問到，虛擬機棧和本地方法棧都是私有的，這就是我們解決某些線程安全問題時，常會用到一個叫棧封閉技術。
關于棧封閉技術如下所示，將變量放在局部，每個線程都有自己的虛擬機棧，線程安全：
public class StackConfinement implements Runnable {
//全部變量 多線操作會有現場問題
int globalVariable = 0;
public void inThread() {
//棧封閉技術，將變量放在局部，每個線程都有自己的虛擬機棧 線程安全
int neverGoOut = 0;
synchronized (this) {
for (int i = 0; i < 10000; i++) {
neverGoOut++;
}
}
System.out.println("棧內保護的數字是線程安全的：" + neverGoOut);//棧內保護的數字是線程安全的：10000
}
@Override
public void run() {
for (int i = 0; i < 10000; i++) {
globalVariable++;
}
inThread();
}
public static void main(String[] args) throws InterruptedException {
StackConfinement r1 = new StackConfinement();
Thread thread1 = new Thread(r1);
Thread thread2 = new Thread(r1);
thread1.start();
thread2.start();
thread1.join();
thread2.join();
System.out.println(r1.globalVariable); //13257
}
}2. 并發和并行的區別是什么？
- 并發：并發我們可以理解為，兩個線程先后執行，但是從宏觀角度來看，他們幾乎是并行的。
- 并行：并行我們可以理解為兩個線程同一時間都在運行。
3. 同步和異步是什么意思？
- 同步：同步就是一個調用沒有結果前，不會返回，直到有結果的才返回。
- 異步：異步即發起一個調用后，不等結果如何直接返回。
4. 為什么需要多線程，多線程解決了什么問題
從宏觀角度來看:線程可以理解為輕量級進程，切換開銷遠遠小于進程，所以在多核CPU的計算機下，使用多線程可以更好的利用計算機資源從而提高計算機利用率和效率來應對現如今的高并發網絡環境。
從微觀場景下來說: 單核場景,在單核CPU情況下，假如一個線程需要進行IO才能執行業務邏輯，若只有單線程，這就意味著IO期間發生阻塞線程卻只能干等。假如我們使用多線程的話，在當前線程IO期間，我們可以將其掛起，讓出CPU時間片讓其他線程工作。
多核場景下，假如我們有一個很復雜的任務需要進程各種IO和業務計算，假如只有一個線程的話，無論我們有多少個CPU核心，因為單線程的緣故他永遠只能利用一個CPU核心，假如我們使用多線程，那么這些線程就會映射到不同的CPU核心上，做到最好的利用計算機資源，提高執行效率，執行事件約為單線程執行事件/CPU核心數。
5. 創建線程方式有哪些
直接繼承Thread啟動運行：
public static void main(String[] args) {
new Task().start();
}
/**
* 繼承thread重寫run方法
*/
private static class Task extends Thread {
@Override
public void run() {
Console.log("{} is running", Thread.currentThread().getName());
}
}通過繼承Runable實現run方法并提交給thread運行：
public static void main(String[] args) {
new Thread(new Task()).start();
}
/**
* 繼承Runnable重寫run方法
*/
private static class Task implements Runnable {
@Override
public void run() {
Console.log("{} is running", Thread.currentThread().getName());
}
}6. 為什么需要Runnable接口實現多線程
由于Java為避免棱形問題所以只支持單繼承，當一個類已有繼承類時，某個函數需要實現異步功能的時候只能通過接口進行拓展，所以才有了Runnable接口。
7. Thread和Runnable使用的區別
- 繼承Thread：線程代碼存放在Thread子類的run方法中，調用start()即可實現調用。
- Runnable：線程代碼存在接口子類的run方法中，需要實例化一個線程對象Thread并將其作為參數傳入，才能調用到run方法。
8. Thread類中run()和start()的區別
- run：僅僅是方法，在線程實例化之后使用run等于一個普通對象的直接調用。
- start：開啟了線程并執行線程中的run方法，這期間程序才真正執行從用戶態到內核態，創建線程的動作。
9. Java線程有哪幾種狀態
- 新建(NEW)：新創建的了一個線程對象，該對象并沒有調用start()。
- 可運行(RUNNABLE)：線程對象創建后，并調用了start方法，等待分配CPU時間執行代碼邏輯。
- 阻塞(BLOCKED)：阻塞狀態，等待鎖的釋放。當線程在synchronized 中被wait，然后再被喚醒時，若synchronized 有其他線程在執行，那么它就會進入BLOCKED狀態。
- 等待(WAITING)：因為某些原因被掛起，等待其他線程通知或者喚醒。
- 超時等待(TIME_WAITING)：等待時間后自行返回，而不像WAITING那樣沒有通知就一直等待。
- 終止(TERMINATED)：該線程執行完畢，終止狀態了。
public enum State {
//線程尚未啟動
NEW,
//可運行的線程狀態，該狀態代表的是操作系統中線程狀態的ready或者running狀態
RUNNABLE,
//阻塞等待監視器(synchronized底層的monitor lock實現)或者主動調用wait后被喚醒等待獲取監視鎖也會處于該狀態
BLOCKED,
//調用wait掛起等待notify或者notifyAll
WAITING,
//設置時限的wait調用掛起，可能是調用下面某個方法
//Thread.sleep
//Object.wait with timeout
//Thread.join with timeout
//LockSupport.parkNanos
//LockSupport.parkUntil
TIMED_WAITING,
//線程已完成執行并終止
TERMINATED;
}10. 和操作系統的線程狀態的區別
如下圖所示，實際上操作系統層面可將RUNNABLE分為Running以及Ready，Java設計者之所以沒有區分那么細是因為現代計算機執行效率非常高，這兩個狀態在宏觀角度幾乎無法感知。現代操作系統對多線程采用時間分片的搶占式調度算法，使得每個線程得到CPU在10-20ms 處于運行狀態，然后在讓出CPU時間片，在不久后又會被調度執行，所以對于這種微觀狀態區別，Java設計者認為沒有必要為了這么一瞬間進行這么多的狀態劃分。
11. 什么是上下文切換
線程在執行過程中都會有自己的運行條件和狀態，這些運行條件和狀態我們就稱之為線程上下文，這些信息例如程序計數器、虛擬機棧、本地方法棧等信息。當出現以下幾種情況的時候就會從占用CPU狀態中退出:
- 線程主動讓出CPU，例如調用wait或者sleep等方法。
- 線程的CPU 時間片用完 而退出CPU占用狀態 (因為操作系統為了避免某些線程獨占CPU導致其他線程饑餓的情況就設定的例如時間分片算法)。
- 線程調用了阻塞類型的系統中斷，例如IO請求等。
- 線程被終止或者結束運行。
上述的前三種情況都會發生上下文切換。為了保證線程被切換在恢復時能夠繼續執行，所以上下文切換都需要保存線程當前執行的信息，并恢復下一個要執行線程的現場。這種操作就會占用CPU和內存資源，頻繁的進行上下文切換就會導致整體效率低下。
12. 線程死鎖問題
如下圖所示，兩個線程各自持有一把鎖，必須拿到對方手中那把鎖才能釋放自己的鎖，正是這樣一種雙方僵持的狀態就會導致線程死鎖問題。
翻譯稱代碼就如下圖所示：
public class DeadLockDemo {
publicstaticfinal Object lock1 = new Object();
publicstaticfinal Object lock2 = new Object();
public static void main(String[] args) {
new Thread(() -> {
synchronized (lock1){
System.out.println("線程1獲得鎖1，準備獲取鎖2");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (lock2){
System.out.println("線程1獲得鎖2");
}
}
}).start();
new Thread(() -> {
synchronized (lock2){
System.out.println("線程2獲得鎖2，準備獲取鎖1");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (lock1){
System.out.println("線程2獲得鎖1");
}
}
}).start();
}
}輸出結果：
線程1獲得鎖1，準備獲取鎖2
線程2獲得鎖2，準備獲取鎖1符合以下4個條件的場景就會發生死鎖問題：
- 互斥：一個資源任意時間只能被一個線程獲取。
- 請求與保持條件：一個線程拿到資源后，在獲取其他資源而進入阻塞期間，不會釋放已有資源。
- 不可剝奪條件：該資源被線程使用時，其他線程無法剝奪該線程使用權，除非這個線程主動釋放。
- 循環等待條件：若干線程獲取資源時，取鎖的流程構成一個頭尾相接的環，如上圖。
預防死鎖的幾種方式：
- 破壞請求與保持條件：以上面代碼為例，我們要求所有線程必須一次性獲得兩個鎖才能進行業務處理。即要求線程一次性獲得所有資源才能進行邏輯處理。
- 破壞不可剝奪：資源被其他線程獲取時，我們可以強行剝奪使用權。
- 破壞循環等待：這個就比較巧妙了，例如我們上面lock1 id為1，lock2id為2，我們讓每個線程取鎖時都按照lock的id順序取鎖，這樣就避免構成循環隊列。
- 操作系統思想(銀行家算法)：這個就涉及到操作系統知識了，大抵的意思是在取鎖之前對資源分配進行評估，如果在給定資源情況下不能完成業務邏輯，那么就避免這個線程取鎖，感興趣的讀者可以
13. sleep和wait方法區別
- sleep不會釋放鎖，只是單純休眠一會。而wait則會釋放鎖。
- sleep單純讓線程休眠，在給定時間后就會蘇醒，而wait若沒有設定時間的話，只能通過notify或者notifyAll喚醒。
- sleep是Thread 的方法，而wait是Object 的方法
- wait常用于線程之間的通信或者交互，而sleep單純讓線程讓出執行權。
14. 為什么sleep會定義在Thread
因為sleep要做的僅僅是讓線程休眠，所以不涉及任何鎖釋放等邏輯，放在Thread上最合適。
15. 為什么wait會定義在Object 上
我們都知道使用wait時就會釋放鎖，并讓對象進入WAITING 狀態，會涉及到資源釋放等問題，所以我們需要將wait放在Object 類上。
16. 可以直接調用 Thread 類的 run 方法嗎？
若我們編寫run方法，然后調用Thread 的start方法，線程就會從用戶態轉內核態創建線程，并在獲取CPU時間片的時候開始運行，然后運行run方法。 若直接調用run方法，那么該方法和普通方法沒有任何差別，它僅僅是一個名字為run的普通方法。
17. 假如在進程中, 已經開辟了多個線程, 其中一個線程怎么中斷其它線程?
找到線程對應線程組并基于線程id即可定位到線程，然后調用interrupt將其打斷即可：
public static Thread getThreadById(long threadId) {
//獲取線程對應線程組
ThreadGroup threadGroup = Thread.currentThread().getThreadGroup();
//比對id定位線程
if (threadGroup != null) {
Thread[] threads = new Thread[(int) (threadGroup.activeCount() * 1.2)];
//獲取線程組中獲取的線程數
int count = threadGroup.enumerate(threads, true);
for (int i = 0; i < count; i++) {
if (threads[i].getId() == threadId) {
return threads[i];
}
}
}
thrownew RuntimeException("未找到線程");
}對應的我們也給出使用示例，感興趣的讀者可自行參閱注釋了解實現細節：
//創建含有2個線程的線程池
privatestaticfinal ExecutorService threadPool = Executors.newFixedThreadPool(2);
//記錄用于打斷的線程id
privatestatic Long threadId;
public static void main(String[] args) throws InterruptedException {
CountDownLatch countDownLatch = new CountDownLatch(2);
//線程1無限休眠，直到被打斷
threadPool.execute(() -> {
Console.log("線程池線程啟動執行，線程id:{}", Thread.currentThread().getId());
threadId = Thread.currentThread().getId();
try {
TimeUnit.DAYS.sleep(1);
} catch (InterruptedException e) {
Console.error("當前線程被打斷，線程id:{}", Thread.currentThread().getId(), e);
} finally {
countDownLatch.countDown();
}
});
//線程2用于打斷線程1
threadPool.execute(() -> {
while (true) {
if (threadId != null) {
Console.log("打斷線程，線程id:{}", threadId);
getThreadById(threadId).interrupt();
countDownLatch.countDown();
break;
}
ThreadUtil.sleep(5000);
}
});
countDownLatch.await();
threadPool.shutdownNow();
}對應輸出結果如下，可以看到threadId 非空時，線程2就會將休眠的線程1打斷：
18. IO阻塞的線程會占用CPU資源嗎？如何避免線程霸占CPU?
由于該問題的篇幅比較大，筆者專門寫了一篇文章來討論這兩個問題，感興趣的朋友可以看看：《IO任務與CPU調度藝術》
