100道Java併發和多線程基礎面試題大集合（含解答），這波面試穩了~

# 前言

這篇文章主要是對多線程的問題進行總結的，所以羅列了100個多線程的問題。

這些多線程的問題來源於各大網站，可能有些問題網上有、可能有些問題對應的答案也有、也可能有些各位網友也都看過，可是本文寫做的重心就是全部的問題都會按照本身的理解回答一遍，不會去看網上的答案，所以可能有些問題講的不對，能指正的但願你們不吝指教。

# 100個問題彙總

一、多線程有什麼用？

一個可能在不少人看來很扯淡的一個問題：我會用多線程就行了，還管它有什麼用？在我看來，這個回答更扯淡。所謂"知其然知其因此然"，"會用"只是"知其然"，"爲何用"纔是"知其因此然"，只有達到"知其然知其因此然"的程度才能夠說是把一個知識點運用自如。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，分別創建程序模型，並經過多線程分別運行這幾個任務，那就簡單不少了。

二、建立線程的方式

比較常見的一個問題了，通常就是兩種：

（1）繼承Thread類

（2）實現Runnable接口

至於哪一個好，不用說確定是後者好，由於實現接口的方式比繼承類的方式更靈活，也能減小程序之間的耦合度，面向接口編程也是設計模式6大原則的核心。

三、start()方法和run()方法的區別

只有調用了start()方法，纔會表現出多線程的特性，不一樣線程的run()方法裏面的代碼交替執行。若是隻是調用run()方法，那麼代碼仍是同步執行的，必須等待一個線程的run()方法裏面的代碼所有執行完畢以後，另一個線程才能夠執行其run()方法裏面的代碼。

四、Runnable接口和Callable接口的區別

有點深的問題了，也看出一個Java程序員學習知識的廣度。

Runnable接口中的run()方法的返回值是void，它作的事情只是純粹地去執行run()方法中的代碼而已；Callable接口中的call()方法是有返回值的，是一個泛型，和Future、FutureTask配合能夠用來獲取異步執行的結果。

這實際上是頗有用的一個特性，由於多線程相比單線程更難、更復雜的一個重要緣由就是由於多線程充滿着未知性，某條線程是否執行了？某條線程執行了多久？某條線程執行的時候咱們指望的數據是否已經賦值完畢？沒法得知，咱們能作的只是等待這條多線程的任務執行完畢而已。而Callable+Future/FutureTask卻能夠獲取多線程運行的結果，能夠在等待時間太長沒獲取到須要的數據的狀況下取消該線程的任務，真的是很是有用。

五、CyclicBarrier和CountDownLatch的區別

兩個看上去有點像的類，都在java.util.concurrent下，均可以用來表示代碼運行到某個點上，兩者的區別在於：

（1）CyclicBarrier的某個線程運行到某個點上以後，該線程即中止運行，直到全部的線程都到達了這個點，全部線程才從新運行；CountDownLatch則不是，某線程運行到某個點上以後，只是給某個數值-1而已，該線程繼續運行

（2）CyclicBarrier只能喚起一個任務，CountDownLatch能夠喚起多個任務

（3）CyclicBarrier可重用，CountDownLatch不可重用，計數值爲0該CountDownLatch就不可再用了

六、volatile關鍵字的做用

一個很是重要的問題，是每一個學習、應用多線程的Java程序員都必須掌握的。理解volatile關鍵字的做用的前提是要理解Java內存模型，這裏就不講Java內存模型了，能夠參見第31點，volatile關鍵字的做用主要有兩個：

（1）多線程主要圍繞可見性和原子性兩個特性而展開，使用volatile關鍵字修飾的變量，保證了其在多線程之間的可見性，即每次讀取到volatile變量，必定是最新的數據

（2）代碼底層執行不像咱們看到的高級語言----Java程序這麼簡單，它的執行是Java代碼-->字節碼-->根據字節碼執行對應的C/C++代碼-->C/C++代碼被編譯成彙編語言-->和硬件電路交互，現實中，爲了獲取更好的性能JVM可能會對指令進行重排序，多線程下可能會出現一些意想不到的問題。使用volatile則會對禁止語義重排序，固然這也必定程度上下降了代碼執行效率

從實踐角度而言，volatile的一個重要做用就是和CAS結合，保證了原子性，詳細的能夠參見java.util.concurrent.atomic包下的類，好比AtomicInteger。

七、什麼是線程安全

又是一個理論的問題，各式各樣的答案有不少，我給出一個我的認爲解釋地最好的：若是你的代碼在多線程下執行和在單線程下執行永遠都能得到同樣的結果，那麼你的代碼就是線程安全的。

這個問題有值得一提的地方，就是線程安全也是有幾個級別的：

（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等都是線程非安全的類

八、Java中如何獲取到線程dump文件

死循環、死鎖、阻塞、頁面打開慢等問題，打線程dump是最好的解決問題的途徑。所謂線程dump也就是線程堆棧，獲取到線程堆棧有兩步：

（1）獲取到線程的pid，能夠經過使用jps命令，在Linux環境下還能夠使用ps -ef | grep java

（2）打印線程堆棧，能夠經過使用jstack pid命令，在Linux環境下還能夠使用kill -3 pid

另外提一點，Thread類提供了一個getStackTrace()方法也能夠用於獲取線程堆棧。這是一個實例方法，所以此方法是和具體線程實例綁定的，每次獲取獲取到的是具體某個線程當前運行的堆棧，

九、一個線程若是出現了運行時異常會怎麼樣

若是這個異常沒有被捕獲的話，這個線程就中止執行了。另外重要的一點是：若是這個線程持有某個某個對象的監視器，那麼這個對象監視器會被當即釋放

十、如何在兩個線程之間共享數據

經過在線程之間共享對象就能夠了，而後經過wait/notify/notifyAll、await/signal/signalAll進行喚起和等待，比方說阻塞隊列BlockingQueue就是爲線程之間共享數據而設計的

十一、sleep方法和wait方法有什麼區別

這個問題常問，sleep方法和wait方法均可以用來放棄CPU必定的時間，不一樣點在於若是線程持有某個對象的監視器，sleep方法不會放棄這個對象的監視器，wait方法會放棄這個對象的監視器

十二、生產者消費者模型的做用是什麼

這個問題很理論，可是很重要：

（1）經過平衡生產者的生產能力和消費者的消費能力來提高整個系統的運行效率，這是生產者消費者模型最重要的做用

（2）解耦，這是生產者消費者模型附帶的做用，解耦意味着生產者和消費者之間的聯繫少，聯繫越少越能夠獨自發展而不須要收到相互的制約

1三、ThreadLocal有什麼用

簡單說ThreadLocal就是一種以空間換時間的作法，在每一個Thread裏面維護了一個以開地址法實現的ThreadLocal.ThreadLocalMap，把數據進行隔離，數據不共享，天然就沒有線程安全方面的問題了

1四、爲何wait()方法和notify()/notifyAll()方法要在同步塊中被調用

這是JDK強制的，wait()方法和notify()/notifyAll()方法在調用前都必須先得到對象的鎖

1五、wait()方法和notify()/notifyAll()方法在放棄對象監視器時有什麼區別

wait()方法和notify()/notifyAll()方法在放棄對象監視器的時候的區別在於：

wait()方法當即釋放對象監視器，notify()/notifyAll()方法則會等待線程剩餘代碼執行完畢纔會放棄對象監視器。

1六、爲何要使用線程池

避免頻繁地建立和銷燬線程，達到線程對象的重用。另外，使用線程池還能夠根據項目靈活地控制併發的數目。

