如何才能夠系統(tǒng)地學(xué)習(xí)Java并發(fā)技術(shù)？

Java并發(fā)編程一直是Java程序員必須懂但又是很難懂的技術(shù)內(nèi)容。

這里不僅僅是指使用簡單的多線程編程，或者使用juc的某個類。當(dāng)然這些都是并發(fā)編程的基本知識，除了使用這些工具以外，Java并發(fā)編程中涉及到的技術(shù)原理十分豐富。為了更好地把并發(fā)知識形成一個體系，也鑒于本人目前也沒有能力寫出這類文章，于是參考幾位并發(fā)編程方面專家的博客和書籍，做一個簡單的整理。

首先說一下我學(xué)習(xí)Java并發(fā)編程的一些方法吧。大概分為這幾步：

1、先學(xué)會最基礎(chǔ)的Java多線程編程，Thread類的使用，線程通信的一些方法等等。這部分內(nèi)容需要多寫一些demo去實踐。

2、接下來可以去使用一些JUC的API，比如concurrenthashmap，并發(fā)工具類，原子數(shù)據(jù)類型等工具，在學(xué)習(xí)這部分內(nèi)容的時候，你可以搭配一些介紹并發(fā)編程的書籍和博客一起看，書籍我當(dāng)時看的是《Java并發(fā)編程藝術(shù)》，我覺得略好于《Java并發(fā)編程實踐》。

我這個專欄里也整合了一些比較好的博客，所以大家可以不妨先看看。

3、接下來就要閱讀源碼了，讀源碼部分最主要的就是讀JUC包的源碼，比如concurrenthashmap，阻塞隊列，線程池等等，當(dāng)然，這些源碼自己讀起來會比較痛苦，所以建議跟著博客走。

4、走到這一步，你已經(jīng)理解了Java并發(fā)編程原理，并且可以熟練使用JUC，應(yīng)付面試已經(jīng)足夠了，剩下的事情就是真正把這些東西用到項目中去，我當(dāng)時在網(wǎng)易實習(xí)的時候就用到了JUC的一些內(nèi)容，不得不說還是挺有意思的。

?下面先介紹一下Java并發(fā)編程的一些主要內(nèi)容，我把它分六個部分，大家可以參考這幾個部分的內(nèi)容分別進行學(xué)習(xí)。

一：并發(fā)基礎(chǔ)和多線程

首先需要學(xué)習(xí)的就是并發(fā)的基礎(chǔ)知識，什么是并發(fā)，為什么要并發(fā)，多線程的概念，線程安全的概念等。

然后學(xué)會使用Java中的Thread或是其他線程實現(xiàn)方法，了解線程的狀態(tài)轉(zhuǎn)換，線程的方法，線程的通信方式等。

二：JMM內(nèi)存模型

任何語言最終都是運行在處理器上，JVM虛擬機為了給開發(fā)者一個一致的編程內(nèi)存模型，需要制定一套規(guī)則，這套規(guī)則可以在不同架構(gòu)的機器上有不同實現(xiàn)，并且向上為程序員提供統(tǒng)一的JMM內(nèi)存模型。

所以了解JMM內(nèi)存模型也是了解Java并發(fā)原理的一個重點，其中了解指令重排，內(nèi)存屏障，以及可見性原理尤為重要。

JMM只保證happens-before和as-if-serial規(guī)則，所以在多線程并發(fā)時，可能出現(xiàn)原子性，可見性以及有序性這三大問題。

下面的內(nèi)容則會講述Java是如何解決這三大問題的。

三：synchronized，volatile，final等關(guān)鍵字

對于并發(fā)的三大問題，volatile可以保證可見性，synchronized三種特性都可以保證。

synchronized是基于操作系統(tǒng)的mutex lock指令實現(xiàn)的，volatile和final則是根據(jù)JMM實現(xiàn)其內(nèi)存語義。

此處還要了解CAS操作，它不僅提供了類似volatile的內(nèi)存語義，并且保證操作原子性，因為它是由硬件實現(xiàn)的。

JUC中的Lock底層就是使用volatile加上CAS的方式實現(xiàn)的。synchronized也會嘗試用cas操作來優(yōu)化器重量級鎖。

了解這些關(guān)鍵字是很有必要的。

四：JUC包

