Java研發工程師知識點總結

時間 2019-11-12

標籤 java 研發工程師知識總結欄目 Java 简体版

原文原文鏈接

Java研發工程師知識點總結

最近一次更新2017年12月08日

大綱

1、Java基礎(語言、集合框架、OOP、設計模式等)
2、Java高級(JavaEE、框架、服務器、工具等)
3、多線程和併發
4、Java虛擬機
5、數據庫(Sql、MySQL、Redis等)
6、算法與數據結構
7、計算機網絡
8、操做系統(OS基礎、Linux等)
9、其餘

1、Java基礎（語言、集合框架、OOP、設計模式等）

1. HashMap和Hashtable的區別html

Hashtable是基於陳舊的Dictionary的Map接口的實現，而HashMap是基於哈希表的Map接口的實現
從方法上看，HashMap去掉了Hashtable的contains方法
HashTable是同步的(線程安全)，而HashMap線程不安全，效率上HashMap更快
HashMap容許空鍵值，而Hashtable不容許
HashMap的iterator迭代器執行快速失敗機制，也就是說在迭代過程當中修改集合結構，除非調用迭代器自身的remove方法，不然以其餘任何方式的修改都將拋出併發修改異常。而Hashtable返回的Enumeration不是快速失敗的。

注：Fast-fail機制:在使用迭代器的過程當中有其它線程修改了集合對象結構或元素數量,都將拋出ConcurrentModifiedException，可是拋出這個異常是不保證的，咱們不能編寫依賴於此異常的程序。java

2. java的線程安全node

Vector、Stack、HashTable、ConcurrentHashMap、Propertiesnginx

3. java集合框架(經常使用)c++

Collection - List - ArrayList
Collection - List - LinkedList
Collection - List - Vector
Collection - List - Vector - Stack
Collection - Set - HashSet
Collection - Set - TreeSet
Collection - List - LinkedHashSet
Map - HashMap
Map - TreeMap
Map - HashTable
Map - LinkedHashMap
Map - ConcurrentHashMap

3.1 List集合和Set集合git

List中元素存取是有序的、可重複的；Set集合中元素是無序的，不可重複的。程序員

CopyOnWriteArrayList:COW的策略，即寫時複製的策略。適用於讀多寫少的併發場景github

Set集合元素存取無序，且元素不可重複。web

HashSet不保證迭代順序，線程不安全；LinkedHashSet是Set接口的哈希表和連接列表的實現，保證迭代順序，線程不安全。面試

TreeSet：能夠對Set集合中的元素排序，元素以二叉樹形式存放，線程不安全。

3.2 ArrayList、LinkedList、Vector的區別

首先它們均是List接口的實現。

ArrayList、LinkedList的區別

1.隨機存取：ArrayList是基於可變大小的數組實現，LinkedList是基於鏈表的實現。這也就決定了對於隨機訪問的get和set的操做，ArrayList要優於LinkedList，由於LinkedList要移動指針。

2.插入和刪除：LinkedList要好一些，由於ArrayList要移動數據，更新索引。

3.內存消耗：LinkedList須要更多的內存，由於須要維護指向後繼結點的指針。

Vector從JDK 1.0起就存在，在1.2時改成實現List接口，功能與ArrayList相似，可是Vector具有線程安全。

3.3 Map集合

Hashtable:基於Dictionary類，線程安全，速度快。底層是哈希表數據結構。是同步的。不容許null做爲鍵，null做爲值。

Properties:Hashtable的子類。用於配置文件的定義和操做，使用頻率很是高，同時鍵和值都是字符串。

HashMap：線程不安全，底層是數組加鏈表實現的哈希表。容許null做爲鍵，null做爲值。HashMap去掉了contains方法。注意：HashMap不保證元素的迭代順序。若是須要元素存取有序，請使用LinkedHashMap

TreeMap：能夠用來對Map集合中的鍵進行排序。

ConcurrentHashMap:是JUC包下的一個併發集合。

3.4 爲何使用ConcurrentHashMap而不是HashMap或Hashtable？

HashMap的缺點：主要是多線程同時put時，若是同時觸發了rehash操做，會致使HashMap中的鏈表中出現循環節點，進而使得後面get的時候，出現死循環，CPU達到100%，因此在併發狀況下不能使用HashMap。讓HashMap同步：Map m = Collections.synchronizeMap(hashMap);而Hashtable雖然是同步的，使用synchronized來保證線程安全，但在線程競爭激烈的狀況下HashTable的效率很是低下。由於當一個線程訪問HashTable的同步方法時，其餘線程訪問HashTable的同步方法時，可能會進入阻塞或輪詢狀態。如線程1使用put進行添加元素，線程2不但不能使用put方法添加元素，而且也不能使用get方法來獲取元素，因此競爭越激烈效率越低。

ConcurrentHashMap的原理：

HashTable容器在競爭激烈的併發環境下表現出效率低下的緣由在於全部訪問HashTable的線程都必須競爭同一把鎖，那假如容器裏有多把鎖，每一把鎖用於鎖容器其中一部分數據，那麼當多線程訪問容器裏不一樣數據段的數據時，線程間就不會存在鎖競爭，從而能夠有效的提升併發訪問效率，這就是ConcurrentHashMap所使用的鎖分段技術，首先將數據分紅一段一段的存儲，而後給每一段數據配一把鎖，當一個線程佔用鎖訪問其中一個段數據的時候，其餘段的數據也能被其餘線程訪問。

ConcurrentHashMap的結構：

ConcurrentHashMap是由Segment數組結構和HashEntry數組結構組成。Segment是一種可重入互斥鎖ReentrantLock，在ConcurrentHashMap裏扮演鎖的角色，HashEntry則用於存儲鍵值對數據。一個ConcurrentHashMap裏包含一個Segment數組，Segment的結構和HashMap相似，是一種數組和鏈表結構，一個Segment裏包含一個HashEntry數組，每一個HashEntry是一個鏈表結構的元素，當對某個HashEntry數組的數據進行修改時，必須首先得到它對應的Segment鎖。

ConcurrentHashMap的構造、get、put操做：

構造函數：傳入參數分別爲

一、初始容量，默認16

二、裝載因子裝載因子用於rehash的斷定，就是當ConcurrentHashMap中的元素大於裝載因子*最大容量時進行擴容，默認0.75

三、併發級別這個值用來肯定Segment的個數，Segment的個數是大於等於concurrencyLevel的第一個2的n次方的數。好比，若是concurrencyLevel爲12，13，14，15，16這些數，則Segment的數目爲16(2的4次方)。默認值爲static final int DEFAULT_CONCURRENCY_LEVEL = 16;。理想狀況下ConcurrentHashMap的真正的併發訪問量可以達到concurrencyLevel，由於有concurrencyLevel個Segment，假若有concurrencyLevel個線程須要訪問Map，而且須要訪問的數據都剛好分別落在不一樣的Segment中，則這些線程可以無競爭地自由訪問（由於他們不須要競爭同一把鎖），達到同時訪問的效果。這也是爲何這個參數起名爲「併發級別」的緣由。默認16.

初始化的一些動做：

初始化segments數組（根據併發級別獲得數組大小size），默認16

初始化segmentShift和segmentMask（這兩個全局變量在定位segment時的哈希算法裏須要使用），默認狀況下segmentShift爲28，segmentMask爲15

初始化每一個Segment，這一步會肯定Segment裏HashEntry數組的長度.

put操做：

一、判斷value是否爲null，若是爲null，直接拋出異常。

二、key經過一次hash運算獲得一個hash值。將獲得hash值向右按位移動segmentShift位，而後再與segmentMask作&運算獲得segment的索引j。即segmentFor方法

三、使用Unsafe的方式從Segment數組中獲取該索引對應的Segment對象。向這個Segment對象中put值，這個put操做也基本是同樣的步驟（經過&運算獲取HashEntry的索引，而後set）。

get操做：

一、和put操做同樣，先經過key進行hash肯定應該去哪一個Segment中取數據。

二、使用Unsafe獲取對應的Segment，而後再進行一次&運算獲得HashEntry鏈表的位置，而後從鏈表頭開始遍歷整個鏈表（由於Hash可能會有碰撞，因此用一個鏈表保存），若是找到對應的key，則返回對應的value值，若是鏈表遍歷完都沒有找到對應的key，則說明Map中不包含該key，返回null。

定位Segment的hash算法：(hash >>> segmentShift) & segmentMask

定位HashEntry所使用的hash算法：int index = hash & (tab.length - 1);

注：

1.tab爲HashEntry數組

2.ConcurrentHashMap既不容許null key也不容許null value

3.5 Collection 和 Collections的區別

Collection是集合類的上級接口，子接口主要有Set 和List、Queue Collections是針對集合類的一個輔助類，提供了操做集合的工具方法：一系列靜態方法實現對各類集合的搜索、排序、線程安全化等操做。

3.6 Map、Set、List、Queue、Stack的特色與用法

Set集合相似於一個罐子，"丟進"Set集合裏的多個對象之間沒有明顯的順序。 List集合表明元素有序、可重複的集合，集合中每一個元素都有其對應的順序索引。 Stack是Vector提供的一個子類，用於模擬"棧"這種數據結構(LIFO後進先出) Queue用於模擬"隊列"這種數據結構(先進先出 FIFO)。 Map用於保存具備"映射關係"的數據，所以Map集合裏保存着兩組值。

3.7 HashMap的工做原理

HashMap維護了一個Entry數組，Entry內部類有key,value，hash和next四個字段，其中next也是一個Entry類型。能夠將Entry數組理解爲一個個的散列桶。每個桶其實是一個單鏈表。當執行put操做時，會根據key的hashcode定位到相應的桶。遍歷單鏈表檢查該key是否已經存在，若是存在，覆蓋該value，反之，新建一個新的Entry，並放在單鏈表的頭部。當經過傳遞key調用get方法時，它再次使用key.hashCode()來找到相應的散列桶，而後使用key.equals()方法找出單鏈表中正確的Entry，而後返回它的值。

3.8 Map的實現類的介紹

HashMap基於散列表來的實現，即便用hashCode()進行快速查詢元素的位置，顯著提升性能。插入和查詢「鍵值對」的開銷是固定的。能夠經過設置容量和裝載因子，以調整容器的性能。

LinkedHashMap, 相似於HashMap,可是迭代遍歷它時，保證迭代的順序是其插入的次序，由於它使用鏈表維護內部次序。此外能夠在構造器中設定LinkedHashMap，使之採用LRU算法。使沒有被訪問過的元素或較少訪問的元素出如今前面，訪問過的或訪問多的出如今後面。這對於須要按期清理元素以節省空間的程序員來講，此功能使得程序員很容易得以實現。

TreeMap, 是基於紅黑樹的實現。同時TreeMap實現了SortedMap接口，該接口能夠確保鍵處於排序狀態。因此查看「鍵」和「鍵值對」時，全部獲得的結果都是通過排序的，次序由天然排序或提供的Comparator決定。SortedMap接口擁有其餘額外的功能，如：返回當前Map使用的Comparator比較強，firstKey()，lastKey(),headMap(toKey),tailMap(fromKey)以及能夠返回一個子樹的subMap()方法等。

WeakHashMap，表示弱鍵映射，WeakHashMap 的工做與正常的 HashMap 相似，可是使用弱引用做爲 key，意思就是當 key 對象沒有任何引用時，key/value 將會被回收。

ConcurrentHashMap，在HashMap基礎上分段鎖機制實現的線程安全的HashMap。

IdentityHashMap 使用==代替equals() 對「鍵」進行比較的散列映射。專爲解決特殊問題而設計。

HashTable：基於Dictionary類的Map接口的實現，它是線程安全的。

3.9 LinkedList 和 PriorityQueue 的區別

它們均是Queue接口的實現。擁有FIFO的特色，它們的區別在於排序行爲。LinkedList 支持雙向列表操做， PriorityQueue 按優先級組織的隊列，元素的出隊次序由元素的天然排序或者由Comparator比較器指定。

3.10 線程安全的集合類。Vector、Hashtable、Properties和Stack、ConcurrentHashMap

3.11 BlockingQueue

Java.util.concurrent.BlockingQueue是一個隊列，在進行獲取元素時，它會等待隊列變爲非空；當在添加一個元素時，它會等待隊列中的可用空間。BlockingQueue接口是Java集合框架的一部分，主要用於實現生產者-消費者模式。咱們不須要擔憂等待生產者有可用的空間，或消費者有可用的對象，由於它都在BlockingQueue的實現類中被處理了。Java提供了集中BlockingQueue的實現，好比ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue,、SynchronousQueue等。

3.12 如何對一組對象進行排序

若是須要對一個對象數組進行排序，咱們能夠使用Arrays.sort()方法。若是咱們須要排序一個對象列表，咱們能夠使用Collections.sort()方法。排序時是默認根據元素的天然排序（使用Comparable）或使用Comparator外部比較器。Collections內部使用數組排序方法，全部它們二者都有相同的性能，只是Collections須要花時間將列表轉換爲數組。

4. ArrayList

無參構造容量爲10
ArrayList(Collections<?extends E> c)構造包含指定collection的元素的列表
ArrayList(int initialCapacity) 指定初始容量

5. final關鍵字

final修飾的變量是常量，必須進行初始化，能夠顯示初始化，也能夠經過構造進行初始化，若是不初始化編譯會報錯。

6. 接口與抽象類

6.1 一個子類只能繼承一個抽象類,但能實現多個接口 6.2 抽象類能夠有構造方法,接口沒有構造方法 6.3 抽象類能夠有普通成員變量,接口沒有普通成員變量 6.4 抽象類和接口均可有靜態成員變量,抽象類中靜態成員變量訪問類型任意，接口只能public static final(默認) 6.5 抽象類能夠沒有抽象方法,抽象類能夠有普通方法,接口中都是抽象方法 6.6 抽象類能夠有靜態方法，接口不能有靜態方法 6.7 抽象類中的方法能夠是public、protected;接口方法只有public abstract

[java抽象類和普通類的區別]

1.抽象類不能被實例化。

2.抽象類能夠有構造函數，被繼承時子類必須繼承父類一個構造方法，抽象方法不能被聲明爲靜態。

3.抽象方法只需申明，而無需實現，抽象類中能夠容許普通方法有主體

4.含有抽象方法的類必須申明爲抽象類

5.抽象的子類必須實現抽象類中全部抽象方法，不然這個子類也是抽象類。

抽象類是否能夠有構造函數？答案是能夠有。抽象類的構造函數用來初始化抽象類的一些字段，而這一切都在抽象類的派生類實例化以前發生。不只如此，抽線類的構造函數還有一種巧妙應用：就是在其內部實現子類必須執行的代碼

7. 抽象類和最終類

抽象類能夠沒有抽象方法, 最終類能夠沒有最終方法

最終類不能被繼承, 最終方法不能被重寫(能夠重載)

8.異常

相關的關鍵字 throw、throws、try...catch、finally

throws 用在方法簽名上, 以便拋出的異常能夠被調用者處理
throw 方法內部經過throw拋出異常
try 用於檢測包住的語句塊, 如有異常, catch子句捕獲並執行catch塊

9. 關於finally

finally無論有沒有異常都要處理
當try和catch中有return時，finally仍然會執行，finally比return先執行
無論有木有異常拋出, finally在return返回前執行
finally是在return後面的表達式運算後執行的（此時並無返回運算後的值，而是先把要返回的值保存起來，管finally中的代碼怎麼樣，返回的值都不會改變，仍然是以前保存的值），因此函數返回值是在finally執行前肯定的

注意：finally中最好不要包含return，不然程序會提早退出，返回值不是try或catch中保存的返回值

finally不執行的幾種狀況：程序提早終止如調用了System.exit, 病毒，斷電

10. 受檢查異常和運行時異常

10.1 粉紅色的是受檢查的異常(checked exceptions),其必須被try...catch語句塊所捕獲, 或者在方法簽名裏經過throws子句聲明。受檢查的異常必須在編譯時被捕捉處理,命名爲Checked Exception是由於Java編譯器要進行檢查, Java虛擬機也要進行檢查, 以確保這個規則獲得遵照。

常見的checked exception：ClassNotFoundException IOException FileNotFoundException EOFException

10.2 綠色的異常是運行時異常(runtime exceptions), 須要程序員本身分析代碼決定是否捕獲和處理,好比空指針,被0除...

常見的runtime exception：NullPointerException ArithmeticException ClassCastException IllegalArgumentException IllegalStateException IndexOutOfBoundsException NoSuchElementException

10.3 而聲明爲Error的，則屬於嚴重錯誤，如系統崩潰、虛擬機錯誤、動態連接失敗等，這些錯誤沒法恢復或者不可能捕捉，將致使應用程序中斷，Error不須要捕獲。

11. this & super

11.1 super出如今父類的子類中。有三種存在方式

super.xxx(xxx爲變量名或對象名)意思是獲取父類中xxx的變量或引用
super.xxx(); (xxx爲方法名)意思是直接訪問並調用父類中的方法
super() 調用父類構造

注：super只能指代其直接父類

11.2 this() & super()在構造方法中的區別

調用super()必須寫在子類構造方法的第一行, 不然編譯不經過
super從子類調用父類構造, this在同一類中調用其餘構造
均須要放在第一行
儘管能夠用this調用一個構造器, 卻不能調用2個
this和super不能出如今同一個構造器中, 不然編譯不經過
this()、super()都指的對象,不能夠在static環境中使用
本質this指向本對象的指針。super是一個關鍵字

12. 修飾符一覽

修飾符    類內部  同一個包  子類   任何地方
private   yes
default         yes   yes
protected  yes   yes    yes
public   yes   yes    yes   yes

13. 構造內部類和靜態內部類對象

public class Enclosingone {
 public class Insideone {}
 public static class Insideone{}
}

public class Test {
 public static void main(String[] args) {
 // 構造內部類對象須要外部類的引用
 Enclosingone.Insideone obj1 = new Enclosingone().new Insideone();
 // 構造靜態內部類的對象
 Enclosingone.Insideone obj2 = new Enclosingone.Insideone();
 }
}

靜態內部類不須要有指向外部類的引用。但非靜態內部類須要持有對外部類的引用。非靜態內部類可以訪問外部類的靜態和非靜態成員。靜態內部類不能訪問外部類的非靜態成員，只能訪問外部類的靜態成員。

14. 序列化

聲明爲static和transient類型的數據不能被序列化，反序列化須要一個無參構造函數

序列化參見個人筆記Java-note-序列化.md

15.正則表達式

次數符號

* 0或屢次
+ 1或屢次
？0或1次
{n} 恰n次
{n,m} 從n到m次

其餘符號

符號等價形式

\d  [0-9]
\D     [^0-9]  
\w   [a-zA-Z_0-9]
\W   [^a-zA-Z_0-9]
\s   [\t\n\r\f]
\S   [^\t\n\r\f]
.   任何字符

邊界匹配器

行開頭 ^ 行結尾 $ 單詞邊界 \b

貪婪模式:最大長度匹配非貪婪模式:匹配到結果就好,最短匹配

環視

字符     描述      匹配對象
.     單個任意字符   
[...]     字符組      列出的任意字符
[^...]           未列出的任意字符
^      caret      行的起始位置
$         dollar      行的結束位置
\<             單詞的起始位置
\>            單詞的結束位置
\b       單詞邊界
\B      非單詞邊界
(?=Expression)  順序確定環視   成功,若是右邊可以匹配
(?!Expression)  順序否認環視   成功,若是右邊不可以匹配
(?<=Expression)  逆序確定環視   成功,若是左邊可以匹配
(?<!Expression)  逆序否認環視   成功,若是左邊不可以匹配

舉例:北京市(海淀區)(朝陽區)(西城區)

