面試題--京東 有用

.Spring的事務有哪些？

什麼是數據庫事務： 訪問並可能改變數據庫中個數據項的一個程序執行單元。

實現方式共有兩種：編碼方式即採用註解的方式（類頭的@Transactional爲默認事務配置）；聲明式事務管理方式（bean）。

基於AOP技術實現的聲明式事務管理，實質就是：在方法執行 先後進行攔截，而後在目標方法開始以前建立並加入事務，執行完目標方法後根據執行狀況提交或回滾事務。

聲明式事務管理又有兩種方式：基於XML配置文件的方式；另外一個是在業務方法上進行@Transactional註解，將事務規則應用到業務邏輯中。

2.Java的鎖有哪幾種？

一、自旋鎖：自旋鎖是採用讓當前線程不停地的在循環體內執行實現的，當循環的條件被其餘線程改變時 才能進入臨界區。

二、自旋鎖的其餘種類

三、阻塞鎖：經常使用的有五個狀態的鎖都是阻塞所。

四、可重入鎖：ReentrantLock

五、讀寫鎖：寫鎖是排他鎖，讀鎖是共享鎖。

六、互斥鎖

七、悲觀鎖：在整個數據處理過程當中，將數據處於鎖定狀態。 悲觀鎖的實現，每每依靠數據庫提供的鎖機制。

八、樂觀鎖：樂觀鎖假設認爲數據通常狀況下不會形成衝突，因此在數據進行提交更新的時候，纔會正式對數據的衝突與否進行檢測，若是發現衝突了，則讓返回用戶錯誤的信息，讓用戶決定如何去作。

公平鎖（Fair）：加鎖前檢查是否有排隊等待的線程，優先排隊等待的線程，先來先得

非公平鎖（Nonfair）：加鎖時不考慮排隊等待問題，直接嘗試獲取鎖，獲取不到自動到隊尾等待

1八、信號量

3.join的優點是什麼？

mysql不支持Full join。

select * from A inner join B on A.name = B.name;

在ON匹配階段 WHERE 子句的條件都不會被使用。僅在匹配階段完成之後，WHERE 子句條件纔會被使用。它將從匹配階段產生的數據中檢索過濾。

cross join：交叉鏈接，獲得的結果是兩個表的乘積，即笛卡爾積。

還有inner join，left join，right join。

4.用線程實現輸出1A2B3C....

5.抽象類和接口的區別

 

1。JSP的內置對象及方法。

在JSP中無需建立就能夠使用的9個對象，它們是：request、response、session、application、out、pagecontext、config、page、exception

l out（JspWriter）：等同 與response.getWriter()，用來向客戶端發送文本數據；

1. void clear() ;

   清除輸出緩衝區的內容，可是不輸出到客戶端。

2. void clearBuffer() ;

   清除輸出緩衝區的內容，並輸出到客戶端。

3. void close() ;

   關閉輸出流，清除全部內容。

4. void flush() ;

   輸出緩衝區裏面的數據。

5. int getBufferSize() ;

   獲取以kb爲單位的目前緩衝區大小。

6. int getRemaining() ;

   獲取以kb爲單位的緩衝區中未被佔用的空間大小。

7. boolean isAutoFlush() ;

   是否自動刷新緩衝區。

8. void newLine() ;

   輸出一個換行字符。

l config（ServletConfig）：對應「真身」中的ServletConfig，config對象用來存放Servlet初始的 數據結構； config 對象的主要做用是取得服務器的配置信息。經過 pageConext對象的 getServletConfig() 方法 能夠獲取一個config對象。當一個Servlet 初始化時，容器把某些信息經過 config對象傳遞給這個 Servlet。

l page（當前JSP的真身類型）： 當前JSP頁面的「this」，即當前對象，page對象表明JSP對象自己，或者說表明編譯後的servlet對象，能夠用( (javax.servlet.jsp.HttpJspPage)page )來取用它的方法和屬性；

l pageContext（PageContext）：頁面上下文對象，它是最後一個沒講的域對象，pageContext對象存儲本JSP頁面相關信息，如屬性、內建對象等； pageContext 對象的做用是取得任何範圍的參數，經過它能夠獲取 JSP頁面的out、request、reponse、session、application 等對象。

l exception（Throwable）：只有在錯誤頁面中能夠使用這個對象，錯誤對象，只有在JSP頁面的page指令中指定isErrorPage="true"後，才能夠在本頁面使用 exception對象；

l request（HttpServletRequest）：即HttpServletRequest類的對象，request對象包含全部請求的信息，如請求的來源、標頭、cookies和請求相關的參數值等， request對象表明了客戶端的請求信息，主要用於接受經過HTTP協議傳送到服務器的數據。（包括頭信息、系統信息、請求方式以及請求參數等）。request對 象的做用域爲一次請求。；

getParameterNames() 獲取客戶端提交的全部參數的名字。

l response（HttpServletResponse）：即HttpServletResponse類的對象，response對象主要將JSP容器處理後的結果傳回到客戶端，response 表明的是對客戶端的響應，主要是將JSP容器處理過的對象傳回到客戶端。response對象也具備做用域，它只在JSP頁面內有效；

response.sendRedirect(index.jsp)

l application（ServletContext）：即ServletContext類的對象，主要功用在於取得或更改Servlet的設定；

setAttribute(String key,Object obj)：將參數Object指定的對象obj添加到Application對象中，併爲添加的對象指定一個索引關鍵字。

getAttribute(String key)：獲取Application對象中含有關鍵字的對象。

l  session（HttpSession）：即HttpSession類的對象，不是每一個JSP頁面中均可以使用，若是在某個JSP頁面中設置<%@page session=」false」%>，說明這個頁面不能使用session，session對象表示目前個別用戶的會話狀態，用來識別每一個用戶。

public String getId()：獲取Session對象編號。

public void setAttribute(String key,Object obj)：將參數Object指定的對象obj添加到Session對象中，併爲添加的對象指定一個索引關鍵字。

public Object getAttribute(String key)：獲取Session對象中含有關鍵字的對象。

public Boolean isNew()：判斷是不是一個新的客戶。

2.說說ArrayList（對比着LinkedList來講）；

1.ArrayList是實現了基於動態數組的數據結構，ArrayList不具備線程安全性，LinkedList基於鏈表的數據結構，LinkedList能夠看作爲一個雙向鏈表，LinkedList也是線程不安全的。 

2.對於隨機訪問get和set，ArrayList以爲優於LinkedList，由於LinkedList要移動指針。 

3.對於新增和刪除操做add和remove，LinedList比較佔優點，由於ArrayList要移動數據。

Vector是線程安全的

26.數組(Array)和列表(ArrayList)有什麼區別？何時應該使用Array而不是ArrayList？

下面列出了Array和ArrayList的不一樣點：

Array能夠包含基本類型和對象類型，ArrayList只能包含對象類型。

Array大小是固定的，ArrayList的大小是動態變化的。

ArrayList提供了更多的方法和特性，好比：addAll()，removeAll()，iterator()等等。

對於基本類型數據，集合使用自動裝箱來減小編碼工做量。可是，當處理固定大小的基本數據類型的時候，這種方式相對比較慢。

27.ArrayList和LinkedList有什麼區別？

ArrayList和LinkedList都實現了List接口，他們有如下的不一樣點：

ArrayList是基於索引的數據接口，它的底層是數組。它能夠以O(1)時間複雜度對元素進行隨機訪問。與此對應，LinkedList是以元素列表的形式存儲它的數據，每個元素都和它的前一個和後一個元素連接在一塊兒，在這種狀況下，查找某個元素的時間複雜度是O(n)。

相對於ArrayList，LinkedList的插入，添加，刪除操做速度更快，由於當元素被添加到集合任意位置的時候，不須要像數組那樣從新計算大小或者是更新索引。

LinkedList比ArrayList更佔內存，由於LinkedList爲每個節點存儲了兩個引用，一個指向前一個元素，一個指向下一個元素。

28.Comparable和Comparator接口是幹什麼的？列出它們的區別。

Java提供了只包含一個 compareTo()方法的Comparable接口。這個方法是能夠比較單個字段的

Java 提供了包含compare()和equals()兩個方法的 Comparator接口。compare()方法用來給兩個輸入參數排序，第一個參數大於第二個參數 返回正整數. 相等返回0 

