1) 什么是線程、進程？

進程是程序執行時的一個實例，是系統進行資源分配和調度的一個獨立單位。
線程是進程的一個實體,是CPU調度和分派的基本單位。

2) 線程和進程有什么區別？

(1) 調度：線程作為調度和分配的基本單位，進程作為擁有資源的基本單位
(2) 并發性：不僅進程之間可以并發執行，同一個進程的多個線程之間也可并發執行
(3) 擁有資源：進程是擁有資源的一個獨立單位，線程不擁有系統資源，但可以訪問隸屬于進程的資源
(4) 系統開銷：進程上下文切換比進程大

3) 如何在Java中實現線程？

兩種方式：繼承Thread類或者實現Runnable接口

public class Thread implements Runnable { ...}

public interface Runnable { ...}

4) 用Runnable還是Thread？

1、Runnable更容易實現資源共享
2、java的單繼承機制
在程序開發中只要是多線程肯定永遠以實現Runnable接口為主。

6) Thread 類中的start() 和 run() 方法有什么區別？

start()方法被用來啟動新創建的線程，而且start()內部調用了run()方法
當你調用run()方法的時候，只會是在原來的線程中調用，沒有新的線程啟動，start()方法才會啟動新線程

7) Java中Runnable和Callable有什么不同？

創建線程的兩種方式，一種是直接繼承Thread，另外一種就是實現Runnable接口。這兩種方式都有一個缺陷就是：在執行完任務之后無法獲取執行結果。如果需要獲取執行結果，就必須通過共享變量或者使用線程通信的方式來達到效果，這樣使用起來就比較麻煩。而自從Java 1.5開始，就提供了Callable和Future，通過它們可以在任務執行完畢之后得到任務執行結果。
參考：https://www.cnblogs.com/dolphin0520/p/3949310.html

8) Java中CyclicBarrier 和 CountDownLatch有什么不同？

CyclicBarrier 和 CountDownLatch 都可以用來讓一組線程等待其它線程。
1、CountDownlatch描述的是1個線程或N個線程等待其他線程的關系。
?????CyclicBarrier描述的是多個線程內部相互等待的關系。
2、CountDownlatch是一次性的，CyclicBarrier可重用

9) Java內存模型是什么？

Java內存模型（Java Memory Model ,JMM）就是一種符合內存模型規范的，屏蔽了各種硬件和操作系統的訪問差異的，保證了Java程序在各種平臺下對內存的訪問都能保證效果一致的機制及規范。

Java內存模型規定了所有的變量都存儲在主內存中，每條線程還有自己的工作內存，線程的工作內存中保存了該線程中是用到的變量的主內存副本拷貝，線程對變量的所有操作都必須在工作內存中進行，而不能直接讀寫主內存。不同的線程之間也無法直接訪問對方工作內存中的變量，線程間變量的傳遞均需要自己的工作內存和主存之間進行數據同步進行。

Java內存模型

10) Java中的volatile 變量是什么？

volatile是一個特殊的修飾符，只有成員變量才能使用它。volatile變量可以保證下一個讀取操作會在前一個寫操作之后發生。
1、保持內存可見性
每次讀取前必須先從主內存刷新最新的值。
每次寫入后必須立即同步回主內存當中。
2、防止指令重排
volatile關鍵字通過“內存屏障”來防止指令被重排序。
參考：https://www.cnblogs.com/monkeysayhi/p/7654460.html

11) 什么是線程安全？Vector是一個線程安全類嗎？

如果一段代碼在多線程和單線程環境下運行結果是一樣的，并且變量的值也和預期是一樣的，就是線程安全的。（強調的是正確性）
Vector 是用同步方法來實現線程安全的, 而和它相似的ArrayList不是線程安全的。

12) Java中什么是競態條件？ 舉個例子說明。

當兩個線程競爭同一資源時，如果對資源的訪問順序敏感，就稱存在競態條件。
導致競態條件發生的代碼區稱作臨界區。在臨界區中使用適當的同步就可以避免競態條件。 臨界區實現方法有兩種，一種是用synchronized，一種是用Lock顯式鎖實現。

常見競態條件：

• 先檢查后執行(Check-Then-Act)
• 和讀取-修改-寫入

13) Java中如何停止一個線程？