Regex: .*(?=\()

模式和匹配器的典型調用次序

把正則表達式編譯到模式中 Pattern p = Pattern.compile("a*b");
建立給定輸入與此模式的匹配器 Matcher m = p.matcher("aaab");
嘗試將整個區域與此模式匹配 boolean b = m.matches();

16. 面向對象的五大基本原則(solid)

S單一職責SRP:Single-Responsibility Principle 一個類,最好只作一件事,只有一個引發它的變化。單一職責原則能夠看作是低耦合,高內聚在面向對象原則的引伸,將職責定義爲引發變化的緣由,以提升內聚性減小引發變化的緣由。
O開放封閉原則OCP:Open-Closed Principle 軟件實體應該是可擴展的,而不是可修改的。對擴展開放,對修改封閉
L里氏替換原則LSP:Liskov-Substitution Principle 子類必須可以替換其基類。這一思想表現爲對繼承機制的約束規範,只有子類可以替換其基類時,纔可以保證系統在運行期內識別子類,這是保證繼承複用的基礎。
I接口隔離原則ISP:Interface-Segregation Principle 使用多個小的接口,而不是一個大的總接口
D依賴倒置原則DIP:Dependency-Inversion Principle 依賴於抽象。具體而言就是高層模塊不依賴於底層模塊,兩者共同依賴於抽象。抽象不依賴於具體,具體依賴於抽象。

17. 面向對象設計其餘原則

封裝變化
少用繼承多用組合
針對接口編程不針對實現編程
爲交互對象之間的鬆耦合設計而努力
類應該對擴展開發對修改封閉（開閉OCP原則）
依賴抽象，不要依賴於具體類（依賴倒置DIP原則）
密友原則：只和朋友交談（最少知識原則，迪米特法則）

說明：一個對象應當對其餘對象有儘量少的瞭解，將方法調用保持在界限內，只調用屬於如下範圍的方法：該對象自己（本地方法）對象的組件被看成方法參數傳進來的對象此方法建立或實例化的任何對象
別找我（調用我）我會找你（調用你）（好萊塢原則）
一個類只有一個引發它變化的緣由（單一職責SRP原則）

18. null能夠被強制轉型爲任意類型的對象

19.代碼執行次序

多個靜態成員變量, 靜態代碼塊按順序執行
單個類中: 靜態代碼 -> main方法 -> 構造塊 -> 構造方法
構造塊在每一次建立對象時執行
涉及父類和子類的初始化過程 a.初始化父類中的靜態成員變量和靜態代碼塊 b.初始化子類中的靜態成員變量和靜態代碼塊 c.初始化父類的普通成員變量和構造代碼塊(按次序)，再執行父類的構造方法(注意父類構造方法中的子類方法覆蓋) d.初始化子類的普通成員變量和構造代碼塊(按次序)，再執行子類的構造方法

20. 數組複製方法

for逐一複製
System.arraycopy() -> 效率最高native方法
Arrays.copyOf() -> 本質調用arraycopy
clone方法 -> 返回Object[],須要強制類型轉換

21. 多態

Java經過方法重寫和方法重載實現多態
方法重寫是指子類重寫了父類的同名方法
方法重載是指在同一個類中，方法的名字相同，可是參數列表不一樣

22. Java文件

.java文件能夠包含多個類，惟一的限制就是：一個文件中只能有一個public類，而且此public類必須與文件名相同。並且這些類和寫在多個文件中沒有區別。

23. Java移位運算符

java中有三種移位運算符

<< :左移運算符,x << 1,至關於x乘以2(不溢出的狀況下),低位補0
>> :帶符號右移,x >> 1,至關於x除以2,正數高位補0,負數高位補1
>>> :無符號右移,忽略符號位,空位都以0補齊

參見個人GitHub，Java移位符

24. 形參&實參

形式參數可被視爲local variable.形參和局部變量同樣都不能離開方法。只有在方法中使用，不會在方法外可見。
形式參數只能用final修飾符，其它任何修飾符都會引發編譯器錯誤。可是用這個修飾符也有必定的限制，就是在方法中不能對參數作任何修改。不過通常狀況下，一個方法的形參不用final修飾。只有在特殊狀況下，那就是：方法內部類。一個方法內的內部類若是使用了這個方法的參數或者局部變量的話，這個參數或局部變量應該是final。
形參的值在調用時根據調用者更改，實參則用自身的值更改形參的值（指針、引用皆在此列），也就是說真正被傳遞的是實參。

25. IO流一覽

26. 局部變量爲何要初始化

局部變量是指類方法中的變量，必須初始化。局部變量運行時被分配在棧中，量大，生命週期短，若是虛擬機給每一個局部變量都初始化一下，是一筆很大的開銷，但變量不初始化爲默認值就使用是不安全的。出於速度和安全性兩個方面的綜合考慮，解決方案就是虛擬機不初始化，但要求編寫者必定要在使用前給變量賦值。

27. Java語言的魯棒性

Java在編譯和運行程序時，都要對可能出現的問題進行檢查，以消除錯誤的產生。它提供自動垃圾收集來進行內存管理，防止程序員在管理內存時容易產生的錯誤。經過集成的面向對象的例外處理機制，在編譯時，Java揭示出可能出現但未被處理的異常，幫助程序員正確地進行選擇以防止系統的崩潰。另外，Java在編譯時還可捕獲類型聲明中的許多常見錯誤，防止動態運行時不匹配問題的出現。

28. Java語言特性

Java致力於檢查程序在編譯和運行時的錯誤
Java虛擬機實現了跨平臺接口
類型檢查幫助檢查出許多開發早期出現的錯誤
Java本身操縱內存減小了內存出錯的可能性
Java還實現了真數組，避免了覆蓋數據的可能

29. 包裝類的equals()方法不處理數據轉型，必須類型和值都同樣才相等。

30. 子類能夠繼承父類的靜態方法！可是不能覆蓋。由於靜態方法是在編譯時肯定了，不能多態，也就是不能運行時綁定。

31. Java語法糖

Java7的switch用字符串 - hashcode方法 switch用於enum枚舉
僞泛型 - List<E>原始類型
自動裝箱拆箱 - Integer.valueOf和Integer.intValue
foreach遍歷 - Iterator迭代器實現
條件編譯
enum枚舉類、內部類
可變參數 - 數組
斷言語言
try語句中定義和關閉資源

32. Java 中應該使用什麼數據類型來表明價格？

若是不是特別關心內存和性能的話，使用BigDecimal，不然使用預約義精度的 double 類型。

33. 怎麼將 byte 轉換爲 String？

能夠使用 String 接收 byte[] 參數的構造器來進行轉換，須要注意的點是要使用的正確的編碼，不然會使用平臺默認編碼，這個編碼可能跟原來的編碼相同，也可能不一樣。

34. Java 中怎樣將 bytes 轉換爲 long 類型？

String接收bytes的構造器轉成String，再Long.parseLong

35. 咱們能將 int 強制轉換爲 byte 類型的變量嗎？若是該值大於 byte 類型的範圍，將會出現什麼現象？

是的，咱們能夠作強制轉換，可是 Java 中 int 是 32 位的，而 byte 是 8 位的，因此，若是強制轉化是，int 類型的高 24 位將會被丟棄，byte 類型的範圍是從 -128 到 127。

36. 存在兩個類，B 繼承 A，C 繼承 B，咱們能將 B 轉換爲 C 麼？如 C = (C) B；

能夠，向下轉型。可是不建議使用，容易出現類型轉型異常.

37. 哪一個類包含 clone 方法？是 Cloneable 仍是 Object？

java.lang.Cloneable 是一個標示性接口，不包含任何方法，clone 方法在 object 類中定義。而且須要知道 clone() 方法是一個本地方法，這意味着它是由 c 或 c++ 或其餘本地語言實現的。

38. Java 中 ++ 操做符是線程安全的嗎？

不是線程安全的操做。它涉及到多個指令，如讀取變量值，增長，而後存儲回內存，這個過程可能會出現多個線程交差。還會存在競態條件（讀取-修改-寫入）。

39. a = a + b 與 a += b 的區別

+= 隱式的將加操做的結果類型強制轉換爲持有結果的類型。若是兩這個整型相加，如 byte、short 或者 int，首先會將它們提高到 int 類型，而後在執行加法操做。


byte a = 127;
byte b = 127;
b = a + b; // error : cannot convert from int to byte
b += a; // ok

（由於 a+b 操做會將 a、b 提高爲 int 類型，因此將 int 類型賦值給 byte 就會編譯出錯）

40. 我能在不進行強制轉換的狀況下將一個 double 值賦值給 long 類型的變量嗎？

不行，你不能在沒有強制類型轉換的前提下將一個 double 值賦值給 long 類型的變量，由於 double 類型的範圍比 long 類型更廣，因此必需要進行強制轉換。

41. 3*0.1 == 0.3 將會返回什麼？true 仍是 false？

false，由於有些浮點數不能徹底精確的表示出來。

42. int 和 Integer 哪一個會佔用更多的內存？

Integer 對象會佔用更多的內存。Integer 是一個對象，須要存儲對象的元數據。可是 int 是一個原始類型的數據，因此佔用的空間更少。

43. 爲何 Java 中的 String 是不可變的（Immutable）？

Java 中的 String 不可變是由於 Java 的設計者認爲字符串使用很是頻繁，將字符串設置爲不可變能夠容許多個客戶端之間共享相同的字符串。更詳細的內容參見答案。

44. 咱們能在 Switch 中使用 String 嗎？

從 Java 7 開始，咱們能夠在 switch case 中使用字符串，但這僅僅是一個語法糖。內部實如今 switch 中使用字符串的 hash code。

45. Java 中的構造器鏈是什麼？

當你從一個構造器中調用另外一個構造器，就是Java 中的構造器鏈。這種狀況只在重載了類的構造器的時候纔會出現。

46. 枚舉類

JDK1.5出現每一個枚舉值都須要調用一次構造函數

48. 什麼是不可變對象（immutable object）？Java 中怎麼建立一個不可變對象？

不可變對象指對象一旦被建立，狀態就不能再改變。任何修改都會建立一個新的對象，如 String、Integer及其它包裝類。

如何在Java中寫出Immutable的類？

要寫出這樣的類，須要遵循如下幾個原則：

1）immutable對象的狀態在建立以後就不能發生改變，任何對它的改變都應該產生一個新的對象。

2）Immutable類的全部的屬性都應該是final的。

3）對象必須被正確的建立，好比：對象引用在對象建立過程當中不能泄露(leak)。

4）對象應該是final的，以此來限制子類繼承父類，以免子類改變了父類的immutable特性。

5）若是類中包含mutable類對象，那麼返回給客戶端的時候，返回該對象的一個拷貝，而不是該對象自己（該條能夠歸爲第一條中的一個特例）

49. 咱們能建立一個包含可變對象的不可變對象嗎？

是的，咱們是能夠建立一個包含可變對象的不可變對象的，你只須要謹慎一點，不要共享可變對象的引用就能夠了，若是須要變化時，就返回原對象的一個拷貝。最多見的例子就是對象中包含一個日期對象的引用。

50. List和Set

List 是一個有序集合，容許元素重複。它的某些實現能夠提供基於下標值的常量訪問時間，可是這不是 List 接口保證的。Set 是一個無序集合。

51. poll() 方法和 remove() 方法的區別？

poll() 和 remove() 都是從隊列中取出一個元素，可是 poll() 在獲取元素失敗的時候會返回空，可是 remove() 失敗的時候會拋出異常。

52. Java 中 LinkedHashMap 和 PriorityQueue 的區別是什麼？

PriorityQueue 保證最高或者最低優先級的的元素老是在隊列頭部，可是 LinkedHashMap 維持的順序是元素插入的順序。當遍歷一個 PriorityQueue 時，沒有任何順序保證，可是 LinkedHashMap 課保證遍歷順序是元素插入的順序。

53. ArrayList 與 LinkedList 的區別？

最明顯的區別是 ArrrayList 底層的數據結構是數組，支持隨機訪問，而 LinkedList 的底層數據結構書鏈表，不支持隨機訪問。使用下標訪問一個元素，ArrayList 的時間複雜度是 O(1)，而 LinkedList 是 O(n)。

54. 用哪兩種方式來實現集合的排序？

你能夠使用有序集合，如 TreeSet 或 TreeMap，你也能夠使用有順序的的集合，如 list，而後經過 Collections.sort() 來排序。

55. Java 中怎麼打印數組？

你能夠使用 Arrays.toString() 和 Arrays.deepToString() 方法來打印數組。因爲數組沒有實現 toString() 方法，因此若是將數組傳遞給 System.out.println() 方法，將沒法打印出數組的內容，可是 Arrays.toString() 能夠打印每一個元素。

56. Java 中的 LinkedList 是單向鏈表仍是雙向鏈表？

是雙向鏈表，你能夠檢查 JDK 的源碼。在 Eclipse，你能夠使用快捷鍵 Ctrl + T，直接在編輯器中打開該類。

57. Java 中的 TreeMap 是採用什麼樹實現的？

Java 中的 TreeMap 是使用紅黑樹實現的。

58. Java 中的 HashSet，內部是如何工做的？

HashSet 的內部採用 HashMap來實現。因爲 Map 須要 key 和 value，因此全部 key 的都有一個默認 value。相似於 HashMap，HashSet 不容許重複的 key，只容許有一個null key，意思就是 HashSet 中只容許存儲一個 null 對象。

59. 寫一段代碼在遍歷 ArrayList 時移除一個元素？

該問題的關鍵在於面試者使用的是 ArrayList 的 remove() 仍是 Iterator 的 remove()方法。這有一段示例代碼，是使用正確的方式來實如今遍歷的過程當中移除元素，而不會出現 ConcurrentModificationException 異常的示例代碼。

60. 咱們能本身寫一個容器類，而後使用 for-each 循環嗎？

能夠，你能夠寫一個本身的容器類。若是你想使用 Java 中加強的循環來遍歷，你只須要實現 Iterable 接口。若是你實現 Collection 接口，默認就具備該屬性。

61. ArrayList 和 HashMap 的默認大小是多數？

在 Java 7 中，ArrayList 的默認大小是 10 個元素，HashMap 的默認大小是16個元素（必須是2的冪）。這就是 Java 7 中 ArrayList 和 HashMap 類的代碼片斷：

// from ArrayList.java JDK 1.7
private static final int DEFAULT_CAPACITY = 10;
 
//from HashMap.java JDK 7
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

62. 有沒有可能兩個不相等的對象有有相同的 hashcode？

有可能，兩個不相等的對象可能會有相同的 hashcode 值，這就是爲何在 hashmap 中會有衝突。相等 hashcode 值的規定只是說若是兩個對象相等，必須有相同的hashcode 值，可是沒有關於不相等對象的任何規定。

63. 兩個相同的對象會有不一樣的的 hash code 嗎？

不能，根據 hash code 的規定，這是不可能的。

64. 咱們能夠在 hashcode() 中使用隨機數字嗎？

不行，由於對象的 hashcode 值必須是相同的。

65. Java 中，Comparator 與 Comparable 有什麼不一樣？

Comparable 接口用於定義對象的天然順序，而 comparator 一般用於定義用戶定製的順序。

Comparable 老是隻有一個，可是能夠有多個 comparator 來定義對象的順序。

66. 爲何在重寫 equals 方法的時候須要重寫 hashCode 方法？

由於有強制的規範指定須要同時重寫 hashcode 與 equal 是方法，許多容器類，如 HashMap、HashSet 都依賴於 hashcode 與 equals 的規定。

67. 「a==b」和」a.equals(b)」有什麼區別？

若是 a 和 b 都是對象，則 a==b 是比較兩個對象的引用，只有當 a 和 b 指向的是堆中的同一個對象纔會返回 true，而 a.equals(b) 是進行邏輯比較，因此一般須要重寫該方法來提供邏輯一致性的比較。例如，String 類重寫 equals() 方法，因此能夠用於兩個不一樣對象，可是包含的字母相同的比較。

68. a.hashCode() 有什麼用？與 a.equals(b) 有什麼關係？

簡介：hashCode() 方法是相應對象整型的 hash 值。它經常使用於基於 hash 的集合類，如 Hashtable、HashMap、LinkedHashMap等等。它與 equals() 方法關係特別緊密。根據 Java 規範，兩個使用 equal() 方法來判斷相等的對象，必須具備相同的 hash code。

一、hashcode的做用

List和Set，如何保證Set不重複呢？經過迭代使用equals方法來判斷，數據量小還能夠接受，數據量大怎麼解決？引入hashcode，實際上hashcode扮演的角色就是尋址，大大減小查詢匹配次數。

二、hashcode重要嗎

對於數組、List集合就是一個累贅。而對於hashmap, hashset, hashtable就異常重要了。

三、equals方法遵循的原則

對稱性若x.equals(y)true，則y.equals(x)true
自反性 x.equals(x)必須true
傳遞性若x.equals(y)true,y.equals(z)true,則x.equals(z)必爲true
一致性只要x,y內容不變，不管調用多少次結果不變
其餘 x.equals(null) 永遠false，x.equals(和x數據類型不一樣)始終false

二者的關係

69. final、finalize 和 finally 的不一樣之處？

final 是一個修飾符，能夠修飾變量、方法和類。若是 final 修飾變量，意味着該變量的值在初始化後不能被改變。Java 技術容許使用 finalize() 方法在垃圾收集器將對象從內存中清除出去以前作必要的清理工做。這個方法是由垃圾收集器在肯定這個對象沒有被引用時對這個對象調用的，可是何時調用 finalize 沒有保證。finally 是一個關鍵字，與 try 和 catch 一塊兒用於異常的處理。finally 塊必定會被執行，不管在 try 塊中是否有發生異常。

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

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

71. 說出幾點 Java 中使用 Collections 的最佳實踐

這是我在使用 Java 中 Collectionc 類的一些最佳實踐：

a）使用正確的集合類，例如，若是不須要同步列表，使用 ArrayList 而不是 Vector。

b）優先使用併發集合，而不是對集合進行同步。併發集合提供更好的可擴展性。

c）使用接口表明和訪問集合，如使用List存儲 ArrayList，使用 Map 存儲 HashMap 等等。

d）使用迭代器來循環集合。

e）使用集合的時候使用泛型。

72. 靜態內部類與頂級類有什麼區別？

一個公共的頂級類的源文件名稱與類名相同，而嵌套靜態類沒有這個要求。一個嵌套類位於頂級類內部，須要使用頂級類的名稱來引用嵌套靜態類，如 HashMap.Entry 是一個嵌套靜態類，HashMap 是一個頂級類，Entry是一個嵌套靜態類。

73. Java 中，Serializable 與 Externalizable 的區別？

Serializable 接口是一個序列化 Java 類的接口，以便於它們能夠在網絡上傳輸或者能夠將它們的狀態保存在磁盤上，是 JVM 內嵌的默認序列化方式，成本高、脆弱並且不安全。Externalizable 容許你控制整個序列化過程，指定特定的二進制格式，增長安全機制。

74. 說出 JDK 1.7 中的三個新特性？

雖然 JDK 1.7 不像 JDK 5 和 8 同樣的大版本，可是，仍是有不少新的特性，如 try-with-resource 語句，這樣你在使用流或者資源的時候，就不須要手動關閉，Java 會自動關閉。Fork-Join 池某種程度上實現 Java 版的 Map-reduce。容許 Switch 中有 String 變量和文本。菱形操做符(<>)用於泛型推斷，再也不須要在變量聲明的右邊申明泛型，所以能夠寫出可讀寫更強、更簡潔的代碼。另外一個值得一提的特性是改善異常處理，如容許在同一個 catch 塊中捕獲多個異常。

75. 說出 5 個 JDK 1.8 引入的新特性？

Java 8 在 Java 歷史上是一個開創新的版本，下面 JDK 8 中 5 個主要的特性： Lambda 表達式，容許像對象同樣傳遞匿名函數 Stream API，充分利用現代多核 CPU，能夠寫出很簡潔的代碼 Date 與 Time API，最終，有一個穩定、簡單的日期和時間庫可供你使用擴展方法，如今，接口中能夠有靜態、默認方法。重複註解，如今你能夠將相同的註解在同一類型上使用屢次。

下述包含 Java 面試過程當中關於 SOLID 的設計原則，OOP 基礎，如類，對象，接口，繼承，多態，封裝，抽象以及更高級的一些概念，如組合、聚合及關聯。也包含了 GOF 設計模式的問題。

76. 接口是什麼？爲何要使用接口而不是直接使用具體類？

接口用於定義 API。它定義了類必須得遵循的規則。同時，它提供了一種抽象，由於客戶端只使用接口，這樣能夠有多重實現，如 List 接口，你能夠使用可隨機訪問的 ArrayList，也能夠使用方便插入和刪除的 LinkedList。接口中不容許普通方法，以此來保證抽象，可是 Java 8 中你能夠在接口聲明靜態方法和默認普通方法。

77. Java 中，抽象類與接口之間有什麼不一樣？

Java 中，抽象類和接口有不少不一樣之處，可是最重要的一個是 Java 中限制一個類只能繼承一個類，可是能夠實現多個接口。抽象類能夠很好的定義一個家族類的默認行爲，而接口能更好的定義類型，有助於後面實現多態機制參見第六條。

78. 除了單例模式，你在生產環境中還用過什麼設計模式？

這須要根據你的經驗來回答。通常狀況下，你能夠說依賴注入，工廠模式，裝飾模式或者觀察者模式，隨意選擇你使用過的一種便可。不過你要準備回答接下的基於你選擇的模式的問題。

79. 你能解釋一下里氏替換原則嗎?

嚴格定義：若是對每個類型爲S的對象o1，都有類型爲T的對象o2，使得以T定義的全部程序P在全部的對象用o1替換o2時，程序P的行爲沒有變化，那麼類型S是類型T的子類型。

通俗表述：全部引用基類（父類）的地方必須能透明地使用其子類的對象。也就是說子類能夠擴展父類的功能，但不能改變父類原有的功能。它包含如下4層含義：

子類能夠實現父類的抽象方法，但不能覆蓋父類的非抽象方法。
子類中能夠增長本身特有的方法。
當子類的方法重載父類的方法時，方法的前置條件（即方法的形參）要比父類方法的輸入參數更寬鬆。
當子類的方法實現父類的抽象方法時，方法的後置條件（即方法的返回值）要比父類更嚴格。

80.什麼狀況下會違反迪米特法則？爲何會有這個問題？

迪米特法則建議「只和朋友說話，不要和陌生人說話」，以此來減小類之間的耦合。

81. 適配器模式是什麼？何時使用？

適配器模式提供對接口的轉換。若是你的客戶端使用某些接口，可是你有另一些接口，你就能夠寫一個適配去來鏈接這些接口。

82. 構造器注入和 setter 依賴注入，那種方式更好？

每種方式都有它的缺點和優勢。構造器注入保證全部的注入都被初始化，可是 setter 注入提供更好的靈活性來設置可選依賴。若是使用 XML 來描述依賴，Setter 注入的可讀寫會更強。經驗法則是強制依賴使用構造器注入，可選依賴使用 setter 注入。

83. 依賴注入和工廠模式之間有什麼不一樣？

雖然兩種模式都是將對象的建立從應用的邏輯中分離，可是依賴注入比工廠模式更清晰。經過依賴注入，你的類就是 POJO，它只知道依賴而不關心它們怎麼獲取。使用工廠模式，你的類須要經過工廠來獲取依賴。所以，使用 DI 會比使用工廠模式更容易測試。

84. 適配器模式和裝飾器模式有什麼區別？

雖然適配器模式和裝飾器模式的結構相似，可是每種模式的出現意圖不一樣。適配器模式被用於橋接兩個接口，而裝飾模式的目的是在不修改類的狀況下給類增長新的功能。

85. 適配器模式和代理模式以前有什麼不一樣？

這個問題與前面的相似，適配器模式和代理模式的區別在於他們的意圖不一樣。因爲適配器模式和代理模式都是封裝真正執行動做的類，所以結構是一致的，可是適配器模式用於接口之間的轉換，而代理模式則是增長一個額外的中間層，以便支持分配、控制或智能訪問。

86. 什麼是模板方法模式？

模板方法提供算法的框架，你能夠本身去配置或定義步驟。例如，你能夠將排序算法看作是一個模板。它定義了排序的步驟，可是具體的比較，能夠使用 Comparable 或者其語言中相似東西，具體策略由你去配置。列出算法概要的方法就是衆所周知的模板方法。

87. 何時使用訪問者模式？

訪問者模式用於解決在類的繼承層次上增長操做，可是不直接與之關聯。這種模式採用雙派發的形式來增長中間層。

88. 何時使用組合模式？

組合模式使用樹結構來展現部分與總體繼承關係。它容許客戶端採用統一的形式來對待單個對象和對象容器。當你想要展現對象這種部分與總體的繼承關係時採用組合模式。

89. 繼承和組合之間有什麼不一樣？

雖然兩種均可以實現代碼複用，可是組合比繼承共靈活，由於組合容許你在運行時選擇不一樣的實現。用組合實現的代碼也比繼承測試起來更加簡單。

90. 描述 Java 中的重載和重寫？

重載和重寫都容許你用相同的名稱來實現不一樣的功能，可是重載是編譯時活動，而重寫是運行時活動。你能夠在同一個類中重載方法，可是隻能在子類中重寫方法。重寫必需要有繼承。

91. OOP 中的組合、聚合和關聯有什麼區別？

若是兩個對象彼此有關係，就說他們是彼此相關聯的。組合和聚合是面向對象中的兩種形式的關聯。組合是一種比聚合更強力的關聯。組合中，一個對象是另外一個的擁有者，而聚合則是指一個對象使用另外一個對象。若是對象 A 是由對象 B 組合的，則 A 不存在的話，B必定不存在，可是若是 A 對象聚合了一個對象 B，則即便 A 不存在了，B 也能夠單獨存在。

92. 給我一個符合開閉原則的設計模式的例子？

開閉原則要求你的代碼對擴展開放，對修改關閉。這個意思就是說，若是你想增長一個新的功能，你能夠很容易的在不改變已測試過的代碼的前提下增長新的代碼。有好幾個設計模式是基於開閉原則的，如策略模式，若是你須要一個新的策略，只須要實現接口，增長配置，不須要改變核心邏輯。一個正在工做的例子是 Collections.sort() 方法，這就是基於策略模式，遵循開閉原則的，你不需爲新的對象修改 sort() 方法，你須要作的僅僅是實現你本身的 Comparator 接口。

93. 何時使用享元模式（蠅量模式）？

享元模式經過共享對象來避免建立太多的對象。爲了使用享元模式，你須要確保你的對象是不可變的，這樣你才能安全的共享。JDK 中 String 池、Integer 池以及 Long 池都是很好的使用了享元模式的例子。

94. Java 中如何格式化一個日期？如格式化爲 ddMMyyyy 的形式？

Java 中，能夠使用 SimpleDateFormat 類或者 joda-time 庫來格式日期。DateFormat 類容許你使用多種流行的格式來格式化日期。

95. Java 中，怎麼在格式化的日期中顯示時區？

pattern中加z yyyy-MM-dd HH:mm:ss.SSS Z

96. Java 中 java.util.Date 與 java.sql.Date 有什麼區別？

java.sql.Date是針對SQL語句使用的，它只包含日期而沒有時間部分,它們都有getTime方法返回毫秒數，天然就能夠直接構建。java.util.Date 是 java.sql.Date 的父類，前者是經常使用的表示時間的類，咱們一般格式化或者獲得當前時間都是用他，後者以後在讀寫數據庫的時候用他，由於PreparedStament的setDate()的第2參數和ResultSet的getDate()方法的第2個參數都是java.sql.Date。

97. Java 中，如何計算兩個日期之間的差距？

public static int dateDiff(Date d1, Date d2) throws Exception {
long n1 = d1.getTime();
long n2 = d2.getTime();
long diff = Math.abs(n1 - n2);

diff /= 3600 * 1000 * 24;
return diff;
}

98. Java 中，如何將字符串 YYYYMMDD 轉換爲日期？

SimpleDateFormat的parse方法

99. 說出幾條 Java 中方法重載的最佳實踐？

下面有幾條能夠遵循的方法重載的最佳實踐來避免形成自動裝箱的混亂。

a）不要重載這樣的方法：一個方法接收 int 參數，而另外一個方法接收 Integer 參數。

b）不要重載參數數量一致，而只是參數順序不一樣的方法。

c）若是重載的方法參數個數多於 5 個，採用可變參數。

100. 說出 5 條 IO 的最佳實踐

IO 對 Java 應用的性能很是重要。理想狀況下，你應該在你應用的關鍵路徑上避免 IO 操做。下面是一些你應該遵循的 Java IO 最佳實踐：

a）使用有緩衝區的 IO 類，而不要單獨讀取字節或字符

b）使用 NIO 和 NIO2

c）在 finally 塊中關閉流，或者使用 try-with-resource（Java7）語句

d）使用內存映射文件獲取更快的 IO

101. Object有哪些公用方法？

clone equals hashcode wait notify notifyall finalize toString getClass 除了clone和finalize其餘均爲公共方法。

11個方法，wait被重載了兩次

102. equals與==的區別

區別1. ==是一個運算符 equals是Object類的方法

區別2. 比較時的區別

a. 用於基本類型的變量比較時：==用於比較值是否相等，equals不能直接用於基本數據類型的比較，須要轉換爲其對應的包裝類型。 b. 用於引用類型的比較時。==和equals都是比較棧內存中的地址是否相等。相等爲true 不然爲false。可是一般會重寫equals方法去實現對象內容的比較。

103. String、StringBuffer與StringBuilder的區別

第一點：可變和適用範圍。String對象是不可變的，而StringBuffer和StringBuilder是可變字符序列。每次對String的操做至關於生成一個新的String對象，而對StringBuffer和StringBuilder的操做是對對象自己的操做，而不會生成新的對象，因此對於頻繁改變內容的字符串避免使用String，由於頻繁的生成對象將會對系統性能產生影響。

第二點：線程安全。String因爲有final修飾，是immutable的，安全性是簡單而純粹的。StringBuilder和StringBuffer的區別在於StringBuilder不保證同步，也就是說若是須要線程安全須要使用StringBuffer，不須要同步的StringBuilder效率更高。

104. switch可否用String作參數

Java1.7開始支持，但實際這是一顆Java語法糖。除此以外，byte，short，long，枚舉，boolean都可用於switch，只有浮點型不能夠。

105. 封裝、繼承、多態

封裝：

1.概念：就是把對象的屬性和操做（或服務）結合爲一個獨立的總體，並儘量隱藏對象的內部實現細節。

2.好處：

(1)隱藏內部實現細節。

繼承：

1.概念：繼承是從已有的類中派生出新的類，新的類能吸取已有類的數據屬性和行爲，並能擴展新的能力

2.好處：提升代碼的複用，縮短開發週期。

多態：

1.概念：多態（Polymorphism）按字面的意思就是「多種狀態，即同一個實體同時具備多種形式。通常表現形式是程序在運行的過程當中，同一種類型在不一樣的條件下表現不一樣的結果。多態也稱爲動態綁定，通常是在運行時刻才能肯定方法的具體執行對象。

2.好處： 1）將接口和實現分開，改善代碼的組織結構和可讀性，還能建立可拓展的程序。 2）消除類型之間的耦合關係。容許將多個類型視爲同一個類型。 3）一個多態方法的調用容許有多種表現形式

106. Comparable和Comparator接口區別

Comparator位於包java.util下，而Comparable位於包java.lang下

若是咱們須要使用Arrays或Collections的排序方法對對象進行排序時，咱們須要在自定義類中實現Comparable接口並重寫compareTo方法，compareTo方法接收一個參數，若是this對象比傳遞的參數小，相等或大時分別返回負整數、0、正整數。Comparable被用來提供對象的天然排序。String、Integer實現了該接口。

Comparator比較器的compare方法接收2個參數，根據參數的比較大小分別返回負整數、0和正整數。 Comparator 是一個外部的比較器，當這個對象天然排序不能知足你的要求時，你能夠寫一個比較器來完成兩個對象之間大小的比較。用 Comparator 是策略模式（strategy design pattern），就是不改變對象自身，而用一個策略對象（strategy object）來改變它的行爲。

107. 與Java集合框架相關的有哪些最好的實踐

（1）根據須要選擇正確的集合類型。好比，若是指定了大小，咱們會選用Array而非ArrayList。若是咱們想根據插入順序遍歷一個Map，咱們須要使用TreeMap。若是咱們不想重複，咱們應該使用Set。

（2）一些集合類容許指定初始容量，因此若是咱們可以估計到存儲元素的數量，咱們能夠使用它，就避免了從新哈希或大小調整。

（3）基於接口編程，而非基於實現編程，它容許咱們後來輕易地改變實現。

（4）老是使用類型安全的泛型，避免在運行時出現ClassCastException。

（5）使用JDK提供的不可變類做爲Map的key，能夠避免本身實現hashCode()和equals()。

108. IO和NIO簡述

一、簡述

在之前的Java IO中，都是阻塞式IO，NIO引入了非阻塞式IO。第一種方式：我從硬盤讀取數據，而後程序一直等，數據讀完後，繼續操做。這種方式是最簡單的，叫阻塞IO。第二種方式：我從硬盤讀取數據，而後程序繼續向下執行，等數據讀取完後，通知當前程序（對硬件來講叫中斷，對程序來講叫回調），而後此程序能夠當即處理數據，也能夠執行完當前操做在讀取數據。

2.流與塊的比較

原來的 I/O 以流的方式處理數據，而 NIO 以塊的方式處理數據。面向流的 I/O 系統一次一個字節地處理數據。一個輸入流產生一個字節的數據，一個輸出流消費一個字節的數據。這樣作是相對簡單的。不利的一面是，面向流的 I/O 一般至關慢。一個面向塊的 I/O 系統以塊的形式處理數據。每個操做都在一步中產生或者消費一個數據塊。按塊處理數據比按(流式的)字節處理數據要快得多。可是面向塊的 I/O 缺乏一些面向流的 I/O 所具備的優雅性和簡單性。

3.通道與流

Channel是一個對象，能夠經過它讀取和寫入數據。通道與流功能相似，不一樣之處在於通道是雙向的。而流只是在一個方向上移動(一個流必須是 InputStream 或者 OutputStream 的子類)，而通道能夠用於讀、寫或者同時用於讀寫。

4.緩衝區Buffer

在 NIO 庫中，全部數據都是用緩衝區處理的。在 NIO 庫中，全部數據都是用緩衝區處理的。

Position: 表示下一次訪問的緩衝區位置 Limit: 表示當前緩衝區存放的數據容量。 Capacity:表示緩衝區最大容量

flip()方法:讀寫模式切換

clear方法:它將 limit 設置爲與 capacity 相同。它設置 position 爲 0。

2、Java高級（JavaEE、框架、服務器、工具等）

1. Servlet

1.1 Servlet繼承實現結構

Servlet (接口)    -->     init|service|destroy方法
GenericServlet(抽象類)  -->     與協議無關的Servlet
HttpServlet(抽象類)  -->  實現了http協議
自定義Servlet   -->  重寫doGet/doPost

1.2 編寫Servlet的步驟

繼承HttpServlet
重寫doGet/doPost方法
在web.xml中註冊servlet

1.3 Servlet生命週期

init:僅執行一次,負責裝載servlet時初始化servlet對象
service:核心方法,通常get/post兩種方式
destroy:中止並卸載servlet,釋放資源

1.4 過程

客戶端request請求 -> 服務器檢查Servlet實例是否存在 -> 若存在調用相應service方法
客戶端request請求 -> 服務器檢查Servlet實例是否存在 -> 若不存在裝載Servlet類並建立實例 -> 調用init初始化 -> 調用service
加載和實例化、初始化、處理請求、服務結束

1.5 doPost方法要拋出的異常:ServletExcception、IOException

1.6 Servlet容器裝載Servlet

web.xml中配置load-on-startup啓動時裝載
客戶首次向Servlet發送請求
Servlet類文件被更新後, 從新裝載Servlet

1.7 HttpServlet容器響應web客戶請求流程

Web客戶向servlet容器發出http請求
servlet容器解析Web客戶的http請求
servlet容器建立一個HttpRequest對象, 封裝http請求信息
servlet容器建立一個HttpResponse對象
servlet容器調用HttpServlet的service方法, 把HttpRequest和HttpResponse對象做爲service方法的參數傳給HttpServlet對象
HttpServlet調用httprequest的有關方法, 獲取http請求信息
httpservlet調用httpresponse的有關方法, 生成響應數據
Servlet容器把HttpServlet的響應結果傳給web客戶

1.8 HttpServletRequest完成的一些功能

request.getCookie()
request.getHeader(String s)
request.getContextPath()
request.getSession()

HttpSession session = request.getSession(boolean create)
返回當前請求的會話

1.9 HttpServletResponse完成一些的功能

設http響應頭
設置Cookie
輸出返回數據

1.10 Servlet與JSP九大內置對象的關係

JSP對象怎樣得到

1. out    ->  response.getWriter
2. request   ->  Service方法中的req參數
3. response   ->  Service方法中的resp參數
4. session   ->  request.getSession
5. application  ->  getServletContext
6. exception   ->  Throwable
7. page    ->  this
8. pageContext  ->  PageContext
9. Config    ->  getServletConfig

exception是JSP九大內置對象之一，其實例表明其餘頁面的異常和錯誤。只有當頁面是錯誤處理頁面時，即isErroePage爲 true時，該對象才能夠使用。

2. JSP

JSP的前身就是Servlet

3. Tomcat

3.1 Tomcat容器的等級

Tomcat - Container - Engine - Host - Servlet - 多個Context(一個Context對應一個web工程)-Wrapper

4. struts

struts可進行文件上傳
struts基於MVC模式
struts讓流程結構更清晰
struts有許多action類, 會增長類文件數目

5. Hibernate的7大鼓勵措施

儘可能使用many-to-one, 避免使用單項one-to-many
靈活使用單項one-to-many
不用一對一, 使用多對一代替一對一
配置對象緩存, 不使用集合對象
一對多使用bag, 多對一使用set
繼承使用顯示多態
消除大表, 使用二級緩存

6. Hibernate延遲加載

Hibernate2延遲加載實現：a)實體對象 b)集合（Collection）
Hibernate3 提供了屬性的延遲加載功能當Hibernate在查詢數據的時候，數據並無存在與內存中，當程序真正對數據的操做時，對象才存在與內存中，就實現了延遲加載，他節省了服務器的內存開銷，從而提升了服務器的性能。
hibernate使用Java反射機制，而不是字節碼加強程序來實現透明性。
hibernate的性能很是好，由於它是個輕量級框架。映射的靈活性很出色。它支持各類關係數據庫，從一對一到多對多的各類複雜關係。