3.寫一個單例模式。我寫的是靜態內部類的單例，而後他問我這個地方爲何用private，這兒爲啥用static,這就考察你的基本功啦

類的構造函數定義爲private的，保證其餘類不能實例化此類，static保證每一個類訪問到的都是同一個。

餓漢模式：

public class Singleton{  

    private static Singleton instance = new Singleton();  

    private Singleton(){}  

    public static Singleton newInstance(){  

        return instance;  

    }  

} 缺點，在類加載以後就被建立，即便沒有用到

懶漢模式：

public class Singleton{  

    private static Singleton instance = null;  

    private Singleton(){}  

    public static synchronized Singleton newInstance(){  

        if(null == instance){  

            instance = new Singleton();  

        }  

        return instance;  

    }  

}在特定時間加載，延遲加載

雙重校驗鎖：

public class Singleton {  

    private static volatile  Singleton instance = null;  

    private Singleton(){}  

    public static Singleton getInstance() {  

        if (instance == null) {  

            synchronized (Singleton.class) {  

                if (instance == null) {//2  

                    instance = new Singleton();  

                }  

            }  

        }  

        return instance;  

    }  

}線程安全

靜態內部類：

public class Singleton{  

    private static class SingletonHolder{  

        public static Singleton instance = new Singleton();  

    }  

    private Singleton(){}  

    public static Singleton newInstance(){  

        return SingletonHolder.instance;  

    }  

} 

枚舉：

public enum Singleton{  

    instance;  

    public void whateverMethod(){}      

} 不多使用

4.給了一個表三個字段，寫SQL語句。主要考察基本SQL語句語法、彙集函數和Group By的用法

姓名	分數	課程
name	score	course

統計出每一個學生有多少門課分數大於80分     select * from 

select name,count(*) as num from student where score > 80 group by name;

5.說一說GC算法吧。

http://www.cnblogs.com/hnrainll/archive/2013/11/06/3410042.html（講到了minor GC)

當兩個存活區切換了幾回（HotSpot虛擬機默認15次，用-XX:MaxTenuringThreshold控制，大於該值進入老年代）以後，仍然存活的對象（其實只有一小部分，好比，咱們本身定義的對象），將被複制到老年代。Eden區與Survivor的比例較大，HotSpot默認是 8:1。在發生Minor GC時，虛擬機會檢查每次晉升進入老年代的大小是否大於老年代的剩餘空間大小，若是大於，則直接觸發一次Full GC。

1) 從JVM內存模型開始提及，在紙上畫出大概的組成部分，而後說出每一個組成部分的特色

線程隔離的有：虛擬機棧，本地方法棧和程序計數器；

線程共享的有：方法區（被虛擬機加載的類的元數據信息：如常量、靜態變量、即時編譯器編譯後的代碼。也成爲永久代）和堆區（存放全部對象實例和數組）；

程序計數器（Program Counter Register）：

每個Java線程都有一個程序計數器來用於保存程序執行到當前方法的哪個指令，對於非Native方法，這個區域記錄的是正在執行的VM原語的地址，若是正在執行的是Natvie方法，這個區域則爲空（undefined）。此內存區域是惟一一個在VM Spec中沒有規定任何OutOfMemoryError狀況的區域。

Java虛擬機棧：

本地變量表存放了編譯期可知的各類標量類型（boolean、byte、char、short、int、float、long、double）、對象引用（不是對象自己，僅僅是一個引用指針）、方法返回地址等。其中long和double會佔用2個本地變量空間（32bit），其他佔用1個。

本地方法棧：

本地方法棧是爲虛擬機使用到的Native方法服務。

堆：

絕大部分的對象實例和數組都在這裏分配。

2) 開始說說分代GC，這時就把GC算法引入進來， 再結合每一個區域的特色 把Minor GC 和Full GC 引入進來

標記-清除算法：從根節點開始標記全部可達對象，其他沒標記的即爲垃圾對象，執行清除。但回收後的空間是不連續的。

複製算法：將內存分紅兩塊，每次只使用其中一塊，垃圾回收時，將標記的對象拷貝到另一塊中，而後徹底清除原來使用的那塊內存。複製後的空間是連續的。（適用於新生代）

標記-壓縮算法：適合用於老年代的算法（存活對象多於垃圾對象）。標記後不復制，而是將存活對象壓縮到內存的一端，而後清理邊界外的全部對象。

2) 能夠跟他說說垃圾回收器，Serial 、 ParNew 、CMS 等等

Serial 是單線程的，新生代使用的是複製算法，老年代使用的是標記整理算法；

ParNew是Serial的多線程版本，Parallel Scavenge是ParNew的加強版，提供可控制的吞吐量設置；

Serial Old和ParNew Old對應的是老年代的GC；

CMS是一種以獲取最短回收停頓時間爲目標的收集器；使用的標記清楚算法；

初始標記，併發標記，從新標記，併發清除；

21.垃圾回收器G1,我只說了CMS

CMS包含初始標記、併發標記、從新標記、併發清除4步。其中初始標記和從新標記是須要中止其餘操做的，併發標記和併發清除是與應用線程併發執行。

可是CMS是CPU資源敏感的；沒法處理浮動垃圾；CMS是基於「標記-清除」算法的，因此有碎片。

G1是面向服務端的，特色：並行與併發、分代收集、空間整合（使用標記-整理算法）、可預測停頓。它再也不區分新老生代，而是劃分region，並經過Remembered Set來避免全堆掃描。

G1收集過程是：初始標記、併發標記、最終標記和篩選回收。除了併發標記是併發的，其餘都是阻塞的。

6.說說死鎖吧，怎麼檢測死鎖？

死鎖：是指兩個或兩個以上的進程在執行過程當中，因爲競爭資源或者因爲彼此通訊而形成的一種阻塞的現象，若無外力做用，它們都將沒法推動下去。

四個條件同時具有：互斥條件、不可搶佔條件、佔有且申請條件、循環等待條件。

• 互斥條件：資源是獨佔的且排他使用，進程互斥使用資源，即任意時刻一個資源只能給一個進程使用，其餘進程若申請一個資源，而該資源被另外一進程佔有時，則申請者等待直到資源被佔有者釋放。
• 不可剝奪條件：進程所得到的資源在未使用完畢以前，不被其餘進程強行剝奪，而只能由得到該資源的進程資源釋放。
• 請求和保持條件：進程每次申請它所須要的一部分資源，在申請新的資源的同時，繼續佔用已分配到的資源。
• 循環等待條件：在發生死鎖時必然存在一個進程等待隊列{P1,P2,…,Pn},其中P1等待P2佔有的資源，P2等待P3佔有的資源，…，Pn等待P1佔有的資源，造成一個進程等待環路，環路中每個進程所佔有的資源同時被另外一個申請，也就是前一個進程佔有後一個進程所深情地資源。 
  以上給出了致使死鎖的四個必要條件，只要系統發生死鎖則以上四個條件至少有一個成立。事實上循環等待的成立蘊含了前三個條件的成立，彷佛沒有必要列出然而考慮這些條件對死鎖的預防是有利的，由於能夠經過破壞四個條件中的任何一個來預防死鎖的發生。

避免方法：

（1）嚴格按照必定順序訪問資源；

（2）在取得進程可以執行的全部資源後纔給進程分配資源，不然不分配；

（3）

銀行家算法：

7.說一說ThreadLocal 關鍵字吧，答出核心。還有volatile，synchronized，Lock

當使用ThreadLocal維護變量時，ThreadLocal爲每一個使用該變量的線程提供獨立的變量副本，因此每個線程均可以獨立地改變本身的副本，而不會影響其它線程所對應的副本。

安全：使用元子類，實現併發鎖，使用線程安全的類，使用volatile關鍵字，

8.聚簇索引 和 非聚簇索引的區別 。下面貼一下核心內容：

創建聚族索引： CREATE CLUSTER INDEX index_name ON table_name(column_name1,column_name2,...);

存儲特色：

彙集索引：表數據按照索引的順序來存儲的，也就是說索引項的順序與表中記錄的物理順序一致。對於彙集索引，葉子結點即存儲了真實的數據行，再也不有另外單獨的數據頁。 在一張表上最多隻能建立一個彙集索引，由於真實數據的物理順序只能有一種。

