Java并發(fā)工具包（JUC），全稱Java Util Concurrent，是Java提供的一個用于構(gòu)建多線程應(yīng)用程序的工具包，位于java.util.concurrent包及其子包中。

并發(fā)編程主要解決以下三個經(jīng)典問題：

1. **原子性問題（Atomicity）**:
? ?- 原子性指的是一個操作或者一組操作要么全部執(zhí)行，要么全部不執(zhí)行，不會出現(xiàn)中間狀態(tài)。在并發(fā)環(huán)境下，由于多個線程可能會同時訪問和修改共享數(shù)據(jù)，因此需要確保對共享數(shù)據(jù)的操作是原子性的，避免數(shù)據(jù)不一致的問題。

2. **可見性問題（Visibility）**:
? ?- 可見性是指當多個線程訪問同一個變量時，一個線程對變量的修改對其他線程是可見的。在沒有適當同步的情況下，線程可能會看到變量的舊值，而不是最新值。Java內(nèi)存模型（JMM）定義了內(nèi)存的可見性規(guī)則，需要通過適當?shù)耐綑C制（如 `volatile` 關(guān)鍵字、synchronized）來解決可見性問題。

3. **有序性問題（Ordering）**:
? ?- 有序性問題指的是在并發(fā)環(huán)境中，由于編譯器優(yōu)化、處理器亂序執(zhí)行等原因，代碼的執(zhí)行順序可能會與編寫順序不同，導致不可預期的行為。為了確保程序的正確性，需要使用內(nèi)存屏障（如 `volatile` 變量的讀寫）、synchronized 塊或鎖等機制來保證操作的順序性。

volatile: 保證變量的可見性和禁止指令重排(有序性問題)。

而加鎖可以解決以上三個問題。

除了這三個經(jīng)典問題，還有其他一些并發(fā)編程中可能需要關(guān)注的方面：

- **死鎖（Deadlock）**:
? - 死鎖發(fā)生在多個線程互相等待對方持有的資源，導致程序無法繼續(xù)執(zhí)行。需要通過設(shè)計避免死鎖的策略，如使用鎖順序、超時鎖嘗試等。

- **活鎖（Livelock）**:
? - 活鎖是指線程在不斷嘗試執(zhí)行操作，但因為其他線程的干擾而無法取得進展。需要通過合理的線程調(diào)度和資源分配策略來避免。

- **資源限制（Resource Limitation）**:
? - 在并發(fā)程序中，資源（如內(nèi)存、數(shù)據(jù)庫連接等）的使用需要考慮限制和配額，以避免資源耗盡導致系統(tǒng)崩潰。

- **性能優(yōu)化（Performance Optimization）**:
? - 并發(fā)程序的性能優(yōu)化是一個持續(xù)的過程，需要考慮線程池大小、任務(wù)調(diào)度、鎖的粒度和種類等因素。線程并不是越多越好，根據(jù)谷歌推薦我們開啟線程數(shù)=CPU數(shù)量＋1就是最優(yōu)。線程多了，線程上下文切換會造成資源浪費

解決這些問題通常需要使用并發(fā)工具（如同步機制、并發(fā)集合、原子變量等），以及遵循并發(fā)編程的最佳實踐。

---

在Java中，多線程環(huán)境下有幾種不同的隊列，它們用于不同的目的，包括任務(wù)調(diào)度、線程同步等。以下是一些常見的隊列：

1. **任務(wù)隊列**:
? ?- 每個線程都有自己的任務(wù)隊列，用于存儲 `Runnable` 對象。當線程執(zhí)行 `run()` 方法時，實際上是從這個隊列中取出任務(wù)并執(zhí)行。

2. **就緒隊列（Ready Queue）**:
? ?- 就緒隊列是調(diào)度器用來管理所有處于就緒狀態(tài)的線程的隊列。線程在等待CPU時間時，會進入這個隊列。調(diào)用Start方法，進入就緒隊列，等待cpu分給線程分時間片

3. **阻塞隊列（Blocking Queues）**:
? ?- Java并發(fā)API提供了多種阻塞隊列實現(xiàn)，如 `ArrayBlockingQueue`、`LinkedBlockingQueue`、`PriorityBlockingQueue` 等。這些隊列用于線程間的協(xié)調(diào)，當生產(chǎn)者線程放入元素或消費者線程取出元素時，如果操作不能立即執(zhí)行，線程將會被阻塞。