7. Java 中，DOM 和 SAX 解析器有什麼不一樣？

DOM 解析器將整個 XML 文檔加載到內存來建立一棵 DOM 模型樹，這樣能夠更快的查找節點和修改 XML 結構，而 SAX 解析器是一個基於事件的解析器，不會將整個 XML 文檔加載到內存。因爲這個緣由，DOM 比 SAX 更快，也要求更多的內存，但不適合於解析大的 XML 文件。

8. Java 中，Maven 和 ANT 有什麼區別？

雖然二者都是構建工具，都用於建立 Java 應用，可是 Maven 作的事情更多，在基於「約定優於配置」的概念下，提供標準的Java 項目結構，同時能爲應用自動管理依賴（應用中所依賴的 JAR 文件）。

9. 解析XML不一樣方式對比

DOM、SAX、JDOM、DOM4J

DOM DOM樹駐留內存

能夠進行修改和寫入,耗費內存。

步驟：建立DocumentBuilderFactory對象 -> 建立DocumentBuilder對象 -> Document document = db.parse("xml")

SAX 事件驅動模式

獲取一個SAXParserFactory工廠的實例 -> 根據該實例獲取SAXParser -> 建立Handler對象 -> 調用SAXParser的parse方法解析

用於讀取節點數據不易編碼事件有順序很難同時訪問xml的多處數據

JDOM

建立一個SAXBuilder的對象 -> 建立一個輸入流，加載xml文件 ->經過saxBuilder的build方法將輸入流加載至saxBuilder並接收Document對象

使用具體類而不使用接口

DOM4J

經過SAXReader的read方法加載xml文件並獲取document對象

使用接口和抽象類，靈活性好，功能強大

10. Nginx相關

請參考個人Nginx

11. XML與JSON對比和區別

XML

1）應用普遍，可擴展性強，被普遍應用各類場合
2）讀取、解析沒有JSON快
3）可讀性強，可描述複雜結構

JSON

1）結構簡單，都是鍵值對
2）讀取、解析速度快，不少語言支持
3）傳輸數據量小，傳輸速率大大提升
4）描述複雜結構能力較弱

JavaScript、PHP等原生支持，簡化了讀取解析。成爲當前互聯網時代廣泛應用的數據結構。

3、多線程和併發

0. Java 中的 volatile 變量是什麼