非彙集索引 ： 表數據存儲順序與索引順序無關。對於非彙集索引，葉結點包含索引字段值及指向數據頁數據行的邏輯指針，其行數量與數據錶行數據量一致。

9.說一說項目中Spring的IOC和AOP具體怎麼使用的。

幾乎都用的IOC(經過Spring容器進行對象的管理，以及對象之間組合關係的映射)

日誌管理是AOP

10.談一談對數據庫事務的理解。四個特性和隔離級別必需要牢記，瞭解

事務併發控制帶來的問題：髒讀、不可重複讀、更新丟失、幻讀等等

原子性，一致性，隔離性，持久性；

① Serializable (串行化)：可避免髒讀、不可重複讀、幻讀的發生。

　　② Repeatable read (可重複讀)：可避免髒讀、不可重複讀的發生。

　　③ Read committed (讀已提交)：可避免髒讀的發生。

　　④ Read uncommitted (讀未提交)：最低級別，任何狀況都沒法保證。

MySql在哪個級別？ 可重複讀   

oracle是 讀已提交

4種都有啊？

11.問我Hibernate的生成策略，主要說了native 、uuid

indentity  實現數據庫自增的生成策略每次加1 

sequence 經過序列生成 主鍵

native 讓數據庫本身生成 適合的主鍵

 

12.說說struts，我就拿出struts 1 和 struts 2 對比着說了

13.mysql 熟悉嗎？知道間隙鎖嗎？InnodB，MyISAM區別？

http://blog.csdn.net/d12345678a/article/details/53858117

當咱們用範圍條件而不是相等條件檢索數據，並請求共享或排他鎖時，InnoDB會給符合條件的已有數據記錄的索引項加鎖；對於鍵值在條件範圍內但並不存在 的記錄，叫作「間隙（GAP)」，InnoDB也會對這個「間隙」加鎖，這種鎖機制就是所謂的間隙鎖（Next-Key鎖）。InnoDB除了經過範圍條件加鎖時使用間隙鎖外，若是使用相等條件請求給一個不存在的記錄加鎖，InnoDB也會使用間隙鎖！

Select * from  emp where empid > 100 for update;

間隙鎖的主要做用是爲了防止出現幻讀，可是它會把鎖定範圍擴大，有時候也會給咱們帶來麻煩。

間隙鎖，而後數據庫會向左掃描掃到第一個比給定參數小的值， 向右掃描掃描到第一個比給定參數大的值， 而後以此爲界，構建一個區間， 鎖住整個區間內的數據。

InnoDB存儲引擎既支持行級鎖（row-level locking），也支持表級鎖，但默認狀況下是採用行級鎖。MyISAM存儲引擎只支持表鎖。

MyISAM表鎖是deadlock free的，這是由於MyISAM老是一次得到所需的所有鎖，要麼所有知足，要麼等待，所以不會出現死鎖。

表級鎖：開銷小，加鎖快；不會出現死鎖；鎖定粒度大，發生鎖衝突的機率最高,併發度最低。

行級鎖：開銷大，加鎖慢；會出現死鎖；鎖定粒度最小，發生鎖衝突的機率最低,併發度也最高。

MySQL的表級鎖有兩種模式：表共享讀鎖（Table Read Lock）和表獨佔寫鎖（Table Write Lock）。MyISAM在執行查詢語句（SELECT）前，會自動給涉及的全部表加讀鎖，在執行更新操做（UPDATE、DELETE、INSERT等）前，會自動 給涉及的表加寫鎖，這個過程並不須要用戶干預，所以，用戶通常不須要直接用LOCK TABLE命令給MyISAM表顯式加鎖。

例子：

Lock tables orders read local, order_detail read local;

Select sum(total) from orders;

Select sum(subtotal) from order_detail;

Unlock tables;

上面的例子在LOCK TABLES時加了「local」選項，其做用就是在知足MyISAM表併發插入條件的狀況下，容許其餘用戶在表尾併發插入記錄。MyISAM是寫優先的。

經過按期在系統空閒時段執行 OPTIMIZE TABLE語句來整理空間碎片，收回因刪除記錄而產生的中間空洞。

InnoDB與MyISAM的最大不一樣有兩點：一是支持事務（TRANSACTION）；二是採用了行級鎖。

l  共享鎖（S）：容許一個事務去讀一行，阻止其餘事務得到相同數據集的排他鎖。

l  排他鎖（X)：容許得到排他鎖的事務更新數據，阻止其餘事務取得相同數據集的共享讀鎖和排他寫鎖。

另外，爲了容許行鎖和表鎖共存，實現多粒度鎖機制，InnoDB還有兩種內部使用的意向鎖（Intention Locks），這兩種意向鎖都是表鎖。

l  意向共享鎖（IS）：事務打算給數據行加行共享鎖，事務在給一個數據行加共享鎖前必須先取得該表的IS鎖。

l  意向排他鎖（IX）：事務打算給數據行加行排他鎖，事務在給一個數據行加排他鎖前必須先取得該表的IX鎖。

  共享鎖（S）：SELECT * FROM table_name WHERE ... LOCK IN SHARE MODE。

排他鎖（X)：SELECT * FROM table_name WHERE ... FOR UPDATE。

InnoDB行鎖是經過給索引上的索引項加鎖來實現的.因爲MySQL的行鎖是針對索引加的鎖，不是針對記錄加的鎖，因此雖然是訪問不一樣行的記錄，可是若是是使用相同的索引鍵，是會出現鎖衝突的。若是不是相同的索引就不會等待。

create table tab_no_index(id int,name varchar(10)) engine=innodb;

一是MySQL的恢復是SQL語句級的，也就是從新執行BINLOG中的SQL語句。

二是MySQL的Binlog是按照事務提交的前後順序記錄的，恢復也是按這個順序進行的。

14.java的優點

簡單（GC）、面向對象、平臺無關（JVM）、分佈式、多線程、可靠和安全等特性

15.有沒有用過哪些集合?

Collection       接口的接口     對象的集合 

├ List           子接口         按進入前後有序保存   可重複 

│├ LinkedList    接口實現類     鏈表     插入刪除   沒有同步   線程不安全 

│├ ArrayList     接口實現類     數組     隨機訪問   沒有同步   線程不安全 

│

├ Queue       子接口      隊列集合

└ Set            子接口       僅接收一次，並作內部排序 

├ HashSet 

│ 　 └ LinkedHashSet  插入的次序

└ TreeSet 

Map                接口      鍵值對的集合 

├ Hashtable                 接口實現類                同步        線程安全  鍵值非空

├ HashMap                   接口實現類                沒有同步    線程不安全 

│├ LinkedHashMap  插入次序

│└ WeakHashMap 

├ TreeMap  基於紅黑樹，能夠返回子樹 排序的

└ IdentifyHashMap 

Collections 是針對集合類的一個幫助類。提供了一系列靜態方法實現對各類集合的搜索、打亂Collections .shuffer()\\排序Collections .sort()、線程徹底化等操做。至關於對 Array 進行相似操做的類——   

Arrays 。 

16.Arraylist如何實現排序

經過compartor 的conpare(兩個參數) 

使用Collections.sort()傳入ArrayList，會採用默認的方式進行排序（字典序）

使用Collections.sort()傳入ArrayList和本身實現Commparator接口的類的對象，實現自定義排序 

使用List.sort()傳入本身實現Commparator接口的類的對象，實現自定義排序 

17.Spring的annotation（註解）如何實現

Annotation是代碼裏的特殊標記，這些標記能夠在編譯、類加載、運行時被讀取，並執行相應的處理。經過使用Annotation，開發人員能夠在不改變原有邏輯的狀況下，在源文件中嵌入一些補充的信息。代碼分析工具、開發工具和部署工具能夠經過這些補充信息進行驗證、處理或者進行部署。

4個元註解：1.@Target,用於描述註解的使用範圍，@Target(ElementType.FIELD)

　　　　2.@Retention,用於描述註解的生命週期，@Retention(RetentionPolicy.RUNTIME)

　　　　3.@Documented,能夠被例如javadoc此類的工具文檔化

4.@Inherited，@Inherited annotation類型是被標註過的class的子類所繼承。類並不從它所實現的接口繼承annotation，方法並不從它所重載的方法繼承annotation。