1七、怎麼檢測一個線程是否持有對象監視器

我也是在網上看到一道多線程面試題才知道有方法能夠判斷某個線程是否持有對象監視器：Thread類提供了一個holdsLock(Object obj)方法，當且僅當對象obj的監視器被某條線程持有的時候纔會返回true，注意這是一個static方法，這意味着"某條線程"指的是當前線程。

1八、synchronized和ReentrantLock的區別

synchronized是和if、else、for、while同樣的關鍵字，ReentrantLock是類，這是兩者的本質區別。既然ReentrantLock是類，那麼它就提供了比

synchronized更多更靈活的特性，能夠被繼承、能夠有方法、能夠有各類各樣的類變量，ReentrantLock比synchronized的擴展性體如今幾點上：

（1）ReentrantLock能夠對獲取鎖的等待時間進行設置，這樣就避免了死鎖

（2）ReentrantLock能夠獲取各類鎖的信息

（3）ReentrantLock能夠靈活地實現多路通知

另外，兩者的鎖機制其實也是不同的。ReentrantLock底層調用的是Unsafe的park方法加鎖，synchronized操做的應該是對象頭中mark word，這點我不能肯定。

1九、ConcurrentHashMap的併發度是什麼

ConcurrentHashMap的併發度就是segment的大小，默認爲16，這意味着最多同時能夠有16條線程操做ConcurrentHashMap，這也是ConcurrentHashMap對Hashtable的最大優點，任何狀況下，Hashtable能同時有兩條線程獲取Hashtable中的數據嗎？

20、ReadWriteLock是什麼

首先明確一下，不是說ReentrantLock很差，只是ReentrantLock某些時候有侷限。若是使用ReentrantLock，可能自己是爲了防止線程A在寫數據、線程B在讀數據形成的數據不一致，但這樣，若是線程C在讀數據、線程D也在讀數據，讀數據是不會改變數據的，沒有必要加鎖，可是仍是加鎖了，下降了程序的性能。

由於這個，才誕生了讀寫鎖ReadWriteLock。ReadWriteLock是一個讀寫鎖接口，ReentrantReadWriteLock是ReadWriteLock接口的一個具體實現，實現了讀寫的分離，讀鎖是共享的，寫鎖是獨佔的，讀和讀之間不會互斥，讀和寫、寫和讀、寫和寫之間纔會互斥，提高了讀寫的性能。

2一、FutureTask是什麼

這個其實前面有提到過，FutureTask表示一個異步運算的任務。FutureTask裏面能夠傳入一個Callable的具體實現類，能夠對這個異步運算的任務的結果進行等待獲取、判斷是否已經完成、取消任務等操做。固然，因爲FutureTask也是Runnable接口的實現類，因此FutureTask也能夠放入線程池中。

2二、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高的線程的當前線程堆棧了。

2三、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：死鎖這篇文章裏面有，就是上面步驟的代碼實現。

2四、怎麼喚醒一個阻塞的線程

若是線程是由於調用了wait()、sleep()或者join()方法而致使的阻塞，能夠中斷線程，而且經過拋出InterruptedException來喚醒它；若是線程遇到了IO阻塞，無能爲力，由於IO是操做系統實現的，Java代碼並無辦法直接接觸到操做系統。

2五、不可變對象對多線程有什麼幫助

前面有提到過的一個問題，不可變對象保證了對象的內存可見性，對不可變對象的讀取不須要進行額外的同步手段，提高了代碼執行效率。

2六、什麼是多線程的上下文切換

多線程的上下文切換是指CPU控制權由一個已經正在運行的線程切換到另一個就緒並等待獲取CPU執行權的線程的過程。

2七、若是你提交任務時，線程池隊列已滿，這時會發生什麼

這裏區分一下：

1. 若是使用的是***隊列LinkedBlockingQueue，也就是***隊列的話，不要緊，繼續添加任務到阻塞隊列中等待執行，由於LinkedBlockingQueue能夠近乎認爲是一個無窮大的隊列，能夠無限存聽任務

2. 若是使用的是有界隊列好比ArrayBlockingQueue，任務首先會被添加到ArrayBlockingQueue中，ArrayBlockingQueue滿了，會根據maximumPoolSize的值增長線程數量，若是增長了線程數量仍是處理不過來，ArrayBlockingQueue繼續滿，那麼則會使用拒絕策略RejectedExecutionHandler處理滿了的任務，默認是AbortPolicy

2八、Java中用到的線程調度算法是什麼

搶佔式。一個線程用完CPU以後，操做系統會根據線程優先級、線程飢餓狀況等數據算出一個總的優先級並分配下一個時間片給某個線程執行。

2九、Thread.sleep(0)的做用是什麼

這個問題和上面那個問題是相關的，我就連在一塊兒了。因爲Java採用搶佔式的線程調度算法，所以可能會出現某條線程經常獲取到CPU控制權的狀況，爲了讓某些優先級比較低的線程也能獲取到CPU控制權，能夠使用Thread.sleep(0)手動觸發一次操做系統分配時間片的操做，這也是平衡CPU控制權的一種操做。

30、什麼是自旋

不少synchronized裏面的代碼只是一些很簡單的代碼，執行時間很是快，此時等待的線程都加鎖多是一種不太值得的操做，由於線程阻塞涉及到用戶態和內核態切換的問題。既然synchronized裏面的代碼執行得很是快，不妨讓等待鎖的線程不要被阻塞，而是在synchronized的邊界作忙循環，這就是自旋。若是作了屢次忙循環發現尚未得到鎖，再阻塞，這樣多是一種更好的策略。

3一、什麼是Java內存模型

Java內存模型定義了一種多線程訪問Java內存的規範。Java內存模型要完整講不是這裏幾句話能說清楚的，我簡單總結一下Java內存模型的幾部份內容：

（1）Java內存模型將內存分爲了主內存和工做內存。類的狀態，也就是類之間共享的變量，是存儲在主內存中的，每次Java線程用到這些主內存中的變量的時候，會讀一次主內存中的變量，並讓這些內存在本身的工做內存中有一份拷貝，運行本身線程代碼的時候，用到這些變量，操做的都是本身工做內存中的那一份。在線程代碼執行完畢以後，會將最新的值更新到主內存中去

（2）定義了幾個原子操做，用於操做主內存和工做內存中的變量

（3）定義了volatile變量的使用規則

（4）happens-before，即先行發生原則，定義了操做A必然先行發生於操做B的一些規則，好比在同一個線程內控制流前面的代碼必定先行發生於控制流後面的代碼、一個釋放鎖unlock的動做必定先行發生於後面對於同一個鎖進行鎖定lock的動做等等，只要符合這些規則，則不須要額外作同步措施，若是某段代碼不符合全部的happens-before規則，則這段代碼必定是線程非安全的

3二、什麼是CAS

CAS，全稱爲Compare and Swap，即比較-替換。假設有三個操做數：內存值V、舊的預期值A、要修改的值B，當且僅當預期值A和內存值V相同時，纔會將內存值修改成B並返回true，不然什麼都不作並返回false。固然CAS必定要volatile變量配合，這樣才能保證每次拿到的變量是主內存中最新的那個值，不然舊的預期值A對某條線程來講，永遠是一個不會變的值A，只要某次CAS操做失敗，永遠都不可能成功。

3三、什麼是樂觀鎖和悲觀鎖

（1）樂觀鎖：就像它的名字同樣，對於併發間操做產生的線程安全問題持樂觀狀態，樂觀鎖認爲競爭不老是會發生，所以它不須要持有鎖，將比較-替換這兩個動做做爲一個原子操做嘗試去修改內存中的變量，若是失敗則表示發生衝突，那麼就應該有相應的重試邏輯。

