Java並發編程73道面試題及答案 —— 面試穩了
- 2019 年 11 月 5 日
- 筆記
作者：烏梟 來自：https://blog.csdn.net/qq_34039315/article/details/78549311
最近後台和微信理有很多讀者讓我整理一些面試題，我就把這事放在心上了，於是在各大網站和其他公眾號裡面搜索麵試相關的高品質文章或者資訊，今天主要整理一下 Java 並發編程在面試中的常見問題，希望對需要的讀者有用。
1、在java中守護執行緒和本地執行緒區別？
java中的執行緒分為兩種：守護執行緒（Daemon）和用戶執行緒（User）。
任何執行緒都可以設置為守護執行緒和用戶執行緒，通過方法Thread.setDaemon(bool on)；true則把該執行緒設置為守護執行緒，反之則為用戶執行緒。Thread.setDaemon()必須在Thread.start()之前調用，否則運行時會拋出異常。
兩者的區別： 唯一的區別是判斷虛擬機(JVM)何時離開，Daemon是為其他執行緒提供服務，如果全部的User Thread已經撤離，Daemon 沒有可服務的執行緒，JVM撤離。也可以理解為守護執行緒是JVM自動創建的執行緒（但不一定），用戶執行緒是程式創建的執行緒；比如JVM的垃圾回收執行緒是一個守護執行緒，當所有執行緒已經撤離，不再產生垃圾，守護執行緒自然就沒事可幹了，當垃圾回收執行緒是Java虛擬機上僅剩的執行緒時，Java虛擬機會自動離開。
擴展：Thread Dump列印出來的執行緒資訊，含有daemon字樣的執行緒即為守護進程，可能會有：服務守護進程、編譯守護進程、windows下的監聽Ctrl+break的守護進程、Finalizer守護進程、引用處理守護進程、GC守護進程。 2、執行緒與進程的區別？
進程是作業系統分配資源的最小單元，執行緒是作業系統調度的最小單元。
一個程式至少有一個進程,一個進程至少有一個執行緒。 3、什麼是多執行緒中的上下文切換？
多執行緒會共同使用一組電腦上的CPU，而執行緒數大於給程式分配的CPU數量時，為了讓各個執行緒都有執行的機會，就需要輪轉使用CPU。不同的執行緒切換使用CPU發生的切換數據等就是上下文切換。 4、死鎖與活鎖的區別，死鎖與飢餓的區別？
死鎖：是指兩個或兩個以上的進程（或執行緒）在執行過程中，因爭奪資源而造成的一種互相等待的現象，若無外力作用，它們都將無法推進下去。
產生死鎖的必要條件：
- 互斥條件：所謂互斥就是進程在某一時間內獨佔資源。
- 請求與保持條件：一個進程因請求資源而阻塞時，對已獲得的資源保持不放。
- 不剝奪條件:進程已獲得資源，在末使用完之前，不能強行剝奪。
- 循環等待條件:若干進程之間形成一種頭尾相接的循環等待資源關係。
活鎖：任務或者執行者沒有被阻塞，由於某些條件沒有滿足，導致一直重複嘗試，失敗，嘗試，失敗。
活鎖和死鎖的區別在於，處於活鎖的實體是在不斷的改變狀態，所謂的「活」， 而處於死鎖的實體表現為等待；活鎖有可能自行解開，死鎖則不能。
飢餓：一個或者多個執行緒因為種種原因無法獲得所需要的資源，導致一直無法執行的狀態。
Java中導致飢餓的原因：
- 高優先順序執行緒吞噬所有的低優先順序執行緒的CPU時間。
- 執行緒被永久堵塞在一個等待進入同步塊的狀態，因為其他執行緒總是能在它之前持續地對該同步塊進行訪問。
- 執行緒在等待一個本身也處於永久等待完成的對象(比如調用這個對象的wait方法)，因為其他執行緒總是被持續地獲得喚醒。
5、Java中用到的執行緒調度演算法是什麼？
採用時間片輪轉的方式。可以設置執行緒的優先順序，會映射到下層的系統上面的優先順序上，如非特別需要，盡量不要用，防止執行緒飢餓。 6、什麼是執行緒組，為什麼在Java中不推薦使用？
ThreadGroup類，可以把執行緒歸屬到某一個執行緒組中，執行緒組中可以有執行緒對象，也可以有執行緒組，組中還可以有執行緒，這樣的組織結構有點類似於樹的形式。
為什麼不推薦使用？因為使用有很多的安全隱患吧，沒有具體追究，如果需要使用，推薦使用執行緒池。 7、為什麼使用Executor框架？
- 每次執行任務創建執行緒 new Thread()比較消耗性能，創建一個執行緒是比較耗時、耗資源的。
- 調用 new Thread()創建的執行緒缺乏管理，被稱為野執行緒，而且可以無限制的創建，執行緒之間的相互競爭會導致過多佔用系統資源而導致系統癱瘓，還有執行緒之間的頻繁交替也會消耗很多系統資源。
- 接使用new Thread() 啟動的執行緒不利於擴展，比如定時執行、定期執行、定時定期執行、執行緒中斷等都不便實現。
8、在Java中Executor和Executors的區別？
Executors 工具類的不同方法按照我們的需求創建了不同的執行緒池，來滿足業務的需求。
Executor 介面對象能執行我們的執行緒任務。
ExecutorService介面繼承了Executor介面並進行了擴展，提供了更多的方法我們能獲得任務執行的狀態並且可以獲取任務的返回值。
使用ThreadPoolExecutor 可以創建自定義執行緒池。
Future 表示非同步計算的結果，他提供了檢查計算是否完成的方法，以等待計算的完成，並可以使用get()方法獲取計算的結果。 9、什麼是原子操作？在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來累加來反映中間有沒有變過） 10、Java Concurrency API中的Lock介面(Lock interface)是什麼？對比同步它有什麼優勢？
Lock介面比同步方法和同步塊提供了更具擴展性的鎖操作。
他們允許更靈活的結構，可以具有完全不同的性質，並且可以支援多個相關類的條件對象。
它的優勢有：
- 可以使鎖更公平
- 可以使執行緒在等待鎖的時候響應中斷
- 可以讓執行緒嘗試獲取鎖，並在無法獲取鎖的時候立即返回或者等待一段時間
- 可以在不同的範圍，以不同的順序獲取和釋放鎖
整體上來說Lock是synchronized的擴展版，Lock提供了無條件的、可輪詢的(tryLock方法)、定時的(tryLock帶參方法)、可中斷的(lockInterruptibly)、可多條件隊列的(newCondition方法)鎖操作。另外Lock的實現類基本都支援非公平鎖(默認)和公平鎖，synchronized只支援非公平鎖，當然，在大部分情況下，非公平鎖是高效的選擇。 11、什麼是Executors框架？
Executor框架是一個根據一組執行策略調用，調度，執行和控制的非同步任務的框架。
無限制的創建執行緒會引起應用程式記憶體溢出。所以創建一個執行緒池是個更好的的解決方案，因為可以限制執行緒的數量並且可以回收再利用這些執行緒。利用Executors框架可以非常方便的創建一個執行緒池。 12、什麼是阻塞隊列？阻塞隊列的實現原理是什麼？如何使用阻塞隊列來實現生產者-消費者模型？
阻塞隊列（BlockingQueue）是一個支援兩個附加操作的隊列。
這兩個附加的操作是：在隊列為空時，獲取元素的執行緒會等待隊列變為非空。當隊列滿時，存儲元素的執行緒會等待隊列可用。
阻塞隊列常用於生產者和消費者的場景，生產者是往隊列里添加元素的執行緒，消費者是從隊列里拿元素的執行緒。阻塞隊列就是生產者存放元素的容器，而消費者也只從容器里拿元素。
JDK7提供了7個阻塞隊列。分別是：
ArrayBlockingQueue ：一個由數組結構組成的有界阻塞隊列。
LinkedBlockingQueue ：一個由鏈表結構組成的有界阻塞隊列。
PriorityBlockingQueue ：一個支援優先順序排序的無界阻塞隊列。
DelayQueue：一個使用優先順序隊列實現的無界阻塞隊列。
SynchronousQueue：一個不存儲元素的阻塞隊列。
LinkedTransferQueue：一個由鏈表結構組成的無界阻塞隊列。
LinkedBlockingDeque：一個由鏈表結構組成的雙向阻塞隊列。
Java 5之前實現同步存取時，可以使用普通的一個集合，然後在使用執行緒的協作和執行緒同步可以實現生產者，消費者模式，主要的技術就是用好，wait ,notify,notifyAll,sychronized這些關鍵字。而在java 5之後，可以使用阻塞隊列來實現，此方式大大簡少了程式碼量，使得多執行緒編程更加容易，安全方面也有保障。
BlockingQueue介面是Queue的子介面，它的主要用途並不是作為容器，而是作為執行緒同步的的工具，因此他具有一個很明顯的特性，當生產者執行緒試圖向BlockingQueue放入元素時，如果隊列已滿，則執行緒被阻塞，當消費者執行緒試圖從中取出一個元素時，如果隊列為空，則該執行緒會被阻塞，正是因為它所具有這個特性，所以在程式中多個執行緒交替向BlockingQueue中放入元素，取出元素，它可以很好的控制執行緒之間的通訊。
阻塞隊列使用最經典的場景就是socket客戶端數據的讀取和解析，讀取數據的執行緒不斷將數據放入隊列，然後解析執行緒不斷從隊列取數據解析。 13、什麼是Callable和Future?
Callable介面類似於Runnable，從名字就可以看出來了，但是Runnable不會返回結果，並且無法拋出返回結果的異常，而Callable功能更強大一些，被執行緒執行後，可以返回值，這個返回值可以被Future拿到，也就是說，Future可以拿到非同步執行任務的返回值。
可以認為是帶有回調的Runnable。
Future介面表示非同步任務，是還沒有完成的任務給出的未來結果。所以說Callable用於產生結果，Future用於獲取結果。 14、什麼是FutureTask?使用ExecutorService啟動任務。
在Java並發程式中FutureTask表示一個可以取消的非同步運算。它有啟動和取消運算、查詢運算是否完成和取回運算結果等方法。只有當運算完成的時候結果才能取回，如果運算尚未完成get方法將會阻塞。一個FutureTask對象可以對調用了Callable和Runnable的對象進行包裝，由於FutureTask也是調用了Runnable介面所以它可以提交給Executor來執行。 15、什麼是並發容器的實現？
何為同步容器：可以簡單地理解為通過synchronized來實現同步的容器，如果有多個執行緒調用同步容器的方法，它們將會串列執行。比如Vector，Hashtable，以及Collections.synchronizedSet，synchronizedList等方法返回的容器。
可以通過查看Vector，Hashtable等這些同步容器的實現程式碼，可以看到這些容器實現執行緒安全的方式就是將它們的狀態封裝起來，並在需要同步的方法上加上關鍵字synchronized。
並發容器使用了與同步容器完全不同的加鎖策略來提供更高的並發性和伸縮性，例如在ConcurrentHashMap中採用了一種粒度更細的加鎖機制，可以稱為分段鎖，在這種鎖機制下，允許任意數量的讀執行緒並發地訪問map，並且執行讀操作的執行緒和寫操作的執行緒也可以並發的訪問map，同時允許一定數量的寫操作執行緒並發地修改map，所以它可以在並發環境下實現更高的吞吐量。 16、多執行緒同步和互斥有幾種實現方法，都是什麼？
執行緒同步是指執行緒之間所具有的一種制約關係，一個執行緒的執行依賴另一個執行緒的消息，當它沒有得到另一個執行緒的消息時應等待，直到消息到達時才被喚醒。
執行緒互斥是指對於共享的進程系統資源，在各單個執行緒訪問時的排它性。當有若干個執行緒都要使用某一共享資源時，任何時刻最多只允許一個執行緒去使用，其它要使用該資源的執行緒必須等待，直到佔用資源者釋放該資源。執行緒互斥可以看成是一種特殊的執行緒同步。
執行緒間的同步方法大體可分為兩類：用戶模式和內核模式。顧名思義，內核模式就是指利用系統內核對象的單一性來進行同步，使用時需要切換內核態與用戶態，而用戶模式就是不需要切換到內核態，只在用戶態完成操作。
用戶模式下的方法有：原子操作（例如一個單一的全局變數），臨界區。內核模式下的方法有：事件，訊號量，互斥量。 17、什麼是競爭條件？你怎樣發現和解決競爭？
當多個進程都企圖對共享數據進行某種處理，而最後的結果又取決於進程運行的順序時，則我們認為這發生了競爭條件（race condition）。 18、你將如何使用thread dump？你將如何分析Thread dump？
- 新建狀態（New） 用new語句創建的執行緒處於新建狀態，此時它和其他Java對象一樣，僅僅在堆區中被分配了記憶體。
- 就緒狀態（Runnable） 當一個執行緒對象創建後，其他執行緒調用它的start()方法，該執行緒就進入就緒狀態，Java虛擬機會為它創建方法調用棧和程式計數器。處於這個狀態的執行緒位於可運行池中，等待獲得CPU的使用權。
- 運行狀態（Running） 處於這個狀態的執行緒佔用CPU，執行程式程式碼。只有處於就緒狀態的執行緒才有機會轉到運行狀態。
- 阻塞狀態（Blocked） 阻塞狀態是指執行緒因為某些原因放棄CPU，暫時停止運行。當執行緒處於阻塞狀態時，Java虛擬機不會給執行緒分配CPU。直到執行緒重新進入就緒狀態，它才有機會轉到運行狀態。 阻塞狀態可分為以下3種： ① 位於對象等待池中的阻塞狀態（Blocked in object』s wait pool）：當執行緒處於運行狀態時，如果執行了某個對象的wait()方法，Java虛擬機就會把執行緒放到這個對象的等待池中，這涉及到「執行緒通訊」的內容。 ② 位於對象鎖池中的阻塞狀態（Blocked in object』s lock pool）：當執行緒處於運行狀態時，試圖獲得某個對象的同步鎖時，如果該對象的同步鎖已經被其他執行緒佔用，Java虛擬機就會把這個執行緒放到這個對象的鎖池中，這涉及到「執行緒同步」的內容。 ③ 其他阻塞狀態（Otherwise Blocked）：當前執行緒執行了sleep()方法，或者調用了其他執行緒的join()方法，或者發出了I/O請求時，就會進入這個狀態。
- 死亡狀態（Dead） 當執行緒退出run()方法時，就進入死亡狀態，該執行緒結束生命周期。
我們運行之前的那個死鎖程式碼SimpleDeadLock.java，然後嘗試輸出資訊(/*這是注釋，作者自己加的*/)：
/* 時間，jvm資訊 */ 2017-11-01 17:36:28 Full thread dump Java HotSpot(TM) 64-Bit Server VM (25.144-b01 mixed mode): /* 執行緒名稱：DestroyJavaVM 編號：#13 優先順序：5 系統優先順序：0 jvm內部執行緒id：0x0000000001c88800 對應系統執行緒id（NativeThread ID）：0x1c18 執行緒狀態： waiting on condition [0x0000000000000000] （等待某個條件） 執行緒詳細狀態：java.lang.Thread.State: RUNNABLE 及之後所有*/ "DestroyJavaVM" #13 prio=5 os_prio=0 tid=0x0000000001c88800 nid=0x1c18 waiting on condition [0x0000000000000000] java.lang.Thread.State: RUNNABLE "Thread-1" #12 prio=5 os_prio=0 tid=0x0000000018d49000 nid=0x17b8 waiting for monitor entry [0x0000000019d7f000] /* 執行緒狀態：阻塞（在對象同步上） 程式碼位置：at com.leo.interview.SimpleDeadLock$B.run(SimpleDeadLock.java:56) 等待鎖：0x00000000d629b4d8 已經獲得鎖：0x00000000d629b4e8*/ java.lang.Thread.State: BLOCKED (on object monitor) at com.leo.interview.SimpleDeadLock$B.run(SimpleDeadLock.java:56) - waiting to lock <0x00000000d629b4d8> (a java.lang.Object) - locked <0x00000000d629b4e8> (a java.lang.Object) "Thread-0" #11 prio=5 os_prio=0 tid=0x0000000018d44000 nid=0x1ebc waiting for monitor entry [0x000000001907f000] java.lang.Thread.State: BLOCKED (on object monitor) at com.leo.interview.SimpleDeadLock$A.run(SimpleDeadLock.java:) - waiting to lock <0x00000000d629b4e8> (a java.lang.Object) - locked <0x00000000d629b4d8> (a java.lang.Object) "Service Thread" #10 daemon prio=9 os_prio=0 tid=0x0000000018ca5000 nid=0x1264 runnable [0x0000000000000000] java.lang.Thread.State: RUNNABLE "C1 CompilerThread2" #9 daemon prio=9 os_prio=2 tid=0x0000000018c46000 nid=0xb8c waiting on condition [0x0000000000000000] java.lang.Thread.State: RUNNABLE "C2 CompilerThread1" #8 daemon prio=9 os_prio=2 tid=0x0000000018be4800 nid=0x1db4 waiting on condition [0x0000000000000000] java.lang.Thread.State: RUNNABLE "C2 CompilerThread0" #7 daemon prio=9 os_prio=2 tid=0x0000000018be3800 nid=0x810 waiting on condition [0x0000000000000000] java.lang.Thread.State: RUNNABLE "Monitor Ctrl-Break" #6 daemon prio=5 os_prio=0 tid=0x0000000018bcc800 nid=0x1c24 runnable [0x00000000193ce000] java.lang.Thread.State: RUNNABLE at java.net.SocketInputStream.socketRead0(Native Method) at java.net.SocketInputStream.socketRead(SocketInputStream.java:) at java.net.SocketInputStream.read(SocketInputStream.java:) at java.net.SocketInputStream.read(SocketInputStream.java:) at sun.nio.cs.StreamDecoder.readBytes(StreamDecoder.java:) at sun.nio.cs.StreamDecoder.implRead(StreamDecoder.java:) at sun.nio.cs.StreamDecoder.read(StreamDecoder.java:) - locked <0x00000000d632b928> (a java.io.InputStreamReader) at java.io.InputStreamReader.read(InputStreamReader.java:) at java.io.BufferedReader.fill(BufferedReader.java:) at java.io.BufferedReader.readLine(BufferedReader.java:) - locked <0x00000000d632b928> (a java.io.InputStreamReader) at java.io.BufferedReader.readLine(BufferedReader.java:) at com.intellij.rt.execution.application.AppMainV2$1.run(AppMainV2.java:) "Attach Listener" #5 daemon prio=5 os_prio=2 tid=0x0000000017781800 nid=0x524 runnable [0x0000000000000000] java.lang.Thread.State: RUNNABLE "Signal Dispatcher" #4 daemon prio=9 os_prio=2 tid=0x000000001778f800 nid=0x1b08 waiting on condition [0x0000000000000000] java.lang.Thread.State: RUNNABLE "Finalizer" #3 daemon prio=8 os_prio=1 tid=0x000000001776a800 nid=0xdac in Object.wait() [0x0000000018b6f000] java.lang.Thread.State: WAITING (on object monitor) at java.lang.Object.wait(Native Method) - waiting on <0x00000000d6108ec8> (a java.lang.ref.ReferenceQueue$Lock) at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:) - locked <0x00000000d6108ec8> (a java.lang.ref.ReferenceQueue$Lock) at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:) at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:) "Reference Handler" #2 daemon prio=10 os_prio=2 tid=0x0000000017723800 nid=0x1670 in Object.wait() [0x00000000189ef000] java.lang.Thread.State: WAITING (on object monitor) at java.lang.Object.wait(Native Method) - waiting on <0x00000000d6106b68> (a java.lang.ref.Reference$Lock) at java.lang.Object.wait(Object.java:) at java.lang.ref.Reference.tryHandlePending(Reference.java:) - locked <0x00000000d6106b68> (a java.lang.ref.Reference$Lock) at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:) "VM Thread" os_prio= tid=0x000000001771b800 nid=0x604 runnable "GC task thread#0 (ParallelGC)" os_prio= tid=0x0000000001c9d800 nid=0x9f0 runnable "GC task thread#1 (ParallelGC)" os_prio= tid=0x0000000001c9f000 nid=0x154c runnable "GC task thread#2 (ParallelGC)" os_prio= tid=0x0000000001ca0800 nid=0xcd0 runnable "GC task thread#3 (ParallelGC)" os_prio= tid=0x0000000001ca2000 nid=0x1e58 runnable "VM Periodic Task Thread" os_prio= tid=0x0000000018c5a000 nid=0x1b58 waiting on condition JNI global references: /* 此處可以看待死鎖的相關資訊！ */ Found one Java-level deadlock: ============================= "Thread-1": waiting to lock monitor 0x0000000017729fc8 (object 0x00000000d629b4d8, a java.lang.Object), which is held by "Thread-0" "Thread-0": waiting to lock monitor 0x0000000017727738 (object 0x00000000d629b4e8, a java.lang.Object), which is held by "Thread-1" Java stack information for the threads listed above: =================================================== "Thread-1": at com.leo.interview.SimpleDeadLock$B.run(SimpleDeadLock.java:) - waiting to lock <0x00000000d629b4d8> (a java.lang.Object) - locked <0x00000000d629b4e8> (a java.lang.Object) "Thread-0": at com.leo.interview.SimpleDeadLock$A.run(SimpleDeadLock.java:) - waiting to lock <0x00000000d629b4e8> (a java.lang.Object) - locked <0x00000000d629b4d8> (a java.lang.Object) Found deadlock. /* 記憶體使用狀況，詳情得看JVM方面的書 */ Heap PSYoungGen total K, used K [0x00000000d6100000, 0x00000000d8b00000, 0x0000000100000000) eden space K, % used [0x00000000d6100000,0x00000000d657b968,0x00000000d8100000) from space K, % used [0x00000000d8600000,0x00000000d8600000,0x00000000d8b00000) to space K, % used [0x00000000d8100000,0x00000000d8100000,0x00000000d8600000) ParOldGen total K, used K [0x0000000082200000, 0x0000000087600000, 0x00000000d6100000) object space K, % used [0x0000000082200000,0x0000000082200000,0x0000000087600000) Metaspace used K, capacity K, committed K, reserved K class space used K, capacity K, committed K, reserved K
19、為什麼我們調用start()方法時會執行run()方法，為什麼我們不能直接調用run()方法？
當你調用start()方法時你將創建新的執行緒，並且執行在run()方法里的程式碼。
但是如果你直接調用run()方法，它不會創建新的執行緒也不會執行調用執行緒的程式碼，只會把run方法當作普通方法去執行。 20、Java中你怎樣喚醒一個阻塞的執行緒？
在Java發展史上曾經使用suspend()、resume()方法對於執行緒進行阻塞喚醒，但隨之出現很多問題，比較典型的還是死鎖問題。
解決方案可以使用以對象為目標的阻塞，即利用Object類的wait()和notify()方法實現執行緒阻塞。
首先，wait、notify方法是針對對象的，調用任意對象的wait()方法都將導致執行緒阻塞，阻塞的同時也將釋放該對象的鎖，相應地，調用任意對象的notify()方法則將隨機解除該對象阻塞的執行緒，但它需要重新獲取改對象的鎖，直到獲取成功才能往下執行；其次，wait、notify方法必須在synchronized塊或方法中被調用，並且要保證同步塊或方法的鎖對象與調用wait、notify方法的對象是同一個，如此一來在調用wait之前當前執行緒就已經成功獲取某對象的鎖，執行wait阻塞後當前執行緒就將之前獲取的對象鎖釋放。 21、在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。 22、什麼是不可變對象，它對寫並發應用有什麼幫助？
不可變對象(Immutable Objects)即對象一旦被創建它的狀態（對象的數據，也即對象屬性值）就不能改變，反之即為可變對象(Mutable Objects)。
不可變對象的類即為不可變類(Immutable Class)。Java平台類庫中包含許多不可變類，如String、基本類型的包裝類、BigInteger和BigDecimal等。
不可變對象天生是執行緒安全的。它們的常量（域）是在構造函數中創建的。既然它們的狀態無法修改，這些常量永遠不會變。
不可變對象永遠是執行緒安全的。
只有滿足如下狀態，一個對象才是不可變的；
- 它的狀態不能在創建後再被修改；
- 所有域都是final類型；並且，
- 它被正確創建（創建期間沒有發生this引用的逸出）。
23、什麼是多執行緒中的上下文切換？
在上下文切換過程中，CPU會停止處理當前運行的程式，並保存當前程式運行的具體位置以便之後繼續運行。從這個角度來看，上下文切換有點像我們同時閱讀幾本書，在來回切換書本的同時我們需要記住每本書當前讀到的頁碼。在程式中，上下文切換過程中的「頁碼」資訊是保存在進程式控制制塊（PCB）中的。PCB還經常被稱作「切換楨」（switchframe）。「頁碼」資訊會一直保存到CPU的記憶體中，直到他們被再次使用。 上下文切換是存儲和恢復CPU狀態的過程，它使得執行緒執行能夠從中斷點恢復執行。上下文切換是多任務作業系統和多執行緒環境的基本特徵。 24、Java中用到的執行緒調度演算法是什麼？
電腦通常只有一個CPU,在任意時刻只能執行一條機器指令,每個執行緒只有獲得CPU的使用權才能執行指令.所謂多執行緒的並發運行,其實是指從宏觀上看,各個執行緒輪流獲得CPU的使用權,分別執行各自的任務.在運行池中,會有多個處於就緒狀態的執行緒在等待CPU,JAVA虛擬機的一項任務就是負責執行緒的調度,執行緒調度是指按照特定機製為多個執行緒分配CPU的使用權.
有兩種調度模型：分時調度模型和搶佔式調度模型。
分時調度模型是指讓所有的執行緒輪流獲得cpu的使用權,並且平均分配每個執行緒佔用的CPU的時間片這個也比較好理解。
java虛擬機採用搶佔式調度模型，是指優先讓可運行池中優先順序高的執行緒佔用CPU，如果可運行池中的執行緒優先順序相同，那麼就隨機選擇一個執行緒，使其佔用CPU。處於運行狀態的執行緒會一直運行，直至它不得不放棄CPU。
25、什麼是執行緒組，為什麼在Java中不推薦使用？
執行緒組和執行緒池是兩個不同的概念，他們的作用完全不同，前者是為了方便執行緒的管理，後者是為了管理執行緒的生命周期，復用執行緒，減少創建銷毀執行緒的開銷。 26、為什麼使用Executor框架比使用應用創建和管理執行緒好？
為什麼要使用Executor執行緒池框架
- 每次執行任務創建執行緒 new Thread()比較消耗性能，創建一個執行緒是比較耗時、耗資源的。
- 調用 new Thread()創建的執行緒缺乏管理，被稱為野執行緒，而且可以無限制的創建，執行緒之間的相互競爭會導致過多佔用系統資源而導致系統癱瘓，還有執行緒之間的頻繁交替也會消耗很多系統資源。
- 直接使用new Thread() 啟動的執行緒不利於擴展，比如定時執行、定期執行、定時定期執行、執行緒中斷等都不便實現。
使用Executor執行緒池框架的優點
- 能復用已存在並空閑的執行緒從而減少執行緒對象的創建從而減少了消亡執行緒的開銷。
- 可有效控制最大並發執行緒數，提高系統資源使用率，同時避免過多資源競爭。
- 框架中已經有定時、定期、單執行緒、並發數控制等功能。
綜上所述使用執行緒池框架Executor能更好的管理執行緒、提供系統資源使用率。
27、java中有幾種方法可以實現一個執行緒？
- 繼承 Thread 類
- 實現 Runnable 介面
- 實現 Callable 介面，需要實現的是 call() 方法
28、如何停止一個正在運行的執行緒？
- 使用共享變數的方式 在這種方式中，之所以引入共享變數，是因為該變數可以被多個執行相同任務的執行緒用來作為是否中斷的訊號，通知中斷執行緒的執行。
- 使用interrupt方法終止執行緒 如果一個執行緒由於等待某些事件的發生而被阻塞，又該怎樣停止該執行緒呢？這種情況經常會發生，比如當一個執行緒由於需要等候鍵盤輸入而被阻塞，或者調用Thread.join()方法，或者Thread.sleep()方法，在網路中調用ServerSocket.accept()方法，或者調用了DatagramSocket.receive()方法時，都有可能導致執行緒阻塞，使執行緒處於處於不可運行狀態時，即使主程式中將該執行緒的共享變數設置為true，但該執行緒此時根本無法檢查循環標誌，當然也就無法立即中斷。這裡我們給出的建議是，不要使用stop()方法，而是使用Thread提供的interrupt()方法，因為該方法雖然不會中斷一個正在運行的執行緒，但是它可以使一個被阻塞的執行緒拋出一個中斷異常，從而使執行緒提前結束阻塞狀態，退出堵塞程式碼。
29、notify()和notifyAll()有什麼區別？
當一個執行緒進入wait之後，就必須等其他執行緒notify/notifyall,使用notifyall,可以喚醒所有處於wait狀態的執行緒，使其重新進入鎖的爭奪隊列中，而notify只能喚醒一個。
如果沒把握，建議notifyAll，防止notigy因為訊號丟失而造成程式異常。
30、什麼是Daemon執行緒？它有什麼意義？
所謂後台(daemon)執行緒，是指在程式運行的時候在後台提供一種通用服務的執行緒，並且這個執行緒並不屬於程式中不可或缺的部分。因此，當所有的非後台執行緒結束時，程式也就終止了，同時會殺死進程中的所有後台執行緒。
反過來說， 只要有任何非後台執行緒還在運行，程式就不會終止。必須在執行緒啟動之前調用setDaemon()方法，才能把它設置為後台執行緒。注意：後台進程在不執行finally子句的情況下就會終止其run()方法。
比如：JVM的垃圾回收執行緒就是Daemon執行緒，Finalizer也是守護執行緒。
31、java如何實現多執行緒之間的通訊和協作？
中斷和共享變數
32、什麼是可重入鎖（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都是可重入的鎖，可重入鎖相對來說簡化了並發編程的開發。
33、當一個執行緒進入某個對象的一個synchronized的實例方法後，其它執行緒是否可進入此對象的其它方法？
如果其他方法沒有synchronized的話，其他執行緒是可以進入的。
所以要開放一個執行緒安全的對象時，得保證每個方法都是執行緒安全的。
34、樂觀鎖和悲觀鎖的理解及如何實現，有哪些實現方式？
悲觀鎖：總是假設最壞的情況，每次去拿數據的時候都認為別人會修改，所以每次在拿數據的時候都會上鎖，這樣別人想拿這個數據就會阻塞直到它拿到鎖。傳統的關係型資料庫裡邊就用到了很多這種鎖機制，比如行鎖，表鎖等，讀鎖，寫鎖等，都是在做操作之前先上鎖。再比如Java裡面的同步原語synchronized關鍵字的實現也是悲觀鎖。
樂觀鎖：顧名思義，就是很樂觀，每次去拿數據的時候都認為別人不會修改，所以不會上鎖，但是在更新的時候會判斷一下在此期間別人有沒有去更新這個數據，可以使用版本號等機制。樂觀鎖適用於多讀的應用類型，這樣可以提高吞吐量，像資料庫提供的類似於write_condition機制，其實都是提供的樂觀鎖。在Java中java.util.concurrent.atomic包下面的原子變數類就是使用了樂觀鎖的一種實現方式CAS實現的。
樂觀鎖的實現方式：
- 使用版本標識來確定讀到的數據與提交時的數據是否一致。提交後修改版本標識，不一致時可以採取丟棄和再次嘗試的策略。
- java中的Compare and Swap即CAS ，當多個執行緒嘗試使用CAS同時更新同一個變數時，只有其中一個執行緒能更新變數的值，而其它執行緒都失敗，失敗的執行緒並不會被掛起，而是被告知這次競爭中失敗，並可以再次嘗試。 CAS 操作中包含三個操作數 —— 需要讀寫的記憶體位置（V）、進行比較的預期原值（A）和擬寫入的新值(B)。如果記憶體位置V的值與預期原值A相匹配，那麼處理器會自動將該位置值更新為新值B。否則處理器不做任何操作。
CAS缺點：
- ABA問題： 比如說一個執行緒one從記憶體位置V中取出A，這時候另一個執行緒two也從記憶體中取出A，並且two進行了一些操作變成了B，然後two又將V位置的數據變成A，這時候執行緒one進行CAS操作發現記憶體中仍然是A，然後one操作成功。儘管執行緒one的CAS操作成功，但可能存在潛藏的問題。從Java1.5開始JDK的atomic包里提供了一個類AtomicStampedReference來解決ABA問題。
- 循環時間長開銷大： 對於資源競爭嚴重（執行緒衝突嚴重）的情況，CAS自旋的概率會比較大，從而浪費更多的CPU資源，效率低於synchronized。
- 只能保證一個共享變數的原子操作： 當對一個共享變數執行操作時，我們可以使用循環CAS的方式來保證原子操作，但是對多個共享變數操作時，循環CAS就無法保證操作的原子性，這個時候就可以用鎖。
35、SynchronizedMap和ConcurrentHashMap有什麼區別？
SynchronizedMap一次鎖住整張表來保證執行緒安全，所以每次只能有一個執行緒來訪為map。
ConcurrentHashMap使用分段鎖來保證在多執行緒下的性能。ConcurrentHashMap中則是一次鎖住一個桶。ConcurrentHashMap默認將hash表分為16個桶，諸如get,put,remove等常用操作只鎖當前需要用到的桶。這樣，原來只能一個執行緒進入，現在卻能同時有16個寫執行緒執行，並發性能的提升是顯而易見的。
另外ConcurrentHashMap使用了一種不同的迭代方式。在這種迭代方式中，當iterator被創建後集合再發生改變就不再是拋出ConcurrentModificationException，取而代之的是在改變時new新的數據從而不影響原有的數據 ，iterator完成後再將頭指針替換為新的數據 ，這樣iterator執行緒可以使用原來老的數據，而寫執行緒也可以並發的完成改變。
36、CopyOnWriteArrayList可以用於什麼應用場景？
CopyOnWriteArrayList(免鎖容器)的好處之一是當多個迭代器同時遍歷和修改這個列表時，不會拋出ConcurrentModificationException。在CopyOnWriteArrayList中，寫入將導致創建整個底層數組的副本，而源數組將保留在原地，使得複製的數組在被修改時，讀取操作可以安全地執行。
- 由於寫操作的時候，需要拷貝數組，會消耗記憶體，如果原數組的內容比較多的情況下，可能導致young gc或者full gc；
- 不能用於實時讀的場景，像拷貝數組、新增元素都需要時間，所以調用一個set操作後，讀取到數據可能還是舊的,雖然CopyOnWriteArrayList 能做到最終一致性,但是還是沒法滿足實時性要求；
CopyOnWriteArrayList透露的思想
- 讀寫分離，讀和寫分開
- 最終一致性
- 使用另外開闢空間的思路，來解決並發衝突
37、什麼叫執行緒安全？servlet是執行緒安全嗎?
執行緒安全是編程中的術語，指某個函數、函數庫在多執行緒環境中被調用時，能夠正確地處理多個執行緒之間的共享變數，使程式功能正確完成。
Servlet不是執行緒安全的，servlet是單實例多執行緒的，當多個執行緒同時訪問同一個方法，是不能保證共享變數的執行緒安全性的。
Struts2的action是多實例多執行緒的，是執行緒安全的，每個請求過來都會new一個新的action分配給這個請求，請求完成後銷毀。
SpringMVC的Controller是執行緒安全的嗎？不是的，和Servlet類似的處理流程
Struts2好處是不用考慮執行緒安全問題；Servlet和SpringMVC需要考慮執行緒安全問題，但是性能可以提升不用處理太多的gc，可以使用ThreadLocal來處理多執行緒的問題。
38、volatile有什麼用？能否用一句話說明下volatile的應用場景？
volatile保證記憶體可見性和禁止指令重排。
volatile用於多執行緒環境下的單次操作(單次讀或者單次寫)。
39、為什麼程式碼會重排序？
在執行程式時，為了提供性能，處理器和編譯器常常會對指令進行重排序，但是不能隨意重排序，不是你想怎麼排序就怎麼排序，它需要滿足以下兩個條件：
- 在單執行緒環境下不能改變程式運行的結果；
- 存在數據依賴關係的不允許重排序
需要注意的是：重排序不會影響單執行緒環境的執行結果，但是會破壞多執行緒的執行語義。
40、在java中wait和sleep方法的不同？
最大的不同是在等待時wait會釋放鎖，而sleep一直持有鎖。Wait通常被用於執行緒間交互，sleep通常被用於暫停執行。
直接了解的深入一點吧：
在Java中執行緒的狀態一共被分成6種：
初始態：NEW
創建一個Thread對象，但還未調用start()啟動執行緒時，執行緒處於初始態。
運行態：RUNNABLE
在Java中，運行態包括就緒態和運行態。
就緒態該狀態下的執行緒已經獲得執行所需的所有資源，只要CPU分配執行權就能運行。所有就緒態的執行緒存放在就緒隊列中。
運行態獲得CPU執行權，正在執行的執行緒。由於一個CPU同一時刻只能執行一條執行緒，因此每個CPU每個時刻只有一條運行態的執行緒。
阻塞態
當一條正在執行的執行緒請求某一資源失敗時，就會進入阻塞態。而在Java中，阻塞態專指請求鎖失敗時進入的狀態。由一個阻塞隊列存放所有阻塞態的執行緒。處於阻塞態的執行緒會不斷請求資源，一旦請求成功，就會進入就緒隊列，等待執行。PS：鎖、IO、Socket等都資源。
等待態
當前執行緒中調用wait、join、park函數時，當前執行緒就會進入等待態。也有一個等待隊列存放所有等待態的執行緒。執行緒處於等待態表示它需要等待其他執行緒的指示才能繼續運行。進入等待態的執行緒會釋放CPU執行權，並釋放資源（如：鎖）
超時等待態
當運行中的執行緒調用sleep(time)、wait、join、parkNanos、parkUntil時，就會進入該狀態；它和等待態一樣，並不是因為請求不到資源，而是主動進入，並且進入後需要其他執行緒喚醒；進入該狀態後釋放CPU執行權 和 佔有的資源。與等待態的區別：到了超時時間後自動進入阻塞隊列，開始競爭鎖。
終止態
執行緒執行結束後的狀態。
注意：
- wait()方法會釋放CPU執行權 和 佔有的鎖。
- sleep(long)方法僅釋放CPU使用權，鎖仍然佔用；執行緒被放入超時等待隊列，與yield相比，它會使執行緒較長時間得不到運行。
- yield()方法僅釋放CPU執行權，鎖仍然佔用，執行緒會被放入就緒隊列，會在短時間內再次執行。
- wait和notify必須配套使用，即必須使用同一把鎖調用；
- wait和notify必須放在一個同步塊中調用wait和notify的對象必須是他們所處同步塊的鎖對象。
41、一個執行緒運行時發生異常會怎樣？
如果異常沒有被捕獲該執行緒將會停止執行。Thread.UncaughtExceptionHandler是用於處理未捕獲異常造成執行緒突然中斷情況的一個內嵌介面。當一個未捕獲異常將造成執行緒中斷的時候JVM會使用Thread.getUncaughtExceptionHandler()來查詢執行緒的UncaughtExceptionHandler並將執行緒和異常作為參數傳遞給handler的uncaughtException()方法進行處理。
42、如何在兩個執行緒間共享數據？
在兩個執行緒間共享變數即可實現共享。
一般來說，共享變數要求變數本身是執行緒安全的，然後在執行緒內使用的時候，如果有對共享變數的複合操作，那麼也得保證複合操作的執行緒安全性。
43、Java中notify 和 notifyAll有什麼區別？
notify() 方法不能喚醒某個具體的執行緒，所以只有一個執行緒在等待的時候它才有用武之地。而notifyAll()喚醒所有執行緒並允許他們爭奪鎖確保了至少有一個執行緒能繼續運行。
44、為什麼wait, notify 和 notifyAll這些方法不在thread類裡面？
一個很明顯的原因是JAVA提供的鎖是對象級的而不是執行緒級的，每個對象都有鎖，通過執行緒獲得。由於wait，notify和notifyAll都是鎖級別的操作，所以把他們定義在Object類中因為鎖屬於對象。
45、什麼是ThreadLocal變數？
ThreadLocal是Java里一種特殊的變數。每個執行緒都有一個ThreadLocal就是每個執行緒都擁有了自己獨立的一個變數，競爭條件被徹底消除了。它是為創建代價高昂的對象獲取執行緒安全的好方法，比如你可以用ThreadLocal讓SimpleDateFormat變成執行緒安全的，因為那個類創建代價高昂且每次調用都需要創建不同的實例所以不值得在局部範圍使用它，如果為每個執行緒提供一個自己獨有的變數拷貝，將大大提高效率。首先，通過復用減少了代價高昂的對象的創建個數。其次，你在沒有使用高代價的同步或者不變性的情況下獲得了執行緒安全。
46、Java中interrupted 和 isInterrupted方法的區別？
interrupt
interrupt方法用於中斷執行緒。調用該方法的執行緒的狀態為將被置為」中斷」狀態。 注意：執行緒中斷僅僅是置執行緒的中斷狀態位，不會停止執行緒。需要用戶自己去監視執行緒的狀態為並做處理。支援執行緒中斷的方法（也就是執行緒中斷後會拋出interruptedException的方法）就是在監視執行緒的中斷狀態，一旦執行緒的中斷狀態被置為「中斷狀態」，就會拋出中斷異常。
interrupted
查詢當前執行緒的中斷狀態，並且清除原狀態。如果一個執行緒被中斷了，第一次調用interrupted則返回true，第二次和後面的就返回false了。
isInterrupted
僅僅是查詢當前執行緒的中斷狀態
47、為什麼wait和notify方法要在同步塊中調用？
Java API強制要求這樣做，如果你不這麼做，你的程式碼會拋出IllegalMonitorStateException異常。還有一個原因是為了避免wait和notify之間產生競態條件。
48、為什麼你應該在循環中檢查等待條件?
處於等待狀態的執行緒可能會收到錯誤警報和偽喚醒，如果不在循環中檢查等待條件，程式就會在沒有滿足結束條件的情況下退出。
49、Java中的同步集合與並發集合有什麼區別？
同步集合與並發集合都為多執行緒和並發提供了合適的執行緒安全的集合，不過並發集合的可擴展性更高。在Java1.5之前程式設計師們只有同步集合來用且在多執行緒並發的時候會導致爭用，阻礙了系統的擴展性。Java5介紹了並發集合像ConcurrentHashMap，不僅提供執行緒安全還用鎖分離和內部分區等現代技術提高了可擴展性。
50、什麼是執行緒池？ 為什麼要使用它？
創建執行緒要花費昂貴的資源和時間，如果任務來了才創建執行緒那麼響應時間會變長，而且一個進程能創建的執行緒數有限。為了避免這些問題，在程式啟動的時候就創建若干執行緒來響應處理，它們被稱為執行緒池，裡面的執行緒叫工作執行緒。從JDK1.5開始，Java API提供了Executor框架讓你可以創建不同的執行緒池。
51、怎麼檢測一個執行緒是否擁有鎖？
在java.lang.Thread中有一個方法叫holdsLock()，它返回true如果當且僅噹噹前執行緒擁有某個具體對象的鎖。 52、你如何在Java中獲取執行緒堆棧？
- kill -3 [java pid] 不會在當前終端輸出，它會輸出到程式碼執行的或指定的地方去。比如，kill -3 tomcat pid, 輸出堆棧到log目錄下。
- Jstack [java pid] 這個比較簡單，在當前終端顯示，也可以重定向到指定文件中。 -JvisualVM：Thread Dump 不做說明，打開JvisualVM後，都是介面操作，過程還是很簡單的。
53、JVM中哪個參數是用來控制執行緒的棧堆棧小的?
-Xss 每個執行緒的棧大小
54、Thread類中的yield方法有什麼作用？
使當前執行緒從執行狀態（運行狀態）變為可執行態（就緒狀態）。
當前執行緒到了就緒狀態，那麼接下來哪個執行緒會從就緒狀態變成執行狀態呢？可能是當前執行緒，也可能是其他執行緒，看系統的分配了。
55、Java中ConcurrentHashMap的並發度是什麼？
ConcurrentHashMap把實際map劃分成若干部分來實現它的可擴展性和執行緒安全。這種劃分是使用並發度獲得的，它是ConcurrentHashMap類構造函數的一個可選參數，默認值為16，這樣在多執行緒情況下就能避免爭用。
在JDK8後，它摒棄了Segment（鎖段）的概念，而是啟用了一種全新的方式實現,利用CAS演算法。同時加入了更多的輔助變數來提高並發度，具體內容還是查看源碼吧。
56、Java中Semaphore是什麼？
Java中的Semaphore是一種新的同步類，它是一個計數訊號。從概念上講，從概念上講，訊號量維護了一個許可集合。如有必要，在許可可用前會阻塞每一個 acquire()，然後再獲取該許可。每個 release()添加一個許可，從而可能釋放一個正在阻塞的獲取者。但是，不使用實際的許可對象，Semaphore只對可用許可的號碼進行計數，並採取相應的行動。訊號量常常用於多執行緒的程式碼中，比如資料庫連接池。
57、Java執行緒池中submit() 和 execute()方法有什麼區別？
兩個方法都可以向執行緒池提交任務，execute()方法的返回類型是void，它定義在Executor介面中。
而submit()方法可以返回持有計算結果的Future對象，它定義在ExecutorService介面中，它擴展了Executor介面，其它執行緒池類像ThreadPoolExecutor和ScheduledThreadPoolExecutor都有這些方法。
58、什麼是阻塞式方法？
阻塞式方法是指程式會一直等待該方法完成期間不做其他事情，ServerSocket的accept()方法就是一直等待客戶端連接。這裡的阻塞是指調用結果返回之前，當前執行緒會被掛起，直到得到結果之後才會返回。此外，還有非同步和非阻塞式方法在任務完成前就返回。
59、Java中的ReadWriteLock是什麼？
讀寫鎖是用來提升並發程式性能的鎖分離技術的成果。
60、volatile 變數和 atomic 變數有什麼不同？
Volatile變數可以確保先行關係，即寫操作會發生在後續的讀操作之前, 但它並不能保證原子性。例如用volatile修飾count變數那麼 count++ 操作就不是原子性的。
而AtomicInteger類提供的atomic方法可以讓這種操作具有原子性如getAndIncrement()方法會原子性的進行增量操作把當前值加一，其它數據類型和引用變數也可以進行相似操作。
61、可以直接調用Thread類的run ()方法么？
當然可以。但是如果我們調用了Thread的run()方法，它的行為就會和普通的方法一樣，會在當前執行緒中執行。為了在新的執行緒中執行我們的程式碼，必須使用Thread.start()方法。
62、如何讓正在運行的執行緒暫停一段時間？
我們可以使用Thread類的Sleep()方法讓執行緒暫停一段時間。需要注意的是，這並不會讓執行緒終止，一旦從休眠中喚醒執行緒，執行緒的狀態將會被改變為Runnable，並且根據執行緒調度，它將得到執行。
63、你對執行緒優先順序的理解是什麼？
每一個執行緒都是有優先順序的，一般來說，高優先順序的執行緒在運行時會具有優先權，但這依賴於執行緒調度的實現，這個實現是和作業系統相關的(OS dependent)。我們可以定義執行緒的優先順序，但是這並不能保證高優先順序的執行緒會在低優先順序的執行緒前執行。執行緒優先順序是一個int變數(從1-10)，1代表最低優先順序，10代表最高優先順序。
java的執行緒優先順序調度會委託給作業系統去處理，所以與具體的作業系統優先順序有關，如非特別需要，一般無需設置執行緒優先順序。
64、什麼是執行緒調度器(Thread Scheduler)和時間分片(Time Slicing )？
執行緒調度器是一個作業系統服務，它負責為Runnable狀態的執行緒分配CPU時間。一旦我們創建一個執行緒並啟動它，它的執行便依賴於執行緒調度器的實現。 同上一個問題，執行緒調度並不受到Java虛擬機控制，所以由應用程式來控制它是更好的選擇（也就是說不要讓你的程式依賴於執行緒的優先順序）。
時間分片是指將可用的CPU時間分配給可用的Runnable執行緒的過程。分配CPU時間可以基於執行緒優先順序或者執行緒等待的時間。
65、你如何確保main()方法所在的執行緒是Java 程式最後結束的執行緒？
我們可以使用Thread類的join()方法來確保所有程式創建的執行緒在main()方法退出前結束。
66、執行緒之間是如何通訊的？
當執行緒間是可以共享資源時，執行緒間通訊是協調它們的重要的手段。Object類中wait()otify()otifyAll()方法可以用於執行緒間通訊關於資源的鎖的狀態。
67、為什麼執行緒通訊的方法wait(), notify()和notifyAll()被定義在Object 類里？
Java的每個對象中都有一個鎖(monitor，也可以成為監視器) 並且wait()，notify()等方法用於等待對象的鎖或者通知其他執行緒對象的監視器可用。在Java的執行緒中並沒有可供任何對象使用的鎖和同步器。這就是為什麼這些方法是Object類的一部分，這樣Java的每一個類都有用於執行緒間通訊的基本方法。
68、為什麼wait(), notify()和notifyAll ()必須在同步方法或者同步塊中被調用？
當一個執行緒需要調用對象的wait()方法的時候，這個執行緒必須擁有該對象的鎖，接著它就會釋放這個對象鎖並進入等待狀態直到其他執行緒調用這個對象上的notify()方法。同樣的，當一個執行緒需要調用對象的notify()方法時，它會釋放這個對象的鎖，以便其他在等待的執行緒就可以得到這個對象鎖。由於所有的這些方法都需要執行緒持有對象的鎖，這樣就只能通過同步來實現，所以他們只能在同步方法或者同步塊中被調用。
69、為什麼Thread類的sleep()和yield ()方法是靜態的？
Thread類的sleep()和yield()方法將在當前正在執行的執行緒上運行。所以在其他處於等待狀態的執行緒上調用這些方法是沒有意義的。這就是為什麼這些方法是靜態的。它們可以在當前正在執行的執行緒中工作，並避免程式設計師錯誤的認為可以在其他非運行執行緒調用這些方法。
70、如何確保執行緒安全？
在Java中可以有很多方法來保證執行緒安全——同步，使用原子類(atomic concurrent classes)，實現並發鎖，使用volatile關鍵字，使用不變類和執行緒安全類。
71、同步方法和同步塊，哪個是更好的選擇？
同步塊是更好的選擇，因為它不會鎖住整個對象（當然你也可以讓它鎖住整個對象）。同步方法會鎖住整個對象，哪怕這個類中有多個不相關聯的同步塊，這通常會導致他們停止執行並需要等待獲得這個對象上的鎖。
同步塊更要符合開放調用的原則，只在需要鎖住的程式碼塊鎖住相應的對象，這樣從側面來說也可以避免死鎖。
72、如何創建守護執行緒？
使用Thread類的setDaemon(true)方法可以將執行緒設置為守護執行緒，需要注意的是，需要在調用start()方法前調用這個方法，否則會拋出IllegalThreadStateException異常。
73、什麼是Java Timer 類？如何創建一個有特定時間間隔的任務？
java.util.Timer是一個工具類，可以用於安排一個執行緒在未來的某個特定時間執行。Timer類可以用安排一次性任務或者周期任務。
java.util.TimerTask是一個實現了Runnable介面的抽象類，我們需要去繼承這個類來創建我們自己的定時任務並使用Timer去安排它的執行。
目前有開源的Qurtz可以用來創建定時任務。
