並發隊列
在並發隊列上JDK提供了兩套實現，一個是以ConcurrentLinkedQueue為代表的高性能隊列 非阻塞隊列，一個是以BlockingQueue接口為代表的阻塞隊列，無論哪種都繼承自Queue。
阻塞隊列與非阻塞隊
阻塞隊列與普通隊列的區別在於，當隊列是空的時，從隊列中獲取元素的操作將會被阻塞，或者當隊列是滿時，往隊列里添加元素的操作會被阻塞。試圖從空的阻塞隊列中獲取元素的線程將會被阻塞，直到其他的線程往空的隊列插入新的元素。同樣，試圖往已滿的阻塞隊列中添加新元素的線程同樣也會被阻塞，直到其他的線程使隊列重新變得空閑起來，如從隊列中移除一個或者多個元素，或者完全清空隊列.
1.ArrayDeque, （數組雙端隊列）
2.PriorityQueue, （優先級隊列）
3.ConcurrentLinkedQueue, （基於鏈表的並發隊列）
4.DelayQueue, （延期阻塞隊列）（阻塞隊列實現了BlockingQueue接口）
5.ArrayBlockingQueue, （基於數組的並發阻塞隊列）
6.LinkedBlockingQueue, （基於鏈表的FIFO阻塞隊列）
7.LinkedBlockingDeque, （基於鏈表的FIFO雙端阻塞隊列）
8.PriorityBlockingQueue, （帶優先級的無界阻塞隊列）
9.SynchronousQueue （並發同步阻塞隊列）
......
ConcurrentLinkedQueue
ConcurrentLinkedQueue: 是一個適用於高並發場景下的隊列，通過無鎖的方式，實現了高並發狀態下的高性能，通常ConcurrentLinkedQueue性能好於BlockingQueue.它是一個基於鏈接節點的無界線程安全隊列。該隊列的元素遵循先進先出的原則。頭是最先加入的，尾是最近加入的，該隊列不允許null元素。ConcurrentLinkedQueue重要方法:add和offer()都是加入元素的方法(由於是無界的隊列，在ConcurrentLinkedQueue中這倆個方法沒有區別)poll()和peek()都是取頭元素節點，區別在於前者會刪除元素，后者不會。
import java.util.concurrent.ConcurrentLinkedQueue;
public class Q001_ConcurrentLinkedQueueTest {
public static void main(String[] args) {
ConcurrentLinkedQueue<String> concurrentLinkedQueue = new ConcurrentLinkedQueue<String>();
concurrentLinkedQueue.offer("aaa");
concurrentLinkedQueue.offer("bbb");
//從隊列頭獲取元素，此方法沒有將元素移出隊列（peek--->偷看；看一眼；一瞥; ）
System.out.println(concurrentLinkedQueue.peek());
System.out.println(concurrentLinkedQueue.size());
//從隊列頭獲取元素，並將其移出隊列
System.out.println(concurrentLinkedQueue.poll());
System.out.println(concurrentLinkedQueue.size());
//繼續獲取
System.out.println(concurrentLinkedQueue.poll());
//此時隊列總沒有元素了 輸出為null
System.out.println(concurrentLinkedQueue.poll());
}
}
執行結果
aaa
2
aaa
1
bbb
null
BlockingQueue
阻塞隊列（
BlockingQueue）是一個支持兩個附加操作的隊列。這兩個附加的操作是：
- 在隊列為空時，獲取元素的線程會等待隊列變為非空。
- 當隊列滿時，存儲元素的線程會等待隊列可用。
- 因此，當一個線程試圖對一個已經滿了的隊列進行入隊列操作時，它將會被阻塞，除非有另一個線程做了出隊列操作；同樣，當一個線程試圖對一個空隊列進行出隊列操作時，它將會被阻塞，除非有另一個線程進行了入隊列操作。
- 在
Java中，BlockingQueue的接口位於java.util.concurrent包中(在Java5版本開始提供)，由上面介紹的阻塞隊列的特性可知，阻塞隊列是線程安全的。 - 在新增的
Concurrent包中，BlockingQueue很好的解決了多線程中，如何高效安全“傳輸”數據的問題。通過這些高效並且線程安全的隊列類，為我們快速搭建高質量的多線程程序帶來極大的便利。 - 阻塞隊列常用於生產者和消費者的場景，生產者是往隊列里添加元素的線程，消費者是從隊列里拿元素的線程。阻塞隊列就是生產者存放元素的容器，而消費者也只從容器里拿元素。
ArrayBlockingQueue
ArrayBlockingQueue是一個有邊界的阻塞隊列，它的內部實現是一個數組。有邊界的意思是它的容量是有限的，我們必須在其初始化的時候指定它的容量大小，容量大小一旦指定就不可改變。ArrayBlockingQueue是以先進先出的方式存儲數據，最新插入的對象是尾部，最新移出的對象是頭部。add()和offer()方法的區別是如果隊列滿的話，add會拋出異常，offer返回false
下面是一個初始化和使用
ArrayBlockingQueue的例子：
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;
/**
* 阻塞隊列
* 在隊列滿的時候，存儲元素的線程會等待隊列可用
* 隊列為空時， 讀取元素的線程 會等待隊列變為非空
*
* @author hao
*
*/
public class Q002_ArrayBlockingQueue {
public static void main(String[] args) throws InterruptedException {
ArrayBlockingQueue<Object> arrayBlockingQueue = new ArrayBlockingQueue<>(3);
arrayBlockingQueue.offer("小明");
arrayBlockingQueue.offer("小李");
arrayBlockingQueue.offer("笑話", 3, TimeUnit.SECONDS);
System.out.println("插入第四條開始");
System.out.println(arrayBlockingQueue.offer("校長", 3, TimeUnit.SECONDS));
System.out.println("插入第四條結束");
//前三個元素一次出列
System.out.println(arrayBlockingQueue.poll(3,TimeUnit.SECONDS));
System.out.println(arrayBlockingQueue.poll(3,TimeUnit.SECONDS));
System.out.println(arrayBlockingQueue.poll(3,TimeUnit.SECONDS));
System.out.println("此時隊列中元素"+arrayBlockingQueue.size());
//第四個元素出列(其實第四個元素沒有入列)
System.out.println(arrayBlockingQueue.poll(3,TimeUnit.SECONDS));
System.out.println("此時隊列中元素"+arrayBlockingQueue.size());
}
}
執行結果
插入第四條開始
false # 這里延時了三秒
插入第四條結束
小明
小李
笑話
此時隊列中元素0
null #這里延時了三秒
此時隊列中元素0
LinkedBlockingQueue
LinkedBlockingQueue阻塞隊列大小的配置是可選的，如果我們初始化時指定一個大小，它就是有邊界的，如果不指定，它就是無邊界的。說是無邊界，其實是采用了默認大小為Integer.MAX_VALUE的容量 。- 它的內部實現是一個鏈表。和
ArrayBlockingQueue一樣，LinkedBlockingQueue也是以先進先出的方式存儲數據，最新插入的對象是尾部，最新移出的對象是頭部。 - 下面是一個初始化和使
LinkedBlockingQueue的例子：
import java.util.concurrent.LinkedBlockingQueue;
public class Q003_LinkedBlockingQueue {
public static void main(String[] args) {
LinkedBlockingQueue<String> linkedBlockingQueue = new LinkedBlockingQueue<String>(2);
System.out.println(linkedBlockingQueue.offer("bbb"));
System.out.println(linkedBlockingQueue.offer("aaa"));
System.out.println(linkedBlockingQueue.offer("ccc")); //容量滿的時候返回false
//add 和 offer 都可以添加隊列 ，add會拋出異常 IllegalStateException
System.out.println(linkedBlockingQueue.add("ddd")); //容量滿時拋出異常
}
}
執行結果
true
true
false
Exception in thread "main" java.lang.IllegalStateException: Queue full
at java.util.AbstractQueue.add(AbstractQueue.java:98)
at com.hao.queue.Q003_LinkedBlockingQueue.main(Q003_LinkedBlockingQueue.java:12)
PriorityBlockingQueue
PriorityBlockingQueue是一個沒有邊界的隊列，它的排序規則和java.util.PriorityQueue一樣。需要注意，PriorityBlockingQueue中允許插入null對象。所有插入PriorityBlockingQueue的對象必須實現java.lang.Comparable接口，隊列優先級的排序規則就是按照我們對這個接口的實現來定義的。另外，我們可以從PriorityBlockingQueue獲得一個迭代器Iterator，但這個迭代器並不保證按照優先級順序進行迭代。
SynchronousQueue
SynchronousQueue隊列內部僅允許容納一個元素。當一個線程插入一個元素后會被阻塞，除非這個元素被另一個線程消費。
使用BlockingQueue模擬生產者與消費者
生產者
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
public 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;
}
}
消費者
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
public 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) {}
}
}
}
測試代碼
import com.hao.queuepc.ConsumerThread;
import com.hao.queuepc.ProducerThread;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
public class Test0005 {
public static void main(String[] args) {
BlockingQueue<String> blockingQueue = new LinkedBlockingQueue<String>();
ProducerThread producer = new ProducerThread(blockingQueue);
ConsumerThread consumer = new ConsumerThread(blockingQueue);
Thread p = new Thread(producer);
Thread c = new Thread(consumer);
p.start();
c.start();
try {
//10秒后停止生產者線程
Thread.sleep(10*1000);
producer.stop();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
執行結果
Thread-0生產者開始啟動....
Thread-1消費者開始啟動....
Thread-0,生產隊列1成功..
消費者獲取到隊列信息成功,data:1
Thread-0,生產隊列2成功..
消費者獲取到隊列信息成功,data:2
Thread-0,生產隊列3成功..
消費者獲取到隊列信息成功,data:3
Thread-0,生產隊列4成功..
消費者獲取到隊列信息成功,data:4
Thread-0,生產隊列5成功..
消費者獲取到隊列信息成功,data:5
Thread-0,生產隊列6成功..
消費者獲取到隊列信息成功,data:6
Thread-0,生產隊列7成功..
消費者獲取到隊列信息成功,data:7
Thread-0,生產隊列8成功..
消費者獲取到隊列信息成功,data:8
Thread-0,生產隊列9成功..
消費者獲取到隊列信息成功,data:9
Thread-0,生產隊列10成功..
消費者獲取到隊列信息成功,data:10
Thread-0,生產者線程停止...
消費者超過2秒時間未獲取到消息.
線程池
什么是線程池
Java中的線程池是運用場景最多的並發框架，幾乎所有需要異步或並發執行任務的程序都可以使用線程池。在開發過程中，合理地使用線程池能夠帶來3個好處。
- 降低資源消耗。通過重復利用已創建的線程降低線程創建和銷毀造成的消耗。
- 提高響應速度。當任務到達時，任務可以不需要等到線程創建就能立即執行。
- 提高線程的可管理性。線程是稀缺資源，如果無限制地創建，不僅會消耗系統資源，還會降低系統的穩定性，使用線程池可以進行統一分配、調優和監控。但是，要做到合理利用線程池，必須對其實現原理了如指掌。
線程池作用
- 線程池是為突然大量爆發的線程設計的，通過有限的幾個固定線程為大量的操作服務，減少了創建和銷毀線程所需的時間，從而提高效率。
- 如果一個線程的時間非常長，就沒必要用線程池了(不是不能作長時間操作，而是不宜。)，況且我們還不能控制線程池中線程的開始、掛起、和中止。
線程池四種創建方式
Java通過Executors（jdk1.5並發包）提供四種線程池，分別為：
newCachedThreadPool創建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閑線程，若無可回收，則新建線程。newFixedThreadPool創建一個定長線程池，可控制線程最大並發數，超出的線程會在隊列中等待。newScheduledThreadPool創建一個定長線程池，支持定時及周期性任務執行。newSingleThreadExecutor創建一個單線程化的線程池，它只會用唯一的工作線程來執行任務，保證所有任務按照指定順序(FIFO,LIFO, 優先級)執行。
newCachedThreadPool
創建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閑線程，若無可回收，則新建線程。示例代碼如下：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class P001_Cached {
public static void main(String[] args) {
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(2000);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
System.out.println(Thread.currentThread().getName() + ",i" + temp);
}
});
}
}
}
執行結果
pool-1-thread-2,i1
pool-1-thread-4,i3
pool-1-thread-3,i2
pool-1-thread-1,i0
pool-1-thread-5,i4
pool-1-thread-1,i5
pool-1-thread-4,i7
pool-1-thread-5,i6
pool-1-thread-3,i8
pool-1-thread-5,i9
總結: 線程池為無限大，當執行第二個任務時第一個任務已經完成，會復用執行第一個任務的線程，而不用每次新建線程。
newFixedThreadPool
創建一個定長線程池，可控制線程最大並發數，超出的線程會在隊列中等待。示例代碼如下：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class P002_Fixed {
public static void main(String[] args) {
ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
final int temp = i;
newFixedThreadPool.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "," + temp);
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}
}
}
執行結果
pool-1-thread-1,0
pool-1-thread-2,1
pool-1-thread-3,2
pool-1-thread-1,3
pool-1-thread-2,5
pool-1-thread-3,4
pool-1-thread-2,7
pool-1-thread-1,6
pool-1-thread-2,9
pool-1-thread-3,8
總結:因為線程池大小為3，每個任務輸出index后sleep 2秒，所以每兩秒打印3個數字。定長線程池的大小最好根據系統資源進行設置。如Runtime.getRuntime().availableProcessors()
newScheduledThreadPool
創建一個定長線程池，支持定時及周期性任務執行。延遲執行示例代碼如下：
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class P003_Scheduled {
public static void main(String[] args) {
ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(3);
for (int i = 0; i < 10; i++) {
final int temp = i;
newScheduledThreadPool.schedule(new Runnable() {
public void run() {
System.out.println(Thread.currentThread().getName() + ",i:" + temp);
}
}, 3, TimeUnit.SECONDS);
}
}
}
程序等待了3秒之后才輸入如下內容:
執行結果
pool-1-thread-1,i:0
pool-1-thread-2,i:1
pool-1-thread-3,i:2
pool-1-thread-2,i:4
pool-1-thread-1,i:3
pool-1-thread-2,i:6
pool-1-thread-3,i:5
pool-1-thread-2,i:8
pool-1-thread-1,i:7
pool-1-thread-3,i:9
newSingleThreadExecutor
創建一個單線程化的線程池，它只會用唯一的工作線程來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先級)執行。示例代碼如下：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class P004_Single {
public static void main(String[] args) {
ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
final int temp = i;
newSingleThreadExecutor.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + ",i:" + temp);
}
});
}
}
}
//注意: 結果依次輸出，相當於順序執行各個任務。
執行結果
pool-1-thread-1,i:0
pool-1-thread-1,i:1
pool-1-thread-1,i:2
pool-1-thread-1,i:3
pool-1-thread-1,i:4
pool-1-thread-1,i:5
pool-1-thread-1,i:6
pool-1-thread-1,i:7
pool-1-thread-1,i:8
pool-1-thread-1,i:9
ThreadPoolExecutor
Java是天生就支持並發的語言，支持並發意味着多線程，線程的頻繁創建在高並發及大數據量是非常消耗資源的，因為Java提供了線程池。在jdk1.5以前的版本中，線程池的使用是及其簡陋的，但是在JDK1.5后，有了很大的改善。jdk1.5之后加入了java.util.concurrent包，java.util.concurrent包的加入給予開發人員開發並發程序以及解決並發問題很大的幫助。
這里主要介紹下並發包下的Executor接口，Executor是 JDK1.5 時發布的
Executor框架的最頂層實現是ThreadPoolExecutor類，Executors工廠類中提供的newScheduledThreadPool、newFixedThreadPool、newCachedThreadPool方法其實也只是ThreadPoolExecutor的構造函數參數不同而已。通過傳入不同的參數，就可以構造出適用於不同應用場景下的線程池，ThreadPoolExecutor構造方中的幾個參數如下：
corePoolSize： 核心池的大小。 當有任務來之后，就會創建一個線程去執行任務，當線程池中的線程數目達到corePoolSize后，就會把到達的任務放到緩存隊列當中
maximumPoolSize： 線程池最大線程數，它表示在線程池中最多能創建多少個線程；
keepAliveTime： 表示線程沒有任務執行時最多保持多久時間會終止。
unit： 參數keepAliveTime的時間單位，有7種取值，在TimeUnit類中有7種靜態屬性。
workQueue: 阻塞隊列 BlockingQueue<Runnable>，當核心線程池滿的時候會放入阻塞隊列中進行等待
線程池原理剖析
提交一個任務到線程池中，線程池的處理流程如下：
- 判斷線程池里的核心線程是否都在執行任務，如果不是（核心線程空閑或者還有核心線程沒有被創建）則創建一個新的工作線程來執行任務。如果核心線程都在執行任務，則進入下個流程。
- 線程池判斷工作隊列是否已滿，如果工作隊列沒有滿，則將新提交的任務存儲在這個工作隊列里。如果工作隊列滿了，則進入下個流程。
- 判斷線程池里的線程（這里比較的是最大線程數）是否都處於工作狀態，如果沒有，則創建一個新的工作線程來執行任務。如果已經滿了，則交給飽和策略來處理這個任務。
自定義線程線程池
如果當前線程池中的線程數目小於corePoolSize，則每來一個任務，就會創建一個線程去執行這個任務；
如果當前線程池中的線程數目>=corePoolSize，則每來一個任務，會嘗試將其添加到任務緩存隊列當中，若添加成功，則該任務會等待空閑線程將其取出去執行；
若添加失敗（一般來說是任務緩存隊列已滿），則會嘗試創建新的線程去執行這個任務；
如果隊列已經滿了，則在總線程數不大於maximumPoolSize的前提下，則創建新的線程如果當前線程池中的線程數目達到maximumPoolSize，則會采取任務拒絕策略進行處理；
如果線程池中的線程數量大於 corePoolSize時，如果某線程空閑時間超過keepAliveTime，線程將被終止，直至線程池中的線程數目不大於corePoolSize；如果允許為核心池中的線程設置存活時間，那么核心池中的線程空閑時間超過keepAliveTime，線程也會被終止。
示例代碼
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class P005_ThreadPoolExecutorTest {
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);
}
}
執行結果
Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task com.hao.pool.TaskThred@33909752 rejected from java.util.concurrent.ThreadPoolExecutor@55f96302[Running, pool size = 2, active threads = 1, queued tasks = 0, completed tasks = 4]
at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2063)
at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:830)
at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1379)
at com.hao.pool.P005_ThreadPoolExecutorTest.main(P005_ThreadPoolExecutorTest.java:13)
pool-1-thread-2任務5
pool-1-thread-2任務2
pool-1-thread-2任務3
pool-1-thread-2任務4
pool-1-thread-1任務1
合理配置線程池
CPU密集
CPU密集的意思是該任務需要大量的運算，而沒有阻塞，CPU一直全速運行。
CPU密集任務只有在真正的多核CPU上才可能得到加速(通過多線程)，而在單核CPU上，無論你開幾個模擬的多線程，該任務都不可能得到加速，因為CPU總的運算能力就那些。
IO密集
IO密集型，即該任務需要大量的IO，即大量的阻塞。在單線程上運行IO密集型的任務會導致浪費大量的CPU運算能力浪費在等待。所以在IO密集型任務中使用多線程可以大大的加速程序運行，這種加速主要就是利用了被浪費掉的阻塞時間。
如何合理的設置線程池大小。
要想合理的配置線程池的大小，首先得分析任務的特性，可以從以下幾個角度分析：
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。