Java 語言提供了一種稍弱的同步機制,即volatile變量。可是volatile並不容易徹底被正確、完整的理解。通常來講，volatile具有2條語義，或者說2個特性。第一是保證volatile修飾的變量對全部線程的可見性，這裏的可見性是指當一條線程修改了該變量，新值對於其它線程來講是當即能夠得知的。而普通變量作不到這一點。

第二條語義是禁止指令重排序優化，這條語義在JDK1.5才被修復。

關於第一點：根據JMM，全部的變量存儲在主內存，而每一個線程還有本身的工做內存，線程的工做內存保存該線程使用到的變量的主內存副本拷貝，線程對變量的操做在工做內存中進行，不能直接讀寫主內存的變量。在volatile可見性這一點上，普通變量作不到的緣由正因如此。好比，線程A修改了一個普通變量的值，而後向主內存進行回寫，線程B在線程A回寫完成後再從主內存讀取，新變量才能對線程B可見。其實，按照虛擬機規範，volatile變量依然有工做內存的拷貝，要藉助主內存來實現可見性。但因爲volatile的特殊規則保證了新值能當即同步回主內存，以及每次使用從主內存刷新，以此保證了多線程操做volatile變量的可見性。

關於第二點：先說指令重排序，指令重排序是指CPU採用了容許將多條指令不按規定順序分開發送給相應的處理單元處理，但並非說任意重排，CPU須要正確處理指令依賴狀況確保最終的正確結果，指令重排序是機器級的優化操做。那麼爲何volatile要禁止指令重排序呢，又是如何去作的。舉例，DCL（雙重檢查加鎖）的單例模式。volatile修飾後，代碼中將會插入許多內存屏障指令保證處理器不發生亂序執行。同時因爲Happens-before規則的保證，在剛纔的例子中寫操做會發生在後續的讀操做以前。

除了以上2點，volatile還保證對於64位long和double的讀取是原子性的。由於在JMM中容許虛擬機對未被volatile修飾的64位的long和double讀寫操做分爲2次32位的操做來執行，這也就是所謂的long和double的非原子性協定。

基於以上幾點，咱們知道volatile雖然有這些語義和特性在併發的狀況下仍然不能保證線程安全。大部分狀況下仍然須要加鎖。

除非是如下2種狀況，1.運算結果不依賴變量的當前值，或者可以確保只有單一線程修改變量的值；2.變量不須要與其餘的狀態變量共同參與不變約束。

1. volatile簡述

Java 語言提供了一種稍弱的同步機制,即volatile變量.用來確保將變量的更新操做通知到其餘線程,保證了新值能當即同步到主內存,以及每次使用前當即從主內存刷新。當把變量聲明爲volatile類型後,編譯器與運行時都會注意到這個變量是共享的。volatile修飾變量,每次被線程訪問時強迫其從主內存重讀該值,修改後再寫回。保證讀取的可見性,對其餘線程當即可見。volatile的另外一個語義是禁止指令重排序優化。可是volatile並不保證原子性,也就不能保證線程安全。

2. Java 中能建立 volatile 數組嗎？

能，Java 中能夠建立 volatile 類型數組，不過只是一個指向數組的引用，而不是整個數組。個人意思是，若是改變引用指向的數組，將會受到 volatile 的保護，可是若是多個線程同時改變數組的元素，volatile 就不能起到以前的保護做用了。

3. volatile 能使得一個非原子操做變成原子操做嗎？

一個典型的例子是在類中有一個 long 類型的成員變量。若是你知道該成員變量會被多個線程訪問，如計數器、價格等，你最好是將其設置爲 volatile。爲何？由於 Java 中讀取 long 類型變量不是原子的，須要分紅兩步，若是一個線程正在修改該 long 變量的值，另外一個線程可能只能看到該值的一半（前 32 位）。可是對一個 volatile 型的 long 或 double 變量的讀寫是原子。

4. volatile 禁止指令重排序的底層原理 指令重排序，是指CPU容許多條指令不按程序規定的順序分開發送給相應電路單元處理。但並非說任意重排，CPU須要能正確處理指令依賴狀況以正確的執行結果。volatile禁止指令重排序是經過內存屏障實現的，指令重排序不能把後面的指令重排序到內存屏障以前。由內存屏障保證一致性。注：該條語義在JDK1.5才得以修復，這點也是JDK1.5以前沒法經過雙重檢查加鎖來實現單例模式的緣由。

5. volatile 類型變量提供什麼保證？

volatile 變量提供有序性和可見性保證，例如，JVM 或者 JIT爲了得到更好的性能會對語句重排序，可是 volatile 類型變量即便在沒有同步塊的狀況下賦值也不會與其餘語句重排序。 volatile 提供 happens-before 的保證，確保一個線程的修改能對其餘線程是可見的。某些狀況下，volatile 還能提供原子性，如讀 64 位數據類型，像 long 和 double 都不是原子的，但 volatile 類型的 double 和 long 就是原子的。

volatile的使用場景：

運算結果不依賴變量的當前值，或者可以確保只有單一的線程修改該值
變量不須要與其餘狀態變量共同參與不變約束

6. volatile的性能

volatile變量的讀操做性能消耗和普通變量差很少，可是寫操做可能相對慢一些，由於它須要在本地代碼中插入許多內存屏障指令以確保處理器不發生亂序執行。大多數狀況下，volatile總開銷比鎖低，但咱們要注意volatile的語義可否知足使用場景。

7. 10 個線程和 2 個線程的同步代碼，哪一個更容易寫？

從寫代碼的角度來講，二者的複雜度是相同的，由於同步代碼與線程數量是相互獨立的。可是同步策略的選擇依賴於線程的數量，由於越多的線程意味着更大的競爭，因此你須要利用同步技術，如鎖分離，這要求更復雜的代碼和專業知識。

8. 你是如何調用 wait（）方法的？使用 if 塊仍是循環？爲何？

wait() 方法應該在循環調用，由於當線程獲取到 CPU 開始執行的時候，其餘條件可能尚未知足，因此在處理前，循環檢測條件是否知足會更好。下面是一段標準的使用 wait 和 notify 方法的代碼：


// The standard idiom for using the wait method
synchronized (obj) {
while (condition does not hold)
obj.wait(); // (Releases lock, and reacquires on wakeup)
... // Perform action appropriate to condition
}

參見 Effective Java 第 69 條，獲取更多關於爲何應該在循環中來調用 wait 方法的內容。

9. 什麼是多線程環境下的僞共享（false sharing）？

僞共享是多線程系統（每一個處理器有本身的局部緩存）中一個衆所周知的性能問題。僞共享發生在不一樣處理器的上的線程對變量的修改依賴於相同的緩存行，以下圖所示：

僞共享問題很難被發現，由於線程可能訪問徹底不一樣的全局變量，內存中卻碰巧在很相近的位置上。如其餘諸多的併發問題，避免僞共享的最基本方式是仔細審查代碼，根據緩存行來調整你的數據結構。

10. 線程的run方法和start方法

run方法

只是thread類的一個普通方法,若直接調用程序中依然只有主線程這一個線程,還要順序執行,依然要等待run方法體執行完畢纔可執行下面的代碼。

start方法

用start方法來啓動線程,是真正實現了多線程。調用thread類的start方法來啓動一個線程,此時線程處於就緒狀態,一旦獲得cpu時間片,就開始執行run方法。

11. ReadWriteLock(讀寫鎖)

寫寫互斥讀寫互斥讀讀併發, 在讀多寫少的狀況下能夠提升效率

12. resume(繼續掛起的線程)和suspend(掛起線程)一塊兒用

13. wait與notify、notifyall一塊兒用

14. sleep與wait的異同點

sleep是Thread類的靜態方法, wait來自object類
sleep方法短暫停頓不釋放鎖, wait方法條件等待要釋放鎖，由於只有這樣，其餘等待的線程才能在知足條件時獲取到該鎖。
wait, notify, notifyall必須在同步代碼塊中使用, sleep能夠在任何地方使用
均可以拋出InterruptedException

15. 讓一個線程中止執行

異常 - 中止執行休眠 - 中止執行阻塞 - 中止執行

16. ThreadLocal簡介

16.1 ThreadLocal解決了變量併發訪問的衝突問題

當使用ThreadLocal維護變量時,ThreadLocal爲每一個使用該變量的線程提供獨立的變量副本,每一個線程均可以獨立地改變本身的副本,而不會影響其它線程所對應的副本,是線程隔離的。線程隔離的祕密在於ThreadLocalMap類(ThreadLocal的靜態內部類)

16.2 與synchronized同步機制的比較

首先,它們都是爲了解決多線程中相同變量訪問衝突問題。不過,在同步機制中,要經過對象的鎖機制保證同一時間只有一個線程訪問該變量。該變量是線程共享的, 使用同步機制要求程序縝密地分析何時對該變量讀寫, 何時須要鎖定某個對象, 何時釋放對象鎖等複雜的問題,程序設計編寫難度較大, 是一種「以時間換空間」的方式。而ThreadLocal採用了以「以空間換時間」的方式。

17. 線程局部變量原理

線程局部變量是侷限於線程內部的變量，屬於線程自身全部，不在多個線程間共享。Java 提供 ThreadLocal 類來支持線程局部變量，是一種實現線程安全的方式。可是在管理環境下（如 web 服務器）使用線程局部變量的時候要特別當心，在這種狀況下，工做線程的生命週期比任何應用變量的生命週期都要長。任何線程局部變量一旦在工做完成後沒有釋放，Java 應用就存在內存泄露的風險。

ThreadLocal的方法：void set(T value)、T get()以及T initialValue()。

ThreadLocal是如何爲每一個線程建立變量的副本的：

首先，在每一個線程Thread內部有一個ThreadLocal.ThreadLocalMap類型的成員變量threadLocals，這個threadLocals就是用來存儲實際的變量副本的，鍵值爲當前ThreadLocal變量，value爲變量副本（即T類型的變量）。初始時，在Thread裏面，threadLocals爲空，當經過ThreadLocal變量調用get()方法或者set()方法，就會對Thread類中的threadLocals進行初始化，而且以當前ThreadLocal變量爲鍵值，以ThreadLocal要保存的副本變量爲value，存到threadLocals。而後在當前線程裏面，若是要使用副本變量，就能夠經過get方法在threadLocals裏面查找。

總結：

實際的經過ThreadLocal建立的副本是存儲在每一個線程本身的threadLocals中的
爲什麼threadLocals的類型ThreadLocalMap的鍵值爲ThreadLocal對象，由於每一個線程中可有多個threadLocal變量，就像上面代碼中的longLocal和stringLocal；
在進行get以前，必須先set，不然會報空指針異常；若是想在get以前不須要調用set就能正常訪問的話，必須重寫initialValue()方法

18. JDK提供的用於併發編程的同步器

Semaphore Java併發庫的Semaphore能夠很輕鬆完成信號量控制，Semaphore能夠控制某個資源可被同時訪問的個數，經過 acquire() 獲取一個許可，若是沒有就等待，而 release() 釋放一個許可。
CyclicBarrier 主要的方法就是一個：await()。await()方法每被調用一次，計數便會減小1，並阻塞住當前線程。當計數減至0時，阻塞解除，全部在此CyclicBarrier上面阻塞的線程開始運行。
CountDownLatch 直譯過來就是倒計數(CountDown)門閂(Latch)。倒計數不用說，門閂的意思顧名思義就是阻止前進。在這裏就是指 CountDownLatch.await() 方法在倒計數爲0以前會阻塞當前線程。

19. 什麼是 Busy spin？咱們爲何要使用它？

Busy spin 是一種在不釋放 CPU 的基礎上等待事件的技術。它常常用於避免丟失 CPU 緩存中的數據（若是線程先暫停，以後在其餘CPU上運行就會丟失）。因此，若是你的工做要求低延遲，而且你的線程目前沒有任何順序，這樣你就能夠經過循環檢測隊列中的新消息來代替調用 sleep() 或 wait() 方法。它惟一的好處就是你只需等待很短的時間，如幾微秒或幾納秒。LMAX 分佈式框架是一個高性能線程間通訊的庫，該庫有一個 BusySpinWaitStrategy 類就是基於這個概念實現的，使用 busy spin 循環 EventProcessors 等待屏障。

20. Java 中怎麼獲取一份線程 dump 文件？

在 Linux 下，你能夠經過命令 kill -3 PID （Java 進程的進程 ID）來獲取 Java 應用的 dump 文件。在 Windows 下，你能夠按下 Ctrl + Break 來獲取。這樣 JVM 就會將線程的 dump 文件打印到標準輸出或錯誤文件中，它可能打印在控制檯或者日誌文件中，具體位置依賴應用的配置。

21. Swing 是線程安全的？

不是，Swing 不是線程安全的。你不能經過任何線程來更新 Swing 組件，如 JTable、JList 或 JPanel，事實上，它們只能經過 GUI 或 AWT 線程來更新。這就是爲何 Swing 提供 invokeAndWait() 和 invokeLater() 方法來獲取其餘線程的 GUI 更新請求。這些方法將更新請求放入 AWT 的線程隊列中，能夠一直等待，也能夠經過異步更新直接返回結果。

22. 用 wait-notify 寫一段代碼來解決生產者-消費者問題？

記住在同步塊中調用 wait() 和 notify()方法，若是阻塞，經過循環來測試等待條件。

23. 用 Java 寫一個線程安全的單例模式（Singleton）？

當咱們說線程安全時，意思是即便初始化是在多線程環境中，仍然能保證單個實例。Java 中，使用枚舉做爲單例類是最簡單的方式來建立線程安全單例模式的方式。參見我整理的單例的文章6種單例模式的實現以及double check的剖析

24. Java 中，編寫多線程程序的時候你會遵循哪些最佳實踐？

這是我在寫Java 併發程序的時候遵循的一些最佳實踐：

a）給線程命名，這樣能夠幫助調試。

b）最小化同步的範圍，而不是將整個方法同步，只對關鍵部分作同步。

c）若是能夠，更偏向於使用 volatile 而不是 synchronized。

d）使用更高層次的併發工具，而不是使用 wait() 和 notify() 來實現線程間通訊，如 BlockingQueue，CountDownLatch 及 Semeaphore。

e）優先使用併發集合，而不是對集合進行同步。併發集合提供更好的可擴展性。

25. 說出至少 5 點在 Java 中使用線程的最佳實踐。

這個問題與以前的問題相似，你能夠使用上面的答案。對線程來講，你應該：

a）對線程命名

b）將線程和任務分離，使用線程池執行器來執行 Runnable 或 Callable。

c）使用線程池

26. 在多線程環境下，SimpleDateFormat 是線程安全的嗎？

不是，很是不幸，DateFormat 的全部實現，包括 SimpleDateFormat 都不是線程安全的，所以你不該該在多線程序中使用，除非是在對外線程安全的環境中使用，如將 SimpleDateFormat 限制在 ThreadLocal 中。若是你不這麼作，在解析或者格式化日期的時候，可能會獲取到一個不正確的結果。所以，從日期、時間處理的全部實踐來講，我強力推薦 joda-time 庫。

27. Happens-Before規則

程序次序規則

按控制流順序前後發生

管程鎖定規則

一個unlock操做先行發生於後面對同一個鎖的lock操做

volatile變量規則

對一個volatile變量的寫操做先行發生於後面對這個變量的讀操做

線程啓動規則

start方法先行發生於線程的每個動做

線程中斷規則

對線程的interrupt方法調用先行發生於被中斷線程的代碼檢測到中斷時間的發生

線程終止規則

線程內的全部操做都先行發生於對此線程的終止檢測

對象終結規則

一個對象的初始化完成先行發生於它的finalize方法的開始

傳遞性

若是A先行發生於操做B，B先行發生於操做C，則A先行發生於操做C

28. 什麼是線程

線程是操做系統可以進行運算調度的最小單位，它被包含在進程之中，是進程中的實際運做單位。程序員能夠經過它進行多處理器編程，能夠使用多線程對運算密集型任務提速。好比，若是一個線程完成一個任務要100 毫秒，那麼用十個線程完成改任務只需 10 毫秒。Java在語言層面對多線程提供了很好的支持。

29. 線程和進程有什麼區別

從概念上：

進程：一個程序對一個數據集的動態執行過程，是分配資源的基本單位。線程：存在於進程內，是進程內的基本調度單位。共享進程的資源。

從執行過程當中來看：

進程：擁有獨立的內存單元，而多個線程共享內存，從而提升了應用程序的運行效率。線程：每個獨立的線程，都有一個程序運行的入口、順序執行序列、和程序的出口。可是線程不可以獨立的執行，必須依存在應用程序中，由應用程序提供多個線程執行控制。

從邏輯角度來看：（重要區別）

多線程的意義在於一個應用程序中，有多個執行部分能夠同時執行。可是，操做系統並無將多個線程看作多個獨立的應用，來實現進程的調度和管理及資源分配。

簡言之，一個程序至少有一個進程,一個進程至少有一個線程。進程是資源分配的基本單位，線程共享進程的資源。

30. 用 Runnable 仍是 Thread

Java 不支持類的多重繼承，但容許你調用多個接口。因此若是你要繼承其餘類，固然是實現Runnable接口好了。

31. Java 中 Runnable 和 Callable 有什麼不一樣

Runnable和 Callable 都表明那些要在不一樣的線程中執行的任務。Runnable 從 JDK1.0 開始就有了，Callable 是在 JDK1.5 增長的。它們的主要區別是 Callable 的 call () 方法能夠返回值和拋出異常，而 Runnable 的 run ()方法沒有這些功能。

32. Java 中 CyclicBarrier 和 CountDownLatch 有什麼不一樣

它們都是JUC下的類，CyclicBarrier 和 CountDownLatch 均可以用來讓一組線程等待其它線程。區別在於CountdownLatch計數沒法被重置。若是須要重置計數，請考慮使用 CyclicBarrier。

33. Java 內存模型是什麼

Java 內存模型規定和指引Java 程序在不一樣的內存架構、CPU 和操做系統間有肯定性地行爲。它在多線程的狀況下尤爲重要。Java內存模型對一個線程所作的變更能被其它線程可見提供了保證，它們之間是先行發生關係。這個關係定義了一些規則讓程序員在併發編程時思路更清晰。

線程內的代碼可以按前後順序執行，這被稱爲程序次序規則。

對於同一個鎖，一個解鎖操做必定要發生在時間上後發生的另外一個鎖定操做以前，也叫作管程鎖定規則。

前一個對volatile的寫操做在後一個volatile的讀操做以前，也叫volatile變量規則。

一個線程內的任何操做必需在這個線程的 start ()調用以後，也叫做線程啓動規則。

對線程的interrupt方法調用先行發生於被中斷線程的代碼檢測到中斷時間的發生,線程中斷規則.

一個線程的全部操做都會在線程終止以前，線程終止規則。

一個對象的終結操做必需在這個對象構造完成以後，也叫對象終結規則。

a先行於b，b先行於c，傳遞性

34. 什麼是線程安全？Vector 是一個線程安全類嗎

若是你的代碼所在的進程中有多個線程在同時運行，而這些線程可能會同時運行這段代碼。若是每次運行結果和單線程運行的結果是同樣的，並且其餘的變量的值也和預期的是同樣的，就是線程安全的。一個線程安全的計數器類的同一個實例對象在被多個線程使用的狀況下也不會出現計算失誤。很顯然你能夠將集合類分紅兩組，線程安全和非線程安全的。Vector 是用同步方法來實現線程安全的，而和它類似的 ArrayList 不是線程安全的。

35. Java 中什麼是競態條件？舉個例子說明。

競態條件會致使程序在併發狀況下出現一些 bugs。多線程對一些資源的競爭的時候就會產生競態條件，若是首先要執行的程序競爭失敗排到後面執行了，那麼整個程序就會出現一些不肯定的 bugs。這種 bugs 很難發現並且會重複出現，由於線程間的隨機競爭。幾類競態條件check-and-act、讀取-修改-寫入、put-if-absent。

36. Java 中如何中止一個線程

當 run () 或者 call () 方法執行完的時候線程會自動結束，若是要手動結束一個線程，你能夠用 volatile 布爾變量來退出 run ()方法的循環或者是取消任務來中斷線程。其餘情形：異常 - 中止執行休眠 - 中止執行阻塞 - 中止執行

37. 一個線程運行時發生異常會怎樣

