一文搞定Java併發編程面試考點

時間 2019-11-13

標籤一文搞定 java 併發編程面試欄目 Java 简体版

原文原文鏈接

一、在java中守護線程和本地線程區別？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守護進程。

二、線程與進程的區別？編程

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

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

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

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

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

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

產生死鎖的必要條件：安全

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

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

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

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

Java中致使飢餓的緣由：

高優先級線程吞噬全部的低優先級線程的CPU時間。
線程被永久堵塞在一個等待進入同步塊的狀態，由於其餘線程老是能在它以前持續地對該同步塊進行訪問。
線程在等待一個自己也處於永久等待完成的對象(好比調用這個對象的wait方法)，由於其餘線程老是被持續地得到喚醒。

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

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

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

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

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

七、爲何使用Executor框架？

每次執行任務建立線程 new Thread()比較消耗性能，建立一個線程是比較耗時、耗資源的。
調用 new Thread()建立的線程缺少管理，被稱爲野線程，並且能夠無限制的建立，線程之間的相互競爭會致使過多佔用系統資源而致使系統癱瘓，還有線程之間的頻繁交替也會消耗不少系統資源。
接使用new Thread() 啓動的線程不利於擴展，好比定時執行、按期執行、定時按期執行、線程中斷等都不便實現。

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

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

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

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

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

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

九、什麼是原子操做？在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框架能夠很是方便的建立一個線程池。

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

阻塞隊列（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()方法時，就進入死亡狀態，該線程結束生命週期。

咱們運行以前的那個死鎖代碼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:34)
    - 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:116)
    at java.net.SocketInputStream.read(SocketInputStream.java:171)
    at java.net.SocketInputStream.read(SocketInputStream.java:141)
    at sun.nio.cs.StreamDecoder.readBytes(StreamDecoder.java:284)
    at sun.nio.cs.StreamDecoder.implRead(StreamDecoder.java:326)
    at sun.nio.cs.StreamDecoder.read(StreamDecoder.java:178)
    - locked <0x00000000d632b928> (a java.io.InputStreamReader)
    at java.io.InputStreamReader.read(InputStreamReader.java:184)
    at java.io.BufferedReader.fill(BufferedReader.java:161)
    at java.io.BufferedReader.readLine(BufferedReader.java:324)
    - locked <0x00000000d632b928> (a java.io.InputStreamReader)
    at java.io.BufferedReader.readLine(BufferedReader.java:389)
    at com.intellij.rt.execution.application.AppMainV2$1.run(AppMainV2.java:64)

"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:143)
    - locked <0x00000000d6108ec8> (a java.lang.ref.ReferenceQueue$Lock)
    at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:164)
    at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:209)

"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:502)
    at java.lang.ref.Reference.tryHandlePending(Reference.java:191)
    - locked <0x00000000d6106b68> (a java.lang.ref.Reference$Lock)
    at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:153)

"VM Thread" os_prio=2 tid=0x000000001771b800 nid=0x604 runnable 

"GC task thread#0 (ParallelGC)" os_prio=0 tid=0x0000000001c9d800 nid=0x9f0 runnable 

"GC task thread#1 (ParallelGC)" os_prio=0 tid=0x0000000001c9f000 nid=0x154c runnable 

"GC task thread#2 (ParallelGC)" os_prio=0 tid=0x0000000001ca0800 nid=0xcd0 runnable 

"GC task thread#3 (ParallelGC)" os_prio=0 tid=0x0000000001ca2000 nid=0x1e58 runnable 

"VM Periodic Task Thread" os_prio=2 tid=0x0000000018c5a000 nid=0x1b58 waiting on condition 

JNI global references: 33


/* 此處能夠看待死鎖的相關信息！ */
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:56)
    - 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:34)
    - waiting to lock <0x00000000d629b4e8> (a java.lang.Object)
    - locked <0x00000000d629b4d8> (a java.lang.Object)

Found 1 deadlock.

/* 內存使用情況，詳情得看JVM方面的書 */
Heap
 PSYoungGen      total 37888K, used 4590K [0x00000000d6100000, 0x00000000d8b00000, 0x0000000100000000)
  eden space 32768K, 14% used [0x00000000d6100000,0x00000000d657b968,0x00000000d8100000)
  from space 5120K, 0% used [0x00000000d8600000,0x00000000d8600000,0x00000000d8b00000)
  to   space 5120K, 0% used [0x00000000d8100000,0x00000000d8100000,0x00000000d8600000)
 ParOldGen       total 86016K, used 0K [0x0000000082200000, 0x0000000087600000, 0x00000000d6100000)
  object space 86016K, 0% used [0x0000000082200000,0x0000000082200000,0x0000000087600000)
 Metaspace       used 3474K, capacity 4500K, committed 4864K, reserved 1056768K
  class space    used 382K, capacity 388K, committed 512K, reserved 1048576K

1九、爲何咱們調用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阻塞後當前線程就將以前獲取的對象鎖釋放。

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()方法，由於該方法雖然不會中斷一個正在運行的線程，可是它可使一個被阻塞的線程拋出一箇中斷異常，從而使線程提早結束阻塞狀態，退出堵塞代碼。

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

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

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

30、什麼是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用於多線程環境下的單次操做(單次讀或者單次寫)。

3九、爲何代碼會重排序？

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

在單線程環境下不能改變程序運行的結果；
存在數據依賴關係的不容許重排序

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

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的對象必須是他們所處同步塊的鎖對象。

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之間產生競態條件。

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

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

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

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

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

建立線程要花費昂貴的資源和時間，若是任務來了才建立線程那麼響應時間會變長，並且一個進程能建立的線程數有限。爲了不這些問題，在程序啓動的時候就建立若干線程來響應處理，它們被稱爲線程池，裏面的線程叫工做線程。從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都有這些方法。

5八、什麼是阻塞式方法？

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

5九、Java中的ReadWriteLock是什麼？

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

60、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() otify() otifyAll()方法能夠用於線程間通訊關於資源的鎖的狀態。

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

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

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

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

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

Thread類的sleep()和yield()方法將在當前正在執行的線程上運行。因此在其餘處於等待狀態的線程上調用這些方法是沒有意義的。這就是爲何這些方法是靜態的。它們能夠在當前正在執行的線程中工做，並避免程序員錯誤的認爲能夠在其餘非運行線程調用這些方法。

70、如何確保線程安全？

在Java中能夠有不少方法來保證線程安全——同步，使用原子類(atomic concurrent classes)，實現併發鎖，使用volatile關鍵字，使用不變類和線程安全類。

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

同步塊是更好的選擇，由於它不會鎖住整個對象（固然你也可讓它鎖住整個對象）。同步方法會鎖住整個對象，哪怕這個類中有多個不相關聯的同步塊，這一般會致使他們中止執行並須要等待得到這個對象上的鎖。

同步塊更要符合開放調用的原則，只在須要鎖住的代碼塊鎖住相應的對象，這樣從側面來講也能夠避免死鎖。

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

使用Thread類的setDaemon(true)方法能夠將線程設置爲守護線程，須要注意的是，須要在調用start()方法前調用這個方法，不然會拋出IllegalThreadStateException異常。

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

java.util.Timer是一個工具類，能夠用於安排一個線程在將來的某個特定時間執行。Timer類能夠用安排一次性任務或者週期任務。

java.util.TimerTask是一個實現了Runnable接口的抽象類，咱們須要去繼承這個類來建立咱們本身的定時任務並使用Timer去安排它的執行。