2萬字Java併發編程面試題合集（含答案，建議收藏）

時間 2020-02-19

標籤萬字 java 併發編程面試合集答案建議收藏欄目 Java 简体版

原文原文鏈接

Java 併發編程

一、在 java 中守護線程和本地線程區別？

二、線程與進程的區別？

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

四、死鎖與活鎖的區別，死鎖與飢餓的區別？

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

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

七、爲何使用 Executor 框架？

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

九、如何在 Windows 和 Linux 上查找哪一個線程使用的 CPU 時間最長？

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

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

十二、什麼是 Executors 框架？

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

1四、什麼是 Callable 和 Future?

1五、什麼是 FutureTask?使用 ExecutorService 啓動任務。

1六、什麼是併發容器的實現？

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

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

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

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

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

2二、在 Java 中 CycliBarriar 和 CountdownLatch 有什麼區別？

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

2四、什麼是多線程中的上下文切換？

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

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

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

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

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

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

3一、什麼是 Daemon 線程？它有什麼意義？

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

3三、什麼是可重入鎖（ReentrantLock）？

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

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

3六、SynchronizedMap 和 ConcurrentHashMap 有什麼區別？

3七、CopyOnWriteArrayList 能夠用於什麼應用場景？

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

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

40、爲何代碼會重排序？

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

4二、用 Java 實現阻塞隊列

4三、一個線程運行時發生異常會怎樣？

4四、如何在兩個線程間共享數據？

4五、Java 中 notify 和 notifyAll 有什麼區別？

4六、爲何 wait, notify 和 notifyAll 這些方法不在 thread 類裏面？

4七、什麼是 ThreadLocal 變量？

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

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

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

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

5二、什麼是線程池？爲何要使用它？

5三、怎麼檢測一個線程是否擁有鎖？

5四、你如何在 Java 中獲取線程堆棧？

5六、Thread 類中的 yield 方法有什麼做用？

5七、Java 中 ConcurrentHashMap 的併發度是什麼？

5八、Java 中 Semaphore 是什麼？

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

60、什麼是阻塞式方法？

6一、Java 中的 ReadWriteLock 是什麼？

6二、volatile 變量和 atomic 變量有什麼不一樣？

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

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

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

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

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

6八、線程之間是如何通訊的？

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

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

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

7二、如何確保線程安全？

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

7四、如何建立守護線程？

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

關於Java併發編程的知識總結了個思惟導圖分享給你們java

一、在 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 守護進程。

二、線程與進程的區別？

進程是操做系統分配資源的最小單元，線程是操做系統調度的最小單元。

一個程序至少有一個進程,一個進程至少有一個線程。

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

多線程會共同使用一組計算機上的 CPU，而線程數大於給程序分配的 CPU 數量時，爲了讓各個線程都有執行的機會，就須要輪轉使用 CPU。不一樣的線程切換使用 CPU發生的切換數據等就是上下文切換。

四、死鎖與活鎖的區別，死鎖與飢餓的區別？

死鎖：是指兩個或兩個以上的進程（或線程）在執行過程當中，因爭奪資源而形成的一種互相等待的現象，若無外力做用，它們都將沒法推動下去。

產生死鎖的必要條件：

一、互斥條件：所謂互斥就是進程在某一時間內獨佔資源。

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

三、不剝奪條件:進程已得到資源，在末使用完以前，不能強行剝奪。

四、循環等待條件:若干進程之間造成一種頭尾相接的循環等待資源關係。

活鎖：任務或者執行者沒有被阻塞，因爲某些條件沒有知足，致使一直重複嘗試，失敗，嘗試，失敗。

活鎖和死鎖的區別在於，處於活鎖的實體是在不斷的改變狀態，所謂的「活」，而處於死鎖的實體表現爲等待；活鎖有可能自行解開，死鎖則不能。

飢餓：一個或者多個線程由於種種緣由沒法得到所須要的資源，致使一直沒法執行的狀態。

Java 中致使飢餓的緣由：

一、高優先級線程吞噬全部的低優先級線程的 CPU 時間。

二、線程被永久堵塞在一個等待進入同步塊的狀態，由於其餘線程老是能在它以前持續地對該同步塊進行訪問。

三、線程在等待一個自己也處於永久等待完成的對象(好比調用這個對象的 wait 方法)，由於其餘線程老是被持續地得到喚醒。

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

採用時間片輪轉的方式。能夠設置線程的優先級，會映射到下層的系統上面的優先級上，如非特別須要，儘可能不要用，防止線程飢餓。

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