簡單的說，若是異常沒有被捕獲該線程將會中止執行。Thread.UncaughtExceptionHandler 是用於處理未捕獲異常形成線程忽然中斷狀況的一個內嵌接口。當一個未捕獲異常將形成線程中斷的時候 JVM 會使用 Thread.getUncaughtExceptionHandler ()來查詢線程的 UncaughtExceptionHandler 並將線程和異常做爲參數傳遞給 handler 的 uncaughtException ()方法進行處理。

38. 如何在兩個線程間共享數據？

經過共享對象來實現這個目的，或者是使用像阻塞隊列這樣併發的數據結構

39. Java 中 notify 和 notifyAll 有什麼區別

notify ()方法不能喚醒某個具體的線程，因此只有一個線程在等待的時候它纔有用武之地。而 notifyAll ()喚醒全部線程並容許他們爭奪鎖確保了至少有一個線程能繼續運行。

40. 爲何 wait, notify 和 notifyAll 這些方法不在 thread 類裏面

一個很明顯的緣由是 JAVA 提供的鎖是對象級的而不是線程級的。若是線程須要等待某些鎖那麼調用對象中的 wait ()方法就有意義了。若是 wait ()方法定義在 Thread 類中，線程正在等待的是哪一個鎖就不明顯了。簡單的說，因爲 wait，notify 和 notifyAll 都是鎖級別的操做，因此把他們定義在 Object 類中由於鎖屬於對象。

41. 什麼是 FutureTask？

在 Java 併發程序中 FutureTask 表示一個能夠取消的異步運算。它有啓動和取消運算、查詢運算是否完成和取回運算結果等方法。只有當運算完成的時候結果才能取回，若是運算還沒有完成 get 方法將會阻塞。一個 FutureTask 對象能夠對調用了 Callable 和 Runnable 的對象進行包裝，因爲 FutureTask 也是調用了 Runnable 接口因此它能夠提交給 Executor 來執行。

42. Java 中 interrupted 和 isInterrupted 方法的區別

interrupted是靜態方法，isInterrupted是一個普通方法

若是當前線程被中斷（沒有拋出中斷異常，不然中斷狀態就會被清除），你調用interrupted方法，第一次會返回true。而後，當前線程的中斷狀態被方法內部清除了。第二次調用時就會返回false。若是你剛開始一直調用isInterrupted，則會一直返回true，除非中間線程的中斷狀態被其餘操做清除了。也就是說isInterrupted 只是簡單的查詢中斷狀態，不會對狀態進行修改。

43. 爲何 wait 和 notify 方法要在同步塊中調用

若是不這麼作，代碼會拋出 IllegalMonitorStateException異常。還有一個緣由是爲了不 wait 和 notify 之間產生競態條件。

44. 爲何你應該在循環中檢查等待條件？

處於等待狀態的線程可能會收到錯誤警報和僞喚醒，若是不在循環中檢查等待條件，程序就會在沒有知足結束條件的狀況下退出。所以，當一個等待線程醒來時，不能認爲它原來的等待狀態仍然是有效的，在 notify 方法調用以後和等待線程醒來以前這段時間它可能會改變。這就是在循環中使用 wait 方法效果更好的緣由。

45. Java 中的同步集合與併發集合有什麼區別

同步集合與併發集合都爲多線程和併發提供了合適的線程安全的集合，不過併發集合的可擴展性更高。在 Java1.5 以前程序員們只有同步集合來用且在多線程併發的時候會致使爭用，阻礙了系統的擴展性。Java1.5加入了併發集合像 ConcurrentHashMap，不只提供線程安全還用鎖分離和內部分區等現代技術提升了可擴展性。它們大部分位於JUC包下。

46. 什麼是線程池？爲何要使用它？

建立線程要花費昂貴的資源和時間，若是任務來了才建立線程那麼響應時間會變長，並且一個進程能建立的線程數有限。爲了不這些問題，在程序啓動的時候就建立若干線程來響應處理，它們被稱爲線程池，裏面的線程叫工做線程。從 JDK1.5 開始，Java API 提供了 Executor 框架讓你能夠建立不一樣的線程池。好比單線程池，每次處理一個任務；數目固定的線程池或者是緩存線程池（一個適合不少生存期短的任務的程序的可擴展線程池）。

47. 如何寫代碼來解決生產者消費者問題？

在現實中你解決的許多線程問題都屬於生產者消費者模型，就是一個線程生產任務供其它線程進行消費，你必須知道怎麼進行線程間通訊來解決這個問題。比較低級的辦法是用 wait 和 notify 來解決這個問題，比較讚的辦法是用 Semaphore 或者 BlockingQueue 來實現生產者消費者模型。

48.如何避免死鎖？

死鎖是指兩個或兩個以上的進程在執行過程當中，因爭奪資源而形成的一種互相等待的現象，若無外力做用，它們都將沒法推動下去。這是一個嚴重的問題，由於死鎖會讓你的程序掛起沒法完成任務，死鎖的發生必須知足如下四個條件：

互斥條件：一個資源每次只能被一個進程使用。

請求與保持條件：一個進程因請求資源而阻塞時，對已得到的資源保持不放。

不剝奪條件：進程已得到的資源，在末使用完以前，不能強行剝奪。

循環等待條件：若干進程之間造成一種頭尾相接的循環等待資源關係。

避免死鎖最簡單的方法就是阻止循環等待條件，將系統中全部的資源設置標誌位、排序，規定全部的進程申請資源必須以必定的順序（升序或降序）作操做來避免死鎖。

49. Java 中活鎖和死鎖有什麼區別？

活鎖和死鎖相似，不一樣之處在於處於活鎖的線程或進程的狀態是不斷改變的，活鎖能夠認爲是一種特殊的飢餓。一個現實的活鎖例子是兩我的在狹小的走廊碰到，兩我的都試着避讓對方好讓彼此經過，可是由於避讓的方向都同樣致使最後誰都不能經過走廊。簡單的說就是，活鎖和死鎖的主要區別是前者進程的狀態能夠改變可是卻不能繼續執行。

50. 怎麼檢測一個線程是否擁有鎖

在 java.lang.Thread 中有一個方法叫 holdsLock，當且僅當當前線程擁有某個具體對象的鎖時它返回true。

51. 你如何在 Java 中獲取線程堆棧

52.Java 中 synchronized 和 ReentrantLock 有什麼不一樣

Java 在過去很長一段時間只能經過 synchronized 關鍵字來實現互斥，它有一些缺點。好比你不能擴展鎖以外的方法或者塊邊界，嘗試獲取鎖時不能中途取消等。Java 5 經過 Lock 接口提供了更復雜的控制來解決這些問題。 ReentrantLock 類實現了 Lock，它擁有與 synchronized 相同的併發性和內存語義且它還具備可擴展性。

53.有三個線程 T1，T2，T3，怎麼確保它們按順序執行

能夠用線程類的 join ()方法。具體操做是在T3的run方法中調用t2.join()，讓t2執行完再執行t3；T2的run方法中調用t1.join()，讓t1執行完再執行t2。這樣就按T1，T2，T3的順序執行了

54.Thread 類中的 yield 方法有什麼做用

Yield 方法能夠暫停當前正在執行的線程對象，讓其它有相同優先級的線程執行。它是一個靜態方法並且只保證當前線程放棄 CPU 佔用而不能保證使其它線程必定能佔用 CPU，執行 yield的線程有可能在進入到暫停狀態後立刻又被執行。

55.Java 中 ConcurrentHashMap 的併發度是什麼

ConcurrentHashMap 把實際 map 劃分紅若干部分來實現它的可擴展性和線程安全。這種劃分是使用併發度得到的，它是 ConcurrentHashMap 類構造函數的一個可選參數，默認值爲 16，這樣在多線程狀況下就能避免爭用。

56.Java 中 Semaphore是什麼

JUC下的一種新的同步類，它是一個計數信號。從概念上講，Semaphore信號量維護了一個許可集合。若有必要，在許可可用前會阻塞每個 acquire，而後再獲取該許可。每一個 release添加一個許可，從而可能釋放一個正在阻塞的獲取者。可是，不使用實際的許可對象，Semaphore 只對可用許可的號碼進行計數，並採起相應的行動。信號量經常用於多線程的代碼中，好比數據庫鏈接池。

57.若是你提交任務時，線程池隊列已滿。會發會生什麼？

這個問題問得很狡猾，許多程序員會認爲該任務會阻塞直到線程池隊列有空位。事實上若是一個任務不能被調度執行那麼 ThreadPoolExecutor’s submit ()方法將會拋出一個 RejectedExecutionException 異常。

58.Java 線程池中 submit () 和 execute ()方法有什麼區別

兩個方法均可以向線程池提交任務，execute ()方法的返回類型是 void，它定義在 Executor 接口中，而 submit ()方法能夠返回持有計算結果的 Future 對象，它定義在 ExecutorService 接口中，它擴展了 Executor 接口，其它線程池類像 ThreadPoolExecutor 和 ScheduledThreadPoolExecutor 都有這些方法。

59.什麼是阻塞式方法？

阻塞式方法是指程序會一直等待該方法完成期間不作其餘事情，ServerSocket 的 accept ()方法就是一直等待客戶端鏈接。這裏的阻塞是指調用結果返回以前，當前線程會被掛起，直到獲得結果以後纔會返回。此外，還有異步和非阻塞式方法在任務完成前就返回。

60.Swing 是線程安全的嗎？

你能夠很確定的給出回答，Swing 不是線程安全的。你不能經過任何線程來更新 Swing 組件，如 JTable、JList 或 JPanel，事實上，它們只能經過 GUI 或 AWT 線程來更新。這就是爲何 Swing 提供 invokeAndWait() 和 invokeLater() 方法來獲取其餘線程的 GUI 更新請求。這些方法將更新請求放入 AWT 的線程隊列中，能夠一直等待，也能夠經過異步更新直接返回結果。

61.Java 中 invokeAndWait 和 invokeLater 有什麼區別

這兩個方法是 Swing API 提供給 Java 開發者用來從當前線程而不是事件派發線程更新 GUI 組件用的。InvokeAndWait ()同步更新 GUI 組件，好比一個進度條，一旦進度更新了，進度條也要作出相應改變。若是進度被多個線程跟蹤，那麼就調用 invokeAndWait ()方法請求事件派發線程對組件進行相應更新。而 invokeLater ()方法是異步調用更新組件的。

62.Swing API 中那些方法是線程安全的？

雖然Swing不是線程安全的可是有一些方法是能夠被多線程安全調用的。如repaint ()， revalidate ()。 JTextComponent 的 setText ()方法和 JTextArea 的 insert () 和 append () 方法也是線程安全的。

63.如何在 Java 中建立 Immutable 對象

Immutable 對象能夠在沒有同步的狀況下共享，下降了對該對象進行併發訪問時的同步化開銷。但是 Java 沒有@Immutable 這個註解符，要建立不可變類，要實現下面幾個步驟：經過構造方法初始化全部成員、對變量不要提供 setter 方法、將全部的成員聲明爲私有的，這樣就不容許直接訪問這些成員、在 getter 方法中，不要直接返回對象自己，而是克隆對象，並返回對象的拷貝。

64.Java 中的 ReadWriteLock 是什麼？

通常而言，讀寫鎖是用來提高併發程序性能的鎖分離技術的成果。Java 中的 ReadWriteLock 是 Java 5 中新增的一個接口，一個 ReadWriteLock 維護一對關聯的鎖，一個用於只讀操做一個用於寫。在沒有寫線程的狀況下一個讀鎖可能會同時被多個讀線程持有。寫鎖是獨佔的，你能夠使用 JDK 中的 ReentrantReadWriteLock 來實現這個規則，它最多支持 65535 個寫鎖和 65535 個讀鎖。

65.多線程中的忙循環是什麼?

忙循環就是程序員用循環讓一個線程等待，不像傳統方法 wait ()， sleep () 或 yield () 它們都放棄了 CPU 控制，而忙循環不會放棄 CPU，它就是在運行一個空循環。這麼作的目的是爲了保留 CPU 緩存，在多核系統中，一個等待線程醒來的時候可能會在另外一個內核運行，這樣會重建緩存。爲了不重建緩存和減小等待重建的時間就能夠使用它了。

66.volatile 變量和 atomic 變量有什麼不一樣

volatile 變量和 atomic 變量看起來很像，但功能卻不同。volatile 變量能夠確保先行關係，即寫操做會發生在後續的讀操做以前，但它並不能保證原子性。例如用 volatile 修飾 count 變量那麼 count++ 操做並非原子性的。而 AtomicInteger 類提供的 atomic 方法可讓這種操做具備原子性如 getAndIncrement ()方法會原子性的進行增量操做把當前值加一，其它數據類型和引用變量也能夠進行類似操做。

67.若是同步塊內的線程拋出異常會發生什麼？

不管你的同步塊是正常仍是異常退出的，裏面的線程都會釋放鎖，因此對比鎖接口我更喜歡同步塊，由於它不用我花費精力去釋放鎖，該功能能夠在 finally block 裏釋放鎖實現。

68.如何在 Java 中建立線程安全的 Singleton

5種，急加載，同步方法，雙檢鎖，靜態內部類，枚舉

69.如何強制啓動一個線程？

這個問題就像是如何強制進行 Java 垃圾回收，目前尚未以爲方法，雖然你能夠使用 System.gc ()來進行垃圾回收，可是不保證能成功。在 Java 裏面沒有辦法強制啓動一個線程，它是被線程調度器控制着且 Java 沒有公佈相關的 API。

70.Java 中的 fork join 框架是什麼？

fork join 框架是 JDK7 中出現的一款高效的工具，Java 開發人員能夠經過它充分利用現代服務器上的多處理器。它是專門爲了那些能夠遞歸劃分紅許多子模塊設計的，目的是將全部可用的處理能力用來提高程序的性能。fork join 框架一個巨大的優點是它使用了工做竊取算法，能夠完成更多任務的工做線程能夠從其它線程中竊取任務來執行。

71.Java 多線程中調用 wait () 和 sleep ()方法有什麼不一樣？

Java 程序中 wait 和 sleep 都會形成某種形式的暫停，它們能夠知足不一樣的須要。wait ()方法意味着條件等待，若是等待條件爲真且其它線程被喚醒時它會釋放鎖，而 sleep ()方法僅僅釋放 CPU 資源或者讓當前線程短暫停頓，但不會釋放鎖。

72.可重入鎖

可重入鎖：若是當前線程已經得到了某個監視器對象所持有的鎖，那麼該線程在該方法中調用另一個同步方法也一樣持有該鎖。

public synchrnozied void test() {
    xxxxxx;
    test2();
}

public synchronized void test2() {
    yyyyy;
}

在上面代碼段中，執行 test 方法須要得到當前對象做爲監視器的對象鎖，但方法中又調用了 test2 的同步方法。

若是鎖是具備可重入性的話，那麼該線程在調用 test2 時並不須要再次得到當前對象的鎖，能夠直接進入 test2 方法進行操做。

若是鎖是不具備可重入性的話，那麼該線程在調用test2前會等待當前對象鎖的釋放，實際上該對象鎖已被當前線程所持有，不可能再次得到。

若是鎖是不具備可重入性特色的話，那麼線程在調用同步方法、含有鎖的方法時就會產生死鎖。

73. 同步方法和同步代碼塊

同步方法默認用this或者當前類class對象做爲鎖；同步代碼塊能夠選擇以什麼來加鎖，比同步方法要更細顆粒度，咱們能夠選擇只同步會發生同步問題的部分代碼而不是整個方法。

4、Java虛擬機

0. 對哪些區域回收

Java運行時數據區域：程序計數器、JVM棧、本地方法棧、方法區和堆。

因爲程序計數器、JVM棧、本地方法棧3個區域隨線程而生隨線程而滅，對這幾個區域內存的回收和分配具備肯定性。而方法區和堆則不同，程序須要在運行時才知道建立哪些對象，對這部份內存的分配是動態的，GC關注的也就是這部份內存。

1. 主動GC

調用system.gc(), Runtime.getRuntime.gc()

2. 垃圾回收

釋放那些不在持有任何引用的對象的內存

3. 怎樣判斷是否須要收集

引用計數法：對象沒有任何引用與之關聯(沒法解決循環引用)

ext：Python使用引用計數法

可達性分析法：經過一組稱爲GC Root的對象爲起點,從這些節點向下搜索，若是某對象不能從這些根對象的一個(至少一個)所到達,則斷定該對象應當回收。

ext：可做爲GCRoot的對象：虛擬機棧中引用的對象。方法區中類靜態屬性引用的對象，方法區中類常量引用的對象，本地方法棧中JNI引用的對象

4.對象的自我救贖

即便在可達性算法中斷定爲不可達時，也並不是必定被回收。對象存在自我救贖的可能。要真正宣告對象的死亡，須要經歷2次標記的過程。若是對象通過可達性分析法發現不可達時，對象將被第一次標記被進行篩選，篩選的條件是此對象是否有必要執行finalize方法。若是對象沒有重寫finalize方法或finalize方法已經被JVM調用過，則斷定爲不須要執行。

若是對象被斷定爲須要執行finalize方法，該對象將被放置在一個叫作F-Queue的隊列中，JVM會創建一個低優先級的線程執行finalize方法，若是對象想要完成自我救贖須要在finalize方法中與引用鏈上的對象關聯，好比把本身也就是this賦值給某個類變量。當GC第二次對F-Queue中對象標記時，該對象將被移出「即將回收」的集合，完成自我救贖。簡言之，finalize方法是對象逃脫死亡命運的最後機會，而且任何對象的finalize方法只會被JVM調用一次。

5.垃圾回收算法

Mark-Sweep法：標記清除法容易產生內存碎片，致使分配較大對象時沒有足夠的連續內存空間而提早出發GC。這裏涉及到另外一個問題，即對象建立時的內存分配，對象建立內存分配主要有2種方法，分別是指針碰撞法和空閒列表法。指針碰撞法：使用的內存在一側，空閒的在另外一側，中間使用一個指針做爲分界點指示器，對象內存分配時只要指針向空閒的移動對象大小的距離便可。空閒列表法：使用的和空閒的內存相互交錯沒法進行指針碰撞，JVM必須維護一個列表記錄哪些內存塊可用，分配時從列表中找出一個足夠的分配給對象，並更新列表記錄。因此，當採用Mark-Sweep算法的垃圾回收器時，內存分配一般採用空閒列表法。

Copy法：將內存分爲2塊，每次使用其中的一塊，當一塊滿了，將存活的對象複製到另外一塊，把使用過的那一塊一次性清除。顯然，Copy法解決了內存碎片的問題，但算法的代價是內存縮小爲原來的一半。現代的垃圾收集器對新生代採用的正是Copy算法。但一般不執行1:1的策略，HotSpot虛擬機默認Eden區Survivor區8:1。每次使用Eden和其中一塊Survivor區。也就是說新生代可用內存爲新生代內存空間的90%。

Mark-Compact法：標記整理法。它的第一階段與Mark-Sweep法同樣，但不直接清除，而是將存活對象向一端移動，而後清除端邊界之外的內存，這樣也不存在內存碎片。

分代收集算法：將堆內存劃分爲新生代，老年代，根據新生代老年代的特色選取不一樣的收集算法。由於新生代對象大多朝生夕死，而老年代對象存活率高，沒有額外空間進行分配擔保，一般對新生代執行復制算法，老年代執行Mark-Sweep算法或Mark-Compact算法。

6.垃圾收集器

一般來講，新生代老年代使用不一樣的垃圾收集器。新生代的垃圾收集器有Serial（單線程）、ParNew（Serial的多線程版本）、ParallelScavenge（吞吐量優先的垃圾收集器），老年代有SerialOld（單線程老年代）、ParallelOld（與ParallelScavenge搭配的多線程執行標記整理算法的老年代收集器）、CMS（標記清除算法，容易產生內存碎片，能夠開啓內存整理的參數），以及當前最早進的垃圾收集器G1，G1一般面向服務器端的垃圾收集器，在我本身的Java應用程序中經過-XX:+PrintGCDetails，發現本身的垃圾收集器是使用了ParallelScavenge + ParallelOld的組合。

7. 不一樣垃圾回收算法對比

標記清除法(Mark-Sweeping):易產生內存碎片
複製回收法(Copying)：爲了解決Mark-Sweep法而提出,內存空間減至一半
標記壓縮法(Mark-Compact):爲了解決Copying法的缺陷,標記後移動到一端再清除
分代回收法(GenerationalCollection):新生代對象存活週期短,須要大量回收對象,須要複製的少,執行copy算法;老年代對象存活週期相對長,回收少許對象,執行mark-compact算法.新生代劃分：較大的eden區和 2個survivor區