當run() 或者 call() 方法執行完的時候線程會自動結束。如果要手動結束一個線程：
1、你可以用volatile 的布爾變量來控制退出run()方法的循環
2、如果是運行狀態的線程，使用interrupt() 方法將中斷狀態設置為true，用isInterrupted() 方法判斷中斷是否為true狀態退出循環
3、對于被Object.wait, Thread.join和Thread.sleep三種方法之一阻塞的線程，使用interrupt() 方法將拋出一個 InterruptedException中斷異常（該線程必須事先預備好處理此異常），從而提早地終結被阻塞狀態。如果線程沒有被阻塞，這時調用 interrupt()將不起作用，直到執行到wait(),sleep(),join()時,才馬上會拋出 InterruptedException。

14) 一個線程運行時發生異常會怎樣？

如果異常沒有被捕獲該線程將會停止執行，同時釋放該線程持有的對象鎖。Thread.UncaughtExceptionHandler是用于處理未捕獲異常造成線程突然中斷情況的一個內嵌接口。

15） 如何在兩個線程間共享數據？

1，如果每個線程執行的代碼相同，可以使用同一個Runnable對象，這個Runnable對象中有那個共享數據，例如，賣票系統就可以這么做。

2，如果每個線程執行的代碼不同，這時候需要用不同的Runnable對象，例如，設計4個線程。其中兩個線程每次對j增加1，另外兩個線程對j每次減1，銀行存取款

16) Java中notify 和 notifyAll有什么區別？

• notify：只會喚醒等待該鎖的其中一個線程。
• notifyAll：喚醒等待該鎖的所有線程。

對象內部鎖
其實，每個對象都擁有兩個池，分別為鎖池(EntrySet)和(WaitSet)等待池。

鎖池：假如已經有線程A獲取到了鎖，這時候又有線程B需要獲取這把鎖(比如需要調用synchronized修飾的方法或者需要執行synchronized修飾的代碼塊)，由于該鎖已經被占用，所以線程B只能等待這把鎖，這時候線程B將會進入這把鎖的鎖池。

等待池：假設線程A獲取到鎖之后，由于一些條件的不滿足(例如生產者消費者模式中生產者獲取到鎖，然后判斷隊列為滿)，此時需要調用對象鎖的wait方法，那么線程A將放棄這把鎖，并進入這把鎖的等待池。
如果有其他線程調用了鎖的notify方法，則會根據一定的算法從等待池中選取一個線程，將此線程放入鎖池。
如果有其他線程調用了鎖的notifyAll方法，則會將等待池中所有線程全部放入鎖池，并爭搶鎖。

鎖池與等待池的區別：等待池中的線程不能獲取鎖，而是需要被喚醒進入鎖池，才有獲取到鎖的機會。

17) 為什么wait, notify 和 notifyAll這些方法不在thread類里面？

因為JAVA提供的鎖是對象級的而不是線程級的，每個對象都有鎖。

wait()，notify()，notifyAll()必須在sychronized同步代碼塊中使用，且要用當前線程持有的鎖來調用。
（1）為什么wait()必須在同步（Synchronized）方法/代碼塊中調用？
答：調用wait()就是釋放鎖，釋放鎖的前提是必須要先獲得鎖，先獲得鎖才能釋放鎖。
（2）為什么notify(),notifyAll()必須在同步（Synchronized）方法/代碼塊中調用？
答：notify(),notifyAll()是將鎖交給含有wait()方法的線程，讓其繼續執行下去，如果自身沒有鎖，怎么叫把鎖交給其他線程呢；（本質是讓處于入口隊列的線程競爭鎖）

首先，要明白，每個對象都可以被認為是一個"監視器monitor"，這個監視器由三部分組成（一個獨占鎖，一個入口隊列，一個等待隊列）。注意一個對象只能有一個獨占鎖，但是任意線程都可以擁有這個獨占鎖。

對于對象的非同步方法而言，任意時刻可以有任意個線程調用該方法。

對于對象的同步方法而言，只有擁有這個對象的獨占鎖才能調用這個同步方法。如果這個獨占鎖被其他線程占用，那么另外一個調用該同步方法的線程就會處于阻塞狀態，此線程進入入口隊列（鎖池）。

若一個擁有該獨占鎖的線程調用該對象同步方法的wait()方法，則該線程會釋放獨占鎖，并加入對象的等待隊列（等待池）；（為什么使用wait()？希望某個變量被設置之后再執行，notify()通知變量已經被設置。）

某個線程調用notify(),notifyAll()方法是將等待隊列（等待池）的線程轉移到入口隊列（鎖池），然后讓他們競爭鎖，所以這個調用線程本身必須擁有鎖。

18) 什么是ThreadLocal變量？

ThreadLocal實例為每個使用該變量的線程提供獨立的變量副本，所以每一個線程都可以獨立地改變自己的副本，而不會影響其它線程所對應的副本。
使用及原理：
1、定義

