1.你用過哪些集合類？

大公司最喜歡問的Java集合類面試題
40個Java集合面試問題和答案
java.util.Collections 是一個包裝類。它包含有各種有關集合操作的靜態多態方法。
java.util.Collection 是一個集合接口。它提供了對集合對象進行基本操作的通用接口方法。

Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│　└Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap

ArrayList、HashMap、TreeMap和HashTable類提供對元素的隨機訪問。

線程安全

Vector
HashTable(不允許插空值)

非線程安全

ArrayList
LinkedList
HashMap(允許插入空值)
HashSet
TreeSet
TreeMap(基于紅黑樹的Map實現)

2.你說說 arraylist 和 linkedlist 的區別？

ArrayList和LinkedList兩者都實現了List接口，但是它們之間有些不同。
（1）ArrayList是由Array所支持的基于一個索引的數據結構，所以它提供對元素的隨機訪問
（2）與ArrayList相比，在LinkedList中插入、添加和刪除一個元素會更快
（3）LinkedList比ArrayList消耗更多的內存，因為LinkedList中的每個節點存儲了前后節點的引用

3.HashMap 底層是怎么實現的？還有什么處理哈希沖突的方法？

處理哈希沖突的方法:

解決HashMap一般沒有什么特別好的方式，要不擴容重新hash要不優化沖突的鏈表結構

1.開放定地址法-線性探測法
2.開放定地址法-平方探查法
3.鏈表解決-可以用紅黑樹提高查找效率

image.png

HashMap簡介
HashMap 是一個散列表，它存儲的內容是鍵值對(key-value)映射。
HashMap 繼承于AbstractMap，實現了Map、Cloneable、java.io.Serializable接口。
HashMap 的實現不是同步的，這意味著它不是線程安全的,但可以用 Collections的synchronizedMap方法使HashMap具有線程安全的能力。它的key、value都可以為null。此外，HashMap中的映射不是有序的。
HashMap 的實例有兩個參數影響其性能：“初始容量” 和 “加載因子”。初始容量默認是16。默認加載因子是 0.75, 這是在時間和空間成本上尋求一種折衷。加載因子過高雖然減少了空間開銷，但同時也增加了查詢成本.
HashMap是數組+鏈表+紅黑樹（JDK1.8增加了紅黑樹部分）實現的,當鏈表長度太長（默認超過8）時，鏈表就轉換為紅黑樹.

image.png

Java8系列之重新認識HashMap
功能實現-方法

1. 確定哈希桶數組索引位置 :這里的Hash算法本質上就是三步：取key的hashCode值、高位運算、取模運算。