三種標準annontation類型：

（1）Override，被標註的方法重載了父類的方法；

（2）Deprecated

（3）SuppressWarnings，此註解能告訴Java編譯器關閉對類、方法及成員變量的警告。

@Autowired顧名思義，就是自動裝配，其做用是爲了消除代碼Java代碼裏面的getter/setter與bean屬性中的property。

若是容器中有一個以上匹配的Bean，則能夠經過@Qualifier註解限定Bean的名稱；

@Service對應的是業務層Bean；

@Repository對應數據訪問層Bean；

@Configuration把一個類做爲一個IoC容器，它的某個方法頭上若是註冊了@Bean，就會做爲這個Spring容器中的Bean。

@Scope註解 做用域

@Lazy(true) 表示延遲初始化

@Service用於標註業務層組件、

@Controller用於標註控制層組件（如struts中的action）

@Repository用於標註數據訪問組件，即DAO組件。

@Component泛指組件，當組件很差歸類的時候，咱們能夠使用這個註解進行標註。

@Scope用於指定scope做用域的（用在類上）

@PostConstruct用於指定初始化方法（用在方法上）

@PreDestory用於指定銷燬方法（用在方法上）

@DependsOn：定義Bean初始化及銷燬時的順序

@Primary：自動裝配時當出現多個Bean候選者時，被註解爲@Primary的Bean將做爲首選者，不然將拋出異常

@Autowired 默認按類型裝配，若是咱們想使用按名稱裝配，能夠結合@Qualifier註解一塊兒使用。以下：

@Autowired @Qualifier("personDaoBean") 存在多個實例配合使用

@Resource默認按名稱裝配，當找不到與名稱匹配的bean纔會按類型裝配。

@PostConstruct 初始化註解

@PreDestroy 摧毀註解 默認 單例  啓動就加載

@Async異步方法調用

Restful的優點：

透明性，暴露資源存在。

充分利用 HTTP 協議自己語義。

無狀態，這點很是重要。在調用一個接口（訪問、操做資源）的時候，能夠不用考慮上下文，不用考慮當前狀態，極大的下降了複雜度

HTTP 自己提供了豐富的內容協商手段，不管是緩存，仍是資源修改的樂觀併發控制，均可以以業務無關的中間件來實現

低耦合；

18.Redis如何解決key衝突

hashcode方法計算key決定在數組中的位置,hashcode值相同發生hash衝突,經過造成鏈表解決衝突  euqals方法決定在鏈表中的位置

19.HashMap，ConcurrentHashMap以及在什麼狀況下性能會很差

HashMap不是線程安全的

 

23.Java中的HashMap的工做原理是什麼？

Java中的HashMap是以鍵值對(key-value)的形式存儲元素的。HashMap須要一個hash函數，它使用hashCode()和 equals()方法來向集合/從集合添加和檢索元素。當調用put()方法的時候，HashMap會計算key的hash值，而後把鍵值對存儲在集合中 合適的索引上。若是key已經存在了，value會被更新成新值。HashMap的一些重要的特性是它的容量(capacity)，負載因子(load factor)和擴容極限(threshold resizing)。

24.hashCode()和equals()方法的重要性體如今什麼地方？

equals通常是用來實現兩個對象內容的比較，若是不重寫就會和==同樣。通常重寫equals方法的時候都會相應的重寫hashCode方法。（重寫hashCode方法是個難點）

Java中的HashMap使用hashCode()和equals()方法來肯定鍵值對的索引，當根據鍵獲取值的時候也會用到這兩個方法。若是沒有正確 的實現這兩個方法，兩個不一樣的鍵可能會有相同的hash值，所以，可能會被集合認爲是相等的。並且，這兩個方法也用來發現重複元素。因此這兩個方法的實現 對HashMap的精確性和正確性是相當重要的。

如何保證key的惟一性？即hashCode和equals的實現原理

相等的對象必須具備相同的散列碼，但散列碼相同則不必定是相等的對象，並且不相等的對象也不必定須要有不一樣的散列碼。

25.HashMap和Hashtable有什麼區別？

HashMap和Hashtable都實現了Map接口，所以不少特性很是類似。可是，他們有如下不一樣點：

HashMap容許鍵和值是null，而Hashtable不容許鍵或者值是null。

Hashtable是同步的，而HashMap不是。所以，HashMap更適合於單線程環境，而Hashtable適合於多線程環境。

HashMap提供了可供應用迭代的鍵的集合，所以，HashMap是快速失敗的。另外一方面Hashtable提供了對鍵的列舉(Enumeration)。通常認爲Hashtable是一個遺留的類。

20.Synchronized和lock區別

wait()和notify()必須在synchronized代碼塊中調用。

在併發量比較小的狀況下，使用synchronized是個不錯的選擇，可是在 併發量比較高的狀況下，其性能降低很嚴重 ，此時ReentrantLock是個不錯的方案。

區別：

（1）Synchronized是java關鍵字，是內置特性；而Lock是一個類；

（2）Lock可讓等待鎖的線程響應中斷，而synchronized卻不行；

（3）Lock能夠提升多個線程進行讀操做的效率；

（4）Synchronized的鎖是自動釋放的，Lock須要手動釋放；

（5）Lock能夠知道線程有沒有成功得到鎖。

java.util.concurrent.locks有Lock是一個接口：

void lock();

    void lockInterruptibly() throws InterruptedException;

    boolean tryLock();

    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

    void unlock();

ReentrantLock（可重入鎖）是惟一實現了Lock接口的類。

單獨調用interrupt()方法不能中斷正在運行過程當中的線程，只能中斷阻塞過程當中的線程。

ReentrantReadWriteLock是惟一實現ReadWriteLock接口的類，有ReadLock和WriteLock方法。

synchronized和ReentrantLock都是可重入鎖。

公平鎖即儘可能以請求鎖的順序來獲取鎖。好比同是有多個線程在等待一個鎖，當這個鎖被釋放時，等待時間最久的線程（最早請求的線程）會得到該所，這種就是公平鎖。

ReentrantLock lock = new ReentrantLock(true);

，synchronized就是非公平鎖，它沒法保證等待的線程獲取鎖的順序。

　　而對於ReentrantLock和ReentrantReadWriteLock，它默認狀況下是非公平鎖，可是能夠設置爲公平鎖。

public void test() {

     ...

     synchronized(this) {

          // todo your code

     }

     ...

}

此時，其效果等同於

public synchronized void test() {

     // todo your code

}

22.通常線程和守護線程的區別

Daemon的做用是爲其餘線程的運行提供服務，好比說GC線程。thread.setDaemon(true)必 須在thread.start()以前設置。 在Daemon線程中產生的新線程也是Daemon的。 

當全部的非守護線程結束時，程序也就終止了，同時會殺死進程中的全部守護線程

24.JDK中哪些體現了命令模式

 命令模式：將一個請求封裝爲一個對象，從而讓咱們可用不一樣的請求對客戶進行參數化，用於「行爲請求者」與「行爲實現者」解耦，可實現兩者之間的鬆耦合，以便適應變化。命令模式是一種對象行爲型模式，其別名爲動做(Action)模式或事務(Transaction)模式。

java.lang.Runnable 和 javax.swing.Action是使用命令模式的經典場景。

25.簡單介紹下線程池的參數？你瞭解哪些線程池？線程池使用了什麼設計模式？線程池使用時通常要考慮哪些問題?

java.util.concurrent.ThreadPoolExecutor;

corePoolSize：核心池的大小

maximumPoolSize：線程池最大線程數

keepAliveTime：表示線程沒有任務執行時最多保持多久時間會終止。

• threadFactory：線程工廠，主要用來建立線程；
• handler：表示當拒絕處理任務時的策略，有如下四種取值：

ThreadPoolExecutor.AbortPolicy:丟棄任務並拋出RejectedExecutionException異常。 

ThreadPoolExecutor.DiscardPolicy：也是丟棄任務，可是不拋出異常。 

ThreadPoolExecutor.DiscardOldestPolicy：丟棄隊列最前面的任務，而後從新嘗試執行任務（重複此過程）

ThreadPoolExecutor.CallerRunsPolicy：由調用線程處理該任務

線程池狀態：

static final int RUNNING    = 0;