4. **等待隊列（Wait Queue）**:
? ?- 等待隊列通常與同步控制相關(guān)，如 `Object.wait()` 方法會導致線程進入等待隊列。當調(diào)用 `wait()` 的線程在等待某個條件變量時，它們會被放入該對象的等待隊列。

5. **鎖的等待隊列**:
? ?- 當一個線程嘗試獲取一個已經(jīng)被其他線程持有的鎖時，它會進入該鎖的等待隊列。一旦鎖被釋放，等待隊列中的線程將有機會獲取該鎖。

6. **線程池的工作隊列**:
? ?- 線程池（如 `ExecutorService`）內(nèi)部通常有一個工作隊列，用于存儲待執(zhí)行的任務(wù)。線程池中的線程會從這個隊列中獲取任務(wù)。

7. **延遲任務(wù)隊列**:
? ?- 延遲任務(wù)隊列用于存儲需要在未來某個時間點執(zhí)行的任務(wù)，如 `ScheduledExecutorService` 使用的延遲任務(wù)隊列。

8. **消息隊列**:
? ?- 在某些并發(fā)框架或消息傳遞系統(tǒng)中，可能會使用消息隊列來傳遞消息或事件，線程會從消息隊列中接收消息進行處理。

9. **信號量隊列**:
? ?- 使用 `Semaphore` 時，如果獲取信號量失敗，線程可能會進入信號量隊列，等待信號量的釋放。

這些隊列是Java多線程編程中用于任務(wù)調(diào)度、線程同步和協(xié)調(diào)的重要組成部分。不同的隊列適用于不同的場景，開發(fā)者可以根據(jù)具體需求選擇合適的隊列來實現(xiàn)線程間的協(xié)作。

---

當某個線程調(diào)用 `notify` 方法（或 `notifyAll`）時，它不會直接將等待隊列中的線程移動到其他類型的隊列。`notify` 方法的作用是喚醒在該對象上等待的單個線程，而 `notifyAll` 喚醒所有等待該對象的線程。以下是這一過程的詳細說明：

1. **喚醒等待線程**:
? ?- 當線程調(diào)用 `notify` 或 `notifyAll` 時，至少有一個線程必須在該對象上等待，即處于該對象的等待隊列（Wait Queue）中。

2. **鎖狀態(tài)改變**:
? ?- 被喚醒的線程不會立即從等待隊列移動到就緒隊列（Ready Queue）。首先，喚醒操作僅改變這些線程的狀態(tài)，使它們從 `WAITING` 狀態(tài)變?yōu)?`BLOCKED` 狀態(tài)，并在鎖的監(jiān)視下等待進入同步塊。

3. **競爭鎖**:
? ?- 被喚醒的線程現(xiàn)在將嘗試獲取鎖。如果只有一個線程被喚醒，它將嘗試獲取鎖并進入同步塊。如果有多個線程被喚醒（`notifyAll` 的情況），它們將競爭獲取鎖。

4. **進入就緒隊列**:
? ?- 當線程成功獲取鎖后，它將從 `BLOCKED` 狀態(tài)變?yōu)?`READY` 狀態(tài)，并進入就緒隊列等待CPU調(diào)度執(zhí)行。

5. **線程調(diào)度**:
? ?- 線程調(diào)度器將選擇就緒隊列中的線程來執(zhí)行。如果被喚醒的線程成功獲取CPU時間并開始執(zhí)行，它將從就緒隊列進入運行隊列。

6. **鎖未獲取的情況**:
? ?- 如果被喚醒的線程未能獲取鎖（例如，有其他線程持有鎖或有更高優(yōu)先級的線程在等待），它將重新進入等待隊列，并等待下一次鎖釋放的機會。

7. **鎖獲取成功**:
? ?- 一旦鎖被獲取，線程將執(zhí)行與該鎖關(guān)聯(lián)的同步代碼塊，之后可能會釋放鎖，允許其他線程進入。

