- **什麼是JUC**
java.util .concurrent 工具包的簡稱。這是一個處理執行緒的工具包，JDK1.5 才有。

- **程式與執行緒**
程式（Process）：
是計算機中的程式關於某資料集合上的一次執行活動；是系統進行資源分配和排程的基本單位；是作業系統結構的基礎； 程式是執行緒的容器；程式是程式的實體。
簡說：指在系統中正在執行的一個應用程式；程式一旦執行就是程式；程式是資源分配的最小單位。
執行緒（thread）：
是作業系統能夠進行運算排程的最小單位；它被包含在程式之中，是程式中的實際運作單位；一個程式中可以併發多個執行緒，每條執行緒並行執行不同的任務。
簡說：系統分配處理器時間資源的基本單元，或者說程式之內獨立執行的一個單元執行流。執行緒是程式執行的最小單位。

- ** 執行緒狀態**
NEW,(新建)
RUNNABLE,（準備就緒）
BLOCKED,（阻塞）
WAITING,（不見不散）
TIMED_WAITING,（過時不候）
TERMINATED;(終結)

- **併發與並行 **
併發：一段時間內多個程式可以執行，一個CPU即可。
並行：一個時間點內多個程式可以執行，得多個CPU。

- **Synchronized **
Synchronized是一種同步鎖。
修飾的物件有：
1.修飾一個程式碼塊，被修飾的程式碼塊稱為同步語句塊，其作用的範圍是大括號{}
括起來的程式碼，作用的物件是呼叫這個程式碼塊的物件；
2. 修飾一個方法，被修飾的方法稱為同步方法，其作用的範圍是整個方法，作用
的物件是呼叫這個方法的物件；
對於普通同步方法，鎖是當前例項物件；
對於靜態同步方法，鎖是當前類的 Class 物件；
對於同步方法塊，鎖是 Synchonized 括號裡配置的物件；
注意：synchronized 關鍵字不能被繼承，即父類某個方法別synchronized修飾，子類不具備同步性，需要加上synchronized才能設定成同步方法。

- **什麼是 Lock**
Lock 鎖實現提供了比使用同步方法和語句可以獲得的更廣泛的鎖操作；Lock 提供了比 synchronized 更多的功能。
Lock 與的 Synchronized 區別：
Lock 不是 Java 語言內建的，synchronized 是 Java 語言的關鍵字；
Lock 是一個類，透過這個類可以實現同步訪問；
採用 synchronized 不需要使用者去手動釋放鎖，當 synchronized 方法或者 synchronized 程式碼塊執行完之後，系統會自動讓執行緒釋放對鎖的佔用；
Lock 則必須要使用者去手動釋放鎖，如果沒有主動釋放鎖，就有可能導致出現死鎖現象。
Lock 的效能要遠遠優於synchronized，在高併發的場景。

- **Lock的常用操作**
1、lock()方法是平常使用得最多的一個方法，就是用來獲取鎖。
2、使用Lock來進行同步的話，則使用一下方式：
```java
Lock lock = ...;
lock.lock();
try{
//處理任務
}catch(Exception ex){
}finally{
	lock.unlock(); //釋放鎖
}
```
注意：使用 Lock 必須在 try{}catch{}塊中進行，並且將釋放鎖的操作放在finally 塊中進行，以保證鎖一定被被釋放，防止死鎖的發生。
3、Lock 鎖的 newContition()方法返回 Condition 物件，Condition 類也可以實現等待/通知模式。
4、ReentrantLock，意思是“可重入鎖”，是唯一實現了 Lock 介面的類，使用方式如下：
```java
public void Test(Thread thread) {
Lock lock = new ReentrantLock(); //鎖
lock.lock();
try {
System.out.println(thread.getName()+"獲取鎖");
for(int i=0;i<5;i++) {
arrayList.add(i);
}
} catch (Exception e) {
}finally {
System.out.println(thread.getName()+"釋放鎖");
lock.unlock();
}
}
```
5、ReadWriteLock 讀寫鎖，主要有兩個方法readLock()和 writeLock()用來獲取讀鎖和寫鎖。

- **執行緒間通訊 **
共享記憶體和訊息傳遞。