static final int SHUTDOWN   = 1;

static final int STOP     = 2;

static final int TERMINATED = 3;

execute()

submit()

shutdown()

shutdownNow()當即終止線程池，並嘗試打斷正在執行的任務，而且清空任務緩存隊列，返回還沒有執行的任務.

線程池的種類：

Executors.newCachedThreadPool();  //建立一個緩衝池，緩衝池容量大小爲Integer.MAX_VALUE

Executors.newSingleThreadExecutor();   //建立 容量爲1的緩衝池

Executors.newFixedThreadPool(int);    //建立固定容量大小的緩衝池

Executors.newScheduleThreadPool建立一個定長的線程池，並且支持定時的以及 週期性的任務執行，相似於Timer。

通常須要根據任務的類型來配置線程池大小：

若是是CPU密集型任務，就須要儘可能壓榨CPU，參考值能夠設爲 NCPU+1

若是是IO密集型任務，參考值能夠設置爲2*NCPU

單個任務處理的時間很短而請求的數目倒是巨大的。join和close均可以用來關閉線程池。不一樣的是，join會把隊列中的任務執行完，而close則馬上清空隊列，而且中斷全部的工做線程。

線程池大小，死鎖，系統資源不足，併發錯誤，線程泄漏（好比都在等待用戶輸入），任務過載（太多等待任務）。

26.一致性Hash原理

27.Java虛擬機的一些參數配置

Trace跟蹤參數：

-XX:+PrintGCDetails 打印GC詳細信息；

-XX:+PrintGCTimeStamps 打印GC時間戳；

-Xloggc:log/gc.log 指定GC log的位置；

-XX:+PrintHeapAtGC 每一次GC前和GC後，都打印堆信息；

-XX:+TraceClassLoading 監控類的加載；

-XX:+PrintClassHistogram 按下Ctrl+Break後，打印類的信息；

堆的分配參數：

-Xmx20m -Xms5m 指定最大堆和最小堆；

問題1： -Xmx（最大堆空間）和 –Xms（最小堆空間）應該保持一個什麼關係，可讓系統的性能儘量的好呢？

問題2：若是你要作一個Java的桌面產品，須要綁定JRE，可是JRE又很大，你如何作一下JRE的瘦身呢？

-Xmn 官方推薦新生代佔堆的3/8，倖存代佔新生代的1/10

　　　　設置新生代大小

• -XX:NewRatio=4

　　　　新生代（eden+2*s）和老年代（不包含永久區）的比值

    　　　　例如：4，表示新生代:老年代=1:4，即新生代佔整個堆的1/5

• -XX:SurvivorRatio=2（倖存代）

　　　　設置兩個Survivor區和eden的比值

    　　　　例如：8，表示兩個Survivor:eden=2:8，即一個Survivor佔年輕代的1/10

-XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=d:/a.dump

若是發生了OOM異常，那就把dump信息導出到d:/a.dump文件中。

-XX:OnOutOfMemoryError=D:/tools/jdk1.7_40/bin/printstack.bat %p //p表明的是當前進程的pid

上方參數的意思是說，執行printstack.bat腳本，而這個腳本作的事情是：D:/tools/jdk1.7_40/bin/jstack -F %1 > D:/a.txt，即當程序OOM時，在D:/a.txt中將會生成線程的dump。

-XX:PermSize=16m  -XX:MaxPermSize：設置永久區的初始空間和最大空間；

棧的分配參數：

Xss 設置棧空間的大小。一般只有幾百K；-Xss128K

-XX:+UseParallelGC -XX:ParallelGCThreads=20此配置僅對年輕代有效。

-XX:MaxGCPauseMillis=100 : 設置每次年輕代垃圾回收的最長時間

-XX:+UseCMSCompactAtFullCollection ：打開對年老代的壓縮。

常見配置彙總

1. 堆設置

• -Xms :初始堆大小
• -Xmx :最大堆大小
• -XX:NewSize=n :設置年輕代大小
• -XX:NewRatio=n: 設置年輕代和年老代的比值。如:爲3，表示年輕代與年老代比值爲1：3，年輕代佔整個年輕代年老代和的1/4
• -XX:SurvivorRatio=n :年輕代中Eden區與兩個Survivor區的比值。注意Survivor區有兩個。如：3，表示Eden：Survivor=3：2，一個Survivor區佔整個年輕代的1/5
• -XX:MaxPermSize=n :設置持久代大小

2. 收集器設置

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

3. 垃圾回收統計信息

• -XX:+PrintGC
• -XX:+PrintGCDetails
• -XX:+PrintGCTimeStamps
• -Xloggc:filename

4. 並行收集器設置

• -XX:ParallelGCThreads=n :設置並行收集器收集時使用的CPU數。並行收集線程數。
• -XX:MaxGCPauseMillis=n :設置並行收集最大暫停時間
• -XX:GCTimeRatio=n :設置垃圾回收時間佔程序運行時間的百分比。公式爲1/(1+n)

5. 併發收集器設置

• -XX:+CMSIncrementalMode :設置爲增量模式。適用於單CPU狀況。
• -XX:ParallelGCThreads=n :設置併發收集器年輕代收集方式爲並行收集時，使用的CPU數。並行收集線程數。

28.Raft協議的leader選舉，正常狀況下，網絡抖動形成follower發起leader選舉，且該follower的

Term比現有leader高。集羣中全部結點的日誌信息當前一致，這種狀況下會選舉成功嗎？

只要term加1以後，以前的leader就做廢，這輪選舉必定能選出來。我以爲還得看下這個term何時會加1，意思就是題目中follower在什麼狀況下term比以前leader高。由於follower在一個時間段內由於網絡波動收不到leader的心跳，他就自動轉化爲candidate狀態且term+1。

29.Tcp鏈接4次揮手的緣由。Time_wait等待超時了會怎樣？

time_wait 狀態原本就是等待2個msl就直接進入closed狀態

TIME_WAIT狀態維持時間是兩個MSL時間長度，也就是在1-4分鐘。Windows操做系統就是4分鐘。