（2）悲觀鎖：仍是像它的名字同樣，對於併發間操做產生的線程安全問題持悲觀狀態，悲觀鎖認爲競爭老是會發生，所以每次對某資源進行操做時，都會持有一個獨佔的鎖，就像synchronized，無論三七二十一，直接上了鎖就操做資源了。

3四、什麼是AQS

簡單說一下AQS，AQS全稱爲AbstractQueuedSychronizer，翻譯過來應該是抽象隊列同步器。

若是說java.util.concurrent的基礎是CAS的話，那麼AQS就是整個Java併發包的核心了，ReentrantLock、CountDownLatch、Semaphore等等都用到了它。AQS實際上以雙向隊列的形式鏈接全部的Entry，比方說ReentrantLock，全部等待的線程都被放在一個Entry中並連成雙向隊列，前面一個線程使用ReentrantLock好了，則雙向隊列實際上的第一個Entry開始運行。

AQS定義了對雙向隊列全部的操做，而只開放了tryLock和tryRelease方法給開發者使用，開發者能夠根據本身的實現重寫tryLock和tryRelease方法，以實現本身的併發功能。

3五、單例模式的線程安全性

老生常談的問題了，首先要說的是單例模式的線程安全意味着：某個類的實例在多線程環境下只會被建立一次出來。單例模式有不少種的寫法，我總結一下：

（1）餓漢式單例模式的寫法：線程安全

（2）懶漢式單例模式的寫法：非線程安全

（3）雙檢鎖單例模式的寫法：線程安全

3六、Semaphore有什麼做用

Semaphore就是一個信號量，它的做用是限制某段代碼塊的併發數。

Semaphore有一個構造函數，能夠傳入一個int型整數n，表示某段代碼最多隻有n個線程能夠訪問，若是超出了n，那麼請等待，等到某個線程執行完畢這段代碼塊，下一個線程再進入。由此能夠看出若是Semaphore構造函數中傳入的int型整數n=1，至關於變成了一個synchronized了。

3七、Hashtable的size()方法中明明只有一條語句"return count"，爲何還要作同步？

這是我以前的一個困惑，不知道你們有沒有想過這個問題。某個方法中若是有多條語句，而且都在操做同一個類變量，那麼在多線程環境下不加鎖，勢必會引起線程安全問題，這很好理解，可是size()方法明明只有一條語句，爲何還要加鎖？

關於這個問題，在慢慢地工做、學習中，有了理解，主要緣由有兩點：

（1）同一時間只能有一條線程執行固定類的同步方法，可是對於類的非同步方法，能夠多條線程同時訪問。因此，這樣就有問題了，可能線程A在執行Hashtable的put方法添加數據，線程B則能夠正常調用size()方法讀取Hashtable中當前元素的個數，那讀取到的值可能不是最新的，可能線程A添加了完了數據，可是沒有對size++，線程B就已經讀取size了，那麼對於線程B來講讀取到的size必定是不許確的。而給size()方法加了同步以後，意味着線程B調用size()方法只有在線程A調用put方法完畢以後才能夠調用，這樣就保證了線程安全性

（2）CPU執行代碼，執行的不是Java代碼，這點很關鍵，必定得記住。Java代碼最終是被翻譯成機器碼執行的，機器碼纔是真正能夠和硬件電路交互的代碼。即便你看到Java代碼只有一行，甚至你看到Java代碼編譯以後生成的字節碼也只有一行，也不意味着對於底層來講這句語句的操做只有一個。一句"return count"假設被翻譯成了三句彙編語句執行，一句彙編語句和其機器碼作對應，徹底可能執行完第一句，線程就切換了。

3八、線程類的構造方法、靜態塊是被哪一個線程調用的

這是一個很是刁鑽和狡猾的問題。請記住：線程類的構造方法、靜態塊是被new這個線程類所在的線程所調用的，而run方法裏面的代碼纔是被線程自身所調用的。

若是說上面的說法讓你感到困惑，那麼我舉個例子，假設Thread2中new了Thread1，main函數中new了Thread2，那麼：

（1）Thread2的構造方法、靜態塊是main線程調用的，Thread2的run()方法是Thread2本身調用的

（2）Thread1的構造方法、靜態塊是Thread2調用的，Thread1的run()方法是Thread1本身調用的

3九、同步方法和同步塊，哪一個是更好的選擇

同步塊，這意味着同步塊以外的代碼是異步執行的，這比同步整個方法更提高代碼的效率。請知道一條原則：同步的範圍越小越好。

藉着這一條，我額外提一點，雖然說同步的範圍越少越好，可是在Java虛擬機中仍是存在着一種叫作鎖粗化的優化方法，這種方法就是把同步範圍變大。這是有用的，比方說StringBuffer，它是一個線程安全的類，天然最經常使用的append()方法是一個同步方法，咱們寫代碼的時候會反覆append字符串，這意味着要進行反覆的加鎖->解鎖，這對性能不利，由於這意味着Java虛擬機在這條線程上要反覆地在內核態和用戶態之間進行切換，所以Java虛擬機會將屢次append方法調用的代碼進行一個鎖粗化的操做，將屢次的append的操做擴展到append方法的頭尾，變成一個大的同步塊，這樣就減小了加鎖-->解鎖的次數，有效地提高了代碼執行的效率。

40、高併發、任務執行時間短的業務怎樣使用線程池？併發不高、任務執行時間長的業務怎樣使用線程池？併發高、業務執行時間長的業務怎樣使用線程池？

這是我在併發編程網上看到的一個問題，把這個問題放在最後一個，但願每一個人都能看到而且思考一下，由於這個問題很是好、很是實際、很是專業。關於這個問題，我的見解是：

（1）高併發、任務執行時間短的業務，線程池線程數能夠設置爲CPU核數+1，減小線程上下文的切換

（2）併發不高、任務執行時間長的業務要區分開看：

　　a）假如是業務時間長集中在IO操做上，也就是IO密集型的任務，由於IO操做並不佔用CPU，因此不要讓全部的CPU閒下來，能夠加大線程池中的線程數目，讓CPU處理更多的業務

　　b）假如是業務時間長集中在計算操做上，也就是計算密集型任務，這個就沒辦法了，和（1）同樣吧，線程池中的線程數設置得少一些，減小線程上下文的切換

（3）併發高、業務執行時間長，解決這種類型任務的關鍵不在於線程池而在於總體架構的設計，看看這些業務裏面某些數據是否能作緩存是第一步，增長服務器是第二步，至於線程池的設置，設置參考（2）。

最後，業務執行時間長的問題，也可能須要分析一下，看看能不能使用中間件對任務進行拆分和解耦。

4一、爲何使用Executor框架？

每次執行任務建立線程 new Thread()比較消耗性能，建立一個線程是比較耗時、耗資源的。

調用 new Thread()建立的線程缺少管理，被稱爲野線程，並且能夠無限制的建立，線程之間的相互競爭會致使過多佔用系統資源而致使系統癱瘓，還有線程之間的頻繁交替也會消耗不少系統資源。

接使用new Thread() 啓動的線程不利於擴展，好比定時執行、按期執行、定時按期執行、線程中斷等都不便實現。

4二、在Java中Executor和Executors的區別？

Executors 工具類的不一樣方法按照咱們的需求建立了不一樣的線程池，來知足業務的需求。

Executor 接口對象能執行咱們的線程任務。ExecutorService接口繼承了Executor接口並進行了擴展，提供了更多的方法咱們能得到任務執行的狀態而且能夠獲取任務的返回值。

