1、在 java 中守護(hù)線程和本地線程區(qū)別？

java 中的線程分為兩種：守護(hù)線程（Daemon）和用戶線程（User）。

任何線程都可以設(shè)置為守護(hù)線程和用戶線程，通過方法 Thread.setDaemon(bool on)拴事；true 則把該線程設(shè)置為守護(hù)線程，反之則為用戶線程圣蝎。Thread.setDaemon() 必須在 Thread.start()之前調(diào)用刃宵，否則運(yùn)行時(shí)會(huì)拋出異常。

兩者的區(qū)別：

唯一的區(qū)別是判斷虛擬機(jī)(JVM)何時(shí)離開捅彻，Daemon 是為其他線程提供服務(wù)组去，如果 全部的 User Thread 已經(jīng)撤離，Daemon 沒有可服務(wù)的線程步淹，JVM 撤離从隆。也可 以理解為守護(hù)線程是 JVM 自動(dòng)創(chuàng)建的線程（但不一定），用戶線程是程序創(chuàng)建的 線程缭裆；比如 JVM 的垃圾回收線程是一個(gè)守護(hù)線程键闺，當(dāng)所有線程已經(jīng)撤離，不再產(chǎn) 生垃圾澈驼，守護(hù)線程自然就沒事可干了辛燥，當(dāng)垃圾回收線程是 Java 虛擬機(jī)上僅剩的線 程時(shí)，Java 虛擬機(jī)會(huì)自動(dòng)離開缝其。

擴(kuò)展：

Thread Dump 打印出來的線程信息挎塌，含有 daemon 字樣的線程即為守護(hù) 進(jìn)程，可能會(huì)有：服務(wù)守護(hù)進(jìn)程内边、編譯守護(hù)進(jìn)程榴都、windows 下的監(jiān)聽 Ctrl+break 的守護(hù)進(jìn)程、Finalizer 守護(hù)進(jìn)程漠其、引用處理守護(hù)進(jìn)程嘴高、GC 守護(hù)進(jìn)程窍荧。

2伸刃、線程與進(jìn)程的區(qū)別妄辩？

進(jìn)程是操作系統(tǒng)分配資源的最小單元凳寺，線程是操作系統(tǒng)調(diào)度的最小單元。

一個(gè)程序至少有一個(gè)進(jìn)程,一個(gè)進(jìn)程至少有一個(gè)線程套啤。

3宽气、什么是多線程中的上下文切換？

多線程會(huì)共同使用一組計(jì)算機(jī)上的 CPU纲岭，而線程數(shù)大于給程序分配的 CPU 數(shù)量時(shí)抹竹， 為了讓各個(gè)線程都有執(zhí)行的機(jī)會(huì)线罕，就需要輪轉(zhuǎn)使用 CPU止潮。不同的線程切換使用 CPU 發(fā)生的切換數(shù)據(jù)等就是上下文切換。

4钞楼、死鎖與活鎖的區(qū)別喇闸，死鎖與饑餓的區(qū)別？

死鎖：是指兩個(gè)或兩個(gè)以上的進(jìn)程（或線程）在執(zhí)行過程中询件，因爭奪資源而造成 的一種互相等待的現(xiàn)象燃乍，若無外力作用，它們都將無法推進(jìn)下去宛琅。

產(chǎn)生死鎖的必要條件：

1刻蟹、互斥條件：所謂互斥就是進(jìn)程在某一時(shí)間內(nèi)獨(dú)占資源。

2嘿辟、請求與保持條件：一個(gè)進(jìn)程因請求資源而阻塞時(shí)舆瘪，對已獲得的資源保持不放。

3红伦、不剝奪條件:進(jìn)程已獲得資源英古，在末使用完之前，不能強(qiáng)行剝奪昙读。

4召调、循環(huán)等待條件:若干進(jìn)程之間形成一種頭尾相接的循環(huán)等待資源關(guān)系。

活鎖：任務(wù)或者執(zhí)行者沒有被阻塞蛮浑，由于某些條件沒有滿足唠叛，導(dǎo)致一直重復(fù)嘗試， 失敗沮稚，嘗試艺沼，失敗。

活鎖和死鎖的區(qū)別在于壮虫，處于活鎖的實(shí)體是在不斷的改變狀態(tài)澳厢，所謂的“活”环础， 而 處于死鎖的實(shí)體表現(xiàn)為等待；活鎖有可能自行解開剩拢，死鎖則不能线得。

饑餓：一個(gè)或者多個(gè)線程因?yàn)榉N種原因無法獲得所需要的資源，導(dǎo)致一直無法執(zhí)行的狀態(tài)徐伐。

Java 中導(dǎo)致饑餓的原因：

1贯钩、高優(yōu)先級線程吞噬所有的低優(yōu)先級線程的 CPU 時(shí)間。

2办素、線程被永久堵塞在一個(gè)等待進(jìn)入同步塊的狀態(tài)角雷，因?yàn)槠渌€程總是能在它之前 持續(xù)地對該同步塊進(jìn)行訪問

3、線程在等待一個(gè)本身也處于永久等待完成的對象(比如調(diào)用這個(gè)對象的 wait 方 法)性穿，因?yàn)槠渌€程總是被持續(xù)地獲得喚醒勺三。

5、Java 中用到的線程調(diào)度算法是什么需曾？

采用時(shí)間片輪轉(zhuǎn)的方式吗坚。可以設(shè)置線程的優(yōu)先級呆万，會(huì)映射到下層的系統(tǒng)上面的優(yōu) 先級上商源，如非特別需要，盡量不要用谋减，防止線程饑餓牡彻。

6、什么是線程組出爹，為什么在 Java 中不推薦使用庄吼？

ThreadGroup 類，可以把線程歸屬到某一個(gè)線程組中以政，線程組中可以有線程對象霸褒， 也可以有線程組，組中還可以有線程盈蛮，這樣的組織結(jié)構(gòu)有點(diǎn)類似于樹的形式废菱。

為什么不推薦使用？因?yàn)槭褂糜泻芏嗟陌踩[患吧抖誉，沒有具體追究殊轴，如果需要使 用，推薦使用線程池袒炉。

7旁理、為什么使用 Executor 框架？

每次執(zhí)行任務(wù)創(chuàng)建線程 new Thread()比較消耗性能我磁，創(chuàng)建一個(gè)線程是比較耗時(shí)孽文、 耗資源的驻襟。

調(diào)用 new Thread()創(chuàng)建的線程缺乏管理，被稱為野線程芋哭，而且可以無限制的創(chuàng)建沉衣， 線程之間的相互競爭會(huì)導(dǎo)致過多占用系統(tǒng)資源而導(dǎo)致系統(tǒng)癱瘓，還有線程之間的 頻繁交替也會(huì)消耗很多系統(tǒng)資源减牺。

接使用 new Thread() 啟動(dòng)的線程不利于擴(kuò)展豌习，比如定時(shí)執(zhí)行、定期執(zhí)行拔疚、定時(shí) 定期執(zhí)行肥隆、線程中斷等都不便實(shí)現(xiàn)。

8稚失、在 Java 中 Executor 和 Executors 的區(qū)別栋艳？

Executors 工具類的不同方法按照我們的需求創(chuàng)建了不同的線程池，來滿足業(yè)務(wù)的需求墩虹。

Executor 接口對象能執(zhí)行我們的線程任務(wù)嘱巾。

ExecutorService 接口繼承了Executor 接口并進(jìn)行了擴(kuò)展，提供了更多的方法我 們能獲得任務(wù)執(zhí)行的狀態(tài)并且可以獲取任務(wù)的返回值诫钓。

使用 ThreadPoolExecutor 可以創(chuàng)建自定義線程池。

Future 表示異步計(jì)算的結(jié)果篙螟，他提供了檢查計(jì)算是否完成的方法菌湃，以等待計(jì)算的 完成，并可以使用 get()方法獲取計(jì)算的結(jié)果遍略。

9惧所、如何在 Windows 和 Linux 上查找哪個(gè)線程使用的 CPU 時(shí) 間最長？

參考： http://daiguahub.com/2016/07/31/使用 jstack 找出消耗 CPU 最多的線程代碼 /

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

原子操作（atomic operation）意為”不可被中斷的一個(gè)或一系列操作” 蕾久。 處理器使用基于對緩存加鎖或總線加鎖的方式來實(shí)現(xiàn)多處理器之間的原子操作势似。 在 Java 中可以通過鎖和循環(huán) CAS 的方式來實(shí)現(xiàn)原子操作。 CAS 操作—— Compare & Set僧著，或是 Compare & Swap履因，現(xiàn)在幾乎所有的 CPU 指令都支持 CAS 的原子操作。

原子操作是指一個(gè)不受其他操作影響的操作任務(wù)單元盹愚。原子操作是在多線程環(huán)境 下避免數(shù)據(jù)不一致必須的手段栅迄。

int++并不是一個(gè)原子操作，所以當(dāng)一個(gè)線程讀取它的值并加 1 時(shí)皆怕，另外一個(gè)線程 有可能會(huì)讀到之前的值毅舆，這就會(huì)引發(fā)錯(cuò)誤西篓。

為了解決這個(gè)問題，必須保證增加操作是原子的憋活，在 JDK1.5 之前我們可以使用同 步技術(shù)來做到這一點(diǎn)污淋。到 JDK1.5，java.util.concurrent.atomic 包提供了 int 和 long 類型的原子包裝類余掖，它們可以自動(dòng)的保證對于他們的操作是原子的并且不需 要使用同步寸爆。

java.util.concurrent 這個(gè)包里面提供了一組原子類。其基本的特性就是在多線程 環(huán)境下盐欺，當(dāng)有多個(gè)線程同時(shí)執(zhí)行這些類的實(shí)例包含的方法時(shí)赁豆，具有排他性，即某個(gè)線程進(jìn)入方法冗美，執(zhí)行其中的指令時(shí)魔种，不會(huì)被其他線程打斷，而別的線程就像 自旋鎖一樣粉洼，一直等到該方法執(zhí)行完成节预，才由 JVM 從等待隊(duì)列中選擇一個(gè)另一個(gè) 線程進(jìn)入，這只是一種邏輯上的理解属韧。

原子類：AtomicBoolean安拟，AtomicInteger，AtomicLong宵喂，AtomicReference 原子數(shù)組：AtomicIntegerArray糠赦，AtomicLongArray，AtomicReferenceArray 原子屬性更新器：AtomicLongFieldUpdater锅棕，AtomicIntegerFieldUpdater拙泽， AtomicReferenceFieldUpdater

解決 ABA 問題的原子類：AtomicMarkableReference（通過引入一個(gè) boolean 來反映中間有沒有變過），AtomicStampedReference（通過引入一個(gè) int 來累 加來反映中間有沒有變過）

11裸燎、Java Concurrency API 中的 Lock 接口(Lock interface) 是什么顾瞻？對比同步它有什么優(yōu)勢？

Lock 接口比同步方法和同步塊提供了更具擴(kuò)展性的鎖操作德绿。

他們允許更靈活的結(jié)構(gòu)荷荤，可以具有完全不同的性質(zhì)，并且可以支持多個(gè)相關(guān)類的條件對象脆炎。

它的優(yōu)勢有：

可以使鎖更公平

可以使線程在等待鎖的時(shí)候響應(yīng)中斷

可以讓線程嘗試獲取鎖梅猿，并在無法獲取鎖的時(shí)候立即返回或者等待一段時(shí)間

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

整體上來說 Lock 是 synchronized 的擴(kuò)展版秒裕，Lock 提供了無條件的袱蚓、可輪詢的 (tryLock 方法)、定時(shí)的(tryLock 帶參方法)几蜻、可中斷的(lockInterruptibly)喇潘、可多 條件隊(duì)列的(newCondition 方法)鎖操作体斩。另外 Lock 的實(shí)現(xiàn)類基本都支持非公平 鎖(默認(rèn))和公平鎖，synchronized 只支持非公平鎖颖低，當(dāng)然絮吵，在大部分情況下，非 公平鎖是高效的選擇忱屑。

12蹬敲、什么是 Executors 框架？

Executor 框架是一個(gè)根據(jù)一組執(zhí)行策略調(diào)用莺戒，調(diào)度伴嗡，執(zhí)行和控制的異步任務(wù)的框架。

無限制的創(chuàng)建線程會(huì)引起應(yīng)用程序內(nèi)存溢出从铲。所以創(chuàng)建一個(gè)線程池是個(gè)更好的的 解決方案瘪校，因?yàn)榭梢韵拗凭€程的數(shù)量并且可以回收再利用這些線程。利用 Executors 框架可以非常方便的創(chuàng)建一個(gè)線程池名段。