MSL就是maximum segment lifetime(最大分節生命期），這是一個IP數據包能在互聯網上生存的最長時間.

time_wait存在的緣由：

1.可靠的終止TCP鏈接。

2.保證讓遲來的TCP報文段有足夠的時間被識別並丟棄。

爲何要三次握手：

爲了防止已失效的鏈接請求報文段忽然又傳送到了服務端，於是產生錯誤。

「已失效的鏈接請求報文段」的產生在這樣一種狀況下：client發出的第一個鏈接請求報文段並無丟失，而是在某個網絡結點長時間的滯留了，以至延誤到鏈接釋放之後的某個時間纔到達server。原本這是一個早已失效的報文段。但server收到此失效的鏈接請求報文段後，就誤認爲是client再次發出的一個新的鏈接請求。因而就向client發出確認報文段，贊成創建鏈接。假設不採用「三次握手」，那麼只要server發出確認，新的鏈接就創建了。因爲如今client並無發出創建鏈接的請求，所以不會理睬server的確認，也不會向server發送數據。但server卻覺得新的運輸鏈接已經創建，並一直等待client發來數據。這樣，server的不少資源就白白浪費掉了。

爲何須要四次揮手：

緣由是由於tcp是全雙工模式，接收到FIN時意味將沒有數據再發來，可是仍是能夠繼續發送數據。

30.不一樣進程打開了同一個文件，那麼這兩個進程獲得的文件描述符（fd）相同嗎？

31.給定一個2叉樹，打印每一層最右邊的結點

32.spring bean初始化過程，Spring的DI工做原理，spring bean生命週期：

1. 容器尋找Bean的定義信息而且將其實例化。

2.受用依賴注入，Spring按照Bean定義信息配置Bean的全部屬性。

3.若是Bean實現了BeanNameAware接口，工廠調用Bean的setBeanName()方法傳遞Bean的ID。

4.若是Bean實現了BeanFactoryAware接口，工廠調用setBeanFactory()方法傳入工廠自身。

5.若是BeanPostProcessor和Bean關聯，那麼它們的postProcessBeforeInitialzation()方法將被調用。

6.若是Bean指定了init-method方法，它將被調用。

7.最後，若是有BeanPsotProcessor和Bean關聯，那麼它們的postProcessAfterInitialization()方法將被調用。

生命週期：執行完上面的步驟就能夠使用了，使用完畢後關閉容器：

調用DisposableBean的destory方法；

Bean在實例化的過程當中：Constructor > @PostConstruct >InitializingBean > init-method

Bean在銷燬的過程當中：@PreDestroy > DisposableBean > destroy-method

33.說一說對java io的理解

在整個 Java.io包中最重要的就是5個類和一個接口。5個類指的是File、OutputStream、InputStream、Writer、Reader；一個接口指的是Serializable.

適配器模式，改變接口來重複使用

把一個類的接口變成客戶端能接受的另外一種接口。

使兩個接口不同的類能一塊兒工做。

InputStreamReader適配器實現了Reader接口，持有InputStream引用。這樣Reader字節最終調用InputStream

InputStreamReader：對象+接口

 

裝飾器模式，接口不變，加強原來對象的功能

賦予類更多的功能，

FileInputStream,

BufferedInputStream是具體實現者，把InputStream讀取內容保存在內存中，加強了功能。

34.juc包（Java.util.concurrent）內有哪些類，CAS（比較並交換（compare and swap））如何實現，說一下對線程池的理解

它的基礎就是AbstractQueuedSynchronizer抽象類，Lock，CountDownLatch等的基礎就是該類，而該類又用到了 CAS操做。CAS以前已經介紹過。JUC在同步器的設計上有獲取操做和釋放操做。AbstractQueuedSynchronizer（AQS）就是 一種同步器的實現。

原子對象；

locks；

Semaphore一個計數信號量，主要用於控制多線程對共同資源庫訪問的限制。

CountDownLatch一個同步輔助類，在完成一組正在其餘線程中執行的操做以前，它容許一個或多個線程一直等待。CyclicBarrier用於一組線程執行時，每一個線程執行有多個節點，每一個節點的處理須要相互等待。

CAS 操做包含三個操做數 —— 內存位置（V）、預期原值（A）和新值(B)。我認爲位置 V 應該包含值 A；若是包含該值，則將 B 放到這個位置；不然，不要更改該位置，只告訴我這個位置如今的值便可。可是有ABA的問題，能夠經過版本號來解決。

public synchronized int compareAndSwap(int expectedValue, int newValue) {

int oldValue = value;

if (oldValue == expectedValue) {

value = newValue;

}

return oldValue;

}

unsafe.compareAndSwapInt(this, valueOffset, expect, update);

36.樹的中序遍歷，除了遞歸和棧還有什麼實現方式

Morris遍歷，其實是用葉子節點的空指針來記錄當前節點的位置，而後一旦遍歷到了葉子節點，發現葉子節點的右指針指向的是當前節點，那麼就認爲以當前節點的左子樹已經遍歷完成。

它的遍歷規則以下：

1. 若是當前節點的左子節點爲空時，輸出當前節點，並將當前節點置爲該節點的右子節點；

2. 若是當前節點的左子節點不爲空，找到當前節點左子樹的最右節點（該節點爲當前節點中序遍歷的前驅節點）；

2.1. 若是最右節點的右指針爲空(right=null)，將最右節點的右指針指向當前節點，當前節點置爲其左子節點；

2.2. 若是最右節點的右指針不爲空，將最右節點右指針從新置爲空(恢復樹的原狀)，輸出當前節點，並將當前節點置爲其右節點；

3. 重複1~2，直到當前節點爲空。

37.操做系統如何實現輸出

38.說一下對B+樹的瞭解

39.linux查詢java進程

ps -ef | grep java

kill -9 [PID] -9 表示強迫進程當即中止

40.linux查看內存佔用狀況

cat /proc/meminfo

sudo atop atop命令是一個終端環境的監控命令。它顯示的是各類系統資源的綜合，而且在高負載的狀況下進行了彩色標註。

top top命令提供了實時的運行中的程序的資源使用統計。

free -h free命令是一個快速查看內存使用狀況的方法，它是對 /proc/meminfo 收集到的信息的一個概述。

ps命令能夠實時的顯示各個進程的內存使用狀況。

vmstat命令顯示實時的和平均的統計，覆蓋CPU、內存、I/O等內容。

41.String，是否能夠繼承，「+」怎樣實現，與StringBuffer，StringBuilder區別

由於有final關鍵字，因此不能被繼承。

「+」是經過StringBuffer或者是StringBuilder的append()和toString()方法來實現的。

String類對象爲不可變對象，StringBuffer類對象爲可修改對象，能夠經過append()方法來修改值；都是線程安全的。

StringBuilder線程不安全，可是效率比StringBuffer高。

42.map 源碼，怎樣解決衝突，和擴容

開放地址法是對那些發生衝突的記錄，用hi=(h(key)+di)mod n方法再次肯定Hash地址。 

        n：爲哈希表長; 

       di：爲增量序列，其取法有如下三種： 

        1）線性探測再散列      di= c * i  

        2）二次探測再散列      di = 12, -12, 22, -22, …, 

        3) 隨機探測再散列      di是一組僞隨機數列 或者 di=i×H2(key) (又稱雙散列函數探測) 

鏈地址法：將全部哈希地址相同的記錄都連接在同一鏈表中

43.servlet流程

1. Web Client 向Servlet容器（Tomcat）發出Http請求
2. Servlet容器接收Web Client的請求
3. Servlet容器建立一個HttpRequest對象，將Web Client請求的信息封裝到這個對象中。
4. Servlet容器建立一個HttpResponse對象
5. Servlet容器調用HttpServlet對象的service方法，把HttpRequest對象與HttpResponse對象做爲參數傳給 HttpServlet 對象。
6. HttpServlet調用HttpRequest對象的有關方法，獲取Http請求信息。
7. HttpServlet調用HttpResponse對象的有關方法，生成響應數據。
8. Servlet容器把HttpServlet的響應結果傳給Web Client。

44.異常：Java中的兩種異常類型是什麼？他們有什麼區別？

Java異常分爲Exception和Error兩大類型，Exception又分爲運行時異常（RuntimeException)和非運行時異常（如IOException），運行時異常表明運行時由Java虛擬機生成的異常，Java編譯器要求Java程序必須捕獲或生命全部的非運行時異常，但對運行時異常能夠不作處理。

Java中有兩種異常：受檢查的(checked)異常和不受檢查的(unchecked)異常。不受檢查的異常不須要在方法或者是構造函數上聲明，就算方法或者是構造函數的執行可能會拋出這樣的異常，而且不受檢查的異常能夠傳播到方法或者是構造函數的外面。相反，受檢查的異常必需要用throws語句在方法或者是構造函數上聲明。這裏有Java異常處理的一些小建議。

Java中Exception和Error有什麼區別？

方法運行過程當中若是發生了意外，方法將生成一個相應類型的異常，並把它交給運行時系統，這一過程稱爲拋出。運行時系統受到異常後，會尋找相應的代碼來處理，這一過程稱爲捕獲。

Exception和Error都是Throwable的子類。Exception用於用戶程序能夠捕獲的異常狀況。Error是指Java虛擬機內部發生錯誤，由虛擬機生產並拋出，定義了不指望被用戶程序捕獲的異常。

Java的異常處理方式有兩種：（1）try-catch-finally；（2）throws。

爲何使用自定義異常？

由於項目中有時會有符合Java語法，可是不符合業務邏輯的狀況，這時就須要自定義異常了。

45.序列化，以及json傳輸

47.tomcat均衡方式 ，netty

48.session/cookie

什麼是cookie？session和cookie有什麼區別？

cookie是Web服務器發送給瀏覽器的一塊信息。瀏覽器會在本地文件中給每個Web服務器存儲cookie。之後瀏覽器在給特定的Web服務器發請求的時候，同時會發送全部爲該服務器存儲的cookie。下面列出了session和cookie的區別：

不管客戶端瀏覽器作怎麼樣的設置，session都應該能正常工做。客戶端能夠選擇禁用cookie，可是，session仍然是可以工做的，由於客戶端沒法禁用服務端的session。

在存儲的數據量方面session和cookies也是不同的。session可以 存儲任意的Java對象，cookie只能 存儲String類型的對象。

設置session有效期的方法有：

（1）在Tomcat的server.xml中定義；

（2）在工程的web.xml中定義；