使用ThreadPoolExecutor 能夠建立自定義線程池。Future 表示異步計算的結果，他提供了檢查計算是否完成的方法，以等待計算的完成，並能夠使用get()方法獲取計算的結果。

4三、什麼是原子操做？在Java Concurrency API中有哪些原子類(atomic classes)？

原子操做（atomic operation）意爲」不可被中斷的一個或一系列操做」 。處理器使用基於對緩存加鎖或總線加鎖的方式來實現多處理器之間的原子操做。

在Java中能夠經過鎖和循環CAS的方式來實現原子操做。CAS操做——Compare & Set，或是 Compare & Swap，如今幾乎全部的CPU指令都支持CAS的原子操做。

原子操做是指一個不受其餘操做影響的操做任務單元。原子操做是在多線程環境下避免數據不一致必須的手段。

int++並非一個原子操做，因此當一個線程讀取它的值並加1時，另一個線程有可能會讀到以前的值，這就會引起錯誤。

爲了解決這個問題，必須保證增長操做是原子的，在JDK1.5以前咱們能夠使用同步技術來作到這一點。到JDK1.5，java.util.concurrent.atomic包提供了int和long類型的原子包裝類，它們能夠自動的保證對於他們的操做是原子的而且不須要使用同步。

java.util.concurrent這個包裏面提供了一組原子類。其基本的特性就是在多線程環境下，當有多個線程同時執行這些類的實例包含的方法時，具備排他性。

即當某個線程進入方法，執行其中的指令時，不會被其餘線程打斷，而別的線程就像自旋鎖同樣，一直等到該方法執行完成，才由JVM從等待隊列中選擇一個另外一個線程進入，這只是一種邏輯上的理解。

• 原子類：AtomicBoolean，AtomicInteger，AtomicLong，AtomicReference

• 原子數組：AtomicIntegerArray，AtomicLongArray，AtomicReferenceArray

• 原子屬性更新器：AtomicLongFieldUpdater，AtomicIntegerFieldUpdater，AtomicReferenceFieldUpdater

解決ABA問題的原子類：AtomicMarkableReference（經過引入一個boolean來反映中間有沒有變過），AtomicStampedReference（經過引入一個int來累加來反映中間有沒有變過）

4四、Java Concurrency API中的Lock接口(Lock interface)是什麼？對比同步它有什麼優點？

Lock接口比同步方法和同步塊提供了更具擴展性的鎖操做。他們容許更靈活的結構，能夠具備徹底不一樣的性質，而且能夠支持多個相關類的條件對象。

它的優點有：

• 能夠使鎖更公平

• 可讓線程嘗試獲取鎖，並在沒法獲取鎖的時候當即返回或者等待一段時間

• 能夠在不一樣的範圍，以不一樣的順序獲取和釋放鎖

總體上來講Lock是synchronized的擴展版，Lock提供了無條件的、可輪詢的(tryLock方法)、定時的(tryLock帶參方法)、可中斷的(lockInterruptibly)、可多條件隊列的(newCondition方法)鎖操做。

另外Lock的實現類基本都支持非公平鎖(默認)和公平鎖，synchronized只支持非公平鎖，固然，在大部分狀況下，非公平鎖是高效的選擇。

4五、什麼是Executors框架？

Executor框架是一個根據一組執行策略調用，調度，執行和控制的異步任務的框架。

無限制的建立線程會引發應用程序內存溢出。因此建立一個線程池是個更好的的解決方案，由於能夠限制線程的數量而且能夠回收再利用這些線程。利用Executors框架能夠很是方便的建立一個線程池。

4六、什麼是阻塞隊列？阻塞隊列的實現原理是什麼？如何使用阻塞隊列來實現生產者-消費者模型？

阻塞隊列（BlockingQueue）是一個支持兩個附加操做的隊列。

這兩個附加的操做是：在隊列爲空時，獲取元素的線程會等待隊列變爲非空。當隊列滿時，存儲元素的線程會等待隊列可用。

阻塞隊列經常使用於生產者和消費者的場景，生產者是往隊列裏添加元素的線程，消費者是從隊列裏拿元素的線程。阻塞隊列就是生產者存放元素的容器，而消費者也只從容器裏拿元素。

JDK7提供了7個阻塞隊列。分別是：

• ArrayBlockingQueue ：一個由數組結構組成的有界阻塞隊列。

• LinkedBlockingQueue ：一個由鏈表結構組成的有界阻塞隊列。

• PriorityBlockingQueue ：一個支持優先級排序的***阻塞隊列。

• DelayQueue：一個使用優先級隊列實現的***阻塞隊列。

• SynchronousQueue：一個不存儲元素的阻塞隊列。

• LinkedTransferQueue：一個由鏈表結構組成的***阻塞隊列。

• LinkedBlockingDeque：一個由鏈表結構組成的雙向阻塞隊列。

Java 5以前實現同步存取時，能夠使用普通的一個集合，而後在使用線程的協做和線程同步能夠實現生產者，消費者模式，主要的技術就是用好，wait ,notify,notifyAll,sychronized這些關鍵字。而在java 5以後，能夠使用阻塞隊列來實現，此方式大大簡少了代碼量，使得多線程編程更加容易，安全方面也有保障。

BlockingQueue接口是Queue的子接口，它的主要用途並非做爲容器，而是做爲線程同步的的工具，所以他具備一個很明顯的特性，當生產者線程試圖向BlockingQueue放入元素時，若是隊列已滿，則線程被阻塞，當消費者線程試圖從中取出一個元素時，若是隊列爲空，則該線程會被阻塞，正是由於它所具備這個特性，因此在程序中多個線程交替向BlockingQueue中放入元素，取出元素，它能夠很好的控制線程之間的通訊。

阻塞隊列使用最經典的場景就是socket客戶端數據的讀取和解析，讀取數據的線程不斷將數據放入隊列，而後解析線程不斷從隊列取數據解析。

4七、什麼是Callable和Future?

Callable接口相似於Runnable，從名字就能夠看出來了，可是Runnable不會返回結果，而且沒法拋出返回結果的異常，而Callable功能更強大一些，被線程執行後，能夠返回值，這個返回值能夠被Future拿到，也就是說，Future能夠拿到異步執行任務的返回值。能夠認爲是帶有回調的Runnable。

Future接口表示異步任務，是尚未完成的任務給出的將來結果。因此說Callable用於產生結果，Future用於獲取結果。

4八、什麼是FutureTask?使用ExecutorService啓動任務。

在Java併發程序中FutureTask表示一個能夠取消的異步運算。它有啓動和取消運算、查詢運算是否完成和取回運算結果等方法。只有當運算完成的時候結果才能取回，若是運算還沒有完成get方法將會阻塞。

一個FutureTask對象能夠對調用了Callable和Runnable的對象進行包裝，因爲FutureTask也是調用了Runnable接口因此它能夠提交給Executor來執行。

4九、什麼是併發容器的實現？

何爲同步容器：能夠簡單地理解爲經過synchronized來實現同步的容器，若是有多個線程調用同步容器的方法，它們將會串行執行。好比Vector，Hashtable，以及Collections.synchronizedSet，synchronizedList等方法返回的容器。

能夠經過查看Vector，Hashtable等這些同步容器的實現代碼，能夠看到這些容器實現線程安全的方式就是將它們的狀態封裝起來，並在須要同步的方法上加上關鍵字synchronized。

併發容器使用了與同步容器徹底不一樣的加鎖策略來提供更高的併發性和伸縮性，例如在ConcurrentHashMap中採用了一種粒度更細的加鎖機制，能夠稱爲分段鎖，在這種鎖機制下，容許任意數量的讀線程併發地訪問map，而且執行讀操做的線程和寫操做的線程也能夠併發的訪問map，同時容許必定數量的寫操做線程併發地修改map，因此它能夠在併發環境下實現更高的吞吐量。

