最全面的阿里多線程面試題，你能回答幾個？

時間 2019-11-18

原文原文鏈接

一、什麼是進程，什麼是線程，爲何須要多線程編程？

進程是具備必定獨立功能的程序關於某個數據集合上的一次運行活動，是操做系統進行資源分配和調度的一個獨立單位；java

線程是進程的一個實體，是CPU調度和分派的基本單位，是比進程更小的能獨立運行的基本單位。線程的劃分尺度小於進程，這使得多線程程序的併發性高；進程在執行時一般擁有獨立的內存單元，而線程之間能夠共享內存。程序員

使用多線程的編程一般可以帶來更好的性能和用戶體驗，可是多線程的程序對於其餘程序是不友好的，由於它可能佔用了更多的CPU資源。固然，也不是線程越多，程序的性能就越好，由於線程之間的調度和切換也會浪費CPU時間。時下很時髦的Node.js就採用了單線程異步I/O的工做模式。web

二、什麼是線程安全

若是你的代碼在多線程下執行和在單線程下執行永遠都能得到同樣的結果，那麼你的代碼就是線程安全的。算法

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

不可變。像String、Integer、Long這些，都是final類型的類，任何一個線程都改變不了它們的值，要改變除非新建立一個，所以這些不可變對象不須要任何同步手段就能夠直接在多線程環境下使用
絕對線程安全。無論運行時環境如何，調用者都不須要額外的同步措施。要作到這一點一般須要付出許多額外的代價，Java中標註本身是線程安全的類，實際上絕大多數都不是線程安全的，不過絕對線程安全的類，Java中也有，比方說CopyOnWriteArrayList、CopyOnWriteArraySet
相對線程安全。相對線程安全也就是咱們一般意義上所說的線程安全，像Vector這種，add、remove方法都是原子操做，不會被打斷，但也僅限於此，若是有個線程在遍歷某個Vector、有個線程同時在add這個Vector，99%的狀況下都會出現ConcurrentModificationException，也就是fail-fast機制。
線程非安全。這個就沒什麼好說的了，ArrayList、LinkedList、HashMap等都是線程非安全的類

三、編寫多線程程序有幾種實現方式？

Java 5之前實現多線程有兩種實現方法：一種是繼承Thread類；另外一種是實現Runnable接口。兩種方式都要經過重寫run()方法來定義線程的行爲，推薦使用後者，由於Java中的繼承是單繼承，一個類有一個父類，若是繼承了Thread類就沒法再繼承其餘類了，顯然使用Runnable接口更爲靈活。編程

Java 5之後建立線程還有第三種方式：實現Callable接口，該接口中的call方法能夠在線程執行結束時產生一個返回值。數組

四、synchronized關鍵字的用法？

synchronized關鍵字能夠將對象或者方法標記爲同步，以實現對對象和方法的互斥訪問，能夠用synchronized(對象) { … }定義同步代碼塊，或者在聲明方法時將synchronized做爲方法的修飾符。緩存

五、簡述synchronized 和java.util.concurrent.locks.Lock的異同？

Lock是Java 5之後引入的新的API，和關鍵字synchronized相比主要相同點：Lock 能完成synchronized所實現的全部功能；主要不一樣點：Lock有比synchronized更精確的線程語義和更好的性能，並且不強制性的要求必定要得到鎖。synchronized會自動釋放鎖，而Lock必定要求程序員手工釋放，而且最好在finally 塊中釋放（這是釋放外部資源的最好的地方）。安全

六、當一個線程進入一個對象的synchronized方法A以後，其它線程是否可進入此對象的synchronized方法B？

不能。其它線程只能訪問該對象的非同步方法，同步方法則不能進入。由於非靜態方法上的synchronized修飾符要求執行方法時要得到對象的鎖，若是已經進入A方法說明對象鎖已經被取走，那麼試圖進入B方法的線程就只能在等鎖池（注意不是等待池哦）中等待對象的鎖。服務器

七、synchronized和ReentrantLock的區別

synchronized是和if、else、for、while同樣的關鍵字，ReentrantLock是類，這是兩者的本質區別。既然ReentrantLock是類，那麼它就提供了比synchronized更多更靈活的特性，能夠被繼承、能夠有方法、能夠有各類各樣的類變量，ReentrantLock比synchronized的擴展性體如今幾點上：

ReentrantLock能夠對獲取鎖的等待時間進行設置，這樣就避免了死鎖
ReentrantLock能夠獲取各類鎖的信息
ReentrantLock能夠靈活地實現多路通知

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

八、舉例說明同步和異步。

