Java 并發編程

1、在 java 中守護執行緒和本地執行緒區別？

2、執行緒與行程的區別？

3、什么是多執行緒中的背景關系切換？

4、死鎖與活鎖的區別，死鎖與饑餓的區別？

5、Java 中用到的執行緒調度演算法是什么？

6、什么是執行緒組，為什么在 Java 中不推薦使用？

7、為什么使用 Executor 框架？

8、在 Java 中 Executor 和 Executors 的區別？

9、如何在 Windows 和 Linux 上查找哪個執行緒使用的 CPU 時間最長？

10、什么是原子操作？在 Java Concurrency API 中有哪些原子類(atomic classes)？

11、Java Concurrency API 中的 Lock 介面(Lock interface)是什么？對比同步它有什么優勢？

12、什么是 Executors 框架？

13、什么是阻塞佇列？阻塞佇列的實作原理是什么？如何使用阻塞佇列來實作生產者-消費者模型？

14、什么是 Callable 和 Future?

15、什么是 FutureTask?使用 ExecutorService 啟動任務，

16、什么是并發容器的實作？

17、多執行緒同步和互斥有幾種實作方法，都是什么？

18、什么是競爭條件？你怎樣發現和解決競爭？

19、你將如何使用 thread dump？你將如何分析 Thread dump？

20、為什么我們呼叫 start()方法時會執行 run()方法，為什么我們不能直接呼叫 run()方法？

21、Java 中你怎樣喚醒一個阻塞的執行緒？

22、在 Java 中 CycliBarriar 和 CountdownLatch 有什么區別？

23、什么是不可變物件，它對寫并發應用有什么幫助？

24、什么是多執行緒中的背景關系切換？

25、Java 中用到的執行緒調度演算法是什么？

26、什么是執行緒組，為什么在 Java 中不推薦使用？

27、為什么使用 Executor 框架比使用應用創建和管理執行緒好？

28、java 中有幾種方法可以實作一個執行緒？

29、如何停止一個正在運行的執行緒？

30、notify()和 notifyAll()有什么區別？

31、什么是 Daemon 執行緒？它有什么意義？

32、java 如何實作多執行緒之間的通訊和協作？

33、什么是可重入鎖（ReentrantLock）？

34、當一個執行緒進入某個物件的一個 synchronized 的實體方法后，其它執行緒是否可進入此物件的其它方法？

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

36、SynchronizedMap 和 ConcurrentHashMap 有什么區別？

37、CopyOnWriteArrayList 可以用于什么應用場景？

38、什么叫執行緒安全？servlet 是執行緒安全嗎?

39、volatile 有什么用？能否用一句話說明下 volatile 的應用場景？

40、為什么代碼會重排序？

41、在 java 中 wait 和 sleep 方法的不同？

42、用 Java 實作阻塞佇列

43、一個執行緒運行時發生例外會怎樣？

44、如何在兩個執行緒間共享資料？

45、Java 中 notify 和 notifyAll 有什么區別？

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

47、什么是 ThreadLocal 變數？

48、Java 中 interrupted 和 isInterrupted 方法的區別？

49、為什么 wait 和 notify 方法要在同步塊中呼叫？

50、為什么你應該在回圈中檢查等待條件?

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

52、什么是執行緒池？ 為什么要使用它？

53、怎么檢測一個執行緒是否擁有鎖？

54、你如何在 Java 中獲取執行緒堆疊？

56、Thread 類中的 yield 方法有什么作用？

57、Java 中 ConcurrentHashMap 的并發度是什么？

58、Java 中 Semaphore 是什么？

59、Java 執行緒池中 submit() 和 execute()方法有什么區別？

60、什么是阻塞式方法？

61、Java 中的 ReadWriteLock 是什么？

62、volatile 變數和 atomic 變數有什么不同？

63、可以直接呼叫 Thread 類的 run ()方法么？

64、如何讓正在運行的執行緒暫停一段時間？

65、你對執行緒優先級的理解是什么？

66 、 什 么 是 線 程 調 度 器 (Thread Scheduler) 和 時 間 分 片 (TimeSlicing )？

67、你如何確保 main()方法所在的執行緒是 Java 程式最后結束的執行緒？

68、執行緒之間是如何通信的？

69、為什么執行緒通信的方法 wait(), notify()和 notifyAll()被定義在Object 類里？

70、為什么 wait(), notify()和 notifyAll ()必須在同步方法或者同步塊中被呼叫？

71、為什么 Thread 類的 sleep()和 yield ()方法是靜態的？

72、如何確保執行緒安全？

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

74、如何創建守護執行緒？

75、什么是 Java Timer 類？如何創建一個有特定時間間隔的任務？

1、在 java 中守護執行緒和本地執行緒區別？

答：
java 中的執行緒分為兩種：守護執行緒（Daemon）和用戶執行緒（User），

任何執行緒都可以設定為守護執行緒和用戶執行緒，通過方法 Thread.setDaemon(boolon)；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、死鎖與活鎖的區別，死鎖與饑餓的區別？

答：
死鎖：是指兩個或兩個以上的行程（或執行緒）在執行程序中，因爭奪資源而造成的一種互相等待的現象，若無外力作用，它們都將無法推進下去，

產生死鎖的必要條件：

1、互斥條件：所謂互斥就是行程在某一時間內獨占資源，

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

3、不剝奪條件:行程已獲得資源，在末使用完之前，不能強行剝奪，