方法一：
static final int hash(Object key) {   //jdk1.8 & jdk1.7
     int h;
     // h = key.hashCode() 為第一步 取hashCode值
     // h ^ (h >>> 16)  為第二步 高位參與運算
     return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
方法二：
static int indexFor(int h, int length) {  //jdk1.7的源碼，jdk1.8沒有這個方法，但是實現原理一樣的
     return h & (length-1);  //第三步 取模運算
}

2. 分析HashMap的put方法

   
   
   image.png

3. 擴容機制：原來的兩倍

3.1 怎樣設計實現一個高效的線程安全的hashmap 。

方法一：通過Collections.synchronizedMap()返回一個新的Map，這個新的map就是線程安全的。 這個要求大家習慣基于接口編程，因為返回的并不是HashMap，而是一個Map的實現。
方法二：重新改寫了HashMap，具體的可以查看java.util.concurrent.ConcurrentHashMap. 這個方法比方法一有了很大的改進。（鎖分離）
方法一使用的是的synchronized方法,是一種悲觀鎖.在進入之前需要獲得鎖,確保獨享當前對象,然后做相應的修改/讀取.
方法二使用的是樂觀鎖(比如通過加個版本號信息，確保修改時版本號對應才修改),只有在需要修改對象時,比較和之前的值是否被人修改了,如果被其他線程修改了,那么就會返回失敗.鎖的實現,使用的是 NonfairSync. 這個特性要確保修改的原子性,互斥性,無法在JDK這個級別得到解決,JDK在此次需要調用JNI方法,而JNI則調用CAS指令來確保原子性與互斥性.

4.熟悉什么算法，還有說說他們的時間復雜度？

經典排序算法總結與實現

image.png

5.ArrayList和Vector的底層代碼和他們的增長策略,它們是如何進行擴容的？

ArrayList 默認數組大小是10，其中ensureCapacity擴容，trimToSize容量調整到適中，擴展后數組大小為（(原數組長度*1.5）與傳遞參數中較大者.
Vector的擴容，是可以指定擴容因子，同時Vector擴容策略是：1.原來容量的2倍,2.原來容量+擴容參數值。

---

詳細內容可以配合閱讀源碼

6.jvm 原理。程序運行區域劃分

問：Java運行時數據區域？
回答：包括程序計數器、JVM棧、本地方法棧、方法區、堆
問：方法區里存放什么？
本地方法棧：和jvm棧所發揮的作用類似，區別是jvm棧為jvm執行java方法（字節碼）服務，而本地方法棧為jvm使用的native方法服務。
JVM棧：局部變量表、操作數棧、動態鏈接、方法出口。
方法區：用于存儲已被虛擬機加載的類信息，常量、靜態變量、即時編譯器編譯后的代碼等。
堆：存放對象實例。

7.minor GC 與 Full GC，分別什么時候會觸發？ 。分別采用哪種垃圾回收算法？簡單介紹算法

GC（或Minor GC）：收集 生命周期短的區域(Young area)。
Full GC （或Major GC）：收集生命周期短的區域(Young area)和生命周期比較長的區域(Old area)對整個堆進行垃圾收集。
新生代通常存活時間較短基于Copying算法進行回收,將可用內存分為大小相等的兩塊，每次只使用其中一塊；當這一塊用完了，就將還活著的對象復制到另一塊上，然后把已使用過的內存清理掉。在HotSpot里，考慮到大部分對象存活時間很短將內存分為Eden和兩塊Survivor，默認比例為8:1:1。代價是存在部分內存空間浪費，適合在新生代使用；
老年代與新生代不同，老年代對象存活的時間比較長、比較穩定，因此采用標記(Mark)算法來進行回收,所謂標記就是掃描出存活的對象，然后再進行回收未被標記的對象，回收后對用空出的空間要么進行合并、要么標記出來便于下次進行分配，總之目的就是要減少內存碎片帶來的效率損耗。
在執行機制上JVM提供了串行GC(Serial MSC)、并行GC(Parallel MSC)和并發GC(CMS)。

Minor GC ，Full GC 觸發條件

• Minor GC觸發條件：當Eden區滿時，觸發Minor GC。

• Full GC觸發條件：

• （1）調用System.gc時，系統建議執行Full GC，但是不必然執行

• （2）老年代空間不足

• （3）方法去空間不足

• （4）通過Minor GC后進入老年代的平均大小大于老年代的可用內存

• （5）由Eden區、From Space區向To Space區復制時，對象大小大于To Space可用內存，則把該對象轉存到老年代，且老年代的可用內存小于該對象大小

8.HashMap 實現原理

在java編程語言中，最基本的結構就是兩種，一個是數組，另外一個是模擬指針（引用），所有的數據結構都可以用這兩個基本結構來構造的，HashMap也不例外。HashMap實際上是一個“鏈表散列”的數據結構，即數組和鏈表的結合體。

9.java.util.concurrent 包下使用過哪些

1.阻塞隊列 BlockingQueue( ArrayBlockingQueue, DelayQueue, LinkedBlockingQueue, SynchronousQueue,LinkedTransferQueue,LinkedBlockingDeque)
2.ConcurrentHashMap
3.Semaphore--信號量
4.CountDownLatch--閉鎖
5.CyclicBarrier--柵欄
6.Exchanger--交換機
7.Executor->ThreadPoolExecutor,ScheduledThreadPoolExecutor

Semaphore semaphore = new Semaphore(1);  
//critical section  
semaphore.acquire();  
...  
semaphore.release();

8.鎖 Lock--ReentrantLock,ReadWriteLock,Condition,LockSupport

Lock lock = new ReentrantLock();  
lock.lock();  
//critical section  
lock.unlock();

10.concurrentMap 和 HashMap 區別

1.hashMap可以有null的鍵，concurrentMap不可以有
2.hashMap是線程不安全的，在多線程的時候需要Collections.synchronizedMap(hashMap),ConcurrentMap使用了重入鎖保證線程安全。
3.在刪除元素時候，兩者的算法不一樣。
ConcurrentHashMap和Hashtable主要區別就是圍繞著鎖的粒度以及如何鎖,可以簡單理解成把一個大的HashTable分解成多個，形成了鎖分離。

11.信號量是什么，怎么使用?volatile關鍵字是什么？

信號量-semaphore：荷蘭著名的計算機科學家Dijkstra 于1965年提出的一個同步機制。是在多線程環境下使用的一種設施, 它負責協調各個線程, 以保證它們能夠正確、合理的使用公共資源。
整形信號量：表示共享資源狀態，且只能由特殊的原子操作改變整型量。
同步與互斥：同類進程為互斥關系（打印機問題），不同進程為同步關系(消費者生產者)。

使用volatile關鍵字是解決同步問題的一種有效手段。 java volatile關鍵字預示著這個變量始終是“存儲進入了主存”。更精確的表述就是每一次讀一個volatile變量，都會從主存讀取，而不是CPU的緩存。同樣的道理，每次寫一個volatile變量，都是寫回主存，而不僅僅是CPU的緩存。
Java 保證volatile關鍵字保證變量的改變對各個線程是可見的。

image.png

12.阻塞隊列了解嗎？怎么使用

image.png

image.png

阻塞隊列 (BlockingQueue)是Java util.concurrent包下重要的數據結構，BlockingQueue提供了線程安全的隊列訪問方式：當阻塞隊列進行插入數據時，如果隊列已滿，線程將會阻塞等待直到隊列非滿；從阻塞隊列取數據時，如果隊列已空，線程將會阻塞等待直到隊列非空。并發包下很多高級同步類的實現都是基于BlockingQueue實現的。

image.png

image.png

以ArrayBlockingQueue為例，我們先來看看代碼：

public void put(E e) throws InterruptedException {
    if (e == null) throw new NullPointerException();
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        while (count == items.length)
            notFull.await();
        enqueue(e);
    } finally {
        lock.unlock();
    }
}

從put方法的實現可以看出，它先獲取了鎖，并且獲取的是可中斷鎖，然后判斷當前元素個數是否等于數組的長度，如果相等，則調用notFull.await()進行等待，當被其他線程喚醒時，通過enqueue(e)方法插入元素，最后解鎖。

/**
* Inserts element at current put position, advances, and signals.
* Call only when holding lock.
*/
private void enqueue(E x) {
    // assert lock.getHoldCount() == 1;
    // assert items[putIndex] == null;
    final Object[] items = this.items;
    items[putIndex] = x;
    if (++putIndex == items.length) putIndex = 0;
    count++;
    notEmpty.signal();
}

插入成功后，通過notEmpty喚醒正在等待取元素的線程。

13.Java中的NIO，BIO，AIO分別是什么？

IO的方式通常分為幾種，同步阻塞的BIO、同步非阻塞的NIO、異步非阻塞的AIO

1.BIO，同步阻塞式IO，簡單理解：一個連接一個線程.BIO方式適用于連接數目比較小且固定的架構，這種方式對服務器資源要求比較高，并發局限于應用中，JDK1.4以前的唯一選擇，但程序直觀簡單易理解。

在JDK1.4之前，用Java編寫網絡請求，都是建立一個ServerSocket，然后，客戶端建立Socket時就會詢問是否有線程可以處理，如果沒有，要么等待，要么被拒絕。即：一個連接，要求Server對應一個處理線程。

2.NIO，同步非阻塞IO，簡單理解：一個請求一個線程.NIO方式適用于連接數目多且連接比較短（輕操作）的架構，比如聊天服務器，并發局限于應用中，編程比較復雜，JDK1.4開始支持。

NIO本身是基于事件驅動思想來完成的，其主要想解決的是BIO的大并發問題： 在使用同步I/O的網絡應用中，如果要同時處理多個客戶端請求，或是在客戶端要同時和多個服務器進行通訊，就必須使用多線程來處理。也就是說，將每一個客戶端請求分配給一個線程來單獨處理。這樣做雖然可以達到我們的要求，但同時又會帶來另外一個問題。由于每創建一個線程，就要為這個線程分配一定的內存空間（也叫工作存儲器），而且操作系統本身也對線程的總數有一定的限制。如果客戶端的請求過多，服務端程序可能會因為不堪重負而拒絕客戶端的請求，甚至服務器可能會因此而癱瘓。

3.AIO，異步非阻塞IO，簡單理解：一個有效請求一個線程.AIO方式使用于連接數目多且連接比較長（重操作）的架構，比如相冊服務器，充分調用OS參與并發操作，編程比較復雜，JDK7開始支持。

14.類加載機制是怎樣的

JVM中類的裝載是由ClassLoader和它的子類來實現的,Java ClassLoader是一個重要的Java運行時系統組件。它負責在運行時查找和裝入類文件的類。
類加載的五個過程：加載、驗證、準備、解析、初始化。

從類被加載到虛擬機內存中開始，到卸御出內存為止，它的整個生命周期分為7個階段，加載(Loading)、驗證(Verification)、準備(Preparation)、解析(Resolution)、初始化(Initialization)、使用(Using)、卸御(Unloading)。其中驗證、準備、解析三個部分統稱為連接。

15.什么是冪等性

所謂冪等，簡單地說，就是對接口的多次調用所產生的結果和調用一次是一致的。
那么我們為什么需要接口具有冪等性呢？設想一下以下情形：

• 在App中下訂單的時候，點擊確認之后，沒反應，就又點擊了幾次。在這種情況下，如果無法保證該接口的冪等性，那么將會出現重復下單問題。
• 在接收消息的時候，消息推送重復。如果處理消息的接口無法保證冪等，那么重復消費消息產生的影響可能會非常大。

16.有哪些 JVM 調優經驗

Jvm參數總結：http://linfengying.com/?p=2470

內存參數

GC參數

附圖：可以配合使用的收集器組合

image.png

上面有7中收集器，分為兩塊，上面為新生代收集器，下面是老年代收集器。如果兩個收集器之間存在連線，就說明它們可以搭配使用。

其他參數

17.分布式 CAP 了解嗎？

一致性(Consistency)
可用性(Availability)
分區容忍性(Partition tolerance)

18.Java中HashMap的key值要是為類對象則該類需要滿足什么條件？

需要同時重寫該類的hashCode()方法和它的equals()方法。

當程序試圖將一個 key-value 對放入 HashMap 中時，程序首先根據該 key 的 hashCode() 返回值決定該 Entry 的存儲位置：如果兩個 Entry 的 key 的 hashCode() 返回值相同，那它們的存儲位置相同。如果這兩個 Entry 的 key 通過 equals 比較返回 true，新添加 Entry 的 value 將覆蓋集合中原有 Entry 的 value，但 key 不會覆蓋。如果這兩個 Entry 的 key 通過 equals 比較返回 false，新添加的 Entry 將與集合中原有 Entry 形成 Entry 鏈，而且新添加的 Entry 位于 Entry 鏈的頭部——具體說明繼續看 addEntry() 方法的說明。

19.java 垃圾回收會出現不可回收的對象嗎？怎么解決內存泄露問題？怎么定位問題源？

一般不會有不可回收的對象，因為現在的GC會回收不可達內存。

20.終止線程有幾種方式？終止線程標記變量為什么是 valotile 類型？

1.線程正常執行完畢，正常結束
2.監視某些條件，結束線程的不間斷運行
3.使用interrupt方法終止線程

在定義exit時，使用了一個Java關鍵字volatile，這個關鍵字的目的是使exit同步，也就是說在同一時刻只能由一個線程來修改exit的值

21.用過哪些并發的數據結構？ cyclicBarrier 什么功能？信號量作用？數據庫讀寫阻塞怎么解決

• 主要有鎖機制，然后基于CAS的concurrent包。
• CyclicBarrier的字面意思是可循環使用（Cyclic）的屏障（Barrier）。它要做的事情是，讓一組線程到達一個屏障（也可以叫同步點）時被阻塞，直到最后一個線程到達屏障時，屏障才會開門，所有被屏障攔截的線程才會繼續干活。CyclicBarrier默認的構造方法是CyclicBarrier(int parties)，其參數表示屏障攔截的線程數量，每個線程調用await方法告訴CyclicBarrier我已經到達了屏障，然后當前線程被阻塞。
  CountDownLatch的計數器只能使用一次。而CyclicBarrier的計數器可以使用reset() 方法重置。
• Semaphore（信號量）是用來控制同時訪問特定資源的線程數量，它通過協調各個線程，以保證合理的使用公共資源。很多年以來，我都覺得從字面上很難理解Semaphore所表達的含義，只能把它比作是控制流量的紅綠燈，比如XX馬路要限制流量，只允許同時有一百輛車在這條路上行使，其他的都必須在路口等待，所以前一百輛車會看到綠燈，可以開進這條馬路，后面的車會看到紅燈，不能駛入XX馬路，但是如果前一百輛中有五輛車已經離開了XX馬路，那么后面就允許有5輛車駛入馬路，這個例子里說的車就是線程，駛入馬路就表示線程在執行，離開馬路就表示線程執行完成，看見紅燈就表示線程被阻塞，不能執行。

22.關于抽象類和接口的關系

簡言之抽象類是一種功能不全的類，接口只是一個抽象方法聲明和靜態不能被修改的數據的集合，兩者都不能被實例化。
從某種意義上說，接口是一種特殊形式的抽象類，在java語言中抽象類表示的是一種繼承關系，一個類只能繼承繼承一個抽象類，而一個類卻可以實現多個接口。在許多情況下，接口確實可以代替抽象類，如果你不需要刻意表達屬性上的繼承的話。

23.堆內存和棧內存的區別

寄存器：JVM內部虛擬寄存器，存取速度非常快，程序不可控制。
棧：保存局部變量的值包括：1.保存基本數據類型的值；2.保存引用變量，即堆區對象的引用(指針)。也可以用來保存加載方法時的幀。
堆：用來存放動態產生的數據，比如new出來的對象。注意創建出來的對象只包含屬于各自的成員變量，并不包括成員方法。因為同一個類的對象擁有各自的成員變量，存儲在各自的堆中，但是他們共享該類的方法，并不是每創建一個對象就把成員方法復制一次。
常量池：JVM為每個已加載的類型維護一個常量池，常量池就是這個類型用到的常量的一個有序集合。包括直接常量(基本類型，String)和對其他類型、方法、字段的符號引用(1)。池中的數據和數組一樣通過索引訪問。由于常量池包含了一個類型所有的對其他類型、方法、字段的符號引用，所以常量池在Java的動態鏈接中起了核心作用。常量池存在于堆中。
代碼段：用來存放從硬盤上讀取的源程序代碼。
數據段：用來存放static修飾的靜態成員（在java中static的作用就是說明該變量，方法，代碼塊是屬于類的還是屬于實例的）。

image.png

24.關于Java文件的內部類的解釋？匿名內部類是什么？如何訪問在其外面定義的變量？

java中的內部類總結
靜態內部類不能訪問外部類非靜態的成員

25.關于重載和重寫的區別

重載是overload，是一個類中同方法名的不同具體實現。然后重寫是override，是子類重寫父類中的方法。

26.String、StringBuffer與StringBuilder之間區別

1.三者在執行速度方面的比較：StringBuilder > StringBuffer > String

String：字符串常量
StringBuffer：字符串變量
StringBuilder：字符串變量

2.StringBuilder：線程非安全的,StringBuffer：線程安全的
**對于三者使用的總結： **
1.如果要操作少量的數據用 = String
2.單線程操作字符串緩沖區 下操作大量數據 = StringBuilder
3.多線程操作字符串緩沖區 下操作大量數據 = StringBuffer

27.運行時異常與一般異常有何異同？常見異常

Java提供了兩類主要的異常:runtime exception和checked exception
常見異常：NullPointerException、IndexOutOfBoundsException、ClassNotFoundException，IllegalArgumentException，ClassCastException(數據類型轉換異常)

28.error和exception有什么區別?

error 表示恢復不是不可能但很困難的情況下的一種嚴重問題。比如說內存溢出。不可能指望程序能處理這樣的情況。
exception表示一種設計或實現問題。也就是說，它表示如果程序運行正常，從不會發生的情況。

29.Java異常處理機制

image.png

1.捕獲異常：try、catch 和 finally
2.拋出異常
2.1. throws拋出異常

methodname throws Exception1,Exception2,..,ExceptionN  
{  }  

30.java中有幾種方法可以實現一個線程?

Java多線程學習（吐血超詳細總結）
40個Java多線程問題總結

1.class Thread1 extends Thread{},然后重寫run方法
2.class Thread2 implements Runnable{},然后重寫run方法
3.class Thread3 implements Callable<Integer>{},然后new FutureTask(thread3),再用new Thread(future)封裝。

class Thread1 extends Thread {
    private String name;
    public Thread1(String name) {
        this.name = name;
    }
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(name + "運行--->>>" + i);
        }
    }

    public static void main(String[] args) {
        Thread1 mTh11=new Thread1("A");
        Thread1 mTh12=new Thread1("B");
        mTh1.start();
        mTh2.start();
    }
}