若是系統中存在臨界資源（資源數量少於競爭資源的線程數量的資源），例如正在寫的數據之後可能被另外一個線程讀到，或者正在讀的數據可能已經被另外一個線程寫過了，那麼這些數據就必須進行同步存取（數據庫操做中的排他鎖就是最好的例子）。當應用程序在對象上調用了一個須要花費很長時間來執行的方法，而且不但願讓程序等待方法的返回時，就應該使用異步編程，在不少狀況下采用異步途徑每每更有效率。事實上，所謂的同步就是指阻塞式操做，而異步就是非阻塞式操做。

九、啓動一個線程是調用run()仍是start()方法？

啓動一個線程是調用start()方法，使線程所表明的虛擬處理機處於可運行狀態，這意味着它能夠由JVM 調度並執行，這並不意味着線程就會當即運行。run()方法是線程啓動後要進行回調（callback）的方法。

十、爲何須要run()和start()方法，咱們能夠只用run()方法來完成任務嗎？

咱們須要run()&start()這兩個方法是由於JVM建立一個單獨的線程不一樣於普通方法的調用，因此這項工做由線程的start方法來完成，start由本地方法實現，須要顯示地被調用，使用這倆個方法的另一個好處是任何一個對象均可以做爲線程運行，只要實現了Runnable接口，這就避免因繼承了Thread類而形成的Java的多繼承問題。

十一、什麼是線程池（thread pool）？

在面向對象編程中，建立和銷燬對象是很費時間的，由於建立一個對象要獲取內存資源或者其它更多資源。

在Java中更是如此，虛擬機將試圖跟蹤每個對象，以便可以在對象銷燬後進行垃圾回收。因此提升服務程序效率的一個手段就是儘量減小建立和銷燬對象的次數，特別是一些很耗資源的對象建立和銷燬，這就是「池化資源」技術產生的緣由。線程池顧名思義就是事先建立若干個可執行的線程放入一個池（容器）中，須要的時候從池中獲取線程不用自行建立，使用完畢不須要銷燬線程而是放回池中，從而減小建立和銷燬線程對象的開銷。

Java 5+中的Executor接口定義一個執行線程的工具。它的子類型即線程池接口是ExecutorService。要配置一個線程池是比較複雜的，尤爲是對於線程池的原理不是很清楚的狀況下，所以在工具類Executors面提供了一些靜態工廠方法，生成一些經常使用的線程池，以下所示：

newSingleThreadExecutor：建立一個單線程的線程池。這個線程池只有一個線程在工做，也就是至關於單線程串行執行全部任務。若是這個惟一的線程由於異常結束，那麼會有一個新的線程來替代它。此線程池保證全部任務的執行順序按照任務的提交順序執行。
newFixedThreadPool：建立固定大小的線程池。每次提交一個任務就建立一個線程，直到線程達到線程池的最大大小。線程池的大小一旦達到最大值就會保持不變，若是某個線程由於執行異常而結束，那麼線程池會補充一個新線程。
newCachedThreadPool：建立一個可緩存的線程池。若是線程池的大小超過了處理任務所須要的線程，那麼就會回收部分空閒（60秒不執行任務）的線程，當任務數增長時，此線程池又能夠智能的添加新線程來處理任務。此線程池不會對線程池大小作限制，線程池大小徹底依賴於操做系統（或者說JVM）可以建立的最大線程大小。
newScheduledThreadPool：建立一個大小無限的線程池。此線程池支持定時以及週期性執行任務的需求。
newSingleThreadExecutor：建立一個單線程的線程池。此線程池支持定時以及週期性執行任務的需求。

十二、線程的基本狀態以及狀態之間的關係？

其中Running表示運行狀態；Runnable表示就緒狀態（萬事俱備，只欠CPU）；Blocked表示阻塞狀態；阻塞狀態又有多種狀況，多是由於調用wait()方法進入等待池，也多是執行同步方法或同步代碼塊進入等鎖池，或者是調用了sleep()方法或join()方法等待休眠或其餘線程結束，或是由於發生了I/O中斷。

1三、Java中如何實現序列化，有什麼意義？

序列化就是一種用來處理對象流的機制，所謂對象流也就是將對象的內容進行流化。能夠對流化後的對象進行讀寫操做，也可將流化後的對象傳輸於網絡之間。序列化是爲了解決對象流讀寫操做時可能引起的問題（若是不進行序列化可能會存在數據亂序的問題）。

要實現序列化，須要讓一個類實現Serializable接口，該接口是一個標識性接口，標註該類對象是可被序列化的，而後使用一個輸出流來構造一個對象輸出流並經過writeObject(Object)方法就能夠將實現對象寫出（即保存其狀態）；若是須要反序列化則能夠用一個輸入流創建對象輸入流，而後經過readObject方法從流中讀取對象。序列化除了可以實現對象的持久化以外，還可以用於對象的深度克隆。