50、多線程同步和互斥有幾種實現方法，都是什麼？

線程同步是指線程之間所具備的一種制約關係，一個線程的執行依賴另外一個線程的消息，當它沒有獲得另外一個線程的消息時應等待，直到消息到達時才被喚醒。

線程互斥是指對於共享的進程系統資源，在各單個線程訪問時的排它性。當有若干個線程都要使用某一共享資源時，任什麼時候刻最多隻容許一個線程去使用，其它要使用該資源的線程必須等待，直到佔用資源者釋放該資源。線程互斥能夠當作是一種特殊的線程同步。

線程間的同步方法大致可分爲兩類：用戶模式和內核模式。顧名思義，內核模式就是指利用系統內核對象的單一性來進行同步，使用時須要切換內核態與用戶態，而用戶模式就是不須要切換到內核態，只在用戶態完成操做。

用戶模式下的方法有：原子操做（例如一個單一的全局變量），臨界區。內核模式下的方法有：事件，信號量，互斥量。

5一、什麼是競爭條件？你怎樣發現和解決競爭？

當多個進程都企圖對共享數據進行某種處理，而最後的結果又取決於進程運行的順序時，則咱們認爲這發生了競爭條件（race condition）。

5二、爲何咱們調用start()方法時會執行run()方法，爲何咱們不能直接調用run()方法？

當你調用start()方法時你將建立新的線程，而且執行在run()方法裏的代碼。

可是若是你直接調用run()方法，它不會建立新的線程也不會執行調用線程的代碼，只會把run方法看成普通方法去執行。

5三、Java中你怎樣喚醒一個阻塞的線程？

在Java發展史上曾經使用suspend()、resume()方法對於線程進行阻塞喚醒，但隨之出現不少問題，比較典型的仍是死鎖問題。

解決方案能夠使用以對象爲目標的阻塞，即利用Object類的wait()和notify()方法實現線程阻塞。

首先，wait、notify方法是針對對象的，調用任意對象的wait()方法都將致使線程阻塞，阻塞的同時也將釋放該對象的鎖，相應地，調用任意對象的notify()方法則將隨機解除該對象阻塞的線程，但它須要從新獲取改對象的鎖，直到獲取成功才能往下執行；

其次，wait、notify方法必須在synchronized塊或方法中被調用，而且要保證同步塊或方法的鎖對象與調用wait、notify方法的對象是同一個，如此一來在調用wait以前當前線程就已經成功獲取某對象的鎖，執行wait阻塞後當前線程就將以前獲取的對象鎖釋放。

5四、在Java中CycliBarriar和CountdownLatch有什麼區別？

CyclicBarrier能夠重複使用，而CountdownLatch不能重複使用。

Java的concurrent包裏面的CountDownLatch其實能夠把它看做一個計數器，只不過這個計數器的操做是原子操做，同時只能有一個線程去操做這個計數器，也就是同時只能有一個線程去減這個計數器裏面的值。

你能夠向CountDownLatch對象設置一個初始的數字做爲計數值，任何調用這個對象上的await()方法都會阻塞，直到這個計數器的計數值被其餘的線程減爲0爲止。

因此在當前計數到達零以前，await 方法會一直受阻塞。以後，會釋放全部等待的線程，await的全部後續調用都將當即返回。這種現象只出現一次——計數沒法被重置。若是須要重置計數，請考慮使用 CyclicBarrier。

CountDownLatch的一個很是典型的應用場景是：有一個任務想要往下執行，但必需要等到其餘的任務執行完畢後才能夠繼續往下執行。假如咱們這個想要繼續往下執行的任務調用一個CountDownLatch對象的await()方法，其餘的任務執行完本身的任務後調用同一個CountDownLatch對象上的countDown()方法，這個調用await()方法的任務將一直阻塞等待，直到這個CountDownLatch對象的計數值減到0爲止。

CyclicBarrier一個同步輔助類，它容許一組線程互相等待，直到到達某個公共屏障點 (common barrier point)。在涉及一組固定大小的線程的程序中，這些線程必須不時地互相等待，此時 CyclicBarrier 頗有用。由於該 barrier 在釋放等待線程後能夠重用，因此稱它爲循環 的 barrier。

5五、什麼是不可變對象，它對寫併發應用有什麼幫助？

不可變對象(Immutable Objects)即對象一旦被建立它的狀態（對象的數據，也即對象屬性值）就不能改變，反之即爲可變對象(Mutable Objects)。

不可變對象的類即爲不可變類(Immutable Class)。Java平臺類庫中包含許多不可變類，如String、基本類型的包裝類、BigInteger和BigDecimal等。

不可變對象天生是線程安全的。它們的常量（域）是在構造函數中建立的。既然它們的狀態沒法修改，這些常量永遠不會變。

不可變對象永遠是線程安全的。只有知足以下狀態，一個對象纔是不可變的；它的狀態不能在建立後再被修改；全部域都是final類型；而且， 它被正確建立（建立期間沒有發生this引用的逸出）。

5六、什麼是多線程中的上下文切換？

在上下文切換過程當中，CPU會中止處理當前運行的程序，並保存當前程序運行的具體位置以便以後繼續運行。從這個角度來看，上下文切換有點像咱們同時閱讀幾本書，在來回切換書本的同時咱們須要記住每本書當前讀到的頁碼。

在程序中，上下文切換過程當中的「頁碼」信息是保存在進程控制塊（PCB）中的。PCB還常常被稱做「切換楨」（switchframe）。「頁碼」信息會一直保存到CPU的內存中，直到他們被再次使用。

上下文切換是存儲和恢復CPU狀態的過程，它使得線程執行可以從中斷點恢復執行。上下文切換是多任務操做系統和多線程環境的基本特徵。

5七、Java中用到的線程調度算法是什麼？

計算機一般只有一個CPU,在任意時刻只能執行一條機器指令,每一個線程只有得到CPU的使用權才能執行指令.所謂多線程的併發運行,實際上是指從宏觀上看,各個線程輪流得到CPU的使用權,分別執行各自的任務。

在運行池中,會有多個處於就緒狀態的線程在等待CPU,JAVA虛擬機的一項任務就是負責線程的調度,線程調度是指按照特定機制爲多個線程分配CPU的使用權.

有兩種調度模型：分時調度模型和搶佔式調度模型。分時調度模型是指讓全部的線程輪流得到cpu的使用權,而且平均分配每一個線程佔用的CPU的時間片這個也比較好理解。

java虛擬機採用搶佔式調度模型，是指優先讓可運行池中優先級高的線程佔用CPU，若是可運行池中的線程優先級相同，那麼就隨機選擇一個線程，使其佔用CPU。處於運行狀態的線程會一直運行，直至它不得不放棄CPU。

5八、什麼是線程組，爲何在Java中不推薦使用？

線程組和線程池是兩個不一樣的概念，他們的做用徹底不一樣，前者是爲了方便線程的管理，後者是爲了管理線程的生命週期，複用線程，減小建立銷燬線程的開銷。

5九、爲何使用Executor框架比使用應用建立和管理線程好？

爲何要使用Executor線程池框架 ？

一、每次執行任務建立線程 new Thread()比較消耗性能，建立一個線程是比較耗時、耗資源的。

二、調用 new Thread()建立的線程缺少管理，被稱爲野線程，並且能夠無限制的建立，線程之間的相互競爭會致使過多佔用系統資源而致使系統癱瘓，還有線程之間的頻繁交替也會消耗不少系統資源。