8. 內存分配

新生代的三部分 |Eden Space|From Space|To Space|，對象主要分配在新生代的Eden區
大對象直接進入老年代大對象好比大數組直接進入老年代，可經過虛擬機參數-XX：PretenureSizeThreshold參數設置
長期存活的對象進入老年代 ext：虛擬機爲每一個對象定義一個年齡計數器，若是對象在Eden區出生並通過一次MinorGC仍然存活，將其移入Survivor的To區，GC完成標記互換後，至關於存活的對象進入From區，對象年齡加1，當增長到默認15歲時，晉升老年代。可經過-XX：MaxTenuringThreshold設置
GC的過程：GC開始前，對象只存在於Eden區和From區，To區邏輯上始終爲空。對象分配在Eden區，Eden區空間不足，發起MinorGC，將Eden區全部存活的對象複製到To區，From區存活的對象根據年齡判斷去向，若到達年齡閾值移入老年代，不然也移入To區，GC完成後Eden區和From區被清空，From區和To區標記互換。對象每在Survivor區躲過一次MinorGC年齡加一。MinorGC將重複這樣的過程，直到To區被填滿，To區滿了之後，將把全部對象移入老年代。
動態對象年齡斷定 suvivor區相同年齡對象總和大於suvivor區空間的一半,年齡大於等於該值的對象直接進入老年代
空間分配擔保在MinorGC開始前，虛擬機檢查老年代最大可用連續空間是否大於新生代全部對象總空間，若是成立，MinorGC能夠確保是安全的。不然，虛擬機會查看HandlePromotionFailure設置值是否容許擔保失敗，若是容許，繼續查看老年代最大可用連續空間是否大於歷次晉升到老年代對象的平均大小，若是大於則嘗試MinorGC，儘管此次MinorGC是有風險的。若是小於，或者HandlerPromotionFailure設置不容許，則要改成FullGC。
新生代的回收稱爲MinorGC,對老年代的回收成爲MajorGC又名FullGC

9. 關於GC的虛擬機參數

GC相關

-XX:NewSize和-XX:MaxNewSize 新生代大小 -XX:SurvivorRatio Eden和其中一個survivor的比值 -XX：PretenureSizeThreshold 大對象進入老年代的閾值 -XX:MaxTenuringThreshold 晉升老年代的對象年齡

收集器設置 -XX:+UseSerialGC:設置串行收集器 -XX:+UseParallelGC:設置並行收集器 -XX:+UseParalledlOldGC:設置並行年老代收集器 -XX:+UseConcMarkSweepGC:設置併發收集器

堆大小設置

-Xmx:最大堆大小 -Xms:初始堆大小(最小內存值) -Xmn:年輕代大小 -XXSurvivorRatio:3 意思是Eden:Survivor=3:2 -Xss棧容量

垃圾回收統計信息

-XX:+PrintGC 輸出GC日誌 -XX:+PrintGCDetails 輸出GC的詳細日誌

10. 方法區的回收

方法區一般會與永久代劃等號，實際上兩者並不等價，只不過是HotSpot虛擬機設計者用永久代實現方法區，並將GC分代擴展至方法區。永久代垃圾回收一般包括兩部份內容：廢棄常量和無用的類。常量的回收與堆區對象的回收相似，當沒有其餘地方引用該字面量時，若是有必要，將被清理出常量池。

斷定無用的類的3個條件：

1.該類的全部實例都已經被回收，也就是說堆中不存在該類的任何實例

2.加載該類的ClassLoader已經被回收

3.該類對應的java.lang.Class對象沒有在任何地方被引用，沒法在任何地方經過反射訪問該類的方法。

固然，這也僅僅是斷定，不表明當即卸載該類。

11. JVM工具

命令行

jps(jvm processor status)虛擬機進程情況工具
jstat(jvm statistics monitoring)統計信息監視
jinfo(configuration info for java)配置信息工具
jmap(memory map for java)Java內存映射工具
jhat(JVM Heap Analysis Tool)虛擬機堆轉儲快照分析工具
jstack(Stack Trace for Java)Java堆棧跟蹤工具
HSDIS：JIT生成代碼反彙編

可視化

JConsole(Java Monitoring and Management Console):Java監視與管理控制檯
VisualVM(All-in-one Java Troubleshooting Tool):多合一故障處理工具

12. JVM內存結構

堆:新生代和年老代
方法區(非堆):持久代, 代碼緩存, 線程共享
JVM棧:中間結果,局部變量,線程隔離
本地棧:本地方法(非Java代碼)
程序計數器：線程私有，每一個線程都有本身獨立的程序計數器，用來指示下一條指令的地址
注：持久代Java8消失, 取代的稱爲元空間(本地堆內存的一部分)

13. JVM的方法區

與堆同樣，是線程共享的區域。方法區中存儲：被虛擬機加載的類信息，常量，靜態變量，JIT編譯後的代碼等數據。參見我是一個Java Class。

14. Java類加載器

一個jvm中默認的classloader有Bootstrap ClassLoader、Extension ClassLoader、App ClassLoader，分別各司其職：

Bootstrap ClassLoader(引導類加載器) 負責加載java基礎類，主要是 %JRE_HOME/lib/目錄下的rt.jar、resources.jar、charsets.jar等
Extension ClassLoader(擴展類加載器) 負責加載java擴展類，主要是 %JRE_HOME/lib/ext目錄下的jar等
App ClassLoader(系統類加載器) 負責加載當前java應用的classpath中的全部類。 classloader 加載類用的是全盤負責委託機制。所謂全盤負責，便是當一個classloader加載一個Class的時候，這個Class所依賴的和引用的全部 Class也由這個classloader負責載入，除非是顯式的使用另一個classloader載入。因此，當咱們自定義的classloader加載成功了com.company.MyClass之後，MyClass裏全部依賴的class都由這個classLoader來加載完成。

15. 64 位 JVM 中，int 的長度是多大？

Java 中，int 類型變量的長度是一個固定值，與平臺無關，都是 32 位。意思就是說，在 32 位和 64 位的Java 虛擬機中，int 類型的長度是相同的。

16. Serial 與 Parallel GC之間的不一樣之處？

Serial 與 Parallel 在GC執行的時候都會引發 stop-the-world。它們之間主要不一樣 serial 收集器是默認的複製收集器，執行 GC 的時候只有一個線程，而 parallel 收集器使用多個 GC 線程來執行。

17.Java 中 WeakReference 與 SoftReference的區別？

Java中一共有四種類型的引用。StrongReference、 SoftReference、 WeakReference 以及 PhantomReference。

StrongReference：Java 的默認引用實現, 它會盡量長時間的存活於 JVM 內，當沒有任何對象指向它時將會被GC回收

SoftReference：儘量長時間保留引用，直到JVM內存不足，適合某些緩存應用

WeakReference：顧名思義, 是一個弱引用, 當所引用的對象在 JVM 內再也不有強引用時, 下一次將被GC回收

PhantomReference：它是最弱的一種引用關係，也沒法經過PhantomReference取得對象的實例。僅用來當該對象被回收時收到一個通知

雖然 WeakReference 與 SoftReference 都有利於提升 GC 和內存的效率，可是 WeakReference ，一旦失去最後一個強引用，就會被 GC 回收，而 SoftReference 會盡量長的保留引用直到 JVM 內存不足時纔會被回收(虛擬機保證), 這一特性使得 SoftReference 很是適合緩存應用。

18. WeakHashMap 是怎麼工做的？

WeakHashMap 的工做與正常的 HashMap 相似，可是使用弱引用做爲 key，意思就是當 key 對象沒有任何引用時，key/value 將會被回收。

19. JVM 選項 -XX:+UseCompressedOops 有什麼做用？爲何要使用？

當你將你的應用從 32 位的 JVM 遷移到 64 位的 JVM 時，因爲對象的指針從 32 位增長到了 64 位，所以堆內存會忽然增長，差很少要翻倍。這也會對 CPU 緩存（容量比內存小不少）的數據產生不利的影響。由於，遷移到 64 位的 JVM 主要動機在於能夠指定最大堆大小，經過壓縮 OOP 能夠節省必定的內存。經過 -XX:+UseCompressedOops 選項，JVM 會使用 32 位的 OOP，而不是 64 位的 OOP。

20. 怎樣經過 Java 程序來判斷 JVM 是 32 位仍是 64 位？

你能夠檢查某些系統屬性如 sun.arch.data.model 或 os.arch 來獲取該信息。

21. 32 位 JVM 和 64 位 JVM 的最大堆內存分別是多數？

理論上說上 32 位的 JVM 堆內存能夠到達 2^32，即 4GB，但實際上會比這個小不少。不一樣操做系統之間不一樣，如 Windows 系統大約 1.5 GB，Solaris 大約 3GB。64 位 JVM容許指定最大的堆內存，理論上能夠達到 2^64，這是一個很是大的數字，實際上你能夠指定堆內存大小到 100GB。甚至有的 JVM，如 Azul，堆內存到 1000G 都是可能的。

22. JRE、JDK、JVM 及 JIT 之間有什麼不一樣？

JRE 表明 Java 運行時（Java run-time），是運行 Java 應用所必須的。JDK 表明 Java 開發工具（Java development kit），是 Java 程序的開發工具，如 Java 編譯器，它也包含 JRE。JVM 表明 Java 虛擬機（Java virtual machine），它的責任是運行 Java 應用。JIT 表明即時編譯（Just In Time compilation），當代碼執行的次數超過必定的閾值時，會將 Java 字節碼轉換爲本地代碼，如，主要的熱點代碼會被準換爲本地代碼，這樣有利大幅度提升 Java 應用的性能。

23. 解釋 Java 堆空間及 GC？

當經過 Java 命令啓動 Java 進程的時候，會爲它分配內存。內存的一部分用於建立堆空間，當程序中建立對象的時候，就從對空間中分配內存。GC 是 JVM 內部的一個後臺進程，回收無效對象的內存用於未來的分配。

24. 你能保證 GC 執行嗎？

不能，雖然你能夠調用 System.gc() 或者 Runtime.getRuntime().gc()，可是沒有辦法保證 GC 的執行。

25. 怎麼獲取 Java 程序使用的內存？堆使用的百分比？

能夠經過 java.lang.Runtime 類中與內存相關方法來獲取剩餘的內存，總內存及最大堆內存。經過這些方法你也能夠獲取到堆使用的百分比及堆內存的剩餘空間。Runtime.freeMemory() 方法返回剩餘空間的字節數，Runtime.totalMemory() 方法總內存的字節數，Runtime.maxMemory() 返回最大內存的字節數。

26. Java 中堆和棧有什麼區別？

JVM 中堆和棧屬於不一樣的內存區域，使用目的也不一樣。棧經常使用於保存方法幀和局部變量，而對象老是在堆上分配。棧一般都比堆小，也不會在多個線程之間共享，而堆被整個 JVM 的全部線程共享。

27. JVM調優

使用工具Jconsol、VisualVM、JProfiler等

堆信息查看

可查看堆空間大小分配（年輕代、年老代、持久代分配）提供即時的垃圾回收功能垃圾監控（長時間監控回收狀況）

查看堆內類、對象信息查看：數量、類型等

對象引用狀況查看

有了堆信息查看方面的功能，咱們通常能夠順利解決如下問題：

年老代年輕代大小劃分是否合理內存泄漏垃圾回收算法設置是否合理

線程監控

線程信息監控：系統線程數量。線程狀態監控：各個線程都處在什麼樣的狀態下

Dump線程詳細信息：查看線程內部運行狀況死鎖檢查

熱點分析

CPU熱點：檢查系統哪些方法佔用的大量CPU時間內存熱點：檢查哪些對象在系統中數量最大（必定時間內存活對象和銷燬對象一塊兒統計）

快照

系統兩個不一樣運行時刻，對象（或類、線程等）的不一樣

舉例說，我要檢查系統進行垃圾回收之後，是否還有該收回的對象被遺漏下來的了。那麼，我能夠在進行垃圾回收先後，分別進行一次堆狀況的快照，而後對比兩次快照的對象狀況。

內存泄漏檢查

年老代堆空間被佔滿

持久代被佔滿

堆棧溢出

線程堆棧滿

系統內存被佔滿

28. Java中有內存泄漏嗎？

內存泄露的定義: 當某些對象再也不被應用程序所使用,可是因爲仍然被引用而致使垃圾收集器不能釋放。

內存泄漏的緣由：對象的生命週期不一樣。好比說對象A引用了對象B. A的生命週期比B的要長得多，當對象B在應用程序中不會再被使用之後, 對象 A 仍然持有着B的引用. (根據虛擬機規範)在這種狀況下GC不能將B從內存中釋放。這種狀況極可能會引發內存問題，假若A還持有着其餘對象的引用,那麼這些被引用的(無用)對象也不會被回收,並佔用着內存空間。甚至有可能B也持有一大堆其餘對象的引用。這些對象因爲被B所引用,也不會被垃圾收集器所回收，全部這些無用的對象將消耗大量寶貴的內存空間。並可能致使內存泄漏。

怎樣防止：

一、小心集合類, 好比HashMap, ArrayList等,由於這是最容易發生內存泄露的地方.當集合對象被聲明爲static時,他們的生命週期通常和整個應用程序同樣長。

29. OOM解決辦法

內存溢出的空間：Permanent Generation和Heap Space，也就是永久代和堆區

一、永久代的OOM

解決辦法有2種：

a.經過虛擬機參數-XX：PermSize和-XX：MaxPermSize調整永久代大小

b.清理程序中的重複的Jar文件，減小類的重複加載

二、堆區的溢出

發生這種問題的緣由是java虛擬機建立的對象太多，在進行垃圾回收之間，虛擬機分配的到堆內存空間已經用滿了，與Heap Space的size有關。解決這類問題有兩種思路：

檢查程序，看是否存在死循環或沒必要要地重複建立大量對象，定位緣由，修改程序和算法。
經過虛擬機參數-Xms和-Xmx設置初始堆和最大堆的大小

30. DirectMemory直接內存

直接內存並非Java虛擬機規範定義的內存區域的一部分，可是這部份內存也被頻繁使用，並且也可能致使OOM異常的出現。

JDK1.4引入了NIO，這是一種基於通道和緩衝區的非阻塞IO模式，它能夠使用Native函數庫分配直接堆外內存，而後經過一個存儲在Java堆中的DirectByteBuffer對象做爲這塊內存的引用進行操做，使得在某些場合顯著提升性能，由於它避免了在Java堆和本地堆之間來回複製數據。

31. Java 中堆和棧有什麼不一樣

每一個線程都有本身的棧內存，用於存儲本地變量，方法參數和棧調用，一個線程中存儲的變量對其它線程是不可見的。而堆是全部線程共享的一片公用內存區域。對象都在堆裏建立，爲了提高效率線程會從堆中弄一個緩存到本身的棧，若是多個線程使用該變量就可能引起問題，這時 volatile 變量就能夠發揮做用了，它要求線程從主存中讀取變量的值。

32. 雙親委派模型中的方法

findLoadedClass(),LoadClass(),findBootstrapClassOrNull(),findClass(),resolveClass()

33. IO模型

通常來講 I/O 模型能夠分爲：同步阻塞，同步非阻塞，異步阻塞，異步非阻塞四種IO模型

同步阻塞 IO ：在此種方式下，用戶進程在發起一個 IO 操做之後，必須等待 IO 操做的完成，只有當真正完成了 IO 操做之後，用戶進程才能運行。 JAVA傳統的 IO 模型屬於此種方式！

同步非阻塞 IO: 在此種方式下，用戶進程發起一個 IO 操做之後可返回作其它事情，可是用戶進程須要時不時的詢問 IO 操做是否就緒，這就要求用戶進程不停的去詢問，從而引入沒必要要的 CPU 資源浪費。其中目前 JAVA 的 NIO 就屬於同步非阻塞 IO 。

異步阻塞 IO ：此種方式下是指應用發起一個 IO 操做之後，不等待內核 IO 操做的完成，等內核完成 IO 操做之後會通知應用程序，這其實就是同步和異步最關鍵的區別，同步必須等待或者主動的去詢問 IO 是否完成，那麼爲何說是阻塞的呢？由於此時是經過 select 系統調用來完成的，而 select 函數自己的實現方式是阻塞的，而採用 select 函數有個好處就是它能夠同時監聽多個文件句柄，從而提升系統的併發性！

異步非阻塞 IO: 在此種模式下，用戶進程只須要發起一個 IO 操做而後當即返回，等 IO 操做真正的完成之後，應用程序會獲得 IO 操做完成的通知，此時用戶進程只須要對數據進行處理就行了，不須要進行實際的 IO 讀寫操做，由於真正的 IO讀取或者寫入操做已經由內核完成了。目前 Java7的AIO正是此種類型。

BIO即同步阻塞IO，適用於鏈接數目較小且固定的架構，這種方式對服務器資源要求比較高，併發侷限於應用中，JDK1.4以前的惟一選擇，但程序直觀、簡單、易理解。

NIO即同步非阻塞IO，適用於鏈接數目多且鏈接比較短的架構，好比聊天服務器，併發侷限於應用中，編程比較複雜，JDK1.4開始支持。

AIO即異步非阻塞IO，適用於鏈接數目多且鏈接比較長的架構，如相冊服務器，充分調用OS參與併發操做，編程比較複雜，JDK1.7開始支持

34. 類加載器按照層次，從頂層到底層，分別加載哪些類？

啓動類加載器：負責將存放在JAVA_HOME/lib下的，或者被－Xbootclasspath參數所指定的路徑中的，而且是虛擬機識別的類庫加載到虛擬機內存中。啓動類加載器沒法被Java程序直接引用。

擴展類加載器：這個加載器負責加載JAVA_HOME/lib/ext目錄中的，或者被java.ext.dirs系統變量所指定的路徑中的全部類庫，開發者能夠直接使用擴展類加載器

應用程序類加載器：這個加載器是ClassLoader中getSystemClassLoader()方法的返回值，因此通常也稱它爲系統類加載器。它負責加載用戶類路徑（Classpath）上所指定的類庫，可直接使用這個加載器，若是應用程序沒有自定義本身的類加載器，通常狀況下這個就是程序中默認的類加載器

實現本身的加載器

只須要繼承ClassLoader，並覆蓋findClass方法。在調用loadClass方法時，會先根據委派模型在父加載器中加載，若是加載失敗，則會調用本身的findClass方法來完成加載

5、數據庫（Sql、MySQL、Redis等）

1. Statement

1.1 基本內容

Statement是最基本的用法, 不傳參, 採用字符串拼接，存在注入漏洞
PreparedStatement傳入參數化的sql語句, 同時檢查合法性, 效率高能夠重用, 防止sql注入
CallableStatement接口擴展PreparedStatement，用來調用存儲過程
BatchedStatement用於批量操做數據庫，BatchedStatement不是標準的Statement類

public interface CallableStatement extends PreparedStatement 
public interface PreparedStatement extends Statement

1.2 Statement與PrepareStatement的區別

建立時的區別

Statement statement = conn.createStatement();
PreparedStatement preStatement = conn.prepareStatement(sql);

執行的時候

ResultSet rSet = statement.executeQuery(sql);
ResultSet pSet = preStatement.executeQuery();

由上能夠看出，PreparedStatement有預編譯的過程，已經綁定sql，以後不管執行多少遍，都不會再去進行編譯，而 statement 不一樣，若是執行多遍，則相應的就要編譯多少遍sql，因此從這點看，preStatement 的效率會比 Statement要高一些

安全性

PreparedStatement是預編譯的，因此能夠有效的防止SQL注入等問題

代碼的可讀性和可維護性

PreparedStatement更勝一籌

2. 遊標

3. 列出 5 個應該遵循的 JDBC 最佳實踐

有不少的最佳實踐，你能夠根據你的喜愛來例舉。下面是一些更通用的原則：

a）使用批量的操做來插入和更新數據

b）使用 PreparedStatement 來避免 SQL 異常，並提升性能

c）使用數據庫鏈接池

d）經過列名來獲取結果集，不要使用列的下標來獲取

4. 數據庫索引的實現

數據庫系統還維護着知足特定查找算法的數據結構，這些數據結構以某種方式引用（指向）數據，這樣就能夠在這些數據結構上實現高級查找算法。這種數據結構，就是索引。