1四、產生死鎖的條件

互斥條件：一個資源每次只能被一個進程使用。
請求與保持條件：一個進程因請求資源而阻塞時，對已得到的資源保持不放
不剝奪條件:進程已得到的資源，在末使用完以前，不能強行剝奪。
循環等待條件:若干進程之間造成一種頭尾相接的循環等待資源關係。

1五、什麼是線程餓死，什麼是活鎖？

線程餓死和活鎖雖然不想是死鎖同樣的常見問題，可是對於併發編程的設計者來講就像一次邂逅同樣。

當全部線程阻塞，或者因爲須要的資源無效而不能處理，不存在非阻塞線程使資源可用。JavaAPI中線程活鎖可能發生在如下情形：

當全部線程在程序中執行Object.wait(0)，參數爲0的wait方法。程序將發生活鎖直到在相應的對象上有線程調用Object.notify()或者Object.notifyAll()。
當全部線程卡在無限循環中。

1六、什麼致使線程阻塞

阻塞指的是暫停一個線程的執行以等待某個條件發生（如某資源就緒），學過操做系統的同窗對它必定已經很熟悉了。Java 提供了大量方法來支持阻塞，下面讓咱們逐一分析。

方法說明sleep()sleep() 容許指定以毫秒爲單位的一段時間做爲參數，它使得線程在指定的時間內進入阻塞狀態，不能獲得CPU 時間，指定的時間一過，線程從新進入可執行狀態。典型地，sleep() 被用在等待某個資源就緒的情形：測試發現條件不知足後，讓線程阻塞一段時間後從新測試，直到條件知足爲止suspend() 和 resume()兩個方法配套使用，suspend()使得線程進入阻塞狀態，而且不會自動恢復，必須其對應的resume() 被調用，才能使得線程從新進入可執行狀態。典型地，suspend() 和 resume() 被用在等待另外一個線程產生的結果的情形：測試發現結果尚未產生後，讓線程阻塞，另外一個線程產生告終果後，調用 resume() 使其恢復。yield()yield() 使當前線程放棄當前已經分得的CPU 時間，但不使當前線程阻塞，即線程仍處於可執行狀態，隨時可能再次分得 CPU 時間。調用 yield() 的效果等價於調度程序認爲該線程已執行了足夠的時間從而轉到另外一個線程。wait() 和 notify()兩個方法配套使用，wait() 使得線程進入阻塞狀態，它有兩種形式，一種容許指定以毫秒爲單位的一段時間做爲參數，另外一種沒有參數，前者當對應的 notify() 被調用或者超出指定時間時線程從新進入可執行狀態，後者則必須對應的 notify() 被調用.

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

Thread類提供了一個holdsLock(Object obj)方法，當且僅當對象obj的監視器被某條線程持有的時候纔會返回true，注意這是一個static方法，這意味着」某條線程」指的是當前線程。

1八、請說出與線程同步以及線程調度相關的方法。

wait()：使一個線程處於等待（阻塞）狀態，而且釋放所持有的對象的鎖；
sleep()：使一個正在運行的線程處於睡眠狀態，是一個靜態方法，調用此方法要處理InterruptedException異常；
notify()：喚醒一個處於等待狀態的線程，固然在調用此方法的時候，並不能確切的喚醒某一個等待狀態的線程，而是由JVM肯定喚醒哪一個線程，並且與優先級無關；
notityAll()：喚醒全部處於等待狀態的線程，該方法並非將對象的鎖給全部線程，而是讓它們競爭，只有得到鎖的線程才能進入就緒狀態；

1九、sleep() 、join（）、yield（）有什麼區別

sleep()方法給其餘線程運行機會時不考慮線程的優先級，所以會給低優先級的線程以運行的機會；yield()方法只會給相同優先級或更高優先級的線程以運行的機會；
線程執行sleep()方法後轉入阻塞（blocked）狀態，而執行yield()方法後轉入就緒（ready）狀態；
sleep()方法聲明拋出InterruptedException，而yield()方法沒有聲明任何異常；
sleep()方法比yield()方法（跟操做系統CPU調度相關）具備更好的可移植性。

20、wait(),notify()和suspend(),resume()之間的區別

初看起來它們與 suspend() 和 resume() 方法對沒有什麼分別，可是事實上它們是大相徑庭的。區別的核心在於，前面敘述的全部方法，阻塞時都不會釋放佔用的鎖（若是佔用了的話），而這一對方法則相反。上述的核心區別致使了一系列的細節上的區別。