class Thread2 implements Runnable {
    private String name;
    private int count = 15;
    public Thread2() {
    }
    public Thread2(String name) {
        this.name = name;
    }
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "運行  :  " + count--);
        }
    }
    public static void main(String[] args) {
        Thread2 mTh2 = new Thread2();
        new Thread(mTh2, "C").start();
        new Thread(mTh2, "D").start();
    }
}

class MyCallableThread implements Callable<Integer>{
        public Integer call() throws Exception {
        int i = 0;
        for(;i<100;i++)
        {
            System.out.println(Thread.currentThread().getName()+" "+i);
        }
        return i;
    }

    public static void main(String[] args) {
        MyCallableThread mct = new MyCallableThread();
        FutureTask<Integer> ft = new FutureTask<Integer>(mct);
        for(int i = 0;i < 100;i++)
        {
            System.out.println(Thread.currentThread().getName()+" 的循環變量i的值"+i);
            if(i==20)
            {
                new Thread(ft,"有返回值的線程").start();
            }
        }
        try
        {
            System.out.println("子線程的返回值："+ft.get());
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        } catch (ExecutionException e)
        {
            e.printStackTrace();
        }
    }
}

如果一個類繼承Thread，則不適合資源共享。但是如果實現了Runable接口的話，則很容易的實現資源共享。