ThreadGroup 類，能夠把線程歸屬到某一個線程組中，線程組中能夠有線程對象，也能夠有線程組，組中還能夠有線程，這樣的組織結構有點相似於樹的形式。

爲何不推薦使用？由於使用有不少的安全隱患吧，沒有具體追究，若是須要使用，推薦使用線程池。

七、爲何使用 Executor 框架？

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

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

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

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

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

Executor 接口對象能執行咱們的線程任務。

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

使用 ThreadPoolExecutor 能夠建立自定義線程池。

Future 表示異步計算的結果，他提供了檢查計算是否完成的方法，以等待計算的完成，並可使用 get()方法獲取計算的結果。

九、如何在 Windows 和 Linux 上查找哪一個線程使用的 CPU 時間最長？

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

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

Lock 接口比同步方法和同步塊提供了更具擴展性的鎖操做。

他們容許更靈活的結構，能夠具備徹底不一樣的性質，而且能夠支持多個相關類的條件對象。

它的優點有：

可使鎖更公平

可使線程在等待鎖的時候響應中斷

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

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

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

十二、什麼是 Executors 框架？

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1四、什麼是 Callable 和 Future?

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

能夠認爲是帶有回調的 Runnable。

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

1五、什麼是 FutureTask?使用 ExecutorService 啓動任務。

在 Java 併發程序中 FutureTask 表示一個能夠取消的異步運算。它有啓動和取消運算、查詢運算是否完成和取回運算結果等方法。只有當運算完成的時候結果才能取回，若是運算還沒有完成 get 方法將會阻塞。一個 FutureTask 對象能夠對調用了 Callable 和 Runnable 的對象進行包裝，因爲 FutureTask 也是調用了 Runnable接口因此它能夠提交給 Executor 來執行。

1六、什麼是併發容器的實現？

何爲同步容器：能夠簡單地理解爲經過 synchronized 來實現同步的容器，若是有多個線程調用同步容器的方法，它們將會串行執行。好比 Vector，Hashtable，以及 Collections.synchronizedSet，synchronizedList 等方法返回的容器。能夠經過查看 Vector，Hashtable 等這些同步容器的實現代碼，能夠看到這些容器實現線程安全的方式就是將它們的狀態封裝起來，並在須要同步的方法上加上關鍵字 synchronized。

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

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

線程同步是指線程之間所具備的一種制約關係，一個線程的執行依賴另外一個線程的消息，當它沒有獲得另外一個線程的消息時應等待，直到消息到達時才被喚醒。線程互斥是指對於共享的進程系統資源，在各單個線程訪問時的排它性。當有若干個線程都要使用某一共享資源時，任什麼時候刻最多隻容許一個線程去使用，其它要使用該資源的線程必須等待，直到佔用資源者釋放該資源。線程互斥能夠當作是一種特殊的線程同步。

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

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

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

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

1九、你將如何使用 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()方法時，就進入死亡狀態，該線程結束生命週期。

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

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

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

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

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

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

首先，wait、notify 方法是針對對象的，調用任意對象的 wait()方法都將致使線程阻塞，阻塞的同時也將釋放該對象的鎖，相應地，調用任意對象的 notify()方法則將隨機解除該對象阻塞的線程，但它須要從新獲取改對象的鎖，直到獲取成功才能往下執行；其次，wait、notify 方法必須在 synchronized 塊或方法中被調用，而且要保證同步塊或方法的鎖對象與調用 wait、notify 方法的對象是同一個，如此一來在調用 wait 以前當前線程就已經成功獲取某對象的鎖，執行 wait 阻塞後當前線程就將以前獲取的對象鎖釋放。

2二、在 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。

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

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

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

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

不可變對象永遠是線程安全的。

只有知足以下狀態，一個對象纔是不可變的；

它的狀態不能在建立後再被修改；

全部域都是 final 類型；而且，它被正確建立（建立期間沒有發生 this 引用的逸出）。

2四、什麼是多線程中的上下文切換？

在上下文切換過程當中，CPU 會中止處理當前運行的程序，並保存當前程序運行的具體位置以便以後繼續運行。從這個角度來看，上下文切換有點像咱們同時閱讀幾本書，在來回切換書本的同時咱們須要記住每本書當前讀到的頁碼。在程序中，上下文切換過程當中的「頁碼」信息是保存在進程控制塊（PCB）中的。PCB 還常常被稱做「切換楨」（switchframe）。「頁碼」信息會一直保存到 CPU 的內存中，直到他們被再次使用。

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

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