首先，前面敘述的全部方法都隸屬於 Thread 類，可是這一對卻直接隸屬於 Object 類，也就是說，全部對象都擁有這一對方法。初看起來這十分難以想象，可是實際上倒是很天然的，由於這一對方法阻塞時要釋放佔用的鎖，而鎖是任何對象都具備的，調用任意對象的 wait() 方法致使線程阻塞，而且該對象上的鎖被釋放。而調用任意對象的notify()方法則致使從調用該對象的 wait() 方法而阻塞的線程中隨機選擇的一個解除阻塞（但要等到得到鎖後才真正可執行）。

其次，前面敘述的全部方法均可在任何位置調用，可是這一對方法卻必須在 synchronized 方法或塊中調用，理由也很簡單，只有在synchronized 方法或塊中當前線程才佔有鎖，纔有鎖能夠釋放。一樣的道理，調用這一對方法的對象上的鎖必須爲當前線程所擁有，這樣纔有鎖能夠釋放。所以，這一對方法調用必須放置在這樣的 synchronized 方法或塊中，該方法或塊的上鎖對象就是調用這一對方法的對象。若不知足這一條件，則程序雖然仍能編譯，但在運行時會出現IllegalMonitorStateException 異常。

wait() 和 notify() 方法的上述特性決定了它們常常和synchronized關鍵字一塊兒使用，將它們和操做系統進程間通訊機制做一個比較就會發現它們的類似性：synchronized方法或塊提供了相似於操做系統原語的功能，它們的執行不會受到多線程機制的干擾，而這一對方法則至關於 block 和wakeup 原語（這一對方法均聲明爲 synchronized）。它們的結合使得咱們能夠實現操做系統上一系列精妙的進程間通訊的算法（如信號量算法），並用於解決各類複雜的線程間通訊問題。

關於 wait() 和 notify() 方法最後再說明兩點：

第一：調用 notify() 方法致使解除阻塞的線程是從因調用該對象的 wait() 方法而阻塞的線程中隨機選取的，咱們沒法預料哪個線程將會被選擇，因此編程時要特別當心，避免因這種不肯定性而產生問題。

第二：除了 notify()，還有一個方法 notifyAll() 也可起到相似做用，惟一的區別在於，調用 notifyAll() 方法將把因調用該對象的 wait() 方法而阻塞的全部線程一次性所有解除阻塞。固然，只有得到鎖的那一個線程才能進入可執行狀態。

談到阻塞，就不能不談一談死鎖，略一分析就能發現，suspend() 方法和不指定超時期限的 wait() 方法的調用均可能產生死鎖。遺憾的是，Java 並不在語言級別上支持死鎖的避免，咱們在編程中必須當心地避免死鎖。

以上咱們對 Java 中實現線程阻塞的各類方法做了一番分析，咱們重點分析了 wait() 和 notify() 方法，由於它們的功能最強大，使用也最靈活，可是這也致使了它們的效率較低，較容易出錯。實際使用中咱們應該靈活使用各類方法，以便更好地達到咱們的目的。

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

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

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

wait()方法和notify()/notifyAll()方法在放棄對象監視器的時候的區別在於：wait()方法當即釋放對象監視器，notify()/notifyAll()方法則會等待線程剩餘代碼執行完畢纔會放棄對象監視器。

2三、Runnable和Callable的區別

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

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

2四、Thread類的sleep()方法和對象的wait()方法均可以讓線程暫停執行，它們有什麼區別？

sleep()方法（休眠）是線程類（Thread）的靜態方法，調用此方法會讓當前線程暫停執行指定的時間，將執行機會（CPU）讓給其餘線程，可是對象的鎖依然保持，所以休眠時間結束後會自動恢復。

wait()是Object類的方法，調用對象的wait()方法致使當前線程放棄對象的鎖（線程暫停執行），進入對象的等待池（wait pool），只有調用對象的notify()方法（或notifyAll()方法）時才能喚醒等待池中的線程進入等鎖池（lock pool），若是線程從新得到對象的鎖就能夠進入就緒狀態。

2五、線程的sleep()方法和yield()方法有什麼區別？

sleep()方法給其餘線程運行機會時不考慮線程的優先級，所以會給低優先級的線程以運行的機會；yield()方法只會給相同優先級或更高優先級的線程以運行的機會；
線程執行sleep()方法後轉入阻塞（blocked）狀態，而執行yield()方法後轉入就緒（ready）狀態；
sleep()方法聲明拋出InterruptedException，而yield()方法沒有聲明任何異常；
sleep()方法比yield()方法（跟操做系統CPU調度相關）具備更好的可移植性。

