常見面試題

時間 2019-11-12

原文原文鏈接

1：hashmap的原理：http://www.javashuo.com/article/p-wccjhppe-ck.htmlhtml

HashMap是基於hashing的原理，咱們使用put(key, value)存儲對象到HashMap中，使用get(key)從HashMap中獲取對象。當咱們給put()方法傳遞鍵和值時，咱們先對鍵調用hashCode()方法，返回的hashCode用於找到bucket位置來儲存Entry對象。」這裏關鍵點在於指出，HashMap是在bucket中儲存鍵對象和值對象，做爲Map.Entry。java

當hashcode相同時：mysql

回答「由於hashcode相同，因此它們的bucket位置相同，‘碰撞’會發生。由於HashMap使用鏈表存儲對象，這個Entry(包含有鍵值對的Map.Entry對象)會存儲在鏈表中。」這個答案很是的合理，雖然有不少種處理碰撞的方法，這種方法是最簡單的，也正是HashMap的處理方法。linux

爲何默認初始化桶數組大小爲16，爲何加載因子的大小爲0.75,這兩個值的選取有什麼特色。

經過看上面的代碼咱們能夠知道這兩個值主要影響的threshold的大小，這個值的數值是當前桶數組需不須要擴容的邊界大小， threshold=initialCapacity*loadFactor，桶中的鍵值對超過這個界限就把桶的容量變大。git

咱們都知道桶數組若是擴容，會申請內存空間，而後把原桶中的元素複製進新的桶數組中，這是一個比較耗時的過程。既然這樣，那爲什麼不把這兩個值都設置大一些呢，threshold是兩個數的乘積，設置大一些就不那麼容易會進行擴容了啊。github

緣由是這樣的，若是桶初始化桶數組設置太大，就會浪費內存空間，16是一個折中的大小，既不會像1，2，3那樣放幾個元素就擴容，也不會像幾千幾萬那樣能夠只會利用一點點空間從而形成大量的浪費。web

加載因子設置爲0.75而不是1，是由於設置過大，桶中鍵值對碰撞的概率就會越大，同一個桶位置可能會存放好幾個value值，這樣就會增長搜索的時間，性能降低，設置太小也不合適，若是是0.1，那麼10個桶，threshold爲1，你放兩個鍵值對就要擴容，太浪費空間了。redis

在擴容的時候, 也是直接乘以2進行擴容, 保證仍是2的n次方 .算法

擴容時，當hashmap的長度爲length = 2^n時，不一樣的hash值發生碰撞的機率比較小，這樣就會使得數據在table數組中分佈較均勻，查詢速度也較快。spring

由於相同位數數字與11111111111進行與運算都不一樣。

咱們回到indexFor方法，該方法僅有一條語句：h&(length - 1)，由於求在hashmap中的位置時就是hashcode%length 而 h & (length - 1) == h % length」這句話除了上面的取模運算外還有一個很是重要的責任：均勻分佈table數據和充分利用空間。

這裏咱們假設length爲16(2^n)和15，h爲五、六、7。

(這裏的h表示的根據key算的hash值，這個indexFor方法是要在數組上給當前數據找個落腳點，好存放當前數據。)

當length=15時，6和7的結果同樣，這樣表示他們在table存儲的位置是相同的，也就是產生了碰撞，六、7就會在一個位置造成鏈表，這樣就會致使查詢速度下降。誠然這裏只分析三個數字不是不少，那麼咱們就看0-15。

從上面的圖表中咱們看到總共發生了8次碰撞，同時發現浪費的空間很是大，有一、三、五、七、九、十一、1三、15處沒有記錄，也就是沒有存放數據。這是由於他們在與14進行&運算時，獲得的結果最後一位永遠都是0，即000一、00十一、010一、01十一、100一、10十一、110一、1111位置處是不可能存儲數據的，空間減小，進一步增長碰撞概率，這樣就會致使查詢速度慢。而當length = 16時，length – 1 = 15 即1111，那麼進行低位&運算時，值老是與原來hash值相同，而進行高位運算時，其值等於其低位值。

因此說當length = 2^n時，不一樣的hash值發生碰撞的機率比較小，這樣就會使得數據在table數組中分佈較均勻，查詢速度也較快。

爲何hashmap最大設置爲2^31，由於考慮到32爲操做系統內存最大爲2^32，當對2^31進行擴容時，首先要建立一個更大的map出來，內存不夠用了

4GB= 2^32 Byte啊

ConcurrentHashMap 使用鎖分段技術，分紅16個段，修改哪一個段，就獲取哪一個段的鎖。

2：從瀏覽器輸入url到加載出頁面，都經歷了什麼，例如輸入www.baidu.com https://segmentfault.com/a/1190000003925803

假設本身的主機已經聯網，省略了廣播到dhcp肯定本機ip和本地dns服務器ip的步驟

輸入url, 首先要解析域名爲對應的ip地址，若是2.2失敗就進行2.3....

2.1：查詢瀏覽器dns緩存

2.2: 查詢操做系統的dns緩存

2.3：搜索操做系統的hosts文件，維護了一張域名與ip的對應表

2.4：向本地dns服務器發出請求，查詢本地dns服務器緩存，成功率爲80%

2.5 向跟dns服務器查詢，跟dns服務器返回返com 域的頂級域名服務器的地址。