13阱扬、什么是阻塞隊(duì)列？阻塞隊(duì)列的實(shí)現(xiàn)原理是什么伸辟？如何使用 阻塞隊(duì)列來實(shí)現(xiàn)生產(chǎn)者-消費(fèi)者模型麻惶？

阻塞隊(duì)列（BlockingQueue）是一個(gè)支持兩個(gè)附加操作的隊(duì)列。

這兩個(gè)附加的操作是：在隊(duì)列為空時(shí)自娩，獲取元素的線程會(huì)等待隊(duì)列變?yōu)榉强沼貌取．?dāng) 隊(duì)列滿時(shí)，存儲(chǔ)元素的線程會(huì)等待隊(duì)列可用忙迁。

阻塞隊(duì)列常用于生產(chǎn)者和消費(fèi)者的場景，生產(chǎn)者是往隊(duì)列里添加元素的線程碎乃，消 費(fèi)者是從隊(duì)列里拿元素的線程姊扔。阻塞隊(duì)列就是生產(chǎn)者存放元素的容器，而消費(fèi)者 也只從容器里拿元素梅誓。

JDK7 提供了 7 個(gè)阻塞隊(duì)列分別是：

ArrayBlockingQueue ：一個(gè)由數(shù)組結(jié)構(gòu)組成的有界阻塞隊(duì)列恰梢。

LinkedBlockingQueue ：一個(gè)由鏈表結(jié)構(gòu)組成的有界阻塞隊(duì)列。

PriorityBlockingQueue ：一個(gè)支持優(yōu)先級排序的無界阻塞隊(duì)列梗掰。

DelayQueue：一個(gè)使用優(yōu)先級隊(duì)列實(shí)現(xiàn)的無界阻塞隊(duì)列嵌言。

SynchronousQueue：一個(gè)不存儲(chǔ)元素的阻塞隊(duì)列。

LinkedTransferQueue：一個(gè)由鏈表結(jié)構(gòu)組成的無界阻塞隊(duì)列及穗。

LinkedBlockingDeque：一個(gè)由鏈表結(jié)構(gòu)組成的雙向阻塞隊(duì)列摧茴。

Java 5 之前實(shí)現(xiàn)同步存取時(shí)，可以使用普通的一個(gè)集合埂陆，然后在使用線程的協(xié)作 和線程同步可以實(shí)現(xiàn)生產(chǎn)者苛白，消費(fèi)者模式娃豹，主要的技術(shù)就是用好， wait ,notify,notifyAll,sychronized 這些關(guān)鍵字购裙。而在 java 5 之后懂版，可以使用阻 塞隊(duì)列來實(shí)現(xiàn)，此方式大大簡少了代碼量躏率，使得多線程編程更加容易躯畴，安全方面也有保障。

BlockingQueue 接口是 Queue 的子接口薇芝，它的主要用途并不是作為容器蓬抄，而是 作為線程同步的的工具，因此他具有一個(gè)很明顯的特性恩掷，當(dāng)生產(chǎn)者線程試圖向 BlockingQueue 放入元素時(shí)倡鲸，如果隊(duì)列已滿，則線程被阻塞黄娘，當(dāng)消費(fèi)者線程試圖 從中取出一個(gè)元素時(shí)峭状，如果隊(duì)列為空，則該線程會(huì)被阻塞逼争，正是因?yàn)樗哂羞@ 個(gè)特性优床，所以在程序中多個(gè)線程交替向 BlockingQueue 中放入元素，取出元素誓焦， 它可以很好的控制線程之間的通信胆敞。

阻塞隊(duì)列使用最經(jīng)典的場景就是 socket 客戶端數(shù)據(jù)的讀取和解析，讀取數(shù)據(jù)的線 程不斷將數(shù)據(jù)放入隊(duì)列杂伟，然后解析線程不斷從隊(duì)列取數(shù)據(jù)解析移层。

14、什么是 Callable 和 Future?

Callable 接口類似于 Runnable赫粥，從名字就可以看出來了观话，但是 Runnable 不會(huì)返 回結(jié)果，并且無法拋出返回結(jié)果的異常越平，而 Callable 功能更強(qiáng)大一些频蛔，被線程行后，可以返回值秦叛，這個(gè)返回值可以被 Future 拿到晦溪，也就是說，F(xiàn)uture 可以拿到 異步執(zhí)行任務(wù)的返回值挣跋。

可以認(rèn)為是帶有回調(diào)的 Runnable三圆。

Future 接口表示異步任務(wù)，是還沒有完成的任務(wù)給出的未來結(jié)果。所以說 Callable 用于產(chǎn)生結(jié)果嫌术，F(xiàn)uture 用于獲取結(jié)果哀澈。

15、什么是 FutureTask?使用 ExecutorService 啟動(dòng)任務(wù)度气。

在 Java 并發(fā)程序中 FutureTask 表示一個(gè)可以取消的異步運(yùn)算割按。它有啟動(dòng)和取消 運(yùn)算、查詢運(yùn)算是否完成和取回運(yùn)算結(jié)果等方法磷籍。只有當(dāng)運(yùn)算完成的時(shí)候結(jié)果才 能取回适荣，如果運(yùn)算尚未完成 get 方法將會(huì)阻塞。一個(gè) FutureTask 對象可以對調(diào)用 了 Callable 和 Runnable 的對象進(jìn)行包裝院领，由于 FutureTask 也是調(diào)用了 Runnabl接口所以它可以提交給 Executor 來執(zhí)行弛矛。

16、什么是并發(fā)容器的實(shí)現(xiàn)比然？

何為同步容器：可以簡單地理解為通過 synchronized 來實(shí)現(xiàn)同步的容器丈氓，如果有 多個(gè)線程調(diào)用同步容器的方法，它們將會(huì)串行執(zhí)行强法。比如 Vector万俗，Hashtable， 以及 Collections.synchronizedSet饮怯，synchronizedList 等方法返回的容器闰歪。 可以通過查看 Vector，Hashtable 等這些同步容器的實(shí)現(xiàn)代碼蓖墅，可以看到這些容 器實(shí)現(xiàn)線程安全的方式就是將它們的狀態(tài)封裝起來库倘，并在需要同步的方法上加上 關(guān)鍵字 synchronized。

并發(fā)容器使用了與同步容器完全不同的加鎖策略來提供更高的并發(fā)性和伸縮性论矾， 例如在 ConcurrentHashMap 中采用了一種粒度更細(xì)的加鎖機(jī)制教翩，可以稱為分段 鎖，在這種鎖機(jī)制下贪壳，允許任意數(shù)量的讀線程并發(fā)地訪問 map迂曲，并且執(zhí)行讀操作 的線程和寫操作的線程也可以并發(fā)的訪問 map，同時(shí)允許一定數(shù)量的寫操作線程 并發(fā)地修改 map寥袭，所以它可以在并發(fā)環(huán)境下實(shí)現(xiàn)更高的吞吐量

17、多線程同步和互斥有幾種實(shí)現(xiàn)方法关霸，都是什么传黄？

線程同步是指線程之間所具有的一種制約關(guān)系，一個(gè)線程的執(zhí)行依賴另一個(gè)線程 的消息队寇，當(dāng)它沒有得到另一個(gè)線程的消息時(shí)應(yīng)等待膘掰，直到消息到達(dá)時(shí)才被喚醒。 線程互斥是指對于共享的進(jìn)程系統(tǒng)資源，在各單個(gè)線程訪問時(shí)的排它性识埋。當(dāng)有若 干個(gè)線程都要使用某一共享資源時(shí)凡伊，任何時(shí)刻最多只允許一個(gè)線程去使用，其它 要使用該資源的線程必須等待窒舟，直到占用資源者釋放該資源系忙。線程互斥可以看成 是一種特殊的線程同步。