4、回圈等待條件:若干行程之間形成一種頭尾相接的回圈等待資源關系，

活鎖：任務或者執行者沒有被阻塞，由于某些條件沒有滿足，導致一直重復嘗試，失敗，嘗試，失敗，

活鎖和死鎖的區別在于，處于活鎖的物體是在不斷的改變狀態，所謂的“活”， 而處于死鎖的物體表現為等待；活鎖有可能自行解開，死鎖則不能，

饑餓：一個或者多個執行緒因為種種原因無法獲得所需要的資源，導致一直無法執行的狀態，

Java 中導致饑餓的原因：

1、高優先級執行緒吞噬所有的低優先級執行緒的 CPU 時間，

2、執行緒被永久堵塞在一個等待進入同步塊的狀態，因為其他執行緒總是能在它之前持續地對該同步塊進行訪問，

3、執行緒在等待一個本身也處于永久等待完成的物件(比如呼叫這個物件的 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、如何在 Windows 和 Linux 上查找哪個執行緒使用的 CPU 時間最長？

答：
使用 jstack 找出消耗 CPU 最多的執行緒代碼，

10、什么是原子操作？在 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 來累加來反映中間有沒有變過）

11、Java Concurrency API 中的 Lock 介面(Lock interface)是什么？對比同步它有什么優勢？

答：
Lock 介面比同步方法和同步塊提供了更具擴展性的鎖操作，

他們允許更靈活的結構，可以具有完全不同的性質，并且可以支持多個相關類的條件物件，

它的優勢有：

1、可以使鎖更公平；

2、可以使執行緒在等待鎖的時候回應中斷；

3、可以讓執行緒嘗試獲取鎖，并在無法獲取鎖的時候立即回傳或者等待一段時間；

4、可以在不同的范圍，以不同的順序獲取和釋放鎖，

整體上來說 Lock 是 synchronized 的擴展版，Lock 提供了無條件的、可輪詢的(tryLock方法)、定時的(tryLock 帶參方法)、可中斷的(lockInterruptibly)、可多條件佇列的(newCondition 方法)鎖操作，另外 Lock 的實作類基本都支持非公平鎖(默認)和公平鎖，synchronized 只支持非公平鎖，當然，在大部分情況下，非公平鎖是高效的選擇，

12、什么是 Executors 框架？

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

無限制的創建執行緒會引起應用程式記憶體溢位，所以創建一個執行緒池是個更好的的解決方案，因為可以限制執行緒的數量并且可以回收再利用這些執行緒，利用Executors 框架可以非常方便的創建一個執行緒池，

13、什么是阻塞佇列？阻塞佇列的實作原理是什么？如何使用阻塞佇列來實作生產者-消費者模型？

答：
阻塞佇列（BlockingQueue）是一個支持兩個附加操作的佇列，

這兩個附加的操作是：在佇列為空時，獲取元素的執行緒會等待佇列變為非空，當佇列滿時，存盤元素的執行緒會等待佇列可用，

阻塞佇列常用于生產者和消費者的場景，生產者是往佇列里添加元素的執行緒，消費者是從佇列里拿元素的執行緒，阻塞佇列就是生產者存放元素的容器，而消費者也只從容器里拿元素，

JDK7 提供了 7 個阻塞佇列，分別是：

• ArrayBlockingQueue ：一個由陣列結構組成的有界阻塞佇列，
• LinkedBlockingQueue ：一個由鏈表結構組成的有界阻塞佇列，
• PriorityBlockingQueue ：一個支持優先級排序的無界阻塞佇列，
• DelayQueue：一個使用優先級佇列實作的無界阻塞佇列，
• SynchronousQueue：一個不存盤元素的阻塞佇列，
• LinkedTransferQueue：一個由鏈表結構組成的無界阻塞佇列，
• LinkedBlockingDeque：一個由鏈表結構組成的雙向阻塞佇列，

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

BlockingQueue 介面是 Queue 的子介面，它的主要用途并不是作為容器，而是作為執行緒同步的的工具，因此他具有一個很明顯的特性，當生產者執行緒試圖向BlockingQueue 放入元素時，如果佇列已滿，則執行緒被阻塞，當消費者執行緒試圖從中取出一個元素時，如果佇列為空，則該執行緒會被阻塞，正是因為它所具有這個特性，所以在程式中多個執行緒交替向 BlockingQueue 中放入元素，取出元素，它可以很好的控制執行緒之間的通信，

阻塞佇列使用最經典的場景就是 socket 客戶端資料的讀取和決議，讀取資料的執行緒不斷將資料放入佇列，然后決議執行緒不斷從佇列取資料決議，

14、什么是 Callable 和 Future?

答：
Callable 介面類似于 Runnable，從名字就可以看出來了，但是 Runnable 不會回傳結果，并且無法拋出回傳結果的例外，而 Callable 功能更強大一些，被執行緒執行后，可以回傳值，這個回傳值可以被 Future 拿到，也就是說，Future 可以拿到異步執行任務的回傳值，

可以認為是帶有回呼的 Runnable，

Future 介面表示異步任務，是還沒有完成的任務給出的未來結果，所以說 Callable用于產生結果，Future 用于獲取結果，

15、什么是 FutureTask?使用 ExecutorService 啟動任務，

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

16、什么是并發容器的實作？

答：
何為同步容器：可以簡單地理解為通過 synchronized 來實作同步的容器，如果有多個執行緒呼叫同步容器的方法，它們將會串行執行，比如 Vector，Hashtable，以及 Collections.synchronizedSet，synchronizedList 等方法回傳的容器，可以通過查看 Vector，Hashtable 等這些同步容器的實作代碼，可以看到這些容器實作執行緒安全的方式就是將它們的狀態封裝起來，并在需要同步的方法上加上關鍵字 synchronized，

并發容器使用了與同步容器完全不同的加鎖策略來提供更高的并發性和伸縮性，例如在 ConcurrentHashMap 中采用了一種粒度更細的加鎖機制，可以稱為分段鎖，在這種鎖機制下，允許任意數量的讀執行緒并發地訪問 map，并且執行讀操作的執行緒和寫操作的執行緒也可以并發的訪問 map，同時允許一定數量的寫操作執行緒并發地修改 map，所以它可以在并發環境下實作更高的吞吐量，

17、多執行緒同步和互斥有幾種實作方法，都是什么？

答：
執行緒同步是指執行緒之間所具有的一種制約關系，一個執行緒的執行依賴另一個執行緒的訊息，當它沒有得到另一個執行緒的訊息時應等待，直到訊息到達時才被喚醒，執行緒互斥是指對于共享的行程系統資源，在各單個執行緒訪問時的排它性，當有若干個執行緒都要使用某一共享資源時，任何時刻最多只允許一個執行緒去使用，其它要使用該資源的執行緒必須等待，直到占用資源者釋放該資源，執行緒互斥可以看成是一種特殊的執行緒同步，

執行緒間的同步方法大體可分為兩類：用戶模式和內核模式，顧名思義，內核模式就是指利用系統內核物件的單一性來進行同步，使用時需要切換內核態與用戶態，而用戶模式就是不需要切換到內核態，只在用戶態完成操作，

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

18、什么是競爭條件？你怎樣發現和解決競爭？

答：
當多個行程都企圖對共享資料進行某種處理，而最后的結果又取決于行程運行的順序時，則我們認為這發生了競爭條件（race condition），

19、你將如何使用 thread dump？你將如何分析 Thread dump？

答：

1. 新建狀態（New）

用 new 陳述句創建的執行緒處于新建狀態，此時它和其他 Java 物件一樣，僅僅在堆區中被分配了記憶體，

2. 就緒狀態（Runnable）

當一個執行緒物件創建后，其他執行緒呼叫它的 start()方法，該執行緒就進入就緒狀態，Java 虛擬機會為它創建方法呼叫堆疊和程式計數器，處于這個狀態的執行緒位于可運行池中，等待獲得 CPU 的使用權，

3. 運行狀態（Running）

處于這個狀態的執行緒占用 CPU，執行程式代碼，只有處于就緒狀態的執行緒才有機會轉到運行狀態，

4. 阻塞狀態（Blocked）

阻塞狀態是指執行緒因為某些原因放棄 CPU，暫時停止運行，當執行緒處于阻塞狀態時，Java 虛擬機不會給執行緒分配 CPU，直到執行緒重新進入就緒狀態，它才有機會轉到運行狀態，

阻塞狀態可分為以下 3 種：

1. 位于物件等待池中的阻塞狀態（Blocked in object’s wait pool）：

當執行緒處于運行狀態時，如果執行了某個物件的 wait()方法，Java 虛擬機就會把執行緒放到這個物件的等待池中，這涉及到“執行緒通信”的內容，

2. 位于物件鎖池中的阻塞狀態（Blocked in object’s lock pool）：

當執行緒處于運行狀態時，試圖獲得某個物件的同步鎖時，如果該物件的同步鎖已經被其他執行緒占用，Java 虛擬機就會把這個執行緒放到這個物件的鎖池中，這涉及到“執行緒同步”的內容，

3. 其他阻塞狀態（Otherwise Blocked）：

當前執行緒執行了 sleep()方法，或者呼叫了其他執行緒的 join()方法，或者發出了 I/O請求時，就會進入這個狀態，

死亡狀態（Dead）：
當執行緒退出 run()方法時，就進入死亡狀態，該執行緒結束生命周期，

20、為什么我們呼叫 start()方法時會執行 run()方法，為什么我們不能直接呼叫 run()方法？

答：
當你呼叫 start()方法時你將創建新的執行緒，并且執行在 run()方法里的代碼，

但是如果你直接呼叫 run()方法，它不會創建新的執行緒也不會執行呼叫執行緒的代碼，只會把 run 方法當作普通方法去執行，

21、Java 中你怎樣喚醒一個阻塞的執行緒？

答：
在 Java 發展史上曾經使用 suspend()、resume()方法對于執行緒進行阻塞喚醒，但隨之出現很多問題，比較典型的還是死鎖問題，

解決方案可以使用以物件為目標的阻塞，即利用 Object 類的 wait()和 notify()方法實作執行緒阻塞，

首 先 ，wait、notify 方法是針對物件的，呼叫任意物件的 wait()方法都將導致執行緒阻塞，阻塞的同時也將釋放該物件的鎖，相應地，呼叫任意物件的 notify()方法則將隨機解除該物件阻塞的執行緒，但它需要重新獲取改物件的鎖，直到獲取成功才能往下執行；其次，wait、notify 方法必須在 synchronized 塊或方法中被呼叫，并且要保證同步塊或方法的鎖物件與呼叫 wait、notify 方法的物件是同一個，如此一來在呼叫 wait 之前當前執行緒就已經成功獲取某物件的鎖，執行 wait 阻塞后當前執行緒就將之前獲取的物件鎖釋放，

22、在 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，

23、什么是不可變物件，它對寫并發應用有什么幫助？

答：
不可變物件(Immutable Objects)即物件一旦被創建它的狀態（物件的資料，也即物件屬性值）就不能改變，反之即為可變物件(Mutable Objects)，

不可變物件的類即為不可變類(Immutable Class)，Java 平臺類別庫中包含許多不可變類，如 String、基本型別的包裝類、BigInteger 和 BigDecimal 等，

不可變物件天生是執行緒安全的，它們的常量（域）是在建構式中創建的，既然它們的狀態無法修改，這些常量永遠不會變，

不可變物件永遠是執行緒安全的，

只有滿足如下狀態，一個物件才是不可變的；

它的狀態不能在創建后再被修改；

所有域都是 final 型別；并且，它被正確創建（創建期間沒有發生 this 參考的逸出），

24、什么是多執行緒中的背景關系切換？

答：
在背景關系切換程序中，CPU 會停止處理當前運行的程式，并保存當前程式運行的具體位置以便之后繼續運行，從這個角度來看，背景關系切換有點像我們同時閱讀幾本書，在來回切換書本的同時我們需要記住每本書當前讀到的頁碼，在程式中，背景關系切換程序中的“頁碼”資訊是保存在行程控制塊（PCB）中的，PCB 還經常被稱作“切換楨”（switchframe），“頁碼”資訊會一直保存到 CPU 的記憶體中，直到他們被再次使用，

背景關系切換是存盤和恢復 CPU 狀態的程序，它使得執行緒執行能夠從中斷點恢復執行，背景關系切換是多任務作業系統和多執行緒環境的基本特征，

25、Java 中用到的執行緒調度演算法是什么？

答：
計算機通常只有一個 CPU,在任意時刻只能執行一潭訓器指令,每個執行緒只有獲得CPU 的使用權才能執行指令.所謂多執行緒的并發運行,其實是指從宏觀上看,各個執行緒輪流獲得 CPU 的使用權,分別執行各自的任務.在運行池中,會有多個處于就緒狀態的執行緒在等待 CPU,JAVA 虛擬機的一項任務就是負責執行緒的調度,執行緒調度是指按照特定機制為多個執行緒分配 CPU 的使用權.

有兩種調度模型：分時調度模型和搶占式調度模型，

分時調度模型是指讓所有的執行緒輪流獲得 cpu 的使用權,并且平均分配每個執行緒占用的 CPU 的時間片這個也比較好理解，

Java虛擬機采用搶占式調度模型，是指優先讓可運行池中優先級高的執行緒占用CPU，如果可運行池中的執行緒優先級相同，那么就隨機選擇一個執行緒，使其占用CPU，處于運行狀態的執行緒會一直運行，直至它不得不放棄 CPU，

26、什么是執行緒組，為什么在 Java 中不推薦使用？

答：
執行緒組和執行緒池是兩個不同的概念，他們的作用完全不同，前者是為了方便執行緒的管理，后者是為了管理執行緒的生命周期，復用執行緒，減少創建銷毀執行緒的開銷，

27、為什么使用 Executor 框架比使用應用創建和管理執行緒好？

答：
為什么要使用 Executor 執行緒池框架：

1、每次執行任務創建執行緒 new Thread()比較消耗性能，創建一個執行緒是比較耗時、耗資源的，

2、呼叫 new Thread()創建的執行緒缺乏管理，被稱為野執行緒，而且可以無限制的創建，執行緒之間的相互競爭會導致過多占用系統資源而導致系統癱瘓，還有執行緒之間的頻繁交替也會消耗很多系統資源，

3、直接使用 new Thread() 啟動的執行緒不利于擴展，比如定時執行、定期執行、定時定期執行、執行緒中斷等都不便實作，

使用 Executor 執行緒池框架的優點：

1、能復用已存在并空閑的執行緒從而減少執行緒物件的創建從而減少了消亡執行緒的開銷，

2、可有效控制最大并發執行緒數，提高系統資源使用率，同時避免過多資源競爭，

3、框架中已經有定時、定期、單執行緒、并發數控制等功能，

綜上所述使用執行緒池框架 Executor 能更好的管理執行緒、提供系統資源使用率，

28、java 中有幾種方法可以實作一個執行緒？

答：

1. 繼承 Thread 類
2. 實作 Runnable 介面
3. 實作 Callable 介面，需要實作的是 call() 方法

29、如何停止一個正在運行的執行緒？

答：

• 使用共享變數的方式

在這種方式中，之所以引入共享變數，是因為該變數可以被多個執行相同任務的執行緒用來作為是否中斷的信號，通知中斷執行緒的執行，

• 使用 interrupt 方法終止執行緒

如果一個執行緒由于等待某些事件的發生而被阻塞，又該怎樣停止該執行緒呢？這種情況經常會發生，比如當一個執行緒由于需要等候鍵盤輸入而被阻塞，或者呼叫Thread.join()方法，或者 Thread.sleep()方法，在網路中呼叫ServerSocket.accept()方法，或者呼叫了 DatagramSocket.receive()方法時，都有可能導致執行緒阻塞，使執行緒處于處于不可運行狀態時，即使主程式中將該執行緒的共享變數設定為 true，但該執行緒此時根本無法檢查回圈標志，當然也就無法立即中斷，這里我們給出的建議是，不要使用 stop()方法，而是使用 Thread 提供的interrupt()方法，因為該方法雖然不會中斷一個正在運行的執行緒，但是它可以使一個被阻塞的執行緒拋出一個中斷例外，從而使執行緒提前結束阻塞狀態，退出堵塞代碼，

30、notify()和 notifyAll()有什么區別？

答：
當一個執行緒進入 wait 之后，就必須等其他執行緒 notify/notifyall,使用 notifyall,可以喚醒所有處于 wait 狀態的執行緒，使其重新進入鎖的爭奪佇列中，而 notify 只能喚醒一個，

如果沒把握，建議 notifyAll，防止 notigy 因為信號丟失而造成程式例外，

31、什么是 Daemon 執行緒？它有什么意義？

答：
所謂后臺(daemon)執行緒，是指在程式運行的時候在后臺提供一種通用服務的執行緒，并且這個執行緒并不屬于程式中不可或缺的部分，因此，當所有的非后臺執行緒結束時，程式也就終止了，同時會殺死行程中的所有后臺執行緒，反過來說，只要有任何非后臺執行緒還在運行，程式就不會終止，必須在執行緒啟動之前呼叫setDaemon()方法，才能把它設定為后臺執行緒，

注意：后臺行程在不執行 finally子句的情況下就會終止其 run()方法，
比如：JVM 的垃圾回收執行緒就是 Daemon執行緒，Finalizer 也是守護執行緒，

32、java 如何實作多執行緒之間的通訊和協作？

答：
中斷 和 共享變數

33、什么是可重入鎖（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 都是可重入的鎖，可重入鎖相對來說簡化了并發編程的開發，

34、當一個執行緒進入某個物件的一個 synchronized 的實體方法后，其它執行緒是否可進入此物件的其它方法？

答：
如果其他方法沒有 synchronized 的話，其他執行緒是可以進入的，
所以要開放一個執行緒安全的物件時，得保證每個方法都是執行緒安全的，

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

答：
悲觀鎖：總是假設最壞的情況，每次去拿資料的時候都認為別人會修改，所以每次在拿資料的時候都會上鎖，這樣別人想拿這個資料就會阻塞直到它拿到鎖，傳統的關系型資料庫里邊就用到了很多這種鎖機制，比如行鎖，表鎖等，讀鎖，寫鎖等，都是在做操作之前先上鎖，再比如 Java 里面的同步原語 synchronized 關鍵字的實作也是悲觀鎖，

樂觀鎖：顧名思義，就是很樂觀，每次去拿資料的時候都認為別人不會修改，所以不會上鎖，但是在更新的時候會判斷一下在此期間別人有沒有去更新這個資料，可以使用版本號等機制，樂觀鎖適用于多讀的應用型別，這樣可以提高吞吐量，像資料庫提供的類似于 write_condition 機制，其實都是提供的樂觀鎖，在 Java中 java.util.concurrent.atomic 包下面的原子變數類就是使用了樂觀鎖的一種實作方式 CAS 實作的，

樂觀鎖的實作方式：

1、使用版本標識來確定讀到的資料與提交時的資料是否一致，提交后修改版本標識，不一致時可以采取丟棄和再次嘗試的策略，

2、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 就無法保證操作的原子性，這個時候就可以用鎖，

36、SynchronizedMap 和 ConcurrentHashMap 有什么區別？

答：
SynchronizedMap 一次鎖住整張表來保證執行緒安全，所以每次只能有一個執行緒來訪為 map，

ConcurrentHashMap 使用分段鎖來保證在多執行緒下的性能，

ConcurrentHashMap 中則是一次鎖住一個桶，ConcurrentHashMap 默認將hash 表分為 16 個桶，諸如 get,put,remove 等常用操作只鎖當前需要用到的桶，

這樣，原來只能一個執行緒進入，現在卻能同時有 16 個寫執行緒執行，并發性能的提升是顯而易見的，

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

ConcurrentModificationException，取而代之的是在改變時 new 新的資料從而不影響原有的資料 ，iterator 完成后再將頭指標替換為新的資料 ，這樣 iterator執行緒可以使用原來老的資料，而寫執行緒也可以并發的完成改變，

37、CopyOnWriteArrayList 可以用于什么應用場景？

答：
CopyOnWriteArrayList(免鎖容器)的好處之一是當多個迭代器同時遍歷和修改這個串列時，不會拋出 ConcurrentModificationException，在CopyOnWriteArrayList 中，寫入將導致創建整個底層陣列的副本，而源陣列將保留在原地，使得復制的陣列在被修改時，讀取操作可以安全地執行，

1、由于寫操作的時候，需要拷貝陣列，會消耗記憶體，如果原陣列的內容比較多的情況下，可能導致 young gc 或者 full gc；

2、不能用于實時讀的場景，像拷貝陣列、新增元素都需要時間，所以呼叫一個 set操作后，讀取到資料可能還是舊的,雖然 CopyOnWriteArrayList 能做到最終一致性,但是還是沒法滿足實時性要求；

CopyOnWriteArrayList 透露的思想：

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

2、最終一致性

3、使用另外開辟空間的思路，來解決并發沖突

38、什么叫執行緒安全？servlet 是執行緒安全嗎?

答：
執行緒安全是編程中的術語，指某個函式、函式庫在多執行緒環境中被呼叫時，能夠正確地處理多個執行緒之間的共享變數，使程式功能正確完成，

Servlet 不是執行緒安全的，servlet 是單實體多執行緒的，當多個執行緒同時訪問同一個方法，是不能保證共享變數的執行緒安全性的，

Struts2 的 action 是多實體多執行緒的，是執行緒安全的，每個請求過來都會 new 一個新的 action 分配給這個請求，請求完成后銷毀，

SpringMVC 的 Controller 是執行緒安全的嗎？不是的，和 Servlet 類似的處理流程，

Struts2 好處是不用考慮執行緒安全問題；Servlet 和 SpringMVC 需要考慮執行緒安全問題，但是性能可以提升不用處理太多的 gc，可以使用 ThreadLocal 來處理多執行緒的問題，

39、volatile 有什么用？能否用一句話說明下 volatile 的應用場景？

答：
volatile 保證記憶體可見性和禁止指令重排，

volatile 用于多執行緒環境下的單次操作(單次讀或者單次寫)，

40、為什么代碼會重排序？

答：
在執行程式時，為了提供性能，處理器和編譯器常常會對指令進行重排序，但是不能隨意重排序，不是你想怎么排序就怎么排序，它需要滿足以下兩個條件：

1. 在單執行緒環境下不能改變程式運行的結果；
2. 存在資料依賴關系的不允許重排序，

需要注意的是：重排序不會影響單執行緒環境的執行結果，但是會破壞多執行緒的執行語意，

41、在 java 中 wait 和 sleep 方法的不同？

答：
最大的不同是在等待時 wait 會釋放鎖，而 sleep 一直持有鎖，Wait 通常被用于執行緒間互動，sleep 通常被用于暫停執行，

42、用 Java 實作阻塞佇列

public class MyBlockQueue<T> {
    //push鎖
    private final static Object pushLock = new Object();
    //pop鎖
    private final static Object popLock = new Object();

    //資料存盤
    private Stack<T> stack;
    //佇列最大長度
    private  int maxSize = 0;
    //佇列最小長度
    private int minSize = 0;
    public MyBlockQueue(int size) {
        this.maxSize = size;
        stack = new Stack<T>();
    }

    public synchronized void push(T t) {
        if(stack.size() >= maxSize) {
            pushLock();
        }
        stack.push(t);
        popUnLock();
    }

    public synchronized T pop() {

        if(stack.size() == minSize) {
            popLock();
        }
        T t = stack.pop();
        pushUnLock();
        return t;
    }

    private void pushLock() {
        synchronized (pushLock) {
            try {
                pushLock.wait();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    private void pushUnLock() {
        synchronized (pushLock) {
            pushLock.notify();
        }
    }

    private  void popLock() {
        synchronized (popLock) {
            try {
                popLock.wait();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    private void  popUnLock() {
        synchronized (popLock) {
            popLock.notify();
        }
    }

}

43、一個執行緒運行時發生例外會怎樣？

答：
如果例外沒有被捕獲該執行緒將會停止執行，Thread.UncaughtExceptionHandler是用于處理未捕獲例外造成執行緒突然中斷情況的一個內嵌介面，當一個未捕獲例外將造成執行緒中斷的時候 JVM 會使用 Thread.getUncaughtExceptionHandler()來查詢執行緒的 UncaughtExceptionHandler 并將執行緒和例外作為引數傳遞給handler 的 uncaughtException()方法進行處理，

44、如何在兩個執行緒間共享資料？

答：
在兩個執行緒間共享變數即可實作共享，

一般來說，共享變數要求變數本身是執行緒安全的，然后在執行緒內使用的時候，如果有對共享變數的復合操作，那么也得保證復合操作的執行緒安全性，

45、Java 中 notify 和 notifyAll 有什么區別？

答：
notify() 方法不能喚醒某個具體的執行緒，所以只有一個執行緒在等待的時候它才有用武之地，而 notifyAll()喚醒所有執行緒并允許他們爭奪鎖確保了至少有一個執行緒能繼續運行，

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

答：
一個很明顯的原因是 JAVA 提供的鎖是物件級的而不是執行緒級的，每個物件都有鎖，通過執行緒獲得，由于 wait，notify 和 notifyAll 都是鎖級別的操作，所以把他們定義在 Object 類中因為鎖屬于物件，

47、什么是 ThreadLocal 變數？

答：
ThreadLocal 是 Java 里一種特殊的變數，每個執行緒都有一個 ThreadLocal 就是每個執行緒都擁有了自己獨立的一個變數，競爭條件被徹底消除了，它是為創建代價高昂的物件獲取執行緒安全的好方法，比如你可以用 ThreadLocal 讓SimpleDateFormat 變成執行緒安全的，因為那個類創建代價高昂且每次呼叫都需要創建不同的實體所以不值得在區域范圍使用它，如果為每個執行緒提供一個自己獨有的變數拷貝，將大大提高效率，首先，通過復用減少了代價高昂的物件的創建個數，其次，你在沒有使用高代價的同步或者不變性的情況下獲得了執行緒安全，

48、Java 中 interrupted 和 isInterrupted 方法的區別？

答：
interrupt：

interrupt 方法用于中斷執行緒，呼叫該方法的執行緒的狀態為將被置為”中斷”狀態，

注意：執行緒中斷僅僅是置執行緒的中斷狀態位，不會停止執行緒，需要用戶自己去監視執行緒的狀態為并做處理，支持執行緒中斷的方法（也就是執行緒中斷后會拋出interruptedException的方法）就是在監視執行緒的中斷狀態，一旦執行緒的中斷狀態被置為“中斷狀態”，就會拋出中斷例外，

interrupted：

查詢當前執行緒的中斷狀態，并且清除原狀態，如果一個執行緒被中斷了，第一次呼叫 interrupted 則回傳 true，第二次和后面的就回傳 false 了，

isInterrupted：

僅僅是查詢當前執行緒的中斷狀態，

49、為什么 wait 和 notify 方法要在同步塊中呼叫？

答：
Java API 強制要求這樣做，如果你不這么做，你的代碼會拋出IllegalMonitorStateException 例外，還有一個原因是為了避免 wait 和 notify之間產生競態條件，

50、為什么你應該在回圈中檢查等待條件?

答：
處于等待狀態的執行緒可能會收到錯誤警報和偽喚醒，如果不在回圈中檢查等待條件，程式就會在沒有滿足結束條件的情況下退出，

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

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

52、什么是執行緒池？ 為什么要使用它？

答：
創建執行緒要花費昂貴的資源和時間，如果任務來了才創建執行緒那么回應時間會變長，而且一個行程能創建的執行緒數有限，為了避免這些問題，在程式啟動的時候就創建若干執行緒來回應處理，它們被稱為執行緒池，里面的執行緒叫作業執行緒，從JDK1.5 開始，Java API 提供了 Executor 框架讓你可以創建不同的執行緒池，

53、怎么檢測一個執行緒是否擁有鎖？

答：
在 java.lang.Thread 中有一個方法叫 holdsLock()，它回傳 true 如果當且僅當當前執行緒擁有某個具體物件的鎖，

54、你如何在 Java 中獲取執行緒堆疊？

答：
kill -3 [java pid]

不會在當前終端輸出，它會輸出到代碼執行的或指定的地方去，比如，kill -3

tomcat pid, 輸出堆疊到 log 目錄下，

Jstack [java pid]

這個比較簡單，在當前終端顯示，也可以重定向到指定檔案中，

-JvisualVM：Thread Dump

不做說明，打開 JvisualVM 后，都是界面操作，程序還是很簡單的，

55、JVM 中哪個引數是用來控制執行緒的堆疊堆疊小的?

答：
Xss 每個執行緒的堆疊大小

56、Thread 類中的 yield 方法有什么作用？

答：
使當前執行緒從執行狀態（運行狀態）變為可執行態（就緒狀態），

當前執行緒到了就緒狀態，那么接下來哪個執行緒會從就緒狀態變成執行狀態呢？可能是當前執行緒，也可能是其他執行緒，看系統的分配了，

57、Java 中 ConcurrentHashMap 的并發度是什么？

答：
ConcurrentHashMap 把實際 map 劃分成若干部分來實作它的可擴展性和執行緒安全，這種劃分是使用并發度獲得的，它是 ConcurrentHashMap 類建構式的一個可選引數，默認值為 16，這樣在多執行緒情況下就能避免爭用，

在 JDK8 后，它摒棄了 Segment（鎖段）的概念，而是啟用了一種全新的方式實作,利用 CAS 演算法，同時加入了更多的輔助變數來提高并發度，具體內容還是查看原始碼吧，

58、Java 中 Semaphore 是什么？

答：
Java 中的 Semaphore 是一種新的同步類，它是一個計數信號，從概念上講，從概念上講，信號量維護了一個許可集合，如有必要，在許可可用前會阻塞每一個acquire()，然后再獲取該許可，每個 release()添加一個許可，從而可能釋放一個正在阻塞的獲取者，但是，不使用實際的許可物件，Semaphore 只對可用許可的號碼進行計數，并采取相應的行動，信號量常常用于多執行緒的代碼中，比如資料庫連接池，

59、Java 執行緒池中 submit() 和 execute()方法有什么區別？

答：
兩個方法都可以向執行緒池提交任務，execute()方法的回傳型別是 void，它定義在Executor 介面中，

而 submit()方法可以回傳持有計算結果的 Future 物件，它定義在ExecutorService 介面中，它擴展了 Executor 介面，其它執行緒池類像ThreadPoolExecutor 和 ScheduledThreadPoolExecutor 都有這些方法，

60、什么是阻塞式方法？

答：
阻塞式方法是指程式會一直等待該方法完成期間不做其他事情，ServerSocket 的accept()方法就是一直等待客戶端連接，這里的阻塞是指呼叫結果回傳之前，當前執行緒會被掛起，直到得到結果之后才會回傳，此外，還有異步和非阻塞式方法在任務完成前就回傳，

61、Java 中的 ReadWriteLock 是什么？

答：
讀寫鎖是用來提升并發程式性能的鎖分離技術的成果，

62、volatile 變數和 atomic 變數有什么不同？

答：
Volatile 變數可以確保先行關系，即寫操作會發生在后續的讀操作之前, 但它并不能保證原子性，例如用 volatile 修飾 count 變數那么 count++ 操作就不是原子性的，

而 AtomicInteger 類提供的 atomic 方法可以讓這種操作具有原子性如getAndIncrement()方法會原子性的進行增量操作把當前值加一，其它資料型別和參考變數也可以進行相似操作，

63、可以直接呼叫 Thread 類的 run ()方法么？

答：
當然可以，但是如果我們呼叫了 Thread 的 run()方法，它的行為就會和普通的方法一樣，會在當前執行緒中執行，為了在新的執行緒中執行我們的代碼，必須使用Thread.start()方法，

64、如何讓正在運行的執行緒暫停一段時間？

答：
我們可以使用 Thread 類的 Sleep()方法讓執行緒暫停一段時間，需要注意的是，這并不會讓執行緒終止，一旦從休眠中喚醒執行緒，執行緒的狀態將會被改變為 Runnable，并且根據執行緒調度，它將得到執行，

65、你對執行緒優先級的理解是什么？

答：
每一個執行緒都是有優先級的，一般來說，高優先級的執行緒在運行時會具有優先權，但這依賴于執行緒調度的實作，這個實作是和作業系統相關的(OS dependent)，我們可以定義執行緒的優先級，但是這并不能保證高優先級的執行緒會在低優先級的執行緒前執行，執行緒優先級是一個 int 變數(從 1-10)，1 代表最低優先級，10 代表最高優先級，

java 的執行緒優先級調度會委托給作業系統去處理，所以與具體的作業系統優先級有關，如非特別需要，一般無需設定執行緒優先級，

66、什么是執行緒調度器(Thread Scheduler)和時間分片(Time Slicing )？

答：
執行緒調度器是一個作業系統服務，它負責為 Runnable 狀態的執行緒分配 CPU 時間，一旦我們創建一個執行緒并啟動它，它的執行便依賴于執行緒調度器的實作，同上一個問題，執行緒調度并不受到 Java 虛擬機控制，所以由應用程式來控制它是更好的選擇（也就是說不要讓你的程式依賴于執行緒的優先級），

時間分片是指將可用的 CPU 時間分配給可用的 Runnable 執行緒的程序，分配 CPU時間可以基于執行緒優先級或者執行緒等待的時間，

67、你如何確保 main()方法所在的執行緒是 Java 程式最后結束的執行緒？

答：
我們可以使用 Thread 類的 join()方法來確保所有程式創建的執行緒在 main()方法退出前結束，

68、執行緒之間是如何通信的？

答：
當執行緒間是可以共享資源時，執行緒間通信是協調它們的重要的手段，Object 類中wait()\notify()\notifyAll()方法可以用于執行緒間通信關于資源的鎖的狀態，

69、為什么執行緒通信的方法 wait(), notify()和 notifyAll()被定義在 Object 類里？

答：
Java 的每個物件中都有一個鎖(monitor，也可以成為監視器) 并且 wait()，notify()等方法用于等待物件的鎖或者通知其他執行緒物件的監視器可用，在 Java 的執行緒中并沒有可供任何物件使用的鎖和同步器，這就是為什么這些方法是 Object 類的一部分，這樣 Java 的每一個類都有用于執行緒間通信的基本方法，

70、為什么 wait(), notify()和 notifyAll ()必須在同步方法或者同步塊中被呼叫？

答：
當一個執行緒需要呼叫物件的 wait()方法的時候，這個執行緒必須擁有該物件的鎖，接著它就會釋放這個物件鎖并進入等待狀態直到其他執行緒呼叫這個物件上的 notify()方法，同樣的，當一個執行緒需要呼叫物件的 notify()方法時，它會釋放這個物件的鎖，以便其他在等待的執行緒就可以得到這個物件鎖，由于所有的這些方法都需要執行緒持有物件的鎖，這樣就只能通過同步來實作，所以他們只能在同步方法或者同步塊中被呼叫，

71、為什么 Thread 類的 sleep()和 yield ()方法是靜態的？

答：
Thread 類的 sleep()和 yield()方法將在當前正在執行的執行緒上運行，所以在其他處于等待狀態的執行緒上呼叫這些方法是沒有意義的，這就是為什么這些方法是靜態的，它們可以在當前正在執行的執行緒中作業，并避免程式員錯誤的認為可以在其他非運行執行緒呼叫這些方法，

72、如何確保執行緒安全？

答：
在 Java 中可以有很多方法來保證執行緒安全——同步，使用原子類(atomic concurrent classes)，實作并發鎖，使用 volatile 關鍵字，使用不變類和執行緒安全類，

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

答：
同步塊是更好的選擇，因為它不會鎖住整個物件（當然你也可以讓它鎖住整個物件），同步方法會鎖住整個物件，哪怕這個類中有多個不相關聯的同步塊，這通常會導致他們停止執行并需要等待獲得這個物件上的鎖，

同步塊更要符合開放呼叫的原則，只在需要鎖住的代碼塊鎖住相應的物件，這樣從側面來說也可以避免死鎖，

74、如何創建守護執行緒？

答：
使用 Thread 類的 setDaemon(true)方法可以將執行緒設定為守護執行緒，需要注意的是，需要在呼叫 start()方法前呼叫這個方法，否則會拋出IllegalThreadStateException 例外，

75、什么是 Java Timer 類？如何創建一個有特定時間間隔的任務？

答：
java.util.Timer 是一個工具類，可以用于安排一個執行緒在未來的某個特定時間執行，Timer 類可以用安排一次性任務或者周期任務，

java.util.TimerTask 是一個實作了 Runnable 介面的抽象類，我們需要去繼承這個類來創建我們自己的定時任務并使用 Timer 去安排它的執行，

結語：

祝大家順順利利作業哦！如果有需要以下Java面試資料的，可以點擊進入，暗號：cszq，免費提供哦！