2.6 向com域的頂級域名服務器發出查詢請求，返回baidu.com的dns服務器地址

2.7：向baidu.com發送查詢請求，返回www.baidu.com 的ip地址

知道了服務器的 IP 地址，下面便開始與服務器建立鏈接了

2.8 與服務器簡歷tcp鏈接，三次握手，可靠數據鏈接（檢驗和，定時，序號，窗口流水線，確定確認，否認確認）

2.8.1 客戶端向服務器發起請求鏈接信號，帶有標緻爲SYN=1,客戶端序號

2.8.2 服務器接收到信號，向客戶端返回確認信號，標緻位SYN=1 ，服務端確認號=客戶端序號+1，服務端序號

2.8.3 客戶端接收到服務器的確認信號，向服務器發送確認信號，能夠帶有數據，標緻位改變，SYN=0 客戶端確認號=服務端序號+1，客戶端序號=服務端確認號

當服務器與主機創建了鏈接以後，下面主機便與服務器進行通訊。網頁請求是一個單向請求的過程，便是一個主機向服務器請求數據，服務器返回相應的數據的過程。

2.9瀏覽器根據 URL 內容生成 HTTP 請求，請求中包含請求文件的位置、請求文件的方式等等；

2.10服務器接到請求後，會根據 HTTP 請求中的內容來決定如何獲取相應的 HTML 文件；

2.11服務器將獲得的 HTML 文件發送給瀏覽器；

2.12在瀏覽器尚未徹底接收 HTML 文件時便開始渲染、顯示網頁；

2.13在執行 HTML 中代碼時，根據須要，瀏覽器會繼續請求圖片、CSS、JavsScript等文件，過程同請求 HTML ；

2.14 斷開鏈接--四次揮手

2.14.1主機向服務器發送一個斷開鏈接的請求（不早了，我該走了）；

2.14.2服務器接到請求後發送確認收到請求的信號（知道了）；尚未斷開鏈接

2.14.3服務器向主機發送斷開通知（我也該走了）；

2.14.4主機接到斷開通知後斷開鏈接並反饋一個確認信號（嗯，好的），服務器收到確認信號後斷開鏈接；

經歷的協議過程：dhcp>dns>tcp鏈接>http>tcp斷開

3：Rpc遠程調用 http://www.javashuo.com/article/p-ggjyumtm-cn.html

Rpc服務器提供一個接口，讓客戶端調用，服務器的具體實現類方法能夠修改。比較靈活

4：設計模式 http://www.cnblogs.com/foryang/p/5849402.html

4.1：責任鏈，一個接口handle, 爲每個handle的實現類設置後繼，當沒有後繼時，就結束

4.2：建造者：一個統領，將構建產品的步驟分步進行。統領者指導建造者一步一步構建產品對象。

4.3：分紅產品族，當一個對象中的部件相互依賴時，例如寶馬的輪胎和寶馬的輪廓才能適配，使用奔馳的輪廓就不行，那麼寶馬分爲一個產品族。這個工廠專門生產寶馬。

5：spring aop 和ioc http://www.javashuo.com/article/p-rmjdpvxu-ce.html

http://jinnianshilongnian.iteye.com/blog/1413846

http://www.javashuo.com/article/p-xzmpncuh-n.html

5.1 :spring ioc 是一個容器，管理各個bean對象。管理的時候是經過描述建立對象，經過配置管理，修改對象。

5.2 最主要是完成了對象的建立和依賴的管理注入等等

5.3 SpringIOC容器管理了咱們定義的各類Bean對象及其相互的關係

5.4 IoC容器的初始化包括BeanDefinition的Resource定位、載入和註冊這三個基本的過程。

//向IoC容器註冊BeanDefinition 
        registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());   //將解析xml事後的bean對象註冊近容器

//若是解析的BeanDefinition有別名，向容器爲其註冊別名  String[] aliases = definitionHolder.getAliases(); if (aliases != null) { for (String aliase : aliases) { registry.registerAlias(beanName, aliase); } }

最後，Bean定義資源文件中配置的Bean被解析事後，已經註冊到IoC容器中，被容器管理起來，真正完成了IoC容器初始化所作的所有工做。現在IoC容器中已經創建了整個Bean的配置信息，這些BeanDefinition信息已經可使用，而且能夠被檢索，IoC容器的做用就是對這些註冊的Bean定義信息進行處理和維護。這些的註冊的Bean定義信息是IoC容器控制反轉的基礎，正是有了這些註冊的數據，容器才能夠進行依賴注入。Spring Bean是單例的：http://www.javashuo.com/article/p-cudrgzdh-hn.html

5.5：控制反轉是一種經過描述（在java中能夠是XML或者註解）並經過第三方去產生或獲取特定對象的方式。

潛意識裏以爲對象須要本身建立，事實上這並非你真正的須要，由於也許你對某一領域並不精通，這個時候能夠把建立對象的主動權交給別人，這就是控制反轉

Spring Ioc容器能夠容納咱們所開發的各類Bean, 而且咱們能夠從中獲取各類發佈在Spring Ioc容器裏的Bean, 而且經過描述能夠獲得它。