線程間的同步方法大體可分為兩類：用戶模式和內(nèi)核模式惠豺。顧名思義银还，內(nèi)核模式 就是指利用系統(tǒng)內(nèi)核對象的單一性來進(jìn)行同步，使用時(shí)需要切換內(nèi)核態(tài)與用戶態(tài)洁墙， 而用戶模式就是不需要切換到內(nèi)核態(tài)蛹疯，只在用戶態(tài)完成操作热监。

用戶模式下的方法有：原子操作（例如一個(gè)單一的全局變量），臨界區(qū)列吼。內(nèi)核模 式下的方法有：事件，信號量冈欢，互斥量盈简。

18凑耻、什么是競爭條件柠贤？你怎樣發(fā)現(xiàn)和解決競爭臼勉？

當(dāng)多個(gè)進(jìn)程都企圖對共享數(shù)據(jù)進(jìn)行某種處理宴霸，而最后的結(jié)果又取決于進(jìn)程運(yùn)行的順序時(shí)瓢谢，則我們認(rèn)為這發(fā)生了競爭條件（race condition）氓扛。

19、你將如何使用 thread dump千所？你將如何分析 Thread dump淫痰？

新建狀態(tài)（New）

用 new 語句創(chuàng)建的線程處于新建狀態(tài)黑界，此時(shí)它和其他 Java 對象一樣管嬉，僅僅在堆區(qū) 中被分配了內(nèi)存蚯撩。

就緒狀態(tài)（Runnable）

當(dāng)一個(gè)線程對象創(chuàng)建后胎挎，其他線程調(diào)用它的 start()方法犹菇，該線程就進(jìn)入就緒狀態(tài)揭芍， Java 虛擬機(jī)會(huì)為它創(chuàng)建方法調(diào)用棧和程序計(jì)數(shù)器称杨。處于這個(gè)狀態(tài)的線程位于可運(yùn)行池中，等待獲得 CPU 的使用權(quán)锭汛。

運(yùn)行狀態(tài)（Running）

處于這個(gè)狀態(tài)的線程占用 CPU唤殴，執(zhí)行程序代碼眨八。只有處于就緒狀態(tài)的線程才有機(jī) 會(huì)轉(zhuǎn)到運(yùn)行狀態(tài)。

阻塞狀態(tài)（Blocked）

阻塞狀態(tài)是指線程因?yàn)槟承┰蚍艞?CPU篓足，暫時(shí)停止運(yùn)行连舍。當(dāng)線程處于阻塞狀態(tài) 時(shí)索赏，Java 虛擬機(jī)不會(huì)給線程分配 CPU潜腻。直到線程重新進(jìn)入就緒狀態(tài)融涣，它才有機(jī)會(huì) 轉(zhuǎn)到運(yùn)行狀態(tài)威鹿。

阻塞狀態(tài)可分為以下 3 種：

位于對象等待池中的阻塞狀態(tài)（Blocked in object’s wait pool）：

當(dāng)線程處于運(yùn)行狀態(tài)時(shí)，如果執(zhí)行了某個(gè)對象的 wait()方法科雳，Java 虛擬機(jī)就會(huì)把 線程放到這個(gè)對象的等待池中炸渡，這涉及到“線程通信”的內(nèi)容蚌堵。

位于對象鎖池中的阻塞狀態(tài)（Blocked in object’s lock pool）：

當(dāng)線程處于運(yùn)行狀態(tài)時(shí)，試圖獲得某個(gè)對象的同步鎖時(shí)泻蚊，如果該對象的同步鎖已 經(jīng)被其他線程占用性雄，Java 虛擬機(jī)就會(huì)把這個(gè)線程放到這個(gè)對象的鎖池中秒旋，這涉及 到“線程同步”的內(nèi)容迁筛。

其他阻塞狀態(tài)（Otherwise Blocked）：

當(dāng)前線程執(zhí)行了 sleep()方法尉桩，或者調(diào)用了其他線程的 join()方法蜘犁，或者發(fā)出了 I/O 請求時(shí)沽瘦，就會(huì)進(jìn)入這個(gè)狀態(tài)。

死亡狀態(tài)（Dead）

當(dāng)線程退出 run()方法時(shí)助隧，就進(jìn)入死亡狀態(tài)并村，該線程結(jié)束生命周期哩牍。 我們運(yùn)行之前的那個(gè)死鎖代碼 SimpleDeadLock.java，然后嘗試輸出信息

  1/* 時(shí)間荚孵，jvm 信息 */
  22017-11-01 17:36:28
  3Full thread dump Java HotSpot(TM) 64-Bit Server VM (25.144-b01 mixed
  4mode):
  5/* 線程名稱：DestroyJavaVM
  6編號：#13
  7優(yōu)先級：5
  8系統(tǒng)優(yōu)先級：0
  9jvm 內(nèi)部線程 id：0x0000000001c88800
 10對應(yīng)系統(tǒng)線程 id（NativeThread ID）：0x1c18
 11線程狀態(tài)： waiting on condition [0x0000000000000000] （等待某個(gè)條件）
 12線程詳細(xì)狀態(tài)：java.lang.Thread.State: RUNNABLE 及之后所有*/
 13"DestroyJavaVM" #13 prio=5 os_prio=0 tid=0x0000000001c88800
 14nid=0x1c18 waiting on condition [0x0000000000000000]
 15java.lang.Thread.State: RUNNABLE
 16"Thread-1" #12 prio=5 os_prio=0 tid=0x0000000018d49000
 17nid=0x17b8 waiting for monitor entry [0x0000000019d7f000]
 18/* 線程狀態(tài)：阻塞（在對象同步上）
 19代碼位置：at
 20com.leo.interview.SimpleDeadLock$B.run(SimpleDeadLock.java:56)
 21等待鎖：0x00000000d629b4d8
 22已經(jīng)獲得鎖：0x00000000d629b4e8*/
 23java.lang.Thread.State: BLOCKED (on object monitor)
 24at
 25com.leo.interview.SimpleDeadLock$B.run(SimpleDeadLock.java:56)
 26- waiting to lock <0x00000000d629b4d8> (a java.lang.Object)
 27- locked <0x00000000d629b4e8> (a java.lang.Object)
 28"Thread-0" #11 prio=5 os_prio=0 tid=0x0000000018d44000 nid=0x1ebc
 29waiting for monitor entry [0x000000001907f000]
 30java.lang.Thread.State: BLOCKED (on object monitor)
 31at
 32com.leo.interview.SimpleDeadLock$A.run(SimpleDeadLock.java:34)
 33- waiting to lock <0x00000000d629b4e8> (a java.lang.Object)
 34- locked <0x00000000d629b4d8> (a java.lang.Object)
 35"Service Thread" #10 daemon prio=9 os_prio=0
 36tid=0x0000000018ca5000 nid=0x1264 runnable [0x0000000000000000]
 37java.lang.Thread.State: RUNNABLE
 38"C1 CompilerThread2" #9 daemon prio=9 os_prio=2
 39tid=0x0000000018c46000 nid=0xb8c waiting on condition
 40[0x0000000000000000]
 41java.lang.Thread.State: RUNNABLE
 42"C2 CompilerThread1" #8 daemon prio=9 os_prio=2
 43tid=0x0000000018be4800 nid=0x1db4 waiting on condition
 44[0x0000000000000000]
 45java.lang.Thread.State: RUNNABLE
 46"C2 CompilerThread0" #7 daemon prio=9 os_prio=2
 47tid=0x0000000018be3800 nid=0x810 waiting on condition
 48[0x0000000000000000]
 49java.lang.Thread.State: RUNNABLE
 50"Monitor Ctrl-Break" #6 daemon prio=5 os_prio=0
 51tid=0x0000000018bcc800 nid=0x1c24 runnable [0x00000000193ce000]
 52java.lang.Thread.State: RUNNABLE
 53at java.net.SocketInputStream.socketRead0(Native Method)
 54at
 55java.net.SocketInputStream.socketRead(SocketInputStream.java:116)
 56at java.net.SocketInputStream.read(SocketInputStream.java:171)
 57at java.net.SocketInputStream.read(SocketInputStream.java:141)
 58at sun.nio.cs.StreamDecoder.readBytes(StreamDecoder.java:284)
 59at sun.nio.cs.StreamDecoder.implRead(StreamDecoder.java:326)
 60at sun.nio.cs.StreamDecoder.read(StreamDecoder.java:178)
 61- locked <0x00000000d632b928> (a java.io.InputStreamReader)
 62at java.io.InputStreamReader.read(InputStreamReader.java:184)
 63at java.io.BufferedReader.fill(BufferedReader.java:161)
 64at java.io.BufferedReader.readLine(BufferedReader.java:324)
 65- locked <0x00000000d632b928> (a java.io.InputStreamReader)
 66at java.io.BufferedReader.readLine(BufferedReader.java:389)
 67at
 68com.intellij.rt.execution.application.AppMainV2$1.run(AppMainV2.java:6
 694)
 70"Attach Listener" #5 daemon prio=5 os_prio=2
 71tid=0x0000000017781800 nid=0x524 runnable [0x0000000000000000]
 72java.lang.Thread.State: RUNNABLE
 73"Signal Dispatcher" #4 daemon prio=9 os_prio=2
 74tid=0x000000001778f800 nid=0x1b08 waiting on condition
 75[0x0000000000000000]
 76java.lang.Thread.State: RUNNABLE
 77"Finalizer" #3 daemon prio=8 os_prio=1 tid=0x000000001776a800
 78nid=0xdac in Object.wait() [0x0000000018b6f000]
 79java.lang.Thread.State: WAITING (on object monitor)
 80at java.lang.Object.wait(Native Method)
 81- waiting on <0x00000000d6108ec8> (a
 82java.lang.ref.ReferenceQueue$Lock)
 83at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:143)
 84- locked <0x00000000d6108ec8> (a
 85java.lang.ref.ReferenceQueue$Lock)
 86at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:164)
 87at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:209)
 88"Reference Handler" #2 daemon prio=10 os_prio=2
 89tid=0x0000000017723800 nid=0x1670 in Object.wait()
 90[0x00000000189ef000]
 91java.lang.Thread.State: WAITING (on object monitor)
 92at java.lang.Object.wait(Native Method)
 93- waiting on <0x00000000d6106b68> (a
 94java.lang.ref.Reference$Lock)
 95at java.lang.Object.wait(Object.java:502)
 96at java.lang.ref.Reference.tryHandlePending(Reference.java:191)
 97- locked <0x00000000d6106b68> (a java.lang.ref.Reference$Lock)
 98at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:153)
 99"VM Thread" os_prio=2 tid=0x000000001771b800 nid=0x604 runnable