2六、爲何wait,nofity和nofityAll這些方法不放在Thread類當中

一個很明顯的緣由是JAVA提供的鎖是對象級的而不是線程級的，每一個對象都有鎖，經過線程得到。若是線程須要等待某些鎖那麼調用對象中的wait()方法就有意義了。若是wait()方法定義在Thread類中，線程正在等待的是哪一個鎖就不明顯了。簡單的說，因爲wait，notify和notifyAll都是鎖級別的操做，因此把他們定義在Object類中由於鎖屬於對象。

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

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

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

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

2九、FutureTask是什麼

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

30、一個線程若是出現了運行時異常怎麼辦？

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

3一、Java當中有哪幾種鎖

自旋鎖: 自旋鎖在JDK1.6以後就默認開啓了。基於以前的觀察，共享數據的鎖定狀態只會持續很短的時間，爲了這一小段時間而去掛起和恢復線程有點浪費，因此這裏就作了一個處理，讓後面請求鎖的那個線程在稍等一會，可是不放棄處理器的執行時間，看看持有鎖的線程可否快速釋放。爲了讓線程等待，因此須要讓線程執行一個忙循環也就是自旋操做。在jdk6以後，引入了自適應的自旋鎖，也就是等待的時間再也不固定了，而是由上一次在同一個鎖上的自旋時間及鎖的擁有者狀態來決定

偏向鎖: 在JDK1.以後引入的一項鎖優化，目的是消除數據在無競爭狀況下的同步原語。進一步提高程序的運行性能。偏向鎖就是偏愛的偏，意思是這個鎖會偏向第一個得到他的線程，若是接下來的執行過程當中，改鎖沒有被其餘線程獲取，則持有偏向鎖的線程將永遠不須要再進行同步。偏向鎖能夠提升帶有同步但無競爭的程序性能，也就是說他並不必定老是對程序運行有利，若是程序中大多數的鎖都是被多個不一樣的線程訪問，那偏向模式就是多餘的，在具體問題具體分析的前提下，能夠考慮是否使用偏向鎖。

輕量級鎖: 爲了減小得到鎖和釋放鎖所帶來的性能消耗，引入了「偏向鎖」和「輕量級鎖」，因此在Java SE1.6裏鎖一共有四種狀態，無鎖狀態，偏向鎖狀態，輕量級鎖狀態和重量級鎖狀態，它會隨着競爭狀況逐漸升級。鎖能夠升級但不能降級，意味着偏向鎖升級成輕量級鎖後不能降級成偏向鎖

3二、如何在兩個線程間共享數據

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

3三、如何正確的使用wait()?使用if仍是while？

wait() 方法應該在循環調用，由於當線程獲取到 CPU 開始執行的時候，其餘條件可能尚未知足，因此在處理前，循環檢測條件是否知足會更好。下面是一段標準的使用 wait 和 notify 方法的代碼：

synchronized (obj) {
   while (condition does not hold)
     obj.wait(); // (Releases lock, and reacquires on wakeup)
     ... // Perform action appropriate to condition
}

3四、什麼是線程局部變量ThreadLocal

線程局部變量是侷限於線程內部的變量，屬於線程自身全部，不在多個線程間共享。Java提供ThreadLocal類來支持線程局部變量，是一種實現線程安全的方式。可是在管理環境下（如 web 服務器）使用線程局部變量的時候要特別當心，在這種狀況下，工做線程的生命週期比任何應用變量的生命週期都要長。任何線程局部變量一旦在工做完成後沒有釋放，Java 應用就存在內存泄露的風險。

3五、ThreadLoal的做用是什麼？

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

3六、ThreadLocal 原理分析

ThreadLocal爲解決多線程程序的併發問題提供了一種新的思路。ThreadLocal，顧名思義是線程的一個本地化對象，當工做於多線程中的對象使用ThreadLocal維護變量時，ThreadLocal爲每一個使用該變量的線程分配一個獨立的變量副本，因此每個線程均可以獨立的改變本身的副本，而不影響其餘線程所對應的副本。從線程的角度看，這個變量就像是線程的本地變量。

ThreadLocal類很是簡單好用，只有四個方法，能用上的也就是下面三個方法：

void set(T value)：設置當前線程的線程局部變量的值。
T get()：得到當前線程所對應的線程局部變量的值。
void remove()：刪除當前線程中線程局部變量的值。