例子：假如如今是共產主義社會，本身是覺得蛋糕師，那麼社會上的各類東西咱們均可以得到，這些東西就做爲Bean注入到了Spring Ioc容器中，本身生產的各類蛋糕Bean也注入到了Spring Ioc容器中，若是咱們想要一輛奔馳車，咱們只須要經過描述想要的奔馳車配置（例如四個輪，2.0T），就能夠獲得一輛奔馳車，咱們並不須要關注製造奔馳車的細節（例如螺絲怎麼擰的）。一樣，別人也能夠經過描述拿到本身作的蛋糕bean

IOC和DI 就是講對象的建立，控制，依賴管理交給IOC容器。

5.2：spring aop 管理切面上某些對象之間的協做，當多個對象，在某一點相互影響時，須要定義一個切面，來協調這幾個對象在這一點的操做。

AOP 1：對多個對象產生影響的行爲進行封裝成一個切面（不少方法（切入點）），2：對方法進行加強

https://www.cnblogs.com/zhaozihan/p/5953063.html

http://www.javashuo.com/article/p-dxbtymsz-hh.html

Spring AOP 經常使用於數據庫事務的編程

spring aop 將業務代碼(一個方法，service層，包含多個對象的相互協做)經過動態代理織入到相應的位置，動態代理中invoke方法中 method.invoke(obj, objects)處; 業務先後的邏輯由攔截器（或固定的實現，例如數據庫鏈接，異常處理）實現。 https://github.com/1367356/GradleTestUseSubModule/tree/master/SpringAOPTheory/src/main/java/com/li

6: innodb和imysam數據庫引擎

Innodb引擎

Innodb引擎提供了對數據庫ACID事務的支持，而且實現了SQL標準的四種隔離級別。該引擎還提供了行級鎖和外鍵約束，它的設計目標是處理大容量數據庫系統，它自己其實就是基於MySQL後臺的完整數據庫系統，MySQL運行時Innodb會在內存中創建緩衝池，用於緩衝數據和索引。可是該引擎不支持FULLTEXT類型的索引，並且它沒有保存表的行數，當SELECT COUNT(*) FROM TABLE時須要掃描全表。當須要使用數據庫事務時，該引擎固然是首選。因爲鎖的粒度更小，寫操做不會鎖定全表，因此在併發較高時，使用Innodb引擎會提高效率。可是使用行級鎖也不是絕對的，若是在執行一個SQL語句時MySQL不能肯定要掃描的範圍，InnoDB表一樣會鎖全表。

MyIASM引擎

MyIASM是MySQL默認的引擎，可是它沒有提供對數據庫事務的支持，也不支持行級鎖和外鍵，所以當INSERT(插入)或UPDATE(更新)數據時即寫操做須要鎖定整個表，效率便會低一些。不過和Innodb不一樣，MyIASM中存儲了表的行數，因而SELECT COUNT(*) FROM TABLE時只須要直接讀取已經保存好的值而不須要進行全表掃描。若是表的讀操做遠遠多於寫操做且不須要數據庫事務的支持，那麼MyIASM也是很好的選擇。

主要區別：

一、MyIASM是非事務安全的，而InnoDB是事務安全的

二、MyIASM鎖的粒度是表級的，而InnoDB支持行級鎖

三、MyIASM支持全文類型索引，而InnoDB不支持全文索引

四、MyIASM相對簡單，效率上要優於InnoDB，小型應用能夠考慮使用MyIASM

五、MyIASM表保存成文件形式，跨平臺使用更加方便

應用場景：

一、MyIASM管理非事務表，提供高速存儲和檢索以及全文搜索能力，若是再應用中執行大量select操做，應該選擇MyIASM

二、InnoDB用於事務處理，具備ACID事務支持等特性，若是在應用中執行大量insert和update操做，應該選擇InnoDB

7：mybatis原理 https://www.cnblogs.com/luoxn28/p/6417892.html

mybatis執行過程，

1：首先讀取配置文件 XMLConfigBuilder（建造者模式，一個統領）對配置文件進行解析，生成Configuraiton對象（單例）。

　　2：經過Configuration 對象生成SqlSessionFactory,

3：SqlSessionFactory 用於生成SqlSession.

4：生成SqlSession以後，使用SqlSession生成一個UserMapper的代理對象

UserMapper mapper = sqlSession.getMapper(UserMapper.class);  //建立UserMapper的代理對象
//建立過程當中判斷UserMapper是否是一個類，若是不是，須要用MapperMethod.excute(SqlSession sqlsession,Object[] obj) 去建立動態代理對象。
//建立過程當中將sqlSession的方法加入到了invoke中。
//那麼調用代理對象mapper方法的時候，就調用sqlSession中的方法，也就是sql語句。   SqlSession至關於一個UserMapper的實現類，用戶本身去寫sqlSession(sql語句)裏面的業務

//SqlSession 包含了執行sql所須要的全部方法，能夠經過SqlSession實例直接運行映射的sql語句，完成對數據的正刪改查和事務的提交等，用完以後關閉SqlSession

8：redis 緩存數據庫，以key-value形式結構進行存儲

優勢：數據結構豐富（字符串，列表，hash，集合，有序集合），可持久化，都是原子操做

9：樂觀鎖，悲觀鎖

悲觀鎖：假定會發生併發衝突，屏蔽一切可能違反數據完整性的操做。[1]
樂觀鎖：假設不會發生併發衝突，只在提交操做時檢查是否違反數據完整性。[1] 樂觀鎖不能解決髒讀的問題。

10： kmp 算法：http://www.javashuo.com/article/p-sqquamym-gz.html