100"GC task thread#0 (ParallelGC)" os_prio=0 tid=0x0000000001c9d800
101nid=0x9f0 runnable
102"GC task thread#1 (ParallelGC)" os_prio=0 tid=0x0000000001c9f000
103nid=0x154c runnable
104"GC task thread#2 (ParallelGC)" os_prio=0 tid=0x0000000001ca0800
105nid=0xcd0 runnable
106"GC task thread#3 (ParallelGC)" os_prio=0 tid=0x0000000001ca2000
107nid=0x1e58 runnable
108"VM Periodic Task Thread" os_prio=2 tid=0x0000000018c5a000
109nid=0x1b58 waiting on condition
110JNI global references: 33
111/* 此處可以看待死鎖的相關(guān)信息判没！ */
112Found one Java-level deadlock:
113=============================
114"Thread-1":
115waiting to lock monitor 0x0000000017729fc8 (object
1160x00000000d629b4d8, a java.lang.Object),
117which is held by "Thread-0"
118"Thread-0":
119waiting to lock monitor 0x0000000017727738 (object
1200x00000000d629b4e8, a java.lang.Object),
121which is held by "Thread-1"
122Java stack information for the threads listed above:
123==============================================
124=====
125"Thread-1":
126at
127com.leo.interview.SimpleDeadLock$B.run(SimpleDeadLock.java:56)
128- waiting to lock <0x00000000d629b4d8> (a java.lang.Object)
129- locked <0x00000000d629b4e8> (a java.lang.Object)
130"Thread-0":
131at
132com.leo.interview.SimpleDeadLock$A.run(SimpleDeadLock.java:34)
133- waiting to lock <0x00000000d629b4e8> (a java.lang.Object)
134- locked <0x00000000d629b4d8> (a java.lang.Object)
135Found 1 deadlock.
136/* 內(nèi)存使用狀況绕德，詳情得看 JVM 方面的書 */
137Heap
138PSYoungGen total 37888K, used 4590K [0x00000000d6100000,
1390x00000000d8b00000, 0x0000000100000000)
140eden space 32768K, 14% used
141[0x00000000d6100000,0x00000000d657b968,0x00000000d8100000)
142from space 5120K, 0% used
143[0x00000000d8600000,0x00000000d8600000,0x00000000d8b00000)
144to space 5120K, 0% used
145[0x00000000d8100000,0x00000000d8100000,0x00000000d8600000)
146ParOldGen total 86016K, used 0K [0x0000000082200000,
1470x0000000087600000, 0x00000000d6100000)
148object space 86016K, 0% used
149[0x0000000082200000,0x0000000082200000,0x0000000087600000)
150Metaspace used 3474K, capacity 4500K, committed 4864K,
151reserved 1056768K
152class space used 382K, capacity 388K, committed 512K, reserved
1531048576K

20、為什么我們調(diào)用 start()方法時(shí)會(huì)執(zhí)行 run()方法，為什么 我們不能直接調(diào)用 run()方法漱牵？

當(dāng)你調(diào)用 start()方法時(shí)你將創(chuàng)建新的線程酣胀，并且執(zhí)行在 run()方法里的代碼闻镶。 但是如果你直接調(diào)用 run()方法铆农，它不會(huì)創(chuàng)建新的線程也不會(huì)執(zhí)行調(diào)用線程的代碼， 只會(huì)把 run 方法當(dāng)作普通方法去執(zhí)行岭皂。

21爷绘、Java 中你怎樣喚醒一個(gè)阻塞的線程？

在 Java 發(fā)展史上曾經(jīng)使用 suspend()毙籽、resume()方法對于線程進(jìn)行阻塞喚醒坑赡，但 隨之出現(xiàn)很多問題毅否，比較典型的還是死鎖問題徘溢。

解決方案可以使用以對象為目標(biāo)的阻塞然爆，即利用 Object 類的 wait()和 notify()方 法實(shí)現(xiàn)線程阻塞曾雕。

首先剖张，wait、notify 方法是針對對象的肯污，調(diào)用任意對象的 wait()方法都將導(dǎo)致線程 阻塞恐锦，阻塞的同時(shí)也將釋放該對象的鎖揭北，相應(yīng)地锄奢，調(diào)用任意對象的 notify()方法將隨機(jī)解除該對象阻塞的線程，但它需要重新獲取改對象的鎖灰伟，直到獲取成功能往下執(zhí)行栏账；其次竖般，wait涣雕、notify 方法必須在 synchronized 塊或方法中被調(diào)用胞谭， 并且要保證同步塊或方法的鎖對象與調(diào)用 wait调俘、notify 方法的對象是同一個(gè)彩库，此一來在調(diào)用 wait 之前當(dāng)前線程就已經(jīng)成功獲取某對象的鎖宛渐，執(zhí)行 wait 阻塞后當(dāng) 前線程就將之前獲取的對象鎖釋放窥翩。

22寇蚊、在 Java 中 CycliBarriar 和 CountdownLatch 有什么區(qū)別？

CyclicBarrier 可以重復(fù)使用扒怖，而 CountdownLatch 不能重復(fù)使用。

Java 的 concurrent 包里面的 CountDownLatch 其實(shí)可以把它看作一個(gè)計(jì)數(shù)器积糯， 只不過這個(gè)計(jì)數(shù)器的操作是原子操作看成，同時(shí)只能有一個(gè)線程去操作這個(gè)計(jì)數(shù)器吃嘿， 也就是同時(shí)只能有一個(gè)線程去減這個(gè)計(jì)數(shù)器里面的值兑燥。

你可以向 CountDownLatch 對象設(shè)置一個(gè)初始的數(shù)字作為計(jì)數(shù)值，任何調(diào)用這個(gè) 對象上的 await()方法都會(huì)阻塞挣饥，直到這個(gè)計(jì)數(shù)器的計(jì)數(shù)值被其他的線程減為 0 為 止。

所以在當(dāng)前計(jì)數(shù)到達(dá)零之前短荐，await 方法會(huì)一直受阻塞忍宋。之后，會(huì)釋放所有等待 的線程乳讥，await 的所有后續(xù)調(diào)用都將立即返回。這種現(xiàn)象只出現(xiàn)一次——計(jì)數(shù)無法 被重置汹忠。如果需要重置計(jì)數(shù)宽菜，請考慮使用 CyclicBarrier继谚。

CountDownLatch 的一個(gè)非常典型的應(yīng)用場景是：有一個(gè)任務(wù)想要往下執(zhí)行，但 必須要等到其他的任務(wù)執(zhí)行完畢后才可以繼續(xù)往下執(zhí)行诡壁。假如我們這個(gè)想要繼續(xù) 往下執(zhí)行的任務(wù)調(diào)用一個(gè) CountDownLatch 對象的 await()方法，其他的任務(wù)行完自己的任務(wù)后調(diào)用同一個(gè) CountDownLatch 對象上的 countDown()方法纽帖， 這個(gè)調(diào)用 await()方法的任務(wù)將一直阻塞等待扒吁，直到這個(gè) CountDownLatch 對象 的計(jì)數(shù)值減到 0 為止雕崩。

CyclicBarrier 一個(gè)同步輔助類粗蔚，它允許一組線程互相等待鹏控，直到到達(dá)某個(gè)公共屏 障點(diǎn) (common barrier point)。在涉及一組固定大小的線程的程序中缘揪，這些線程 必須不時(shí)地互相等待蹈垢，此時(shí) CyclicBarrier 很有用曹抬。因?yàn)樵?barrier 在釋放等待 線程后可以重用，所以稱它為循環(huán) 的 barrier赖临。

23、什么是不可變對象，它對寫并發(fā)應(yīng)用有什么幫助吟逝？

不可變對象(Immutable Objects)即對象一旦被創(chuàng)建它的狀態(tài)（對象的數(shù)據(jù)块攒，也即 對象屬性值）就不能改變，反之即為可變對象(Mutable Objects)佃乘。

不可變對象的類即為不可變類(Immutable Class)囱井。Java 平臺(tái)類庫中包含許多不可 變類，如 String趣避、基本類型的包裝類、BigInteger 和 BigDecimal 等程帕。

不可變對象天生是線程安全的住练。它們的常量（域）是在構(gòu)造函數(shù)中創(chuàng)建的。既然 它們的狀態(tài)無法修改愁拭，這些常量永遠(yuǎn)不會(huì)變澎羞。

不可變對象永遠(yuǎn)是線程安全的。

只有滿足如下狀態(tài)敛苇，一個(gè)對象才是不可變的妆绞；

它的狀態(tài)不能在創(chuàng)建后再被修改顺呕；

所有域都是 final 類型；并且括饶，

它被正確創(chuàng)建（創(chuàng)建期間沒有發(fā)生 this 引用的逸出）株茶。

24、什么是多線程中的上下文切換图焰？

在上下文切換過程中启盛，CPU 會(huì)停止處理當(dāng)前運(yùn)行的程序，并保存當(dāng)前程序運(yùn)行的 具體位置以便之后繼續(xù)運(yùn)行技羔。從這個(gè)角度來看僵闯，上下文切換有點(diǎn)像我們同時(shí)閱讀 幾本書，在來回切換書本的同時(shí)我們需要記住每本書當(dāng)前讀到的頁碼藤滥。在程序中鳖粟， 上下文切換過程中的“頁碼”信息是保存在進(jìn)程控制塊（PCB）中的。PCB 還經(jīng) 常被稱作“切換楨”（switchframe）拙绊∠蛲迹“頁碼”信息會(huì)一直保存到 CPU 的內(nèi)存 中，直到他們被再次使用标沪。

上下文切換是存儲(chǔ)和恢復(fù) CPU 狀態(tài)的過程榄攀，它使得線程執(zhí)行能夠從中斷點(diǎn)恢復(fù)執(zhí) 行。上下文切換是多任務(wù)操作系統(tǒng)和多線程環(huán)境的基本特征金句。

25檩赢、Java 中用到的線程調(diào)度算法是什么？