在了解完上述內(nèi)容以后，就可以看看JUC的內(nèi)容了。

JUC提供了包括Lock，原子操作類，線程池，同步容器，工具類等內(nèi)容。

這些類的基礎(chǔ)都是AQS，所以了解AQS的原理是很重要的。

除此之外，還可以了解一下Fork/Join，以及JUC的常用場景，比如生產(chǎn)者消費者，阻塞隊列，以及讀寫容器等。

五：實踐

上述這些內(nèi)容，除了JMM部分的內(nèi)容比較不好實現(xiàn)之外，像是多線程基本使用，JUC的使用都可以在代碼實踐中更好地理解其原理。多嘗試一些場景，或者在網(wǎng)上找一些比較經(jīng)典的并發(fā)場景，或者參考別人的例子，在實踐中加深理解，還是很有必要的。

六：補充

由于很多Java新手可能對并發(fā)編程沒什么概念，在這里放一張不錯的思維導(dǎo)圖，該圖簡要地提幾個并發(fā)編程中比要重要的點，也是比較基本的點，在大致了解了這些基礎(chǔ)內(nèi)容以后，才能更好地開展后面詳細內(nèi)容的學(xué)習(xí)。

上面講到了學(xué)習(xí)路線，建議大家先跟著這個路線去看一看本專欄的一些博客，然后再來看下面這部分內(nèi)容，因為下面的內(nèi)容是我基于本專欄所有博客進行歸納和總結(jié)的，主要是方便記憶和復(fù)習(xí)，也可以讓你把知識點重新過一遍，如果你覺得我的總結(jié)不夠好，你也可以自己做總結(jié)，這也是一種不錯的學(xué)習(xí)方法，話不多少，咱們接著往下看。

這篇總結(jié)主要是基于我Java并發(fā)技術(shù)系列的文章而形成的的。主要是把重要的知識點用自己的話說了一遍，可能會有一些錯誤，還望見諒和指點。謝謝

更多詳細內(nèi)容可以查看我的專欄文章：Java并發(fā)技術(shù)指南

https://blog.csdn.net/column/details/21961.html

線程安全

1. 線程安全一般指多線程之間的操作結(jié)果不會因為線程調(diào)度的順序不同而發(fā)生改變。

互斥和同步

1. 互斥一般指資源的獨占訪問，同步則要求同步代碼中的代碼順序執(zhí)行，并且也是單線程獨占的。

JMM內(nèi)存模型

1. JVM中的內(nèi)存分區(qū)包括堆，棧，方法區(qū)等區(qū)域，這些內(nèi)存都是抽象出來的，實際上，系統(tǒng)中只有一個主內(nèi)存，但是為了方便Java多線程語義的實現(xiàn)，以及降低程序員編寫并發(fā)程序的難度，Java提出了JMM內(nèi)存模型，將內(nèi)存分為主內(nèi)存和工作內(nèi)存，工作內(nèi)存是線程獨占的，實際上它是一系列寄存器，編譯器優(yōu)化后的結(jié)果。

as-if-Serial，happens-before

1. as if serial語義提供單線程代碼的順序執(zhí)行保證，雖然他允許指令重排序，但是前提是指令重排序不會改變執(zhí)行結(jié)果。

volatile

1. volatile語義實際上是在代碼中插入一個內(nèi)存屏障，內(nèi)存屏障分為讀寫，寫讀，讀讀，寫寫四種，可以用來避免volatile變量的讀寫操作發(fā)生重排序，從而保證了volatile的語義，實際上，volatile修飾的變量強制要求線程寫時將數(shù)據(jù)從緩存刷入主內(nèi)存，讀時強制要求線程從主內(nèi)存中讀取，因此保證了它的可見性。
4. 而對于volatile修飾的64位類型數(shù)據(jù)，可以保證其原子性，不會因為指令重排序?qū)е乱粋€64位數(shù)據(jù)被分割成兩個32位數(shù)據(jù)來讀取。

synchronized和鎖優(yōu)化

1. synchronized是Java提供的同步標識，底層是操作系統(tǒng)的mutex lock調(diào)用，需要進行用戶態(tài)到內(nèi)核態(tài)的切換，開銷比較大。

2. synchronized經(jīng)過編譯后的匯編代碼會有monitor in和monitor out的字樣，用于標識進入監(jiān)視器模塊和退出監(jiān)視器模塊，