三、直接使用new Thread() 啓動的線程不利於擴展，好比定時執行、按期執行、定時按期執行、線程中斷等都不便實現。

使用Executor線程池框架的優勢 ：

一、能複用已存在並空閒的線程從而減小線程對象的建立從而減小了消亡線程的開銷。

二、可有效控制最大併發線程數，提升系統資源使用率，同時避免過多資源競爭。

三、框架中已經有定時、按期、單線程、併發數控制等功能。綜上所述使用線程池框架Executor能更好的管理線程、提供系統資源使用率。

60、java中有幾種方法能夠實現一個線程？

1. 繼承 Thread 類

2. 實現 Runnable 接口

3. Callable接口和FutureTask類，須要實現的是 call() 方法

4. 線程池建立線程。

6一、如何中止一個正在運行的線程？

1. 使用共享變量的方式

在這種方式中，之因此引入共享變量，是由於該變量能夠被多個執行相同任務的線程用來做爲是否中斷的信號，通知中斷線程的執行。

2. 使用interrupt方法終止線程

若是一個線程因爲等待某些事件的發生而被阻塞，又該怎樣中止該線程呢？這種狀況常常會發生，好比當一個線程因爲須要等候鍵盤輸入而被阻塞，或者調用Thread.join()方法，或者Thread.sleep()方法，在網絡中調用ServerSocket.accept()方法，或者調用了DatagramSocket.receive()方法時，都有可能致使線程阻塞，使線程處於處於不可運行狀態時，即便主程序中將該線程的共享變量設置爲true，但該線程此時根本沒法檢查循環標誌，固然也就沒法當即中斷。

這裏咱們給出的建議是，不要使用stop()方法，而是使用Thread提供的interrupt()方法，由於該方法雖然不會中斷一個正在運行的線程，可是它能夠使一個被阻塞的線程拋出一箇中斷異常，從而使線程提早結束阻塞狀態，退出堵塞代碼。

6二、notify()和notifyAll()有什麼區別？

當一個線程進入wait以後，就必須等其餘線程notify/notifyall,使用notifyall,能夠喚醒全部處於wait狀態的線程，使其從新進入鎖的爭奪隊列中，而notify只能喚醒一個。

若是沒把握，建議notifyAll，防止notigy由於信號丟失而形成程序異常。

6三、什麼是Daemon線程？它有什麼意義？

所謂後臺(daemon)線程，是指在程序運行的時候在後臺提供一種通用服務的線程，而且這個線程並不屬於程序中不可或缺的部分。

所以，當全部的非後臺線程結束時，程序也就終止了，同時會殺死進程中的全部後臺線程。反過來講， 只要有任何非後臺線程還在運行，程序就不會終止。

必須在線程啓動以前調用setDaemon()方法，才能把它設置爲後臺線程。注意：後臺進程在不執行finally子句的狀況下就會終止其run()方法。

好比：JVM的垃圾回收線程就是Daemon線程，Finalizer也是守護線程。

6四、java如何實現多線程之間的通信和協做？

中斷 和 共享變量

6五、什麼是可重入鎖（ReentrantLock）？

舉例來講明鎖的可重入性

public class UnReentrant{
    Lock lock = new Lock();
    public void outer(){
        lock.lock();
        inner();
        lock.unlock();
    }
    public void inner(){
        lock.lock();
        //do something
        lock.unlock();
    }
}複製代碼

outer中調用了inner，outer先鎖住了lock，這樣inner就不能再獲取lock。其實調用outer的線程已經獲取了lock鎖，可是不能在inner中重複利用已經獲取的鎖資源，這種鎖即稱之爲 不可重入可重入就意味着：線程能夠進入任何一個它已經擁有的鎖所同步着的代碼塊。

synchronized、ReentrantLock都是可重入的鎖，可重入鎖相對來講簡化了併發編程的開發。

6六、當一個線程進入某個對象的一個synchronized的實例方法後，其它線程是否可進入此對象的其它方法？

若是其餘方法沒有synchronized的話，其餘線程是能夠進入的。

因此要開放一個線程安全的對象時，得保證每一個方法都是線程安全的。

6七、樂觀鎖和悲觀鎖的理解及如何實現，有哪些實現方式？

悲觀鎖：老是假設最壞的狀況，每次去拿數據的時候都認爲別人會修改，因此每次在拿數據的時候都會上鎖，這樣別人想拿這個數據就會阻塞直到它拿到鎖。

傳統的關係型數據庫裏邊就用到了不少這種鎖機制，好比行鎖，表鎖等，讀鎖，寫鎖等，都是在作操做以前先上鎖。再好比Java裏面的同步原語synchronized關鍵字的實現也是悲觀鎖。

樂觀鎖：顧名思義，就是很樂觀，每次去拿數據的時候都認爲別人不會修改，因此不會上鎖，可是在更新的時候會判斷一下在此期間別人有沒有去更新這個數據，能夠使用版本號等機制。

樂觀鎖適用於多讀的應用類型，這樣能夠提升吞吐量，像數據庫提供的相似於write_condition機制，其實都是提供的樂觀鎖。

在Java中java.util.concurrent.atomic包下面的原子變量類就是使用了樂觀鎖的一種實現方式CAS實現的。

樂觀鎖的實現方式：

一、使用版本標識來肯定讀到的數據與提交時的數據是否一致。提交後修改版本標識，不一致時能夠採起丟棄和再次嘗試的策略。

二、java中的Compare and Swap即CAS ，當多個線程嘗試使用CAS同時更新同一個變量時，只有其中一個線程能更新變量的值，而其它線程都失敗，失敗的線程並不會被掛起，而是被告知此次競爭中失敗，並能夠再次嘗試。　CAS 操做中包含三個操做數 —— 須要讀寫的內存位置（V）、進行比較的預期原值（A）和擬寫入的新值(B)。若是內存位置V的值與預期原值A相匹配，那麼處理器會自動將該位置值更新爲新值B。不然處理器不作任何操做。

CAS缺點：

1. ABA問題：好比說一個線程one從內存位置V中取出A，這時候另外一個線程two也從內存中取出A，而且two進行了一些操做變成了B，而後two又將V位置的數據變成A，這時候線程one進行CAS操做發現內存中仍然是A，而後one操做成功。儘管線程one的CAS操做成功，但可能存在潛藏的問題。從Java1.5開始JDK的atomic包裏提供了一個類AtomicStampedReference來解決ABA問題。

2. 循環時間長開銷大：對於資源競爭嚴重（線程衝突嚴重）的狀況，CAS自旋的機率會比較大，從而浪費更多的CPU資源，效率低於synchronized。

3. 只能保證一個共享變量的原子操做：當對一個共享變量執行操做時，咱們能夠使用循環CAS的方式來保證原子操做，可是對多個共享變量操做時，循環CAS就沒法保證操做的原子性，這個時候就能夠用鎖。

6八、SynchronizedMap和ConcurrentHashMap有什麼區別？

SynchronizedMap一次鎖住整張表來保證線程安全，因此每次只能有一個線程來訪爲map。ConcurrentHashMap使用分段鎖來保證在多線程下的性能。

ConcurrentHashMap中則是一次鎖住一個桶。ConcurrentHashMap默認將hash表分爲16個桶，諸如get,put,remove等經常使用操做只鎖當前須要用到的桶。這樣，原來只能一個線程進入，如今卻能同時有16個寫線程執行，併發性能的提高是顯而易見的。

另外ConcurrentHashMap使用了一種不一樣的迭代方式。在這種迭代方式中，當iterator被建立後集合再發生改變就再也不是拋出