（3）經過session.setMaxInactiveInterval(1000)；

判斷session是否失效：

request.getSession(false) == null ?

清楚session中的信息：session.invalidate()；

Cookie能夠設置有效期：cookie.setMaxAge(120)；

在禁用Cookie的狀況下使用Session：response.encodeurl(url);

49.利用數組，實現一個循環隊列類

隊爲空的判斷：front==rear；隊爲滿的判斷：(rear+1)%MAXSIZE==front。

public class CircleQueue {

private int[] q = null;

//首索引

private int head = 0;

//尾索引

private int tail = 0;

private int len = 0;

public CircleQueue(int len){

this.len = len;

q = new int[len];

}

//insert into circle queue

private int insert(int x){

//判斷循環隊列是否已滿

if (isFull()){

System.out.println("circle queue is Full");

return -1;

}else {

q[tail] = x;

//邏輯上實現首尾相連，循環隊列

tail = (tail + 1) % len;

//返回最近插入的元素

return x;

}

}

private int pop(){

if (isNull()){

System.out.println("circle queue is Null");

return -1;

}else {

int n = q[head];

//頭結點不斷追趕尾結點

head = (head + 1)%len;

//返回最近彈出的元素

return n;

}

}

private int head(){

return q[head];

}

private int tail(){

return q[(tail + len - 1)%len];

}

private boolean isFull(){

if ((tail + 1) % len == head){

return true;

}else {

return false;

}

}

//check is null

private boolean isNull(){

//首尾相等的話則爲空

if (head == tail){

return true;

}else {

return false;

}

}

}

50.http頭，TCP/IP 有幾層，每層有何含義

GET http://download.microtool.de:80/somedata.exe

Host: download.microtool.de

Accept:*/* 告訴WEB服務器本身接受什麼介質類型，*/* 表示任何類型

Pragma: no-cache

Cache-Control: no-cache 指定請求和響應遵循的緩存機制。

Connection：Keep-Alive 表示鏈接狀態

Referer: http://download.microtool.de/

User-Agent:Mozilla/4.04[en](Win95;I;Nav)

Range:bytes=554554-

響應：

HTTP/1.0 200 OK

Date:Mon,31Dec200104:25:57GMT

Server:Apache/1.3.14(Unix)

Content-type:text/html

Last-modified:Tue,17Apr200106:46:28GMT

Etag:"a030f020ac7c01:1e9f"

Content-length:39725426

Content-range:bytes554554-40279979/40279980

TCP/IP的4層模型：

（1）應用層：FTP、DNS、Telnet、SMTP、 HTTP

（2）傳輸層：TCP（傳輸控制協議）、UDP（用戶數據報協議）

（3）網絡層：IP

（4）網絡接口層：接受和發送IP數據包。

 

（1）應用層：與其餘計算機進行通信的一個應用，它是對應應用程序的通訊服務的。示例：telnet，HTTP,FTP,WWW,NFS,SMTP等。 

    （2）表示層：這一層的主要功能是定義數據格式及加密。示例：加密，ASII等。 

    （3）會話層：他定義瞭如何開始、控制和結束一個會話，包括對多個雙向小時的控制和管理，以便在只完成連續消息的一部分時能夠通知應用，從而使表示層看到的數據是連續的。示例：RPC，SQL等。 

   （4）傳輸層：這層的功能包括是否選擇差錯恢復協議仍是無差錯恢復協議，及在同一主機上對不一樣應用的數據流的輸入進行復用，還包括對收到的順序不對的數據包的從新排序功能。示例：TCP，UDP，SPX。 

   （5）網絡層：這層對端到端的包傳輸進行定義，他定義了可以標識全部結點的邏輯地址，還定義了路由實現的方9式和學習的方式。。示例：IP,IPX等。 

   （6）數據鏈路層：他定義了在單個鏈路上如何傳輸數據。

   （7）物理層：OSI的物理層規範是有關傳輸介質的特性標準，這些規範一般也參考了其餘組織制定的標準。

 

 

51.DNS的解析流程

一、在瀏覽器中輸入www.qq.com域名，操做系統會先檢查本身本地的hosts文件是否有這個網址映射關係，若是有，就先調用這個IP地址映射，完成域名解析。 

二、若是hosts裏沒有這個域名的映射，則查找本地DNS解析器緩存，是否有這個網址映射關係，若是有，直接返回，完成域名解析。 

三、若是hosts與本地DNS解析 器緩存都沒有相應的網址映射關係，首先會找TCP/ip參數中設置的首選DNS服務器，在此咱們叫它本地DNS服務器，此服務器收到查詢時，若是要查詢的 域名，包含在本地配置區域資源中，則返回解析結果給客戶機，完成域名解析，此解析具備權威性。 

四、若是要查詢的域名，不禁本地DNS服務器區域解析，但該服務器已緩存了此網址映射關係，則調用這個IP地址映射，完成域名解析，此解析不具備權威性。 

五、若是本地DNS服務器本地區域文 件與緩存解析都失效，則根據本地DNS服務器的設置（是否設置轉發器）進行查詢，若是未用轉發模式，本地DNS就把請求發至13臺根DNS，根DNS服務 器收到請求後會判斷這個域名(.com)是誰來受權管理，並會返回一個負責該頂級域名服務器的一個IP。本地DNS服務器收到IP信息後，將會聯繫負 責.com域的這臺服務器。這臺負責.com域的服務器收到請求後，若是本身沒法解析，它就會找一個管理.com域的下一級DNS服務器地址 (qq.com)給本地DNS服務器。當本地DNS服務器收到這個地址後，就會找qq.com域服務器，重複上面的動做，進行查詢，直至找到 www.qq.com主機。 

六、若是用的是轉發模式，此DNS服 務器就會把請求轉發至上一級DNS服務器，由上一級服務器進行解析，上一級服務器若是不能解析，或找根DNS或把轉請求轉至上上級，以此循環。無論是本地 DNS服務器用是是轉發，仍是根提示，最後都是把結果返回給本地DNS服務器，由此DNS服務器再返回給客戶機。

當應用過程須要將一個 主機域名映射爲IP地址時，就調用域名解析函數，解析函數將待轉換的域

名放在DNS請求中，以UDP報文方式發給本地 域名服務器。 本地的域名服務器查到域名後，將對應的IP地址放在應答報文中返回。同時域名服務器還必須具備連向其餘服務器的信息以支持不能解析時的轉發。若域名服務器 不能回答該請求，則此域名服務器就暫成爲DNS中的另外一個客戶，向根域名服務器發出請求解析，根域名服務器必定能找到下面的全部 二級域名的域名服務器，這樣以此類推，一直向下解析，直到查詢到所請求的域名。

52.MapReduce

52.Object中的方法

protected Object	clone()  建立並返回此對象的一個副本。
boolean	equals(Object obj)  指示其餘某個對象是否與此對象「相等」。
protected void	finalize()  當垃圾回收器肯定不存在對該對象的更多引用時，由對象的垃圾回收器調用此方法。
Class<?>	getClass()  返回此 Object 的運行時類。
int	hashCode()  返回該對象的哈希碼值。
void	notify()  喚醒在此對象監視器上等待的單個線程。
void	notifyAll()  喚醒在此對象監視器上等待的全部線程。
String	toString()  返回該對象的字符串表示。
void	wait()  在其餘線程調用此對象的 notify() 方法或 notifyAll() 方法前，致使當前線程等待。
void	wait(long timeout)  在其餘線程調用此對象的 notify() 方法或 notifyAll() 方法，或者超過指定的時間量前，致使當前線程等待。
void	wait(long timeout, int nanos)  在其餘線程調用此對象的 notify() 方法或 notifyAll() 方法，或者其餘某個線程中斷當前線程，或者已超過某個實際時間量前，致使當前線程等待。

54.進程和線程的區別是什麼？

進程是執行着的應用程序，而線程是進程內部的一個執行序列。一個進程能夠有多個線程。線程又叫作輕量級進程。

進程是CPU分配資源的最小單位，線程是CPU調度和程序執行的最小單位；

一個進程有幾個（至少一個）線程組成，他們共享進程資源，同一我的進程能夠有多個線程併發，一個線程能夠建立和撤銷另外一個線程；

進程有本身的獨立地址空間，線程只有本身的堆棧和局部變量；

