多线程面试题集锦
1、為什么使用Executor框架？
每次創(chuàng)建線程new Thread()比較消耗性能（耗時，耗資源），而且任務來了才創(chuàng)建那么響應時間會變長 。線程池方便線程的回收利用，避免頻繁創(chuàng)建導致的資源消耗
new Thread()創(chuàng)建的線程缺乏管理，而且可以無限制的創(chuàng)建，線程之間的相互競爭會導致過多占用系統(tǒng)資源而導致系統(tǒng)癱瘓（OutOfMemoryError，OOM），還有線程之間的頻繁交替也會消耗很多系統(tǒng)資源。Executors創(chuàng)建線程可以有效控制最大并發(fā)線程數(shù)，提高系統(tǒng)資源利用率，同時避免過多資源競爭
new Thread()啟動的線程不利于擴展，比如定時執(zhí)行、定期執(zhí)行、線程中斷等都不便實現(xiàn)（線程池提供定時定期執(zhí)行、單線程、并發(fā)數(shù)控制等）
2、Executor和Executors的區(qū)別
Executors是工具類，里面的方法可以創(chuàng)建不同類型的線程池（定長、變長、定時、單一）
Executro是線程池的一個根接口，里面有一個execute()方法用來執(zhí)行任務
3、什么是原子操作？簡述java.util.concurrent包中的原子類？
原子操作（atomic operation）：不可被中斷的一個或一系列操作。
處理器使用基于對緩存加鎖或總線加鎖的方式來實現(xiàn)多處理器之間的原子操作。
在Java中可以通過鎖和循環(huán)CAS的方式來實現(xiàn)原子操作。CAS操作（Compare and swap或compare and set），現(xiàn)在幾乎所有的cpu指令都支持cas的原子操作
原子操作是指一個不受其他操作影響的操作任務單元。原子操作是在多線程環(huán)境下避免數(shù)據(jù)不一致必須的手段
int++并不是一個原子操作，所以當一個線程讀取它的值并加一時，另外一個線程有可能會讀到之前的值，這就引發(fā)錯誤
為了解決這個問題，必須保證增加操作是原子的，JDK1.5之前我們可以使用同步技術(shù)來做到這一點。1.5后增加了java.util.concurrent.atomic包提供了int和long類型的原子包裝類，他們可以保證對于他們的操作是原子的，而且不需要使用同步。
java.util.concurrent.atomic包里面的原子類，基本特性就是在多線程環(huán)境下，當有多個線程同時執(zhí)行這些類的實例包含的方法時，具有排他性：即當某個線程進入方法，執(zhí)行其中的指令時，不會被其他線程打斷，而別的線程就像自旋鎖一樣，一直等到該方法執(zhí)行完成，才由JVM從等待隊列中選擇另一個線程進入，這只是一種邏輯上的理解。
原子類：AtomicBoolean，AtomicInteger，AtomicLong，AtomicReference
原子數(shù)組：AtomicIntegerArray，AtomicLongArray，AtomicReferenceArray
原子屬性更新器：AtomicLongFieldUpdater,AtomicIntegerFieldUpdater，AtomicReferenceFieldUpdater
解決ABA問題的原子類：AtomicMarkableReference（通過引入一個boolean來反映中間有沒有變過）（通過引入一個int來累加反映中間有沒有變過）
4、Lock接口是什么？對比synchronized有什么優(yōu)勢？
Lock接口比synchronized提供了更具擴展性的鎖操作
優(yōu)勢：
公平鎖
可以使線程在等待鎖的時候響應中斷
可以讓線程嘗試獲取鎖（tryLock）并在無法獲取鎖的時候立即返回或者等待一段時間
可以在不同的范圍，以不同的順序獲取和釋放鎖
整體上來說Lock是synchronized的擴展板，Lock提供了無條件的，可輪詢的（tryLock方法）、定時的（tryLock帶參）、可中斷的（lockInterruptibly）、可多條件隊列的（new Condition方法）鎖操作。另外Lock的實現(xiàn)類基本都支持非公平（默認）和公平鎖。synchronized只支持非公平鎖，當然，在大部分情況下，非公平鎖是高效的選擇
5、Executors框架
Excutors框架是一個根據(jù)一組執(zhí)行側(cè)率調(diào)用，調(diào)度，執(zhí)行和控制的異步任務的框架。
無限制的創(chuàng)建線程會引起應用程序內(nèi)存溢出。所以創(chuàng)建一個線程池是個更好的解決方案，因為可以限制線程的數(shù)量并且可以回收再利用這些線程。利用Executors框架可以非常方便的創(chuàng)建一個線程池（定長、變長、單一、定時）
6、什么是阻塞隊列（BlockingQueue）？阻塞隊列的實現(xiàn)原理是什么？如何使用阻塞隊列來實現(xiàn)生產(chǎn)者-消費者模型
阻塞隊列（BlockingQueue）是一個支持兩個附加操作的隊列。
這兩個附加的操作是：在隊列為空時，獲取元素的線程會等待隊列變?yōu)榉强铡．旉犃袧M時，存儲元素的線程會等待隊列可用。
阻塞隊列常用語生產(chǎn)者和消費者的場景，生產(chǎn)者是往隊列里添加元素的線程，消費者是從隊列里拿元素的線程。阻塞隊列就是生產(chǎn)者存放元素的容器，而消費者也只從容器拿元素。
JDK7提供了7個阻塞隊列。分別是：
ArrayBlockingQueue：一個由數(shù)組結(jié)構(gòu)組成的有界阻塞隊列
LinkedBlockingQueue：一個由鏈表結(jié)構(gòu)組成的有界阻塞隊列
PriorityBlockingQueue：一個支持優(yōu)先級排序的無界阻塞隊列
DelayQueue：一個使用優(yōu)先級隊列實現(xiàn)的無界阻塞隊列
SynchronousQueue：一個不存儲元素的阻塞隊列（此5個jdk 1.5）
LinkedTransferQueue：一個由鏈表結(jié)構(gòu)阻塞的無界阻塞隊列（jdk1.7）
LinkedBlockingDeque：一個由鏈表結(jié)構(gòu)組成的雙向阻塞隊列（jdk1.6）
java 5之前實現(xiàn)同步存取時，可以使用普通的一個集合，然后在使用線程的協(xié)作和線程同步可以實現(xiàn)生產(chǎn)者、消費者模式，主要技術(shù)就是用好：wait、notify、notifyAll、synchronized這些關(guān)鍵字。而在java 5之后，可以使用阻塞隊列來實現(xiàn)，此方式大大減少了代碼量，使得多線程編程更加容易，安全方面也有保障。
BlockingQueue接口是Queue的子接口，它的主要用途并不是作為容器，而是作為線程同步的工具，因此它具有一個很明顯的特性，當生產(chǎn)者線程師徒想BlockingQueue放入元素時，如果隊列已滿，則線程被阻塞，當消費者線程師徒從中取出一個元素時，如果隊列為空，則該線程會被阻塞，正是因為它所具有的這個特性，所以在程序中多個線程交替向BlockingQueue中放入元素，取出元素，它可以很好的控制線程之間的通信。
阻塞隊列使用最經(jīng)典的場景就是socket客戶端數(shù)據(jù)的讀取和解析，讀取數(shù)據(jù)的線程不斷將數(shù)據(jù)放入隊列，然后解析線程不斷從隊列數(shù)據(jù)解析
7、什么是Callable和Future？
Callable接口類似于Runnable，但是Runnable沒有返回值，并且無法拋出異常（run 方法無法聲明異常）。Callable接口，的call方法允許有返回值（并且可以聲明異常），這個返回值可以被Future拿到。
可以認為它是帶有回調(diào)的Runnable
Future接口表示異步任務，是還沒有完成的任務給出的未來結(jié)果。所以說Callable用于產(chǎn)生結(jié)果，F(xiàn)uture用于獲取結(jié)果
8、什么是FutureTask？
FutureTask表示一個異步運算任務，實現(xiàn)了Future和Runnable接口，持有Callable的引用。意味著它可以傳遞給Thread(Runnable task)，調(diào)用start()方法啟動線程，并且能夠獲取到線程執(zhí)行結(jié)果的返回值。當然同樣可以使用Executors線程池來提交任務。
public static void main(String[] args) {
//第一種方式
ExecutorService executor = Executors.newCachedThreadPool();
Task task = new Task();
FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
executor.submit(futureTask);
executor.shutdown();
//第二種方式，注意這種方式和第一種方式效果是類似的，只不過一個使用的是ExecutorService，一個使用的是Thread
/*Task task = new Task();
FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
Thread thread = new Thread(futureTask);
thread.start();*/
try {
Thread.sleep(1000);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
System.out.println("主線程在執(zhí)行任務");
try {
System.out.println("task運行結(jié)果"+futureTask.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
System.out.println("所有任務執(zhí)行完畢");
}
9、什么是并發(fā)容器的實現(xiàn)？
同步容器：就是通過synchronized來實現(xiàn)同步的容器。如果有多個線程調(diào)用同步容器的方法，它們會串行執(zhí)行。比如Vector、HashTable，Collections.synchronizedSet,synchronizedList等方法返回的容器。這些容器的方法一般都使用了synchronized來修飾（包括讀）
并發(fā)容器使用了與同步容器完全不同的加鎖策略來提供更高的并發(fā)性和伸縮性，例如在ConcurrentHashMap中采用了一種粒度更細的加鎖機制（分段鎖），在這種鎖機制下，允許任意數(shù)量的讀線程并發(fā)地訪問map，并且執(zhí)行讀操作的線程和寫操作的線程也可以并發(fā)的訪問map，同時允許一定數(shù)量的寫操作線程并發(fā)地修改map，所以它可以在并發(fā)環(huán)境下實現(xiàn)更高的吞吐量
10、CyclicBarrier和CountDownLatch有什么區(qū)別？
1）CountDownLatch一個線程等待，知道他等待的其他線程都執(zhí)行完成并且調(diào)用countDown()方法發(fā)出通知后，當前線程才能繼續(xù)執(zhí)行
2）CyclicBarrier是所有線程都進行等待，知道所有線程都準備好進入await()方法之后，所有的線程同時開始執(zhí)行
3）CyclicBarrier可以重復使用（reset()），而CountDownLatch不能重復使用。所以CyclicBarrier可以處理更為復雜的業(yè)務場景，比如如果計算發(fā)生錯誤，可以充值計數(shù)器讓線程們重新執(zhí)行一次。
4）CyclicBarrier還提供其他有用的方法，比如getNumberWaiting方法可以獲得CyclicBarrier阻塞的線程數(shù)量。isBroken方法用來知道阻塞的線程是否被中斷。
Java的concurrent包里面的CountDownLatch其實可以把它看做一個計數(shù)器，只不過這個計數(shù)器的操作是原子操作，同時只能有一個線程去操作這個計數(shù)器，也就是同時只能有一個線程去減這個計數(shù)器里面的值。
你可以向CountDownLatch對象設(shè)置一個初始的數(shù)字作為計數(shù)值，任何調(diào)用這個對象的await()方法都會阻塞，直到這個計數(shù)器的計數(shù)值被其他的線程減為0為止。
所以在當前計數(shù)到達零之前，await方法會一直受阻塞。之后，會釋放所有等待的線程，await的所有后續(xù)調(diào)用都將立即返回。這種現(xiàn)象只出現(xiàn)一次——計數(shù)無法被重置。如果需要重置計數(shù)，請考慮使用CyclicBarrier。
CountDownLatch的一個非常典型的應用場景是：有一個任務想要往下執(zhí)行，但必須要等到其他的任務執(zhí)行完畢后才可以繼續(xù)往下執(zhí)行。假如我們這個想要繼續(xù)往下執(zhí)行的任務調(diào)用一個CountDownLatch對象的awit()方法，其他的任務執(zhí)行完自己的任務后調(diào)用同一個CountDownLatch對象上的countDown()方法，這個調(diào)用await()方法的任務將一直阻塞等待，直到這個CountDownLatch對象的計數(shù)值減到0為止。
CountDownLatch:一個線程(或者多個)， 等待另外N個線程完成某個事情之后才能執(zhí)行。
CyclicBarrier：N個線程互相等待，任何一個線程完成之前，所有的線程都必須等待
CyclicBarrier是一個同步輔助類，它允許一組線程互相等待，直到到達某個公共屏障點（common barrier point）。在涉及一組固定大小的線程的程序中，這些線程必須不時地互相等待，此時CyclicBarrier很有用。因為該barrier在釋放等待線程后可以重用，所以稱他為循環(huán)的barrier。
CyclicBarrier的一個典型使用場景是用于多線程計算數(shù)據(jù)，最后合并計算結(jié)果
11、如何停止一個正在運行的線程？
1）使用共享變量：共享變量作為標記
2）使用interrupt()方法終止線程：如果一個線程由于等待某些事件的發(fā)生而被阻塞，又該怎樣停止該線程呢？這種情況經(jīng)常會發(fā)生，比如當一個線程由于需要等候鍵盤輸入而被阻塞，或者調(diào)用Thread.join()方法，或者Thread.sleep()方法，在網(wǎng)絡(luò)中調(diào)用ServerSocket.accept()方法，或者調(diào)用了DatagramSocket.receive()方法時，都有可能導致線程阻塞，使線程處于處于不可運行狀態(tài)時，即使主程序中將該線程的共享變量設(shè)置為true，但該線程此時根本無法檢查循環(huán)標志，當然也就無法立即中斷。這里我們給出的建議是，不要使用stop()方法，而是使用Thread提供的interrupt()方法，因為該方法雖然不會中斷一個正在運行的線程，但是它可以使一個被阻塞的線程拋出一個中斷異常，從而使線程提前結(jié)束阻塞狀態(tài)，退出堵塞代碼。
12、樂觀鎖和悲觀鎖的理解及如何實現(xiàn)，有哪些實現(xiàn)方式？
悲觀鎖：總是假設(shè)最壞的情況，每次去那數(shù)據(jù)的時候都認為別人會修改，所以在每次拿數(shù)據(jù)的時候都會上鎖，這樣別人想拿這個數(shù)據(jù)就會阻塞直到它拿到鎖。傳統(tǒng)的關(guān)系型數(shù)據(jù)庫里邊就用到了很多這種鎖機制，比如行鎖，表鎖等，讀鎖，寫鎖等，都是在做操作之前上鎖。再比如Java里面的同步synchronized關(guān)鍵字的實現(xiàn)其實也是悲觀鎖。
樂觀鎖：顧名思義，就是很樂觀，每次去拿數(shù)據(jù)的時候都認為別人不會修改，所以不會上鎖，但是在更新的時候會判斷一下在此期間別人有沒有去更新這個數(shù)據(jù)，可以使用版本號等機制。樂觀鎖適用于多讀的應用場景，這樣可以提高吞吐量，想數(shù)據(jù)庫提供的類似write_condition機制，其實都是提供的樂觀鎖。在Java中java.util.concurrent.atomic包下面的院子變量類就是使用了樂觀鎖的一種實現(xiàn)方式CAS實現(xiàn)的。
樂觀鎖的實現(xiàn)方式：
（1）使用版本表示來確定讀到的數(shù)據(jù)與提交時的數(shù)據(jù)是否一致。提交后修改版本標識，不一致可以采取丟棄和再嘗試的策略
（2）java中的Compareandswap即CAS，當多個線程嘗試使用CAS同時更新同一個變量時，只有其中一個線程能更新變量的值，而其它線程都失敗，失敗的線程并不會被掛起，而是被告知這次競爭中失敗，并可以再次嘗試。CAS操作中包含三個操作數(shù)——需要讀寫的內(nèi)存位置（V）、進行比較的預期原值（A）和擬寫入的新值（B）。如果內(nèi)存位置V的值與預期原值A(chǔ)相匹配，那么處理器會自動將該值更新為新值B。否則處理器不做任何操作。
CAS缺點：
（1）ABA問題：比如說一個線程one從內(nèi)存位置V取出A，這時候另一個線程two也從內(nèi)存中取出A，并且two進行了一些操作變成了B，然后two又將V位置的數(shù)據(jù)變成了A，這時候線程one進行CAS操作發(fā)現(xiàn)內(nèi)存中仍然是A，然后one操作成功。盡管線程one的CAS操作成功，但可能存在潛藏的問題。從Java1.5開始JDK的atomic包里提供了一個雷AtomicStampedReference來解決ABA問題
（2）循環(huán)時間長開銷大：對于資源競爭嚴重（線程沖突嚴重）的情況，CAS自旋的概率會比較大，從而浪費更多的CPU資源，效率低于synchronized
（3）只能保證一個共享變量的原子操作：當對一個共享變量執(zhí)行操作時，我們可以使用循環(huán)CAS的方式來保證原子操作，但是對多個共享變量從操作時，循環(huán)CAS就無法保證操作的原子性，這個時候就可以用鎖。
13、SynchronizedMap和ConcurrentHashMap有什么區(qū)別？
SynchronizedMap使用同步代碼塊來保證線程安全，鎖為當前對象。
ConcurrentHashMap使用分段鎖來保證多線程的性能。
ConcurrentHashMap中則是一次鎖住一個桶。ConcurrentHashMap默認將hash表分為16個桶，諸如get，put，remove等常用操作值鎖當前需要用到的桶。這樣，原來只能一個線程進入，現(xiàn)在卻能16個寫線程執(zhí)行，并發(fā)性能的提升顯而易見。
另外ConcurrentHashMap使用了一種不同的迭代方式。在這種迭代方式中，當iterator被創(chuàng)建后集合再發(fā)生改變就不再拋出ConcurrentModificationException，取而代之的是在改變時new新的數(shù)據(jù)從而不影響原有數(shù)據(jù)，iterator完成后再將頭指針替換為新的數(shù)據(jù)，這樣iterator線程可以使用原來老的數(shù)據(jù)，而寫線程也可以并發(fā)的完成改變
14、CopyOnWriteArrayList的應用場景
CopyOnWriteArrayList（免鎖容器）的好處之一是當多個迭代器同時遍歷和修改這個列表時，不會跑出ConcurrentModificationException。
在CopyOnWriteArrayList中，寫入將導致創(chuàng)建整個底層數(shù)組的副本，而源數(shù)組將保留在原地，使得復制的數(shù)組在被修改時，讀取操作可以安全地執(zhí)行。
（1）由于寫操作的時候，需要拷貝數(shù)組，會消耗內(nèi)存，如果原數(shù)組的內(nèi)容比較多的情況下，可能導致younggc或者fullgc；
（2）不能用于實時讀的場景，像拷貝數(shù)組、新增元素都需要時間，所以調(diào)用一個set操作后，讀取到數(shù)據(jù)可能還是舊的，雖然CopyOnWriteArrayList能做到最終一致性，但是還是沒法滿足實時性要求；
CopyOnWriteArrayList透露的思想：讀寫分離；最終一致性；使用另外開辟空間的思路，來解決并發(fā)沖突
15、什么叫線程安全？servlet是線程安全嗎？
線程安全指某個函數(shù)、函數(shù)庫在多線程環(huán)境中被調(diào)用時，能夠正確地處理多個線程之間的共享變量，使程序功能正確完成。
Servlet不是線程安全的，servlet使單例多線程的，當多個線程同時訪問同一個方法，是不能保證共享變量的線程安全性的。
16、volatile有什么用？應用場景
volatile保證內(nèi)存可見性和禁止指令重排序
volatile用于多線程下的單次操作（單次讀或者單次寫）
五種應用場景：狀態(tài)標志、一次性安全發(fā)布、獨立觀察、volatilebean模式、開銷較低的讀-寫鎖策略（參考：https://www.ibm.com/developerworks/cn/java/j-jtp06197.html）
17、為什么代碼會重排序
在執(zhí)行程序時，為了提供性能，處理器和編譯器常常會對指令進行重排序，但是不能隨意重排序，需要滿足以下兩個條件：
（1）在單線程環(huán)境下不能改變程序運行結(jié)果
（2）存在數(shù)據(jù)以來關(guān)系的不允許重排序
需要注意的是：重排序不會影響單線程環(huán)境的執(zhí)行結(jié)果，但是會破壞多線程的執(zhí)行語義
18、一個線程運行時發(fā)生異常會怎么樣？
如果異常沒有捕獲，該線程會停止執(zhí)行
Thread.UncaughtExceptionHandler是用來處理未捕獲異常造成線程突然中斷情況的一個內(nèi)嵌借口。當一個未捕獲異常將造成線程中斷的時候，JVM會使用Thread.getUncaughtExceptionHandler()來查詢線程的UncaughtExceptionHandler病將線程和異常作為參數(shù)傳遞給handler的uncaughtException()方法進行處理
19、為什么wait，notify和notifyAll這些方法不在Thread類，而在Object類？
一個很明顯的原因就是Java提供的鎖是對象鎖，而不是線程級的，每個對象都有鎖，通過線程獲得。由于wait、notify、notifyAll都是鎖級別的操作，所以把他們定義在Object類中，因為鎖屬于對象
20、什么是ThreadLocal變量？
ThreadLocal稱為線程變量，每個線程都有一個ThreadLocal就是每個線程都有自己的獨立變量，競爭條件被消除了。它是為創(chuàng)建代價高昂的對象獲取線程安全的好方法，比如你可以用ThreadLocal讓SimpleDataFormat變成線程安全的，因為那個類創(chuàng)建代價高昂且每次調(diào)用都需要創(chuàng)建不同的實例所以不值得在局部范圍使用它，如果為每個線程提供一個自己獨有的變量拷貝，將大大提高效率。首先，通過復用減少了代價高昂的對象的創(chuàng)建個數(shù)。其次，你在沒有使用高代價的同步或者不可變性的情況下獲得了線程安全。
ThreadLocal比較核心是ThreadLocalMap，作為存儲的容器，key為當前線程，value為值，所以通過get方法或去ThreadLocalMap中獲取當前線程對應key的value
21、怎么檢測一個線程是否擁有鎖？
java.lang.Thread中有一個方法holdsLock(Objectobj)，它返回true如果當且僅當當前線程擁有某個具體鎖對象
22、如何在Java中獲取線程堆棧？
kill -3 [java pid]
不會再當前中斷輸出，它會輸出到代碼執(zhí)行的或指定的地方去。比如，kill -3tomcatpid，輸出堆棧到log目錄下
Jstack [javapid]
這個比較簡單，在當前終端顯示，也可以重定向到指定文件中。
JvisualVM
Thread Dump，打開后都是界面操作
23、JVM中關(guān)于線程的參數(shù)
-Xss：每個線程的棧大小
24、ConcurrentHashMap的并發(fā)度是什么？
ConcurrentHashMap把實際map劃分成若干部分來實現(xiàn)它的可擴展性和線程安全。這種劃分是使用并發(fā)度獲得的，它是ConcurrentHashMap類構(gòu)造函數(shù)的一個可選參數(shù)，默認值16，這樣在多線程情況下就能避免爭用。
在JDK8之后，它摒棄了Segment（鎖段）的概念，而是啟用了一種全新的方式實現(xiàn)，利用CAS算法。同時加入了更多的輔助變量來提高并發(fā)度。
25、Java中Semaphore是什么？
Java中Semaphore是一種新的同步類，它是一個計數(shù)信號。從概念上講，信號量維護了一個許可集合。如有必要，在許可可用前會阻塞每一個acquire()，然后再獲取該許可。每個release()添加一個許可，從而可能釋放一個正在阻塞的獲取者。但是，不使用實際的許可對象，Semaphore只對可用許可的號碼進行計數(shù)，并采用相應的行動。信號量常常用于多線程的代碼中，比如數(shù)據(jù)庫連接池
26、線程池的submit()和execute()方法有什么區(qū)別
兩個方法都可以向線程池提交任務，execute方法返回值為void，它定義在Executor接口中。
submit方法可以返回持有計算結(jié)果的Future對象，它定義在ExecutorService接口中，它擴展了Executor接口
27、什么是阻塞式方法？
指程序會一直等待該方法完成期間不做其他事情，ServerSocket的accept()方法就是一直等待客戶端連接。這里的阻塞是指調(diào)用結(jié)果返回之前，當前線程會被掛起，直到得到結(jié)果之后才會返回。此外，還有異步和非阻塞式方法在任務完成前就返回
28、volatile變量和atomic變量有什么不同？
Volatile變量可以確保先行關(guān)系，即寫操作會發(fā)生在后續(xù)的讀操作之前, 但它并不能保證原子性。例如用volatile修飾count變量那么 count++ 操作就不是原子性的。
而AtomicInteger類提供的atomic方法可以讓這種操作具有原子性如getAndIncrement()方法會原子性的進行增量操作把當前值加一，其它數(shù)據(jù)類型和引用變量也可以進行相似操作。
29、你對線程優(yōu)先級的理解是什么？
每一個線程都是有優(yōu)先級的，一般來說，高優(yōu)先級的線程在運行時會具有優(yōu)先權(quán)，但這依賴于線程調(diào)度的實現(xiàn)，這個實現(xiàn)是和操作系統(tǒng)相關(guān)的(OS dependent)。我們可以定義線程的優(yōu)先級，但是這并不能保證高優(yōu)先級的線程會在低優(yōu)先級的線程前執(zhí)行。線程優(yōu)先級是一個int變量(從1-10)，1代表最低優(yōu)先級，10代表最高優(yōu)先級。
java的線程優(yōu)先級調(diào)度會委托給操作系統(tǒng)去處理，所以與具體的操作系統(tǒng)優(yōu)先級有關(guān)，如非特別需要，一般無需設(shè)置線程優(yōu)先級。
30、如何確保main()方法所在的線程是java程序最后結(jié)束的線程？
就是讓main方法等待其他線程完成在結(jié)束，最簡單的我們可以使用Thread類的join()方法來確保所有程序創(chuàng)建的線程在main()方法退出前結(jié)束。
其次可以使用CountDownLatch，CyclicBarrier等來阻塞main線程
31、線程之間是如何通信的？
object類的wait()，notify()，notifyAll()，Condition接口的await()，signal()，signalAll()
32、同步方法和同步塊，哪個是更好的選擇？
同步塊，因為他不會鎖住整個對象（當然你可以讓他鎖住整個對象）。同步方法會鎖住整個對象。
同步塊更符合開放調(diào)用的原則，只在需要鎖定的代碼塊鎖住相應的對象，這樣從側(cè)面也可以避免死鎖。同步原則，范圍越小越好，提高效率
33、如何創(chuàng)建守護線程？
使用Thread類的setDaemon(true)方法可以將線程設(shè)置為守護線程，需要注意的是，需要在調(diào)用start()方法前調(diào)用這個方法，否則會拋出IllegalThreadStateException異常。
34、什么是JavaTimer類？如何創(chuàng)建一個有特定時間間隔的任務？
java.util.Timer是一個工具類，可以用于安排一個線程在未來的某個特定時間執(zhí)行。Timer類可以用安排一次性任務或者周期任務。
java.util.TimerTask算是一個實現(xiàn)了Runnable接口的抽象類，我們需要去繼承這個類來創(chuàng)建我們自己的定時任務并使用Timer去安排它執(zhí)行。
35、《阿里巴巴開發(fā)手冊》為什么要禁用Executors的方式創(chuàng)建線程池？
可以參照java并發(fā)編程：線程池-Executors的分析
總結(jié)就是：
FixedThreadPool和SingleThreadExecutor兩者允許的請求隊列長度為Integer.MAX_VALUE，可能會堆積大量的請求，從而引起OOM異常
CachedThreadPool則允許創(chuàng)建的線程數(shù)為Integer.MAX_VALUE，可能會創(chuàng)建大量的線程，從而引起OOM異常
所以阿里巴巴開發(fā)手冊禁用Executors的方式創(chuàng)建線程池，推薦自己創(chuàng)建ThreadPoolExecutor的原因
參考：https://juejin.im/post/5dc41c165188257bad4d9e69
總結(jié)
- 上一篇： Lol滑稽id(滑稽id大全)
- 下一篇： Python爬虫爬取动态页面思路+实例（