計(jì)算機(jī)通常只有一個(gè) CPU,在任意時(shí)刻只能執(zhí)行一條機(jī)器指令,每個(gè)線程只有獲得 CPU 的使用權(quán)才能執(zhí)行指令.所謂多線程的并發(fā)運(yùn)行,其實(shí)是指從宏觀上看,各個(gè)線 程輪流獲得 CPU 的使用權(quán),分別執(zhí)行各自的任務(wù).在運(yùn)行池中,會(huì)有多個(gè)處于就緒狀 態(tài)的線程在等待 CPU,JAVA 虛擬機(jī)的一項(xiàng)任務(wù)就是負(fù)責(zé)線程的調(diào)度,線程調(diào)度是指 按照特定機(jī)制為多個(gè)線程分配 CPU 的使用權(quán).

有兩種調(diào)度模型：分時(shí)調(diào)度模型和搶占式調(diào)度模型

分時(shí)調(diào)度模型是指讓所有的線程輪流獲得 cpu 的使用權(quán),并且平均分配每個(gè)線程占 用的 CPU 的時(shí)間片這個(gè)也比較好理解违寞。

java 虛擬機(jī)采用搶占式調(diào)度模型漠畜，是指優(yōu)先讓可運(yùn)行池中優(yōu)先級高的線程占用 CPU，如果可運(yùn)行池中的線程優(yōu)先級相同坞靶，那么就隨機(jī)選擇一個(gè)線程，使其占用 CPU蝴悉。處于運(yùn)行狀態(tài)的線程會(huì)一直運(yùn)行彰阴，直至它不得不放棄 CPU。

26拍冠、什么是線程組尿这，為什么在 Java 中不推薦使用？

線程組和線程池是兩個(gè)不同的概念庆杜，他們的作用完全不同射众，前者是為了方便線程 的管理，后者是為了管理線程的生命周期晃财，復(fù)用線程叨橱，減少創(chuàng)建銷毀線程的開銷。

27、為什么使用 Executor 框架比使用應(yīng)用創(chuàng)建和管理線程好罗洗？

為什么要使用 Executor 線程池框架

1愉舔、每次執(zhí)行任務(wù)創(chuàng)建線程 new Thread()比較消耗性能，創(chuàng)建一個(gè)線程是比較耗 時(shí)伙菜、耗資源的轩缤。

2、調(diào)用 new Thread()創(chuàng)建的線程缺乏管理贩绕，被稱為野線程火的，而且可以無限制的 創(chuàng)建，線程之間的相互競爭會(huì)導(dǎo)致過多占用系統(tǒng)資源而導(dǎo)致系統(tǒng)癱瘓淑倾，還有線程 之間的頻繁交替也會(huì)消耗很多系統(tǒng)資源馏鹤。

3、直接使用 new Thread() 啟動(dòng)的線程不利于擴(kuò)展踊淳，比如定時(shí)執(zhí)行假瞬、定期執(zhí)行、 定時(shí)定期執(zhí)行迂尝、線程中斷等都不便實(shí)現(xiàn)脱茉。

使用 Executor 線程池框架的優(yōu)點(diǎn)

1、能復(fù)用已存在并空閑的線程從而減少線程對象的創(chuàng)建從而減少了消亡線程的開 銷垄开。

2琴许、可有效控制最大并發(fā)線程數(shù)，提高系統(tǒng)資源使用率溉躲，同時(shí)避免過多資源競爭榜田。

3、框架中已經(jīng)有定時(shí)锻梳、定期箭券、單線程、并發(fā)數(shù)控制等功能疑枯。 綜上所述使用線程池框架 Executor 能更好的管理線程辩块、提供系統(tǒng)資源使用率。

28荆永、java 中有幾種方法可以實(shí)現(xiàn)一個(gè)線程废亭？

繼承 Thread 類

實(shí)現(xiàn) Runnable 接口

實(shí)現(xiàn) Callable 接口，需要實(shí)現(xiàn)的是 call() 方法

29具钥、如何停止一個(gè)正在運(yùn)行的線程豆村？

使用共享變量的方式

在這種方式中，之所以引入共享變量骂删，是因?yàn)樵撟兞靠梢员欢鄠€(gè)執(zhí)行相同任務(wù)的 線程用來作為是否中斷的信號掌动，通知中斷線程的執(zhí)行四啰。

使用 interrupt 方法終止線程

如果一個(gè)線程由于等待某些事件的發(fā)生而被阻塞，又該怎樣停止該線程呢坏匪？這種 情況經(jīng)常會(huì)發(fā)生拟逮，比如當(dāng)一個(gè)線程由于需要等候鍵盤輸入而被阻塞，或者調(diào)用 Thread.join()方法适滓，或者 Thread.sleep()方法敦迄，在網(wǎng)絡(luò)中調(diào)用

ServerSocket.accept()方法，或者調(diào)用了 DatagramSocket.receive()方法時(shí)凭迹，有可能導(dǎo)致線程阻塞罚屋，使線程處于處于不可運(yùn)行狀態(tài)時(shí)，即使主程序中將該線程 的共享變量設(shè)置為 true嗅绸，但該線程此時(shí)根本無法檢查循環(huán)標(biāo)志脾猛，當(dāng)然也就無法立 即中斷。這里我們給出的建議是鱼鸠，不要使用 stop()方法猛拴，而是使用 Thread 提供的 interrupt()方法，因?yàn)樵摲椒m然不會(huì)中斷一個(gè)正在運(yùn)行的線程蚀狰，但是它可以使一 個(gè)被阻塞的線程拋出一個(gè)中斷異常愉昆，從而使線程提前結(jié)束阻塞狀態(tài)，退出堵塞代碼麻蹋。

30跛溉、notify()和 notifyAll()有什么區(qū)別？

當(dāng)一個(gè)線程進(jìn)入 wait 之后扮授，就必須等其他線程 notify/notifyall,使用 notifyall,可 以喚醒所有處于 wait 狀態(tài)的線程芳室，使其重新進(jìn)入鎖的爭奪隊(duì)列中，而 notify 只能喚醒一個(gè)刹勃。

如果沒把握堪侯，建議 notifyAll，防止 notigy 因?yàn)樾盘杹G失而造成程序異常荔仁。

31伍宦、什么是 Daemon 線程？它有什么意義咕晋？

所謂后臺(tái)(daemon)線程，是指在程序運(yùn)行的時(shí)候在后臺(tái)提供一種通用服務(wù)的線 程收奔，并且這個(gè)線程并不屬于程序中不可或缺的部分掌呜。因此，當(dāng)所有的非后臺(tái)線程 結(jié)束時(shí)坪哄，程序也就終止了质蕉，同時(shí)會(huì)殺死進(jìn)程中的所有后臺(tái)線程势篡。反過來說， 只要有任何非后臺(tái)線程還在運(yùn)行模暗，程序就不會(huì)終止禁悠。必須在線程啟動(dòng)之前調(diào)用 setDaemon()方法，才能把它設(shè)置為后臺(tái)線程兑宇。注意：后臺(tái)進(jìn)程在不執(zhí)行 finally 子句的情況下就會(huì)終止其 run()方法碍侦。

比如：JVM 的垃圾回收線程就是 Daemon 線程，F(xiàn)inalizer 也是守護(hù)線程隶糕。

32瓷产、java 如何實(shí)現(xiàn)多線程之間的通訊和協(xié)作？

中斷 和 共享變量

33枚驻、什么是可重入鎖（ReentrantLock）濒旦？

舉例來說明鎖的可重入性

 1public class UnReentrant{
 2Lock lock = new Lock();
 3public void outer(){
 4lock.lock();
 5inner();
 6lock.unlock();
 7}
 8public void inner(){
 9lock.lock();
10//do something
11lock.unlock();
12}
13}

outer 中調(diào)用了 inner，outer 先鎖住了 lock再登，這樣 inner 就不能再獲取 lock尔邓。其 實(shí)調(diào)用 outer 的線程已經(jīng)獲取了 lock 鎖，但是不能在 inner 中重復(fù)利用已經(jīng)獲取 的鎖資源锉矢，這種鎖即稱之為 不可重入可重入就意味著：線程可以進(jìn)入任何一個(gè)它 已經(jīng)擁有的鎖所同步著的代碼塊梯嗽。

synchronized、ReentrantLock 都是可重入的鎖沈撞，可重入鎖相對來說簡化了并發(fā) 編程的開發(fā)慷荔。

34、當(dāng)一個(gè)線程進(jìn)入某個(gè)對象的一個(gè) synchronized 的實(shí)例方 法后缠俺，其它線程是否可進(jìn)入此對象的其它方法显晶？

如果其他方法沒有 synchronized 的話，其他線程是可以進(jìn)入的壹士。

所以要開放一個(gè)線程安全的對象時(shí)磷雇，得保證每個(gè)方法都是線程安全的。

35躏救、樂觀鎖和悲觀鎖的理解及如何實(shí)現(xiàn)唯笙，有哪些實(shí)現(xiàn)方式？

悲觀鎖：總是假設(shè)最壞的情況盒使，每次去拿數(shù)據(jù)的時(shí)候都認(rèn)為別人會(huì)修改崩掘，所以每 次在拿數(shù)據(jù)的時(shí)候都會(huì)上鎖，這樣別人想拿這個(gè)數(shù)據(jù)就會(huì)阻塞直到它拿到鎖少办。傳 統(tǒng)的關(guān)系型數(shù)據(jù)庫里邊就用到了很多這種鎖機(jī)制苞慢，比如行鎖，表鎖等英妓，讀鎖挽放，寫 鎖等绍赛，都是在做操作之前先上鎖。再比如 Java 里面的同步原語 synchronized 關(guān) 鍵字的實(shí)現(xiàn)也是悲觀鎖辑畦。

樂觀鎖：顧名思義吗蚌，就是很樂觀，每次去拿數(shù)據(jù)的時(shí)候都認(rèn)為別人不會(huì)修改纯出，所 以不會(huì)上鎖蚯妇，但是在更新的時(shí)候會(huì)判斷一下在此期間別人有沒有去更新這個(gè)數(shù)據(jù)， 可以使用版本號等機(jī)制潦刃。樂觀鎖適用于多讀的應(yīng)用類型侮措，這樣可以提高吞吐量， 像數(shù)據(jù)庫提供的類似于 write_condition 機(jī)制乖杠，其實(shí)都是提供的樂觀鎖分扎。在 Java 中 java.util.concurrent.atomic 包下面的原子變量類就是使用了樂觀鎖的一種實(shí) 現(xiàn)方式 CAS 實(shí)現(xiàn)的。