進程切換須要很大的開銷，線程開銷相對較小。

協程避免了無心義的調度，由此能夠提升性能，但也所以，程序員必須本身承擔調度的責任，同時，協程也失去了標準線程使用多CPU的能力。

55.java的反射機制

反射的做用於原理。

反射是指程序能夠訪問、檢測和修改其自身狀態或行爲的一種能力。

56.數據庫索引的實現，MySQL主從結構

數據庫的DDL、DML（數據操縱語言）

DDL（數據庫定義語句）是SQL語言的四大功能之一。

用於定義 數據庫的三級結構，包括外模式、概念模式、內模式及其相互之間的映像，定義數據的完整性、安全控制等約束

DDL不須要commit.

CREATE

ALTER

DROP

TRUNCATE

COMMENT

RENAME

DML分紅交互型DML和嵌入型DML兩類。

依據語言的級別，DML又可分紅過程性DML和非過程性DML兩種。

須要commit.

SELECT

INSERT

UPDATE

DELETE

MERGE

CALL

EXPLAIN PLAN

LOCK TABLE

DCL（數據庫控制語言）

GRANT 受權

REVOKE 取消受權

TCL（Transaction Control Language）事務控制語言

SAVEPOINT 設置保存點

ROLLBACK  回滾

SET TRANSACTION

57.StringBuilder內部實現

底層也是char[]}經過append拼接字符  

58.linux相關：查看線程命令，用戶態和內核態

內核態: CPU能夠訪問內存全部數據, 包括外圍設備, 例如硬盤, 網卡. CPU也能夠將本身從一個程序切換到另外一個程序

用戶態: 只能受限的訪問內存, 且不容許訪問外圍設備. 佔用CPU的能力被剝奪, CPU資源能夠被其餘程序獲取

1. 用戶態程序將一些數據值放在寄存器中, 或者使用參數建立一個堆棧(stack frame), 以此代表須要操做系統提供的服務.
2. 用戶態程序執行陷阱指令
3. CPU切換到內核態, 並跳到位於內存指定位置的指令, 這些指令是操做系統的一部分, 他們具備內存保護, 不可被用戶態程序訪問
4. 這些指令稱之爲陷阱(trap)或者系統調用處理器(system call handler). 他們會讀取程序放入內存的數據參數, 並執行程序請求的服務
5. 系統調用完成後, 操做系統會重置CPU爲用戶態並返回系統調用的結果

用戶態切換到內核態的3種方式：a. 系統調用；b. 異常；c. 外圍設備的中斷。

59.Runnable傳入Thread構造方法，算是什麼設計模式。

代理設計模式。

Runnable target = new MyTarget();// 目標角色  

        Thread proxy = new Thread(target);// 代理角色  

        proxy.start(); 

61.系統降級的方案。

在開發高併發 系統時有三把利器用來保護系統：緩存、降級和限流。

62.socket客戶端和服務端

http://blog.csdn.net/zhangyiacm/article/details/49488721

 private void handleSocket() throws Exception {  

         Reader reader = new InputStreamReader(socket.getInputStream());  

         char chars[] = new char[64];  

         int len;  

         StringBuilder sb = new StringBuilder();  

         String temp;  

         int index;  

         while ((len=reader.read(chars)) != -1) {  

            temp = new String(chars, 0, len);  

            if ((index = temp.indexOf("eof")) != -1) {//遇到eof時就結束接收  

             sb.append(temp.substring(0, index));  

                break;  

            }  

            sb.append(temp);  

         }  

         System.out.println("from client: " + sb);  

         //讀完後寫一句  

       Writer writer = new OutputStreamWriter(socket.getOutputStream());  

         writer.write("Hello Client.");  

         writer.flush();  

         writer.close();  

         reader.close();  

         socket.close();  

      }  

        

   } 

 

 

----------------------------------------------------------------更新---------------------------------------------

 

1.數據庫索引：

數據庫索引；（高頻）

CREATE CLUSTER INDEX id

索引的實現一般使用B樹及其變種B+樹。

優勢：加快查詢速度；

缺點： 佔用空間，維護起來比較耗時；

建議使用索引的地方：主鍵，外鍵；須要排序或者根據範圍來檢索的列；常常須要搜索的列；WHERE子句中的列。

不建立索引的列：查詢不多用到的列； 只有不多數據值的列；修改性遠遠大於檢索性的列。

索引類型有： 主鍵索引，惟一索引，彙集索引。

將一個節點的大小設爲等於一個頁，這樣每一個節點只須要一次I/O就能夠徹底載入。B-Tree中一次檢索最多須要h-1次I/O（根節點常駐內存），漸進複雜度爲O(h)=O(logdN)。通常實際應用中，出度d是很是大的數字，一般超過100，所以h很是小（一般不超過3）。

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

預讀的長度通常爲頁（page）的整倍數。頁是計算機管理存儲器的邏輯塊，硬件及 操做系統往 往將主存和磁盤存儲區分割爲連續的大小相等的塊，每一個存儲塊稱爲一頁（在許多操做系統中，頁得大小一般爲4k），主存和磁盤以頁爲單位交換數據。當程序要 讀取的數據不在主存中時，會觸發一個缺頁異常，此時系統會向磁盤發出讀盤信號，磁盤會找到數據的起始位置並向後連續讀取一頁或幾頁載入內存中，而後異常返 回，程序繼續運行。

索引類型（全文索引），底層實現（B+樹），什麼狀況下索引會失效

索引是對數據庫表中一列或多列的值進行排序的一種結構。

惟一索引、主鍵索引和彙集索引。

MySQL目前主要有如下幾種索引類型：FULLTEXT，HASH，BTREE，RTREE。

FULLTEXT，即爲全文索引，目前只有MyISAM引擎支持。其能夠在CREATE TABLE ，ALTER TABLE ，CREATE INDEX 使用，不過目前只有 CHAR、VARCHAR ，TEXT 列上能夠建立全文索引。

HASH，hash很適合作索引，爲某一列或幾列創建hash索引，就會利用這一列或幾列的值經過必定的 算法計算出一個hash值，對應一行或幾行數據。

如下幾種狀況，將致使索引失效：

1. 若是條件中有or，即便其中有條件帶索引也不會使用(這也是爲何儘可能少用or的緣由)；
2. 對於多列索引，不是使用的第一部分，則不會使用索引

　 　3.like查詢是以%開頭

4.若是列類型是字符串，那必定要在條件中將數據使用引號引用起來,不然不使用索引

5.若是mysql估計使用全表掃描要比使用索引快,則不使用索引

數據庫優化（索引、存儲引擎、sql優化、視圖）

1.適當創建索引：對查詢進行優化，要儘可能避免全表掃描，首先應考慮在 where 及 order by 涉及的列上創建索引，但索引並非越多越好：

（1）應儘可能避免在 where 子句中對字段進行 null 值判斷，應儘可能避免在 where 子句中使用 != 或 <> 操做符，以及like "%aa"，使用參數， or （若是一個字段有索引，一個字段沒有索引），in 和 not in 也要慎用，應儘可能避免在where子句中對字段進行函數操做，不要在 where 子句中的「=」左邊進行函數、算術運算或其餘表達式運算，在使用索引字段做爲條件時，若是該索引是複合索引，那麼必須使用到該索引中的第一個字段做爲條件時才能保證系統使用該索引，不然該索引將不會被使用，而且應儘量的讓字段順序與索引順序相一致。

2.Update 語句，若是隻更改一、2個字段，不要Update所有字段，不然頻繁調用會引發明顯的性能消耗，同時帶來大量日誌。

3.對於多張大數據量（這裏幾百條就算大了）的表JOIN，要先分頁再JOIN，不然邏輯讀會很高，性能不好。

4.select count(*) from table； 這樣不帶任何條件的count會引發全表掃描，而且沒有任何業務意義，是必定要杜絕的。

5.應儘量的避免更新 clustered 索引數據列，由於 clustered 索引數據列的順序就是表記錄的物理存儲順序，一旦該列值改變將致使整個表記錄的順序的調整，會耗費至關大的資源。

6.選擇適當的字段類型，特別是主鍵：儘可能使用數字型字段，若只含數值信息的字段儘可能不要設計爲字符型。

索引的實現一般使用B樹及其變種B+樹。