本篇文章給大家?guī)砹岁P(guān)于java的相關(guān)知識(shí)，其中主要介紹了java并發(fā)的相關(guān)問題，總結(jié)了一些問題，大家來看一下會(huì)多少，希望對(duì)大家有幫助。

推薦學(xué)習(xí)：《java教程》

1.并行跟并發(fā)有什么區(qū)別？

從操作系統(tǒng)的角度來看，線程是CPU分配的最小單位。

• 并行就是同一時(shí)刻，兩個(gè)線程都在執(zhí)行。這就要求有兩個(gè)CPU去分別執(zhí)行兩個(gè)線程。
• 并發(fā)就是同一時(shí)刻，只有一個(gè)執(zhí)行，但是一個(gè)時(shí)間段內(nèi)，兩個(gè)線程都執(zhí)行了。并發(fā)的實(shí)現(xiàn)依賴于CPU切換線程，因?yàn)榍袚Q的時(shí)間特別短，所以基本對(duì)于用戶是無感知的。

就好像我們?nèi)ナ程么蝻?，并行就是我們?cè)诙鄠€(gè)窗口排隊(duì)，幾個(gè)阿姨同時(shí)打菜；并發(fā)就是我們擠在一個(gè)窗口，阿姨給這個(gè)打一勺，又手忙腳亂地給那個(gè)打一勺。

2.說說什么是進(jìn)程和線程？

要說線程，必須得先說說進(jìn)程。

• 進(jìn)程：進(jìn)程是代碼在數(shù)據(jù)集合上的一次運(yùn)行活動(dòng)，是系統(tǒng)進(jìn)行資源分配和調(diào)度的基本單位。
• 線程：線程是進(jìn)程的一個(gè)執(zhí)行路徑，一個(gè)進(jìn)程中至少有一個(gè)線程，進(jìn)程中的多個(gè)線程共享進(jìn)程的資源。

操作系統(tǒng)在分配資源時(shí)是把資源分配給進(jìn)程的， 但是 CPU 資源比較特殊，它是被分配到線程的，因?yàn)檎嬲加肅PU運(yùn)行的是線程，所以也說線程是 CPU分配的基本單位。

比如在Java中，當(dāng)我們啟動(dòng) main 函數(shù)其實(shí)就啟動(dòng)了一個(gè)JVM進(jìn)程，而 main 函數(shù)在的線程就是這個(gè)進(jìn)程中的一個(gè)線程，也稱主線程。

一個(gè)進(jìn)程中有多個(gè)線程，多個(gè)線程共用進(jìn)程的堆和方法區(qū)資源，但是每個(gè)線程有自己的程序計(jì)數(shù)器和棧。

3.說說線程有幾種創(chuàng)建方式？

Java中創(chuàng)建線程主要有三種方式，分別為繼承Thread類、實(shí)現(xiàn)Runnable接口、實(shí)現(xiàn)Callable接口。

• 繼承Thread類，重寫run()方法，調(diào)用start()方法啟動(dòng)線程

public class ThreadTest {      /**      * 繼承Thread類      */     public static class MyThread extends Thread {         @Override         public void run() {             System.out.println("This is child thread");         }     }      public static void main(String[] args) {         MyThread thread = new MyThread();         thread.start();     }}

• 實(shí)現(xiàn) Runnable 接口，重寫run()方法

public class RunnableTask implements Runnable {     public void run() {         System.out.println("Runnable!");     }      public static void main(String[] args) {         RunnableTask task = new RunnableTask();         new Thread(task).start();     }}

上面兩種都是沒有返回值的，但是如果我們需要獲取線程的執(zhí)行結(jié)果，該怎么辦呢？

• 實(shí)現(xiàn)Callable接口，重寫call()方法，這種方式可以通過FutureTask獲取任務(wù)執(zhí)行的返回值

public class CallerTask implements Callable<String> {     public String call() throws Exception {         return "Hello,i am running!";     }      public static void main(String[] args) {         //創(chuàng)建異步任務(wù)         FutureTask<String> task=new FutureTask<String>(new CallerTask());         //啟動(dòng)線程         new Thread(task).start();         try {             //等待執(zhí)行完成，并獲取返回結(jié)果             String result=task.get();             System.out.println(result);         } catch (InterruptedException e) {             e.printStackTrace();         } catch (ExecutionException e) {             e.printStackTrace();         }     }}

4.為什么調(diào)用start()方法時(shí)會(huì)執(zhí)行run()方法，那怎么不直接調(diào)用run()方法？

JVM執(zhí)行start方法，會(huì)先創(chuàng)建一條線程，由創(chuàng)建出來的新線程去執(zhí)行thread的run方法，這才起到多線程的效果。

**為什么我們不能直接調(diào)用run()方法？**也很清楚， 如果直接調(diào)用Thread的run()方法，那么run方法還是運(yùn)行在主線程中，相當(dāng)于順序執(zhí)行，就起不到多線程的效果。

5.線程有哪些常用的調(diào)度方法？

線程等待與通知

在Object類中有一些函數(shù)可以用于線程的等待與通知。

• wait()：當(dāng)一個(gè)線程A調(diào)用一個(gè)共享變量的 wait()方法時(shí)， 線程A會(huì)被阻塞掛起， 發(fā)生下面幾種情況才會(huì)返回 ：

  • （1） 線程A調(diào)用了共享對(duì)象 notify()或者 notifyAll()方法；

  • （2）其他線程調(diào)用了線程A的 interrupt() 方法，線程A拋出InterruptedException異常返回。

• wait(long timeout) ：這個(gè)方法相比 wait() 方法多了一個(gè)超時(shí)參數(shù)，它的不同之處在于，如果線程A調(diào)用共享對(duì)象的wait(long timeout)方法后，沒有在指定的 timeout ms時(shí)間內(nèi)被其它線程喚醒，那么這個(gè)方法還是會(huì)因?yàn)槌瑫r(shí)而返回。

• wait(long timeout, int nanos)，其內(nèi)部調(diào)用的是 wait(long timout）函數(shù)。

上面是線程等待的方法，而喚醒線程主要是下面兩個(gè)方法：

• notify() : 一個(gè)線程A調(diào)用共享對(duì)象的 notify() 方法后，會(huì)喚醒一個(gè)在這個(gè)共享變量上調(diào)用 wait 系列方法后被掛起的線程。 一個(gè)共享變量上可能會(huì)有多個(gè)線程在等待，具體喚醒哪個(gè)等待的線程是隨機(jī)的。
• notifyAll() ：不同于在共享變量上調(diào)用 notify() 函數(shù)會(huì)喚醒被阻塞到該共享變量上的一個(gè)線程，notifyAll()方法則會(huì)喚醒所有在該共享變量上由于調(diào)用 wait 系列方法而被掛起的線程。

Thread類也提供了一個(gè)方法用于等待的方法：

• join()：如果一個(gè)線程A執(zhí)行了thread.join()語句，其含義是：當(dāng)前線程A等待thread線程終止之后才

  從thread.join()返回。

線程休眠

• sleep(long millis) :Thread類中的靜態(tài)方法，當(dāng)一個(gè)執(zhí)行中的線程A調(diào)用了Thread 的sleep方法后，線程A會(huì)暫時(shí)讓出指定時(shí)間的執(zhí)行權(quán)，但是線程A所擁有的監(jiān)視器資源，比如鎖還是持有不讓出的。指定的睡眠時(shí)間到了后該函數(shù)會(huì)正常返回，接著參與 CPU 的調(diào)度，獲取到 CPU 資源后就可以繼續(xù)運(yùn)行。

讓出優(yōu)先權(quán)

• yield() ：Thread類中的靜態(tài)方法，當(dāng)一個(gè)線程調(diào)用 yield 方法時(shí)，實(shí)際就是在暗示線程調(diào)度器當(dāng)前線程請(qǐng)求讓出自己的CPU ，但是線程調(diào)度器可以無條件忽略這個(gè)暗示。

線程中斷

Java 中的線程中斷是一種線程間的協(xié)作模式，通過設(shè)置線程的中斷標(biāo)志并不能直接終止該線程的執(zhí)行，而是被中斷的線程根據(jù)中斷狀態(tài)自行處理。

• void interrupt() ：中斷線程，例如，當(dāng)線程A運(yùn)行時(shí)，線程B可以調(diào)用錢程interrupt() 方法來設(shè)置線程的中斷標(biāo)志為true 并立即返回。設(shè)置標(biāo)志僅僅是設(shè)置標(biāo)志, 線程A實(shí)際并沒有被中斷， 會(huì)繼續(xù)往下執(zhí)行。
• boolean isInterrupted() 方法： 檢測(cè)當(dāng)前線程是否被中斷。
• boolean interrupted() 方法： 檢測(cè)當(dāng)前線程是否被中斷，與 isInterrupted 不同的是，該方法如果發(fā)現(xiàn)當(dāng)前線程被中斷，則會(huì)清除中斷標(biāo)志。

6.線程有幾種狀態(tài)？

在Java中，線程共有六種狀態(tài)：

線程在自身的生命周期中， 并不是固定地處于某個(gè)狀態(tài)，而是隨著代碼的執(zhí)行在不同的狀態(tài)之間進(jìn)行切換，Java線程狀態(tài)變化如圖示：

7.什么是線程上下文切換？

使用多線程的目的是為了充分利用CPU，但是我們知道，并發(fā)其實(shí)是一個(gè)CPU來應(yīng)付多個(gè)線程。

為了讓用戶感覺多個(gè)線程是在同時(shí)執(zhí)行的， CPU 資源的分配采用了時(shí)間片輪轉(zhuǎn)也就是給每個(gè)線程分配一個(gè)時(shí)間片，線程在時(shí)間片內(nèi)占用 CPU 執(zhí)行任務(wù)。當(dāng)線程使用完時(shí)間片后，就會(huì)處于就緒狀態(tài)并讓出 CPU 讓其他線程占用，這就是上下文切換。

8.守護(hù)線程了解嗎？

Java中的線程分為兩類，分別為 daemon 線程（守護(hù)線程）和 user 線程（用戶線程）。

在JVM 啟動(dòng)時(shí)會(huì)調(diào)用 main 函數(shù)，main函數(shù)所在的錢程就是一個(gè)用戶線程。其實(shí)在 JVM 內(nèi)部同時(shí)還啟動(dòng)了很多守護(hù)線程， 比如垃圾回收線程。

那么守護(hù)線程和用戶線程有什么區(qū)別呢？區(qū)別之一是當(dāng)最后一個(gè)非守護(hù)線程束時(shí)， JVM會(huì)正常退出，而不管當(dāng)前是否存在守護(hù)線程，也就是說守護(hù)線程是否結(jié)束并不影響 JVM退出。換而言之，只要有一個(gè)用戶線程還沒結(jié)束，正常情況下JVM就不會(huì)退出。

9.線程間有哪些通信方式？

• volatile和synchronized關(guān)鍵字

關(guān)鍵字volatile可以用來修飾字段（成員變量），就是告知程序任何對(duì)該變量的訪問均需要從共享內(nèi)存中獲取，而對(duì)它的改變必須同步刷新回共享內(nèi)存，它能保證所有線程對(duì)變量訪問的可見性。

關(guān)鍵字synchronized可以修飾方法或者以同步塊的形式來進(jìn)行使用，它主要確保多個(gè)線程在同一個(gè)時(shí)刻，只能有一個(gè)線程處于方法或者同步塊中，它保證了線程對(duì)變量訪問的可見性和排他性。

• 等待/通知機(jī)制

可以通過Java內(nèi)置的等待/通知機(jī)制（wait()/notify()）實(shí)現(xiàn)一個(gè)線程修改一個(gè)對(duì)象的值，而另一個(gè)線程感知到了變化，然后進(jìn)行相應(yīng)的操作。

• 管道輸入/輸出流

管道輸入/輸出流和普通的文件輸入/輸出流或者網(wǎng)絡(luò)輸入/輸出流不同之處在于，它主要用于線程之間的數(shù)據(jù)傳輸，而傳輸?shù)拿浇闉閮?nèi)存。