3. 監(jiān)視器模塊watcher會監(jiān)控同步代碼塊中的線程號，只允線程號正確的線程進入。

5. Java在synchronized關(guān)鍵字中進行了多次優(yōu)化。

7. 比如輕量級鎖優(yōu)化，使用鎖對象的對象頭做文章，當(dāng)一個線程需要獲得該對象鎖時，線程有一段空間叫做lock record，用于存儲對象頭的mask word，然后通過cas操作將對象頭的mask word改成指向線程中的lockrecord。

8. 如果成功了就是獲取到了鎖，否則就是發(fā)生了互斥。需要鎖粗化，膨脹為互斥鎖。

10. 偏向鎖，去掉了更多的同步措施，檢查mask word是否是可偏向狀態(tài)，然后檢查mask word中的線程id是否是自己的id，如果是則執(zhí)行同步代碼，如果不是則cas修改其id，如果修改失敗，則出現(xiàn)鎖爭用，偏向鎖失效，膨脹為輕量級鎖。

12. 自旋鎖，每個線程會被分配一段時間片，并且聽候cpu調(diào)度，如果發(fā)生線程阻塞需要切換的開銷，于是使用自旋鎖不需要阻塞，而是忙等循環(huán)，一獲取時間片就開始忙等，這樣的鎖就是自旋鎖，一般用于并發(fā)量比較小，又擔(dān)心切換開銷的場景。

CAS操作

1. CAS操作是通過硬件實現(xiàn)的原子操作，通過一條指令完成比較和賦值的操作，防止發(fā)生因指令重排導(dǎo)致的非原子操作，在Java中通過unsafe包可以直接使用，在Java原子類中使用cas操作來完成一系列原子數(shù)據(jù)類型的構(gòu)建，保證自加自減等依賴原值的操作不會出現(xiàn)并發(fā)問題。

3. cas操作也廣泛用在其他并發(fā)類中，通過循環(huán)cas操作可以完成線程安全的并發(fā)賦值，也可以通過一次cas操作來避免使用互斥鎖。

Lock類

AQS

1. AQS是Lock類的基石，他是一個抽象類，通過操作一個變量state來判斷線程鎖爭用的情況，通過一系列方法實現(xiàn)對該變量的修改。一般可以分為獨占鎖和互斥鎖。

3. AQS維護著一個CLH阻塞隊列，這個隊列主要用來存放阻塞等待鎖的線程節(jié)點?？梢钥醋鲆粋€鏈表。

一：獨占鎖

獨占鎖的state只有0和1兩種情況（如果是可重入鎖也可以把state一直往上加，這里不討論），state = 1時說明已經(jīng)有線程爭用到鎖。線程獲取鎖時一般是通過aqs的lock方法，如果state為0，首先嘗試cas修改state=1，成功返回，失敗時則加入阻塞隊列。 非公共鎖使用時，線程節(jié)點加入阻塞隊列時依然會嘗試cas獲取鎖，最后如果還是失敗再老老實實阻塞在隊列中。

獨占鎖還可以分為公平鎖和非公平鎖，公平鎖要求鎖節(jié)點依據(jù)順序加入阻塞隊列，通過判斷前置節(jié)點的狀態(tài)來改變后置節(jié)點的狀態(tài)，比如前置節(jié)點獲取鎖后，釋放鎖時會通知后置節(jié)點。

非公平鎖則不一定會按照隊列的節(jié)點順序來獲取鎖，如上面所說，會先嘗試cas操作，失敗再進入阻塞隊列。

二：共享鎖

共享鎖的state狀態(tài)可以是0到n。共享鎖維護的阻塞隊列和互斥鎖不太一樣，互斥鎖的節(jié)點釋放鎖后只會通知后置節(jié)點，而共享鎖獲取鎖后會通知所有的共享類型節(jié)點，讓他們都來獲取鎖。共享鎖用于countdownlatch工具類與cyliderbarrier等，可以很好地完成多線程的協(xié)調(diào)工作

鎖Lock和Conditon

Lock 鎖維護這兩個內(nèi)部類fairsync和unfairsync，都繼承自aqs，重寫了部分方法，實際上大部分方法還是aqs中的，Lock只是重新把AQS做了封裝，讓程序員更方便地使用Lock鎖。