B樹：

一棵m階B樹(balanced tree of order m)是一棵平衡的m路搜索樹。它或者是空樹，或者是知足下列性質的樹：

一、根結點至少有兩個子女；二、每一個非根節點所包含的關鍵字個數 j 知足：┌m/2┐ - 1 <= j <= m - 1；三、除根結點之外的全部結點（不包括葉子結點）的度數正好是關鍵字總數加1，故內部子樹個數 k 知足：┌m/2┐ <= k <= m ；四、全部的葉子結點都位於同一層。

因爲B-Tree的特性，在B-Tree中按key檢索數據的算法很是直觀：首先從根節點進行二分查找，若是找到則返回對應節點的data，不然對相應區間的指針指向的節點遞歸進行查找，直到找到節點或找到null指針，前者查找成功，後者查找失敗。

一個度爲d的B-Tree，設其索引N個key，則其樹高h的上限爲logd((N+1)/2)，檢索一個key，其查找節點個數的漸進複雜度爲O(logdN)。從這點能夠看出，B-Tree是一個很是有效率的索引數據結構。

B+樹：

B-Tree有許多變種，其中最多見的是B+Tree，例如MySQL就廣泛使用B+Tree實現其索引結構。

B+樹是B樹的變形，它把全部的data都放在葉子結點中，只將關鍵字和子女指針保存於內結點，內結點徹底是索引的功能。

與B-Tree相比，B+Tree有如下不一樣點：

一、每一個節點的指針上限爲2d而不是2d+1。

二、內節點不存儲data，只存儲key；葉子節點存儲data不存儲指針。

通常在數據庫系統或文件系統中使用的B+Tree結構都在經典B+Tree的基礎上進行了優化，增長了順序訪問指針。

在B+Tree的每一個葉子節點增長一個指向相鄰葉子節點的指針

例如圖4中若是要查詢key爲從18到49的全部數據記錄，當找到18後，只需順着節點和指針順序遍歷就能夠一次性訪問到全部數據節點，極大提到了區間查詢效率。

爲何B樹（B+樹）？

通常來講，索引自己也很大，不可能所有存儲在內存中，所以索引每每以索引文件的形式存儲的磁盤上。這樣的話，索引查找過程當中就要產生磁盤I/O消耗，相對於內存存取，I/O存取的消耗要高几個數量級，因此評價一個數據結構做爲索引的優劣最重要的指標就是在查找過程當中磁盤I/O操做次數的漸進複雜度。換句話說，索引的結構組織要儘可能減小查找過程當中磁盤I/O的存取次數。

這涉及到磁盤存取原理、局部性原理和磁盤預讀。

先從B-Tree分析，根據B-Tree的定義，可知檢索一次最多須要訪問h個節點。數據庫系統的設計者巧妙利用了磁盤預讀原理，將一個節點的大小設爲等於一個頁，這樣每一個節點只須要一次I/O就能夠徹底載入。爲了達到這個目的，在實際實現B-Tree還須要使用以下技巧：

每次新建節點時，直接申請一個頁的空間，這樣就保證一個節點物理上也存儲在一個頁裏，加之計算機存儲分配都是按頁對齊的，就實現了一個node只需一次I/O。

B-Tree中一次檢索最多須要h-1次I/O（根節點常駐內存），漸進複雜度爲O(h)=O(logdN)。通常實際應用中，出度d是很是大的數字，一般超過100，所以h很是小（一般不超過3）。

綜上所述，用B-Tree做爲索引結構效率是很是高的。

而紅黑樹這種結構，h明顯要深的多。因爲邏輯上很近的節點（父子）物理上可能很遠，沒法利用局部性，因此紅黑樹的I/O漸進複雜度也爲O(h)，效率明顯比B-Tree差不少。

至於B+Tree爲何更適合外存索引，緣由和內節點出度d有關。

因爲B+Tree內節點去掉了data域，所以能夠擁有更大的出度，擁有更好的性能。

6、算法與數據結構

1. 二叉搜索樹:(Binary Search Tree又名：二叉查找樹,二叉排序樹)它或者是一棵空樹,或者是具備下列性質的二叉樹：若它的左子樹不空,則左子樹上全部結點的值均小於它的根結點的值；若它的右子樹不空,則右子樹上全部結點的值均大於它的根結點的值；它的左、右子樹也分別爲二叉搜索樹。

2. RBT紅黑樹

二叉搜索樹:(Binary Search Tree又名：二叉查找樹，二叉排序樹)它或者是一棵空樹,或者是具備下列性質的二叉樹：若它的左子樹不空,則左子樹上全部結點的值均小於它的根結點的值；若它的右子樹不空,則右子樹上全部結點的值均大於它的根結點的值；它的左、右子樹也分別爲二叉搜索樹。

紅黑樹是一棵二叉搜索樹，它在每一個結點上增長一個存儲位來表示結點的顏色，能夠是RED或BLACK。經過對任何一條從根到葉子的簡單路徑上各個結點的顏色進行約束，紅黑樹沒有一條路徑會比其餘路徑長出2倍，因此紅黑樹是近似平衡的，使得紅黑樹的查找、插入、刪除等操做的時間複雜度最壞爲O(log n)，但須要注意到在紅黑樹上執行插入或刪除後將不在知足紅黑樹性質，恢復紅黑樹的屬性須要少許(O(log n))的顏色變動(實際是很是快速的)和不超過三次樹旋轉(對於插入操做是兩次)。雖然插入和刪除很複雜，但操做時間仍能夠保持爲 O(log n) 次。具體如何保證？引出紅黑樹的5個性質。

紅黑樹的5個性質：知足如下五個性質的二叉搜索樹

每一個結點或是紅色的或是黑色的
根結點是黑色的
每一個葉結點是黑色的
若是一個結點是紅色的,則它的兩個子結點是黑色的
對於每一個結點,從該結點到其後代葉結點的簡單路徑上,均包含相同數目的黑色結點

插入操做：

因爲性質的約束，插入的結點都是紅色的。插入時性質一、3始終保持。破壞性質2當且僅當當前插入結點爲根節點。變一下顏色便可。若是是破壞性質4或5，則須要旋轉和變色來繼續知足紅黑樹的性質。下面說一說插入的幾種狀況，約定當前插入結點爲N，其父結點爲P，叔叔爲U，祖父爲G

情形1：樹空，直接插入違反性質1，將紅色改黑。

情形2：N的父結點爲黑，沒必要修改，直接插入

從情形3開始的情形假定N結點的父結點P爲紅色，因此存在G，而且G爲黑色。且N存在一個叔叔結點U，儘管U可能爲葉結點。

情形3：P爲紅，U爲紅（G結點必定存在且爲黑）這裏不論P是G的左孩子仍是右孩子；不論N是P的左孩子仍是右孩子。

首先把P、U改黑，G改紅，並以G做爲一個新插入的紅結點從新進行各類狀況的檢查，若一路檢索至根節點還未結束，則將根結點變黑。

情形4：P爲紅，U爲黑或不存在（G結點必定存在且爲黑），且P爲G的左孩子，N爲P的左孩子（或者P爲G的右孩子，N爲P的右孩子，保證同向的）。 P、G右旋並將P、G變相反色。由於P取代以前黑G的位置，因此P變黑能夠理解，而G變紅是爲了避免違反性質5。

情形5：P爲紅，U爲黑或不存在，且P爲G的左孩子，N爲P的右孩子（或P爲G的右孩子，N爲P的左孩子，保證是反向的），對N，P進行一次左旋轉換爲情形4

刪除操做比插入複雜一些，但最多不超過三次旋轉可讓紅黑樹恢復平衡。

其餘

黑高從某個結點x出發(不含x)到達一個葉結點的任意一條簡單路徑上的黑色結點個數稱爲該結點的黑高。紅黑樹的黑高爲其根結點的黑高。
一個具備n個內部結點的紅黑樹的高度h<=2lg(n+1)
結點的屬性(五元組):color key left right p
動態集合操做最壞時間複雜度爲O(lgn)

3. 排序算法

穩定排序:插入排序、冒泡排序、歸併排序、基數排序
插入排序[穩定] 適用於小數組,數組已排好序或接近於排好序速度將會很是快複雜度：O(n^2) - O(n) - O(n^2) - O(1)[平均 - 最好 - 最壞 - 空間複雜度]
歸併排序[穩定] 採用分治法複雜度：O(nlogn) - O(nlgn) - O(nlgn) - O(n)[平均 - 最好 - 最壞 - 空間複雜度]
冒泡排序[穩定] 複雜度：O(n^2) - O(n) - O(n^2) - O(1)[平均 - 最好 - 最壞 - 空間複雜度]
基數排序分配+收集[穩定] 複雜度： O(d(n+r)) r爲基數d爲位數空間複雜度O(n+r)
樹排序[不穩定] 應用：TreeSet的add方法、TreeMap的put方法不支持相同元素,沒有穩定性問題複雜度：平均最差O(nlogn)
堆排序(就地排序)[不穩定] 複雜度：O(nlogn) - O(nlgn) - O(nlgn) - O(1)[平均 - 最好 - 最壞 - 空間複雜度]
快速排序[不穩定] 複雜度：O(nlgn) - O(nlgn) - O(n^2) - O(1)[平均 - 最好 - 最壞 - 空間複雜度] 棧空間0(lgn) - O(n)
選擇排序[不穩定] 複雜度：O(n^2) - O(n^2) - O(n^2) - O(1)[平均 - 最好 - 最壞 - 空間複雜度]
希爾排序[不穩定] 複雜度小於O(n^2) 平均 O(nlgn) 最差O(n^s)[1<s<2] 空間O(1)

九大內部排序算法代碼及性能分析參見個人GitHub

4. 查找與散列

4.1 散列函數設計

直接定址法:f(key) = a*key+b

簡單、均勻,不易產生衝突。但需事先知道關鍵字的分佈狀況,適合查找表較小且連續的狀況,故現實中並不經常使用

