併發包

(計數器)CountDownLatch
CountDownLatch 類位於java.util.concurrent包下，利用它可以實現類似計數器的功能。比如有一個任務A，它要等待其他4個任務執行完畢之後才能執行，此時就可以利用CountDownLatch來實現這種功能了。CountDownLatch是通過一個計數器來實現的，計數器的初始值爲線程的數量。每當一個線程完成了自己的任務後，計數器的值就會減1。當計數器值到達0時，它表示所有的線程已經完成了任務，然後在閉鎖上等待的線程就可以恢復執行任務。

public static void main(String[] args) throws InterruptedException {

CountDownLatch countDownLatch = new CountDownLatch(2);

new Thread(new Runnable() {

@Override

public void run() {

System.out.println(Thread.currentThread().getName() + ",子線程開始執行...");

countDownLatch.countDown();

System.out.println(Thread.currentThread().getName() + ",子線程結束執行...");

}

}).start();

new Thread(new Runnable() {

@Override

public void run() {

System.out.println(Thread.currentThread().getName() + ",子線程開始執行...");

countDownLatch.countDown();//計數器值每次減去1

System.out.println(Thread.currentThread().getName() + ",子線程結束執行...");

}

}).start();

countDownLatch.await();// 減去爲0,恢復任務繼續執行

System.out.println("兩個子線程執行完畢....");

System.out.println("主線程繼續執行.....");

for (int i = 0; i <10; i++) {

System.out.println("main,i:"+i);

}

(屏障)CyclicBarrier

CyclicBarrier初始化時規定一個數目，然後計算調用了CyclicBarrier.await()進入等待的線程數。當線程數達到了這個數目時，所有進入等待狀態的線程被喚醒並繼續。

CyclicBarrier就象它名字的意思一樣，可看成是個障礙，所有的線程必須到齊後才能一起通過這個障礙。

CyclicBarrier初始時還可帶一個Runnable的參數，此Runnable任務在CyclicBarrier的數目達到後，所有其它線程被喚醒前被執行。

class Writer extends Thread {

private CyclicBarrier cyclicBarrier;

public Writer(CyclicBarrier cyclicBarrier){

this.cyclicBarrier=cyclicBarrier;

}

@Override

public void run() {

System.out.println("線程" + Thread.currentThread().getName() + ",正在寫入數據");

try {

Thread.sleep(3000);

} catch (Exception e) {

// TODO: handle exception

}

System.out.println("線程" + Thread.currentThread().getName() + ",寫入數據成功.....");

try {

cyclicBarrier.await();

} catch (Exception e) {

}

System.out.println("所有線程執行完畢..........");

}

public class Test001 {

public static void main(String[] args) {

CyclicBarrier cyclicBarrier=new CyclicBarrier(5);

for (int i = 0; i < 5; i++) {

Writer writer = new Writer(cyclicBarrier);

writer.start();

}

(計數信號量)Semaphore

Semaphore是一種基於計數的信號量。它可以設定一個閾值，基於此，多個線程競爭獲取許可信號，做自己的申請後歸還，超過閾值後，線程申請許可信號將會被阻塞。Semaphore可以用來構建一些對象池，資源池之類的，比如數據庫連接池，我們也可以創建計數爲1的Semaphore，將其作爲一種類似互斥鎖的機制，這也叫二元信號量，表示兩種互斥狀態。它的用法如下：

availablePermits函數用來獲取當前可用的資源數量

wc.acquire(); //申請資源

wc.release();// 釋放資源

// 創建一個計數閾值爲5的信號量對象

// 只能5個線程同時訪問

Semaphore semp = new Semaphore(5);

try {

// 申請許可

semp.acquire();

try {

// 業務邏輯

} catch (Exception e) {

} finally {

// 釋放許可

semp.release();

}

} catch (InterruptedException e) {

}

案例:

需求: 一個廁所只有3個坑位，但是有10個人來上廁所，那怎麼辦？假設10的人的編號分別爲1-10，並且1號先到廁所，10號最後到廁所。那麼1-3號來的時候必然有可用坑位，順利如廁，4號來的時候需要看看前面3人是否有人出來了，如果有人出來，進去，否則等待。同樣的道理，4-10號也需要等待正在上廁所的人出來後才能進去，並且誰先進去這得看等待的人是否有素質，是否能遵守先來先上的規則。

代碼:

class ThradDemo001 extends Thread {

private String name;

private Semaphore wc;

public ThradDemo001(String name, Semaphore wc) {

this.name = name;

this.wc = wc;

}

@Override

public void run() {

// 剩下的資源

int availablePermits = wc.availablePermits();

if (availablePermits > 0) {

System.out.println(name + "天助我也，終於有茅坑了.....");

} else {

System.out.println(name + "怎麼沒有茅坑了...");

}

try {

// 申請資源

wc.acquire();

} catch (InterruptedException e) {

}

System.out.println(name + "終於上廁所啦.爽啊" + ",剩下廁所:" + wc.availablePermits());

try {

Thread.sleep(new Random().nextInt(1000));

} catch (Exception e) {

// TODO: handle exception

}

System.out.println(name + "廁所上完啦!");

// 釋放資源

wc.release();

}

public class TestSemaphore {

public static void main(String[] args) {

Semaphore semaphore = new Semaphore(3);

for (int i = 1; i <= 10; i++) {

ThradDemo001 thradDemo001 = new ThradDemo001("第" + i + "個人", semaphore);

thradDemo001.start();

}

併發隊列

在併發隊列上JDK提供了兩套實現，一個是以ConcurrentLinkedQueue爲代表的高性能隊

列非阻塞5️⃣，一個是以BlockingQueue接口爲代表的阻塞隊列，無論哪種都繼承自Queue。

阻塞隊列與非阻塞隊

阻塞隊列與普通隊列的區別在於，當隊列是空的時，從隊列中獲取元素的操作將會被阻塞，或者當隊列是滿時，往隊列裏添加元素的操作會被阻塞。試圖從空的阻塞隊列中獲取元素的線程將會被阻塞，直到其他的線程往空的隊列插入新的元素。同樣，試圖往已滿的阻塞隊列中添加新元素的線程同樣也會被阻塞，直到其他的線程使隊列重新變得空閒起來，如從隊列中移除一個或者多個元素，或者完全清空隊列.

1.ArrayDeque, （數組雙端隊列）
2.PriorityQueue, （優先級隊列）
3.ConcurrentLinkedQueue, （基於鏈表的併發隊列）
4.DelayQueue, （延期阻塞隊列）（阻塞隊列實現了BlockingQueue接口）
5.ArrayBlockingQueue, （基於數組的併發阻塞隊列）
6.LinkedBlockingQueue, （基於鏈表的FIFO阻塞隊列）
7.LinkedBlockingDeque, （基於鏈表的FIFO雙端阻塞隊列）
8.PriorityBlockingQueue, （帶優先級的無界阻塞隊列）
9.SynchronousQueue （併發同步阻塞隊列）

ConcurrentLinkedDeque
ConcurrentLinkedQueue : 是一個適用於高併發場景下的隊列，通過無鎖的方式，實現
了高併發狀態下的高性能，通常ConcurrentLinkedQueue性能好於BlockingQueue.它
是一個基於鏈接節點的無界線程安全隊列。該隊列的元素遵循先進先出的原則。頭是最先
加入的，尾是最近加入的，該隊列不允許null元素。
ConcurrentLinkedQueue重要方法:
add 和offer() 都是加入元素的方法(在ConcurrentLinkedQueue中這倆個方法沒有任何區別)
poll() 和peek() 都是取頭元素節點，區別在於前者會刪除元素，後者不會。

ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();

q.offer("餘勝軍");

q.offer("碼雲");

q.offer("螞蟻課堂");

q.offer("張傑");

q.offer("艾姐");

//從頭獲取元素,刪除該元素

System.out.println(q.poll());

//從頭獲取元素,不刪除該元素

System.out.println(q.peek());

//獲取總長度

System.out.println(q.size());

BlockingQueue

阻塞隊列（BlockingQueue）是一個支持兩個附加操作的隊列。這兩個附加的操作是：

在隊列爲空時，獲取元素的線程會等待隊列變爲非空。

當隊列滿時，存儲元素的線程會等待隊列可用。

阻塞隊列常用於生產者和消費者的場景，生產者是往隊列裏添加元素的線程，消費者是從隊列裏拿元素的線程。阻塞隊列就是生產者存放元素的容器，而消費者也只從容器裏拿元素。

BlockingQueue即阻塞隊列，從阻塞這個詞可以看出，在某些情況下對阻塞隊列的訪問可能會造成阻塞。被阻塞的情況主要有如下兩種：

1. 當隊列滿了的時候進行入隊列操作

2. 當隊列空了的時候進行出隊列操作

因此，當一個線程試圖對一個已經滿了的隊列進行入隊列操作時，它將會被阻塞，除非有另一個線程做了出隊列操作；同樣，當一個線程試圖對一個空隊列進行出隊列操作時，它將會被阻塞，除非有另一個線程進行了入隊列操作。

在Java中，BlockingQueue的接口位於java.util.concurrent 包中(在Java5版本開始提供)，由上面介紹的阻塞隊列的特性可知，阻塞隊列是線程安全的。

在新增的Concurrent包中，BlockingQueue很好的解決了多線程中，如何高效安全“傳輸”數據的問題。通過這些高效並且線程安全的隊列類，爲我們快速搭建高質量的多線程程序帶來極大的便利。本文詳細介紹了BlockingQueue家庭中的所有成員，包括他們各自的功能以及常見使用場景。

認識BlockingQueue

阻塞隊列，顧名思義，首先它是一個隊列，而一個隊列在數據結構中所起的作用大致如下圖所示：

從上圖我們可以很清楚看到，通過一個共享的隊列，可以使得數據由隊列的一端輸入，從另外一端輸出；

常用的隊列主要有以下兩種：（當然通過不同的實現方式，還可以延伸出很多不同類型的隊列，DelayQueue就是其中的一種）

　　先進先出（FIFO）：先插入的隊列的元素也最先出隊列，類似於排隊的功能。從某種程度上來說這種隊列也體現了一種公平性。

　　後進先出（LIFO）：後插入隊列的元素最先出隊列，這種隊列優先處理最近發生的事件。

多線程環境中，通過隊列可以很容易實現數據共享，比如經典的“生產者”和“消費者”模型中，通過隊列可以很便利地實現兩者之間的數據共享。假設我們有若干生產者線程，另外又有若干個消費者線程。如果生產者線程需要把準備好的數據共享給消費者線程，利用隊列的方式來傳遞數據，就可以很方便地解決他們之間的數據共享問題。但如果生產者和消費者在某個時間段內，萬一發生數據處理速度不匹配的情況呢？理想情況下，如果生產者產出數據的速度大於消費者消費的速度，並且當生產出來的數據累積到一定程度的時候，那麼生產者必須暫停等待一下（阻塞生產者線程），以便等待消費者線程把累積的數據處理完畢，反之亦然。然而，在concurrent包發佈以前，在多線程環境下，我們每個程序員都必須去自己控制這些細節，尤其還要兼顧效率和線程安全，而這會給我們的程序帶來不小的複雜度。好在此時，強大的concurrent包橫空出世了，而他也給我們帶來了強大的BlockingQueue。（在多線程領域：所謂阻塞，在某些情況下會掛起線程（即阻塞），一旦條件滿足，被掛起的線程又會自動被喚醒）

下面兩幅圖演示了BlockingQueue的兩個常見阻塞場景：

ArrayBlockingQueue

ArrayBlockingQueue是一個有邊界的阻塞隊列，它的內部實現是一個數組。有邊界的意思是它的容量是有限的，我們必須在其初始化的時候指定它的容量大小，容量大小一旦指定就不可改變。

ArrayBlockingQueue是以先進先出的方式存儲數據，最新插入的對象是尾部，最新移出的對象是頭部。下面

是一個初始化和使用ArrayBlockingQueue的例子：

<String> arrays = new ArrayBlockingQueue<String>(3);

arrays.add("李四");

arrays.add("張軍");

// 添加阻塞隊列

arrays.offer("張三", 1, TimeUnit.SECONDS);

LinkedBlockingQueue

LinkedBlockingQueue阻塞隊列大小的配置是可選的，如果我們初始化時指定一個大小，它就是有邊界的，如果不指定，它就是無邊界的。說是無邊界，其實是採用了默認大小爲Integer.MAX_VALUE的容量。它的內部實現是一個鏈表。

和ArrayBlockingQueue一樣，LinkedBlockingQueue 也是以先進先出的方式存儲數據，最新插入的對象是尾部，最新移出的對象是頭部。下面是一個初始化和使LinkedBlockingQueue的例子：

LinkedBlockingQueue linkedBlockingQueue = new LinkedBlockingQueue(3);

linkedBlockingQueue.add("張三");

linkedBlockingQueue.add("李四");

System.out.println(linkedBlockingQueue.size());

PriorityBlockingQueue

PriorityBlockingQueue是一個沒有邊界的隊列，它的排序規則和 java.util.PriorityQueue一樣。需要注

意，PriorityBlockingQueue中允許插入null對象。

所有插入PriorityBlockingQueue的對象必須實現 java.lang.Comparable接口，隊列優先級的排序規則就

是按照我們對這個接口的實現來定義的。

另外，我們可以從PriorityBlockingQueue獲得一個迭代器Iterator，但這個迭代器並不保證按照優先級順

序進行迭代。

下面我們舉個例子來說明一下，首先我們定義一個對象類型，這個對象需要實現Comparable接口：

SynchronousQueue

SynchronousQueue隊列內部僅允許容納一個元素。當一個線程插入一個元素後會被阻塞，除非這個元素被另一個線程消費。

使用BlockingQueue模擬生產者與消費者

class ProducerThread implements Runnable {

private BlockingQueue<String> blockingQueue;

private AtomicInteger count = new AtomicInteger();

private volatile boolean FLAG = true;

public ProducerThread(BlockingQueue<String> blockingQueue) {

this.blockingQueue = blockingQueue;

}

@Override

public void run() {

System.out.println(Thread.currentThread().getName() + "生產者開始啓動....");

while (FLAG) {

String data = count.incrementAndGet() + "";

try {

boolean offer = blockingQueue.offer(data, 2, TimeUnit.SECONDS);

if (offer) {

System.out.println(Thread.currentThread().getName() + ",生產隊列" + data + "成功..");

} else {

System.out.println(Thread.currentThread().getName() + ",生產隊列" + data + "失敗..");

}

Thread.sleep(1000);

} catch (Exception e) {

}

System.out.println(Thread.currentThread().getName() + ",生產者線程停止...");

}

public void stop() {

this.FLAG = false;

}

class ConsumerThread implements Runnable {

private volatile boolean FLAG = true;

private BlockingQueue<String> blockingQueue;

public ConsumerThread(BlockingQueue<String> blockingQueue) {

this.blockingQueue = blockingQueue;

}

@Override

public void run() {

System.out.println(Thread.currentThread().getName() + "消費者開始啓動....");

while (FLAG) {

try {

String data = blockingQueue.poll(2, TimeUnit.SECONDS);

if (data == null || data == "") {

FLAG = false;

System.out.println("消費者超過2秒時間未獲取到消息.");

return;

}

System.out.println("消費者獲取到隊列信息成功,data:" + data);

} catch (Exception e) {

// TODO: handle exception

}

public class Test0008 {

public static void main(String[] args) {

BlockingQueue<String> blockingQueue = new LinkedBlockingQueue<>(3);

ProducerThread producerThread = new ProducerThread(blockingQueue);

ConsumerThread consumerThread = new ConsumerThread(blockingQueue);

Thread t1 = new Thread(producerThread);

Thread t2 = new Thread(consumerThread);

t1.start();

t2.start();

//10秒後停止線程..

try {

Thread.sleep(10*1000);

producerThread.stop();

} catch (Exception e) {

// TODO: handle exception

}

線程池

什麼是線程池

Java中的線程池是運用場景最多的並發框架，幾乎所有需要異步或並發執行任務的程序
都可以使用線程池。在開發過程中，合理地使用線程池能夠帶來3個好處。
第一：降低資源消耗。通過重複利用已創建的線程降低線程創建和銷毀造成的消耗。
第二：提高響應速度。當任務到達時，任務可以不需要等到線程創建就能立即執行。
第三：提高線程的可管理性。線程是稀缺資源，如果無限制地創建，不僅會消耗系統資源，
還會降低系統的穩定性，使用線程池可以進行統一分配、調優和監控。但是，要做到合理利用
線程池，必須對其實現原理了如指掌。

線程池作用

線程池是爲突然大量爆發的線程設計的，通過有限的幾個固定線程爲大量的操作服務，減少了創建和銷燬線程所需的時間，從而提高效率。

如果一個線程的時間非常長，就沒必要用線程池了(不是不能作長時間操作，而是不宜。)，況且我們還不能控制線程池中線程的開始、掛起、和中止。

線程池的分類

ThreadPoolExecutor

Java是天生就支持併發的語言，支持併發意味着多線程，線程的頻繁創建在高併發及大數據量是非常消耗資源的，因爲java提供了線程池。在jdk1.5以前的版本中，線程池的使用是及其簡陋的，但是在JDK1.5後，有了很大的改善。JDK1.5之後加入了java.util.concurrent包，java.util.concurrent包的加入給予開發人員開發併發程序以及解決併發問題很大的幫助。這篇文章主要介紹下併發包下的Executor接口，Executor接口雖然作爲一個非常舊的接口（JDK1.5 2004年發佈），但是很多程序員對於其中的一些原理還是不熟悉，因此寫這篇文章來介紹下Executor接口，同時鞏固下自己的知識。如果文章中有出現錯誤，歡迎大家指出。

Executor框架的最頂層實現是ThreadPoolExecutor類，Executors工廠類中提供的newScheduledThreadPool、newFixedThreadPool、newCachedThreadPool方法其實也只是ThreadPoolExecutor的構造函數參數不同而已。通過傳入不同的參數，就可以構造出適用於不同應用場景下的線程池，那麼它的底層原理是怎樣實現的呢，這篇就來介紹下ThreadPoolExecutor線程池的運行過程。

corePoolSize：核心池的大小。當有任務來之後，就會創建一個線程去執行任務，當線程池中的線程數目達到corePoolSize後，就會把到達的任務放到緩存隊列當中
maximumPoolSize：線程池最大線程數，它表示在線程池中最多能創建多少個線程；
keepAliveTime：表示線程沒有任務執行時最多保持多久時間會終止。
unit：參數keepAliveTime的時間單位，有7種取值，在TimeUnit類中有7種靜態屬性：

線程池四種創建方式

Java通過Executors（jdk1.5併發包）提供四種線程池，分別爲：

newCachedThreadPool創建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閒線程，若無可回收，則新建線程。

newFixedThreadPool 創建一個定長線程池，可控制線程最大併發數，超出的線程會在隊列中等待。

newScheduledThreadPool 創建一個定長線程池，支持定時及週期性任務執行。

newSingleThreadExecutor 創建一個單線程化的線程池，它只會用唯一的工作線程來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先級)執行。

newCachedThreadPool

創建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閒線程，若無可回收，則新建線程。示例代碼如下：

// 無限大小線程池 jvm自動回收

ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();

for (int i = 0; i < 10; i++) {

final int temp = i;

newCachedThreadPool.execute(new Runnable() {

@Override

public void run() {

try {

Thread.sleep(100);

} catch (Exception e) {

// TODO: handle exception

}

System.out.println(Thread.currentThread().getName() + ",i:" + temp);

}

});

}

總結: 線程池爲無限大，當執行第二個任務時第一個任務已經完成，會複用執行第一個任務的線程，而不用每次新建線程。

newFixedThreadPool

創建一個定長線程池，可控制線程最大併發數，超出的線程會在隊列中等待。示例代碼如下：

ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(5);

for (int i = 0; i < 10; i++) {

final int temp = i;

newFixedThreadPool.execute(new Runnable() {

@Override

public void run() {

System.out.println(Thread.currentThread().getId() + ",i:" + temp);

}

});

}

總結:因爲線程池大小爲3，每個任務輸出index後sleep 2秒，所以每兩秒打印3個數字。

定長線程池的大小最好根據系統資源進行設置。如Runtime.getRuntime().availableProcessors()

newScheduledThreadPool

創建一個定長線程池，支持定時及週期性任務執行。延遲執行示例代碼如下：

ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(5);

for (int i = 0; i < 10; i++) {

final int temp = i;

newScheduledThreadPool.schedule(new Runnable() {

public void run() {

System.out.println("i:" + temp);

}

}, 3, TimeUnit.SECONDS);

}

表示延遲3秒執行。

newSingleThreadExecutor

創建一個單線程化的線程池，它只會用唯一的工作線程來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先級)執行。示例代碼如下：

ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();

for (int i = 0; i < 10; i++) {

final int index = i;

newSingleThreadExecutor.execute(new Runnable() {

@Override

public void run() {

System.out.println("index:" + index);

try {

Thread.sleep(200);

} catch (Exception e) {

// TODO: handle exception

}

});

}

注意: 結果依次輸出，相當於順序執行各個任務。

線程池原理剖析

提交一個任務到線程池中，線程池的處理流程如下：

1、判斷線程池裏的核心線程是否都在執行任務，如果不是（核心線程空閒或者還有核心線程沒有被創建）則創建一個新的工作線程來執行任務。如果核心線程都在執行任務，則進入下個流程。

2、線程池判斷工作隊列是否已滿，如果工作隊列沒有滿，則將新提交的任務存儲在這個工作隊列裏。如果工作隊列滿了，則進入下個流程。

3、判斷線程池裏的線程是否都處於工作狀態，如果沒有，則創建一個新的工作線程來執行任務。如果已經滿了，則交給飽和策略來處理這個任務。

自定義線程線程池

如果當前線程池中的線程數目小於corePoolSize，則每來一個任務，就會創建一個線程去執行這個任務；

如果當前線程池中的線程數目>=corePoolSize，則每來一個任務，會嘗試將其添加到任務緩存隊列當中，若添加成功，則該任務會等待空閒線程將其取出去執行；若添加失敗（一般來說是任務緩存隊列已滿），則會嘗試創建新的線程去執行這個任務；

如果隊列已經滿了，則在總線程數不大於maximumPoolSize的前提下，則創建新的線程

如果當前線程池中的線程數目達到maximumPoolSize，則會採取任務拒絕策略進行處理；

如果線程池中的線程數量大於 corePoolSize時，如果某線程空閒時間超過keepAliveTime，線程將被終止，直至線程池中的線程數目不大於corePoolSize；如果允許爲核心池中的線程設置存活時間，那麼核心池中的線程空閒時間超過keepAliveTime，線程也會被終止。

public class Test0007 {

public static void main(String[] args) {

ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 2, 60L, TimeUnit.SECONDS, new ArrayBlockingQueue<>(3));

for (int i = 1; i <= 6; i++) {

TaskThred t1 = new TaskThred("任務" + i);

executor.execute(t1);

}

executor.shutdown();

}

class TaskThred implements Runnable {

private String taskName;

public TaskThred(String taskName) {

this.taskName = taskName;

}

@Override

public void run() {

System.out.println(Thread.currentThread().getName()+taskName);

}

合理配置線程池

CPU密集

CPU密集的意思是該任務需要大量的運算，而沒有阻塞，CPU一直全速運行。

CPU密集任務只有在真正的多核CPU上纔可能得到加速(通過多線程)，而在單核CPU上，無論你開幾個模擬的多線程，該任務都不可能得到加速，因爲CPU總的運算能力就那些。

IO密集

IO密集型，即該任務需要大量的IO，即大量的阻塞。在單線程上運行IO密集型的任務會導致浪費大量的CPU運算能力浪費在等待。所以在IO密集型任務中使用多線程可以大大的加速程序運行，即時在單核CPU上，這種加速主要就是利用了被浪費掉的阻塞時間。

接着上一篇探討線程池留下的尾巴，如何合理的設置線程池大小。

要想合理的配置線程池的大小，首先得分析任務的特性，可以從以下幾個角度分析：

1. 任務的性質：CPU密集型任務、IO密集型任務、混合型任務。

2. 任務的優先級：高、中、低。

3. 任務的執行時間：長、中、短。

4. 任務的依賴性：是否依賴其他系統資源，如數據庫連接等。

性質不同的任務可以交給不同規模的線程池執行。

對於不同性質的任務來說，CPU密集型任務應配置儘可能小的線程，如配置CPU個數+1的線程數，IO密集型任務應配置儘可能多的線程，因爲IO操作不佔用CPU，不要讓CPU閒下來，應加大線程數量，如配置兩倍CPU個數+1，而對於混合型的任務，如果可以拆分，拆分成IO密集型和CPU密集型分別處理，前提是兩者運行的時間是差不多的，如果處理時間相差很大，則沒必要拆分了。

若任務對其他系統資源有依賴，如某個任務依賴數據庫的連接返回的結果，這時候等待的時間越長，則CPU空閒的時間越長，那麼線程數量應設置得越大，才能更好的利用CPU。

當然具體合理線程池值大小，需要結合系統實際情況，在大量的嘗試下比較才能得出，以上只是前人總結的規律。

最佳線程數目 = （（線程等待時間+線程CPU時間）/線程CPU時間）* CPU數目

比如平均每個線程CPU運行時間爲0.5s，而線程等待時間（非CPU運行時間，比如IO）爲1.5s，CPU核心數爲8，那麼根據上面這個公式估算得到：((0.5+1.5)/0.5)*8=32。這個公式進一步轉化爲：

最佳線程數目 = （線程等待時間與線程CPU時間之比 + 1）* CPU數目

可以得出一個結論：
線程等待時間所佔比例越高，需要越多線程。線程CPU時間所佔比例越高，需要越少線程。
以上公式與之前的CPU和IO密集型任務設置線程數基本吻合。

CPU密集型時，任務可以少配置線程數，大概和機器的cpu核數相當，這樣可以使得每個線程都在執行任務

IO密集型時，大部分線程都阻塞，故需要多配置線程數，2*cpu核數

操作系統之名稱解釋：

某些進程花費了絕大多數時間在計算上，而其他則在等待I/O上花費了大多是時間，

前者稱爲計算密集型（CPU密集型）computer-bound，後者稱爲I/O密集型，I/O-bound。

併發-線程池原理分析

併發包

(屏障)CyclicBarrier

(計數信號量)Semaphore

併發隊列

阻塞隊列與非阻塞隊

BlockingQueue

使用BlockingQueue模擬生產者與消費者

線程池

什麼是線程池

線程池作用

線程池的分類

ThreadPoolExecutor

線程池四種創建方式

newCachedThreadPool

newFixedThreadPool

newScheduledThreadPool

newSingleThreadExecutor

線程池原理剖析

自定義線程線程池

合理配置線程池

CPU密集

IO密集

微服務實踐k8s&dapr開發部署實驗（2）狀態管理

Win10 LTSC 2019 安裝後的一些步驟

Python 潮流週刊#52：Python 處理 Excel 的資源

手寫SpringIOC 實現原理-註解版本-手寫@Service和@Resource

互聯網高併發解決方案01-基於Hystrix實現服務隔離與降級

併發-線程池原理分析

併發-多線程之間實現通訊

進階-第106_es生產集羣版本升級之基於索引重建策略進行1.x到5.x的跨多個大版本的升級

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結