ConcurrentModificationException，取而代之的是在改變時new新的數據從而不影響原有的數據 ，iterator完成後再將頭指針替換爲新的數據 ，這樣iterator線程能夠使用原來老的數據，而寫線程也能夠併發的完成改變。

6九、CopyOnWriteArrayList能夠用於什麼應用場景？

CopyOnWriteArrayList(免鎖容器)的好處之一是當多個迭代器同時遍歷和修改這個列表時，不會拋出ConcurrentModificationException。在CopyOnWriteArrayList中，寫入將致使建立整個底層數組的副本，而源數組將保留在原地，使得複製的數組在被修改時，讀取操做能夠安全地執行。

一、因爲寫操做的時候，須要拷貝數組，會消耗內存，若是原數組的內容比較多的狀況下，可能致使young gc或者full gc；

二、不能用於實時讀的場景，像拷貝數組、新增元素都須要時間，因此調用一個set操做後，讀取到數據可能仍是舊的,雖然CopyOnWriteArrayList 能作到最終一致性,可是仍是無法知足實時性要求；

CopyOnWriteArrayList透露的思想

一、讀寫分離，讀和寫分開

二、最終一致性

三、使用另外開闢空間的思路，來解決併發衝突

70、什麼叫線程安全？servlet是線程安全嗎?

線程安全是編程中的術語，指某個函數、函數庫在多線程環境中被調用時，可以正確地處理多個線程之間的共享變量，使程序功能正確完成。

Servlet不是線程安全的，servlet是單實例多線程的，當多個線程同時訪問同一個方法，是不能保證共享變量的線程安全性的。

Struts2的action是多實例多線程的，是線程安全的，每一個請求過來都會new一個新的action分配給這個請求，請求完成後銷燬。

SpringMVC的Controller是線程安全的嗎？不是的，和Servlet相似的處理流程。

Struts2好處是不用考慮線程安全問題；Servlet和SpringMVC須要考慮線程安全問題，可是性能能夠提高不用處理太多的gc，能夠使用ThreadLocal來處理多線程的問題。

7一、volatile有什麼用？可否用一句話說明下volatile的應用場景？

volatile保證內存可見性和禁止指令重排。

volatile用於多線程環境下的單次操做(單次讀或者單次寫)。

7二、爲何代碼會重排序？

在執行程序時，爲了提供性能，處理器和編譯器經常會對指令進行重排序，可是不能隨意重排序，不是你想怎麼排序就怎麼排序，它須要知足如下兩個條件：

在單線程環境下不能改變程序運行的結果；存在數據依賴關係的不容許重排序須要注意的是：重排序不會影響單線程環境的執行結果，可是會破壞多線程的執行語義。

7三、在java中wait和sleep方法的不一樣？

最大的不一樣是在等待時wait會釋放鎖，而sleep一直持有鎖。Wait一般被用於線程間交互，sleep一般被用於暫停執行。

直接瞭解的深刻一點吧， 在Java中線程的狀態一共被分紅6種：

（1）初始態：NEW

建立一個Thread對象，但還未調用start()啓動線程時，線程處於初始態。

（2）運行態：RUNNABLE

在Java中，運行態包括就緒態 和 運行態。就緒態 該狀態下的線程已經得到執行所需的全部資源，只要CPU分配執行權就能運行。全部就緒態的線程存放在就緒隊列中。

運行態 得到CPU執行權，正在執行的線程。因爲一個CPU同一時刻只能執行一條線程，所以每一個CPU每一個時刻只有一條運行態的線程。

（3）阻塞態

當一條正在執行的線程請求某一資源失敗時，就會進入阻塞態。而在Java中，阻塞態專指請求鎖失敗時進入的狀態。由一個阻塞隊列存放全部阻塞態的線程。處於阻塞態的線程會不斷請求資源，一旦請求成功，就會進入就緒隊列，等待執行。PS：鎖、IO、Socket等都資源。

（4）等待態

當前線程中調用wait、join、park函數時，當前線程就會進入等待態。也有一個等待隊列存放全部等待態的線程。線程處於等待態表示它須要等待其餘線程的指示才能繼續運行。進入等待態的線程會釋放CPU執行權，並釋放資源（如：鎖）

（5）超時等待態

當運行中的線程調用sleep(time)、wait、join、parkNanos、parkUntil時，就會進入該狀態；它和等待態同樣，並非由於請求不到資源，而是主動進入，而且進入後須要其餘線程喚醒；進入該狀態後釋放CPU執行權 和 佔有的資源。與等待態的區別：到了超時時間後自動進入阻塞隊列，開始競爭鎖。

（6）終止態

線程執行結束後的狀態。

注意：

• wait()方法會釋放CPU執行權 和 佔有的鎖。

• sleep(long)方法僅釋放CPU使用權，鎖仍然佔用；線程被放入超時等待隊列，與yield相比，它會使線程較長時間得不到運行。

• yield()方法僅釋放CPU執行權，鎖仍然佔用，線程會被放入就緒隊列，會在短期內再次執行。

• wait和notify必須配套使用，即必須使用同一把鎖調用；

• wait和notify必須放在一個同步塊中調用wait和notify的對象必須是他們所處同步塊的鎖對象。

7四、爲何wait和notify方法要在同步塊中調用？

Java API強制要求這樣作，若是你不這麼作，你的代碼會拋出IllegalMonitorStateException異常。還有一個緣由是爲了不wait和notify之間產生競態條件。

7五、爲何你應該在循環中檢查等待條件?

處於等待狀態的線程可能會收到錯誤警報和僞喚醒，若是不在循環中檢查等待條件，程序就會在沒有知足結束條件的狀況下退出。

7六、Java中的同步集合與併發集合有什麼區別？

同步集合與併發集合都爲多線程和併發提供了合適的線程安全的集合，不過併發集合的可擴展性更高。在Java1.5以前程序員們只有同步集合來用且在多線程併發的時候會致使爭用，阻礙了系統的擴展性。Java5介紹了併發集合像ConcurrentHashMap，不只提供線程安全還用鎖分離和內部分區等現代技術提升了可擴展性。

7七、什麼是線程池？爲何要使用它？

建立線程要花費昂貴的資源和時間，若是任務來了才建立線程那麼響應時間會變長，並且一個進程能建立的線程數有限。

爲了不這些問題，在程序啓動的時候就建立若干線程來響應處理，它們被稱爲線程池，裏面的線程叫工做線程。從JDK1.5開始，Java API提供了Executor框架讓你能夠建立不一樣的線程池。

7八、怎麼檢測一個線程是否擁有鎖？

在java.lang.Thread中有一個方法叫holdsLock()，它返回true若是當且僅當當前線程擁有某個具體對象的鎖。

7九、你如何在Java中獲取線程堆棧？

kill -3 [java pid]不會在當前終端輸出，它會輸出到代碼執行的或指定的地方去。好比，kill -3 tomcat pid, 輸出堆棧到log目錄下。Jstack [java pid]這個比較簡單，在當前終端顯示，也能夠重定向到指定文件中。-JvisualVM：Thread Dump不作說明，打開JvisualVM後，都是界面操做，過程仍是很簡單的。

80、JVM中哪一個參數是用來控制線程的棧堆棧小的?

-Xss 每一個線程的棧大小

8一、Thread類中的yield方法有什麼做用？

使當前線程從執行狀態（運行狀態）變爲可執行態（就緒狀態）。

當前線程到了就緒狀態，那麼接下來哪一個線程會從就緒狀態變成執行狀態呢？多是當前線程，也多是其餘線程，看系統的分配了。

