java线程池_Java多线程并发：线程基本方法+线程池原理+阻塞队列原理技术分享...
線程基本方法有哪些？
線程相關的基本方法有 wait，notify，notifyAll，sleep，join，yield 等。
線程等待(wait)
調用該方法的線程進入 WAITING 狀態，只有等待另外線程的通知或被中斷才會返回，需要注意的是調用 wait()方法后，會釋放對象的鎖。因此，wait 方法一般用在同步方法或同步代碼塊中。
線程睡眠(sleep)
sleep 導致當前線程休眠，與 wait 方法不同的是 sleep 不會釋放當前占有的鎖,sleep(long)會導致線程進入 TIMED-WATING 狀態，而 wait()方法會導致當前線程進入 WATING 狀態。
線程讓步(yield)
yield 會使當前線程讓出 CPU 執行時間片，與其他線程一起重新競爭 CPU 時間片。一般情況下，優先級高的線程有更大的可能性成功競爭得到 CPU 時間片，但這又不是絕對的，有的操作系統對線程優先級并不敏感。
線程中斷(interrupt)
中斷一個線程，其本意是給這個線程一個通知信號，會影響這個線程內部的一個中斷標識位。這個線程本身并不會因此而改變狀態(如阻塞，終止等)。
1. 調用 interrupt()方法并不會中斷一個正在運行的線程。也就是說處于 Running 狀態的線程并不會因為被中斷而被終止，僅僅改變了內部維護的中斷標識位而已。
2. 若調用 sleep()而使線程處于 TIMED-WATING 狀態，這時調用 interrupt()方法，會拋出InterruptedException,從而使線程提前結束 TIMED-WATING 狀態。
3. 許多聲明拋出 InterruptedException 的方法(如 Thread.sleep(long mills 方法))，拋出異常前，都會清除中斷標識位，所以拋出異常后，調用 isInterrupted()方法將會返回 false。
4. 中斷狀態是線程固有的一個標識位，可以通過此標識位安全的終止線程。比如,你想終止一個線程 thread 的時候，可以調用 thread.interrupt()方法，在線程的 run 方法內部可以根據 thread.isInterrupted()的值來優雅的終止線程。
Join 等待其他線程終止
join() 方法，等待其他線程終止，在當前線程中調用一個線程的 join() 方法，則當前線程轉為阻塞
狀態，回到另一個線程結束，當前線程再由阻塞狀態變為就緒狀態，等待 cpu 的寵幸。
為什么要用 join()方法？
很多情況下，主線程生成并啟動了子線程，需要用到子線程返回的結果，也就是需要主線程需要在子線程結束后再結束，這時候就要用到 join() 方法。
System.out.println(Thread.currentThread().getName() + "線程運行開始!");
Thread6 thread1 = new Thread6();
thread1.setName("線程 B");
thread1.join();
System.out.println("這時 thread1 執行完畢之后才能執行主線程");
線程喚醒(notify)
Object 類中的 notify() 方法，喚醒在此對象監視器上等待的單個線程，如果所有線程都在此對象上等待，則會選擇喚醒其中一個線程，選擇是任意的，并在對實現做出決定時發生，線程通過調用其中一個 wait() 方法，在對象的監視器上等待，直到當前的線程放棄此對象上的鎖定，才能繼續執行被喚醒的線程，被喚醒的線程將以常規方式與在該對象上主動同步的其他所有線程進行競爭。類似的方法還有 notifyAll() ，喚醒再次監視器上等待的所有線程。
其他方法：
1. sleep()：強迫一個線程睡眠Ｎ毫秒。
2. isAlive()： 判斷一個線程是否存活。
3. join()： 等待線程終止。
4. activeCount()： 程序中活躍的線程數。
5. enumerate()： 枚舉程序中的線程。
6. currentThread()： 得到當前線程。
7. isDaemon()： 一個線程是否為守護線程。
8. setDaemon()： 設置一個線程為守護線程。(用戶線程和守護線程的區別在于，是否等待主線程依賴于主線程結束而結束)
9. setName()： 為線程設置一個名稱。
10. wait()： 強迫一個線程等待。
11. notify()： 通知一個線程繼續運行。
12. setPriority()： 設置一個線程的優先級。
13. getPriority():：獲得一個線程的優先級。
線程上下文切換
巧妙地利用了時間片輪轉的方式, CPU 給每個任務都服務一定的時間，然后把當前任務的狀態保存下來，在加載下一任務的狀態后，繼續服務下一任務，任務的狀態保存及再加載, 這段過程就叫做上下文切換。時間片輪轉的方式使多個任務在同一顆 CPU 上執行變成了可能。
進程
(有時候也稱做任務)是指一個程序運行的實例。在 Linux 系統中，線程就是能并行運行并且與他們的父進程(創建他們的進程)共享同一地址空間(一段內存區域)和其他資源的輕量級的進程。
上下文
是指某一時間點 CPU 寄存器和程序計數器的內容。
寄存器
是 CPU 內部的數量較少但是速度很快的內存(與之對應的是 CPU 外部相對較慢的 RAM 主內存)。寄存器通過對常用值(通常是運算的中間值)的快速訪問來提高計算機程序運行的速度。
程序計數器
是一個專用的寄存器，用于表明指令序列中 CPU 正在執行的位置，存的值為正在執行的指令的位置或者下一個將要被執行的指令的位置，具體依賴于特定的系統。
PCB-“切換楨”
上下文切換可以認為是內核(操作系統的核心)在 CPU 上對于進程(包括線程)進行切換，上下文切換過程中的信息是保存在進程控制塊(PCB, process control block)中的。PCB 還經常被稱作“切換楨”(switchframe)。信息會一直保存到 CPU 的內存中，直到他們被再次使用。
上下文切換的活動：
1. 掛起一個進程，將這個進程在 CPU 中的狀態(上下文)存儲于內存中的某處。
2. 在內存中檢索下一個進程的上下文并將其在 CPU 的寄存器中恢復。
3. 跳轉到程序計數器所指向的位置(即跳轉到進程被中斷時的代碼行)，以恢復該進程在程序中。
引起線程上下文切換的原因
1. 當前執行任務的時間片用完之后，系統 CPU 正常調度下一個任務；
2. 當前執行任務碰到 IO 阻塞，調度器將此任務掛起，繼續下一任務；
3. 多個任務搶占鎖資源，當前任務沒有搶到鎖資源，被調度器掛起，繼續下一任務；
4. 用戶代碼掛起當前任務，讓出 CPU 時間；
5. 硬件中斷；
同步鎖與死鎖
同步鎖
當多個線程同時訪問同一個數據時，很容易出現問題。為了避免這種情況出現，我們要保證線程同步互斥，就是指并發執行的多個線程，在同一時間內只允許一個線程訪問共享數據。 Java 中可以使用 synchronized 關鍵字來取得一個對象的同步鎖。
死鎖
何為死鎖，就是多個線程同時被阻塞，它們中的一個或者全部都在等待某個資源被釋放。
線程池原理
線程池做的工作主要是控制運行的線程的數量，處理過程中將任務放入隊列，然后在線程創建后啟動這些任務，如果線程數量超過了最大數量超出數量的線程排隊等候，等其它線程執行完畢，再從隊列中取出任務來執行。他的主要特點為：線程復用；控制最大并發數；管理線程。
線程復用
每一個 Thread 的類都有一個 start 方法。 當調用 start 啟動線程時 Java 虛擬機會調用該類的 run方法。 那么該類的 run() 方法中就是調用了 Runnable 對象的 run() 方法。 我們可以繼承重寫Thread 類，在其 start 方法中添加不斷循環調用傳遞過來的 Runnable 對象。 這就是線程池的實現原理。循環方法中不斷獲取 Runnable 是用 Queue 實現的，在獲取下一個 Runnable 之前可以是阻塞的。
線程池的組成
一般的線程池主要分為以下 4 個組成部分：
1. 線程池管理器：用于創建并管理線程池
2. 工作線程：線程池中的線程
3. 任務接口：每個任務必須實現的接口，用于工作線程調度其運行
4. 任務隊列：用于存放待處理的任務，提供一種緩沖機制
Java 中的線程池是通過 Executor 框架實現的，該框架中用到了 Executor，Executors，ExecutorService，ThreadPoolExecutor ，Callable 和 Future、FutureTask 這幾個類。
ThreadPoolExecutor 的構造方法如下：
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize, long keepAliveTime,
TimeUnit unit, BlockingQueue workQueue) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), defaultHandler);
}
1. corePoolSize：指定了線程池中的線程數量。
2. maximumPoolSize：指定了線程池中的最大線程數量。
3. keepAliveTime：當前線程池數量超過 corePoolSize 時，多余的空閑線程的存活時間，即多次時間內會被銷毀。
4. unit：keepAliveTime 的單位。
5. workQueue：任務隊列，被提交但尚未被執行的任務。
6. threadFactory：線程工廠，用于創建線程，一般用默認的即可。
7. handler：拒絕策略，當任務太多來不及處理，如何拒絕任務。
拒絕策略
線程池中的線程已經用完了，無法繼續為新任務服務，同時，等待隊列也已經排滿了，再也塞不下新任務了。這時候我們就需要拒絕策略機制合理的處理這個問題。
JDK 內置的拒絕策略如下：
1. AbortPolicy ： 直接拋出異常，阻止系統正常運行。
2. CallerRunsPolicy ： 只要線程池未關閉，該策略直接在調用者線程中，運行當前被丟棄的任務。顯然這樣做不會真的丟棄任務，但是，任務提交線程的性能極有可能會急劇下降。
3. DiscardOldestPolicy ： 丟棄最老的一個請求，也就是即將被執行的一個任務，并嘗試再次提交當前任務。
4. DiscardPolicy ： 該策略默默地丟棄無法處理的任務，不予任何處理。如果允許任務丟失，這是最好的一種方案。
以上內置拒絕策略均實現了 RejectedExecutionHandler 接口，若以上策略仍無法滿足實際需要，完全可以自己擴展 RejectedExecutionHandler 接口。
Java 線程池工作過程
1. 線程池剛創建時，里面沒有一個線程。任務隊列是作為參數傳進來的。不過，就算隊列里面有任務，線程池也不會馬上執行它們。
2. 當調用 execute() 方法添加一個任務時，線程池會做如下判斷：
a) 如果正在運行的線程數量小于 corePoolSize，那么馬上創建線程運行這個任務；
b) 如果正在運行的線程數量大于或等于 corePoolSize，那么將這個任務放入隊列；
c) 如果這時候隊列滿了，而且正在運行的線程數量小于 maximumPoolSize，那么還是要創建非核心線程立刻運行這個任務；
d) 如果隊列滿了，而且正在運行的線程數量大于或等于 maximumPoolSize，那么線程池會拋出異常 RejectExecutionException。
3. 當一個線程完成任務時，它會從隊列中取下一個任務來執行。
4. 當一個線程無事可做，超過一定的時間(keepAliveTime)時，線程池會判斷，如果當前運行的線程數大于 corePoolSize，那么這個線程就被停掉。所以線程池的所有任務完成后，它最終會收縮到 corePoolSize 的大小。
JAVA 阻塞隊列原理
阻塞隊列，關鍵字是阻塞，先理解阻塞的含義，在阻塞隊列中，線程阻塞有這樣的兩種情況：
1. 當隊列中沒有數據的情況下，消費者端的所有線程都會被自動阻塞(掛起)，直到有數據放入隊列。
2. 當隊列中填滿數據的情況下，生產者端的所有線程都會被自動阻塞(掛起)，直到隊列中有空的位置，線程被自動喚醒。
阻塞隊列的主要方法
? 拋出異常：拋出一個異常；
? 特殊值：返回一個特殊值(null 或 false,視情況而定)
? 則塞：在成功操作之前，一直阻塞線程
? 超時：放棄前只在最大的時間內阻塞
插入操作：
1：public abstract boolean add(E paramE)：將指定元素插入此隊列中(如果立即可行且不會違反容量限制)，成功時返回 true，如果當前沒有可用的空間，則拋出 IllegalStateException。如果該元素是 NULL，則會拋出 NullPointerException 異常。
2：public abstract boolean offer(E paramE)：將指定元素插入此隊列中(如果立即可行且不會違反容量限制)，成功時返回 true，如果當前沒有可用的空間，則返回 false。
3：public abstract void put(E paramE) throws InterruptedException： 將指定元素插入此隊列中，將等待可用的空間(如果有必要)
public void put(E paramE) throws InterruptedException {
checkNotNull(paramE);
ReentrantLock localReentrantLock = this.lock;
localReentrantLock.lockInterruptibly();
try {
while (this.count == this.items.length)
this.notFull.await();//如果隊列滿了，則線程阻塞等待
enqueue(paramE);
ocalReentrantLock.unlock();
} finally {
localReentrantLock.unlock();
}
}
4：offer(E o, long timeout, TimeUnit unit)：可以設定等待的時間，如果在指定的時間內，還不能往隊列中加入 BlockingQueue，則返回失敗。
獲取數據操作：
1：poll(time):取走 BlockingQueue 里排在首位的對象,若不能立即取出,則可以等 time 參數規定的時間,取不到時返回 null;
2：poll(long timeout, TimeUnit unit)：從 BlockingQueue 取出一個隊首的對象，如果在指定時間內，隊列一旦有數據可取，則立即返回隊列中的數據。否則直到時間超時還沒有數據可取，返回失敗。
3：take():取走 BlockingQueue 里排在首位的對象,若 BlockingQueue 為空,阻斷進入等待狀態直到 BlockingQueue 有新的數據被加入。
4.drainTo():一次性從 BlockingQueue 獲取所有可用的數據對象(還可以指定獲取數據的個數)，通過該方法，可以提升獲取數據效率；不需要多次分批加鎖或釋放鎖。
Java 中的阻塞隊列
1. ArrayBlockingQueue ：由數組結構組成的有界阻塞隊列。
2. LinkedBlockingQueue ：由鏈表結構組成的有界阻塞隊列。
3. PriorityBlockingQueue ：支持優先級排序的無界阻塞隊列。
4. DelayQueue：使用優先級隊列實現的無界阻塞隊列。
5. SynchronousQueue：不存儲元素的阻塞隊列。
6. LinkedTransferQueue：由鏈表結構組成的無界阻塞隊列。
7. LinkedBlockingDeque：由鏈表結構組成的雙向阻塞隊列
ArrayBlockingQueue(公平、非公平)
用數組實現的有界阻塞隊列。此隊列按照先進先出(FIFO)的原則對元素進行排序。默認情況下不保證訪問者公平的訪問隊列，所謂公平訪問隊列是指阻塞的所有生產者線程或消費者線程，當隊列可用時，可以按照阻塞的先后順序訪問隊列，即先阻塞的生產者線程，可以先往隊列里插入元素，先阻塞的消費者線程，可以先從隊列里獲取元素。通常情況下為了保證公平性會降低吞吐量。我們可以使用以下代碼創建一個公平的阻塞隊列：
ArrayBlockingQueue fairQueue = new ArrayBlockingQueue(1000,true);
LinkedBlockingQueue(兩個獨立鎖提高并發)
基于鏈表的阻塞隊列，同 ArrayListBlockingQueue 類似，此隊列按照先進先出(FIFO)的原則對元素進行排序。而 LinkedBlockingQueue 之所以能夠高效的處理并發數據，還因為其對于生產者端和消費者端分別采用了獨立的鎖來控制數據同步，這也意味著在高并發的情況下生產者和消費者可以并行地操作隊列中的數據，以此來提高整個隊列的并發性能。
LinkedBlockingQueue 會默認一個類似無限大小的容量(Integer.MAX_VALUE)。
PriorityBlockingQueue(compareTo 排序實現優先)
是一個支持優先級的無界隊列。默認情況下元素采取自然順序升序排列。可以自定義實現compareTo()方法來指定元素進行排序規則，或者初始化 PriorityBlockingQueue 時，指定構造參數 Comparator 來對元素進行排序。需要注意的是不能保證同優先級元素的順序。
DelayQueue(緩存失效、定時任務 )
是一個支持延時獲取元素的無界阻塞隊列。隊列使用 PriorityQueue 來實現。隊列中的元素必須實現 Delayed 接口，在創建元素時可以指定多久才能從隊列中獲取當前元素。只有在延遲期滿時才能從隊列中提取元素。我們可以將 DelayQueue 運用在以下應用場景：
1. 緩存系統的設計：可以用 DelayQueue 保存緩存元素的有效期，使用一個線程循環查詢DelayQueue，一旦能從 DelayQueue 中獲取元素時，表示緩存有效期到了。
2. 定時任務調度：使用 DelayQueue 保存當天將會執行的任務和執行時間，一旦從DelayQueue 中獲取到任務就開始執行，從比如 TimerQueue 就是使用 DelayQueue 實現的。
SynchronousQueue(不存儲數據、可用于傳遞數據)
是一個不存儲元素的阻塞隊列。每一個 put 操作必須等待一個 take 操作，否則不能繼續添加元素。
SynchronousQueue 可以看成是一個傳球手，負責把生產者線程處理的數據直接傳遞給消費者線程。隊列本身并不存儲任何元素，非常適合于傳遞性場景,比如在一個線程中使用的數據，傳遞給另 外 一 個 線 程 使 用 ， SynchronousQueue 的 吞 吐 量 高 于 LinkedBlockingQueue 和ArrayBlockingQueue。
LinkedTransferQueue
是 一 個 由 鏈 表 結 構 組 成 的 無 界 阻 塞 TransferQueue 隊 列 。 相 對 于 其 他 阻 塞 隊 列 ，LinkedTransferQueue 多了 tryTransfer 和 transfer 方法。
1. transfer 方法：如果當前有消費者正在等待接收元素(消費者使用 take()方法或帶時間限制的poll()方法時)，transfer 方法可以把生產者傳入的元素立刻 transfer(傳輸)給消費者。如果沒有消費者在等待接收元素，transfer 方法會將元素存放在隊列的 tail 節點，并等到該元素被消費者消費了才返回。
2. tryTransfer 方法。則是用來試探下生產者傳入的元素是否能直接傳給消費者。如果沒有消費者等待接收元素，則返回 false。和 transfer 方法的區別是 tryTransfer 方法無論消費者是否接收，方法立即返回。而 transfer 方法是必須等到消費者消費了才返回。
對于帶有時間限制的 tryTransfer(E e, long timeout, TimeUnit unit)方法，則是試圖把生產者傳入的元素直接傳給消費者，但是如果沒有消費者消費該元素則等待指定的時間再返回，如果超時還沒消費元素，則返回 false，如果在超時時間內消費了元素，則返回 true。
LinkedBlockingDeque
是一個由鏈表結構組成的雙向阻塞隊列。所謂雙向隊列指的你可以從隊列的兩端插入和移出元素。
雙端隊列因為多了一個操作隊列的入口，在多線程同時入隊時，也就減少了一半的競爭。相比其他的阻塞隊列，LinkedBlockingDeque 多了 addFirst，addLast，offerFirst，offerLast，peekFirst，peekLast 等方法，以 First 單詞結尾的方法，表示插入，獲取(peek)或移除雙端隊列的第一個元素。以 Last 單詞結尾的方法，表示插入，獲取或移除雙端隊列的最后一個元素。另外插入方法 add 等同于 addLast，移除方法 remove 等效于 removeFirst。但是 take 方法卻等同于 takeFirst，不知道是不是 Jdk 的 bug，使用時還是用帶有 First 和 Last 后綴的方法更清楚。
在初始化 LinkedBlockingDeque 時可以設置容量防止其過渡膨脹。另外雙向阻塞隊列可以運用在“工作竊取”模式中。
感謝大家支持！！
多多轉發文章關注小編不迷路~~~后續更出好文~
總結
以上是生活随笔為你收集整理的java线程池_Java多线程并发：线程基本方法+线程池原理+阻塞队列原理技术分享...的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： java发邮件_使用MATLAB自动发邮
- 下一篇： javaio流_万字长文+思维导图帮你梳