管道輸入/輸出流主要包括了如下4種具體實(shí)現(xiàn)：PipedOutputStream、PipedInputStream、 PipedReader和PipedWriter，前兩種面向字節(jié)，而后兩種面向字符。

• 使用Thread.join()

如果一個(gè)線程A執(zhí)行了thread.join()語句，其含義是：當(dāng)前線程A等待thread線程終止之后才從thread.join()返回。。線程Thread除了提供join()方法之外，還提供了join(long millis)和join(long millis,int nanos)兩個(gè)具備超時(shí)特性的方法。

• 使用ThreadLocal

ThreadLocal，即線程變量，是一個(gè)以ThreadLocal對(duì)象為鍵、任意對(duì)象為值的存儲(chǔ)結(jié)構(gòu)。這個(gè)結(jié)構(gòu)被附帶在線程上，也就是說一個(gè)線程可以根據(jù)一個(gè)ThreadLocal對(duì)象查詢到綁定在這個(gè)線程上的一個(gè)值。

可以通過set(T)方法來設(shè)置一個(gè)值，在當(dāng)前線程下再通過get()方法獲取到原先設(shè)置的值。

關(guān)于多線程，其實(shí)很大概率還會(huì)出一些筆試題，比如交替打印、銀行轉(zhuǎn)賬、生產(chǎn)消費(fèi)模型等等，后面老三會(huì)單獨(dú)出一期來盤點(diǎn)一下常見的多線程筆試題。

ThreadLocal

ThreadLocal其實(shí)應(yīng)用場(chǎng)景不是很多，但卻是被炸了千百遍的面試?yán)嫌蜅l，涉及到多線程、數(shù)據(jù)結(jié)構(gòu)、JVM，可問的點(diǎn)比較多，一定要拿下。

10.ThreadLocal是什么？

ThreadLocal，也就是線程本地變量。如果你創(chuàng)建了一個(gè)ThreadLocal變量，那么訪問這個(gè)變量的每個(gè)線程都會(huì)有這個(gè)變量的一個(gè)本地拷貝，多個(gè)線程操作這個(gè)變量的時(shí)候，實(shí)際是操作自己本地內(nèi)存里面的變量，從而起到線程隔離的作用，避免了線程安全問題。

• 創(chuàng)建

創(chuàng)建了一個(gè)ThreadLoca變量localVariable，任何一個(gè)線程都能并發(fā)訪問localVariable。

//創(chuàng)建一個(gè)ThreadLocal變量public static ThreadLocal<String> localVariable = new ThreadLocal<>();

• 寫入

線程可以在任何地方使用localVariable，寫入變量。

localVariable.set("鄙人三某”);

• 讀取

線程在任何地方讀取的都是它寫入的變量。

localVariable.get();

11.你在工作中用到過ThreadLocal嗎？

有用到過的，用來做用戶信息上下文的存儲(chǔ)。

我們的系統(tǒng)應(yīng)用是一個(gè)典型的MVC架構(gòu)，登錄后的用戶每次訪問接口，都會(huì)在請(qǐng)求頭中攜帶一個(gè)token，在控制層可以根據(jù)這個(gè)token，解析出用戶的基本信息。那么問題來了，假如在服務(wù)層和持久層都要用到用戶信息，比如rpc調(diào)用、更新用戶獲取等等，那應(yīng)該怎么辦呢？

一種辦法是顯式定義用戶相關(guān)的參數(shù)，比如賬號(hào)、用戶名……這樣一來，我們可能需要大面積地修改代碼，多少有點(diǎn)瓜皮，那該怎么辦呢？

這時(shí)候我們就可以用到ThreadLocal，在控制層攔截請(qǐng)求把用戶信息存入ThreadLocal，這樣我們?cè)谌魏我粋€(gè)地方，都可以取出ThreadLocal中存的用戶數(shù)據(jù)。

很多其它場(chǎng)景的cookie、session等等數(shù)據(jù)隔離也都可以通過ThreadLocal去實(shí)現(xiàn)。

我們常用的數(shù)據(jù)庫連接池也用到了ThreadLocal：

• 數(shù)據(jù)庫連接池的連接交給ThreadLoca進(jìn)行管理，保證當(dāng)前線程的操作都是同一個(gè)Connnection。

12.ThreadLocal怎么實(shí)現(xiàn)的呢？

