Java多線程分類中寫了21篇多線程的文章，21篇文章的內容很多，個人認為，學習，內容越多、越雜的知識，越需要進行深刻的總結，這樣才能記憶深刻，將知識變成自己的。這篇文章主要是對多線程的問題進行總結的，因此羅列了40個多線程的問題。
這些多線程的問題，有些來源於各大網站、有些來源於自己的思考。可能有些問題網上有、可能有些問題對應的答案也有、也可能有些各位網友也都看過，但是本文寫作的重心就是所有的問題都會按照自己的理解回答一遍，不會去看網上的答案，因此可能有些問題講的不對，能指正的希望大家不吝指教。
悲觀鎖
在關系數據庫管理系統里，悲觀並發控制（又名“悲觀鎖”，Pessimistic Concurrency Control，縮寫“PCC”）是一種並發控制的方法。它可以阻止一個事務以影響其他用戶的方式來修改數據。如果一個事務執行的操作都某行數據應用了鎖，那只有當這個事務把鎖釋放，其他事務才能夠執行與該鎖沖突的操作。
悲觀並發控制主要用於數據爭用激烈的環境，以及發生並發沖突時使用鎖保護數據的成本要低於回滾事務的成本的環境中。
悲觀鎖，正如其名，它指的是對數據被外界（包括本系統當前的其他事務，以及來自外部系統的事務處理）修改持保守態度(悲觀)，因此，在整個數據處理過程中，將數據處於鎖定狀態。 悲觀鎖的實現，往往依靠數據庫提供的鎖機制 （也只有數據庫層提供的鎖機制才能真正保證數據訪問的排他性，否則，即使在本系統中實現了加鎖機制，也無法保證外部系統不會修改數據）
在數據庫中，悲觀鎖的流程如下：
在對任意記錄進行修改前，先嘗試為該記錄加上排他鎖（exclusive locking）。
如果加鎖失敗，說明該記錄正在被修改，那么當前查詢可能要等待或者拋出異常。 具體響應方式由開發者根據實際需要決定。
如果成功加鎖，那么就可以對記錄做修改，事務完成后就會解鎖了。
其間如果有其他對該記錄做修改或加排他鎖的操作，都會等待我們解鎖或直接拋出異常。
MySQL InnoDB中使用悲觀鎖
要使用悲觀鎖，我們必須關閉mysql數據庫的自動提交屬性，因為MySQL默認使用autocommit模式，也就是說，當你執行一個更新操作后，MySQL會立刻將結果進行提交。
set autocommit=0;
//0.開始事務 begin;/begin work;/start transaction; (三者選一就可以) //1.查詢出商品信息 select status from t_goods where id=1 for update; //2.根據商品信息生成訂單 insert into t_orders (id,goods_id) values (null,1); //3.修改商品status為2 update t_goods set status=2; //4.提交事務 commit;/commit work;上面的查詢語句中，我們使用了select…for update的方式，這樣就通過開啟排他鎖的方式實現了悲觀鎖。此時在t_goods表中，id為1的 那條數據就被我們鎖定了，其它的事務必須等本次事務提交之后才能執行。這樣我們可以保證當前的數據不會被其它事務修改。
上面我們提到，使用
select…for update會把數據給鎖住，不過我們需要注意一些鎖的級別，MySQL InnoDB默認行級鎖。行級鎖都是基於索引的，如果一條SQL語句用不到索引是不會使用行級鎖的，會使用表級鎖把整張表鎖住，這點需要注意。
優點與不足
悲觀並發控制實際上是“先取鎖再訪問”的保守策略，為數據處理的安全提供了保證。但是在效率方面，處理加鎖的機制會讓數據庫產生額外的開銷，還有增加產生死鎖的機會；另外，在只讀型事務處理中由於不會產生沖突，也沒必要使用鎖，這樣做只能增加系統負載；還有會降低了並行性，一個事務如果鎖定了某行數據，其他事務就必須等待該事務處理完才可以處理那行數
樂觀鎖
在關系數據庫管理系統里，樂觀並發控制（又名“樂觀鎖”，Optimistic Concurrency Control，縮寫“OCC”）是一種並發控制的方法。它假設多用戶並發的事務在處理時不會彼此互相影響，各事務能夠在不產生鎖的情況下處理各自影響的那部分數據。在提交數據更新之前，每個事務會先檢查在該事務讀取數據后，有沒有其他事務又修改了該數據。如果其他事務有更新的話，正在提交的事務會進行回滾。樂觀事務控制最早是由孔祥重（H.T.Kung）教授提出。
樂觀鎖（ Optimistic Locking ） 相對悲觀鎖而言，樂觀鎖假設認為數據一般情況下不會造成沖突，所以在數據進行提交更新的時候，才會正式對數據的沖突與否進行檢測，如果發現沖突了，則讓返回用戶錯誤的信息，讓用戶決定如何去做。
相對於悲觀鎖，在對數據庫進行處理的時候，樂觀鎖並不會使用數據庫提供的鎖機制。一般的實現樂觀鎖的方式就是記錄數據版本。
數據版本,為數據增加的一個版本標識。當讀取數據時，將版本標識的值一同讀出，數據每更新一次，同時對版本標識進行更新。當我們提交更新的時候，判斷數據庫表對應記錄的當前版本信息與第一次取出來的版本標識進行比對，如果數據庫表當前版本號與第一次取出來的版本標識值相等，則予以更新，否則認為是過期數據。
實現數據版本有兩種方式，第一種是使用版本號，第二種是使用時間戳。
使用版本號實現樂觀鎖
使用版本號時，可以在數據初始化時指定一個版本號，每次對數據的更新操作都對版本號執行+1操作。並判斷當前版本號是不是該數據的最新的版本號。
1.查詢出商品信息 select (status,status,version) from t_goods where id=#{id} 2.根據商品信息生成訂單 3.修改商品status為2 update t_goods set status=2,version=version+1 where id=#{id} and version=#{version};優點與不足
樂觀並發控制相信事務之間的數據競爭(data race)的概率是比較小的，因此盡可能直接做下去，直到提交的時候才去鎖定，所以不會產生任何鎖和死鎖。但如果直接簡單這么做，還是有可能會遇到不可預期的結果，例如兩個事務都讀取了數據庫的某一行，經過修改以后寫回數據庫，這時就遇到了問題。
六、Java內存模型
堆 存放 對象和數組, 是GC主要操作的區域 由於堆是動態分配內存. 堆存取效率低於棧.
虛擬機棧 存放基本數據類型 和對象的引用.線程. 棧中數據可以共享.
方法區 存放常量、靜態變量 ,編譯后的代碼
本地方法棧 虛擬機使用的本地服務
40個問題匯總
1、多線程有什么用？
一個可能在很多人看來很扯淡的一個問題：我會用多線程就好了，還管它有什么用？在我看來，這個回答更扯淡。所謂”知其然知其所以然”，”會用”只是”知其然”，”為什么用”才是”知其所以然”，只有達到”知其然知其所以然”的程度才可以說是把一個知識點運用自如。OK，下面說說我對這個問題的看法：
（1）發揮多核CPU的優勢
隨着工業的進步，現在的筆記本、台式機乃至商用的應用服務器至少也都是雙核的，4核、8核甚至16核的也都不少見，如果是單線程的程序，那么在雙核CPU上就浪費了50%，在4核CPU上就浪費了75%。單核CPU上所謂的”多線程”那是假的多線程，同一時間處理器只會處理一段邏輯，只不過線程之間切換得比較快，看着像多個線程”同時”運行罷了。多核CPU上的多線程才是真正的多線程，它能讓你的多段邏輯同時工作，多線程，可以真正發揮出多核CPU的優勢來，達到充分利用CPU的目的。
（2）防止阻塞
從程序運行效率的角度來看，單核CPU不但不會發揮出多線程的優勢，反而會因為在單核CPU上運行多線程導致線程上下文的切換，而降低程序整體的效率。但是單核CPU我們還是要應用多線程，就是為了防止阻塞。試想，如果單核CPU使用單線程，那么只要這個線程阻塞了，比方說遠程讀取某個數據吧，對端遲遲未返回又沒有設置超時時間，那么你的整個程序在數據返回回來之前就停止運行了。多線程可以防止這個問題，多條線程同時運行，哪怕一條線程的代碼執行讀取數據阻塞，也不會影響其它任務的執行。
（3）便於建模
這是另外一個沒有這么明顯的優點了。假設有一個大的任務A，單線程編程，那么就要考慮很多，建立整個程序模型比較麻煩。但是如果把這個大的任務A分解成幾個小任務，任務B、任務C、任務D，分別建立程序模型，並通過多線程分別運行這幾個任務，那就簡單很多了。
2、創建線程的方式
比較常見的一個問題了，一般就是兩種：
（1）繼承Thread類
（2）實現Runnable接口
至於哪個好，不用說肯定是后者好，因為實現接口的方式比繼承類的方式更靈活，也能減少程序之間的耦合度，面向接口編程也是設計模式6大原則的核心。
3、start()方法和run()方法的區別
只有調用了start()方法，才會表現出多線程的特性，不同線程的run()方法里面的代碼交替執行。如果只是調用run()方法，那么代碼還是同步執行的，必須等待一個線程的run()方法里面的代碼全部執行完畢之后，另外一個線程才可以執行其run()方法里面的代碼。
只有調用了start方法后 jvm才會在開啟的線程中運行run()
6、volatile關鍵字的作用
一個非常重要的問題，是每個學習、應用多線程的Java程序員都必須掌握的。理解volatile關鍵字的作用的前提是要理解Java內存模型，這里就不講Java內存模型了，可以參見第31點，volatile關鍵字的作用主要有兩個：
當我們使用volatile關鍵字去修飾變量的時候，所以線程都會直接讀取該變量並且不緩存它。這就確保了線程讀取到的變量是同內存中是一致的。
（1）多線程主要圍繞可見性和原子性兩個特性而展開，使用volatile關鍵字修飾的變量，保證了其在多線程之間的可見性，即每次讀取到volatile變量，一定是最新的數據
（2）代碼底層執行不像我們看到的高級語言—-Java程序這么簡單，它的執行是Java代碼–>字節碼–>根據字節碼執行對應的C/C++代碼–>C/C++代碼被編譯成匯編語言–>和硬件電路交互，現實中，為了獲取更好的性能JVM可能會對指令進行重排序，多線程下可能會出現一些意想不到的問題。使用volatile則會對禁止語義重排序，當然這也一定程度上降低了代碼執行效率
從實踐角度而言，volatile的一個重要作用就是和CAS結合，保證了原子性，詳細的可以參見java.util.concurrent.atomic包下的類，比如AtomicInteger。
7、什么是線程安全
又是一個理論的問題，各式各樣的答案有很多，我給出一個個人認為解釋地最好的：如果你的代碼在多線程下執行和在單線程下執行永遠都能獲得一樣的結果，那么你的代碼就是線程安全的。
這個問題有值得一提的地方，就是線程安全也是有幾個級別的：
（1）不可變
像String、Integer、Long這些，都是final類型的類，任何一個線程都改變不了它們的值，要改變除非新創建一個，因此這些不可變對象不需要任何同步手段就可以直接在多線程環境下使用
（2）絕對線程安全
不管運行時環境如何，調用者都不需要額外的同步措施。要做到這一點通常需要付出許多額外的代價，Java中標注自己是線程安全的類，實際上絕大多數都不是線程安全的，不過絕對線程安全的類，Java中也有，比方說CopyOnWriteArrayList、CopyOnWriteArraySet
（3）相對線程安全
相對線程安全也就是我們通常意義上所說的線程安全，像Vector這種，add、remove方法都是原子操作，不會被打斷，但也僅限於此，如果有個線程在遍歷某個Vector、有個線程同時在add這個Vector，99%的情況下都會出現ConcurrentModificationException，也就是fail-fast機制。
（4）線程非安全
這個就沒什么好說的了，ArrayList、LinkedList、HashMap等都是線程非安全的類
10、如何在兩個線程之間共享數據
通過在線程之間共享對象就可以了，然后通過wait/notify/notifyAll、await/signal/signalAll進行喚起和等待，比方說阻塞隊列BlockingQueue就是為線程之間共享數據而設計的
11、sleep方法和wait方法有什么區別
這個問題常問，sleep方法和wait方法都可以用來放棄CPU一定的時間，不同點在於如果線程持有某個對象的監視器，sleep方法不會放棄這個對象的監視器，wait方法會放棄這個對象的監視器
12、生產者消費者模型的作用是什么
這個問題很理論，但是很重要：
（1）通過平衡生產者的生產能力和消費者的消費能力來提升整個系統的運行效率，這是生產者消費者模型最重要的作用
（2）解耦，這是生產者消費者模型附帶的作用，解耦意味着生產者和消費者之間的聯系少，聯系越少越可以獨自發展而不需要收到相互的制約
13、ThreadLocal有什么用
簡單說ThreadLocal就是一種以空間換時間的做法，在每個Thread里面維護了一個以開地址法實現的ThreadLocal.ThreadLocalMap，把數據進行隔離，數據不共享，自然就沒有線程安全方面的問題了
14、為什么wait()方法和notify()/notifyAll()方法要在同步塊中被調用
這是JDK強制的，wait()方法和notify()/notifyAll()方法在調用前都必須先獲得對象的鎖
15、wait()方法和notify()/notifyAll()方法在放棄對象監視器時有什么區別
wait()方法和notify()/notifyAll()方法在放棄對象監視器的時候的區別在於：wait()方法立即釋放對象監視器，notify()/notifyAll()方法則會等待線程剩余代碼執行完畢才會放棄對象監視器。
16、為什么要使用線程池
避免頻繁地創建和銷毀線程，達到線程對象的重用。另外，使用線程池還可以根據項目靈活地控制並發的數目。
17、怎么檢測一個線程是否持有對象監視器
我也是在網上看到一道多線程面試題才知道有方法可以判斷某個線程是否持有對象監視器：Thread類提供了一個holdsLock(Object obj)方法，當且僅當對象obj的監視器被某條線程持有的時候才會返回true，注意這是一個static方法，這意味着“某條線程”指的是當前線程。
18、synchronized和ReentrantLock的區別
synchronized是和if、else、for、while一樣的關鍵字，ReentrantLock是類，這是二者的本質區別。既然ReentrantLock是類，那么它就提供了比synchronized更多更靈活的特性，可以被繼承、可以有方法、可以有各種各樣的類變量，ReentrantLock比synchronized的擴展性體現在幾點上：
（1）ReentrantLock可以對獲取鎖的等待時間進行設置，這樣就避免了死鎖
（2）ReentrantLock可以獲取各種鎖的信息
（3）ReentrantLock可以靈活地實現多路通知
另外，二者的鎖機制其實也是不一樣的。ReentrantLock底層調用的是Unsafe的park方法加鎖，synchronized操作的應該是對象頭中mark word，這點我不能確定。
19、ConcurrentHashMap的並發度是什么
hashTable 11 擴容 2倍+1 hashmap 初始16 擴容2倍.
ConcurrentHashMap的並發度就是segment的大小，默認為16，這意味着最多同時可以有16條線程操作ConcurrentHashMap，這也是ConcurrentHashMap對Hashtable的最大優勢，任何情況下，Hashtable能同時有兩條線程獲取Hashtable中的數據嗎？
20、ReadWriteLock是什么
首先明確一下，不是說ReentrantLock不好，只是ReentrantLock某些時候有局限。如果使用ReentrantLock，可能本身是為了防止線程A在寫數據、線程B在讀數據造成的數據不一致，但這樣，如果線程C在讀數據、線程D也在讀數據，讀數據是不會改變數據的，沒有必要加鎖，但是還是加鎖了，降低了程序的性能。
因為這個，才誕生了讀寫鎖ReadWriteLock。ReadWriteLock是一個讀寫鎖接口，ReentrantReadWriteLock是ReadWriteLock接口的一個具體實現，實現了讀寫的分離，讀鎖是共享的，寫鎖是獨占的，讀和讀之間不會互斥，讀和寫、寫和讀、寫和寫之間才會互斥，提升了讀寫的性能。
22、Linux環境下如何查找哪個線程使用CPU最長
這是一個比較偏實踐的問題，這種問題我覺得挺有意義的。可以這么做：
（1）獲取項目的pid，jps或者ps -ef | grep java，這個前面有講過
（2）top -H -p pid，順序不能改變
這樣就可以打印出當前的項目，每條線程占用CPU時間的百分比。注意這里打出的是LWP，也就是操作系統原生線程的線程號，我筆記本山沒有部署Linux環境下的Java工程，因此沒有辦法截圖演示，網友朋友們如果公司是使用Linux環境部署項目的話，可以嘗試一下。
使用”top -H -p pid”+”jps pid”可以很容易地找到某條占用CPU高的線程的線程堆棧，從而定位占用CPU高的原因，一般是因為不當的代碼操作導致了死循環。
最后提一點，”top -H -p pid”打出來的LWP是十進制的，”jps pid”打出來的本地線程號是十六進制的，轉換一下，就能定位到占用CPU高的線程的當前線程堆棧了。
23、Java編程寫一個會導致死鎖的程序 --整理
第一次看到這個題目，覺得這是一個非常好的問題。很多人都知道死鎖是怎么一回事兒：線程A和線程B相互等待對方持有的鎖導致程序無限死循環下去。當然也僅限於此了，問一下怎么寫一個死鎖的程序就不知道了，這種情況說白了就是不懂什么是死鎖，懂一個理論就完事兒了，實踐中碰到死鎖的問題基本上是看不出來的。
真正理解什么是死鎖，這個問題其實不難，幾個步驟：
（1）兩個線程里面分別持有兩個Object對象：lock1和lock2。這兩個lock作為同步代碼塊的鎖；
（2）線程1的run()方法中同步代碼塊先獲取lock1的對象鎖，Thread.sleep(xxx)，時間不需要太多，50毫秒差不多了，然后接着獲取lock2的對象鎖。這么做主要是為了防止線程1啟動一下子就連續獲得了lock1和lock2兩個對象的對象鎖
（3）線程2的run)(方法中同步代碼塊先獲取lock2的對象鎖，接着獲取lock1的對象鎖，當然這時lock1的對象鎖已經被線程1鎖持有，線程2肯定是要等待線程1釋放lock1的對象鎖的
這樣，線程1″睡覺”睡完，線程2已經獲取了lock2的對象鎖了，線程1此時嘗試獲取lock2的對象鎖，便被阻塞，此時一個死鎖就形成了。代碼就不寫了，占的篇幅有點多，Java多線程7：死鎖這篇文章里面有，就是上面步驟的代碼實現。
24、怎么喚醒一個阻塞的線程
如果線程是因為調用了wait()、sleep()或者join()方法而導致的阻塞，可以中斷線程，並且通過拋出InterruptedException來喚醒它；如果線程遇到了IO阻塞，無能為力，因為IO是操作系統實現的，Java代碼並沒有辦法直接接觸到操作系統。
25、不可變對象對多線程有什么幫助
前面有提到過的一個問題，不可變對象保證了對象的內存可見性，對不可變對象的讀取不需要進行額外的同步手段，提升了代碼執行效率。
26、什么是多線程的上下文切換
多線程的上下文切換是指CPU控制權由一個已經正在運行的線程切換到另外一個就緒並等待獲取CPU執行權的線程的過程。
27、如果你提交任務時，線程池隊列已滿，這時會發生什么
如果你使用的LinkedBlockingQueue，也就是無界隊列的話，沒關系，繼續添加任務到阻塞隊列中等待執行，因為LinkedBlockingQueue可以近乎認為是一個無窮大的隊列，可以無限存放任務；如果你使用的是有界隊列比方說ArrayBlockingQueue的話，任務首先會被添加到ArrayBlockingQueue中，ArrayBlockingQueue滿了，則會使用拒絕策略RejectedExecutionHandler處理滿了的任務，默認是AbortPolicy。
28、Java中用到的線程調度算法是什么
搶占式。一個線程用完CPU之后，操作系統會根據線程優先級、線程飢餓情況等數據算出一個總的優先級並分配下一個時間片給某個線程執行。
32、什么是CAS; 樂觀鎖 --整理
CAS，全稱為Compare and Swap，即比較-替換。假設有三個操作數：內存值V、舊的預期值A、要修改的值B，當且僅當預期值A和內存值V相同時，才會將內存值修改為B並返回true，否則什么都不做並返回false。當然CAS一定要volatile變量配合，這樣才能保證每次拿到的變量是主內存中最新的那個值，否則舊的預期值A對某條線程來說，永遠是一個不會變的值A，只要某次CAS操作失敗，永遠都不可能成功。
33、什么是樂觀鎖和悲觀鎖
（1）樂觀鎖：就像它的名字一樣，對於並發間操作產生的線程安全問題持樂觀狀態，樂觀鎖認為競爭不總是會發生，因此它不需要持有鎖，將比較-替換這兩個動作作為一個原子操作嘗試去修改內存中的變量，如果失敗則表示發生沖突，那么就應該有相應的重試邏輯。
（2）悲觀鎖：還是像它的名字一樣，對於並發間操作產生的線程安全問題持悲觀狀態，悲觀鎖認為競爭總是會發生，因此每次對某資源進行操作時，都會持有一個獨占的鎖，就像synchronized，不管三七二十一，直接上了鎖就操作資源了。
34、什么是AQS
簡單說一下AQS，AQS全稱為AbstractQueuedSychronizer，翻譯過來應該是抽象隊列同步器。
如果說java.util.concurrent的基礎是CAS的話，那么AQS就是整個Java並發包的核心了，ReentrantLock、CountDownLatch、Semaphore等等都用到了它。AQS實際上以雙向隊列的形式連接所有的Entry，比方說ReentrantLock，所有等待的線程都被放在一個Entry中並連成雙向隊列，前面一個線程使用ReentrantLock好了，則雙向隊列實際上的第一個Entry開始運行。
AQS定義了對雙向隊列所有的操作，而只開放了tryLock和tryRelease方法給開發者使用，開發者可以根據自己的實現重寫tryLock和tryRelease方法，以實現自己的並發功能。
35、單例模式的線程安全性
老生常談的問題了，首先要說的是單例模式的線程安全意味着：某個類的實例在多線程環境下只會被創建一次出來。單例模式有很多種的寫法，我總結一下：
（1）餓漢式單例模式的寫法：線程安全
（2）懶漢式單例模式的寫法：非線程安全
（3）雙檢鎖單例模式的寫法：線程安全
36、