static ThreadLocal<User> threadLocal_1 = new ThreadLocal<>();
static ThreadLocal<Client> threadLocal_2 = new ThreadLocal<>();

2、設置值

// thread-1中
threadLocal_1.set(user_1);
threadLocal_2.set(client_1);

// thread-2中
threadLocal_1.set(user_2);
threadLocal_2.set(client_2);

3、運行時結構

運行時結構

當調用ThreadLocal的set()/get()方法的時候，首先獲取當前的線程Thread t = Thread.currentThread();

//ThreadLocalMap的set方法
public void set(T value) {
    Thread t = Thread.currentThread(); // 獲取當前線程
    ThreadLocalMap map = getMap(t); // 拿到當前線程的 ThreadLocalMap
    if (map != null) // 判斷 ThreadLocalMap 是否存在
        map.set(this, value); // 調用 ThreadLocalMap 的 set 方法
    else
        createMap(t, value); // 創建 ThreadLocalMap
}

之后通過當前線程去獲取ThreadLocalMap，ThreadLocalMap map = getMap(t);，getMap(t)方法源碼：

    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

通過傳入的線程類實例t，獲取線程t中的ThreadLocalMap對象，我們繼續追蹤Thread類，發現Thread的成員變量是包含一個 ThreadLocal.ThreadLocalMap實例。

    /* ThreadLocal values pertaining to this thread. This map is maintained
     * by the ThreadLocal class. */
    ThreadLocal.ThreadLocalMap threadLocals = null;

獲取到了ThreadLocalMap實例map后，判斷其是否為null，如果不為空，直接調用map.set(this, value)方法，將調用的ThreadLocal對象和傳入數據value存儲到map中。如果為null，則會調用createMap(t, value)方法，直接初始化ThreadLocalMap，賦值給線程t中的threadLocals。

   void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

通過對ThreadLocal的set方法的追蹤我們大致了解了ThreadLocal數據存儲的過程，每次存儲數據都會獲取方法被調用的線程，之后將數據和threadlocal對象存儲到對應線程的ThreadLocalMap中。這樣的存儲方式就實現了數據線程之間的隔離。通過不同線程取出的ThreadLocalMap是不同，自然獲取到存儲的數據也是不同的。

ThreadLocalMap是ThreadLocal的靜態內部類。每個線程持有自己的 ThreadLocalMap，ThreadLocalMap 初始容量為16（即圖中的16個槽位），ThreadLocalMap數據結構采用 數組 + 開放地址法（沖突未使用鏈表結構解決），Entry 繼承 WeakReference。

ThreadLocalMap使用ThreadLocal的弱引用

可能造成內存泄露原因：如上圖，ThreadLocalMap使用ThreadLocal的弱引用作為key，如果一個ThreadLocal沒有外部強引用引用他，那么系統gc的時候，這個ThreadLocal勢必會被回收，這樣一來，ThreadLocalMap中就會出現key為null的Entry，就沒有辦法訪問這些key為null的Entry的value，如果當前線程再遲遲不結束的話，這些key為null的Entry的value就會一直存在一條強引用鏈：
Thread Ref -> Thread -> ThreaLocalMap -> Entry -> value
永遠無法回收，造成內存泄露。

19) 什么是FutureTask？

在Java并發程序中FutureTask表示一個可以取消的異步運算。它有啟動和取消運算、查詢運算是否完成和取回運算結果等方法。只有當運算完成的時候結果才能取回，如果運算尚未完成get方法將會阻塞。一個FutureTask對象可以對調用了Callable和Runnable的對象進行包裝，由于FutureTask也是調用了Runnable接口所以它可以提交給Executor來執行。

20) Java中interrupted 和 isInterruptedd方法的區別？

interrupted() 和 isInterrupted()的主要區別是前者會將中斷狀態清除而后者不會。Java多線程的中斷機制是用內部標識來實現的，調用Thread.interrupt()來中斷一個線程就會設置中斷標識為true。當中斷線程調用靜態方法Thread.interrupted()來檢查中斷狀態時，中斷狀態會被清零。而非靜態方法isInterrupted()用來查詢其它線程的中斷狀態且不會改變中斷狀態標識。簡單的說就是任何拋出InterruptedException異常的方法都會將中斷狀態清零。無論如何，一個線程的中斷狀態有有可能被其它線程調用中斷來改變。

public class Thread{     
  public void interrupt(){...}     
  public boolean isInterrupted(){...}     
  public static boolean interrupted(){...} 
}

interrupt方法能中斷目標線程。調用interrupt并不意味著立即停止目標線程正在運行的工作，而只是傳遞了請求中斷的消息。