- **集合的執行緒安全 **
1、Vector 是向量佇列，它是一個佇列，支援相關的新增、刪除、修改、遍歷等功能。 Vector 實現了 RandmoAccess 介面，即提供了隨機訪問功能；他是執行緒安全的。
2、Collections 提供了方法 synchronizedList 保證 list 是同步執行緒安全的。
```java
List list = Collections.synchronizedList(new ArrayList<>());
```
3、CopyOnWriteArrayList：
適合於具有以下特徵的應用程式：List 大小通常保持很小，只讀操作遠多於可變操作，需要在遍歷期間防止執行緒間的衝突；
它是執行緒安全的；
可變操作（add()、set() 和 remove()等等）的開銷很大；
迭代器支援 hasNext(), next()等不可變操作，但不支援可變 remove()等操作；
使用迭代器進行遍歷的速度很快，採用讀寫分離思想，其實質就是複製一份資料。
```java
List list = new CopyOnWriteArrayList();
```

- **執行緒建立的方式**
Thread：
```java
public class ThreadDemo04 extends Thread{
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
```
Runnable：
```java
	public class MyThread1 implements Runnable{
	/**
	* run 方法
	*/
	@Override
	public void run() {
	try { 
	System.out.println(Thread.currentThread().getName() + "進入 run
	方法");
	}catch (Exception e){
	e.printStackTrace();
	}
	}
	}
```

Callable：
```java
public class MyThread2 implements Callable{
/**
* call 方法
* @return
* @throws Exception
*/
@Override
public Long call() throws Exception {
try {
System.out.println(Thread.currentThread().getName() + "進入 call
方法");
Thread.sleep(1000);
}catch (Exception e){
e.printStackTrace();
}
return System.currentTimeMillis();
}
}
```

- ** JUC 三大輔助類**
CountDownLatch: 
減少計數，透過 countDown 方法來進行加減的操作；
```java
//定義一個數值為 12 的計數器
CountDownLatch countDownLatch = new CountDownLatch(12);
```
CyclicBarrier: 
迴圈柵欄，CyclicBarrier 看英文單詞可以看出大概就是迴圈阻塞的意思，在使用中CyclicBarrier 的構造方法第一個引數是目標障礙數，每次執行 CyclicBarrier 一次障礙數會加一，如果達到了目標障礙數，才會執行 cyclicBarrier.await()之後的語句。可以將 CyclicBarrier 理解為加 1 操作
```java
//定義迴圈柵欄
int num = 7;//集齊七龍珠
CyclicBarrier cyclicBarrier = new CyclicBarrier(num, () ->{
System.out.println("集齊" + num + "顆龍珠,召喚神龍");
});
........
cyclicBarrier.await();
```
Semaphore: 
訊號燈,Semaphore 的構造方法中傳入的第一個引數是最大訊號量（可以看成最大執行緒池），每個訊號量初始化為一個最多隻能分發一個許可證。使用 acquire 方法獲得許可證，release 方法釋放許可。
```java
//定義 6 個停車位
Semaphore semaphore = new Semaphore(6);
....
semaphore.acquire();
```

- **讀寫鎖**
對共享資源有讀和寫的操作，且寫操作沒有讀操作那麼頻繁。在沒有寫操作的時候，多個執行緒同時讀一個資源沒有任何問題，所以
應該允許多個執行緒同時讀取共享資源；但是如果一個執行緒想去寫這些共享資源，就不應該允許其他執行緒對該資源進行讀和寫的操作了。JAVA 的併發包提供了讀寫鎖 ReentrantReadWriteLock，它表示兩個鎖，一個是讀操作相關的鎖，稱為共享鎖；一個是寫相關的鎖，稱
為排他鎖。
執行緒進入讀鎖的前提條件：
沒有其他執行緒的寫鎖；
執行緒進入寫鎖的前提條件：
沒有其他執行緒的讀鎖
沒有其他執行緒的寫鎖
而讀寫鎖有以下三個重要的特性：
公平選擇性：支援非公平（預設）和公平的鎖獲取方式，吞吐量還是非公平優於公平；
重進入：讀鎖和寫鎖都支援執行緒重進入；
鎖降級：遵循獲取寫鎖、獲取讀鎖再釋放寫鎖的次序，寫鎖能夠降級成為讀鎖。