計算機一般只有一個 CPU,在任意時刻只能執行一條機器指令,每一個線程只有得到CPU 的使用權才能執行指令.所謂多線程的併發運行,實際上是指從宏觀上看,各個線程輪流得到 CPU 的使用權,分別執行各自的任務.在運行池中,會有多個處於就緒狀態的線程在等待 CPU,JAVA 虛擬機的一項任務就是負責線程的調度,線程調度是指按照特定機制爲多個線程分配 CPU 的使用權.

有兩種調度模型：分時調度模型和搶佔式調度模型。

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

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

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

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

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

爲何要使用 Executor 線程池框架

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

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

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

使用 Executor 線程池框架的優勢

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

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

三、框架中已經有定時、按期、單線程、併發數控制等功能。

綜上所述使用線程池框架 Executor 能更好的管理線程、提供系統資源使用率。

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

繼承 Thread 類

實現 Runnable 接口

實現 Callable 接口，須要實現的是 call() 方法

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

使用共享變量的方式

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

使用 interrupt 方法終止線程

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

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

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

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

3一、什麼是 Daemon 線程？它有什麼意義？

所謂後臺(daemon)線程，是指在程序運行的時候在後臺提供一種通用服務的線程，而且這個線程並不屬於程序中不可或缺的部分。所以，當全部的非後臺線程結束時，程序也就終止了，同時會殺死進程中的全部後臺線程。反過來講，只要有任何非後臺線程還在運行，程序就不會終止。必須在線程啓動以前調用setDaemon()方法，才能把它設置爲後臺線程。注意：後臺進程在不執行 finally子句的狀況下就會終止其 run()方法。

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

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

中斷和共享變量

3三、什麼是可重入鎖（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 都是可重入的鎖，可重入鎖相對來講簡化了併發編程的開發。

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

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

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

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

悲觀鎖：老是假設最壞的狀況，每次去拿數據的時候都認爲別人會修改，因此每次在拿數據的時候都會上鎖，這樣別人想拿這個數據就會阻塞直到它拿到鎖。傳統的關係型數據庫裏邊就用到了不少這種鎖機制，好比行鎖，表鎖等，讀鎖，寫鎖等，都是在作操做以前先上鎖。再好比 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 就沒法保證操做的原子性，這個時候就能夠用鎖。

3六、SynchronizedMap 和 ConcurrentHashMap 有什麼區別？

SynchronizedMap 一次鎖住整張表來保證線程安全，因此每次只能有一個線程來訪爲 map。

ConcurrentHashMap 使用分段鎖來保證在多線程下的性能。

ConcurrentHashMap 中則是一次鎖住一個桶。ConcurrentHashMap 默認將hash 表分爲 16 個桶，諸如 get,put,remove 等經常使用操做只鎖當前須要用到的桶。

這樣，原來只能一個線程進入，如今卻能同時有 16 個寫線程執行，併發性能的提高是顯而易見的。

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

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

3七、CopyOnWriteArrayList 能夠用於什麼應用場景？

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

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

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

CopyOnWriteArrayList 透露的思想

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

二、最終一致性

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

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

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

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

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

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

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

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

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

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

40、爲何代碼會重排序？

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

在單線程環境下不能改變程序運行的結果；

存在數據依賴關係的不容許重排序

須要注意的是：重排序不會影響單線程環境的執行結果，可是會破壞多線程的執行語義。

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

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

4二、用 Java 實現阻塞隊列

4三、一個線程運行時發生異常會怎樣？

若是異常沒有被捕獲該線程將會中止執行。Thread.UncaughtExceptionHandler是用於處理未捕獲異常形成線程忽然中斷狀況的一個內嵌接口。當一個未捕獲異常將形成線程中斷的時候 JVM 會使用 Thread.getUncaughtExceptionHandler()來查詢線程的 UncaughtExceptionHandler 並將線程和異常做爲參數傳遞給handler 的 uncaughtException()方法進行處理。

4四、如何在兩個線程間共享數據？

在兩個線程間共享變量便可實現共享。

通常來講，共享變量要求變量自己是線程安全的，而後在線程內使用的時候，若是有對共享變量的複合操做，那麼也得保證複合操做的線程安全性。

4五、Java 中 notify 和 notifyAll 有什麼區別？

notify() 方法不能喚醒某個具體的線程，因此只有一個線程在等待的時候它纔有用武之地。而 notifyAll()喚醒全部線程並容許他們爭奪鎖確保了至少有一個線程能繼續運行。

4六、爲何 wait, notify 和 notifyAll 這些方法不在 thread類裏面？