isInterrupted方法能返回目標線程的中斷狀態。

靜態的interrupted方法將清除當前線程的中斷狀態，并返回它之前的值，這也是清除中斷狀態的唯一方法。

23) Java中的同步集合與并發集合有什么區別？

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

同步容器是線程安全的。同步容器將所有對容器狀態的訪問都串行化，以實現他們的線程安全性。這種方法的代價是嚴重降低并發性，當多個線程競爭容器的鎖時，吞吐量將嚴重降低。并發容器是針對多個線程并發訪問設計的，改進了同步容器的性能。通過并發容器來代替同步容器，可以極大地提高伸縮性并降低風險。

24） Java中堆和棧有什么不同？

為什么把這個問題歸類在多線程和并發面試題里？因為棧是一塊和線程緊密相關的內存區域。每個線程都有自己的棧內存，用于存儲本地變量，方法參數和棧調用，一個線程中存儲的變量對其它線程是不可見的。而堆是所有線程共享的一片公用內存區域。對象都在堆里創建，為了提升效率線程會從堆中弄一個緩存到自己的棧，如果多個線程使用該變量就可能引發問題，這時volatile 變量就可以發揮作用了，它要求線程從主存中讀取變量的值。更多內容詳見答案。

25） 什么是線程池？ 為什么要使用它？

創建線程要花費昂貴的資源和時間，如果任務來了才創建線程那么響應時間會變長，而且一個進程能創建的線程數有限。為了避免這些問題，在程序啟動的時候就創建若干線程來響應處理，它們被稱為線程池，里面的線程叫工作線程。從JDK1.5開始，Java API提供了Executor框架讓你可以創建不同的線程池。比如單線程池，每次處理一個任務；數目固定的線程池或者是緩存線程池（一個適合很多生存期短的任務的程序的可擴展線程池）。更多內容詳見這篇文章。

線程池，從字面含義來看，是指一組同構工作線程的資源池。線程池與工作隊列密切相關的，其中在工作隊列中保存了所有等待執行的任務。工作者線程的任務很簡單：從工作隊列中獲取一個任務，執行任務，然后返回線程池并等待下一個任務。

“在線程池中執行任務”比“為每個任務分配一個線程”優勢更多。通過重用現有的線程而不是創建新線程，可以在處理多個請求時額分攤在線程創建和銷毀過程中產生的巨大開銷。另外一個好處是，當請求到達時，工作線程已經存在，因此不會猶豫等待創建線程而延遲任務的執行，從而提高了響應性。通過適當調整線程池的大小，可以創建足夠多的線程以便使處理器保持忙碌狀態，同時還可以防止過多線程相互競爭資源而使應用程序耗盡內存或失敗。

可以通過調用Executors中的靜態工廠方法之一來創建線程池：

（1）、newCachedThreadPool：創建一個可緩存的線程池；（如果線程池長度超過處理需要，可靈活回收空閑線程，若無可回收，則新建線程）

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

（2）、newFixedThreadPool：創建一個固定長度的線程池；（可控制線程最大并發數，超出的線程會在隊列中等待）

ExecutorService executorService = Executors.newFixedThreadPool(3);

（3）、newScheduleThreadPool：創建一個固定長度的線程池，而且以延遲或定時的方式來執行任務。

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);

（4）、newSingleThreadExecutor：創建一個單線程化的線程池，它只會用唯一的工作線程來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先級)執行。（如果當前線程意外終止，會創建一個新線程繼續執行任務，這和我們直接創建線程不同，也和newFixedThreadPool(1)不同。）

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

26） 如何寫代碼來解決生產者消費者問題？

http://www.lxweimin.com/p/e39270996bf9

27） 如何避免死鎖？

image

Java多線程中的死鎖

死鎖是指兩個或兩個以上的進程在執行過程中，因爭奪資源而造成的一種互相等待的現象，若無外力作用，它們都將無法推進下去。這是一個嚴重的問題，因為死鎖會讓你的程序掛起無法完成任務，死鎖的發生必須滿足以下四個條件：

• 互斥條件：一個資源每次只能被一個進程使用。

• 請求與保持條件：一個進程因請求資源而阻塞時，對已獲得的資源保持不放。

• 不可剝奪條件：進程已獲得的資源，在末使用完之前，不能強行剝奪。

• 循環等待條件：若干進程之間形成一種頭尾相接的循環等待資源關系。

如何避免死鎖？

• 加鎖順序（線程按照一定的順序加鎖）
• 加鎖時限（線程嘗試獲取鎖的時候加上一定的時限，超過時限則放棄對該鎖的請求，并釋放自己占有的鎖）
• 死鎖檢測