樂觀鎖的實(shí)現(xiàn)方式：

1胧洒、使用版本標(biāo)識(shí)來確定讀到的數(shù)據(jù)與提交時(shí)的數(shù)據(jù)是否一致畏吓。提交后修改版本標(biāo) 識(shí)，不一致時(shí)可以采取丟棄和再次嘗試的策略卫漫。

2菲饼、java 中的 Compare and Swap 即 CAS ，當(dāng)多個(gè)線程嘗試使用 CAS 同時(shí)更新 同一個(gè)變量時(shí)列赎，只有其中一個(gè)線程能更新變量的值宏悦，而其它線程都失敗，失敗的 線程并不會(huì)被掛起包吝，而是被告知這次競爭中失敗饼煞，并可以再次嘗試。 CAS 操作 中包含三個(gè)操作數(shù) —— 需要讀寫的內(nèi)存位置（V）诗越、進(jìn)行比較的預(yù)期原值（A） 和擬寫入的新值(B)砖瞧。如果內(nèi)存位置 V 的值與預(yù)期原值 A 相匹配，那么處理器會(huì)自 動(dòng)將該位置值更新為新值 B嚷狞。否則處理器不做任何操作块促。

CAS 缺點(diǎn)：

1、ABA 問題：

比如說一個(gè)線程 one 從內(nèi)存位置 V 中取出 A床未，這時(shí)候另一個(gè)線程 two 也從內(nèi)存中 取出 A竭翠，并且 two 進(jìn)行了一些操作變成了 B，然后 two 又將 V 位置的數(shù)據(jù)變成 A薇搁， 這時(shí)候線程 one 進(jìn)行 CAS 操作發(fā)現(xiàn)內(nèi)存中仍然是 A斋扰，然后 one 操作成功。盡管線 程 one 的 CAS 操作成功，但可能存在潛藏的問題褥实。從 Java1.5 開始 JDK 的 atomic 包里提供了一個(gè)類 AtomicStampedReference 來解決 ABA 問題。

2裂允、循環(huán)時(shí)間長開銷大：

對于資源競爭嚴(yán)重（線程沖突嚴(yán)重）的情況损离，CAS 自旋的概率會(huì)比較大，從而浪 費(fèi)更多的 CPU 資源绝编，效率低于 synchronized僻澎。

3、只能保證一個(gè)共享變量的原子操作：

當(dāng)對一個(gè)共享變量執(zhí)行操作時(shí)十饥，我們可以使用循環(huán) CAS 的方式來保證原子操作窟勃， 但是對多個(gè)共享變量操作時(shí)，循環(huán) CAS 就無法保證操作的原子性逗堵，這個(gè)時(shí)候就可以用鎖秉氧。

36、SynchronizedMap 和 ConcurrentHashMap 有什么區(qū)別蜒秤？

SynchronizedMap 一次鎖住整張表來保證線程安全汁咏，所以每次只能有一個(gè)線程來 訪為 map。

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

ConcurrentHashMap 中則是一次鎖住一個(gè)桶攘滩。ConcurrentHashMap 默認(rèn)將 hash 表分為 16 個(gè)桶，諸如 get,put,remove 等常用操作只鎖當(dāng)前需要用到的桶纸泡。 這樣漂问，原來只能一個(gè)線程進(jìn)入，現(xiàn)在卻能同時(shí)有 16 個(gè)寫線程執(zhí)行女揭，并發(fā)性能的提 升是顯而易見的蚤假。

另外 ConcurrentHashMap 使用了一種不同的迭代方式。在這種迭代方式中田绑，當(dāng) iterator 被創(chuàng)建后集合再發(fā)生改變就不再是拋出

ConcurrentModificationException勤哗，取而代之的是在改變時(shí) new 新的數(shù)據(jù)從而 不影響原有的數(shù)據(jù) ，iterator 完成后再將頭指針替換為新的數(shù)據(jù) 掩驱，這樣 iterator 線程可以使用原來老的數(shù)據(jù)芒划，而寫線程也可以并發(fā)的完成改變。

37欧穴、CopyOnWriteArrayList 可以用于什么應(yīng)用場景民逼？

CopyOnWriteArrayList(免鎖容器)的好處之一是當(dāng)多個(gè)迭代器同時(shí)遍歷和修改這 個(gè)列表時(shí)，不會(huì)拋出 ConcurrentModificationException涮帘。在 CopyOnWriteArrayList 中拼苍，寫入將導(dǎo)致創(chuàng)建整個(gè)底層數(shù)組的副本，而源數(shù)組將保 留在原地，使得復(fù)制的數(shù)組在被修改時(shí)疮鲫，讀取操作可以安全地執(zhí)行

1吆你、由于寫操作的時(shí)候，需要拷貝數(shù)組俊犯，會(huì)消耗內(nèi)存妇多，如果原數(shù)組的內(nèi)容比較多的 情況下，可能導(dǎo)致 young gc 或者 full gc燕侠；

2者祖、不能用于實(shí)時(shí)讀的場景，像拷貝數(shù)組绢彤、新增元素都需要時(shí)間七问，所以調(diào)用一個(gè) set 操作后，讀取到數(shù)據(jù)可能還是舊的,雖然 CopyOnWriteArrayList 能做到最終一致 性,但是還是沒法滿足實(shí)時(shí)性要求茫舶；

CopyOnWriteArrayList 透露的思想

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

2饶氏、最終一致性

3坟比、使用另外開辟空間的思路，來解決并發(fā)沖突

38嚷往、什么叫線程安全葛账？servlet 是線程安全嗎?

線程安全是編程中的術(shù)語，指某個(gè)函數(shù)皮仁、函數(shù)庫在多線程環(huán)境中被調(diào)用時(shí)籍琳，能夠 正確地處理多個(gè)線程之間的共享變量，使程序功能正確完成贷祈。

Servlet 不是線程安全的趋急，servlet 是單實(shí)例多線程的，當(dāng)多個(gè)線程同時(shí)訪問同一個(gè) 方法势誊，是不能保證共享變量的線程安全性的呜达。

Struts2 的 action 是多實(shí)例多線程的，是線程安全的粟耻，每個(gè)請求過來都會(huì) new 一 個(gè)新的 action 分配給這個(gè)請求查近，請求完成后銷毀。

SpringMVC 的 Controller 是線程安全的嗎挤忙？不是的霜威，和 Servlet 類似的處理流程。

Struts2 好處是不用考慮線程安全問題册烈；Servlet 和 SpringMVC 需要考慮線程全問題戈泼，但是性能可以提升不用處理太多的 gc，可以使用 ThreadLocal 來處理多 線程的問題。

39大猛、volatile 有什么用扭倾？能否用一句話說明下 volatile 的應(yīng)用 場景？

volatile 保證內(nèi)存可見性和禁止指令重排挽绩。

volatile 用于多線程環(huán)境下的單次操作(單次讀或者單次寫)吆录。

40、為什么代碼會(huì)重排序琼牧？

在執(zhí)行程序時(shí)，為了提供性能哀卫，處理器和編譯器常常會(huì)對指令進(jìn)行重排序巨坊，但是 不能隨意重排序，不是你想怎么排序就怎么排序此改，它需要滿足以下兩個(gè)條件：

在單線程環(huán)境下不能改變程序運(yùn)行的結(jié)果趾撵；

存在數(shù)據(jù)依賴關(guān)系的不允許重排序

需要注意的是：重排序不會(huì)影響單線程環(huán)境的執(zhí)行結(jié)果，但是會(huì)破壞多線程的行語義共啃。

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

最大的不同是在等待時(shí) wait 會(huì)釋放鎖移剪，而 sleep 一直持有鎖究珊。Wait 通常被用于線 程間交互，sleep 通常被用于暫停執(zhí)行纵苛。

直接了解的深入一點(diǎn)吧：

在 Java 中線程的狀態(tài)一共被分成 6 種：

初始態(tài)：NEW

創(chuàng)建一個(gè) Thread 對象剿涮，但還未調(diào)用 start()啟動(dòng)線程時(shí)，線程處于初始態(tài)攻人。

運(yùn)行態(tài)：RUNNABLE

在 Java 中取试，運(yùn)行態(tài)包括就緒態(tài) 和 運(yùn)行態(tài)。

就緒態(tài) 該狀態(tài)下的線程已經(jīng)獲得執(zhí)行所需的所有資源怀吻，只要 CPU 分配執(zhí)行權(quán)就 能運(yùn)行瞬浓。所有就緒態(tài)的線程存放在就緒隊(duì)列中。

運(yùn)行態(tài) 獲得 CPU 執(zhí)行權(quán)蓬坡，正在執(zhí)行的線程猿棉。由于一個(gè) CPU 同一時(shí)刻只能執(zhí)行一 條線程，因此每個(gè) CPU 每個(gè)時(shí)刻只有一條運(yùn)行態(tài)的線程屑咳。

阻塞態(tài)

當(dāng)一條正在執(zhí)行的線程請求某一資源失敗時(shí)铺根，就會(huì)進(jìn)入阻塞態(tài)。而在 Java 中乔宿，阻 塞態(tài)專指請求鎖失敗時(shí)進(jìn)入的狀態(tài)位迂。由一個(gè)阻塞隊(duì)列存放所有阻塞態(tài)的線程。處 于阻塞態(tài)的線程會(huì)不斷請求資源，一旦請求成功掂林，就會(huì)進(jìn)入就緒隊(duì)列臣缀，等待執(zhí)行。 PS：鎖泻帮、IO精置、Socket 等都資源。

等待態(tài)

當(dāng)前線程中調(diào)用 wait锣杂、join脂倦、park 函數(shù)時(shí)，當(dāng)前線程就會(huì)進(jìn)入等待態(tài)元莫。也有一個(gè) 等待隊(duì)列存放所有等待態(tài)的線程赖阻。線程處于等待態(tài)表示它需要等待其他線程的指 示才能繼續(xù)運(yùn)行。進(jìn)入等待態(tài)的線程會(huì)釋放 CPU 執(zhí)行權(quán)踱蠢，并釋放資源（如：鎖）

超時(shí)等待態(tài)