31.Java中常用的類，包，接口。

class: 'Date','System','Calender','Math','ArrayList','HashMap'
package: 'java.lang','java.util','java.io','java.sql','java.net'
interface: 'Collection','Map','List','Runnable','Callable'

32.java在處理線程同步時，常用方法有：

1、synchronized關鍵字。
2、Lock顯示加鎖。
3、信號量Semaphore。
4、CAS算法
5、concurrent包

33.Spring IOC/AOP？

回答了IOC/DI、AOP的概念。
AOP（Aspect-OrientedProgramming，面向方面編程），可以說是OOP（Object-Oriented Programing，面向對象編程）的補充和完善。
OOP引入封裝、繼承和多態性等概念來建立一種對象層次結構，用以模擬公共行為的一個集合。當我們需要為分散的對象引入公共行為的時候，OOP則顯得無能為力。
也就是說，OOP允許你定義從上到下的關系，但并不適合定義從左到右的關系。例如日志功能。日志代碼往往水平地散布在所有對象層次中，而與它所散布到的對象的核心功能毫無關系。
對于其他類型的代碼，如安全性、異常處理和透明的持續性也是如此。這種散布在各處的無關的代碼被稱為橫切（cross-cutting）代碼，
在OOP設計中，它導致了大量代碼的重復，而不利于各個模塊的重用。
依賴注入(Dependency Injection)和控制反轉(Inversion of Control)是同一個概念。
當某個角色(可能是一個Java實例，調用者)需要另一個角色(另一個Java實例，被調用者)的協助時，在傳統的程序設計過程中，通常由調用者來創建被調用者的實例。
但在Spring里，創建被調用者的工作不再由調用者來完成，因此稱為控制反轉;創建被調用者 實例的工作通常由Spring容器來完成，然后注入調用者，因此也稱為依賴注入。
不管是依賴注入，還是控制反轉，都說明Spring采用動態、靈活的方式來管理各種對象。對象與對象之間的具體實現互相透明。
在理解依賴注入之前，看如下這個問題在各種社會形態里如何解決:一個人(Java實例，調用者)需要一把斧子(Java實例，被調用者)。