ThreadLocal是如何作到爲每個線程維護一份獨立的變量副本的呢？在ThreadLocal類中有一個Map，鍵爲線程對象，值是其線程對應的變量的副本，本身要模擬實現一個ThreadLocal類其實並不困難，代碼以下所示：

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
public class MyThreadLocal<T> {
    private Map<Thread, T> map = Collections.synchronizedMap(new HashMap<Thread, T>());
    public void set(T newValue) {
        map.put(Thread.currentThread(), newValue);
    }
    public T get() {
        return map.get(Thread.currentThread());
    }
    public void remove() {
        map.remove(Thread.currentThread());
    }
}

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

若是你使用的LinkedBlockingQueue，也就是無界隊列的話，不要緊，繼續添加任務到阻塞隊列中等待執行，由於LinkedBlockingQueue能夠近乎認爲是一個無窮大的隊列，能夠無限存聽任務；若是你使用的是有界隊列比方說ArrayBlockingQueue的話，任務首先會被添加到ArrayBlockingQueue中，ArrayBlockingQueue滿了，則會使用拒絕策略RejectedExecutionHandler處理滿了的任務，默認是AbortPolicy。

3八、爲何要使用線程池

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

3九、java中用到的線程調度算法是什麼

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

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

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

4一、什麼是CAS

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

4二、什麼是樂觀鎖和悲觀鎖

樂觀鎖：樂觀鎖認爲競爭不老是會發生，所以它不須要持有鎖，將比較-替換這兩個動做做爲一個原子操做嘗試去修改內存中的變量，若是失敗則表示發生衝突，那麼就應該有相應的重試邏輯。

悲觀鎖：悲觀鎖認爲競爭老是會發生，所以每次對某資源進行操做時，都會持有一個獨佔的鎖，就像synchronized，無論三七二十一，直接上了鎖就操做資源了。

4三、ConcurrentHashMap的併發度是什麼？

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

4四、ConcurrentHashMap的工做原理

ConcurrentHashMap在jdk 1.6和jdk 1.8實現原理是不一樣的.

jdk 1.6: ConcurrentHashMap是線程安全的，可是與Hashtablea相比，實現線程安全的方式不一樣。Hashtable是經過對hash表結構進行鎖定，是阻塞式的，當一個線程佔有這個鎖時，其餘線程必須阻塞等待其釋放鎖。ConcurrentHashMap是採用分離鎖的方式，它並無對整個hash表進行鎖定，而是局部鎖定，也就是說當一個線程佔有這個局部鎖時，不影響其餘線程對hash表其餘地方的訪問。具體實現:ConcurrentHashMap內部有一個Segment

jdk 1.8 在jdk 8中，ConcurrentHashMap再也不使用Segment分離鎖，而是採用一種樂觀鎖CAS算法來實現同步問題，但其底層仍是「數組+鏈表->紅黑樹」的實現。

4五、CyclicBarrier和CountDownLatch區別

這兩個類很是相似，都在java.util.concurrent下，均可以用來表示代碼運行到某個點上，兩者的區別在於：

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

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

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

4六、java中的++操做符線程安全麼？

不是線程安全的操做。它涉及到多個指令，如讀取變量值，增長，而後存儲回內存，這個過程可能會出現多個線程交差

4七、有三個線程T1，T2，T3，怎麼確保它們按順序執行？

在多線程中有多種方法讓線程按特定順序執行，你能夠用線程類的join()方法在一個線程中啓動另外一個線程，另一個線程完成該線程繼續執行。爲了確保三個線程的順序你應該先啓動最後一個(T3調用T2，T2調用T1)，這樣T1就會先完成而T3最後完成。

4八、如何在Java中建立Immutable對象？

這個問題看起來和多線程沒什麼關係，但不變性有助於簡化已經很複雜的併發程序。Immutable對象能夠在沒有同步的狀況下共享，下降了對該對象進行併發訪問時的同步化開銷。但是Java沒有@Immutable這個註解符，要建立不可變類，要實現下面幾個步驟：經過構造方法初始化全部成員、對變量不要提供setter方法、將全部的成員聲明爲私有的，這樣就不容許直接訪問這些成員、在getter方法中，不要直接返回對象自己，而是克隆對象，並返回對象的拷貝。

4九、你有哪些多線程開發良好的實踐？

給線程命名
最小化同步範圍
優先使用volatile
儘量使用更高層次的併發工具而非wait和notify()來實現線程通訊,如BlockingQueue,Semeaphore
優先使用併發容器而非同步容器.
考慮使用線程池

50、能夠建立Volatile數組嗎？

Java 中能夠建立 volatile類型數組，不過只是一個指向數組的引用，而不是整個數組。若是改變引用指向的數組，將會受到volatile 的保護，可是若是多個線程同時改變數組的元素，volatile標示符就不能起到以前的保護做用了