http://www.cnblogs.com/tangzhengyue/p/4315393.html

10：linux下mysql備份命令：

一，數據庫的備份與導入

1)，數據庫的備份

1.導出整個數據庫
mysqldump -u 用戶名 -p 數據庫名 > 導出的文件名
例：mysqldump -u dbadmin -p myblog > /home/zhangy/blog/database_bak/myblog.sql

2.導出一個表
mysqldump -u 用戶名 -p 數據庫名表名> 導出的文件名
例：mysqldump -u dbadmin -p myblog wp_users> /home/zhangy/blog/database_bak/blog_users.sql

3.導出一個數據庫結構
mysqldump -u dbadmin -p -d --add-drop-table myblog > /home/zhangy/blog/database_bak/blog_struc.sql
說明：-d 沒有數據 --add-drop-table 在每一個create語句以前增長一個drop table

4.導出數據庫一個表結構
mysqldump -u dbadmin -p -d --add-drop-table myblog wp_users> /home/zhangy/blog/database_bak/blog_users_struc.sql
說明：-d 沒有數據 --add-drop-table 在每一個create語句以前增長一個drop table

2)，數據庫的導入

1，用 mysqldump 備份出來的文件是一個能夠直接倒入的 SQL 腳本，有兩種方法能夠將數據導入。
例如：
#/usr/local/mysql/bin/mysql -u root -p ***** myblog < /home/zhangy/blog/database_bak/myblog.sql

這種方法，我之前常常如今不多用了，由於很容易產生亂碼，由於：

a,導出數據庫時，你若是忘了設置導出字符集的話，在導入的時候，就有可能會出問題.

b,假如，你導出時設置導出時設置了utf8的編碼，可是你又把你的數據庫如今的字符集改爲了gb2312的.這樣又會亂碼。

2，用 source 語句
例如：

mysql -u dbadmin -p

use myblog;

set names utf8; #這裏的字符集根你的將要導入的數據庫的字符集一至。

source /home/zhangy/blog/database_bak/myblog.sql;

11： socket編程

兩個程序（進程）運行時，它們經過從套接字讀出和寫入數據彼此之間進行通訊。

網絡應用程序，經過socket進行通訊。 socket將發送方的數據經過socket通訊（指定IP, 端口，協議）傳遞到接收方。

網絡層的「ip地址」能夠惟一標識網絡中的主機，而傳輸層的「協議+端口」能夠惟一標識主機中的應用程序（進程）。這樣利用三元組（ip地址，協議，端口）就能夠標識網絡的進程了，網絡中的進程通訊就能夠利用這個標誌與其它進程進行交互。

網絡中的進程是經過socket來通訊的

https://blog.csdn.net/m0_37947204/article/details/80489431

http://www.javashuo.com/article/p-drqmpbyr-gs.html

https://www.cnblogs.com/wangcq/p/3520400.html

12：爲何有進程了，還要有線程

由於進程是系統分配資源的最小單位，進程切換開銷大。

線程容許在同一個進程中同時存在多個程序控制流，線程會共享進程範圍內的資源。

緣由：線程是比進程更輕量級的調度執行單位。線程的引入，能夠把一個進程的資源分配和執行調度分開，各個線程便可以共享進程資源（內存地址，文件I/O等），又能夠獨立調度（線程是CPU調度的基本單位）。

13:多路複用和多路分解

多路複用：將多個進程的套接字的數據取出，爲各個數據添加上協議（ip，端口號），組成分組，發送出去。

多路分解：將套接字中的數據分解，發給各個進程，叫作多路分解。

IO多路複用：就是多個客戶端線程發送過來IO請求，來的都放進來，而不是每一個鏈接爲其開啓一個服務端進程。服務端將其放到一個隊列中，而後服務端一個線程對這個隊列進行處理。處理完返回。至關於一個事件循環Event loop.

後臺就一個線程，避免了線程切換和後天線程搶奪資源，可能單cpu

14：校驗和

一個十六進制數，

0x8732ACD87

前4爲和後四位化成二進制，相加獲得一個和，若是最高位有進位，就和的最後+1。而後取反

15：創建兩個列的索引，複合查詢。符合索引的有效索引爲最長前綴匹配。例如 index(A,B,C) 那麼有效索引爲：(A),(A,B),(A,B,C)

16：String intern的用法

http://www.javashuo.com/article/p-xwueyuaf-eo.html

上面是jdk源碼中對intern方法的詳細解釋。簡單來講就是intern用來返回常量池中的某字符串，若是常量池中已經存在該字符串，則直接返回常量池中該對象的引用。不然，在常量池中加入該對象，而後返回引用。下面的一個例子詳細的解釋了intern的做用過程:

例如： jdk 1.7以後，將會在堆上建立對象，在常量池中保存符號引用， String.intern()返回字符串的首次出現的實例引用。

String st2=new StringBuilder("計算機").append("軟件").toString();
System.out.println(st2.intern()==st2);

String st3=new StringBuilder("計算機").append("軟件").toString();
System.out.println(st3.intern()==st3);
System.out.println(st3.intern()==st2);
/**結果
 true
 false
 true
 */

st3.intern()是首次計算機軟件出現的實例引用（在常量池中）。

17:String 的equals 和==的區別

==是對象引用的比較