我們看一下ThreadLocal的set(T)方法，發(fā)現(xiàn)先獲取到當(dāng)前線程，再獲取ThreadLocalMap，然后把元素存到這個(gè)map中。

    public void set(T value) {         //獲取當(dāng)前線程         Thread t = Thread.currentThread();         //獲取ThreadLocalMap         ThreadLocalMap map = getMap(t);         //講當(dāng)前元素存入map         if (map != null)             map.set(this, value);         else             createMap(t, value);     }

ThreadLocal實(shí)現(xiàn)的秘密都在這個(gè)ThreadLocalMap了，可以Thread類中定義了一個(gè)類型為ThreadLocal.ThreadLocalMap的成員變量threadLocals。

public class Thread implements Runnable {    //ThreadLocal.ThreadLocalMap是Thread的屬性    ThreadLocal.ThreadLocalMap threadLocals = null;}

ThreadLocalMap既然被稱為Map，那么毫無疑問它是<key,value>型的數(shù)據(jù)結(jié)構(gòu)。我們都知道m(xù)ap的本質(zhì)是一個(gè)個(gè)<key,value>形式的節(jié)點(diǎn)組成的數(shù)組，那ThreadLocalMap的節(jié)點(diǎn)是什么樣的呢？

        static class Entry extends WeakReference<ThreadLocal<?>> {             /** The value associated with this ThreadLocal. */             Object value;              //節(jié)點(diǎn)類             Entry(ThreadLocal<?> k, Object v) {                 //key賦值                 super(k);                 //value賦值                 value = v;             }         }

這里的節(jié)點(diǎn)，key可以簡(jiǎn)單低視作ThreadLocal，value為代碼中放入的值，當(dāng)然實(shí)際上key并不是ThreadLocal本身，而是它的一個(gè)弱引用，可以看到Entry的key繼承了 WeakReference（弱引用），再來看一下key怎么賦值的：

    public WeakReference(T referent) {         super(referent);     }

key的賦值，使用的是WeakReference的賦值。

所以，怎么回答ThreadLocal原理？要答出這幾個(gè)點(diǎn)：

• Thread類有一個(gè)類型為ThreadLocal.ThreadLocalMap的實(shí)例變量threadLocals，每個(gè)線程都有一個(gè)屬于自己的ThreadLocalMap。
• ThreadLocalMap內(nèi)部維護(hù)著Entry數(shù)組，每個(gè)Entry代表一個(gè)完整的對(duì)象，key是ThreadLocal的弱引用，value是ThreadLocal的泛型值。
• 每個(gè)線程在往ThreadLocal里設(shè)置值的時(shí)候，都是往自己的ThreadLocalMap里存，讀也是以某個(gè)ThreadLocal作為引用，在自己的map里找對(duì)應(yīng)的key，從而實(shí)現(xiàn)了線程隔離。
• ThreadLocal本身不存儲(chǔ)值，它只是作為一個(gè)key來讓線程往ThreadLocalMap里存取值。

13.ThreadLocal 內(nèi)存泄露是怎么回事？

我們先來分析一下使用ThreadLocal時(shí)的內(nèi)存，我們都知道，在JVM中，棧內(nèi)存線程私有，存儲(chǔ)了對(duì)象的引用，堆內(nèi)存線程共享，存儲(chǔ)了對(duì)象實(shí)例。

所以呢，棧中存儲(chǔ)了ThreadLocal、Thread的引用，堆中存儲(chǔ)了它們的具體實(shí)例。

ThreadLocalMap中使用的 key 為 ThreadLocal 的弱引用。

“弱引用：只要垃圾回收機(jī)制一運(yùn)行，不管JVM的內(nèi)存空間是否充足，都會(huì)回收該對(duì)象占用的內(nèi)存?！?/p>

那么現(xiàn)在問題就來了，弱引用很容易被回收，如果ThreadLocal（ThreadLocalMap的Key）被垃圾回收器回收了，但是ThreadLocalMap生命周期和Thread是一樣的，它這時(shí)候如果不被回收，就會(huì)出現(xiàn)這種情況：ThreadLocalMap的key沒了，value還在，這就會(huì)造成了內(nèi)存泄漏問題。

那怎么解決內(nèi)存泄漏問題呢？

很簡(jiǎn)單，使用完ThreadLocal后，及時(shí)調(diào)用remove()方法釋放內(nèi)存空間。

ThreadLocal<String> localVariable = new ThreadLocal();try {     localVariable.set("鄙人三某”);     ……} finally {     localVariable.remove();}

那為什么key還要設(shè)計(jì)成弱引用？

key設(shè)計(jì)成弱引用同樣是為了防止內(nèi)存泄漏。

假如key被設(shè)計(jì)成強(qiáng)引用，如果ThreadLocal Reference被銷毀，此時(shí)它指向ThreadLoca的強(qiáng)引用就沒有了，但是此時(shí)key還強(qiáng)引用指向ThreadLoca，就會(huì)導(dǎo)致ThreadLocal不能被回收，這時(shí)候就發(fā)生了內(nèi)存泄漏的問題。

14.ThreadLocalMap的結(jié)構(gòu)了解嗎？

ThreadLocalMap雖然被叫做Map，其實(shí)它是沒有實(shí)現(xiàn)Map接口的，但是結(jié)構(gòu)還是和HashMap比較類似的，主要關(guān)注的是兩個(gè)要素：元素?cái)?shù)組和散列方法。

• 元素?cái)?shù)組

  一個(gè)table數(shù)組，存儲(chǔ)Entry類型的元素，Entry是ThreaLocal弱引用作為key，Object作為value的結(jié)構(gòu)。

 private Entry[] table;

• 散列方法

  散列方法就是怎么把對(duì)應(yīng)的key映射到table數(shù)組的相應(yīng)下標(biāo)，ThreadLocalMap用的是哈希取余法，取出key的threadLocalHashCode，然后和table數(shù)組長(zhǎng)度減一&運(yùn)算（相當(dāng)于取余）。

int i = key.threadLocalHashCode & (table.length - 1);

這里的threadLocalHashCode計(jì)算有點(diǎn)東西，每創(chuàng)建一個(gè)ThreadLocal對(duì)象，它就會(huì)新增0x61c88647，這個(gè)值很特殊，它是斐波那契數(shù) 也叫 黃金分割數(shù)。hash增量為 這個(gè)數(shù)字，帶來的好處就是 hash 分布非常均勻。

    private static final int HASH_INCREMENT = 0x61c88647;          private static int nextHashCode() {         return nextHashCode.getAndAdd(HASH_INCREMENT);     }

15.ThreadLocalMap怎么解決Hash沖突的？

我們可能都知道HashMap使用了鏈表來解決沖突，也就是所謂的鏈地址法。

ThreadLocalMap沒有使用鏈表，自然也不是用鏈地址法來解決沖突了，它用的是另外一種方式——開放定址法。開放定址法是什么意思呢？簡(jiǎn)單來說，就是這個(gè)坑被人占了，那就接著去找空著的坑。

如上圖所示，如果我們插入一個(gè)value=27的數(shù)據(jù)，通過 hash計(jì)算后應(yīng)該落入第 4 個(gè)槽位中，而槽位 4 已經(jīng)有了 Entry數(shù)據(jù)，而且Entry數(shù)據(jù)的key和當(dāng)前不相等。此時(shí)就會(huì)線性向后查找，一直找到 Entry為 null的槽位才會(huì)停止查找，把元素放到空的槽中。

在get的時(shí)候，也會(huì)根據(jù)ThreadLocal對(duì)象的hash值，定位到table中的位置，然后判斷該槽位Entry對(duì)象中的key是否和get的key一致，如果不一致，就判斷下一個(gè)位置。

16.ThreadLocalMap擴(kuò)容機(jī)制了解嗎？

在ThreadLocalMap.set()方法的最后，如果執(zhí)行完啟發(fā)式清理工作后，未清理到任何數(shù)據(jù)，且當(dāng)前散列數(shù)組中Entry的數(shù)量已經(jīng)達(dá)到了列表的擴(kuò)容閾值(len*2/3)，就開始執(zhí)行rehash()邏輯：

if (!cleanSomeSlots(i, sz) && sz >= threshold)     rehash();

再著看rehash()具體實(shí)現(xiàn)：這里會(huì)先去清理過期的Entry，然后還要根據(jù)條件判斷size >= threshold - threshold / 4 也就是size >= threshold* 3/4來決定是否需要擴(kuò)容。

private void rehash() {     //清理過期Entry     expungeStaleEntries();      //擴(kuò)容     if (size >= threshold - threshold / 4)         resize();}//清理過期Entryprivate void expungeStaleEntries() {     Entry[] tab = table;     int len = tab.length;     for (int j = 0; j < len; j++) {         Entry e = tab[j];         if (e != null && e.get() == null)             expungeStaleEntry(j);     }}

接著看看具體的resize()方法，擴(kuò)容后的newTab的大小為老數(shù)組的兩倍，然后遍歷老的table數(shù)組，散列方法重新計(jì)算位置，開放地址解決沖突，然后放到新的newTab，遍歷完成之后，oldTab中所有的entry數(shù)據(jù)都已經(jīng)放入到newTab中了，然后table引用指向newTab

具體代碼：

17.父子線程怎么共享數(shù)據(jù)？

父線程能用ThreadLocal來給子線程傳值嗎？毫無疑問，不能。那該怎么辦？

這時(shí)候可以用到另外一個(gè)類——InheritableThreadLocal。

使用起來很簡(jiǎn)單，在主線程的InheritableThreadLocal實(shí)例設(shè)置值，在子線程中就可以拿到了。

public class InheritableThreadLocalTest {          public static void main(String[] args) {         final ThreadLocal threadLocal = new InheritableThreadLocal();         // 主線程         threadLocal.set("不擅技術(shù)");         //子線程         Thread t = new Thread() {             @Override             public void run() {                 super.run();                 System.out.println("鄙人三某 ，" + threadLocal.get());             }         };         t.start();     }}

那原理是什么呢？

原理很簡(jiǎn)單，在Thread類里還有另外一個(gè)變量：

ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

在Thread.init的時(shí)候，如果父線程的inheritableThreadLocals不為空，就把它賦給當(dāng)前線程（子線程）的inheritableThreadLocals。

        if (inheritThreadLocals && parent.inheritableThreadLocals != null)             this.inheritableThreadLocals =                 ThreadLocal.createInheritedMap(parent.inheritableThreadLocals)

18.說一下你對(duì)Java內(nèi)存模型（JMM）的理解？

Java內(nèi)存模型（Java Memory Model，JMM），是一種抽象的模型，被定義出來屏蔽各種硬件和操作系統(tǒng)的內(nèi)存訪問差異。

JMM定義了線程和主內(nèi)存之間的抽象關(guān)系：線程之間的共享變量存儲(chǔ)在主內(nèi)存（Main Memory）中，每個(gè)線程都有一個(gè)私有的本地內(nèi)存（Local Memory），本地內(nèi)存中存儲(chǔ)了該線程以讀/寫共享變量的副本。

Java內(nèi)存模型的抽象圖：

本地內(nèi)存是JMM的 一個(gè)抽象概念，并不真實(shí)存在。它其實(shí)涵蓋了緩存、寫緩沖區(qū)、寄存器以及其他的硬件和編譯器優(yōu)化。

圖里面的是一個(gè)雙核 CPU 系統(tǒng)架構(gòu) ，每個(gè)核有自己的控制器和運(yùn)算器，其中控制器包含一組寄存器和操作控制器，運(yùn)算器執(zhí)行算術(shù)邏輔運(yùn)算。每個(gè)核都有自己的一級(jí)緩存，在有些架構(gòu)里面還有一個(gè)所有 CPU 共享的二級(jí)緩存。 那么 Java 內(nèi)存模型里面的工作內(nèi)存，就對(duì)應(yīng)這里的 Ll 緩存或者 L2 緩存或者 CPU 寄存器。

19.說說你對(duì)原子性、可見性、有序性的理解？

原子性、有序性、可見性是并發(fā)編程中非常重要的基礎(chǔ)概念，JMM的很多技術(shù)都是圍繞著這三大特性展開。

• 原子性：原子性指的是一個(gè)操作是不可分割、不可中斷的，要么全部執(zhí)行并且執(zhí)行的過程不會(huì)被任何因素打斷，要么就全不執(zhí)行。
• 可見性：可見性指的是一個(gè)線程修改了某一個(gè)共享變量的值時(shí)，其它線程能夠立即知道這個(gè)修改。
• 有序性：有序性指的是對(duì)于一個(gè)線程的執(zhí)行代碼，從前往后依次執(zhí)行，單線程下可以認(rèn)為程序是有序的，但是并發(fā)時(shí)有可能會(huì)發(fā)生指令重排。

分析下面幾行代碼的原子性？

int i = 2;int j = i;i++;i = i + 1;

• 第1句是基本類型賦值，是原子性操作。
• 第2句先讀i的值，再賦值到j(luò)，兩步操作，不能保證原子性。
• 第3和第4句其實(shí)是等效的，先讀取i的值，再+1，最后賦值到i，三步操作了，不能保證原子性。

原子性、可見性、有序性都應(yīng)該怎么保證呢？

• 原子性：JMM只能保證基本的原子性，如果要保證一個(gè)代碼塊的原子性，需要使用synchronized。
• 可見性：Java是利用volatile關(guān)鍵字來保證可見性的，除此之外，final和synchronized也能保證可見性。
• 有序性：synchronized或者volatile都可以保證多線程之間操作的有序性。

20.那說說什么是指令重排？

在執(zhí)行程序時(shí)，為了提高性能，編譯器和處理器常常會(huì)對(duì)指令做重排序。重排序分3種類型。

1. 編譯器優(yōu)化的重排序。編譯器在不改變單線程程序語義的前提下，可以重新安排語句的執(zhí)行順序。
2. 指令級(jí)并行的重排序?，F(xiàn)代處理器采用了指令級(jí)并行技術(shù)（Instruction-Level Parallelism，ILP）來將多條指令重疊執(zhí)行。如果不存在數(shù)據(jù)依賴性，處理器可以改變語句對(duì)應(yīng) 機(jī)器指令的執(zhí)行順序。
3. 內(nèi)存系統(tǒng)的重排序。由于處理器使用緩存和讀/寫緩沖區(qū)，這使得加載和存儲(chǔ)操作看上去可能是在亂序執(zhí)行。

從Java源代碼到最終實(shí)際執(zhí)行的指令序列，會(huì)分別經(jīng)歷下面3種重排序，如圖：

我們比較熟悉的雙重校驗(yàn)單例模式就是一個(gè)經(jīng)典的指令重排的例子，Singleton instance=new Singleton()；對(duì)應(yīng)的JVM指令分為三步：分配內(nèi)存空間–>初始化對(duì)象—>對(duì)象指向分配的內(nèi)存空間，但是經(jīng)過了編譯器的指令重排序，第二步和第三步就可能會(huì)重排序。

JMM屬于語言級(jí)的內(nèi)存模型，它確保在不同的編譯器和不同的處理器平臺(tái)之上，通過禁止特定類型的編譯器重排序和處理器重排序，為程序員提供一致的內(nèi)存可見性保證。

21.指令重排有限制嗎？happens-before了解嗎？

指令重排也是有一些限制的，有兩個(gè)規(guī)則happens-before和as-if-serial來約束。

happens-before的定義：

• 如果一個(gè)操作happens-before另一個(gè)操作，那么第一個(gè)操作的執(zhí)行結(jié)果將對(duì)第二個(gè)操作可見，而且第一個(gè)操作的執(zhí)行順序排在第二個(gè)操作之前。
• 兩個(gè)操作之間存在happens-before關(guān)系，并不意味著Java平臺(tái)的具體實(shí)現(xiàn)必須要按照 happens-before關(guān)系指定的順序來執(zhí)行。如果重排序之后的執(zhí)行結(jié)果，與按happens-before關(guān)系來執(zhí)行的結(jié)果一致，那么這種重排序并不非法

happens-before和我們息息相關(guān)的有六大規(guī)則：

• 程序順序規(guī)則：一個(gè)線程中的每個(gè)操作，happens-before于該線程中的任意后續(xù)操作。
• 監(jiān)視器鎖規(guī)則：對(duì)一個(gè)鎖的解鎖，happens-before于隨后對(duì)這個(gè)鎖的加鎖。
• volatile變量規(guī)則：對(duì)一個(gè)volatile域的寫，happens-before于任意后續(xù)對(duì)這個(gè)volatile域的讀。
• 傳遞性：如果A happens-before B，且B happens-before C，那么A happens-before C。
• start()規(guī)則：如果線程A執(zhí)行操作ThreadB.start()（啟動(dòng)線程B），那么A線程的 ThreadB.start()操作happens-before于線程B中的任意操作。
• join()規(guī)則：如果線程A執(zhí)行操作ThreadB.join()并成功返回，那么線程B中的任意操作 happens-before于線程A從ThreadB.join()操作成功返回。

22.as-if-serial又是什么？單線程的程序一定是順序的嗎？

as-if-serial語義的意思是：不管怎么重排序（編譯器和處理器為了提高并行度），單線程程序的執(zhí)行結(jié)果不能被改變。編譯器、runtime和處理器都必須遵守as-if-serial語義。

為了遵守as-if-serial語義，編譯器和處理器不會(huì)對(duì)存在數(shù)據(jù)依賴關(guān)系的操作做重排序，因?yàn)檫@種重排序會(huì)改變執(zhí)行結(jié)果。但是，如果操作之間不存在數(shù)據(jù)依賴關(guān)系，這些操作就可能被編譯器和處理器重排序。為了具體說明，請(qǐng)看下面計(jì)算圓面積的代碼示例。

double pi = 3.14;   // Adouble r = 1.0;   // B double area = pi * r * r;   // C

上面3個(gè)操作的數(shù)據(jù)依賴關(guān)系：

A和C之間存在數(shù)據(jù)依賴關(guān)系，同時(shí)B和C之間也存在數(shù)據(jù)依賴關(guān)系。因此在最終執(zhí)行的指令序列中，C不能被重排序到A和B的前面（C排到A和B的前面，程序的結(jié)果將會(huì)被改變）。但A和B之間沒有數(shù)據(jù)依賴關(guān)系，編譯器和處理器可以重排序A和B之間的執(zhí)行順序。

所以最終，程序可能會(huì)有兩種執(zhí)行順序：

as-if-serial語義把單線程程序保護(hù)了起來，遵守as-if-serial語義的編譯器、runtime和處理器共同編織了這么一個(gè)“楚門的世界”：?jiǎn)尉€程程序是按程序的“順序”來執(zhí)行的。as- if-serial語義使單線程情況下，我們不需要擔(dān)心重排序的問題，可見性的問題。

23.volatile實(shí)現(xiàn)原理了解嗎？

volatile有兩個(gè)作用，保證可見性和有序性。

volatile怎么保證可見性的呢？

相比synchronized的加鎖方式來解決共享變量的內(nèi)存可見性問題，volatile就是更輕量的選擇，它沒有上下文切換的額外開銷成本。

volatile可以確保對(duì)某個(gè)變量的更新對(duì)其他線程馬上可見，一個(gè)變量被聲明為volatile 時(shí)，線程在寫入變量時(shí)不會(huì)把值緩存在寄存器或者其他地方，而是會(huì)把值刷新回主內(nèi)存 當(dāng)其它線程讀取該共享變量 ，會(huì)從主內(nèi)存重新獲取最新值，而不是使用當(dāng)前線程的本地內(nèi)存中的值。

例如，我們聲明一個(gè) volatile 變量 volatile int x = 0，線程A修改x=1，修改完之后就會(huì)把新的值刷新回主內(nèi)存，線程B讀取x的時(shí)候，就會(huì)清空本地內(nèi)存變量，然后再從主內(nèi)存獲取最新值。

volatile怎么保證有序性的呢？

重排序可以分為編譯器重排序和處理器重排序，valatile保證有序性，就是通過分別限制這兩種類型的重排序。

為了實(shí)現(xiàn)volatile的內(nèi)存語義，編譯器在生成字節(jié)碼時(shí)，會(huì)在指令序列中插入內(nèi)存屏障來禁止特定類型的處理器重排序。

1. 在每個(gè)volatile寫操作的前面插入一個(gè)StoreStore屏障
2. 在每個(gè)volatile寫操作的后面插入一個(gè)StoreLoad屏障
3. 在每個(gè)volatile讀操作的后面插入一個(gè)LoadLoad屏障
4. 在每個(gè)volatile讀操作的后面插入一個(gè)LoadStore屏障

24.synchronized用過嗎？怎么使用？

synchronized經(jīng)常用的，用來保證代碼的原子性。

synchronized主要有三種用法：

• 修飾實(shí)例方法: 作用于當(dāng)前對(duì)象實(shí)例加鎖，進(jìn)入同步代碼前要獲得 當(dāng)前對(duì)象實(shí)例的鎖

synchronized void method() {   //業(yè)務(wù)代碼}

• 修飾靜態(tài)方法：也就是給當(dāng)前類加鎖，會(huì)作?于類的所有對(duì)象實(shí)例 ，進(jìn)?同步代碼前要獲得當(dāng)前 class 的鎖。因?yàn)殪o態(tài)成員不屬于任何?個(gè)實(shí)例對(duì)象，是類成員（ static 表明這是該類的?個(gè)靜態(tài)資源，不管 new 了多少個(gè)對(duì)象，只有?份）。

  如果?個(gè)線程 A 調(diào)??個(gè)實(shí)例對(duì)象的?靜態(tài) synchronized ?法，?線程 B 需要調(diào)?這個(gè)實(shí)例對(duì)象所屬類的靜態(tài) synchronized ?法，是允許的，不會(huì)發(fā)?互斥現(xiàn)象，因?yàn)樵L問靜態(tài) synchronized ?法占?的鎖是當(dāng)前類的鎖，?訪問?靜態(tài) synchronized ?法占?的鎖是當(dāng)前實(shí)例對(duì)象鎖。

synchronized void staic method() {  //業(yè)務(wù)代碼}

• 修飾代碼塊 ：指定加鎖對(duì)象，對(duì)給定對(duì)象/類加鎖。 synchronized(this|object) 表示進(jìn)?同步代碼庫前要獲得給定對(duì)象的鎖。 synchronized(類.class) 表示進(jìn)?同步代碼前要獲得 當(dāng)前 class 的鎖

synchronized(this) {  //業(yè)務(wù)代碼}

25.synchronized的實(shí)現(xiàn)原理？

synchronized是怎么加鎖的呢？

我們使用synchronized的時(shí)候，發(fā)現(xiàn)不用自己去lock和unlock，是因?yàn)镴VM幫我們把這個(gè)事情做了。

1. synchronized修飾代碼塊時(shí)，JVM采用monitorenter、monitorexit兩個(gè)指令來實(shí)現(xiàn)同步，monitorenter 指令指向同步代碼塊的開始位置， monitorexit 指令則指向同步代碼塊的結(jié)束位置。

   反編譯一段synchronized修飾代碼塊代碼，javap -c -s -v -l SynchronizedDemo.class，可以看到相應(yīng)的字節(jié)碼指令。

2. synchronized修飾同步方法時(shí)，JVM采用ACC_SYNCHRONIZED標(biāo)記符來實(shí)現(xiàn)同步，這個(gè)標(biāo)識(shí)指明了該方法是一個(gè)同步方法。

   同樣可以寫段代碼反編譯看一下。

synchronized鎖住的是什么呢？

monitorenter、monitorexit或者ACC_SYNCHRONIZED都是基于Monitor實(shí)現(xiàn)的。

實(shí)例對(duì)象結(jié)構(gòu)里有對(duì)象頭，對(duì)象頭里面有一塊結(jié)構(gòu)叫Mark Word，Mark Word指針指向了monitor。

所謂的Monitor其實(shí)是一種同步工具，也可以說是一種同步機(jī)制。在Java虛擬機(jī)（HotSpot）中，Monitor是由ObjectMonitor實(shí)現(xiàn)的，可以叫做內(nèi)部鎖，或者M(jìn)onitor鎖。

ObjectMonitor的工作原理：

• ObjectMonitor有兩個(gè)隊(duì)列：_WaitSet、_EntryList，用來保存ObjectWaiter 對(duì)象列表。
• _owner，獲取 Monitor 對(duì)象的線程進(jìn)入 _owner 區(qū)時(shí)， _count + 1。如果線程調(diào)用了 wait() 方法，此時(shí)會(huì)釋放 Monitor 對(duì)象， _owner 恢復(fù)為空， _count – 1。同時(shí)該等待線程進(jìn)入 _WaitSet 中，等待被喚醒。

ObjectMonitor() {     _header       = NULL;     _count        = 0; // 記錄線程獲取鎖的次數(shù)     _waiters      = 0,     _recursions   = 0;  //鎖的重入次數(shù)     _object       = NULL;     _owner        = NULL;  // 指向持有ObjectMonitor對(duì)象的線程     _WaitSet      = NULL;  // 處于wait狀態(tài)的線程，會(huì)被加入到_WaitSet     _WaitSetLock  = 0 ;     _Responsible  = NULL ;     _succ         = NULL ;     _cxq          = NULL ;     FreeNext      = NULL ;     _EntryList    = NULL ;  // 處于等待鎖block狀態(tài)的線程，會(huì)被加入到該列表     _SpinFreq     = 0 ;     _SpinClock    = 0 ;     OwnerIsThread = 0 ;   }

可以類比一個(gè)去醫(yī)院就診的例子[18]：

• 首先，患者在門診大廳前臺(tái)或自助掛號(hào)機(jī)進(jìn)行掛號(hào)；

• 隨后，掛號(hào)結(jié)束后患者找到對(duì)應(yīng)的診室就診：

  • 診室每次只能有一個(gè)患者就診；
  • 如果此時(shí)診室空閑，直接進(jìn)入就診；
  • 如果此時(shí)診室內(nèi)有其它患者就診，那么當(dāng)前患者進(jìn)入候診室，等待叫號(hào)；

• 就診結(jié)束后，走出就診室，候診室的下一位候診患者進(jìn)入就診室。

這個(gè)過程就和Monitor機(jī)制比較相似：

• 門診大廳：所有待進(jìn)入的線程都必須先在入口Entry Set掛號(hào)才有資格；
• 就診室：就診室**_Owner**里里只能有一個(gè)線程就診，就診完線程就自行離開
• 候診室：就診室繁忙時(shí)，進(jìn)入等待區(qū)（Wait Set），就診室空閑的時(shí)候就從**等待區(qū)（Wait Set）**叫新的線程

所以我們就知道了，同步是鎖住的什么東西：

• monitorenter，在判斷擁有同步標(biāo)識(shí) ACC_SYNCHRONIZED 搶先進(jìn)入此方法的線程會(huì)優(yōu)先擁有 Monitor 的 owner ，此時(shí)計(jì)數(shù)器 +1。
• monitorexit，當(dāng)執(zhí)行完退出后，計(jì)數(shù)器 -1，歸 0 后被其他進(jìn)入的線程獲得。

26.除了原子性，synchronized可見性，有序性，可重入性怎么實(shí)現(xiàn)？

synchronized怎么保證可見性？

• 線程加鎖前，將清空工作內(nèi)存中共享變量的值，從而使用共享變量時(shí)需要從主內(nèi)存中重新讀取最新的值。
• 線程加鎖后，其它線程無法獲取主內(nèi)存中的共享變量。
• 線程解鎖前，必須把共享變量的最新值刷新到主內(nèi)存中。

synchronized怎么保證有序性？

synchronized同步的代碼塊，具有排他性，一次只能被一個(gè)線程擁有，所以synchronized保證同一時(shí)刻，代碼是單線程執(zhí)行的。

因?yàn)閍s-if-serial語義的存在，單線程的程序能保證最終結(jié)果是有序的，但是不保證不會(huì)指令重排。

所以synchronized保證的有序是執(zhí)行結(jié)果的有序性，而不是防止指令重排的有序性。

synchronized怎么實(shí)現(xiàn)可重入的呢？

synchronized 是可重入鎖，也就是說，允許一個(gè)線程二次請(qǐng)求自己持有對(duì)象鎖的臨界資源，這種情況稱為可重入鎖。

synchronized 鎖對(duì)象的時(shí)候有個(gè)計(jì)數(shù)器，他會(huì)記錄下線程獲取鎖的次數(shù)，在執(zhí)行完對(duì)應(yīng)的代碼塊之后，計(jì)數(shù)器就會(huì)-1，直到計(jì)數(shù)器清零，就釋放鎖了。

之所以，是可重入的。是因?yàn)?synchronized 鎖對(duì)象有個(gè)計(jì)數(shù)器，會(huì)隨著線程獲取鎖后 +1 計(jì)數(shù)，當(dāng)線程執(zhí)行完畢后 -1，直到清零釋放鎖。

27.鎖升級(jí)？synchronized優(yōu)化了解嗎？

了解鎖升級(jí)，得先知道，不同鎖的狀態(tài)是什么樣的。這個(gè)狀態(tài)指的是什么呢？

Java對(duì)象頭里，有一塊結(jié)構(gòu)，叫Mark Word標(biāo)記字段，這塊結(jié)構(gòu)會(huì)隨著鎖的狀態(tài)變化而變化。

64 位虛擬機(jī) Mark Word 是 64bit，我們來看看它的狀態(tài)變化：

Mark Word存儲(chǔ)對(duì)象自身的運(yùn)行數(shù)據(jù)，如哈希碼、GC分代年齡、鎖狀態(tài)標(biāo)志、偏向時(shí)間戳（Epoch） 等。

synchronized做了哪些優(yōu)化？

在JDK1.6之前，synchronized的實(shí)現(xiàn)直接調(diào)用ObjectMonitor的enter和exit，這種鎖被稱之為重量級(jí)鎖。從JDK6開始，HotSpot虛擬機(jī)開發(fā)團(tuán)隊(duì)對(duì)Java中的鎖進(jìn)行優(yōu)化，如增加了適應(yīng)性自旋、鎖消除、鎖粗化、輕量級(jí)鎖和偏向鎖等優(yōu)化策略，提升了synchronized的性能。

• 偏向鎖：在無競(jìng)爭(zhēng)的情況下，只是在Mark Word里存儲(chǔ)當(dāng)前線程指針，CAS操作都不做。

• 輕量級(jí)鎖：在沒有多線程競(jìng)爭(zhēng)時(shí)，相對(duì)重量級(jí)鎖，減少操作系統(tǒng)互斥量帶來的性能消耗。但是，如果存在鎖競(jìng)爭(zhēng)，除了互斥量本身開銷，還額外有CAS操作的開銷。

• 自旋鎖：減少不必要的CPU上下文切換。在輕量級(jí)鎖升級(jí)為重量級(jí)鎖時(shí)，就使用了自旋加鎖的方式

• 鎖粗化：將多個(gè)連續(xù)的加鎖、解鎖操作連接在一起，擴(kuò)展成一個(gè)范圍更大的鎖。

• 鎖消除：虛擬機(jī)即時(shí)編譯器在運(yùn)行時(shí)，對(duì)一些代碼上要求同步，但是被檢測(cè)到不可能存在共享數(shù)據(jù)競(jìng)爭(zhēng)的鎖進(jìn)行消除。

鎖升級(jí)的過程是什么樣的？

鎖升級(jí)方向：無鎖–>偏向鎖—> 輕量級(jí)鎖—->重量級(jí)鎖，這個(gè)方向基本上是不可逆的。

我們看一下升級(jí)的過程：

偏向鎖：

偏向鎖的獲?。?/strong>

    // 創(chuàng)建非公平鎖     ReentrantLock lock = new ReentrantLock();     // 獲取鎖操作     lock.lock();     try {         // 執(zhí)行代碼邏輯     } catch (Exception ex) {         // ...     } finally {         // 解鎖操作         lock.unlock();     }

public ReentrantLock() {     sync = new NonfairSync();}

ReentrantLock lock = new ReentrantLock(true);--- ReentrantLock// true 代表公平鎖，false 代表非公平鎖public ReentrantLock(boolean fair) {     sync = fair ? new FairSync() : new NonfairSync();}

    public final int getAndIncrement() {         return unsafe.getAndAddInt(this, valueOffset, 1);     }

    public final int getAndAddInt(Object var1, long var2, int var4) {         int var5;         do {             var5 = this.getIntVolatile(var1, var2);         } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));          return var5;     }

    public static void main(String[] args) throws InterruptedException {         CountDownLatch countDownLatch = new CountDownLatch(5);          Thread 大喬 = new Thread(countDownLatch::countDown);         Thread 蘭陵王 = new Thread(countDownLatch::countDown);         Thread 安其拉 = new Thread(countDownLatch::countDown);         Thread 哪吒 = new Thread(countDownLatch::countDown);         Thread 鎧 = new Thread(() -> {             try {                 // 稍等，上個(gè)衛(wèi)生間，馬上到...                 Thread.sleep(1500);                 countDownLatch.countDown();             } catch (InterruptedException ignored) {}         });          大喬.start();         蘭陵王.start();         安其拉.start();         哪吒.start();         鎧.start();         countDownLatch.await();         System.out.println("所有玩家已經(jīng)就位！");     }

    public static void main(String[] args) throws InterruptedException {         CountDownLatch countDownLatch = new CountDownLatch(1);          Thread 大喬 = new Thread(() -> waitToFight(countDownLatch));         Thread 蘭陵王 = new Thread(() -> waitToFight(countDownLatch));         Thread 安其拉 = new Thread(() -> waitToFight(countDownLatch));         Thread 哪吒 = new Thread(() -> waitToFight(countDownLatch));         Thread 鎧 = new Thread(() -> waitToFight(countDownLatch));          大喬.start();         蘭陵王.start();         安其拉.start();         哪吒.start();         鎧.start();         Thread.sleep(1000);         countDownLatch.countDown();         System.out.println("敵方還有5秒達(dá)到戰(zhàn)場(chǎng)，全軍出擊！");     }      private static void waitToFight(CountDownLatch countDownLatch) {         try {             countDownLatch.await(); // 在此等待信號(hào)再繼續(xù)             System.out.println("收到，發(fā)起進(jìn)攻！");         } catch (InterruptedException e) {             e.printStackTrace();         }     }

public class SemaphoreTest {     private static final int THREAD_COUNT = 30;     private static ExecutorService threadPool = Executors.newFixedThreadPool(THREAD_COUNT);     private static Semaphore s = new Semaphore(10);      public static void main(String[] args) {         for (int i = 0; i < THREAD_COUNT; i++) {             threadPool.execute(new Runnable() {                 @Override                 public void run() {                     try {                         s.acquire();                         System.out.println("save data");                         s.release();                     } catch (InterruptedException e) {                     }                 }             });         }         threadPool.shutdown();     }}

public class ExchangerTest {     private static final Exchanger<String> exgr = new Exchanger<String>();     private static ExecutorService threadPool = Executors.newFixedThreadPool(2);      public static void main(String[] args) {         threadPool.execute(new Runnable() {             @Override             public void run() {                 try {                     String A = "銀行流水A"; // A錄入銀行流水?dāng)?shù)據(jù)                      exgr.exchange(A);                 } catch (InterruptedException e) {                 }             }         });         threadPool.execute(new Runnable() {             @Override             public void run() {                 try {                     String B = "銀行流水B"; // B錄入銀行流水?dāng)?shù)據(jù)                      String A = exgr.exchange("B");                     System.out.println("A和B數(shù)據(jù)是否一致：" + A.equals(B) + "，A錄入的是："                             + A + "，B錄入是：" + B);                 } catch (InterruptedException e) {                 }             }         });         threadPool.shutdown();     }}

  synchronized (PushProcessServiceImpl.class) {}

threadsPool.execute(new Runnable() {      @Override public void run() {          // TODO Auto-generated method stub }      });

Future<Object> future = executor.submit(harReturnValuetask); try { Object s = future.get(); } catch (InterruptedException e) {      // 處理中斷異常 } catch (ExecutionException e) {      // 處理無法執(zhí)行任務(wù)異常 } finally {      // 關(guān)閉線程池 executor.shutdown();}

1. 計(jì)算密集型一般推薦線程池不要過大，一般是CPU數(shù) + 1，+1是因?yàn)榭赡艽嬖?strong>頁缺失(就是可能存在有些數(shù)據(jù)在硬盤中需要多來一個(gè)線程將數(shù)據(jù)讀入內(nèi)存)。如果線程池?cái)?shù)太大，可能會(huì)頻繁的 進(jìn)行線程上下文切換跟任務(wù)調(diào)度。獲得當(dāng)前CPU核心數(shù)代碼如下：

Runtime.getRuntime().availableProcessors();

2. IO密集型：線程數(shù)適當(dāng)大一點(diǎn)，機(jī)器的Cpu核心數(shù)*2。
3. 混合型：可以考慮根絕情況將它拆分成CPU密集型和IO密集型任務(wù)，如果執(zhí)行時(shí)間相差不大，拆分可以提升吞吐量，反之沒有必要。

當(dāng)然，實(shí)際應(yīng)用中沒有固定的公式，需要結(jié)合測(cè)試和監(jiān)控來進(jìn)行調(diào)整。

53.有哪幾種常見的線程池？

面試常問，主要有四種，都是通過工具類Excutors創(chuàng)建出來的，需要注意，阿里巴巴《Java開發(fā)手冊(cè)》里禁止使用這種方式來創(chuàng)建線程池。

• newFixedThreadPool (固定數(shù)目線程的線程池)

• newCachedThreadPool (可緩存線程的線程池)

• newSingleThreadExecutor (單線程的線程池)

• newScheduledThreadPool (定時(shí)及周期執(zhí)行的線程池)

54.能說一下四種常見線程池的原理嗎？

前三種線程池的構(gòu)造直接調(diào)用ThreadPoolExecutor的構(gòu)造方法。

newSingleThreadExecutor

  public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {         return new FinalizableDelegatedExecutorService             (new ThreadPoolExecutor(1, 1,                                     0L, TimeUnit.MILLISECONDS,                                     new LinkedBlockingQueue<Runnable>(),                                     threadFactory));     }

線程池特點(diǎn)

• 核心線程數(shù)為1
• 最大線程數(shù)也為1
• 阻塞隊(duì)列是無界隊(duì)列LinkedBlockingQueue，可能會(huì)導(dǎo)致OOM
• keepAliveTime為0

工作流程：

• 提交任務(wù)
• 線程池是否有一條線程在，如果沒有，新建線程執(zhí)行任務(wù)
• 如果有，將任務(wù)加到阻塞隊(duì)列
• 當(dāng)前的唯一線程，從隊(duì)列取任務(wù)，執(zhí)行完一個(gè)，再繼續(xù)取，一個(gè)線程執(zhí)行任務(wù)。

適用場(chǎng)景

適用于串行執(zhí)行任務(wù)的場(chǎng)景，一個(gè)任務(wù)一個(gè)任務(wù)地執(zhí)行。

newFixedThreadPool

  public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {         return new ThreadPoolExecutor(nThreads, nThreads,                                       0L, TimeUnit.MILLISECONDS,                                       new LinkedBlockingQueue<Runnable>(),                                       threadFactory);     }

線程池特點(diǎn)：

• 核心線程數(shù)和最大線程數(shù)大小一樣
• 沒有所謂的非空閑時(shí)間，即keepAliveTime為0
• 阻塞隊(duì)列為無界隊(duì)列LinkedBlockingQueue，可能會(huì)導(dǎo)致OOM

工作流程：

• 提交任務(wù)
• 如果線程數(shù)少于核心線程，創(chuàng)建核心線程執(zhí)行任務(wù)
• 如果線程數(shù)等于核心線程，把任務(wù)添加到LinkedBlockingQueue阻塞隊(duì)列
• 如果線程執(zhí)行完任務(wù)，去阻塞隊(duì)列取任務(wù)，繼續(xù)執(zhí)行。

使用場(chǎng)景

FixedThreadPool 適用于處理CPU密集型的任務(wù)，確保CPU在長(zhǎng)期被工作線程使用的情況下，盡可能的少的分配線程，即適用執(zhí)行長(zhǎng)期的任務(wù)。

newCachedThreadPool

   public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {         return new ThreadPoolExecutor(0, Integer.MAX_VALUE,                                       60L, TimeUnit.SECONDS,                                       new SynchronousQueue<Runnable>(),                                       threadFactory);     }

線程池特點(diǎn)：

• 核心線程數(shù)為0
• 最大線程數(shù)為Integer.MAX_VALUE，即無限大，可能會(huì)因?yàn)闊o限創(chuàng)建線程，導(dǎo)致OOM
• 阻塞隊(duì)列是SynchronousQueue
• 非核心線程空閑存活時(shí)間為60秒

當(dāng)提交任務(wù)的速度大于處理任務(wù)的速度時(shí)，每次提交一個(gè)任務(wù)，就必然會(huì)創(chuàng)建一個(gè)線程。極端情況下會(huì)創(chuàng)建過多的線程，耗盡 CPU 和內(nèi)存資源。由于空閑 60 秒的線程會(huì)被終止，長(zhǎng)時(shí)間保持空閑的 CachedThreadPool 不會(huì)占用任何資源。

工作流程：

• 提交任務(wù)
• 因?yàn)闆]有核心線程，所以任務(wù)直接加到SynchronousQueue隊(duì)列。
• 判斷是否有空閑線程，如果有，就去取出任務(wù)執(zhí)行。
• 如果沒有空閑線程，就新建一個(gè)線程執(zhí)行。
• 執(zhí)行完任務(wù)的線程，還可以存活60秒，如果在這期間，接到任務(wù)，可以繼續(xù)活下去；否則，被銷毀。

適用場(chǎng)景

用于并發(fā)執(zhí)行大量短期的小任務(wù)。

newScheduledThreadPool

    public ScheduledThreadPoolExecutor(int corePoolSize) {         super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,               new DelayedWorkQueue());     }

線程池特點(diǎn)

• 最大線程數(shù)為Integer.MAX_VALUE，也有OOM的風(fēng)險(xiǎn)
• 阻塞隊(duì)列是DelayedWorkQueue
• keepAliveTime為0
• scheduleAtFixedRate() ：按某種速率周期執(zhí)行
• scheduleWithFixedDelay()：在某個(gè)延遲后執(zhí)行

工作機(jī)制

• 線程從DelayQueue中獲取已到期的ScheduledFutureTask（DelayQueue.take()）。到期任務(wù)是指ScheduledFutureTask的time大于等于當(dāng)前時(shí)間。
• 線程執(zhí)行這個(gè)ScheduledFutureTask。
• 線程修改ScheduledFutureTask的time變量為下次將要被執(zhí)行的時(shí)間。
• 線程把這個(gè)修改time之后的ScheduledFutureTask放回DelayQueue中（DelayQueue.add()）。

使用場(chǎng)景

周期性執(zhí)行任務(wù)的場(chǎng)景，需要限制線程數(shù)量的場(chǎng)景

使用無界隊(duì)列的線程池會(huì)導(dǎo)致什么問題嗎？

例如newFixedThreadPool使用了無界的阻塞隊(duì)列LinkedBlockingQueue，如果線程獲取一個(gè)任務(wù)后，任務(wù)的執(zhí)行時(shí)間比較長(zhǎng)，會(huì)導(dǎo)致隊(duì)列的任務(wù)越積越多，導(dǎo)致機(jī)器內(nèi)存使用不停飆升，最終導(dǎo)致OOM。

55.線程池異常怎么處理知道嗎？

在使用線程池處理任務(wù)的時(shí)候，任務(wù)代碼可能拋出RuntimeException，拋出異常后，線程池可能捕獲它，也可能創(chuàng)建一個(gè)新的線程來代替異常的線程，我們可能無法感知任務(wù)出現(xiàn)了異常，因此我們需要考慮線程池異常情況。

常見的異常處理方式：

56.能說一下線程池有幾種狀態(tài)嗎？

線程池有這幾個(gè)狀態(tài)：RUNNING,SHUTDOWN,STOP,TIDYING,TERMINATED。

   //線程池狀態(tài)    private static final int RUNNING    = -1 << COUNT_BITS;    private static final int SHUTDOWN   =  0 << COUNT_BITS;    private static final int STOP       =  1 << COUNT_BITS;    private static final int TIDYING    =  2 << COUNT_BITS;    private static final int TERMINATED =  3 << COUNT_BITS;

線程池各個(gè)狀態(tài)切換圖：

RUNNING

• 該狀態(tài)的線程池會(huì)接收新任務(wù)，并處理阻塞隊(duì)列中的任務(wù);
• 調(diào)用線程池的shutdown()方法，可以切換到SHUTDOWN狀態(tài);
• 調(diào)用線程池的shutdownNow()方法，可以切換到STOP狀態(tài);

SHUTDOWN

• 該狀態(tài)的線程池不會(huì)接收新任務(wù)，但會(huì)處理阻塞隊(duì)列中的任務(wù)；
• 隊(duì)列為空，并且線程池中執(zhí)行的任務(wù)也為空,進(jìn)入TIDYING狀態(tài);

STOP

• 該狀態(tài)的線程不會(huì)接收新任務(wù)，也不會(huì)處理阻塞隊(duì)列中的任務(wù)，而且會(huì)中斷正在運(yùn)行的任務(wù)；
• 線程池中執(zhí)行的任務(wù)為空,進(jìn)入TIDYING狀態(tài);

TIDYING

• 該狀態(tài)表明所有的任務(wù)已經(jīng)運(yùn)行終止，記錄的任務(wù)數(shù)量為0。
• terminated()執(zhí)行完畢，進(jìn)入TERMINATED狀態(tài)

TERMINATED

• 該狀態(tài)表示線程池徹底終止

57.線程池如何實(shí)現(xiàn)參數(shù)的動(dòng)態(tài)修改？

線程池提供了幾個(gè) setter方法來設(shè)置線程池的參數(shù)。

這里主要有兩個(gè)思路：

• 在我們微服務(wù)的架構(gòu)下，可以利用配置中心如Nacos、Apollo等等，也可以自己開發(fā)配置中心。業(yè)務(wù)服務(wù)讀取線程池配置，獲取相應(yīng)的線程池實(shí)例來修改線程池的參數(shù)。

• 如果限制了配置中心的使用，也可以自己去擴(kuò)展ThreadPoolExecutor，重寫方法，監(jiān)聽線程池參數(shù)變化，來動(dòng)態(tài)修改線程池參數(shù)。

線程池調(diào)優(yōu)了解嗎？

線程池配置沒有固定的公式，通常事前會(huì)對(duì)線程池進(jìn)行一定評(píng)估，常見的評(píng)估方案如下：

上線之前也要進(jìn)行充分的測(cè)試，上線之后要建立完善的線程池監(jiān)控機(jī)制。

事中結(jié)合監(jiān)控告警機(jī)制，分析線程池的問題，或者可優(yōu)化點(diǎn)，結(jié)合線程池動(dòng)態(tài)參數(shù)配置機(jī)制來調(diào)整配置。

事后要注意仔細(xì)觀察，隨時(shí)調(diào)整。

具體的調(diào)優(yōu)案例可以查看參考[7]美團(tuán)技術(shù)博客。

58.你能設(shè)計(jì)實(shí)現(xiàn)一個(gè)線程池嗎？

這道題在阿里的面試中出現(xiàn)頻率比較高

線程池實(shí)現(xiàn)原理可以查看 要是以前有人這么講線程池，我早就該明白了！ ，當(dāng)然，我們自己實(shí)現(xiàn)， 只需要抓住線程池的核心流程-參考[6]：

我們自己的實(shí)現(xiàn)就是完成這個(gè)核心流程：

• 線程池中有N個(gè)工作線程
• 把任務(wù)提交給線程池運(yùn)行
• 如果線程池已滿，把任務(wù)放入隊(duì)列
• 最后當(dāng)有空閑時(shí)，獲取隊(duì)列中任務(wù)來執(zhí)行

實(shí)現(xiàn)代碼[6]：

這樣，一個(gè)實(shí)現(xiàn)了線程池主要流程的類就完成了。

59.單機(jī)線程池執(zhí)行斷電了應(yīng)該怎么處理？

我們可以對(duì)正在處理和阻塞隊(duì)列的任務(wù)做事務(wù)管理或者對(duì)阻塞隊(duì)列中的任務(wù)持久化處理，并且當(dāng)斷電或者系統(tǒng)崩潰，操作無法繼續(xù)下去的時(shí)候，可以通過回溯日志的方式來撤銷正在處理的已經(jīng)執(zhí)行成功的操作。然后重新執(zhí)行整個(gè)阻塞隊(duì)列。

也就是說，對(duì)阻塞隊(duì)列持久化；正在處理任務(wù)事務(wù)控制；斷電之后正在處理任務(wù)的回滾，通過日志恢復(fù)該次操作；服務(wù)器重啟后阻塞隊(duì)列中的數(shù)據(jù)再加載。

并發(fā)容器和框架

關(guān)于一些并發(fā)容器，可以去看看 面渣逆襲：Java集合連環(huán)三十問 ，里面有CopyOnWriteList和ConcurrentHashMap這兩種線程安全容器類的問答。。

60.Fork/Join框架了解嗎？

Fork/Join框架是Java7提供的一個(gè)用于并行執(zhí)行任務(wù)的框架，是一個(gè)把大任務(wù)分割成若干個(gè)小任務(wù)，最終匯總每個(gè)小任務(wù)結(jié)果后得到大任務(wù)結(jié)果的框架。

要想掌握Fork/Join框架，首先需要理解兩個(gè)點(diǎn)，分而治之和工作竊取算法。

分而治之

Fork/Join框架的定義，其實(shí)就體現(xiàn)了分治思想：將一個(gè)規(guī)模為N的問題分解為K個(gè)規(guī)模較小的子問題，這些子問題相互獨(dú)立且與原問題性質(zhì)相同。求出子問題的解，就可得到原問題的解。

工作竊取算法

大任務(wù)拆成了若干個(gè)小任務(wù)，把這些小任務(wù)放到不同的隊(duì)列里，各自創(chuàng)建單獨(dú)線程來執(zhí)行隊(duì)列里的任務(wù)。

那么問題來了，有的線程干活塊，有的線程干活慢。干完活的線程不能讓它空下來，得讓它去幫沒干完活的線程干活。它去其它線程的隊(duì)列里竊取一個(gè)任務(wù)來執(zhí)行，這就是所謂的工作竊取。

工作竊取發(fā)生的時(shí)候，它們會(huì)訪問同一個(gè)隊(duì)列，為了減少竊取任務(wù)線程和被竊取任務(wù)線程之間的競(jìng)爭(zhēng)，通常任務(wù)會(huì)使用雙端隊(duì)列，被竊取任務(wù)線程永遠(yuǎn)從雙端隊(duì)列的頭部拿，而竊取任務(wù)的線程永遠(yuǎn)從雙端隊(duì)列的尾部拿任務(wù)執(zhí)行。

看一個(gè)Fork/Join框架應(yīng)用的例子，計(jì)算1~n之間的和：1+2+3+…+n

• 設(shè)置一個(gè)分割閾值，任務(wù)大于閾值就拆分任務(wù)
• 任務(wù)有結(jié)果，所以需要繼承RecursiveTask

public class CountTask extends RecursiveTask<Integer> {     private static final int THRESHOLD = 16; // 閾值     private int start;     private int end;      public CountTask(int start, int end) {         this.start = start;         this.end = end;     }      @Override     protected Integer compute() {         int sum = 0;         // 如果任務(wù)足夠小就計(jì)算任務(wù)         boolean canCompute = (end - start) <= THRESHOLD;         if (canCompute) {             for (int i = start; i <= end; i++) {                 sum += i;             }         } else {             // 如果任務(wù)大于閾值，就分裂成兩個(gè)子任務(wù)計(jì)算             int middle = (start + end) / 2;             CountTask leftTask = new CountTask(start, middle);             CountTask rightTask = new CountTask(middle + 1, end);             // 執(zhí)行子任務(wù)             leftTask.fork();             rightTask.fork(); // 等待子任務(wù)執(zhí)行完，并得到其結(jié)果             int leftResult = leftTask.join();             int rightResult = rightTask.join(); // 合并子任務(wù)             sum = leftResult + rightResult;         }         return sum;     }      public static void main(String[] args) {         ForkJoinPool forkJoinPool = new ForkJoinPool(); // 生成一個(gè)計(jì)算任務(wù)，負(fù)責(zé)計(jì)算1+2+3+4         CountTask task = new CountTask(1, 100); // 執(zhí)行一個(gè)任務(wù)         Future<Integer> result = forkJoinPool.submit(task);         try {             System.out.println(result.get());         } catch (InterruptedException e) {         } catch (ExecutionException e) {         }     }     }

ForkJoinTask與一般Task的主要區(qū)別在于它需要實(shí)現(xiàn)compute方法，在這個(gè)方法里，首先需要判斷任務(wù)是否足夠小，如果足夠小就直接執(zhí)行任務(wù)。如果比較大，就必須分割成兩個(gè)子任務(wù)，每個(gè)子任務(wù)在調(diào)用fork方法時(shí)，又會(huì)進(jìn)compute方法，看看當(dāng)前子任務(wù)是否需要繼續(xù)分割成子任務(wù)，如果不需要繼續(xù)分割，則執(zhí)行當(dāng)前子任務(wù)并返回結(jié)果。使用join方法會(huì)等待子任務(wù)執(zhí)行完并得到其結(jié)果。

推薦學(xué)習(xí)：《java教程》