當(dāng)運(yùn)行中的線程調(diào)用 sleep(time)火欧、wait、join茎截、parkNanos苇侵、parkUntil 時(shí)，就 會(huì)進(jìn)入該狀態(tài)企锌；它和等待態(tài)一樣榆浓，并不是因?yàn)檎埱蟛坏劫Y源，而是主動(dòng)進(jìn)入撕攒，并 且進(jìn)入后需要其他線程喚醒哀军；進(jìn)入該狀態(tài)后釋放 CPU 執(zhí)行權(quán) 和 占有的資源。等待態(tài)的區(qū)別：到了超時(shí)時(shí)間后自動(dòng)進(jìn)入阻塞隊(duì)列打却，開始競爭鎖杉适。

終止態(tài)

線程執(zhí)行結(jié)束后的狀態(tài)。

注意：

wait()方法會(huì)釋放 CPU 執(zhí)行權(quán) 和 占有的鎖柳击。

sleep(long)方法僅釋放 CPU 使用權(quán)猿推，鎖仍然占用；線程被放入超時(shí)等待隊(duì)列捌肴，與 yield 相比蹬叭，它會(huì)使線程較長時(shí)間得不到運(yùn)行。

yield()方法僅釋放 CPU 執(zhí)行權(quán)状知，鎖仍然占用秽五，線程會(huì)被放入就緒隊(duì)列，會(huì)在短時(shí) 間內(nèi)再次執(zhí)行饥悴。

wait 和 notify 必須配套使用坦喘，即必須使用同一把鎖調(diào)用盲再；

wait 和 notify 必須放在一個(gè)同步塊中調(diào)用 wait 和 notify 的對象必須是他們所處 同步塊的鎖對象。

42瓣铣、用 Java 實(shí)現(xiàn)阻塞隊(duì)列

參考 java 中的阻塞隊(duì)列的內(nèi)容吧答朋，直接實(shí)現(xiàn)有點(diǎn)煩： http://www.infoq.com/cn/articles/java-blocking-queue

43、一個(gè)線程運(yùn)行時(shí)發(fā)生異常會(huì)怎樣棠笑？

如果異常沒有被捕獲該線程將會(huì)停止執(zhí)行梦碗。Thread.UncaughtExceptionHandler 是用于處理未捕獲異常造成線程突然中斷情況的一個(gè)內(nèi)嵌接口。當(dāng)一個(gè)未捕獲異 常將造成線程中斷的時(shí)候 JVM 會(huì)使用 Thread.getUncaughtExceptionHandler() 來查詢線程的 UncaughtExceptionHandler 并將線程和異常作為參數(shù)傳遞給 handler 的 uncaughtException()方法進(jìn)行處理蓖救。

44牢贸、如何在兩個(gè)線程間共享數(shù)據(jù)靶草？

在兩個(gè)線程間共享變量即可實(shí)現(xiàn)共享兴想。

一般來說叮喳，共享變量要求變量本身是線程安全的，然后在線程內(nèi)使用的時(shí)候巨柒，如 果有對共享變量的復(fù)合操作，那么也得保證復(fù)合操作的線程安全性柠衍。

45洋满、Java 中 notify 和 notifyAll 有什么區(qū)別？

notify() 方法不能喚醒某個(gè)具體的線程珍坊，所以只有一個(gè)線程在等待的時(shí)候它才有 用武之地牺勾。而 notifyAll()喚醒所有線程并允許他們爭奪鎖確保了至少有一個(gè)線程 能繼續(xù)運(yùn)行。

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

一個(gè)很明顯的原因是 JAVA 提供的鎖是對象級的而不是線程級的，每個(gè)對象都有 鎖履怯，通過線程獲得回还。由于 wait，notify 和 notifyAll 都是鎖級別的操作叹洲，所以把他 們定義在 Object 類中因?yàn)殒i屬于對象柠硕。

47、什么是 ThreadLocal 變量运提？

ThreadLocal 是 Java 里一種特殊的變量蝗柔。每個(gè)線程都有一個(gè) ThreadLocal 就是每 個(gè)線程都擁有了自己獨(dú)立的一個(gè)變量，競爭條件被徹底消除了民泵。它是為創(chuàng)建代價(jià) 高昂的對象獲取線程安全的好方法癣丧，比如你可以用 ThreadLocal 讓 SimpleDateFormat 變成線程安全的，因?yàn)槟莻€(gè)類創(chuàng)建代價(jià)高昂且每次調(diào)用都要?jiǎng)?chuàng)建不同的實(shí)例所以不值得在局部范圍使用它栈妆，如果為每個(gè)線程提供一個(gè)自獨(dú)有的變量拷貝胁编，將大大提高效率厢钧。首先，通過復(fù)用減少了代價(jià)高昂的對象的創(chuàng)建個(gè)數(shù)掏呼。其次坏快，你在沒有使用高代價(jià)的同步或者不變性的情況下獲得了線程安全。

48憎夷、Java 中 interrupted 和 isInterrupted 方法的區(qū)別莽鸿？

interrupt

interrupt 方法用于中斷線程。調(diào)用該方法的線程的狀態(tài)為將被置為”中斷”狀態(tài)拾给。 注意：線程中斷僅僅是置線程的中斷狀態(tài)位祥得，不會(huì)停止線程。需要用戶自己去監(jiān) 視線程的狀態(tài)為并做處理蒋得。支持線程中斷的方法（也就是線程中斷后會(huì)拋出 interruptedException 的方法）就是在監(jiān)視線程的中斷狀態(tài)级及，一旦線程的中斷狀 態(tài)被置為“中斷狀態(tài)”，就會(huì)拋出中斷異常额衙。

interrupted

查詢當(dāng)前線程的中斷狀態(tài)饮焦，并且清除原狀態(tài)。如果一個(gè)線程被中斷了窍侧，第一次調(diào) 用 interrupted 則返回 true县踢，第二次和后面的就返回 false 了。

isInterrupted

僅僅是查詢當(dāng)前線程的中斷狀態(tài)

49伟件、為什么 wait 和 notify 方法要在同步塊中調(diào)用硼啤？

Java API 強(qiáng)制要求這樣做，如果你不這么做斧账，你的代碼會(huì)拋出 IllegalMonitorStateException 異常谴返。還有一個(gè)原因是為了避免 wait 和 notify 之間產(chǎn)生競態(tài)條件。

50咧织、為什么你應(yīng)該在循環(huán)中檢查等待條件?

處于等待狀態(tài)的線程可能會(huì)收到錯(cuò)誤警報(bào)和偽喚醒嗓袱，如果不在循環(huán)中檢查等待條 件，程序就會(huì)在沒有滿足結(jié)束條件的情況下退出习绢。

51索抓、Java 中的同步集合與并發(fā)集合有什么區(qū)別？

同步集合與并發(fā)集合都為多線程和并發(fā)提供了合適的線程安全的集合毯炮，不過并發(fā) 集合的可擴(kuò)展性更高逼肯。在 Java1.5 之前程序員們只有同步集合來用且在多線程并發(fā) 的時(shí)候會(huì)導(dǎo)致爭用，阻礙了系統(tǒng)的擴(kuò)展性桃煎。Java5 介紹了并發(fā)集合像 ConcurrentHashMap篮幢，不僅提供線程安全還用鎖分離和內(nèi)部分區(qū)等現(xiàn)代技術(shù)提高 了可擴(kuò)展性。

52为迈、什么是線程池三椿？ 為什么要使用它缺菌？

創(chuàng)建線程要花費(fèi)昂貴的資源和時(shí)間，如果任務(wù)來了才創(chuàng)建線程那么響應(yīng)時(shí)間會(huì)變 長搜锰，而且一個(gè)進(jìn)程能創(chuàng)建的線程數(shù)有限伴郁。為了避免這些問題，在程序啟動(dòng)的時(shí)候 就創(chuàng)建若干線程來響應(yīng)處理蛋叼，它們被稱為線程池焊傅，里面的線程叫工作線程。從 JDK1.5 開始狈涮，Java API 提供了 Executor 框架讓你可以創(chuàng)建不同的線程池狐胎。

53、怎么檢測一個(gè)線程是否擁有鎖歌馍？

在 java.lang.Thread 中有一個(gè)方法叫 holdsLock()握巢，它返回 true 如果當(dāng)且僅當(dāng)當(dāng) 前線程擁有某個(gè)具體對象的鎖。

54松却、你如何在 Java 中獲取線程堆棧暴浦？

kill -3 [java pid]

不會(huì)在當(dāng)前終端輸出，它會(huì)輸出到代碼執(zhí)行的或指定的地方去晓锻。比如歌焦，kill -3 tomcat pid, 輸出堆棧到 log 目錄下。

Jstack [java pid]

這個(gè)比較簡單带射，在當(dāng)前終端顯示同规，也可以重定向到指定文件中循狰。

-JvisualVM：Thread Dum

不做說明窟社，打開 JvisualVM 后，都是界面操作绪钥，過程還是很簡單的灿里。

55、JVM 中哪個(gè)參數(shù)是用來控制線程的棧堆棧小的?

-Xss 每個(gè)線程的棧大小

56程腹、Thread 類中的 yield 方法有什么作用匣吊？

使當(dāng)前線程從執(zhí)行狀態(tài)（運(yùn)行狀態(tài)）變?yōu)榭蓤?zhí)行態(tài)（就緒狀態(tài)）

當(dāng)前線程到了就緒狀態(tài)，那么接下來哪個(gè)線程會(huì)從就緒狀態(tài)變成執(zhí)行狀態(tài)呢寸潦？可 能是當(dāng)前線程色鸳，也可能是其他線程，看系統(tǒng)的分配了见转。

57命雀、Java 中 ConcurrentHashMap 的并發(fā)度是什么？

ConcurrentHashMap 把實(shí)際 map 劃分成若干部分來實(shí)現(xiàn)它的可擴(kuò)展性和線程安 全斩箫。這種劃分是使用并發(fā)度獲得的吏砂，它是 ConcurrentHashMap 類構(gòu)造函數(shù)的一 個(gè)可選參數(shù)撵儿，默認(rèn)值為 16，這樣在多線程情況下就能避免爭用狐血。

在 JDK8 后淀歇，它摒棄了 Segment（鎖段）的概念，而是啟用了一種全新的方式實(shí) 現(xiàn),利用 CAS 算法匈织。同時(shí)加入了更多的輔助變量來提高并發(fā)度浪默，具體內(nèi)容還是查看 源碼吧。