equals是邏輯一致性比較，對象覆蓋了該方法，將會按照對象設定的比較方式進行比較。

String 覆蓋了equals方法

public final class String implements Serializable, Comparable<String>, CharSequence {
    public boolean equals(Object var1) {
        if (this == var1) {
            return true;
        } else {
            if (var1 instanceof String) {
                String var2 = (String)var1;
                int var3 = this.value.length;
                if (var3 == var2.value.length) {
                    char[] var4 = this.value;
                    char[] var5 = var2.value;

                    for(int var6 = 0; var3-- != 0; ++var6) {
                        if (var4[var6] != var5[var6]) {
                            return false;
                        }
                    }

                    return true;
                }
            }

            return false;
        }
    }
}

        String s1 = new String("abc");
        String s2 = new String("abc");

        System.out.println(s1 == s2);
        System.out.println(s1.equals(s2));

        /**結果
         false
         true
         */

18：Java 中的編譯期常量是什麼？使用它又什麼風險？

風險：使用了一個其它Jar包的編譯器常量，jar包的發佈者有可能會改變它的值。而你不知道，還在使用，解決方法，當更新Jar依賴時，要從新編譯。

公共靜態不可變（public static final ）變量也就是咱們所說的編譯期常量，這裏的 public 可選的。實際上這些變量在編譯時會被替換掉，由於編譯器知道這些變量的值，而且知道這些變量在運行時不能改變。這種方式存在的一個問題是你使用了一個內部的或第三方庫中的公有編譯時常量，可是這個值後面被其餘人改變了，可是你的客戶端仍然在使用老的值，甚至你已經部署了一個新的jar。爲了不這種狀況，當你在更新依賴 JAR 文件時，確保從新編譯你的程序。

19：運行時常量池

運行時常量池是方法區的一部分，存放編譯器生成的各類字面量和符號引用，字面量和符號引用是Class文件的一部分。

方法區用於存放類信息，常量，靜態變量，編譯後的代碼。

20: BIO,NIO,AIO. Selector

http://www.javashuo.com/article/p-sqmzvpaz-nh.html

http://www.javashuo.com/article/p-qkkfaxit-kk.html

BIO同步阻塞：BIO 每一個鏈接須要服務器建立一個線程。

NIO 同步非阻塞：NIO的最重要的地方是當一個鏈接建立後，不須要對應一個線程，這個鏈接會被註冊到多路複用器上面，因此全部的鏈接只須要一個線程就能夠搞定，當這個線程中的多路複用器進行輪詢的時候，發現鏈接上有請求的話，纔開啓一個線程進行處理，也就是一個請求一個線程模式。

非阻塞：須要while輪詢

AIO 異步阻塞：經過read,write異步操做來完成，

與NIO不一樣，當進行讀寫操做時，只須直接調用API的read或write方法便可。這兩種方法均爲異步的，對於讀操做而言，當有流可讀取時，操做系統會將可讀的流傳入read方法的緩衝區，並通知應用程序；對於寫操做而言，當操做系統將write方法傳遞的流寫入完畢時，操做系統主動通知應用程序。便可以理解爲，read/write方法都是異步的，完成後會主動調用回調函數。

同步和異步：

同步和異步是針對應用程序和內核的交互而言的，同步指的是用戶進程觸發IO操做並等待或者輪詢的去查看IO操做是否就緒，而異步是指用戶進程觸發IO操做之後便開始作本身的事情，而當IO操做已經完成的時候會獲得IO完成的通知。

Selector 是一個選擇器，輪詢器。用於NIO同步非阻塞。

http://www.importnew.com/26258.html

select將會採用輪詢的方式對隊列中的全部鏈接進行查詢，獲取有效的鏈接。可是，當鏈接特別多時，例如1000000個鏈接，可是有效請求特別少時，例如100個，那麼將會形成極大的浪費。
epoll將活躍鏈接保存在一個紅黑樹中，每次只查詢活躍鏈接。  已經取代了select/poll.

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package java.nio.channels;

import java.io.Closeable;
import java.io.IOException;
import java.nio.channels.spi.SelectorProvider;
import java.util.Set;

public abstract class Selector implements Closeable {
    protected Selector() {
    }

    public static Selector open() throws IOException {
        return SelectorProvider.provider().openSelector();
    }

    public abstract boolean isOpen();

    public abstract SelectorProvider provider();

    public abstract Set<SelectionKey> keys();

    public abstract Set<SelectionKey> selectedKeys();

    public abstract int selectNow() throws IOException;

    public abstract int select(long var1) throws IOException;

    public abstract int select() throws IOException;

    public abstract Selector wakeup();

    public abstract void close() throws IOException;
}

21：瞭解的設計模式

a：工廠模式

http://www.cnblogs.com/java-my-life/archive/2012/03/28/2418836.html

b: 建造者模式 https://github.com/1367356/GradleTestUseSubModule/tree/master/DesignPattern/src/main/java/com/li/MyBuilderPattern

http://www.cnblogs.com/java-my-life/archive/2012/04/07/2433939.html

c: 適配器模式：

http://www.cnblogs.com/java-my-life/archive/2012/04/13/2442795.html

d: 觀察者模式

http://www.cnblogs.com/java-my-life/archive/2012/05/16/2502279.html

e: 策略模式

http://www.cnblogs.com/java-my-life/archive/2012/05/10/2491891.html

f: 代理模式