34.對JVM的垃圾回收的認識?

垃圾回收器的作用是查找和回收（清理）無用的對象。以便讓JVM更有效的使用內存。

35.進程與線程的區別，及其通信方式

線程與進程的區別及其通信方式
區別
1.一個程序至少有一個進程,一個進程至少有一個線程.
2.進程在執行過程中擁有獨立的內存單元，而多個線程共享內存
3.線程是進程的一個實體,是CPU調度和分派的基本單位

• 進程間通信

1.管道（Pipe）及有名管道（named pipe）
2.信號（Signal）
3.消息隊列（Message）
4.共享內存
5.信號量（semaphore）
6.套接口（Socket）

36.JVM如何GC，新生代，老年代，持久代，都存儲哪些東西？

JVM的GC算法有：引用計數器算法，根搜索方法

新生成的對象首先都是放在年輕代的。年輕代的目標就是盡可能快速的收集掉那些生命周期短的對象。

在年輕代中經歷了N次垃圾回收后仍然存活的對象，就會被放到年老代中。因此，可以認為年老代中存放的都是一些生命周期較長的對象。

持久代主要存放的是Java類的類信息

37.JVM分為哪些區，每一個區干嘛的？

問：Java運行時數據區域？
回答：包括程序計數器、JVM棧、本地方法棧、方法區、堆
問：方法區里存放什么？
本地方法棧：和jvm棧所發揮的作用類似，區別是jvm棧為jvm執行java方法（字節碼）服務，而本地方法棧為jvm使用的native方法服務。
JVM棧：局部變量表、操作數棧、動態鏈接、方法出口。
方法區：用于存儲已被虛擬機加載的類信息，常量、靜態變量、即時編譯器編譯后的代碼等。
堆：存放對象實例。