- **BlockingQueue（阻塞佇列）**
BlockingQueue的核心方法：
1、放入資料：
offer(Object):表示如果可能的話,將 Object 加到 BlockingQueue 裡,即如果 BlockingQueue 可以容納,則返回 true,否則返回 false.（本方法不阻塞當前執行方法的執行緒）
offer(E o, long timeout, TimeUnit unit)：可以設定等待的時間，如果在指定的時間內，還不能往佇列中加入 BlockingQueue，則返回失敗
put(anObject):把 anObject 加到 BlockingQueue 裡,如果 BlockQueue 沒有空間,則呼叫此方法的執行緒被阻斷直到 BlockingQueue 裡面有空間再繼續。
2、獲取資料
poll(time): 取走 BlockingQueue 裡排在首位的物件,若不能立即取出,則可以等time 引數規定的時間,取不到時返回 null；
poll(long timeout, TimeUnit unit)：從 BlockingQueue 取出一個隊首的物件，如果在指定時間內，佇列一旦有資料可取，則立即返回佇列中的資料。否則直到時間超時還沒有資料可取，返回失敗。
take(): 取走 BlockingQueue 裡排在首位的物件,若 BlockingQueue 為空,阻斷進入等待狀態直到 BlockingQueue 有新的資料被加入;
drainTo(): 一次性從 BlockingQueue 獲取所有可用的資料物件（還可以指定獲取資料的個數），透過該方法，可以提升獲取資料效率；不需要多次分批加
鎖或釋放鎖。
常見的BlockingQueue：
ArrayBlockingQueue（常用），由陣列結構組成的有界阻塞佇列；
 LinkedBlockingQueue（常用），由連結串列結構組成的有界（但大小預設值為integer.MAX_VALUE）阻塞佇列；
 DelayQueue， 使用優先順序佇列實現的延遲無界阻塞佇列；
 PriorityBlockingQueue，支援優先順序排序的無界阻塞佇列；
 SynchronousQueue，不儲存元素的阻塞佇列，也即單個元素的佇列；
 LinkedTransferQueue， 由連結串列組成的無界阻塞佇列；
 LinkedBlockingDeque，由連結串列組成的雙向阻塞佇列。
 
- **執行緒池**
 執行緒池的優勢：
 執行緒池做的工作只要是控制執行的執行緒數量，處理過程中將任務放入佇列，然後線上程建立後啟動這些任務，如果執行緒數量超過了最大數量，超出數量的執行緒排隊等候，等其他執行緒執行完畢，再從佇列中取出任務來執行。
 主要特點為：