http://www.cnblogs.com/java-my-life/archive/2012/04/23/2466712.html

解釋：

狀態模式：狀態決定行爲，狀態是一個接口，狀態（子類對象不一樣）不一樣，行爲不一樣。

策略模式：客戶端選擇不一樣的策略，選擇不一樣的計算方法

工廠模式：各個零部件（產品零部件）的工廠，工程師組裝

抽象工廠模式：每個產品，構成一個產品族，有產品工廠生成

建造者模式：一個統領，指揮建造者一步一步構建產品對象。統領，建造者，產品(part1,part2).

適配器模式：適配類（ada.method1）沒有須要的目標對象(target.method1,target.method2)中的方法，就建造一個適配器(method1(){ada.method1},method2)，繼承適配類和目標對象，將目標對象的方法用適配類方法重寫.

觀察者模式：爲主題添加觀察者對象（繼承自抽象觀察者），當主題變化時，通知觀察者。有推模式和拉模式，推模式是將主題變化的狀態推給觀察者，拉模式是將主題對象直接給觀察者，由觀察者本身從主題對象中獲取內容。

代理模式：爲一個類建立一個代理類，其中，代理類和被代理的類（目標類）實現了相同的接口，代理類也實現了InvocationHandler。生成的代理類中有目標類的方法和hashCode，equals，toString方法，當調用這幾個方法時>會調用super(invocaitonHandler)>會調用invoke方法>調用method.invoke(target)>調用了目標類了的方法。

22：緩存策略

http://www.javashuo.com/article/p-firrwpbx-gv.html

23：redis

redis底層是用字典(dict)數據結構存儲的。

dict裏面有兩個哈希表，每一個哈希表的桶裏面存儲dictEntry鏈表，dictEntry存儲具體的key和value。

redis支持的數據類型hashtable是用開鏈表的形式（和hashMap差很少）。

Redis也是惰性刪除，即要用到數據時，先檢查key是否過時，過時則刪除，而後返回錯誤。單純的靠惰性刪除，上面說過可能會致使內存浪費，因此Redis也有補充方案，Redis裏面有個定時執行的函數，叫servercron，它是維護服務器的函數，在它裏面，會對過時數據進行刪除，注意不是全刪，而是在必定的時間內，對每一個數據庫的expire dict裏面的數據隨機選取出來，若是過時，則刪除，不然再選，直到規定的時間到。即隨機選取過時的數據刪除，這個操做的時間分兩種，一種較長，一種較短，通常執行短期的刪除，每隔必定的時間，執行一次長時間的刪除。這樣能夠有效的緩解光采用惰性刪除而致使的內存浪費問題。

redis持久化

1：保存redis數據庫文件 RDB ，後臺線程執行bgsave

2: 保存redis命令

2.1 根據aof_buf 向aof文件中輸入命令

2.2 aof_rewrite命令能夠根據數據庫生成操做命令（逆向），將生成的命令存入aof

aof命令載入的時候，redis生成一個假的客戶端，去執行這些命令，最後將原來的數據恢復出來。

Redis是單event loop的，主線程是單線程的。

24: epoll

http://www.javashuo.com/article/p-wsiwtuxy-m.html

http://www.javashuo.com/article/p-bfjmamzc-mt.html

https://www.jianshu.com/p/36197dac65d9

select 使用掃描全表的形式找出活躍的鏈接，有最大fd限制，1024。 10萬個fd至少須要100個進程

epoll首先create是建立對象的epoll對象(事件)的，ctl操做爲紅黑樹添加，更新事件。當有有效事件發生時，經過事件的回調函數callback事件添加到了雙向鏈表rlist中。

await查詢雙向鏈表中有無事件便可，有的話處理，沒有等待。

25：複合索引的匹配策略，左向最長匹配

例如一個索引index(a,b,c), 那麼可使用索引的選擇項爲：

select * from table a=''

select * from table a='' and b='';

select * from table a='' and b='' and c='';

26: 修飾符的做用範圍從大到小 public - protected- default-private

27：進程間通訊方式: http://www.javashuo.com/article/p-vifdlolq-bd.html

近日想總結下進程間，線程間的通訊方式，在網上搜索了下，感受寫的很好，照搬過來，當作加深記憶。

幾種進程間的通訊方式

（1）管道（pipe）：管道是一種半雙工的通訊方式，數據只能單向流動，並且只能在具備血緣關係的進程間使用。進程的血緣關係一般指父子進程關係。

（2）有名管道（named pipe）：有名管道也是半雙工的通訊方式，可是它容許無親緣關係進程間通訊。

（3）信號量（semophore）：信號量是一個計數器，能夠用來控制多個進程對共享資源的訪問。它一般做爲一種鎖機制，防止某進程正在訪問共享資源時，其餘進程也訪問該資源。所以，主要做爲進程間以及同一進程內不一樣線程之間的同步手段。

（4）消息隊列（message queue）：消息隊列是由消息組成的鏈表，存放在內核中並由消息隊列標識符標識。消息隊列克服了信號傳遞信息少，管道只能承載無格式字節流以及緩衝區大小受限等缺點。

（5）信號（signal）：信號是一種比較複雜的通訊方式，用於通知接收進程某一事件已經發生。