總結(jié)來說，調(diào)用 `notify` 或 `notifyAll` 方法僅喚醒等待隊列中的線程，并不直接將它們移動到就緒隊列。線程需要在競爭鎖成功后，才能從等待隊列進入就緒隊列，并最終獲得執(zhí)行機會。這個過程是線程同步機制的一部分，確保了共享資源的線程安全訪問。
?

---

`Thread.join()` 方法不會使線程進入線程等待隊列。相反，它的作用是讓當前線程等待（阻塞）直到被調(diào)用 `join()` 方法的線程終止。以下是 `Thread.join()` 方法的一些關(guān)鍵點：

1. **等待其他線程終止**:
? ?當一個線程A調(diào)用另一個線程B的 `join()` 方法時，線程A會等待直到線程B完成執(zhí)行。

2. **阻塞行為**:
? ?`join()` 方法導致調(diào)用它的線程（即主調(diào)用線程）進入阻塞狀態(tài)，而不是進入任何隊列。

3. **線程生命周期**:
? ?在等待期間，調(diào)用 `join()` 的線程不會執(zhí)行任何操作，直到被加入的線程（即子線程）執(zhí)行完畢。

4. **返回控制**:
? ?一旦被加入的線程終止，`join()` 方法會返回，控制權(quán)會重新回到調(diào)用它的線程。

5. **死鎖避免**:
? ?使用 `join()` 方法時，需要注意避免死鎖。確保線程間的 `join()` 調(diào)用不是循環(huán)的。

6. **指定等待時間**:
? ?`join()` 方法還可以接受一個參數(shù)，表示等待的時間長度（單位為毫秒）。如果指定了時間參數(shù)，調(diào)用線程將等待直到子線程終止或超時。

? ?```java
? ?thread.join(1000); // 等待最多1秒
? ?```

7. **中斷處理**:
? ?如果調(diào)用 `join()` 的線程被中斷，`join()` 方法會拋出 `InterruptedException`。

8. **線程調(diào)度**:
? ?`join()` 方法不會影響線程調(diào)度，它只是簡單地讓當前線程等待，直到滿足退出條件。

9. **同步工具的替代**:
? ?盡管 `join()` 方法可以用于線程間的同步，但它不是顯式的同步控制機制，如 `wait()` 和 `notify()`。

`Thread.join()` 是Java并發(fā)編程中一個非常有用的工具，用于確保一個線程在另一個線程執(zhí)行完畢之前不繼續(xù)執(zhí)行。它在處理線程依賴關(guān)系和確保資源按特定順序釋放時非常有用。
?

---

`Thread.yield()` 方法是 Java 中的一個靜態(tài)方法，用于提示線程調(diào)度器當前線程愿意放棄當前的 CPU 時間片。這個方法的目的是讓線程調(diào)度器可以選擇另一個相同優(yōu)先級的線程來運行，從而提高系統(tǒng)的響應(yīng)性。

然而，調(diào)用 `Thread.yield()` 并不保證一定會發(fā)生線程上下文切換，也就是說，當前線程可能馬上再次被調(diào)度執(zhí)行。以下是一些關(guān)鍵點：

1. **線程調(diào)度器的響應(yīng)**:
? ?- 線程調(diào)度器可能會響應(yīng) `yield` 調(diào)用，選擇另一個相同優(yōu)先級的線程來運行，但這不是一定的。

2. **線程優(yōu)先級**:
? ?- `yield` 方法只影響當前線程的優(yōu)先級組內(nèi)的線程。如果當前線程是最高優(yōu)先級的線程，或者沒有其他同優(yōu)先級的線程處于可運行狀態(tài)，那么 `yield` 調(diào)用可能不會有任何效果。

3. **上下文切換**:
? ?- 即使 `yield` 調(diào)用導致線程調(diào)度器選擇了另一個線程，也不一定會發(fā)生完整的線程上下文切換。線程調(diào)度器的實現(xiàn)可能允許在不進行完整上下文切換的情況下進行線程切換。

4. **自旋**:
? ?- 在某些情況下，如果線程調(diào)度器沒有立即選擇另一個線程，當前線程可能會在 `yield` 調(diào)用后繼續(xù)執(zhí)行，這稱為自旋。