一個很明顯的緣由是 JAVA 提供的鎖是對象級的而不是線程級的，每一個對象都有鎖，經過線程得到。因爲 wait，notify 和 notifyAll 都是鎖級別的操做，因此把他們定義在 Object 類中由於鎖屬於對象。

4七、什麼是 ThreadLocal 變量？

ThreadLocal 是 Java 裏一種特殊的變量。每一個線程都有一個 ThreadLocal 就是每一個線程都擁有了本身獨立的一個變量，競爭條件被完全消除了。它是爲建立代價高昂的對象獲取線程安全的好方法，好比你能夠用 ThreadLocal 讓SimpleDateFormat 變成線程安全的，由於那個類建立代價高昂且每次調用都須要建立不一樣的實例因此不值得在局部範圍使用它，若是爲每一個線程提供一個本身獨有的變量拷貝，將大大提升效率。首先，經過複用減小了代價高昂的對象的建立個數。其次，你在沒有使用高代價的同步或者不變性的狀況下得到了線程安全。

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

interrupt

interrupt 方法用於中斷線程。調用該方法的線程的狀態爲將被置爲」中斷」狀態。

注意：線程中斷僅僅是置線程的中斷狀態位，不會中止線程。須要用戶本身去監視線程的狀態爲並作處理。支持線程中斷的方法（也就是線程中斷後會拋出interruptedException 的方法）就是在監視線程的中斷狀態，一旦線程的中斷狀態被置爲「中斷狀態」，就會拋出中斷異常。

interrupted

查詢當前線程的中斷狀態，而且清除原狀態。若是一個線程被中斷了，第一次調用 interrupted 則返回 true，第二次和後面的就返回 false 了。

isInterrupted

僅僅是查詢當前線程的中斷狀態

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

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

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

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

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

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

5二、什麼是線程池？爲何要使用它？

建立線程要花費昂貴的資源和時間，若是任務來了才建立線程那麼響應時間會變長，並且一個進程能建立的線程數有限。爲了不這些問題，在程序啓動的時候就建立若干線程來響應處理，它們被稱爲線程池，裏面的線程叫工做線程。從JDK1.5 開始，Java API 提供了 Executor 框架讓你能夠建立不一樣的線程池。

5三、怎麼檢測一個線程是否擁有鎖？

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

5四、你如何在 Java 中獲取線程堆棧？

kill -3 [java pid]

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

tomcat pid, 輸出堆棧到 log 目錄下。

Jstack [java pid]

這個比較簡單，在當前終端顯示，也能夠重定向到指定文件中。

-JvisualVM：Thread Dump

不作說明，打開 JvisualVM 後，都是界面操做，過程仍是很簡單的。

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

-Xss 每一個線程的棧大小

5六、Thread 類中的 yield 方法有什麼做用？

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

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

5七、Java 中 ConcurrentHashMap 的併發度是什麼？

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

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

5八、Java 中 Semaphore 是什麼？

Java 中的 Semaphore 是一種新的同步類，它是一個計數信號。從概念上講，從概念上講，信號量維護了一個許可集合。若有必要，在許可可用前會阻塞每個acquire()，而後再獲取該許可。每一個 release()添加一個許可，從而可能釋放一個正在阻塞的獲取者。可是，不使用實際的許可對象，Semaphore 只對可用許可的號碼進行計數，並採起相應的行動。信號量經常用於多線程的代碼中，好比數據庫鏈接池。

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

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

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

60、什麼是阻塞式方法？

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

6一、Java 中的 ReadWriteLock 是什麼？

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

6二、volatile 變量和 atomic 變量有什麼不一樣？

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

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

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

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

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

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

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

每個線程都是有優先級的，通常來講，高優先級的線程在運行時會具備優先權，但這依賴於線程調度的實現，這個實現是和操做系統相關的(OS dependent)。咱們能夠定義線程的優先級，可是這並不能保證高優先級的線程會在低優先級的線程前執行。線程優先級是一個 int 變量(從 1-10)，1 表明最低優先級，10 表明最高優先級。

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

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

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

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

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

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

6八、線程之間是如何通訊的？

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

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

Java 的每一個對象中都有一個鎖(monitor，也能夠成爲監視器) 而且 wait()，notify()等方法用於等待對象的鎖或者通知其餘線程對象的監視器可用。在 Java 的線程中並無可供任何對象使用的鎖和同步器。這就是爲何這些方法是 Object 類的一部分，這樣 Java 的每個類都有用於線程間通訊的基本方法。

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

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