28) Java中活鎖和死鎖有什么區別？

1.死鎖：是指兩個或兩個以上的進程（或線程）在執行過程中，因爭奪資源而造成的一種互相等待的現象，若無外力作用，它們都將無法推進下去。此時稱系統處于死鎖狀態或系統產生了死鎖，這些永遠在互相等待的進程稱為死鎖進程。
2.活鎖：線程A和B都需要過橋(都需要使用進程),而都禮讓不走(那到的系統優先級相同,都認為不是自己優先級高),就這么僵持下去.（很紳士，互相謙讓）
3.饑餓：這是個獨木橋(單進程),橋上只能走一個人,B來到時A在橋上,B等待;
而此時比B年齡小的C來了,B讓C現行(A走完后系統把進程分給了C),
C上橋后,D又來了,B又讓D現行(C走完后系統把進程分個了D)
以此類推B一直是等待狀態

活鎖和死鎖類似，不同之處在于處于活鎖的線程或進程的狀態是不斷改變的，活鎖可以認為是一種特殊的饑餓。

29） 怎么檢測一個線程是否擁有鎖？

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

30) 你如何在Java中獲取線程堆棧？

對于不同的操作系統，有多種方法來獲得Java進程的線程堆棧。當你獲取線程堆棧時，JVM會把所有線程的狀態存到日志文件或者輸出到控制臺。在Windows你可以使用Ctrl + Break組合鍵來獲取線程堆棧，Linux下用kill -3命令。你也可以用jstack這個工具來獲取，它對線程id進行操作，你可以用jps這個工具找到id。

31) JVM中哪個參數是用來控制線程的棧堆棧小的

這個問題很簡單， -Xss參數用來控制線程的堆棧大小。

32） Java中synchronized 和 ReentrantLock 有什么不同？

（1）、synchronized通過object的wait()/notify()調度 lock通過condition調度
（2）、synchronized可加方法上或synchronized代碼塊使用 jvm c++實現，lock只能嵌套在代碼中java實現
（3）、不存在或并發低的情況下synchronized性能優于lock , 但是并發升高時synchronized性能下降很快
（4）、synchronized非公平鎖，lock可以指定公平性
（5）、synchronized代碼塊發生異常時能自動釋放鎖，lock需加在finally中，若lock出現死鎖也能通過有限時等待釋放死鎖

Lock lock = new ReenTrantLock(); 
... lock.lock(); 
try{     
  //更新對象狀態     
  //捕獲異常，并在必要時恢復不變性的條件 
}finally{
     lock.unlock(); 
}

我覺得這篇博文區別總結挺詳細： synchronized和鎖(ReentrantLock) 區別

33） 有三個線程T1，T2，T3，怎么確保它們按順序執行？

在多線程中有多種方法讓線程按特定順序執行，你可以用線程類的join()方法在一個線程中啟動另一個線程，另外一個線程完成該線程繼續執行。為了確保三個線程的順序你應該先啟動最后一個(T3調用T2，T2調用T1)，這樣T1就會先完成而T3最后完成。你可以查看這篇文章了解更多。

示例代碼如下：

public class JoinTest {
     public static void main(String[] args) {
         final Thread t1 = new Thread(new Runnable() {
             @Override
             public void run() {
                 System.out.println("t1");
             }
         });
         final Thread t2 = new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     t1.join(); 
                } catch (InterruptedException e) { 
                    e.printStackTrace(); 
                } 
                System.out.println("t2");
             } 
        }); 
        Thread t3 = new Thread(new Runnable() {
             @Override
             public void run() {
                 try { 
                    //引用t2線程，等待t2線程執行完
                     t2.join(); 
                } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
                 System.out.println("t3");
             }
         });
         t3.start();
         t2.start();
         t1.start(); 
    } 
}

34) Thread類中的yield方法有什么作用？

yield()的作用是讓步。它能讓當前線程由“運行狀態”進入到“就緒狀態”，從而讓其它具有相同優先級的等待線程獲取執行權；但是，并不能保證在當前線程調用yield()之后，其它具有相同優先級的線程就一定能獲得執行權；也有可能是當前線程又進入到“運行狀態”繼續運行！

35） Java中ConcurrentHashMap的并發度是什么？

ConcurrentHashMap把實際map劃分成若干部分來實現它的可擴展性和線程安全。這種劃分是使用并發度獲得的，它是ConcurrentHashMap類構造函數的一個可選參數，默認值為16，這樣在多線程情況下就能避免爭用。欲了解更多并發度和內部大小調整請閱讀我的文章How ConcurrentHashMap works in Java。