除留餘數法:f(key) = key mod p (p<=m) p取小於表長的最大質數 m爲表長
DJBX33A算法(time33哈希算法hash = hash*33+(unsigned int)str[i];

平方取中法摺疊法更多....

4.2 衝突處理

閉散列(開放地址方法):要求裝填因子a較小，閉散列方法把全部記錄直接存儲在散列表中

線性探測:易產生堆積現象(基地址不一樣堆積在一塊兒)
二次探測:f(key) = (f(key)+di) % m di=1^2,-1^2,2^2,-2^2...能夠消除基本彙集
隨機探測:f(key) = (f(key)+di),di採用隨機函數獲得,能夠消除基本彙集
雙散列:避免二次彙集

開散列(鏈地址法):原地處理

同義詞記錄存儲在一個單鏈表中,散列表中子存儲單鏈表的頭指針。
優勢:無堆積事先無需肯定表長刪除結點易於實現裝載因子a>=1,缺點:須要額外空間

5. 跳錶

爲何選擇跳錶？

目前常用的平衡數據結構有：B樹，紅黑樹，AVL樹，Splay Tree, Treep等。想象一下，給你一張草稿紙，一隻筆，一個編輯器，你能當即實現一顆紅黑樹，或者AVL樹出來嗎？很難吧，這須要時間，要考慮不少細節，要參考一堆算法與數據結構之類的樹，還要參考網上的代碼，至關麻煩。用跳錶吧，跳錶是一種隨機化的數據結構，目前開源軟件 Redis 和 LevelDB 都有用到它，它的效率和紅黑樹以及 AVL 樹不相上下，但跳錶的原理至關簡單，只要你能熟練操做鏈表，就能去實現一個 SkipList。

跳躍表是一種隨機化數據結構，基於並聯的鏈表，其效率可比擬於二叉查找樹(對於大多數操做須要O(log n)平均時間)，而且對併發算法友好。

Skip list(跳錶）是一種能夠代替平衡樹的數據結構，默認是按照Key值升序的。Skip list讓已排序的數據分佈在多層鏈表中，以0-1隨機數決定一個數據的向上攀升與否，是一種「空間來換取時間」的一個算法，在每一個節點中增長了指向下一層的指針，在插入、刪除、查找時能夠忽略一些不可能涉及到的結點，從而提升了效率。

在Java的API中已經有了實現：分別是

ConcurrentSkipListMap(在功能上對應HashTable、HashMap、TreeMap) ；

ConcurrentSkipListSet(在功能上對應HashSet)

Skip list的性質

(1) 由不少層結構組成，level是經過必定的機率隨機產生的

(2) 每一層都是一個有序的鏈表，默認是升序

(3) 最底層(Level 1)的鏈表包含全部元素

(4) 若是一個元素出如今Level i 的鏈表中，則它在Level i 之下的鏈表也都會出現

(5) 每一個節點包含兩個指針，一個指向同一鏈表中的下一個元素，一個指向下面一層的元素

時間複雜度O(lgn) 最壞O(2lgn)

Java實現參見個人GitHub Repo Algorithm

6. AVL樹

1.LL型

在某一節點的左孩子的左子樹上插入一個新的節點，使得該節點再也不平衡。舉例 A B Ar Bl Br 在Bl下插入N，執行一次右旋便可，即把B變爲父結點，原來的根節點A變爲B的左孩子，B的右子樹變爲A的左子樹。

2.RR型

與LL型是對稱的，執行一次左旋便可。

3.LR型

指在AVL樹某一結點左孩子的右子樹上插入一個結點，使得該節點不在平衡。這時須要兩次旋轉，先左旋再右旋。

4.RL型

與LR對稱，執行一次右旋，再執行一次左旋。

刪除

一、被刪的節點是葉子節點

將該節點直接從樹中刪除，並利用遞歸的特色和高度的變化，反向推算其父節點和祖先節點是否失衡。

二、被刪的節點只有左子樹或只有右子樹

將左子樹（右子樹）替代原有節點的位置，並利用遞歸的特色和高度的變化，反向推算父節點和祖先節點是否失衡。

三、被刪的節點既有左子樹又有右子樹

找到被刪節點的左子樹的最右端的節點，將該結點的的值賦給待刪除結點，再用該結點的左孩子替換它原本的位置，而後釋放該結點，並利用遞歸特色，反向推斷父節點和祖父節點是否失衡。

7. 一致性Hash

第一：簡單介紹一致性哈希算法是分佈式系統中經常使用的算法。好比，一個分佈式的存儲系統，要將對象存儲到具體的節點上，若是採用普通的hash方法，將數據映射到具體的節點上，如key%N，N是機器節點數。

一、考慮到好比一個服務器down掉，服務器結點N變爲N-1，映射公式必須變爲key%(N-1)

二、訪問量加劇，須要添加服務器結點，N變爲N+1，映射公式變爲hash(object)%(N+1)

當出現1,2的狀況意味着咱們的映射都將無效，對服務器來講將是一場災難，尤爲是對緩存服務器來講，由於緩存服務器映射的失效，洪水般的訪問都將衝向後臺服務器。

第二點：hash算法的單調性

Hash 算法的一個衡量指標是單調性，單調性是指若是已經有一些內容經過哈希分派到了相應的緩衝中，又有新的緩衝加入到系統中。哈希的結果應可以保證原有已分配的內容能夠被映射到新的緩衝中去，而不會被映射到舊的緩衝集合中的其餘緩衝區。

consistent hash 也是一種hash 算法，簡單的說，在移除 / 添加一個結點時，它可以儘量小的改變已存在的映射關係，儘量的知足單調性的要求。

第三點：將對象和服務器結點分別映射到環型空間

一般的一致性哈希作法是將 value 映射到一個 32 位的 key 值，也便是 0~2^32-1 次方的數值空間；咱們能夠將這個空間想象成一個首（ 0 ）尾（ 2^32-1 ）相接的圓環。

咱們能夠經過hash函數將咱們的key映射到環型空間中，同時根據相同的哈希算法把服務器也映射到環型空間中，順便提一下服務器或者某個計算節點的 hash 計算，通常的方法能夠使用機器的 IP 地址或者機器名做爲 hash 輸入。

第四點：將對象映射到服務器

在這個環形空間中，若是沿着順時針方向從對象的 key 值出發，直到碰見一個服務器結點，那麼就將該對象存儲在這個服務器結點上，由於對象和服務器的hash 值是固定的，所以這個 cache 必然是惟一和肯定的。

這時候考察某個服務器down機或者須要添加服務器結點，也就是移除和添加的操做，咱們只須要幾個對象的映射。

第五點：虛擬結點

Hash 算法的另外一個指標是平衡性 (Balance)。平衡性是指哈希的結果可以儘量分佈到全部的緩衝中去，這樣能夠使得全部的緩衝空間都獲得利用。

對於上述的作法，可能致使某些對象都映射到某個服務器，使得分佈不平衡。爲此能夠採用「虛擬結點」的作法。

「虛擬結點」（ virtual node ）是實際節點在 hash 空間的複製品，一實際結點對應了若干個「虛擬節點」，這個對應個數也成爲「複製個數」，「虛擬節點」在 hash 空間中以 hash 值排列。引入「虛擬結點」會讓咱們的映射分佈更爲平衡一些。

引入「虛擬結點」前： Hash(「192.168.1.1」);

引入「虛擬結點」後： Hash(「192.168.1.1#1」); Hash(「192.168.1.1#2」);

8. 如何判斷鏈表是否有環

方法1：快慢指針法 2.設兩個工做指針p、q，p老是向前走，但q每次都從頭開始走，對於每一個節點，看p走的步數是否和q同樣。好比p從A走到D，用了4步，而q則用了14步。於是步數不等，出現矛盾，存在環。

9. 熟悉哪些算法？

[哈希算法] 一致性哈希 time33哈希 FNV1_32_HASH
[排序算法] 快速排序
[搜索算法] DFS BFS
[最小生成樹算法] Kruskal Prim
[最短路徑算法] Dijkstra Floyed

7、計算機網絡

1.中止等待協議

中止等待協議是最基本的數據鏈路層協議，它的工做原理是這樣的。

在發送端，每發送完一幀就中止發送，等待接收端的確認，若是收到確認就發送下一幀。

在接收端，每收到一個無差錯的幀，就把這個幀交付上層並向發送端發送確認。若該幀有差錯，就丟棄，其餘什麼也不作。

其餘細節：

中止等待協議爲了可靠交付，須要對幀進行編號，因爲每次只發送一幀，因此中止等待協議使用1個比特編號，編號0和1

中止等待協議會出現死鎖現象（A等待B的確認），解決辦法，啓動超時計時器，超時計時器有一個重傳時間。重傳時間通常選擇略大於「正常狀況下從發完數據幀到收到確認幀所需的平均時間」。

2.滑動窗口協議

再說滑動窗口以前，先說下連續ARQ，連續ARQ又稱Go-back-N ARQ，意思是當出現差錯必須重傳時，要向回走N個幀，而後再開始重傳，也就意味着只要有一幀出現差錯，即便已經正確的幀也須要重傳，白白浪費時間，增大開銷。爲此，應該對發送出去但未被確認的幀的數目加以限制，這就是滑動窗口協議。滑動窗口指收發兩端分別維護一個發送窗口和接收窗口，發送窗口有一個窗口值Wt，窗口值Wt表明在沒有收到對方確認的狀況下最多能夠發送的幀的數目。當發送的幀的序號被接收窗口正確收下後，接收端向前滑動並向發送端發去確認，發送端收到確認後，發送窗口向前滑動。收發兩端按規律向前推動。

連續ARQ和選擇重傳ARQ均是窗口大於1的滑動窗口協議，而中止等待協議至關於收發兩端窗口等於1。

滑動窗口指接收和發送兩端的窗口按規律不斷向前推動，是一種流量控制的策略。

3.Http1.0和Http1.1的區別

1.HTTP/1.0協議使用非持久鏈接,即在非持久鏈接下,一個tcp鏈接只傳輸一個Web對象。 2.HTTP/1.1默認使用持久鏈接(然而,HTTP/1.1協議的客戶機和服務器能夠配置成使用非持久鏈接)。在持久鏈接下,沒必要爲每一個Web對象的傳送創建一個新的鏈接,一個鏈接中能夠傳輸多個對象。

4.Post和Get的區別

1.安全性上說：get的方式是把數據在地址欄中明文的形式發送，URL中可見，POST方式對用戶是透明的，安全性更高。 2.數據量說：Get傳送的數據量較小，通常不能大於2KB，POST傳送的數據量更大。 3.適用範圍說：查詢用Get，數據添加、修改和刪除建議Post

5.TCP/IP體系各層功能及協議

TCP/IP體系共有四個層次，分別爲網絡接口層Host-to-Network Layer, 網際層 Internet Layer，傳輸層Transport Layer，應用層Application Layer。

5.1 網絡接口層 -> 接收和發送數據報

主要負責將數據發送到網絡傳輸介質上以及從網絡上接收TCP/IP數據報，至關於OSI參考模型的物理層和數據鏈路層。在實際中，前後流行的以太網、令牌環網、ATM、幀中繼等均可視爲其底層協議。它將發送的信息組裝成幀並經過物理層向選定網絡發送，或者從網絡上接收物理幀，將去除控制信息後的IP數據報交給網絡層。

5.2 網際層 -> 數據報封裝和路由尋址

網際層主要功能是尋址和對數據報的封裝以及路由選擇功能。這些功能大部分經過IP協議完成，並經過地址解析協議ARP、逆地址解析協議RARP、因特網控制報文協議ICMP、因特網組管理協議IGMP從旁協助。因此IP協議是網絡層的核心。

網際協議IP：IP協議是一個無鏈接的協議，主要負責將數據報從源結點轉發到目的結點。也就是說IP協議經過對數據報中源地址和目的地址進行分析，而後進行路由選擇，最後再轉發到目的地。須要注意的是：IP協議只負責對數據進行轉發，並不對數據進行檢查，也就是說，它不負責數據的可靠性，這樣設計的主要目的是提升IP協議傳送和轉發數據的效率。

ARP：該協議負責將IP地址解析轉換爲計算機的物理地址。

雖然咱們使用IP地址進行通訊，但IP地址只是主機在抽象的網絡層中的地址。最終要傳到數據鏈路層封裝成MAC幀才能發送到實際的網絡。所以無論使用什麼協議最終須要的仍是硬件地址。

每一個主機擁有一個ARP高速緩存（存放所在局域網內主機和路由器的IP地址到硬件地址的映射表）

舉例：A發送B

(1)A在本身的ARP高速緩存中查到B的MAC地址，寫入MAC幀發往此B

(2)沒查到，A向本局域網廣播ARP請求分組，內容包括本身的地址映射和B的IP地址

(3)B發送ARP響應分組，內容爲本身的IP地址到物理地址的映射，同時將A的映射寫入本身的ARP高速緩存（單播的方式）

注：ARP Cache映射項目具備一個生存時間。

RARP：將計算機物理地址轉換爲IP地址

ICMP：該協議主要負責發送和傳遞包含控制信息的數據報，這些控制信息包括了哪臺計算機出現了什麼錯誤，網絡路由出現了什麼錯誤等內容。

5.3 傳輸層 -> 應用進程間端到端的通訊

傳輸層主要負責應用進程間「端到端」的通訊，即從某個應用進程傳輸到另外一個應用進程，它與OSI參考模型的傳輸層功能相似。

傳輸層在某個時刻可能要同時爲多個不一樣的應用進程服務，所以傳輸層在每一個分組中必須增長用於識別應用進程的標識，即端口。

TCP/IP體系的傳輸層主要包含兩個主要協議，即傳輸控制協議TCP和用戶數據報協議UDP。TCP協議是一種可靠的、面向鏈接的協議，保證收發兩端有可靠的字節流傳輸，進行了流量控制，協調雙方的發送和接收速度，達到正確傳輸的目的。

UDP是一種不可靠的、無鏈接的協議，其特色是協議簡單、額外開銷小、效率較高，不能保證可靠傳輸。

傳輸層提供應用進程間的邏輯通訊。它使應用進程看見的就好像是在兩個運輸層實體間一條端到端的邏輯通訊信道。

當運輸層採用TCP時，儘管下面的網絡是不可靠的，但這種邏輯通訊信道至關於一條全雙工的可靠信道。能夠作到報文的無差錯、按序、無丟失、無重複。

注：單單面向鏈接只是可靠的必要條件，不充分。還須要其餘措施，如確認重傳，按序接收，無丟失無重複。

熟知端口：

20 FTP數據鏈接 
21 FTP控制鏈接 
22 SSH 
23 TELNET 
25 SMTP 
53 DNS 
69 TFTP
80 HTTP
161 SNMP

UDP重要

UDP的優勢：

1.發送以前無需創建鏈接，減少了開銷和發送數據的時延

2.UDP不使用鏈接，不使用可靠交付，所以主機不須要維護複雜的參數表、鏈接狀態表

3.UDP用戶數據報只有8個字節的首部開銷，而TCP要20字節。

4.因爲沒有擁塞控制，所以網絡出現擁塞不會使源主機的發送速率下降（IP電話等實時應用要求源主機以恆定的速率發送數據是有利的）

Table，使用TCP和UDP的應用

應用	應用層協議	運輸層協議
名字轉換	DNS	UDP
文件傳送	TFTP	UDP
路由選擇協議	RIP	UDP
IP地址配置	BOOTTP,DHCP	UDP
網絡管理	SNMP	UDP
遠程文件服務器	NFS	UDP
IP電話	專用協議	UDP
流式多媒體通訊	專用協議	UDP
電子郵件	SMTP	TCP
遠程終端接入	TELNET	TCP
萬維網	HTTP	TCP
文件傳送	FTP	TCP

注：TFTP：Trivial File Transfer Protocol

UDP的過程（以TFTP舉例）：

1.服務器進程運行着，等待TFTP客戶進程的服務請求。客戶端TFTP進程啓動時，向操做系統申請一個臨時端口號，而後操做系統爲該進程建立2個隊列，入隊列和出隊列。只要進程在執行，2個隊列一直存在。

2.客戶進程將報文發送到出隊列中。UDP按報文在隊列的前後順序發送。在傳送到IP層以前給報文加上UDP首部，其中目的端口後爲69，而後發給IP層。出隊列若溢出，則操做系統通知應用層TFTP客戶進程暫停發送。

3.客戶端收到來自IP層的報文時，UDP檢查報文中目的端口號是否正確，若正確，放入入隊列隊尾，客戶進程按前後順序一一取走。若不正確，UDP丟棄該報文，並請ICMP發送」端口不可達「差錯報文給服務器端。入隊列可能會溢出，若溢出，UDP丟棄該報文，不通知對方。

服務器端相似。

UDP首部：源端口 - 目的端口 - 長度 - 檢驗和，每一個字段22字節。

注：IP數據報檢驗和只檢驗IP數據報的首部，而UDP的檢驗和將首部和數據部分一塊兒都檢驗。

TCP重要

細節：

TCP報文段是面向字節的數據流。

TCP首部：20字節固定首部

確認比特ACK，ACK=1 確認號字段纔有效；同步比特SYN：SYN=1 ACK=0表示一個鏈接請求報文段；終止比特FIN，FIN=1時要求釋放鏈接。

窗口：將TCP收發兩端記爲A和B，A根據TCP緩存空間的大小肯定本身的接收窗口大小。並在A發送給B的窗口字段寫入該值。做爲B的發送窗口的上限。意味着B在未收到A的確認狀況下，最多發送的字節數。

選項：最大報文段長度MSS，MSS告訴對方TCP：個人緩存所能接收的報文段的數據字段的最大長度是MSS個字節。若主機未填寫，默認爲536字節。

TCP的可靠是使用了序號和確認。當TCP發送一個報文時，在本身的重傳隊列中存放一個副本。若收到確認，刪除副本。

TCP使用捎帶確認。

TCP報文段的發送時機：1.維持一個變量等於MSS，發送緩存達到MSS就發送 2.發送端應用進程指明要發送，即TCP支持的PUSH操做。3.設定計時器

TCP的擁塞控制：TCP使用慢開始和擁塞避免算法進行擁塞控制

慢開始和擁塞避免

接收端根據自身資源狀況控制發送端發送窗口的大小。

每一個TCP鏈接須要維持一下2個狀態變量：

接收端窗口rwnd（receiver window）：接收端根據目前接收緩存大小設置的窗口值，是來自接收端的流量控制

擁塞窗口cwnd（congestion window）：是發送端根據本身估計的網絡擁塞程度設置的窗口值，是來自發送端的流量控制

發送端的窗口上限值=Min(rwnd, cwnd)

慢開始算法原理：主機剛開始發送數據時，若是當即將較大的發送窗口的所有字節注入網絡，因爲不清楚網絡情況，可能會引發擁塞。一般的作法是將cwnd設置爲1個MSS，每收到一個確認，將cwnd+1，由小到大逐步增大cwnd，使分組注入網絡的速率更加合理。爲了防止擁塞窗口增加引發網絡擁塞，還需設置一個狀態變量ssthresh，即慢開始門限。

慢開始門限：ssthresh，當cwnd < ssthresh,執行慢開始算法；cwnd > ssthresh，改用擁塞避免算法。 cwnd = ssthresh時，均可以。

擁塞避免算法使發送端的擁塞窗口每通過一個RTT增長一個MSS（而無論在此期間收到多少ACK），這樣，擁塞窗口cwnd按線性規律增加，擁塞窗口此時比慢開始增加速率緩慢不少。這一過程稱爲加法增大，目的在於使擁塞窗口緩慢增加，防止網絡過早擁塞。

不管是慢開始仍是擁塞避免，只要發送端發現網絡出現擁塞（根據是沒有按時收到ACK或者收到重複ACK），就將慢開始門限ssthresh設置爲擁塞窗口值的一半並將擁塞窗口cwnd置爲1，從新執行慢開始算法。這一過程稱爲乘法減少。目的在於迅速減小主機發送到網絡中的分組數，使得發生擁塞的路由器有足夠時間把隊列中積壓的分組處理完畢。

上述TCP確認都是經過捎帶確認執行的。

快重傳和快恢復

上述的慢開始和擁塞避免算法是早期TCP使用的擁塞控制算法。由於有時TCP鏈接會在重傳時因等待重傳計時器的超時時間而空閒。爲此在快重傳中規定：只要發送端一連收到三個重複的ACK,便可判定分組丟失，沒必要等待重傳計數器，當即重傳丟失的報文。

與快重傳搭配使用的還有快恢復：當不使用快恢復時，發送端若發現網絡擁塞就將擁塞窗口降爲1，而後執行慢開始算法，這樣的缺點是網絡不能很快恢復到正常狀態。快恢復是指當發送端收到3個重複的ACK時，執行乘法減少，ssthresh變爲擁塞窗口值的一半。可是cwnd不是置爲1，而是ssthresh+3xMSS。若收到的重複ACK 爲n(n > 3)，則cwnd=ssthresh+n*MSS.這樣作的理由是基於發送端已經收到3個重複的ACK，它代表已經有3個分組離開了網絡，它們不在消耗網絡的資源。

注意的是：在使用快恢復算法時，慢開始算法只在TCP鏈接創建時使用。

TCP的重傳機制

每發送一個報文段，就對這個報文段設置一次計時器。新的重傳時間=γ*舊的重傳時間。

TCP鏈接創建和釋放的過程

SYN置1和FIN的報文段要消耗一個序號。

客戶端鏈接狀態變遷：CLOSED -> 主動打開,發送SYN=1 -> SYN_SENT -> 收到服務器的SYN=1和ACK時,發送三次握手的最後一個ACK -> ESTABLISHED -> 數據傳送 -> 主動關閉 -> 發送FIN=1,等待確認ACK的到達 -> FIN_WAIT_1 -> 收到確認ACK後 -> FIN_WAIT_2 -> 收到服務器發送的FIN=1報文，響應，發送四次揮手的的最後一個確認ACK -> 進入TIME_WAIT狀態 -> 通過2倍報文壽命，TCP刪除鏈接記錄 -> 回到CLOSED狀態

客戶端狀態：CLOSED - SYN_SENT- ESTABLISHED - FIN_WAIT_1 - FIN_WAIT_2 - TIME_WAIT - CLOSED

服務器端鏈接狀態變遷：CLOSED -> 被動打開 -> LISTEN -> 收到SYN=1的報文，發送SYN=1和確認ACK -> 進入SYN_RCVD -> 收到三次握手的最後一個確認ACK -> ESTABLISHED -> 數據傳送 -> 數據傳送完畢，收到FIN=1 -> 發送確認ACK並進入CLOSED_WAIT -> 發送FIN=1給客戶端 -> LAST_ACK -> 收到客戶端四次揮手的最後一個確認ACK -> 刪除鏈接記錄 -> 回到CLOSED狀態

服務器端：CLOSED - LISTEN - SYN_RCVD - ESTABLISHED - CLOSED_WAIT - LAST_ACK - CLOSED

5.4 應用層

應用層位於TCP/IP體系結構的最高一層，也是直接爲應用進程服務的一層，即當不一樣的應用進程數據交換時，就去調用應用層的不一樣協議實體，讓這些實體去調用傳輸層的TCP或者UDP來進行網絡傳輸。具體的應用層協議有，SMTP 2五、DNS 5三、HTTP 80、FTP 20數據端口 21控制端口、TFTP 6九、TELNET 2三、SNMP 161等

5.5 網絡的劃分

按網絡拓撲結構：總線、星型、環型、樹型、網狀結構和混合型。

按覆蓋範圍：局域網、城域網、廣域網

按傳播方式：廣播網絡和點對點網絡

廣播式網絡是指網絡中的計算機使用一個共享信道進行數據傳播，網絡中的全部結點都能收到某一結點發出的數據信息。

單播：一對一的發送形式。

組播：採用一對一組的發送形式，將數據發送給網絡中的某一組主機。

廣播：採用一對全部，將數據發送給網絡全部目的結點。

點對點網絡中兩個結點間的通訊方式是點對點的。若是兩臺計算機之間沒有直連的線路，則須要中間結點的接收、存儲、轉發直至目的結點。

6. TCP的三次握手和四次揮手的過程

以客戶端爲例

鏈接創建（三次握手）：首先Client端發送鏈接請求報文SYN並進入SYN_SENT狀態，Server收到後發送ACK+SYN報文，併爲此次鏈接分配資源。Client端接收到Server端的SYN+ACK後發送三次握手的最後一個ACK，並分配資源，鏈接創建。

鏈接釋放（四次揮手）：假設Client端發起斷開鏈接請求，首先發送FIN=1,等待確認ACK的到達 -> FIN_WAIT_1 -> 收到Server端的確認ACK後時 -> FIN_WAIT_2 ->收到服務器發送的FIN=1報文，響應，發送四次揮手的的最後一個確認ACK ->進入TIME_WAIT狀態 -> 通過2倍報文壽命，TCP刪除鏈接記錄 -> 回到CLOSED狀態

7. 爲何鏈接創建是三次握手，而鏈接釋放要四次揮手？

由於當Server端收到Client端發送的SYN鏈接請求報文後，能夠直接發送SYN+ACK報文，其中ACK用來應答，SYN用來同步。可是關閉鏈接時，當Server端收到FIN報文後，並不會當即關閉socket，因此先回復一個ACK，告訴Client端「你的FIN我收到了」，只有等Server端的全部報文發送完了，Server端才發送FIN報文，所以不能一塊兒發送，故須要四次揮手。

8. 爲何TIME_WAIT狀態須要2MSL（最大報文段生存時間）才能返回Closed狀態？

這是由於雖然雙方都贊成關閉鏈接了，並且四次揮手的報文也都協調發送完畢。可是咱們必須假想網絡是不可靠的，沒法保證最後發送的ACK報文必定被對方收到，所以處於LAST_ACK狀態下的 Server端可能會因未收到ACK而重發FIN，因此TIME_WAIT狀態的做用就是用來重發可能丟失的ACK報文。

9. Http報文格式

Http請求報文格式：1.請求行 2.Http頭 3.報文主體

請求行由三部分組成，分別是請求方法，請求地址，Http版本

Http頭：有三種，分別爲請求頭（request header），普通頭（General Header）和實體頭（entity header）。Get方法沒有實體頭。

報文主體：只在POST方法請求中存在。

Http響應報文：1.狀態行 2.Http頭 3.返回內容

狀態行：第一部分爲Http版本，第二部分爲響應狀態碼第三部分爲狀態碼的描述

其中第三部分爲狀態碼的描述，信息類100-199 響應成功200-299 重定向類300-399 客戶端錯誤400-499 服務器端錯誤500-599

常見的

100 continue 初始請求已接受，客戶端應繼續發送請求剩餘部分
200 OK
202 Accepted 已接受，處理還沒有完成 
301 永久重定向
302 臨時重定向
400 Bad Request
401 Unauthorized
403 Forbidden 資源不可用
404 Not Found
500 Internal Server Error 服務器錯誤
502 Bad Gateway
503 Service Unavailable 服務器負載太重
504 Gateway Timeout 未能及時從遠程服務器得到應答

Http頭：響應頭（Response Header），普通頭（General Header）和實體頭(Entity Header)

返回內容：即Http請求的信息，能夠是HTML也能夠是圖片等等。

10. Http和Https的區別

Https即Secure Hypertext Transfer Protocol，即安全超文本傳輸協議，它是一個安全通訊信道，基於Http開發，用於在客戶機和服務器間交換信息。它使用安全套接字層SSL進行信息交換，是Http的安全版。

Https協議須要到CA申請證書，通常免費證書不多，須要交費。

Http是超文本傳輸協議，信息是明文傳輸，https則是具備安全性的tls/ssl加密傳輸協議。

http是80端口，https是443端口

11. 瀏覽器輸入一個URL的過程

瀏覽器向DNS服務器請求解析該URL中的域名所對應的IP地址
解析出IP地址後，根據IP地址和默認端口80和服務器創建TCP鏈接
瀏覽器發出Http請求，該請求報文做爲TCP三次握手的第三個報文的數據發送給服務器
服務器作出響應，把對應的請求資源發送給瀏覽器
釋放TCP鏈接
瀏覽器解析並顯示內容

12. 中間人攻擊

中間人獲取server發給client的公鑰，本身僞造一對公私鑰，而後僞造本身讓client覺得它是server，而後將僞造的公鑰發給client，並攔截client發給server的密文，用僞造的私鑰便可獲得client發出去的內容，最後用真實的公鑰對內容加密發給server。

解決辦法：數字證書，證書鏈，可信任的中間人

13. 差錯檢測

誤碼率：傳輸錯誤的比特與傳輸總比特數的比率

CRC是檢錯方法並不能糾錯，FCS（Frame Check Sequence）是冗餘碼。

計算冗餘碼（餘數R）的方法：先補0（n個）再對生成多項式取模。

CRC只能表示以接近1的機率認爲它沒有差錯。但不能作到可靠傳輸。可靠傳輸還須要確認和重傳機制。

生成多項式P(X)：CRC-16，CRC-CCITT，CRC-32

14. 數據鏈路層的協議

中止等待協議 - 連續ARQ - 選擇重傳ARQ - PPP - 以太網協議- 幀中繼 - ATM - HDLC

15. 截斷二進制指數退避算法

是以太網用於解決當發生碰撞時就中止發送而後重發再碰撞這一問題。

截斷二進制指數退避算法：基本退避時間爲2τ k=min{重傳次數，10} r=random(0~2^k-1) 重傳所需時延爲r倍的基本退避時間

8、操做系統（OS基礎、Linux等）

1. 併發和並行

「並行」是指不管從微觀仍是宏觀，兩者都是一塊兒執行的，也就是同一時刻執行而「併發」在微觀上不是同時執行的。是在同一時間間隔交替輪流執行

2. 進程間通訊的方式

管道( pipe )：管道是一種半雙工的通訊方式，數據只能單向流動，並且只能在具備親緣關係的進程間使用。進程的親緣關係一般是指父子進程關係。
有名管道 (named pipe) ：有名管道也是半雙工的通訊方式，可是它容許無親緣關係進程間的通訊。
信號量( semophore ) ：信號量是一個計數器，能夠用來控制多個進程對共享資源的訪問。它常做爲一種鎖機制，防止某進程正在訪問共享資源時，其餘進程也訪問該資源。所以，主要做爲進程間以及同一進程內不一樣線程之間的同步手段。
消息隊列( message queue ) 消息隊列是由消息的鏈表，存放在內核中並由消息隊列標識符標識。消息隊列克服了信號傳遞信息少、管道只能承載無格式字節流以及緩衝區大小受限等缺點。
信號 ( sinal ) ：信號是一種比較複雜的通訊方式，用於通知接收進程某個事件已經發生。
共享內存( shared memory )