8二、Java中ConcurrentHashMap的併發度是什麼？

ConcurrentHashMap把實際map劃分紅若干部分來實現它的可擴展性和線程安全。這種劃分是使用併發度得到的，它是ConcurrentHashMap類構造函數的一個可選參數，默認值爲16，這樣在多線程狀況下就能避免爭用。

在JDK8後，它摒棄了Segment（鎖段）的概念，而是啓用了一種全新的方式實現,利用CAS算法。同時加入了更多的輔助變量來提升併發度，具體內容仍是查看源碼吧。

8三、Java中Semaphore是什麼？

Java中的Semaphore是一種新的同步類，它是一個計數信號。從概念上講，從概念上講，信號量維護了一個許可集合。若有必要，在許可可用前會阻塞每個 acquire()，而後再獲取該許可。

每一個 release()添加一個許可，從而可能釋放一個正在阻塞的獲取者。可是，不使用實際的許可對象，Semaphore只對可用許可的號碼進行計數，並採起相應的行動。信號量經常用於多線程的代碼中，好比數據庫鏈接池。

8四、Java線程池中submit() 和 execute()方法有什麼區別？

兩個方法均可以向線程池提交任務，execute()方法的返回類型是void，它定義在Executor接口中。

而submit()方法能夠返回持有計算結果的Future對象，它定義在ExecutorService接口中，它擴展了Executor接口，其它線程池類像ThreadPoolExecutor和ScheduledThreadPoolExecutor都有這些方法。

8五、什麼是阻塞式方法？

阻塞式方法是指程序會一直等待該方法完成期間不作其餘事情，ServerSocket的accept()方法就是一直等待客戶端鏈接。這裏的阻塞是指調用結果返回以前，當前線程會被掛起，直到獲得結果以後纔會返回。此外，還有異步和非阻塞式方法在任務完成前就返回。

8六、Java中的ReadWriteLock是什麼？

讀寫鎖是用來提高併發程序性能的鎖分離技術的成果。

8七、volatile 變量和 atomic 變量有什麼不一樣？

Volatile變量能夠確保先行關係，即寫操做會發生在後續的讀操做以前, 但它並不能保證原子性。例如用volatile修飾count變量那麼 count++ 操做就不是原子性的。

而AtomicInteger類提供的atomic方法可讓這種操做具備原子性如getAndIncrement()方法會原子性的進行增量操做把當前值加一，其它數據類型和引用變量也能夠進行類似操做。

8八、能夠直接調用Thread類的run ()方法麼？

固然能夠。可是若是咱們調用了Thread的run()方法，它的行爲就會和普通的方法同樣，會在當前線程中執行。爲了在新的線程中執行咱們的代碼，必須使用Thread.start()方法。

8九、如何讓正在運行的線程暫停一段時間？

咱們能夠使用Thread類的Sleep()方法讓線程暫停一段時間。須要注意的是，這並不會讓線程終止，一旦從休眠中喚醒線程，線程的狀態將會被改變爲Runnable，而且根據線程調度，它將獲得執行。

90、你對線程優先級的理解是什麼？

每個線程都是有優先級的，通常來講，高優先級的線程在運行時會具備優先權，但這依賴於線程調度的實現，這個實現是和操做系統相關的(OS dependent)。

咱們能夠定義線程的優先級，可是這並不能保證高優先級的線程會在低優先級的線程前執行。線程優先級是一個int變量(從1-10)，1表明最低優先級，10表明最高優先級。

java的線程優先級調度會委託給操做系統去處理，因此與具體的操做系統優先級有關，如非特別須要，通常無需設置線程優先級。

9一、什麼是線程調度器(Thread Scheduler)和時間分片(Time Slicing )？

線程調度器是一個操做系統服務，它負責爲Runnable狀態的線程分配CPU時間。一旦咱們建立一個線程並啓動它，它的執行便依賴於線程調度器的實現。同上一個問題，線程調度並不受到Java虛擬機控制，因此由應用程序來控制它是更好的選擇（也就是說不要讓你的程序依賴於線程的優先級）。

時間分片是指將可用的CPU時間分配給可用的Runnable線程的過程。分配CPU時間能夠基於線程優先級或者線程等待的時間。

9二、你如何確保main()方法所在的線程是Java 程序最後結束的線程？

咱們能夠使用Thread類的join()方法來確保全部程序建立的線程在main()方法退出前結束。

9三、線程之間是如何通訊的？

當線程間是能夠共享資源時，線程間通訊是協調它們的重要的手段。Object類中wait()\notify()\notifyAll()方法能夠用於線程間通訊關於資源的鎖的狀態。

9四、爲何線程通訊的方法wait(), notify()和notifyAll()被定義在Object 類裏？

Java的每一個對象中都有一個鎖(monitor，也能夠成爲監視器) 而且wait()，notify()等方法用於等待對象的鎖或者通知其餘線程對象的監視器可用。

在Java的線程中並無可供任何對象使用的鎖和同步器。這就是爲何這些方法是Object類的一部分，這樣Java的每個類都有用於線程間通訊的基本方法。

9五、爲何wait(), notify()和notifyAll ()必須在同步方法或者同步塊中被調用？

當一個線程須要調用對象的wait()方法的時候，這個線程必須擁有該對象的鎖，接着它就會釋放這個對象鎖並進入等待狀態直到其餘線程調用這個對象上的notify()方法。

一樣的，當一個線程須要調用對象的notify()方法時，它會釋放這個對象的鎖，以便其餘在等待的線程就能夠獲得這個對象鎖。因爲全部的這些方法都須要線程持有對象的鎖，這樣就只能經過同步來實現，因此他們只能在同步方法或者同步塊中被調用。

9六、爲何Thread類的sleep()和yield ()方法是靜態的？

Thread類的sleep()和yield()方法將在當前正在執行的線程上運行。因此在其餘處於等待狀態的線程上調用這些方法是沒有意義的。這就是爲何這些方法是靜態的。它們能夠在當前正在執行的線程中工做，並避免程序員錯誤的認爲能夠在其餘非運行線程調用這些方法。

9七、如何確保線程安全？

在Java中能夠有不少方法來保證線程安全——同步，使用原子類(atomic concurrent classes)，實現併發鎖，使用volatile關鍵字，使用不變類和線程安全類。

9八、同步方法和同步塊，哪一個是更好的選擇？

同步塊是更好的選擇，由於它不會鎖住整個對象（固然你也可讓它鎖住整個對象）。同步方法會鎖住整個對象，哪怕這個類中有多個不相關聯的同步塊，這一般會致使他們中止執行並須要等待得到這個對象上的鎖。

同步塊更要符合開放調用的原則，只在須要鎖住的代碼塊鎖住相應的對象，這樣從側面來講也能夠避免死鎖。

9九、如何建立守護線程？

使用Thread類的setDaemon(true)方法能夠將線程設置爲守護線程，須要注意的是，須要在調用start()方法前調用這個方法，不然會拋出IllegalThreadStateException異常。

100、什麼是Java Timer 類？如何建立一個有特定時間間隔的任務？

java.util.Timer是一個工具類，能夠用於安排一個線程在將來的某個特定時間執行。Timer類能夠用安排一次性任務或者週期任務。

java.util.TimerTask是一個實現了Runnable接口的抽象類，咱們須要去繼承這個類來建立咱們本身的定時任務並使用Timer去安排它的執行。目前有開源的Qurtz能夠用來建立定時任務。

總結：

全部的面試題目都不是一成不變的，上面的面試題只是給你們一個借鑑做用，最主要的是給本身增長知識的儲備，有備無患。