并發度可以理解為程序運行時能夠同時更新ConccurentHashMap且不產生鎖競爭的最大線程數，實際上就是ConcurrentHashMap中的分段鎖個數，即Segment[]的數組長度。ConcurrentHashMap默認的并發度為16，但用戶也可以在構造函數中設置并發度。當用戶設置并發度時，ConcurrentHashMap會使用大于等于該值的最小2冪指數作為實際并發度（假如用戶設置并發度為17，實際并發度則為32）。運行時通過將key的高n位（n = 32 – segmentShift）和并發度減1（segmentMask）做位與運算定位到所在的Segment。segmentShift與segmentMask都是在構造過程中根據concurrency level被相應的計算出來。

如果并發度設置的過小，會帶來嚴重的鎖競爭問題；如果并發度設置的過大，原本位于同一個Segment內的訪問會擴散到不同的Segment中，CPU cache命中率會下降，從而引起程序性能下降。（文檔的說法是根據你并發的線程數量決定，太多會導性能降低）。更多參考ConcurrentHashMap總結。

36） Java中Semaphore是什么？

Java中的Semaphore是一種新的同步類，它是一個計數信號。從概念上講，信號量維護了一個許可集合，許可的初始數量可以通過構造函數來指定。如有必要，在許可可用前會阻塞每一個 acquire()，然后再獲取該許可。每個 release()添加一個許可，從而可能釋放一個正在阻塞的獲取者。但是，不使用實際的許可對象，Semaphore只對可用許可的號碼進行計數，并采取相應的行動。信號量常常用于多線程的代碼中，比如數據庫連接池。更多詳細信息請點擊這里。

37）如果你提交任務時，線程池隊列已滿。會時發會生什么？

這個問題問得很狡猾，許多程序員會認為該任務會阻塞直到線程池隊列有空位。事實上如果一個任務不能被調度執行那么ThreadPoolExecutor’s submit()方法將會拋出一個RejectedExecutionException異常。

當有界隊列被填滿后，拒絕策略開始發揮作用。ThreadPoolExecutor的拒絕策略可以通過setRejectExecutionHandler來修改。（如果某個任務被提交到一個已經被關閉的Executor時，也會用到飽和策略。）JDK提供了幾種不同的RejectExecutionHandler實現，每種實現都包含有不同的拒絕策略：AbortPolicy、DiscardPolicy和DiscardOldestPolicy、CallerRunsPolicy。

中止策略(AbortPolicy)是默認的拒絕策略，該策略將拋出未檢查的RejectedExecutionException。調用者可以捕獲這個異常，然后根據需求編寫自己的處理代碼。當新任務的提交無法保存到隊列中等待執行的時候，
拋棄策略(DiscardPolicy)會悄悄拋棄該任務。
拋棄最舊的策略(DiscardOldestPolicy)則會拋棄下一個將被執行的任務，然后嘗試重新提交新的任務。
“調用者運行”策略(CallerRunsPolicy)實現了一種調節機制，該策略既不會拋棄任務，也不會拋出異常，而是將某些任務回退到調用者，從而降低新任務的流量。

38) Java線程池中submit() 和 execute()方法有什么區別？

兩個方法都可以向線程池提交任務，execute()方法的返回類型是void，用于提交不需要返回值的任務，它定義在Executor接口中； 而submit()方法用于提交需要返回值的任務，該可以返回持有計算結果的Future對象，通過這個Future對象可以判斷任務是否執行成功，并且可以通過Future的get()方法來獲取返回值，它定義在ExecutorService接口中，它擴展了Executor接口，其它線程池類像ThreadPoolExecutor和ScheduledThreadPoolExecutor都有這些方法。

    ExecutorService executorService =  Executors.newCachedThreadPool();         executorService.execute(new Runnable() {
             @Override
             public void run() {
                 // TODO Auto-generated method stub
             }
         });

ExecutorService executorService =  Executors.newCachedThreadPool();
         Callable<String> callable = new Callable<String>() {
             public String call() throws Exception {
                 System.out.println("This is  ThreadPoolExetor#submit(Callable<T> task) method.");                 return "result";
             }
         };
         Future<?> future = executorService.submit(callable);
         try {
             Object s = future.get();
         } catch (InterruptedException e) {
             //處理中中斷異常
         } catch (ExecutionException e) {
             //處理無法執行任務異常
         } finally { 
            executorService.shutdown();
         } 

39) 什么是阻塞式方法？

阻塞式方法是指程序會一直等待該方法完成期間不做其他事情，ServerSocket的accept()方法就是一直等待客戶端連接。這里的阻塞是指調用結果返回之前，當前線程會被掛起，直到得到結果之后才會返回。此外，還有異步和非阻塞式方法在任務完成前就返回。更多詳細信息請點擊這里。