5一、Volatile關鍵字的做用

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

多線程主要圍繞可見性和原子性兩個特性而展開，使用volatile關鍵字修飾的變量，保證了其在多線程之間的可見性，即每次讀取到volatile變量，必定是最新的數據
代碼底層執行不像咱們看到的高級語言—-Java程序這麼簡單，它的執行是Java代碼–>字節碼–>根據字節碼執行對應的C/C++代碼–>C/C++代碼被編譯成彙編語言–>和硬件電路交互，現實中，爲了獲取更好的性能JVM可能會對指令進行重排序，多線程下可能會出現一些意想不到的問題。使用volatile則會對禁止語義重排序，固然這也必定程度上下降了代碼執行效率

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

5二、volatile能使得一個非原子操做變成原子操做嗎？

一個典型的例子是在類中有一個 long 類型的成員變量。若是你知道該成員變量會被多個線程訪問，如計數器、價格等，你最好是將其設置爲 volatile。爲何？由於 Java 中讀取 long 類型變量不是原子的，須要分紅兩步，若是一個線程正在修改該 long 變量的值，另外一個線程可能只能看到該值的一半（前 32 位）。可是對一個 volatile 型的 long 或 double 變量的讀寫是原子。

一種實踐是用 volatile 修飾 long 和 double 變量，使其能按原子類型來讀寫。double 和 long 都是64位寬，所以對這兩種類型的讀是分爲兩部分的，第一次讀取第一個 32 位，而後再讀剩下的 32 位，這個過程不是原子的，但 Java 中 volatile 型的 long 或 double 變量的讀寫是原子的。volatile 修復符的另外一個做用是提供內存屏障（memory barrier），例如在分佈式框架中的應用。簡單的說，就是當你寫一個 volatile 變量以前，Java 內存模型會插入一個寫屏障（write barrier），讀一個 volatile 變量以前，會插入一個讀屏障（read barrier）。意思就是說，在你寫一個 volatile 域時，能保證任何線程都能看到你寫的值，同時，在寫以前，也能保證任何數值的更新對全部線程是可見的，由於內存屏障會將其餘全部寫的值更新到緩存。

5三、volatile類型變量提供什麼保證？

volatile 主要有兩方面的做用:1.避免指令重排2.可見性保證.例如，JVM 或者 JIT爲了得到更好的性能會對語句重排序，可是 volatile 類型變量即便在沒有同步塊的狀況下賦值也不會與其餘語句重排序。 volatile 提供 happens-before 的保證，確保一個線程的修改能對其餘線程是可見的。某些狀況下，volatile 還能提供原子性，如讀 64 位數據類型，像 long 和 double 都不是原子的(低32位和高32位)，但 volatile 類型的 double 和 long 就是原子的.

5四、Java 中，編寫多線程程序的時候你會遵循哪些最佳實踐？

這是我在寫Java 併發程序的時候遵循的一些最佳實踐：

給線程命名，這樣能夠幫助調試。
最小化同步的範圍，而不是將整個方法同步，只對關鍵部分作同步。
若是能夠，更偏向於使用 volatile 而不是 synchronized。
使用更高層次的併發工具，而不是使用 wait() 和 notify() 來實現線程間通訊，如 BlockingQueue，CountDownLatch 及 Semeaphore。
優先使用併發集合，而不是對集合進行同步。併發集合提供更好的可擴展性。

5五、說出至少 5 點在 Java 中使用線程的最佳實踐。

這個問題與以前的問題相似，你能夠使用上面的答案。對線程來講，你應該：

對線程命名
將線程和任務分離，使用線程池執行器來執行 Runnable 或 Callable。
使用線程池

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

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

獲取到線程的pid，能夠經過使用jps命令，在Linux環境下還能夠使用ps -ef | grep java
打印線程堆棧，能夠經過使用jstack pid命令，在Linux環境下還能夠使用kill -3 pid

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

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

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

高併發、任務執行時間短的業務，線程池線程數能夠設置爲CPU核數+1，減小線程上下文的切換
併發不高、任務執行時間長的業務要區分開看：

假如是業務時間長集中在IO操做上，也就是IO密集型的任務，由於IO操做並不佔用CPU，因此不要讓全部的CPU閒下來，能夠加大線程池中的線程數目，讓CPU處理更多的業務
假如是業務時間長集中在計算操做上，也就是計算密集型任務，這個就沒辦法了，和（1）同樣吧，線程池中的線程數設置得少一些，減小線程上下文的切換

