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、死鎖與活鎖的差別，死鎖與饑餓的差別？
死鎖：是指兩個或兩個以上的程序（或線程）在執行過程中，因争奪資源而造成的一種互相等待的現象，若無外力作用，它們都将無法推進下去。 産生死鎖的必要條件： 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時間最長？
參考： http://daiguahub.com/2016/07/31/%E4%BD%BF%E7%94%A8jstack%E6%89%BE%E5%87%BA%E6%B6%88%E8%80%97CPU%E6%9C%80%E5%A4%9A%E7%9A%84%E7%BA%BF%E7%A8%8B%E4%BB%A3%E7%A0%81/
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接口比同步方法和同步塊提供了更具擴充性的鎖操作。 他們允許更靈活的結構，可以具有完全不同的性質，并且可以支援多個相關類的條件對象。
它的優勢有：
可以使鎖更公平 可以使線程在等待鎖的時候響應中斷 可以讓線程嘗試擷取鎖，并在無法擷取鎖的時候立即傳回或者等待一段時間 可以在不同的範圍，以不同的順序擷取和釋放鎖 整體上來說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？
建立狀态（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:28Full thread dump Java HotSpot(TM) 64-Bit Server VM (25.144-b01 mixed mode):
/* 線程名稱：DestroyJavaVM編号：#13優先級：5系統優先級：0jvm内部線程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 複制
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中有幾種方法可以實作一個線程？
繼承 Thread 類 實作 Runnable 接口 實作 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、為什麼代碼會重排序？
在執行程式時，為了提供性能，處理器和編譯器常常會對指令進行重排序，但是不能随意重排序，不是你想怎麼排序就怎麼排序，它需要滿足以下兩個條件：
在單線程環境下不能改變程式運作的結果； 存在資料依賴關系的不允許重排序 需要注意的是：重排序不會影響單線程環境的執行結果，但是會破壞多線程的執行語義。
41、在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的對象必須是他們所處同步塊的鎖對象。
42、用Java實作阻塞隊列
參考java中的阻塞隊列的内容吧，直接實作有點煩： http://www.infoq.com/cn/articles/java-blocking-queue
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去安排它的執行。
原文：
https://blog.csdn.net/qq_34039315/article/details/78549311
更多技術幹貨
近期100多篇技術幹貨，升職加薪必看
MQ消息隊列應用場景比較介紹
動圖+源碼+總結：示範JDK8 中的資料結構執行過程及原理
我們來談下高并發和分布式中的幂等處理
大型分布式系統中的緩存架構
美團面試經曆，貢獻出來一起學習
幹貨：MySQL索引與優化實踐
技術變化那麼快，學 Docker 看這篇就夠了
一文看懂 MySQL 高性能優化技巧實踐
分布式事務不了解？一次給你講清楚
動畫+原理+代碼+優化，解讀十大經典排序算法