44） Java中的ReadWriteLock是什么？

一般而言，讀寫鎖是用來提升并發程序性能的鎖分離技術的成果。Java中的ReadWriteLock是Java 5 中新增的一個接口，一個ReadWriteLock維護一對關聯的鎖，一個用于只讀操作一個用于寫。在沒有寫線程的情況下一個讀鎖可能會同時被多個讀線程持有。寫鎖是獨占的，你可以使用JDK中的ReentrantReadWriteLock來實現這個規則，它最多支持65535個寫鎖和65535個讀鎖。

public interface ReadWriteLock{
     Lock readLock();
     Lock writeLock();
 }

在讀寫鎖的加鎖策略中，允許多個讀操作同時進行，但每次只允許一個寫操作。

讀寫鎖是一種性能優化措施，在一些特定的情況下能實現更高的并發性。在實際情況中，對于在多處理器系統上被頻繁讀取的數據結構，讀寫鎖能夠提高性能。而在其他情況下，讀寫鎖的性能比獨占鎖的性能要略差一些，這是因為它們的復雜性更高。

45) 多線程中的忙循環是什么?

忙循環就是程序員用循環讓一個線程等待，不像傳統方法wait(), sleep() 或 yield() 它們都放棄了CPU控制，而忙循環不會放棄CPU，它就是在運行一個空循環。這么做的目的是為了保留CPU緩存，在多核系統中，一個等待線程醒來的時候可能會在另一個內核運行，這樣會重建緩存。為了避免重建緩存和減少等待重建的時間就可以使用它了。你可以查看這篇文章獲得更多信息。

46）volatile 變量和 atomic 變量有什么不同？

這是個有趣的問題。首先，volatile 變量和 atomic 變量看起來很像，但功能卻不一樣。Volatile變量可以確保先行關系，即寫操作會發生在后續的讀操作之前, 但它并不能保證原子性。例如用volatile修飾count變量那么 count++ 操作就不是原子性的。而AtomicInteger類提供的atomic方法可以讓這種操作具有原子性如getAndIncrement()方法會原子性的進行增量操作把當前值加一，其它數據類型和引用變量也可以進行相似操作。

47) 如果同步塊內的線程拋出異常會發生什么？

這個問題坑了很多Java程序員，若你能想到鎖是否釋放這條線索來回答還有點希望答對。無論你的同步塊是正常還是異常退出的，里面的線程都會釋放鎖，所以對比鎖接口我更喜歡同步塊，因為它不用我花費精力去釋放鎖，該功能可以在finally block里釋放鎖實現。

48） 單例模式的雙檢鎖是什么？

這個問題在Java面試中經常被問到，但是面試官對回答此問題的滿意度僅為50%。一半的人寫不出雙檢鎖還有一半的人說不出它的隱患和Java1.5是如何對它修正的。它其實是一個用來創建線程安全的單例的老方法，當單例實例第一次被創建時它試圖用單個鎖進行性能優化，但是由于太過于復雜在JDK1.4中它是失敗的，我個人也不喜歡它。無論如何，即便你也不喜歡它但是還是要了解一下，因為它經常被問到。你可以查看how double checked locking on Singleton works這篇文章獲得更多信息。

在早期的JVM中，同步（甚至是無競爭的同步）都存在著巨大的性能開銷。因此，人們想出來了許多“聰明的”技巧來降低同步的影響，有些技巧很好，有些技巧是不好的，甚至是糟糕的，DCL就屬于“糟糕”的一類。

public class DoubleCheckedLocking {     private static Resource resource;     public static Resource getInstance() {         if (resource == null) {             synchronized (DoubleCheckedLocking.class) {                 if (resource == null) {                     resource = new Resource();                 }             }         }         return resource;     } }

DCL的真正問題在于：當在沒有同步的情況下讀取一個共享對象時，可能發生的最糟糕的事情只是看到一個失效值（在這種情況下是一個空值），此時DCL方法將通過在持有鎖的情況下再次嘗試來避免這種風險。然而實際情況遠比這種情況糟糕——線程可能看到引用的當前值，但對象的狀態值卻是失效的，這意味著線程可以看到對象處于無效或錯誤的狀態。

在JVM的后續版本中（Java 5.0以及更高的版本）中，如果resource聲明為volatile類型，那么就能啟用DCL，并且這種凡是對性能的影響很小，因為volatile變量讀取操作的性能通常只是略高于非volatile變量讀取操作的性能。