降低資源消耗: 透過重複利用已建立的執行緒降低執行緒建立和銷燬造成的銷耗。
提高響應速度: 當任務到達時，任務可以不需要等待執行緒建立就能立即執行。
提高執行緒的可管理性: 執行緒是稀缺資源，如果無限制的建立，不僅會銷耗系統資源，還會降低系統的穩定性，使用執行緒池可以進行統一的分配，調優和監控。
Java 中的執行緒池是透過 Executor 框架實現的，該框架中用到了 Executor，Executors，ExecutorService，ThreadPoolExecutor 這幾個類
常用引數：
corePoolSize 執行緒池的核心執行緒數
maximumPoolSize 能容納的最大執行緒數
keepAliveTime 空閒執行緒存活時間
unit 存活的時間單位
workQueue 存放提交但未執行任務的佇列
threadFactory 建立執行緒的工廠類
handler 等待佇列滿後的拒絕策略
執行緒池中，有三個重要的引數，決定影響了拒絕策略：corePoolSize - 核心執行緒數，也即最小的執行緒數。workQueue - 阻塞佇列 。 maximumPoolSize -最大執行緒數。
當提交任務數大於 corePoolSize 的時候，會優先將任務放到 workQueue 阻塞佇列中。當阻塞佇列飽和後，會擴充執行緒池中執行緒數，直到達到maximumPoolSize 最大執行緒數配置。此時，再多餘的任務，則會觸發執行緒池的拒絕策略了。
總之，當提交的任務數大於（workQueue.size() +maximumPoolSize ），就會觸發執行緒池的拒絕策略。
拒絕策略：
CallerRunsPolicy: 當觸發拒絕策略，只要執行緒池沒有關閉的話，則使用呼叫執行緒直接執行任務。
AbortPolicy: 丟棄任務，並丟擲拒絕執行 RejectedExecutionException 異常資訊。執行緒池預設的拒絕策略。必須處理好丟擲的異常，否則會打斷當前的執行流程，影響後續的任務執行。
DiscardPolicy: 直接丟棄。
DiscardOldestPolicy: 當觸發拒絕策略，只要執行緒池沒有關閉的話，丟棄阻塞佇列 workQueue 中最老的一個任務，並將新任務加入。
執行緒池的種類與建立：
1、newCachedThreadPool：
作用：建立一個可快取執行緒池，如果執行緒池長度超過處理需要，可靈活回收空閒執行緒，若無可回收，則新建執行緒。
特點:
執行緒池中數量沒有固定，可達到最大值（Interger. MAX_VALUE）
執行緒池中的執行緒可進行快取重複利用和回收（回收預設時間為 1 分鐘）
當執行緒池中，沒有可用執行緒，會重新建立一個執行緒
建立方式：
```java
new ThreadPoolExecutor(0,
Integer.MAX_VALUE,
60L,
TimeUnit.SECONDS,
new SynchronousQueue<>(),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
```
場景: 適用於建立一個可無限擴大的執行緒池，伺服器負載壓力較輕，執行時間較短，任務多的場景
2、newFixedThreadPool
作用：建立一個可重用固定執行緒數的執行緒池，以共享的無界佇列方式來執行這些執行緒。
特徵：
執行緒池中的執行緒處於一定的量，可以很好的控制執行緒的併發量；
執行緒可以重複被使用，在顯示關閉之前，都將一直存在；
超出一定量的執行緒被提交時候需在佇列中等待。
建立方式：
```java
new ThreadPoolExecutor(10,
10,
0L,
TimeUnit.SECONDS,
new LinkedBlockingQueue<>(),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
```
場景: 適用於可以預測執行緒數量的業務中，或者伺服器負載較重，對執行緒數有嚴格限制的場景。
3、newSingleThreadExecutor
作用：建立一個使用單個 worker 執行緒的 Executor，以無界佇列方式來執行該執行緒。
特徵： 執行緒池中最多執行 1 個執行緒，之後提交的執行緒活動將會排在佇列中以此執行。
建立方式：
```java
new ThreadPoolExecutor(1,
1,
0L,
TimeUnit.SECONDS,
new LinkedBlockingQueue<>(),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
```
場景: 適用於需要保證順序執行各個任務，並且在任意時間點，不會同時有多個執行緒的場景。
4、newScheduleThreadPool
作用: 執行緒池支援定時以及週期性執行任務，建立一個 corePoolSize 為傳入參。數，最大執行緒數為整形的最大數的執行緒池
特徵:
（1）執行緒池中具有指定數量的執行緒，即便是空執行緒也將保留 
（2）可定時或者延遲執行執行緒活動
建立方式:
```java
new ScheduledThreadPoolExecutor(corePoolSize,
threadFactory);
```
場景: 適用於需要多個後臺執行緒執行週期任務的場景。
5、newWorkStealingPool
作用：jdk1.8 提供的執行緒池，底層使用的是 ForkJoinPool 實現，建立一個擁有多個任務佇列的執行緒池，可以減少連線數，建立當前可用 cpu 核數的執行緒來並行執行任務。
建立方式:
```java
	/**
	* parallelism：並行級別，通常預設為 JVM 可用的處理器個數
	* factory：用於建立 ForkJoinPool 中使用的執行緒。
	* handler：用於處理工作執行緒未處理的異常，預設為 null
	* asyncMode：用於控制 WorkQueue 的工作模式:佇列---反佇列
	*/
	new ForkJoinPool(parallelism,
	ForkJoinPool.defaultForkJoinWorkerThreadFactory,
	null,
	true);
```
場景: 適用於大耗時，可並行執行的場景。

- ** Fork/Join**
Fork：把一個複雜任務進行分拆，大事化小
Join：把分拆任務的結果進行合併

JUC的概述

相關文章