併發高、業務執行時間長，解決這種類型任務的關鍵不在於線程池而在於總體架構的設計，看看這些業務裏面某些數據是否能作緩存是第一步，增長服務器是第二步，至於線程池的設置，設置參考（2）。
業務執行時間長的問題，也可能須要分析一下，看看能不能使用中間件對任務進行拆分和解耦。

5八、做業(進程)調度算法

先來先服務調度算法(FCFS) 每次調度都是從後備做業隊列中選擇一個或多個最早進入該隊列的做業，將它們調入內存，爲它們分配資源、建立進程，而後放入就緒隊列。
短做業(進程)優先調度算法(SPF) 短做業優先(SJF)的調度算法是從後備隊列中選擇一個或若干個估計運行時間最短的做業，將它們調入內存運行。缺點:長做業的運行得不到保證
優先權調度算法(HPF) 當把該算法用於做業調度時，系統將從後備隊列中選擇若干個優先權最高的做業裝入內存。當用於進程調度時，該算法是把處理機分配給就緒隊列中優先權最高的進程，這時，又可進一步把該算法分紅以下兩種。能夠分爲:

非搶佔式優先權算法
搶佔式優先權調度算法

高響應比優先調度算法(HRN) 每次選擇高響應比最大的做業執行，響應比=(等待時間+要求服務時間)/要求服務時間。該算法同時考慮了短做業優先和先來先服務。

若是做業的等待時間相同，則要求服務的時間愈短，其優先權愈高，於是該算法有利於短做業。
當要求服務的時間相同時，做業的優先權決定於其等待時間，等待時間愈長，其優先權愈高，於是它實現的是先來先服務。
對於長做業，做業的優先級能夠隨等待時間的增長而提升，當其等待時間足夠長時，其優先級即可升到很高，從而也可得到處理機。簡言之，該算法既照顧了短做業，又考慮了做業到達的前後次序，不會使長做業長期得不到服務。所以，該算法實現了一種較好的折衷。固然，在利用該算法時，每要進行調度以前，都須先作響應比的計算，這會增長系統開銷。

時間片輪轉法（RR）在早期的時間片輪轉法中，系統將全部的就緒進程按先來先服務的原則排成一個隊列，每次調度時，把CPU分配給隊首進程，並令其執行一個時間片。時間片的大小從幾ms到幾百ms。當執行的時間片用完時，由一個計時器發出時鐘中斷請求，調度程序便據此信號來中止該進程的執行，並將它送往就緒隊列的末尾；而後，再把處理機分配給就緒隊列中新的隊首進程，同時也讓它執行一個時間片。這樣就能夠保證就緒隊列中的全部進程在一給定的時間內均能得到一時間片的處理機執行時間。換言之，系統能在給定的時間內響應全部用戶的請求。
多級反饋隊列調度算法它是目前被公認的一種較好的進程調度算法。

應設置多個就緒隊列，併爲各個隊列賦予不一樣的優先級。第一個隊列的優先級最高，第二個隊列次之，其他各隊列的優先權逐個下降。該算法賦予各個隊列中進程執行時間片的大小也各不相同，在優先權愈高的隊列中，爲每一個進程所規定的執行時間片就愈小。例如，第二個隊列的時間片要比第一個隊列的時間片長一倍，……，第i+1個隊列的時間片要比第i個隊列的時間片長一倍。
當一個新進程進入內存後，首先將它放入第一隊列的末尾，按FCFS原則排隊等待調度。當輪到該進程執行時，如它能在該時間片內完成，即可準備撤離系統；若是它在一個時間片結束時還沒有完成，調度程序便將該進程轉入第二隊列的末尾，再一樣地按FCFS原則等待調度執行；若是它在第二隊列中運行一個時間片後仍未完成，再依次將它放入第三隊列，……，如此下去，當一個長做業(進程)從第一隊列依次降到第n隊列後，在第n 隊列便採起按時間片輪轉的方式運行。
僅當第一隊列空閒時，調度程序才調度第二隊列中的進程運行；僅當第1～(i-1)隊列均空時，纔會調度第i隊列中的進程運行。若是處理機正在第i隊列中爲某進程服務時，又有新進程進入優先權較高的隊列(第1～(i-1)中的任何一個隊列)，則此時新進程將搶佔正在運行進程的處理機，即由調度程序把正在運行的進程放回到第i隊列的末尾，把處理機分配給新到的高優先權進程。

5九、講講線程池的實現原理

首先要明確爲何要使用線程池，使用線程池會帶來什麼好處？

線程是稀缺資源，不能頻繁的建立。
應當將其放入一個池子中，能夠給其餘任務進行復用。
解耦做用，線程的建立於執行徹底分開，方便維護。

60、建立一個線程池

以一個使用較多的

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler);

爲例：