public class Singleton {     private volatile static Singleton uniqueInstance;     private Singleton() {     }     public static Singleton getInstance() {         //檢查實例，如果不存在則進入同步代碼塊         //注意：只有第一次，才徹底執行if中所有代碼         if (uniqueInstance == null) {             synchronized (Singleton.class) {                 //進入區塊后，再檢查一次。如果仍然是null，才創建實例                 if (uniqueInstance == null) {                     uniqueInstance = new Singleton();                 }             }         }         return uniqueInstance;     } } 

然而，DCL的這種使用方法已經被廣泛地廢棄了——促使該模式出現的動力（無競爭同步的執行速度很慢，以及JVM啟動時很慢）已經不復存在了，因為它不是一種高效地優化措施。延遲初始化占位類模式能帶來同樣的優勢，并且更容易理解。

“延遲初始化占位類模式”中使用了一個專門的類來初始化Resource。JVM將推遲ResourceHolder的初始化操作，直到開始使用這個類時才初始化，并且由于通過一個靜態初始化來初始化Resource，因此不需要額外的同步。當任何一個線程第一次調用getResource時，都會使ResourceHolder被加載和被初始化，此時靜態初始化器將執行Resource的初始化操作。

public class ResourceFactory {     private static class ResourceHolder {         public static Resource resource = new Resource();     }     public static Resource getResource() {         return ResourceHolder.resource;     } }

49） 如何在Java中創建線程安全的Singleton？

這是上面那個問題的后續，如果你不喜歡雙檢鎖而面試官問了創建Singleton類的替代方法，你可以利用JVM的類加載和靜態變量初始化特征來創建Singleton實例，或者是利用枚舉類型來創建Singleton，我很喜歡用這種方法。你可以查看如何優雅地手寫單例模式獲得更多信息。

50) 寫出3條你遵循的多線程最佳實踐

這種問題我最喜歡了，我相信你在寫并發代碼來提升性能的時候也會遵循某些最佳實踐。以下三條最佳實踐我覺得大多數Java程序員都應該遵循：

• 給你的線程起個有意義的名字。

  這樣可以方便找bug或追蹤。OrderProcessor, QuoteProcessor or TradeProcessor 這種名字比 Thread-1. Thread-2 and Thread-3 好多了，給線程起一個和它要完成的任務相關的名字，所有的主要框架甚至JDK都遵循這個最佳實踐。

• 避免鎖定和縮小同步的范圍

  鎖花費的代價高昂且上下文切換更耗費時間空間，試試最低限度的使用同步和鎖，縮小臨界區。因此相對于同步方法我更喜歡同步塊，它給我擁有對鎖的絕對控制權。

• 多用同步類少用wait 和 notify

  首先，CountDownLatch, Semaphore, CyclicBarrier 和 Exchanger 這些同步類簡化了編碼操作，而用wait和notify很難實現對復雜控制流的控制。其次，這些類是由最好的企業編寫和維護在后續的JDK中它們還會不斷優化和完善，使用這些更高等級的同步工具你的程序可以不費吹灰之力獲得優化。

• 多用并發集合少用同步集合

  這是另外一個容易遵循且受益巨大的最佳實踐，并發集合比同步集合的可擴展性更好，所以在并發編程時使用并發集合效果更好。如果下一次你需要用到map，你應該首先想到用ConcurrentHashMap。我的文章Java并發集合有更詳細的說明。

51) 如何強制啟動一個線程？

這個問題就像是如何強制進行Java垃圾回收，目前還沒有覺得方法，雖然你可以使用System.gc()來進行垃圾回收，但是不保證能成功。在Java里面沒有辦法強制啟動一個線程，它是被線程調度器控制著且Java沒有公布相關的API。

52) Java中的fork join框架是什么？

fork join框架是JDK7中出現的一款高效的工具，Java開發人員可以通過它充分利用現代服務器上的多處理器。它是專門為了那些可以遞歸劃分成許多子模塊設計的，目的是將所有可用的處理能力用來提升程序的性能。fork join框架一個巨大的優勢是它使用了工作竊取算法，可以完成更多任務的工作線程可以從其它線程中竊取任務來執行。你可以查看這篇文章獲得更多信息。

53） Java多線程中調用wait() 和 sleep()方法有什么不同？

Java程序中wait 和 sleep都會造成某種形式的暫停，它們可以滿足不同的需要。wait()方法用于線程間通信，如果等待條件為真且其它線程被喚醒時它會釋放鎖，而sleep()方法僅僅釋放CPU資源或者讓當前線程停止執行一段時間，但不會釋放鎖。你可以查看這篇文章獲得更多信息。