和Lock鎖搭配使用的還有condition，由于Lock鎖只維護著一個阻塞隊列，有時候想分不同情況進行鎖阻塞和鎖通知怎么辦，原來我們一般會使用多個鎖對象，現(xiàn)在可以使用condition來完成這件事，比如線程A和線程B分別等待事件A和事件B，可以使用兩個condition分別維護兩個隊列，A放在A隊列，B放在B隊列，由于Lock和condition是綁定使用的，當(dāng)事件A觸發(fā)，線程A被喚醒，此時他會加入Lock自己的CLH隊列中進行鎖爭用，當(dāng)然也分為公平鎖和非公平鎖兩種，和上面的描述一樣。

Lock和condtion的組合廣泛用于JUC包中，比如生產(chǎn)者和消費者模型，再比如cyliderbarrier。

讀寫鎖

讀寫鎖也是Lock的一個子類，它在一個阻塞隊列中同時存儲讀線程節(jié)點和寫線程節(jié)點，讀寫鎖采用state的高16位和低16位分別代表獨占鎖和共享鎖的狀態(tài)，如果共享鎖的state > 0可以繼續(xù)獲取讀鎖，并且state-1，如果=0,則加入到阻塞隊列中，寫鎖節(jié)點和獨占鎖的處理一樣，因此一個隊列中會有兩種類型的節(jié)點，喚醒讀鎖節(jié)點時不會喚醒寫鎖節(jié)點，喚醒寫鎖節(jié)點時，則會喚醒后續(xù)的節(jié)點。

因此讀寫鎖一般用于讀多寫少的場景，寫鎖可以降級為讀鎖，就是在獲取到寫鎖的情況下可以再獲取讀鎖。

并發(fā)工具類

1 countdownlatch

countdownlatch主要通過AQS的共享模式實現(xiàn)，初始時設(shè)置state為N，N是countdownlatch初始化使用的size，每當(dāng)有一個線程執(zhí)行countdown，則state-1，state = 0之前所有線程阻塞在隊列中，當(dāng)state=0時喚醒隊頭節(jié)點，隊頭節(jié)點依次通知所有共享類型的節(jié)點，喚醒這些線程并執(zhí)行后面的代碼。

2 cycliderbarrier

cycliderbarrier主要通過lock和condition結(jié)合實現(xiàn)，首先設(shè)置state為屏障等待的線程數(shù)，在某個節(jié)點設(shè)置一個屏障，所有線程運行到此處會阻塞等待，其實就是等待在一個condition的隊列中，并且每當(dāng)有一個線程到達，state -=1 則當(dāng)所有線程到達時,state = 0，則喚醒condition隊列的所有結(jié)點，去執(zhí)行后面的代碼。

3 samphere

samphere也是使用AQS的共享模式實現(xiàn)的，與countlatch大同小異，不再贅述。

4 exchanger

exchanger就比較復(fù)雜了。使用exchanger時會開辟一段空間用來讓兩個線程進行交互操作，這個空間一般是一個?；蜿犃?，一個線程進來時先把數(shù)據(jù)放到這個格子里，然后阻塞等待其他線程跟他交換，如果另一個線程也進來了，就會讀取這個數(shù)據(jù)，并把自己的數(shù)據(jù)放到對方線程的格子里，然后雙雙離開。當(dāng)然使用棧和隊列的交互是不同的，使用棧的話匹配的是最晚進來的一個線程，隊列則相反。

原子數(shù)據(jù)類型

原子數(shù)據(jù)類型基本都是通過cas操作實現(xiàn)的，避免并發(fā)操作時出現(xiàn)的安全問題。

同步容器

同步容器主要就是concurrenthashmap了，在集合類中我已經(jīng)講了chm了，所以在這里簡單帶過，chm1.7通過分段鎖來實現(xiàn)鎖粗化，使用的死LLock鎖，而1.8則改用synchronized和cas的結(jié)合，性能更好一些。

還有就是concurrentlinkedlist，ConcurrentSkipListMap與CopyOnWriteArrayList。

第一個鏈表也是通過cas和synchronized實現(xiàn)。