58报亩、Java 中 Semaphore 是什么浴鸿？

Java 中的 Semaphore 是一種新的同步類，它是一個(gè)計(jì)數(shù)信號弦追。從概念上講岳链，從 概念上講，信號量維護(hù)了一個(gè)許可集合劲件。如有必要掸哑，在許可可用前會(huì)阻塞每一個(gè) acquire()，然后再獲取該許可零远。每個(gè) release()添加一個(gè)許可苗分，從而可能釋放一個(gè) 正在阻塞的獲取者。但是牵辣，不使用實(shí)際的許可對象摔癣，Semaphore 只對可用許可的 號碼進(jìn)行計(jì)數(shù)，并采取相應(yīng)的行動(dòng)纬向。信號量常常用于多線程的代碼中择浊，比如數(shù)據(jù) 庫連接池。

59逾条、Java 線程池中 submit() 和 execute()方法有什么區(qū)別琢岩？

兩個(gè)方法都可以向線程池提交任務(wù)，execute()方法的返回類型是 void师脂，它定義在 Executor 接口中担孔。

而 submit()方法可以返回持有計(jì)算結(jié)果的 Future 對象，它定義在 ExecutorService 接口中吃警，它擴(kuò)展了 Executor 接口糕篇，其它線程池類像 ThreadPoolExecutor 和 ScheduledThreadPoolExecutor 都有這些方法。

60酌心、什么是阻塞式方法拌消？

阻塞式方法是指程序會(huì)一直等待該方法完成期間不做其他事情，ServerSocket accept()方法就是一直等待客戶端連接谒府。這里的阻塞是指調(diào)用結(jié)果返回之前拼坎，當(dāng)前 線程會(huì)被掛起浮毯，直到得到結(jié)果之后才會(huì)返回。此外泰鸡，還有異步和非阻塞式方法在 任務(wù)完成前就返回债蓝。

61、Java 中的 ReadWriteLock 是什么盛龄？

讀寫鎖是用來提升并發(fā)程序性能的鎖分離技術(shù)的成果饰迹。

62、volatile 變量和 atomic 變量有什么不同余舶？

Volatile 變量可以確保先行關(guān)系啊鸭，即寫操作會(huì)發(fā)生在后續(xù)的讀操作之前, 但它并不 能保證原子性。例如用 volatile 修飾 count 變量那么 count++ 操作就不是原子 性的匿值。

而 AtomicInteger 類提供的 atomic 方法可以讓這種操作具有原子性如 getAndIncrement()方法會(huì)原子性的進(jìn)行增量操作把當(dāng)前值加一赠制，其它數(shù)據(jù)類型 和引用變量也可以進(jìn)行相似操作。

63挟憔、可以直接調(diào)用 Thread 類的 run ()方法么钟些？

當(dāng)然可以。但是如果我們調(diào)用了 Thread 的 run()方法绊谭，它的行為就會(huì)和普通的方 法一樣政恍，會(huì)在當(dāng)前線程中執(zhí)行。為了在新的線程中執(zhí)行我們的代碼达传，必須使用 Thread.start()方法篙耗。

64、如何讓正在運(yùn)行的線程暫停一段時(shí)間宪赶？

我們可以使用 Thread 類的 Sleep()方法讓線程暫停一段時(shí)間宗弯。需要注意的是，這 并不會(huì)讓線程終止逊朽，一旦從休眠中喚醒線程罕伯，線程的狀態(tài)將會(huì)被改變?yōu)?Runnable曲伊， 并且根據(jù)線程調(diào)度叽讳，它將得到執(zhí)行。

65坟募、你對線程優(yōu)先級的理解是什么岛蚤？

每一個(gè)線程都是有優(yōu)先級的，一般來說懈糯，高優(yōu)先級的線程在運(yùn)行時(shí)會(huì)具有優(yōu)先權(quán)涤妒， 但這依賴于線程調(diào)度的實(shí)現(xiàn)，這個(gè)實(shí)現(xiàn)是和操作系統(tǒng)相關(guān)的(OS dependent)赚哗。我 們可以定義線程的優(yōu)先級她紫，但是這并不能保證高優(yōu)先級的線程會(huì)在低優(yōu)先級的線 程前執(zhí)行硅堆。線程優(yōu)先級是一個(gè) int 變量(從 1-10)，1 代表最低優(yōu)先級贿讹，10 代表最 高優(yōu)先級渐逃。

java 的線程優(yōu)先級調(diào)度會(huì)委托給操作系統(tǒng)去處理，所以與具體的操作系統(tǒng)優(yōu)先級 有關(guān)民褂，如非特別需要茄菊，一般無需設(shè)置線程優(yōu)先級。

66赊堪、什么是線程調(diào)度器(Thread Scheduler)和時(shí)間分片(Time Slicing )面殖？

線程調(diào)度器是一個(gè)操作系統(tǒng)服務(wù)，它負(fù)責(zé)為 Runnable 狀態(tài)的線程分配 CPU 時(shí)間哭廉。 一旦我們創(chuàng)建一個(gè)線程并啟動(dòng)它脊僚，它的執(zhí)行便依賴于線程調(diào)度器的實(shí)現(xiàn)。 同上一個(gè)問題遵绰，線程調(diào)度并不受到 Java 虛擬機(jī)控制吃挑，所以由應(yīng)用程序來控制它是 更好的選擇（也就是說不要讓你的程序依賴于線程的優(yōu)先級）。

時(shí)間分片是指將可用的 CPU 時(shí)間分配給可用的 Runnable 線程的過程街立。分配 CPU 時(shí)間可以基于線程優(yōu)先級或者線程等待的時(shí)間舶衬。

67、你如何確保 main()方法所在的線程是 Java 程序最后結(jié)束 的線程赎离？

我們可以使用 Thread 類的 join()方法來確保所有程序創(chuàng)建的線程在 main()方法退 出前結(jié)束逛犹。

68、線程之間是如何通信的梁剔？

當(dāng)線程間是可以共享資源時(shí)虽画，線程間通信是協(xié)調(diào)它們的重要的手段。Object 類中 wait()\notify()\notifyAll()方法可以用于線程間通信關(guān)于資源的鎖的狀態(tài)荣病。

69码撰、為什么線程通信的方法 wait(), notify()和 notifyAll()被定 義在 Object 類里？

Java 的每個(gè)對象中都有一個(gè)鎖(monitor个盆，也可以成為監(jiān)視器) 并且 wait()脖岛，notify() 等方法用于等待對象的鎖或者通知其他線程對象的監(jiān)視器可用。在 Java 的線程中 并沒有可供任何對象使用的鎖和同步器颊亮。這就是為什么這些方法是 Object 類的一 部分柴梆，這樣 Java 的每一個(gè)類都有用于線程間通信的基本方法。

70终惑、為什么 wait(), notify()和 notifyAll ()必須在同步方法或 者同步塊中被調(diào)用绍在？

當(dāng)一個(gè)線程需要調(diào)用對象的 wait()方法的時(shí)候，這個(gè)線程必須擁有該對象的鎖，接 著它就會(huì)釋放這個(gè)對象鎖并進(jìn)入等待狀態(tài)直到其他線程調(diào)用這個(gè)對象上的 notify() 方法偿渡。同樣的臼寄，當(dāng)一個(gè)線程需要調(diào)用對象的 notify()方法時(shí)，它會(huì)釋放這個(gè)對象的 鎖溜宽，以便其他在等待的線程就可以得到這個(gè)對象鎖脯厨。由于所有的這些方法都需要 線程持有對象的鎖，這樣就只能通過同步來實(shí)現(xiàn)坑质，所以他們只能在同步方法或者 同步塊中被調(diào)用合武。

71、為什么 Thread 類的 sleep()和 yield ()方法是靜態(tài)的涡扼？

Thread 類的 sleep()和 yield()方法將在當(dāng)前正在執(zhí)行的線程上運(yùn)行稼跳。所以在其他 處于等待狀態(tài)的線程上調(diào)用這些方法是沒有意義的。這就是為什么這些方法是靜 態(tài)的吃沪。它們可以在當(dāng)前正在執(zhí)行的線程中工作汤善，并避免程序員錯(cuò)誤的認(rèn)為可以在 其他非運(yùn)行線程調(diào)用這些方法。

72票彪、如何確保線程安全红淡？

在 Java 中可以有很多方法來保證線程安全——同步，使用原子類(atomic concurrent classes)降铸，實(shí)現(xiàn)并發(fā)鎖在旱，使用 volatile 關(guān)鍵字，使用不變類和線程安全類推掸。

73桶蝎、同步方法和同步塊，哪個(gè)是更好的選擇谅畅？

同步塊是更好的選擇登渣，因?yàn)樗粫?huì)鎖住整個(gè)對象（當(dāng)然你也可以讓它鎖住整個(gè)對 象）。同步方法會(huì)鎖住整個(gè)對象毡泻，哪怕這個(gè)類中有多個(gè)不相關(guān)聯(lián)的同步塊胜茧，這通 常會(huì)導(dǎo)致他們停止執(zhí)行并需要等待獲得這個(gè)對象上的鎖。

同步塊更要符合開放調(diào)用的原則仇味，只在需要鎖住的代碼塊鎖住相應(yīng)的對象呻顽，這樣 從側(cè)面來說也可以避免死鎖

74、如何創(chuàng)建守護(hù)線程邪铲？

使用 Thread 類的 setDaemon(true)方法可以將線程設(shè)置為守護(hù)線程芬位，需要注意 的是无拗，需要在調(diào)用 start()方法前調(diào)用這個(gè)方法带到，否則會(huì)拋出 IllegalThreadStateException 異常。

75、什么是 Java Timer 類揽惹？如何創(chuàng)建一個(gè)有特定時(shí)間間隔的任務(wù)被饿？

java.util.Timer 是一個(gè)工具類，可以用于安排一個(gè)線程在未來的某個(gè)特定時(shí)間執(zhí) 行搪搏。Timer 類可以用安排一次性任務(wù)或者周期任務(wù)狭握。

java.util.TimerTask 是一個(gè)實(shí)現(xiàn)了 Runnable 接口的抽象類，我們需要去繼承這 個(gè)類來創(chuàng)建我們自己的定時(shí)任務(wù)并使用 Timer 去安排它的執(zhí)行疯溺。