併發包

(計數器)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("111");
	q.offer("碼雲");
	q.offer("333");
	q.offer("張傑");
	q.offer("艾姐");
	//從頭獲取元素,刪除該元素
	System.out.println(q.poll());
	//從頭獲取元素,不刪除該元素
	System.out.println(q.peek());
	//獲取總長度
	System.out.println(q.size());

BlockingQueue

阻塞隊列（BlockingQueue）是一個支持兩個附加操作的隊列。這兩個附加的操作是：
在隊列爲空時，獲取元素的線程會等待隊列變爲非空。
當隊列滿時，存儲元素的線程會等待隊列可用。
阻塞隊列常用於生產者和消費者的場景，生產者是往隊列裏添加元素的線程，消費者是從隊列裏拿元素的線程。阻塞隊列就是生產者存放元素的容器，而消費者也只從容器裏拿元素。
BlockingQueue即阻塞隊列，從阻塞這個詞可以看出，在某些情況下對阻塞隊列的訪問可能會造成阻塞。被阻塞的情況主要有如下兩種：

當隊列滿了的時候進行入隊列操作
當隊列空了的時候進行出隊列操作
因此，當一個線程試圖對一個已經滿了的隊列進行入隊列操作時，它將會被阻塞，除非有另一個線程做了出隊列操作；同樣，當一個線程試圖對一個空隊列進行出隊列操作時，它將會被阻塞，除非有另一個線程進行了入隊列操作。
在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.add("張軍");
	// 添加阻塞隊列
	arrays.offer("張三", 1, TimeUnit.SECONDS);

LinkedBlockingQueue

LinkedBlockingQueue阻塞隊列大小的配置是可選的，如果我們初始化時指定一個大小，它就是有邊界的，如果不指定，它就是無邊界的。說是無邊界，其實是採用了默認大小爲Integer.MAX_VALUE的容量。它的內部實現是一個鏈表。
和ArrayBlockingQueue一樣，LinkedBlockingQueue 也是以先進先出的方式存儲數據，最新插入的對象是尾部，最新移出的對象是頭部。下面是一個初始化和使LinkedBlockingQueue的例子：

LinkedBlockingQueue linkedBlockingQueue = new LinkedBlockingQueue(3);
linkedBlockingQueue.add("張三");
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上，這種加速主要就是利用了被浪費掉的阻塞時間。

接着上一篇探討線程池留下的尾巴，如何合理的設置線程池大小。
要想合理的配置線程池的大小，首先得分析任務的特性，可以從以下幾個角度分析：

任務的性質：CPU密集型任務、IO密集型任務、混合型任務。
任務的優先級：高、中、低。
任務的執行時間：長、中、短。
任務的依賴性：是否依賴其他系統資源，如數據庫連接等。
性質不同的任務可以交給不同規模的線程池執行。
對於不同性質的任務來說，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。

Java線程池原理分析

併發包