5. **使用場景**:
? ?- `yield` 方法通常用于線程間的協(xié)作，例如在自旋鎖或其他同步算法中，當線程無法獲得所需的條件時，可以使用 `yield` 來讓出 CPU 時間片。

6. **線程調(diào)度器的實現(xiàn)**:
? ?- 線程調(diào)度器的實現(xiàn)可能影響 `yield` 方法的行為。不同的 JVM 實現(xiàn)或不同的操作系統(tǒng)的線程調(diào)度器可能以不同的方式處理 `yield` 調(diào)用。

7. **性能影響**:
? ?- 過度使用 `yield` 可能會導致性能問題，因為它增加了線程調(diào)度的開銷。

總的來說，`Thread.yield()` 是一個提示，它建議線程調(diào)度器讓當前線程暫停執(zhí)行，但它不保證一定會發(fā)生線程上下文切換，也不保證當前線程會立即停止執(zhí)行。在實際編程中，應(yīng)謹慎使用 `yield`，以避免不可預測的行為和潛在的性能問題。
?

---

Java 中的 `interrupt()` 方法是 `Thread` 類的一個實例方法，用于中斷線程的狀態(tài)。以下是 `interrupt()` 方法的一些關(guān)鍵點：

1. **請求中斷**:
? ?- `interrupt()` 方法用于向線程發(fā)送一個中斷請求。這并不立即停止線程，而是設(shè)置線程的中斷狀態(tài)。

2. **線程響應(yīng)**:
? ?- 線程可以通過檢查 `Thread.interrupted()` 或 `this.interrupted()` 來響應(yīng)中斷請求。

3. **中斷狀態(tài)**:
? ?- 中斷狀態(tài)是一個標志，可以通過 `isInterrupted()` 方法查詢。

4. **清除中斷狀態(tài)**:
? ?- 調(diào)用 `interrupt()` 方法會清除當前線程的中斷狀態(tài)。因此，如果需要檢查中斷狀態(tài)，應(yīng)該在調(diào)用 `interrupt()` 之前進行。

5. **響應(yīng)中斷**:
? ?- 線程可以通過捕獲 `InterruptedException` 來響應(yīng)中斷請求。例如，在調(diào)用阻塞操作（如 `sleep()`、`wait()`、`join()` 等）時，如果線程被中斷，這些方法會拋出 `InterruptedException`。

6. **中斷其他線程**:
? ?- 一個線程可以調(diào)用另一個線程的 `interrupt()` 方法來請求中斷它。但是，實際的中斷效果取決于被請求中斷的線程是否響應(yīng)中斷。

7. **中斷狀態(tài)與線程結(jié)束**:
? ?- 中斷請求不會強制終止線程，它只是給線程一個信號，表明應(yīng)該在適當?shù)臅r候停止執(zhí)行。

8. **中斷標志傳播**:
? ?- 在響應(yīng)中斷時，中斷狀態(tài)可以通過 `InterruptedException` 傳播到調(diào)用棧的上層。

9. **線程中斷協(xié)調(diào)**:
? ?- 線程應(yīng)該定期檢查中斷狀態(tài)，并在適當?shù)臅r候響應(yīng)中斷請求。

10. **守護線程與中斷**:
? ? - 守護線程（Daemon Thread）在執(zhí)行時對中斷不敏感，即使收到中斷請求，也不會拋出 `InterruptedException`。

示例代碼：
```java
Thread thread = new Thread(() -> {
? ? try {
? ? ? ? // 執(zhí)行一些長時間運行的任務(wù)
? ? ? ? Thread.sleep(10000);
? ? } catch (InterruptedException e) {
? ? ? ? // 線程被中斷時的處理
? ? ? ? System.out.println("線程被中斷");
? ? ? ? Thread.currentThread().interrupt(); // 重新設(shè)置中斷狀態(tài)
? ? }
});

thread.start();

// 請求中斷線程
thread.interrupt();
```

在這個示例中，當 `interrupt()` 方法被調(diào)用時，它會設(shè)置線程的中斷狀態(tài)。線程在 `sleep()` 期間被中斷，會捕獲 `InterruptedException`，并打印一條消息。然后，它重新設(shè)置中斷狀態(tài)，以便調(diào)用棧上層可以檢測到中斷狀態(tài)。
?