38.GC用的引用可達性分析算法中，哪些對象可作為GC Roots對象？

• 虛擬機棧（棧幀中的本地變量表）中引用的對象；
• 方法區中類靜態屬性引用的對象；
• 方法區中常量引用的對象；
• 本地方法棧中JNI（即一般說的Native方法）引用的對象

39.用什么工具調試程序？jmap、jstack,JConsole，用過嗎？

虛擬機性能監控與調優實戰--博客

40.線程池用過嗎？

線程池--并發編程網 - ifeve.com

線程池（Thread Pool）對于限制應用程序中同一時刻運行的線程數很有用。因為每啟動一個新線程都會有相應的性能開銷，每個線程都需要給棧分配一些內存等等。

我們可以把并發執行的任務傳遞給一個線程池，來替代為每個并發執行的任務都啟動一個新的線程。只要池里有空閑的線程，任務就會分配給一個線程執行。在線程池的內部，任務被插入一個阻塞隊列（Blocking Queue ），線程池里的線程會去取這個隊列里的任務。當一個新任務插入隊列時，一個空閑線程就會成功的從隊列中取出任務并且執行它。

41.操作系統如何進行分頁調度？--要考LRU

1.最講置換原則-OPT
2.先進先出原則-FIFO
3.最近最少使用置換算法-LRU
4.時鐘置換算法