而concurrentskiplistmap則是一個跳表，跳表分為很多層，每層都是一個鏈表，每個節(jié)點可以有向下和向右兩個指針，先通過向右指針進行索引，再通過向下指針細化搜索，這個的搜索效率是很高的，可以達到logn，并且它的實現(xiàn)難度也比較低。通過跳表存map就是把entry節(jié)點放在鏈表中了。查詢時按照跳表的查詢規(guī)則即可。

CopyOnWriteArrayList是一個寫時復(fù)制鏈表，查詢時不加鎖，而修改時則會復(fù)制一個新list進行操作，然后再賦值給原list即可。 適合讀多寫少的場景。

阻塞隊列

BlockingQueue 實現(xiàn)之 ArrayBlockingQueue

1. ArrayBlockingQueue其實就是數(shù)組實現(xiàn)的阻塞隊列，該阻塞隊列通過一個lock和兩個condition實現(xiàn)，一個condition負責(zé)從隊頭插入節(jié)點，一個condition負責(zé)隊尾讀取節(jié)點，通過這樣的方式可以實現(xiàn)生產(chǎn)者消費者模型。

BlockingQueue 實現(xiàn)之 LinkedBlockingQueue

<pre>

1. LinkedBlockingQueue是用鏈表實現(xiàn)的阻塞隊列，和arrayblockqueue有所區(qū)別，它支持實現(xiàn)為***隊列，并且它使用兩個lock和對應(yīng)的condition搭配使用，這是因為鏈表可以同時對頭部和尾部進行操作，而數(shù)組進行操作后可能還要執(zhí)行移位和擴容等操作。

2. 所以鏈表實現(xiàn)更靈活，讀寫分別用兩把鎖，效率更高。

BlockingQueue 實現(xiàn)之 SynchronousQueue

1. SynchronousQueue實現(xiàn)是一個不存儲數(shù)據(jù)的隊列，只會保留一個隊列用于保存線程節(jié)點。詳細請參加上面的exchanger實現(xiàn)類，它就是基于SynchronousQueue設(shè)計出來的工具類。

BlockingQueue 實現(xiàn)之 PriorityBlockingQueue

PriorityBlockingQueue

1. PriorityBlockingQueue是一個支持優(yōu)先級的***隊列。默認情況下元素采取自然順序排列，也可以通過比較器comparator來指定元素的排序規(guī)則。元素按照升序排列。

DelayQueue

1. DelayQueue是一個支持延時獲取元素的***阻塞隊列。隊列使用PriorityQueue來實現(xiàn)。隊列中的元素必須實現(xiàn)Delayed接口，在創(chuàng)建元素時可以指定多久才能從隊列中獲取當(dāng)前元素。只有在延遲期滿時才能從隊列中提取元素。我們可以將DelayQueue運用在以下應(yīng)用場景：

3. 緩存系統(tǒng)的設(shè)計：可以用DelayQueue保存緩存元素的有效期，使用一個線程循環(huán)查詢DelayQueue，一旦能從DelayQueue中獲取元素時，表示緩存有效期到了。

4. 定時任務(wù)調(diào)度。使用DelayQueue保存當(dāng)天將會執(zhí)行的任務(wù)和執(zhí)行時間，一旦從DelayQueue中獲取到任務(wù)就開始執(zhí)行，從比如TimerQueue就是使用DelayQueue實現(xiàn)的。

線程池

類圖

首先看看executor接口，只提供一個run方法，而他的一個子接口executorservice則提供了更多方法，比如提交任務(wù)，結(jié)束線程池等。

然后抽象類abstractexecutorservice提供了更多的實現(xiàn)了，最后我們最常使用的類ThreadPoolExecutor就是繼承它來的。

ThreadPoolExecutor可以傳入多種參數(shù)來自定義實現(xiàn)線程池。

而我們也可以使用Executors中的工廠方法來實例化常用的線程池。

常用線程池

比如newFixedThreadPool

newSingleThreadExecutor newCachedThreadPool

newScheduledThreadPool等等，這些線程池即可以使用submit提交有返回結(jié)果的callable和futuretask任務(wù)，通過一個future來接收結(jié)果，或者通過callable中的回調(diào)函數(shù)call來回寫執(zhí)行結(jié)果。也可以用execute執(zhí)行無返回值的runable任務(wù)。

在探討這些線程池的區(qū)別之前，先看看線程池的幾個核心概念。