（6）共享內存（shared memory）：共享內存就是映射一段能被其餘進程所訪問的內存，這段共享內存由一個進程建立，但多個進程均可以訪問，共享內存是最快的IPC方式，它是針對其餘進程間的通訊方式運行效率低而專門設計的。它每每與其餘通訊機制，如信號量配合使用，來實現進程間的同步和通訊。

（7）套接字（socket）：套接口也是一種進程間的通訊機制，與其餘通訊機制不一樣的是它能夠用於不一樣及其間的進程通訊。

幾種線程間的通訊機制

一、鎖機制

1.1 互斥鎖：提供了以排它方式阻止數據結構被併發修改的方法。

1.2 讀寫鎖：容許多個線程同時讀共享數據，而對寫操做互斥。

1.3 條件變量：能夠以原子的方式阻塞進程，直到某個特定條件爲真爲止。對條件測試是在互斥鎖的保護下進行的。條件變量始終與互斥鎖一塊兒使用。

二、信號量機制：包括無名線程信號量與有名線程信號量

三、信號機制：相似於進程間的信號處理。

線程間通訊的主要目的是用於線程同步，因此線程沒有象進程通訊中用於數據交換的通訊機制。

28：求一個環形鏈表的長度，

能夠取一個節點做爲頭節點，而後將該節點賦值爲head, 再一次向下取節點，並判斷是否等於頭節點，直到等於頭結點，結束。

29：死鎖產生的條件和預防

http://www.javashuo.com/article/p-byvlpsof-gq.html

30:深複製與淺複製 https://www.jianshu.com/p/aa6d493603d3

淺複製：僅僅複製一個對象的引用，clone就是淺複製。克隆對象和原對象指向相同的位置。改變淺複製的引用的值，也將改變原對象的值。

深複製：經過序列化將對象寫到流裏面，而後經過反序列化復原原對象。改變深複製對象的值，不會改變原對象的值。

31：TCP的狀態

http://blog.51cto.com/jinlong/2065461

32：悲觀鎖和樂觀鎖 http://www.javashuo.com/article/p-qpuqpsfi-gk.html

首先介紹一些樂觀鎖與悲觀鎖:

　　悲觀鎖：老是假設最壞的狀況，每次去拿數據的時候都認爲別人會修改，因此每次在拿數據的時候都會上鎖，這樣別人想拿這個數據就會阻塞直到它拿到鎖。傳統的關係型數據庫裏邊就用到了不少這種鎖機制，好比行鎖，表鎖等，讀鎖，寫鎖等，都是在作操做以前先上鎖。再好比Java裏面的同步原語synchronized關鍵字的實現也是悲觀鎖。

　　樂觀鎖：顧名思義，就是很樂觀，每次去拿數據的時候都認爲別人不會修改，因此不會上鎖，可是在更新的時候會判斷一下在此期間別人有沒有去更新這個數據，可使用版本號等機制。樂觀鎖適用於多讀的應用類型，這樣能夠提升吞吐量，像數據庫提供的相似於write_condition機制，其實都是提供的樂觀鎖。在Java中java.util.concurrent.atomic包下面的原子變量類就是使用了樂觀鎖的一種實現方式CAS實現的。

33：裝態碼

200 OK

請求已成功，請求所但願的響應頭或數據體將隨此響應返回。出現此狀態碼是表示正常狀態。

34：爲何TCP 4次揮手期間要等待2MSL

問題

主動發起關閉鏈接的操做的一方將達到TIME_WAIT狀態，並且這個狀態要保持Maximum Segment Lifetime的兩倍時間。爲何要這樣作而不是直接進入CLOSED狀態？

緣由：

保證TCP協議的全雙工鏈接可以可靠關閉
保證此次鏈接的重複數據段從網絡中消失

解釋

若是Client直接CLOSED了，那麼因爲IP協議的不可靠性或者是其它網絡緣由，致使Server沒有收到Client最後回覆的ACK。那麼Server就會在超時以後繼續發送FIN，此時因爲Client已經CLOSED了，就找不到與重發的FIN對應的鏈接，最後Server就會收到RST而不是ACK，Server就會覺得是鏈接錯誤把問題報告給高層。這樣的狀況雖然不會形成數據丟失，可是卻致使TCP協議不符合可靠鏈接的要求。因此，Client不是直接進入CLOSED，而是要保持TIME_WAIT，當再次收到FIN的時候，可以保證對方收到ACK，最後正確的關閉鏈接。
若是Client直接CLOSED，而後又再向Server發起一個新鏈接，咱們不能保證這個新鏈接與剛關閉的鏈接的端口號是不一樣的。也就是說有可能新鏈接和老鏈接的端口號是相同的。通常來講不會發生什麼問題，可是仍是有特殊狀況出現：假設新鏈接和已經關閉的老鏈接端口號是同樣的，若是前一次鏈接的某些數據仍然滯留在網絡中，這些延遲數據在創建新鏈接以後纔到達Server，因爲新鏈接和老鏈接的端口號是同樣的，又由於TCP協議判斷不一樣鏈接的依據是socket pair，因而，TCP協議就認爲那個延遲的數據是屬於新鏈接的，這樣就和真正的新鏈接的數據包發生混淆了。因此TCP鏈接還要在TIME_WAIT狀態等待2倍MSL，這樣能夠保證本次鏈接的全部數據都從網絡中消失。

35：判斷一個鏈表中是否有環， http://www.javashuo.com/article/p-hmasbovi-ex.html