//擴展一下LinkedHashMap這個類，讓他實現LRU算法
class LRULinkedHashMap<K,V> extends LinkedHashMap<K,V>{
    //定義緩存的容量
    private int capacity;
    private static final long serialVersionUID = 1L;
    //帶參數的構造器
    LRULinkedHashMap(int capacity){
        //調用LinkedHashMap的構造器，傳入以下參數
        super(16,0.75f,true);
        //傳入指定的緩存最大容量
        this.capacity=capacity;
    }
    //實現LRU的關鍵方法，如果map里面的元素個數大于了緩存最大容量，則刪除鏈表的頂端元素
    @Override
    public boolean removeEldestEntry(Map.Entry<K, V> eldest){
        System.out.println(eldest.getKey() + "=" + eldest.getValue());
        return size()>capacity;
    }
}

42.講講LinkedHashMap

Java8 LinkedHashMap工作原理及實現

LinkedHashMap是通過哈希表和鏈表實現的，它通過維護一個鏈表來保證對哈希表迭代時的有序性，而這個有序是指鍵值對插入的順序。

LinkedHashMap 的大致實現如下圖所示，當然鏈表和哈希表中相同的鍵值對都是指向同一個對象，這里把它們分開來畫只是為了呈現出比較清晰的結構。

image.png