1 任務(wù)隊列：線程池中維護了一個任務(wù)隊列，每當(dāng)向線程池提交任務(wù)時，任務(wù)加入隊列。

2 工作線程：也叫worker，從線程池中獲取任務(wù)并執(zhí)行，執(zhí)行后被回收或者保留，因情況而定。

3 核心線程數(shù)和最大線程數(shù)，核心線程數(shù)是線程池需要保持存活的線程數(shù)量，以便接收任務(wù)，最大線程數(shù)是能創(chuàng)建的線程數(shù)上限。

4 newFixedThreadPool可以設(shè)置固定的核心線程數(shù)和最大線程數(shù)，一個任務(wù)進來以后，就會開啟一個線程去執(zhí)行，并且這部分線程不會被回收，當(dāng)開啟的線程達到核心線程數(shù)時，則把任務(wù)先放進任務(wù)隊列。當(dāng)任務(wù)隊列已滿時，才會繼續(xù)開啟線程去處理，如果線程總數(shù)打到最大線程數(shù)限制，任務(wù)隊列又是滿的時候，會執(zhí)行對應(yīng)的拒絕策略。

5 拒絕策略一般有幾種常用的，比如丟棄任務(wù)，丟棄隊尾任務(wù)，回退給調(diào)用者執(zhí)行，或者拋出異常，也可以使用自定義的拒絕策略。

6 newSingleThreadExecutor是一個單線程執(zhí)行的線程池，只會維護一個線程，他也有任務(wù)隊列，當(dāng)任務(wù)隊列已滿并且線程數(shù)已經(jīng)是1個的時候，再提交任務(wù)就會執(zhí)行拒絕策略。

7 newCachedThreadPool比較特別，第一個任務(wù)進來時會開啟一個線程，而后如果線程還沒執(zhí)行完前面的任務(wù)又有新任務(wù)進來，就會再創(chuàng)建一個線程，這個線程池使用的是無容量的SynchronousQueue隊列，要求請求線程和接受線程匹配時才會完成任務(wù)執(zhí)行。 所以如果一直提交任務(wù)，而接受線程來不及處理的話，就會導(dǎo)致線程池不斷創(chuàng)建線程，導(dǎo)致cpu消耗很大。

8 ScheduledThreadPoolExecutor內(nèi)部使用的是delayqueue隊列，內(nèi)部是一個優(yōu)先級隊列priorityqueue，也就是一個堆。通過這個delayqueue可以知道線程調(diào)度的先后順序和執(zhí)行時間點。

Fork/Join框架

又稱工作竊取線程池。

我們在大學(xué)算法課本上，學(xué)過的一種基本算法就是：分治。其基本思路就是：把一個大的任務(wù)分成若干個子任務(wù)，這些子任務(wù)分別計算，最后再Merge出最終結(jié)果。這個過程通常都會用到遞歸。

而Fork/Join其實就是一種利用多線程來實現(xiàn)“分治算法”的并行框架。

另外一方面，可以把Fori/Join看作一個單機版的Map/Reduce，只不過這里的并行不是多臺機器并行計算，而是多個線程并行計算。

1 與ThreadPool的區(qū)別 通過上面例子，我們可以看出，它在使用上，和ThreadPool有共同的地方，也有區(qū)別點： （1） ThreadPool只有“外部任務(wù)”，也就是調(diào)用者放到隊列里的任務(wù)。 ForkJoinPool有“外部任務(wù)”，還有“內(nèi)部任務(wù)”，也就是任務(wù)自身在執(zhí)行過程中，分裂出”子任務(wù)“，遞歸，再次放入隊列。 （2）ForkJoinPool里面的任務(wù)通常有2類，RecusiveAction/RecusiveTask，這2個都是繼承自FutureTask。在使用的時候，重寫其compute算法。

2 工作竊取算法 上面提到，F(xiàn)orkJoinPool里有”外部任務(wù)“，也有“內(nèi)部任務(wù)”。其中外部任務(wù)，是放在ForkJoinPool的全局隊列里面，而每個Worker線程，也有一個自己的隊列，用于存放內(nèi)部任務(wù)。

3 竊取的基本思路就是：當(dāng)worker自己的任務(wù)隊列里面沒有任務(wù)時，就去scan別的線程的隊列，把別人的任務(wù)拿過來執(zhí)行