36： String ,StringBuffer,StringBuilder http://www.javashuo.com/article/p-pzzvfptq-mr.html

37： jvm何時會進行full gc.

a:當老年代的最大可用的連續空間大於新生代全部對象的總空間時。容許minor gc

b: 當老年代的最大可用的連續空間S小於新生代全部對象的總空間時, 可是開啓了HandlePromotionFailure=true設置容許擔保失敗時，而且S大於歷次晉升到老年代對象的平均大小。容許發生minor gc

c: jdk1.6以後，HandlePromotionFailure已經再也不使用，只要老年代的最大可用的連續空間大於新生代全部對象的總空間或者大於歷次晉升到老年代對象的平均大小。容許發生minor gc

何時會進行full gc.

d: 老年代的最大可用的連續空間小於歷次晉升到老年代對象的平均大小，進行full gc。

當老年代的最大可用的連續空間小於新生代全部對象的總空間時，開啓了HandlePromotionFailure=false不容許擔保失敗時，將進行full gc。

38：Spring Boot 啓動流程，啓動解析

http://www.javashuo.com/article/p-yytkatbe-ew.html

http://www.javashuo.com/article/p-flhyhcgb-dz.html

Spring 事務原理

http://www.javashuo.com/article/p-pqkcmraz-ce.html

Spring 事務傳播機制：http://www.javashuo.com/article/p-fhpapdbr-dg.html

39：elasticsearch 原理

http://www.javashuo.com/article/p-zksoblfe-bo.html

倒排索引：http://www.javashuo.com/article/p-dampwjyp-by.html

倒排索引，和MyISAM的全文檢索同樣，用單詞找文檔。單詞作鍵，文檔列表做爲值。

單詞1：【記錄1，記錄2】

單詞2：【記錄1，記錄3，記錄5】

40：iPv4 和ipv6所包含的字段

ipv4: 版本號，首部長度，服務類型（將要求低時延，高吞吐量，或可靠性的數據報區別開來），數據報長度，標籤，標識，片偏移，壽命，上層協議，校驗和，選項，源ip,目的ip，數據。

ipv6: 版本號，流量類型，流標籤，有效載荷長度，跳限制，下一個首部，源ip，目的ip，數據。

tcp: 源端口號，目的端口號，序列號，確認號，校驗和，窗口，數據，選項等。

udp：源端口號，目的端口號，長度，校驗和，數據。

41：經常使用linux命令

http://www.javashuo.com/article/p-gvkrzyvd-m.html

http://man.linuxde.net/

42：項目中設置的jvm大小 871.12MB

43： Integer 詳解

https://www.jianshu.com/p/9cb9c61b0986

44： Compable 和Compartor

http://www.javashuo.com/article/p-ofkjiiep-bm.html

45：不使用第三方變量的交換，+-法，異或^

a = a + b;

b = a - b;

a = a - b;

46：方法重載和重寫的區別

方法重寫(overriding)：

　　一、也叫子類的方法覆蓋父類的方法，要求返回值、方法名和參數都相同。

　　二、子類拋出的異常不能超過父類相應方法拋出的異常。(子類異常不能超出父類異常)

　　三、子類方法的的訪問級別不能低於父類相應方法的訪問級別(子類訪問級別不能低於父類訪問級別)

方法重載(overloading):重載是在同一個類中的兩個或兩個以上的方法，擁有相同的方法名，可是參數卻不相同，方法體也不相同，最多見的重載的例子就是類的構造函數，能夠參考API幫助文檔看看類的構造方法

47：線程池

http://www.cnblogs.com/dolphin0520/p/3932921.html

https://blog.csdn.net/cjh94520/article/details/70545202/

爲何要有線程池：1：由於線程的建立和銷燬cpu開銷比較大，2：由於無限制的建立線程池，資源消耗比較大。3：建立線程不是越多越好，必定程度便可。超過必定限度，性能反而會下降 4：穩定性，建立線程的數量受到多個因素的制約，例如JVM啓動參數，Thread請求參數中請求的棧大小以及操做系統的支持。若是破壞了這些限制，極可能拋出OutOfMemoryError 。

線程池的好處：

public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler);

1：maximumPoolSize線程池能建立的最大線程數量>穩定性增強。

2：corePoolSize 核心線程數量，這些線程一直在一個while死循環中運行（從workQueue總獲取任務，執行），其他的線程（maximumPoolSize-corePoolSize）個線程，當超過必定時間時，會銷燬。這樣可以保證資源開銷不會太大。

3：long keepAliveTime,TimeUnit unit, 活躍時間和時間單位

4：workQueue 任務隊列，當執行exec.execute(task)時，將會將task添加到workQueue中。而後while循環中的線程，取出任務，最後仍是執行了Runnable.run()。

5：ThreadFactory 線程工廠，用來建立線程

6： handle ，當執行出現錯誤時，選擇的處理策略，a:拋出異常，b:丟棄任務等。

線程池的大小http://www.javashuo.com/article/p-qmesfdwy-gh.html

48：spring boot特性，啓動流程 http://www.javashuo.com/article/p-yytkatbe-ew.html

Spring 啓動流程：http://www.javashuo.com/article/p-kikedxkm-cn.html

http://www.javashuo.com/article/p-flhyhcgb-dz.html

AOP, DI, IOC

49:Spring 如何保證線程安全的