LinkedHashMap是Hash表和鏈表的實現，并且依靠著雙向鏈表保證了迭代順序是插入的順序。

三個重點實現的函數

在HashMap中提到了下面的定義：

// Callbacks to allow LinkedHashMap post-actions
//1.把當前節點e移至鏈表的尾部。因為使用的是雙向鏈表，所以在尾部插入可以以O（1）的時間復雜度來完成。并且只有當accessOrder設置為true時，才會執行這個操作。在HashMap的putVal方法中，就調用了這個方法。
void afterNodeAccess(Node<K,V> p) { }
//2.afterNodeInsertion方法是在哈希表中插入了一個新節點時調用的，它會把鏈表的頭節點刪除掉，刪除的方式是通過調用HashMap的removeNode方法。通過afterNodeInsertion方法和afterNodeAccess方法，是不是就可以簡單的實現一個基于最近最少使用（LRU）的淘汰策略了？當然，我們還要重寫removeEldestEntry方法，因為它默認返回的是false。
void afterNodeInsertion(boolean evict) { }
//3.這個方法是當HashMap刪除一個鍵值對時調用的，它會把在HashMap中刪除的那個鍵值對一并從鏈表中刪除，保證了哈希表和鏈表的一致性。
void afterNodeRemoval(Node<K,V> p) { }

LinkedHashMap繼承于HashMap，因此也重新實現了這3個函數，顧名思義這三個函數的作用分別是：節點訪問后、節點插入后、節點移除后做一些事情。

43.線程同步與阻塞的關系？同步一定阻塞嗎？阻塞一定同步嗎？,同步和異步有什么區別？

同步與非同步：主要是保證互斥的訪問臨界資源的情況
阻塞與非阻塞：主要是從 CPU 的消耗上來說的

44.int與Integer的區別，分別什么場合使用

1、Integer是int提供的封裝類，而int是Java的基本數據類型
2、Integer默認值是null，而int默認值是0；
3、聲明為Integer的變量需要實例化，而聲明為int的變量不需要實例化；
4、Integer是對象，用一個引用指向這個對象，而int是基本類型，直接存儲數值。

int是基本數據類型，Integer是包裝類，類似HashMap這樣的結構必須使用包裝類，因為包裝類繼承自Object,都需要實現HashCode，所以可以使用在HashMap這類數據結構中。

45.RPC的詳細過程

RPC主要的重點有：
動態代理,主要是invoke反射原理
序列化,使用Thrift的效率高
通信方式,使用Netty的NIO能提高效率
服務發現,使用zookeeper可以實現

• 1）服務消費方（client）調用以本地調用方式調用服務；
• 2）client stub接收到調用后負責將方法、參數等組裝成能夠進行網絡傳輸的消息體；
• 3）client stub找到服務地址，并將消息發送到服務端；
• 4）server stub收到消息后進行解碼；
• 5）server stub根據解碼結果調用本地的服務；
• 6）本地服務執行并將結果返回給server stub；
• 7）server stub將返回結果打包成消息并發送至消費方；
• 8）client stub接收到消息，并進行解碼；
• 9）服務消費方得到最終結果。