留學生大佬面經

做者：bobbyparadise
連接：https://www.nowcoder.com/discuss/84899?type=0&order=4&pos=3&page=1
來源：牛客網

拼多多面試：

1，·  CHROME給每一個tab開了進程，爲何？ 其實就是問線程與進程區別 ：

· ·  進程是具備必定獨立功能的程序、它是系統進行資源分配和調度的一個獨立單位，重點在系統調度和單獨的單位，也就是說進程是能夠獨立運行的一段程序。

· 線程是進程的一個實體，是CPU調度和分派的基本單位，他是比進程更小的能獨立運行的基本單位，線程本身基本上不擁有系統資源。在運行時，只是暫用一些計數器、寄存器和棧 。

· 調度：線程做爲調度和分配的基本單位，進程做爲擁有資源的基本單位。

· 併發性：不只進程之間能夠併發執行，同一個進程的多個線程之間也能夠併發執行。

· 擁有資源：進程是擁有資源的一個獨立單位，線程不擁有系統資源，但能夠訪問隸屬於進程的資源。

· 具體見Java線程與線程、進程與進程之間通訊方式

1 線程與線程間通訊

1.1 基本概念以及線程與進程之間的區別聯繫

· 關於進程和線程，首先從定義上理解就有所不一樣：

1. 進程是具備必定獨立功能的程序、它是系統進行資源分配和調度的一個獨立單位，重點在系統調度和單獨的單位，也就是說進程是能夠獨立運行的一段程序。

2. 線程是進程的一個實體，是CPU調度和分派的基本單位，他是比進程更小的能獨立運行的基本單位，線程本身基本上不擁有系統資源。在運行時，只是暫用一些計數器、寄存器和棧 。

·

他們之間的關係

·

1. 一個線程只能屬於一個進程，而一個進程能夠有多個線程，但至少有一個線程（一般說的主線程）。

2. 資源分配給進程，同一進程的全部線程共享該進程的全部資源。

3. 線程在執行過程當中，須要協做同步。不一樣進程的線程間要利用消息通訊的辦法實現同步。

4. 處理機分給線程，即真正在處理機上運行的是線程。

5. 線程是指進程內的一個執行單元，也是進程內的可調度實體。

·

從三個角度來剖析兩者之間的區別

·

1. 調度：線程做爲調度和分配的基本單位，進程做爲擁有資源的基本單位。

2. 併發性：不只進程之間能夠併發執行，同一個進程的多個線程之間也能夠併發執行。

3. 擁有資源：進程是擁有資源的一個獨立單位，線程不擁有系統資源，但能夠訪問隸屬於進程的資源。

1.2 多線程間通訊方式

· 共享變量

· wait/notify機制

· Lock/Condition機制

· 管道

1.2.1 共享變量

· 線程間發送信號的一個簡單方式是在共享對象的變量裏設置信號值。線程A在一個同步塊裏設置boolean型成員變量hasDataToProcess爲true，線程B也在同步塊裏讀取hasDataToProcess這個成員變量。這個簡單的例子使用了一個持有信號的對象，並提供了set和check方法:

1 2 3 4 5 6 7 8 9 10 11 12 13

public class MySignal{ protected boolean hasDataToProcess = false; public synchronized boolean hasDataToProcess(){ return this.hasDataToProcess; } public synchronized void setHasDataToProcess(boolean hasData){ this.hasDataToProcess = hasData; } }

· 線程A和B必須得到指向一個MySignal共享實例的引用，以便進行通訊。若是它們持有的引用指向不一樣的MySingal實例，那麼彼此將不能檢測到對方的信號。須要處理的數據能夠存放在一個共享緩存區裏，它和MySignal實例是分開存放的。

1.2.2 wait()/notify機制

· 爲了實現線程通訊，咱們能夠使用Object類提供的wait()、notify()、notifyAll()三個方法。調用wait()方法會釋放對該同步監視器的鎖定。這三個方法必須由同步監視器對象來調用，這可分紅兩種狀況：

o 對於使用synchronized修飾的同步方法，由於該類的默認實例是(this)就是同步監視器，因此能夠直接調用這三使用個方法。

o 對於synchronized修飾的同步代碼塊，同步監視器是synchronized括號裏的對象，因此必須使用該對象調用這三個方法。

·

假設系統中有兩條線程，這兩條線程分別表明取錢者和存錢者。如今系統有一種特殊的要求，系統要求存款者和取錢者不斷的實現存款和取錢動做，並且要求每當存款者將錢存入指定帳戶後，取錢者當即將錢取走.不容許存款者兩次存錢，也不容許取錢者兩次取錢。
咱們經過設置一個旗標來標識帳戶中是否已有存款，有就爲true,沒有就標爲false。具體代碼以下:

·

·

首先咱們定義一個Account類，這個類中有取錢和存錢的兩個方法，因爲這兩個方法可能須要併發的執行取錢、存錢操做，全部將這兩個方法都修改成同步方法.(使用synchronized關鍵字)。

·

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57

public class Account { private String accountNo; private double balance; //標識帳戶中是否有存款的旗標 private boolean flag=false; public Account() { super(); } public Account(String accountNo, double balance) { super(); this.accountNo = accountNo; this.balance = balance; } public synchronized void draw (double drawAmount){ try { if(!flag){ this.wait(); }else { //取錢 System.out.println(Thread.currentThread().getName()+" 取錢:"+drawAmount); balance=balance-drawAmount; System.out.println("餘額 : "+balance); //將標識帳戶是否已有存款的標誌設爲false flag=false; //喚醒其它線程 this.notifyAll(); } } catch (Exception e) { e.printStackTrace(); } } public synchronized void deposit(double depositAmount){ try { if(flag){ this.wait(); } else{ System.out.println(Thread.currentThread().getName()+"存錢"+depositAmount); balance=balance+depositAmount; System.out.println("帳戶餘額爲："+balance); flag=true; //喚醒其它線程 this.notifyAll(); } } catch (Exception e) { // TODO: handle exception e.printStackTrace(); } } }

· 接下來建立兩個線程類，分別爲取錢和存錢線程！

· 取錢線程類：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

public class DrawThread implements Runnable { private Account account; private double drawAmount; public DrawThread(Account account, double drawAmount) { super(); this.account = account; this.drawAmount = drawAmount; } public void run() { for(int i=0;i<100;i++){ account.draw(drawAmount); } } }

· 存錢線程類：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

public class depositThread implements Runnable{ private Account account; private double depositAmount; public depositThread(Account account, double depositAmount) { super(); this.account = account; this.depositAmount = depositAmount; } public void run() { for(int i=0;i<100;i++){ account.deposit(depositAmount); } } }

· 最後咱們測試一下這個取錢和存錢的操做

1 2 3 4 5 6 7 8 9 10

public  class TestDraw { public static void main(String[] args) { //建立一個帳戶 Account account=new Account(); new Thread(new DrawThread(account, 800),"取錢者").start(); new Thread(new depositThread(account, 800),"存款者甲").start(); new Thread(new depositThread(account, 800),"存款者乙").start(); new Thread(new depositThread(account, 800),"存款者丙").start(); } }

· 大體的輸出結果以下

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

存款者甲存錢800.0 帳戶餘額爲：800.0 取錢者 取錢:800.0 餘額 : 0.0 存款者丙存錢800.0 帳戶餘額爲：800.0 取錢者 取錢:800.0 餘額 : 0.0 存款者甲存錢800.0 帳戶餘額爲：800.0 取錢者 取錢:800.0 餘額 : 0.0 存款者丙存錢800.0 帳戶餘額爲：800.0 取錢者 取錢:800.0 餘額 : 0.0 存款者甲存錢800.0 帳戶餘額爲：800.0 取錢者 取錢:800.0 餘額 : 0.0 存款者丙存錢800.0 帳戶餘額爲：800.0 取錢者 取錢:800.0 餘額 : 0.0 存款者甲存錢800.0 帳戶餘額爲：800.0 取錢者 取錢:800.0 餘額 : 0.0 存款者丙存錢800.0 帳戶餘額爲：800.0 取錢者 取錢:800.0 餘額 : 0.0 存款者甲存錢800.0 帳戶餘額爲：800.0 取錢者 取錢:800.0 餘額 : 0.0

1.2.3 Lock/Condition機制

· 如何程序不使用synchronized關鍵字來保持同步，而是直接適用Lock對像來保持同步，則系統中不存在隱式的同步監視器對象，也就不能使用wait()、notify()、notifyAll()來協調線程的運行.

· 當使用LOCK對象保持同步時，Java爲咱們提供了Condition類來協調線程的運行。關於Condition類，JDK文檔裏進行了詳細的解釋.，再次就不囉嗦了。

· 咱們就拿Account類進行稍微的修改 一下吧！

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80

import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class Account { //顯示定義Lock對象 private final Lock lock=new ReentrantLock(); //得到指定Lock對象對應的條件變量 private final  Condition con=lock.newCondition(); private String accountNo; private double balance; //標識帳戶中是否有存款的旗標 private boolean flag=false; public Account() { super(); } public Account(String accountNo, double balance) { super(); this.accountNo = accountNo; this.balance = balance; } public void draw (double drawAmount){ //加鎖 lock.lock(); try { if(!flag){ //            this.wait(); con.await(); }else { //取錢 System.out.println(Thread.currentThread().getName()+" 取錢:"+drawAmount); balance=balance-drawAmount; System.out.println("餘額 : "+balance); //將標識帳戶是否已有存款的標誌設爲false flag=false; //喚醒其它線程 //               this.notifyAll(); con.signalAll(); } } catch (Exception e) { e.printStackTrace(); } finally{ lock.unlock(); } } public void deposit(double depositAmount){ //加鎖 lock.lock(); try { if(flag){ //              this.wait(); con.await(); } else{ System.out.println(Thread.currentThread().getName()+"存錢"+depositAmount); balance=balance+depositAmount; System.out.println("帳戶餘額爲："+balance); flag=true; //喚醒其它線程 //                this.notifyAll(); con.signalAll(); } } catch (Exception e) { // TODO: handle exception e.printStackTrace(); }finally{ lock.unlock(); } } }

· 輸出結果和上面是同樣的！只不過這裏顯示的使用Lock對像來充當同步監視器,使用Condition對象來暫停指定線程，喚醒指定線程！

1.2.4 管道

·

管道流是JAVA中線程通信的經常使用方式之一，基本流程以下：

·

1.

建立管道輸出流PipedOutputStream pos和管道輸入流PipedInputStream pis

2.

3.

將pos和pis匹配，pos.connect(pis);

4.

5.

將pos賦給信息輸入線程，pis賦給信息獲取線程，就能夠實現線程間的通信了

6.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87

import java.io.IOException; import java.io.PipedInputStream; import java.io.PipedOutputStream; public class testPipeConnection { public static void main(String[] args) { /** * 建立管道輸出流 */ PipedOutputStream pos = new PipedOutputStream(); /** * 建立管道輸入流 */ PipedInputStream pis = new PipedInputStream(); try { /** * 將管道輸入流與輸出流鏈接 此過程也可經過重載的構造函數來實現 */ pos.connect(pis); } catch (IOException e) { e.printStackTrace(); } /** * 建立生產者線程 */ Producer p = new Producer(pos); /** * 建立消費者線程 */ Consumer1 c1 = new Consumer1(pis); /** * 啓動線程 */ p.start(); c1.start(); } } /** * 生產者線程(與一個管道輸入流相關聯) * */ class Producer extends Thread { private PipedOutputStream pos; public Producer(PipedOutputStream pos) { this.pos = pos; } public void run() { int i = 0; try { while(true) { this.sleep(3000); pos.write(i); i++; } } catch (Exception e) { e.printStackTrace(); } } } /** * 消費者線程(與一個管道輸入流相關聯) * */ class Consumer1 extends Thread { private PipedInputStream pis; public Consumer1(PipedInputStream pis) { this.pis = pis; } public void run() { try { while(true) { System.out.println("consumer1:"+pis.read()); } } catch (IOException e) { e.printStackTrace(); } } }

· 程序啓動後，就能夠看到producer線程往consumer1線程發送數據

consumer1:0

consumer1:1

consumer1:2

consumer1:3

......

·

管道流雖然使用起來方便，可是也有一些缺點

·

o

管道流只能在兩個線程之間傳遞數據 。線程consumer1和consumer2同時從pis中read數據，當線程producer往管道流中寫入一段數據後，每個時刻只有一個線程能獲取到數據，並非兩個線程都能獲取到producer發送來的數據，所以一個管道流只能用於兩個線程間的通信。不只僅是管道流，其餘IO方式都是一對一傳輸。

o

o

管道流只能實現單向發送，若是要兩個線程之間互通信，則須要兩個管道流 。能夠看到上面的例子中，線程producer經過管道流向線程consumer發送數據，若是線程consumer想給線程producer發送數據，則須要新建另外一個管道流pos1和pis1，將pos1賦給consumer1，將pis1賦給producer，具體例子本文再也不多說。

o

2 進程與進程間通訊

2.1 進程間通訊方式

· 管道（Pipe） ：管道可用於具備親緣關係進程間的通訊，容許一個進程和另外一個與它有共同祖先的進程之間進行通訊。

· 命名管道（named pipe） ：命名管道克服了管道沒有名字的限制，所以，除具備管道所具備的功能外，它還容許無親緣關係進程間的通訊。命名管道在文件系統中有對應的文件名。命名管道經過命令mkfifo或系統調用mkfifo來建立。

· 信號（Signal） ：信號是比較複雜的通訊方式，用於通知接受進程有某種事件發生，除了用於進程間通訊外，進程還能夠發送信號給進程自己；Linux除了支持Unix早期信號語義函數sigal外，還支持語義符合Posix.1標準的信號函數sigaction（實際上，該函數是基於BSD的，BSD爲了實現可靠信號機制，又可以統一對外接口，用sigaction函數從新實現了signal函數）。

· 消息（Message）隊列 ：消息隊列是消息的連接表，包括Posix消息隊列system V消息隊列。有足夠權限的進程能夠向隊列中添加消息，被賦予讀權限的進程則能夠讀走隊列中的消息。消息隊列克服了信號承載信息量少，管道只能承載無格式字節流以及緩衝區大小受限等缺

· 共享內存 ：使得多個進程能夠訪問同一塊內存空間，是最快的可用IPC形式。是針對其餘通訊機制運行效率較低而設計的。每每與其它通訊機制，如信號量結合使用，來達到進程間的同步及互斥。

· 內存映射（mapped memory） ：內存映射容許任何多個進程間通訊，每個使用該機制的進程經過把一個共享的文件映射到本身的進程地址空間來實現它。

· 信號量（semaphore） ：主要做爲進程間以及同一進程不一樣線程之間的同步手段。

· 套接口（Socket） ：更爲通常的進程間通訊機制，可用於不一樣機器之間的進程間通訊。起初是由Unix系統的BSD分支開發出來的，但如今通常能夠移植到其它類Unix系統上：linux和System V的變種都支持套接字。

CVTE一面

·  我的介紹

·  ·  springMVC攔截器和過濾器的區別

http://blog.csdn.net/chenleixing/article/details/44573495

·  ·  excel導出功能如何實現

http://blog.csdn.net/gaojinshan/article/details/30221729

·  ·  SpringIOC和AOP，動態代理實現方式

·  ·  自動裝配有哪幾種方式，自動裝配有什麼侷限性

模式	說明
Default	在每一個bean中都一個autowire=default的默認配置它的含義是： 採用beans和跟標籤中的default-autowire="屬性值"同樣的設置。
On	不使用自動裝配，必須經過ref元素指定依賴，默認設置。
ByNname	根據屬性名自動裝配。此選項將檢查容器並根據名字查找與屬性徹底一致的bean，並將其與屬性自動裝配。例如，在bean定義中將autowire設置爲by name，而該bean包含master屬性（同時提供setMaster(..)方法），Spring就會查找名爲master的bean定義，並用它來裝配給master屬性。
Bytype	若是容器中存在一個與指定屬性類型相同的bean，那麼將與該屬性自動裝配。若是存在多個該類型的bean，那麼將會拋出異常，並指出不能使用byType方式進行自動裝配。若沒有找到相匹配的bean，則什麼事都不發生，屬性也不會被設置。若是你不但願這樣，那麼能夠經過設置dependency-check="objects"讓Spring拋出異常。
Constructor	與byType的方式相似，不一樣之處在於它應用於構造器參數。若是在容器中沒有找到與構造器參數類型一致的bean，那麼將會拋出異常。
Antodetect	經過bean類的自省機制（introspection）來決定是使用constructor仍是byType方式進行自動裝配。若是發現默認的構造器，那麼將使用byType方式。

注意：

byName 和byType

在使用的過程當中必須保證bean可以初始化,不然的話會出現bug

若是有默認的無參數的構造器就不須要多餘的配置

若是有帶有參數的構造器,那在bean的配置中必須配置器初始化的參數 或者在bean中添加無參數的構造器

基本類型不能夠裝配，精準度 易混亂bean必須能夠得到

·  ·  數據庫引擎，Innodb,MyISAM的區別

MyISAM和InnoDB的區別

1. MySQL默認採用的是MyISAM。

2. MyISAM不支持事務，而InnoDB支持。InnoDB的AUTOCOMMIT默認是打開的，即每條SQL語句會默認被封裝成一個事務，自動提交，這樣會影響速度，因此最好是把多條SQL語句顯示放在begin和commit之間，組成一個事務去提交。

3. InnoDB支持數據行鎖定，MyISAM不支持行鎖定，只支持鎖定整個表。即MyISAM同一個表上的讀鎖和寫鎖是互斥的，MyISAM併發讀寫時若是等待隊列中既有讀請求又有寫請求，默認寫請求的優先級高，即便讀請求先到，因此MyISAM不適合於有大量查詢和修改並存的狀況，那樣查詢進程會長時間阻塞。由於MyISAM是鎖表，因此某項讀操做比較耗時會使其餘寫進程餓死。

4. InnoDB支持外鍵，MyISAM不支持。

5. InnoDB的主鍵範圍更大，最大是MyISAM的2倍。

6. InnoDB不支持全文索引，而MyISAM支持。全文索引是指對char、varchar和text中的每一個詞（停用詞除外）創建倒排序索引。MyISAM的全文索引其實沒啥用，由於它不支持中文分詞，必須由使用者分詞後加入空格再寫到數據表裏，並且少於4個漢字的詞會和停用詞同樣被忽略掉。

7. MyISAM支持GIS數據，InnoDB不支持。即MyISAM支持如下空間數據對象：Point,Line,Polygon,Surface等。

8. 沒有where的count(*)使用MyISAM要比InnoDB快得多。由於MyISAM內置了一個計數器，count(*)時它直接從計數器中讀，而InnoDB必須掃描全表。因此在InnoDB上執行count(*)時通常要伴隨where，且where中要包含主鍵之外的索引列。爲何這裏特別強調「主鍵之外」？由於InnoDB中primary index是和raw data存放在一塊兒的，而secondary index則是單獨存放，而後有個指針指向primary key。因此只是count(*)的話使用secondary index掃描更快，而primary key則主要在掃描索引同時要返回raw data時的做用較大。

·  ·  索引實現方式，B+樹有什麼特色，B樹和B+數的區別，B+樹的實現方式

·  ·  索引的最左配原則

·  ·  HashMap和HashSet的區別，HashMap是有序的嗎

·  ·  LinkedHashMap，保證什麼有序，底層實現。

·  ·  java多線程的方式，FutureTask CallAble介紹，CallAble和Runnable的區別

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

·  ·  線程池

·  ·  類的加載過程，雙親委派機制

上午交叉面，下午已回絕。四面掛，心痛。分享面經，爲後面校招攢人品。

一面：(8月1號上午：電話面試：80分32秒)

1.自我介紹？

2.作過哪些項目？項目中遇到哪些難點，你是怎樣解決的？單點登陸系統說一下？分佈式緩存的使用場景？(說好的基礎呢，上來就是項目，毫無準備，致使好多東西都記不起來了。面試官還說「那你說一個你記得的項目」，手動無奈。。。)

分佈式緩存的典型應用場景可分爲如下幾類:

1)頁面緩存.用來緩存Web頁面的內容片斷,包括HTML、CSS和圖片等,多應用於社交網站等;

2)應用對象緩存.緩存系統做爲ORM框架的二級緩存對外提供服務,目的是減輕數據庫的負載壓力,加速應用訪問;

3)狀態緩存.緩存包括Session會話狀態及應用橫向擴展時的狀態數據等,這類數據通常是難以恢復的,對可用性要求較高,多應用於高可用集羣;

4)並行處理.一般涉及大量中間計算結果須要共享;

5)事件處理.分佈式緩存提供了針對事件流的連續查詢(continuous query)處理技術,知足實時性需求;

6)極限事務處理.分佈式緩存爲事務型應用提供高吞吐率、低延時的解決方案,支持高併發事務請求處理,多應用於鐵路、金融服務和電信等領域.

3.你實習的時候JDK用的是那個版本，這個版本有什麼新的特性？

http://zcc888.gitee.io/2018/03/20/java/#more

Jdk7的新特性：

1.對集合類的語言支持；(？？)

2.自動資源管理；

3.改進的通用實例建立類型推斷；(？？)

4.數字字面量下劃線支持；（√）

5.switch中使用string；（√）

JSR292 的實現增長了一個 InvokeDynamic 的字節碼指令來支持動態類型語言，使得在把源代碼編譯成字節碼時並不須要肯定方法的簽名，即方法參數的類型和返回類型。當運行時執行 InvokeDynamic 指令時，JVM 會經過新的動態連接機制 Method Handles，尋找到真實的方法。

G1

ClassLoader 新增 API

爲了防止自定義多線程ClassLoad產生的死鎖問題，java.lang.ClassLoader類增長了如下API。

4.G1回收器和其餘回收器有什麼區別？

併發與並行，部分代 本身就能夠，局部複製全局標記整理堆>4G會比較好。

Java 8及G1回收器

Java 8 update 20所引入的一個很棒的優化就是G1回收器中的字符串去重（String deduplication）。因爲字符串(包括它們內部的char[]數組）佔用了大多數的堆空間，這項新的優化旨在使得G1回收器能識別出堆中那些重複出現的字符串並將它們指向同一個內部的char[]數組，以免同一個字符串的多份拷貝，那樣堆的使用效率會變得很低。你能夠使用-XX:+UseStringDeduplication這個JVM參數來試一下這個特性。

Java 8及持久代

Java 8中最大的改變就是持久代的移除，它本來是用來給類元數據，駐留字符串，靜態變量來分配空間的。這在之前都是須要開發人員來針對那些會加載大量類的應用來專門進行堆比例的優化及調整。許多年來都是如此，這也正是許多OutOfMemory異常的根源，所以由JVM來接管它真是再好不過了。即使如此，它自己並不會減小開發人員將應用解耦到不一樣的JVM中的可能性。

每一個回收器都有許多不一樣的開關和選項來進行調優，這可能會增長吞吐量，也可能會減小，這取決於你的應用的具體的行爲了。在下一篇文章中咱們會深刻講解配置這些算法的關鍵策略。

5.垃圾回收爲何會停頓？哪些對象可能做爲GCRoots?

虛擬機棧中引用的對象 方法區（靜態屬性，常量引用的對象）本地方法棧中引用的對象。

6.垃圾回收分代收集算法？爲何會有兩個Survivor區？new一個對象會保存在哪裏？

堆

Survivor的存在乎義，就是減小被送到老年代的對象，進而減小Full GC的發生，Survivor的預篩選保證，只有經歷16次Minor GC還能在新生代中存活的對象，纔會被送到老年代。

http://blog.csdn.net/antony9118/article/details/51425581

設置兩個Survivor區最大的好處就是解決了碎片化

7.Java內存模型?volatile關鍵字，使用場景？原子性的理解？先行發生原則？

Java內存模型中規定了全部的變量都存儲在主內存中，每條線程還有本身的工做內存（能夠與前面將的處理器的高速緩存類比），線程的工做內存中保存了該線程使用到的變量到主內存副本拷貝，線程對變量的全部操做（讀取、賦值）都必須在工做內存中進行，而不能直接讀寫主內存中的變量。

· lock（鎖定）：做用於主內存的變量，把一個變量標識爲一條線程獨佔狀態。

· unlock（解鎖）：做用於主內存變量，把一個處於鎖定狀態的變量釋放出來，釋放後的變量才能夠被其餘線程鎖定。

· read（讀取）：做用於主內存變量，把一個變量值從主內存傳輸到線程的工做內存中，以便隨後的load動做使用

· load（載入）：做用於工做內存的變量，它把read操做從主內存中獲得的變量值放入工做內存的變量副本中。

· use（使用）：做用於工做內存的變量，把工做內存中的一個變量值傳遞給執行引擎，每當虛擬機遇到一個須要使用變量的值的字節碼指令時將會執行這個操做。

· assign（賦值）：做用於工做內存的變量，它把一個從執行引擎接收到的值賦值給工做內存的變量，每當虛擬機遇到一個給變量賦值的字節碼指令時執行這個操做。

· store（存儲）：做用於工做內存的變量，把工做內存中的一個變量的值傳送到主內存中，以便隨後的write的操做。

· write（寫入）：做用於主內存的變量，它把store操做從工做內存中一個變量的值傳送到主內存的變量中。

若是要把一個變量從主內存中複製到工做內存，就須要按順尋地執行read和load操做，若是把變量從工做內存中同步回主內存中，就要按順序地執行store和write操做。Java內存模型只要求上述操做必須按順序執行，而沒有保證必須是連續執行。也就是read和load之間，store和write之間是能夠插入其餘指令的，如對主內存中的變量a、b進行訪問時，可能的順序是read a，read b，load b，load a。Java內存模型還規定了在執行上述八種基本操做時，必須知足以下規則：

· 不容許read和load、store和write操做之一單獨出現

· 不容許一個線程丟棄它的最近assign的操做，即變量在工做內存中改變了以後必須同步到主內存中。

· 不容許一個線程無緣由地（沒有發生過任何assign操做）把數據從工做內存同步回主內存中。

· 一個新的變量只能在主內存中誕生，不容許在工做內存中直接使用一個未被初始化（load或assign）的變量。即就是對一個變量實施use和store操做以前，必須先執行過了assign和load操做。

· 一個變量在同一時刻只容許一條線程對其進行lock操做，lock和unlock必須成對出現

· 若是對一個變量執行lock操做，將會清空工做內存中此變量的值，在執行引擎使用這個變量前須要從新執行load或assign操做初始化變量的值

· 若是一個變量事先沒有被lock操做鎖定，則不容許對它執行unlock操做；也不容許去unlock一個被其餘線程鎖定的變量。

· 對一個變量執行unlock操做以前，必須先把此變量同步到主內存中（執行store和write操做）。

Volatile有五個使用場景(參考Brian Goetz (brian.goetz@sun.com)的文章):

1.做爲狀態標誌

2.一次性安全發佈

3.獨立觀察

4.volatile bean模式

5.開銷較低的讀寫鎖策略

Java內存模型中存在的自然的先行發生關係：

1. 程序次序規則：同一個線程內，按照代碼出現的順序，前面的代碼先行於後面的代碼，準確的說是控制流順序，由於要考慮到分支和循環結構。

2. 管程鎖定規則：一個unlock操做先行發生於後面（時間上）對同一個鎖的lock操做。

3. volatile變量規則：對一個volatile變量的寫操做先行發生於後面（時間上）對這個變量的讀操做。

4. 線程啓動規則：Thread的start( )方法先行發生於這個線程的每個操做。

5. 線程終止規則：線程的全部操做都先行於此線程的終止檢測。能夠經過Thread.join( )方法結束、Thread.isAlive( )的返回值等手段檢測線程的終止。

6. 線程中斷規則：對線程interrupt( )方法的調用先行發生於被中斷線程的代碼檢測到中斷事件的發生，能夠經過Thread.interrupt( )方法檢測線程是否中斷

7. 對象終結規則：一個對象的初始化完成先行於發生它的finalize（）方法的開始。

8. 傳遞性：若是操做A先行於操做B，操做B先行於操做C，那麼操做A先行於操做C。

8.場景題：如今有三個線程，同時start，用什麼方法能夠保證線程執行的順序，線程一執行完線程二執行，線程二執行完線程三執行？

package com.wenjie.threadDemo;

public class JionTest {

public static void main(String[] args) {

final Thread t1 = new Thread(new Runnable() {

@Override

public void run() {

// TODO Auto-generated method stub

System.out.println("t1");

}

});

final Thread t2 = new Thread(new Runnable() {

@Override

public void run() {

// TODO Auto-generated method stub

try {

t1.join();

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println("t2");

}

});

final Thread t3 = new Thread(new Runnable() {

@Override

public void run() {

// TODO Auto-generated method stub

try {

t2.join();

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println("t3");

}

});

t2.start();

t3.start();

t1.start();

}

}

9.你是怎麼理解線程安全的？HashMap是線程安全的麼？若是多個線程同時修改HashMap時會發生什麼狀況？

Failfast

死鎖

異常concurrentmodeex

10.ConcurrentHashMap底層原理？每一個版本的實現上有什麼區別？http://www.cnblogs.com/study-everyday/p/6430462.html#autoid-1-0-0

11.靜態代理和動態代理的區別？動態代理是怎麼實現的？

12.深拷貝和淺拷貝的區別？http://blog.csdn.net/XIAXIA__/article/details/41652057

13.你作過hadoop的項目，爲何要用hadoop？大家處理的文件是什麼格式的？寫了幾個mapper幾個reducer？

Hbase，json

14.zookeeper大家用了幾臺，用來幹什麼的？通常狀況下都是奇數臺，那麼若是一臺掛了，偶數臺如何實現master選舉？zookeeper的兩種啓動模式？http://www.cnblogs.com/raphael5200/category/800894.html

15.TCP首部？TCP爲何是可靠的？三次握手四次揮手？

TCP提供一種面向鏈接的、可靠的字節流服務。

面向鏈接：意味着兩個使用TCP的應用（一般是一個客戶和一個服務器）在彼此交換數據以前必須先創建一個TCP鏈接。在一個TCP鏈接中，僅有兩方進行彼此通訊。廣播和多播不能用於TCP。

TCP經過下列方式來提供可靠性：

一、應用數據被分割成TCP認爲最適合發送的數據塊。這和UDP徹底不一樣，應用程序產生的數據報長度將保持不變。 (將數據截斷爲合理的長度)

二、當TCP發出一個段後，它啓動一個定時器，等待目的端確認收到這個報文段。若是不能及時收到一個確認，將重發這個報文段。

(超時重發)

三、當TCP收到發自TCP鏈接另外一端的數據，它將發送一個確認。這個確認不是當即發送，一般將推遲幾分之一秒 。 (對於收到的請求，給出確認響應) (之因此推遲，多是要對包作完整校驗)

四、TCP將保持它首部和數據的檢驗和。這是一個端到端的檢驗和，目的是檢測數據在傳輸過程當中的任何變化。若是收到段的檢驗和有差錯，TCP將丟棄這個報文段和不確認收到此報文段。 (校驗出包有錯，丟棄報文段，不給出響應，TCP發送數據端，超時時會重發數據)

五、既然TCP報文段做爲IP數據報來傳輸，而IP數據報的到達可能會失序，所以TCP報文段的到達也可能會失序。若是必要，TCP將對收到的數據進行從新排序，將收到的數據以正確的順序交給應用層。 (對失序數據進行從新排序，而後才交給應用層)

六、既然IP數據報會發生重複，TCP的接收端必須丟棄重複的數據。(對於重複數據，可以丟棄重複數據)

七、TCP還能提供流量控制。TCP鏈接的每一方都有固定大小的緩衝空間。TCP的接收端只容許另外一端發送接收端緩衝區所能接納的數據。這將防止較快主機導致較慢主機的緩衝區溢出。(TCP能夠進行流量控制，防止較快主機導致較慢主機的緩衝區溢出)TCP使用的流量控制協議是可變大小的滑動窗口協議。

字節流服務::

兩個應用程序經過TCP鏈接交換8bit字節構成的字節流。TCP不在字節流中插入記錄標識符。咱們將這稱爲字節流服務（bytestreamservice）。

TCP對字節流的內容不做任何解釋:: TCP對字節流的內容不做任何解釋。TCP不知道傳輸的數據字節流是二進制數據，仍是ASCII字符、EBCDIC字符或者其餘類型數據。對字節流的解釋由TCP鏈接雙方的應用層解釋。

17.你平時喜歡作什麼？看過哪些書？最近在看什麼書？（這裏有個段子，我：最近在看《HTTP權威指南》。面試官：什麼？HTTP潛規則？我：？？？）

柯南 東野圭吾

舞蹈 運動電影

二面：(8月2號晚上：視頻面試：47分鐘)

1.你那邊怎麼有點黑啊？（我靠，我也想說啊，暑假寢室集中供電，然而咱們寢室沒有電。發麪經也不忘吐槽學校，簡直坑啊。。。抱着檯燈瑟瑟發抖。。。）

2.如今在哪裏實習？實習主要作些什麼？

3.說一下Java裏面你最感興趣的一個部分？

併發？

4.熟悉Java的哪些框架？用了Spring的哪些東西？Spring如今最新的版本是多少？

5.講一下MVC設計模式，有什麼框架用到了這個模式？spring

6.場景題：一個Controller調用兩個Service，這兩Service又都分別調用兩個Dao，問其中用到了幾個數據庫鏈接池的鏈接？

7.安全方面：如何防止SQL注入？如何防止用戶刪除其餘用戶的信息？表單提交能夠跨域麼？本身寫的接口如何防止被其餘人惡意調用？

貌似瀏覽器也不容許js修改已經存在的header，只能增長自定義header: ajax - Set a request header in JavaScript

防止被惡意調用的話，能夠作請求限制，第一次請求返回一個隨機數，下次請求把隨機數帶過來，返回時再返回一個隨機數

8.zookeeper偶數選舉問題？（感受很重視zookeeper啊）

9.hadoop爲何要將文件分塊而且複製三份，複製兩份不行麼？這樣不浪費空間麼？namenode腦裂問題？zookeeper如何管理全局配置文件？大家的Hadoop項目用到了幾臺機器，每一個機器的做用？

10.Servlet是線程安全的麼？

11.建立一個對象的詳細過程？其中發生了些什麼？

12.Java NIO你瞭解麼？講一講你最熟悉的部分？

13.你在生活中有沒有遇到什麼神奇的事情，能夠分享一下麼？好比灑水車爲何總是在陰天或者快下雨的時候灑水？還有我和我老婆常常吵，陽臺的花是早上澆好呢，仍是晚上澆好呢？（我靠，這是什麼套路）

14.你認爲你身邊的同窗怎麼樣？若是你正在打遊戲，你想讓同窗幫忙帶瓶水，你以爲有多少人會幫你帶？（這又是什麼套路？讓我去送水？）

15.你還有什麼想問的？

三面：（HR面，8月4號下午：視頻面試：22分鐘）

1.7歲一個階段，說一說每個階段對你影響最大的一我的或事？

2.說一下你大學階段作了些什麼？

3.你感受你前兩個面試官怎麼樣？

4.春招的時候爲何沒有去bat實習？

5.你當初準備暑期實習的話，是想學到些什麼？如今感受本身有哪些進步？

6.你還有什麼想問的？（固然是萬能的培養計劃和晉升機制）

四面：（交叉面，8月16號上午：電話面試：30分鐘）

1.自我介紹？
2.說一下最能表明你技術水平的項目吧？

3.maven如何進行依賴管理，如何解決依賴衝突？

http://blog.csdn.net/honghailiang888/article/details/53019635

爲何會出現依賴衝突

首先要說明Maven的依賴管理，具體的能夠參考這邊Maven學習——依賴管理 這篇文章，maven在依賴衝管理中有一下幾個原則。

1. 依賴是使用Maven座標來定位的，而Maven座標主要由GAV（groupId, artifactId, version）構成。若是兩個相同的依賴包，若是groupId, artifactId, version不一樣，那麼maven也認爲這兩個是不一樣的。

2. 依賴會傳遞，A依賴了B，B依賴了C，那麼A的依賴中就會出現B和C。

3. Maven對同一個groupId, artifactId的衝突仲裁，不是以version越大越保留，而是依賴路徑越短越優先，而後進行保留。

4. 依賴的scope會影響依賴的影響範圍。

當出現了依賴的時候如何快速定位衝突緣由

但出現了衝突的時候，好比系統出現了NoSuchMethodError，LinkageError 頗有多是你係統中出現了依賴衝突。出現衝突之後，能夠按如下的步驟執行

1.肯定出了問題的jar包名稱。一般能夠在eclipse中查找衝突的類有在哪些依賴包裏面出現了。並肯定實際要使用的是那個包，衝突的包有哪些。

2.經過mvn dependency:tree  >  tree.txt導出所有的依賴。

3.在導出的依賴文件中，查找問題相關的jar。肯定這些jar是如何被依賴進來的，是直接依賴的仍是經過傳遞依賴引入的。

4.找到相互衝突的並須要排除的依賴的頂級依賴,並分析衝突的緣由，衝突的緣由多是如下幾種：

· 同一個jar包但groupId, artifactId不一樣，這種衝突只能經過設定依賴的<exclusions>來進行排除

· 須要的版本jar包依賴路徑較長，這種衝突能夠把想要版本的依賴直接什麼在依賴中，這樣路徑就最短了優先級最高。

5.最後能夠經過打包mvn install來確認打出來的war包中是否有被排除的依賴。

4.maven的源和插件瞭解哪些？maven的生命週期？

http://blog.csdn.net/limm33/article/details/53142118

5.如何保證分佈式緩存的一致性？分佈式session實現？

6.spring的bean的建立時機？依賴注入的時機？

7.大家的圖片時怎麼存儲的，對應在數據庫中時如何保存圖片的信息的？

http://blog.csdn.net/haluoluo211/article/details/52080325最好是二進制或者項目中，直接保存相對路徑

8.單點登陸系統的實現？

http://www.cnblogs.com/ywlaker/p/6113927.html

9.項目中用到的JDK的哪些特性？

10.java8流式迭代的好處？

http://www.cnblogs.com/shenlanzhizun/p/6027042.html

11.多線程如何在多個CPU上分佈？線程調度算法有哪些？

12.線程調度和進程調度的區別？

13.項目中用到了哪些集合類？

14.說一下TreeMap的實現原理？紅黑樹的性質？紅黑樹遍歷方式有哪些？若是key衝突如何解決？setColor()方法在何時用？何時會進行旋轉和顏色轉換？後者覆蓋前者 保持惟一性

15.你有什麼想問的？

時隔兩年，再一次的面臨離職找工做，這一次換工做有些許的不捨，也有些許的無奈。我的所在的技術團隊不錯，兩年時間成長了不少，也很不捨這個團隊。可是，因爲公司的某些緣由和對於自身將來發展的綜合考慮，又不得不得離去，去尋找更合適的地方成長和發展。相比於兩年前，如今找工做沒有那麼的着急，也沒有那麼的迫切，也沒有特別想去的公司，反正去大廠互聯網公司基本都是加班加點的。也許，這是工做三年的我即將面臨的一個坎吧。對於將來的選擇和考慮，對於將來的恐懼吧。也許我是杞人憂天，也許是上天註定我將去某一家公司，無論怎樣，堅持作最好的本身！不停進步，不停成長！

下面將最近面試遇到的一些題目進行彙總以下，但願對如今正在找工做的同窗和如今面臨畢業找工做的同窗有所幫助。

一、經常使用設計模式

·

單例模式：懶漢式、餓漢式、雙重校驗鎖、靜態加載，內部類加載、枚舉類加載。保證一個類僅有一個實例，並提供一個訪問它的全局訪問點。

·

·

代理模式：動態代理和靜態代理，何時使用動態代理。

·

·

適配器模式：將一個類的接口轉換成客戶但願的另一個接口。適配器模式使得本來因爲接口不兼容而不能一塊兒工做的那些類能夠一塊兒工做。

·

·

裝飾者模式：動態給類加功能。

·

·

觀察者模式：有時被稱做發佈/訂閱模式，觀察者模式定義了一種一對多的依賴關係，讓多個觀察者對象同時監聽某一個主題對象。這個主題對象在狀態發生變化時，會通知全部觀察者對象，使它們可以自動更新本身。

·

·

策略模式：定義一系列的算法,把它們一個個封裝起來,而且使它們可相互替換。

·

·

外觀模式：爲子系統中的一組接口提供一個一致的界面，外觀模式定義了一個高層接口，這個接口使得這一子系統更加容易使用。

·

·

命令模式：將一個請求封裝成一個對象，從而使您能夠用不一樣的請求對客戶進行參數化。

·

·

建立者模式：將一個複雜的構建與其表示相分離，使得一樣的構建過程能夠建立不一樣的表示。

·

·

抽象工廠模式：提供一個建立一系列相關或相互依賴對象的接口，而無需指定它們具體的類。

·

二、基礎知識

·

Java基本類型哪些，所佔字節和範圍

·

·

Set、List、Map的區別和聯繫

·

·

何時使用HashMap

·

·

何時使用LinkedHashMap、ConcurrentHashMap、WeakHashMap

·

·

哪些集合類是線程安全的

·

·

爲何Set、List、Map不實現Cloneable和Serializable接口

·

·

ConcurrentHashMap的實現，1.7和1.8的實現

·

·

Arrays.sort的實現

·

·

何時使用CopyOnArrayList

·

·

volatile的使用

·

·

Synchronied的使用

·

·

ReentrantLock的實現以及和Synchronied的區別

·

·

CAS的實現原理以及問題

·

·

AQS的實現原理

·

·

接口和抽象類的區別，何時使用

·

·

類加載機制的步驟，每一步作了什麼，static和final修改的成員變量的加載時機

·

·

雙親委派模型

·

·

反射機制：反射動態擦除泛型、反射動態調用方法等

·

·

動態綁定：父類引用指向子類對象

·

·

JVM內存管理機制：有哪些區域，每一個區域作了什麼

·

·

JVM垃圾回收機制：垃圾回收算法 垃圾回收器 垃圾回收策略

·

·

jvm參數的設置和jvm調優

·

·

什麼狀況產生年輕代內存溢出、什麼狀況產生年老代內存溢出

·

·

內部類：靜態內部類和匿名內部類的使用和區別

·

·

redis和memcached：何時選擇redis，何時選擇memcached，內存模型和存儲策略是什麼樣的

·

·

MySQL的基本操做主從數據庫一致性維護

·

·

mysql的優化策略有哪些

·

·

mysql索引的實現B+樹的實現原理

·

·

什麼狀況索引不會命中，會形成全表掃描

·

·

java中bio nio aio的區別和聯繫

·

·

爲何bio是阻塞的nio是非阻塞的nio的模型是什麼樣的

·

·

java io的總體架構和使用的設計模式

·

·

Reactor模型和Proactor模型

·

·

http請求報文結構和內容

·

·

http三次握手和四次揮手

·

·

rpc相關：如何設計一個rpc框架，從io模型 傳輸協議 序列化方式綜合考慮

·

·

linux命令 統計，排序，前幾問題等

·

·

StringBuff和StringBuilder的實現，底層實現是經過byte數據，外加數組的拷貝來實現的

·

·

cas操做的使用

·

·

內存緩存和數據庫的一致性同步實現

·

·

微服務的優缺點

·

·

線程池的參數問題

·

·

ip問題 如何判斷ip是否在多個ip段中

·

·

判斷數組兩個中任意兩個數之和是否爲給定的值

·

·

樂觀鎖和悲觀鎖的實現

·

·

synchronized實現原理

·

·

你在項目中遇到的困難和怎麼解決的

·

·

你在項目中完成的比較出色的亮點

·

·

消息隊列廣播模式和發佈/訂閱模式的區別

·

·

生產者消費者代碼實現

·

·

死鎖代碼實現

·

·

線程池：參數，每一個參數的做用，幾種不一樣線程池的比較，阻塞隊列的使用，拒絕策略

·

·

Future和ListenableFuture異步回調相關

·

·

算法相關：判斷可否從數組中找出兩個數字和爲給定值，隨機生成1~10000不重複並放入數組，求數組的子數組的最大和，二分查找算法的實現及其時間複雜計算

·

三、其它

·

算法：經常使用排序算法，二分查找，鏈表相關，數組相關，字符串相關，樹相關等

·

·

常見序列化協議及其優缺點

·

·

memcached內存原理，爲何是基於塊的存儲

·

·

搭建一個rpc須要準備什麼

·

·

若是線上服務器頻繁地出現full gc，如何去排查

·

·

若是某一時刻線上機器忽然量變得很大，服務扛不住了，怎麼解決

·

·

LRU算法的實現

·

·

LinkedHashMap實現LRU

·

·

定義棧的數據結構，請在該類型中實現一個可以找到棧最小元素的min函數

·

·

海量數據處理的解決思路

·

·

reactor模型的演變

·

·

阻塞、非阻塞、同步、異步區別

·

·

Collection的子接口

·

·

jvm調優相關

·

·

zookeeper相關，節點類型，如何實現服務發現和服務註冊

·

·

nginx負載均衡相關，讓你去實現負載均衡，該怎麼實現

·

·

linux命令，awk、cat、sort、cut、grep、uniq、wc、top等

·

·

壓力測試相關，怎麼分析，單接口壓測和多狀況下的壓測

·

·

你以爲你的優勢是什麼，你的缺點是什麼，爲何咱們要錄用你

·

·

Spring mvc的實現原理

·

·

netty底層實現，IO模型，ChannelPipeline的實現和原理

·

·

緩存的設計和優化

·

·

緩存和數據庫一致性同步解決方案

·

·

你所在項目的系統架構，談談總體實現

·

·

消息隊列的使用場景

·

·

ActiveMQ、RabbitMQ、Kafka的區別

·

·

JVM內存分配策略和垃圾回收時機

·

·

JVM垃圾回收策略和對象的實際生命週期

·

·

對象是如何在堆中分配的

·

·

full gc觸發的場景，線上若是一直full gc怎麼排查

·

·

如何防止接口被惡意攻擊

·

·

線上某一臺服務器出現問題，如何實際操做去解決

·

·

線上接口最大的QPS以及如何評估服務器可承受的最大請求數

·

·

內存緩存的使用場景和優缺點

·

·

怎麼防止線上接口被惡意刷

·

·

怎麼防止線上接口被攻擊

·

·

棧幀的結構

·

·

transient關鍵字的使用

·

以上內容爲近期的面試總結。後續若有新的內容，會持續更新。

hashMap能夠key爲空或者value爲空嗎？能夠同時爲空嗎？

HashSet有什麼特色？

話題二：

HashMap底層是怎麼實現的？

1.6：數組+鏈表

1.8：數組+鏈表/紅黑樹

爲何要二次hash？談談擴容|何時擴容？

HashMap與Hashtable有什麼區別嗎？

Hashtable加同步鎖有什麼問題？能不能有更好的實現方式？

ConcurrentHashMap底層怎麼實現的？怎麼保證同步的（CAS）？

話題三：

若是前面的，你都答出來了？

什麼是CAS？它synchronized有什麼區別？

談談synchronized？

能談一下volatile嗎？

六、JVM連環炮+併發編程？

話題一：

一、談談內存區域？

堆、棧、方法區、（程序計算器、本地方法棧 ）|能夠不談

二、堆、棧、方法區分別有什麼用？存儲什麼內容？

三、能談談堆嗎？

新生代、老年代

四、怎麼判斷對象不可用？

五、能談一下GC策略嗎？它是怎麼回收不可用對象的？

標記-清除，複製、標記-整理、分代。

六、能談一下垃圾回收器嗎?(暫無遇見問的)

七、對象怎麼分配的？

話題二：

一、談一下類加載過程？

二、談一下雙親委派機制？

話題三：

一、談一下Java內存模型

二、談一下Synchronized、volatile？

二、談一下AQS、CountDownLatch、ReentrantLock？（暫時尚未人問）

三、談一下ThreadLocal？

四、談一下CAS？

五、談一下線程池原理？

2、設計模式

一、談一下六種設計原則？開閉原則什麼意思？里氏XX是什麼意思？

二、寫一個單例模式？後續本身擴展各類的優缺點？

三、談一個你熟悉的設計模式？

3、緩存

一、設計一個高效的緩存？

http://www.cnblogs.com/xiaopohou/archive/2011/08/31/2160437.html

二、談談LRU算法？（解決高效的緩存）

3、架構思想、高併發、大數據量解決方案。

一、一個很大的日記文件，統計出訪問排行？

二、mapreduce思想？談談shuffle？

一、unordered_map的實現原理。。很具體的描述

二、單鏈表多路歸併排序

三、LRU cache的實現，插入、查找、刪除時間複雜度不能超過O(1)

有一個場景，如今cache滿了，須要淘汰頻率最低的那個

更新：0824華爲

關於HTTP請求GET和POST的區別

1.GET提交，請求的數據會附在URL以後（就是把數據放置在HTTP協議頭＜request-line＞中），以?分割URL和傳輸數據，多個參數用&鏈接;例如：login.action?name=hyddd&password=idontknow&verify=%E4%BD%A0 %E5%A5%BD。若是數據是英文字母/數字，原樣發送，若是是空格，轉換爲+，若是是中文/其餘字符，則直接把字符串用BASE64加密，得出如：%E4%BD%A0%E5%A5%BD，其中％XX中的XX爲該符號以16進製表示的ASCII。

POST提交：把提交的數據放置在是HTTP包的包體＜request-body＞中。上文示例中紅色字體標明的就是實際的傳輸數據

所以，GET提交的數據會在地址欄中顯示出來，而POST提交，地址欄不會改變

2.傳輸數據的大小：

首先聲明,HTTP協議沒有對傳輸的數據大小進行限制，HTTP協議規範也沒有對URL長度進行限制。而在實際開發中存在的限制主要有：

GET:特定瀏覽器和服務器對URL長度有限制，例如IE對URL長度的限制是2083字節(2K+35)。對於其餘瀏覽器，如Netscape、FireFox等，理論上沒有長度限制，其限制取決於操做系統的支持。

所以對於GET提交時，傳輸數據就會受到URL長度的限制。

POST:因爲不是經過URL傳值，理論上數據不受限。但實際各個WEB服務器會規定對post提交數據大小進行限制，Apache、IIS6都有各自的配置。

3.安全性：

POST的安全性要比GET的安全性高。注意：這裏所說的安全性和上面GET提到的「安全」不是同個概念。上面「安全」的含義僅僅是不做數據修改，而這裏安全的含義是真正的Security的含義，好比：經過GET提交數據，用戶名和密碼將明文出如今URL上，由於(1)登陸頁面有可能被瀏覽器緩存，(2)其餘人查看瀏覽器的歷史紀錄，那麼別人就能夠拿到你的帳號和密碼了，

Http協議：一個HTTP請求報文由請求行（request line）、請求頭部（header）、空行和請求數據4個部分組成，下圖給出了請求報文的通常格式。

請求行由請求方法字段、URL字段和HTTP協議版本字段3個字段組成，它們用空格分隔。例如，GET /index.html HTTP/1.1。

請求頭部由關鍵字/值對組成，每行一對，關鍵字和值用英文冒號「:」分隔。請求頭部通知服務器有關於客戶端請求的信息，典型的請求頭有：

User-Agent：產生請求的瀏覽器類型。

Accept：客戶端可識別的內容類型列表。

Host：請求的主機名，容許多個域名同處一個IP地址，即虛擬主機。

HTTP響應也由三個部分組成，分別是：狀態行、消息報頭、響應正文。

HTTP：是互聯網上應用最爲普遍的一種網絡協議，是一個客戶端和服務器端請求和應答的標準（TCP），用於從WWW服務器傳輸超文本到本地瀏覽器的傳輸協議，它能夠使瀏覽器更加高效，使網絡傳輸減小。

HTTPS：是以安全爲目標的HTTP通道，簡單講是HTTP的安全版，即HTTP下加入SSL層，HTTPS的安全基礎是SSL，所以加密的詳細內容就須要SSL。

HTTPS協議的主要做用能夠分爲兩種：一種是創建一個信息安全通道，來保證數據傳輸的安全；另外一種就是確認網站的真實性。

HTTPS和HTTP的區別主要以下：

一、https協議須要到ca申請證書，通常免費證書較少，於是須要必定費用。

二、http是超文本傳輸協議，信息是明文傳輸，https則是具備安全性的ssl加密傳輸協議。

三、http和https使用的是徹底不一樣的鏈接方式，用的端口也不同，前者是80，後者是443。

四、http的鏈接很簡單，是無狀態的；HTTPS協議是由SSL+HTTP協議構建的可進行加密傳輸、身份認證的網絡協議，比http協議安全。

對稱密碼加解密，非對稱密碼加解密。

事務隔離級別和實現方式。

反射：固化框架層的，業務層實際上用不太到。JAVA反射機制是在運行狀態中，對於任意一個類，都可以知道這個類的全部屬性和方法；對於任意一個對象，都可以調用它的任意一個方法和屬性；這種動態獲取的信息以及動態調用對象的方法的功能稱爲java語言的反射機制。

遇到問題：分佈式加鎖問題：

memcached分佈式鎖:一、實現原理：

memcached帶有add函數，利用add函數的特性便可實現分佈式鎖。add和set的區別在於：若是多線程併發set，則每一個set都會成功，但最後存儲的值以最後的set的線程爲準。而add的話則相反，add會添加第一個到達的值，並返回true，後續的添加則都會返回false。利用該點便可很輕鬆地實現分佈式鎖。

二、優勢

併發高效。

三、缺點

效率對庫依賴比較重，重量級

（1）memcached採用列入LRU置換策略，因此若是內存不夠，可能致使緩存中的鎖信息丟失。

（2）memcached沒法持久化，一旦重啓，將致使信息丟失。

Redis：redis分佈式鎖便可以結合zk分佈式鎖鎖高度安全和memcached併發場景下效率很好的優勢，能夠利用jedis客戶端實現。

URL到頁面相應的全過程：

瀏覽器緩存etc緩存 路由緩存 服務提供商緩存 遞歸到根dns,請求鏈接TCP。發送報文，恢復

Spring AOP開發用到了那些部分？

==通常只用到了基本數據類型比較

一、equals方法用於比較對象的內容是否相等（覆蓋之後）

二、hashcode方法只有在集合中用到

三、當覆蓋了equals方法時，比較對象是否相等將經過覆蓋後的equals方法進行比較（判斷對象的內容是否相等）。

四、將對象放入到集合中時，首先判斷要放入對象的hashcode值與集合中的任意一個元素的hashcode值是否相等，若是不相等直接將該對象放入集合中。若是hashcode值相等，而後再經過equals方法判斷要放入對象與集合中的任意一個對象是否相等，若是equals判斷不相等，直接將該元素放入到集合中，不然不放入。

做者：Xoper.ducky
連接：https://www.nowcoder.com/discuss/3043
來源：牛客網

J2SE基礎

1. 九種基本數據類型的大小，以及他們的封裝類。

基本類型	大小(字節)	默認值	封裝類
byte	1	(byte)0	Byte
short	2	(short)0	Short
int	4	0	Integer
long	8	0L	Long
float	4	0.0f	Float
double	8	0.0d	Double
boolean	-	false	Boolean
char	2	\u0000(null)	Character
void	-	-	Void

2. Switch可否用string作參數？

3. equals與==的區別。

4. Object有哪些公用方法？

Wait notify notifyall clone equels getclass

5. Java的四種引用，強弱軟虛，用到的場景。

6. Hashcode的做用。

7. ArrayList、LinkedList、Vector的區別。

8. String、StringBuffer與StringBuilder的區別。

9. Map、Set、List、Queue、Stack的特色與用法。

10. HashMap和HashTable的區別。

11. HashMap和ConcurrentHashMap的區別，HashMap的底層源碼。

12. TreeMap、HashMap、LindedHashMap的區別。

13. Collection包結構，與Collections的區別。

14. try catch finally，try裏有return，finally還執行麼？

15. Excption與Error包結構。OOM你遇到過哪些狀況，SOF你遇到過哪些狀況。

16. Java面向對象的三個特徵與含義。

17. Override和Overload的含義去區別。

18. Interface與abstract類的區別。

19. Static class 與non static class的區別。

20. java多態的實現原理。

同一操做不一樣結果，前期綁定後期綁定

21.實現多線程的兩種方法：Thread與Runable。Call

22.線程同步的方法：sychronized、lock、reentrantLock等。

23.鎖的等級：方法鎖、對象鎖、類鎖。

24.寫出生產者消費者模式。

25. ThreadLocal的設計理念與做用。Thread ThreadLocal->ThreadLocalMap

26. ThreadPool用法與優點。

27. Concurrent包裏的其餘東西：ArrayBlockingQueue、CountDownLatch等等。

28. wait()和sleep()的區別。

29. foreach與正常for循環效率對比。

30. Java IO與NIO。

31.反射的做用於原理。

32.泛型經常使用特色，List<String>可否轉爲List<Object>。

33.解析XML的幾種方式的原理與特色：DOM、SAX、PULL。

34. Java與C++對比。

35. Java1.7與1.8新特性。

36.設計模式：單例、工廠、適配器、責任鏈、觀察者等等。

37. JNI的使用。

Java裏有不少很雜的東西，有時候須要你閱讀源碼，大多數可能書裏面講的不是太清楚，須要你在網上尋找答案。

推薦書籍：《java核心技術卷I》《Thinking in java》《java併發編程》《effictive java》《大話設計模式》

JVM

1.內存模型以及分區，須要詳細到每一個區放什麼。

2.堆裏面的分區：Eden，survival from to，老年代，各自的特色。

3.對象建立方法，對象的內存分配，對象的訪問定位。

4. GC的兩種斷定方法：引用計數與引用鏈。

5. GC的三種收集方法：標記清除、標記整理、複製算法的原理與特色，分別用在什麼地方，若是讓你優化收集方法，有什麼思路？

6. GC收集器有哪些？CMS收集器與G1收集器的特色。

7. Minor GC與Full GC分別在何時發生？

8.幾種經常使用的內存調試工具：jmap、jstack、jconsole。

9.類加載的五個過程：加載、驗證、準備、解析、初始化。

10.雙親委派模型：Bootstrap ClassLoader、Extension ClassLoader、ApplicationClassLoader。

11.分派：靜態分派與動態分派。

JVM過去過來就問了這麼些問題，沒怎麼變，內存模型和GC算法這塊問得比較多，能夠在網上多找幾篇博客來看看。

推薦書籍：《深刻理解java虛擬機》

操做系統

1.進程和線程的區別。

2.死鎖的必要條件，怎麼處理死鎖。

3. Window內存管理方式：段存儲，頁存儲，段頁存儲。

4.進程的幾種狀態。

5. IPC幾種通訊方式。

6.什麼是虛擬內存。

7.虛擬地址、邏輯地址、線性地址、物理地址的區別。

由於是作android的這一塊問得比較少一點，還有可能上我簡歷上沒有寫操做系統的緣由。

推薦書籍：《深刻理解現代操做系統》

TCP/IP

1. OSI與TCP/IP各層的結構與功能，都有哪些協議。

2. TCP與UDP的區別。

3. TCP報文結構。

4. TCP的三次握手與四次揮手過程，各個狀態名稱與含義，TIMEWAIT的做用。

5. TCP擁塞控制。

6. TCP滑動窗口與回退N針協議。

7. Http的報文結構。

8. Http的狀態碼含義。

9. Http request的幾種類型。

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

11. Http怎麼處理長鏈接。

12. Cookie與Session的做用於原理。

13.電腦上訪問一個網頁，整個過程是怎麼樣的：DNS、HTTP、TCP、OSPF、IP、ARP。

14. Ping的整個過程。ICMP報文是什麼。

15. C/S模式下使用socket通訊，幾個關鍵函數。

16. IP地址分類。

17.路由器與交換機區別。

網絡其實大致分爲兩塊，一個TCP協議，一個HTTP協議，只要把這兩塊以及相關協議搞清楚，通常問題不大。

推薦書籍：《TCP/IP協議族》

數據結構與算法

1.鏈表與數組。

2.隊列和棧，出棧與入棧。

3.鏈表的刪除、插入、反向。

4.字符串操做。

5. Hash表的hash函數，衝突解決方法有哪些。

6.各類排序：冒泡、選擇、插入、希爾、歸併、快排、堆排、桶排、基數的原理、平均時間複雜度、最壞時間複雜度、空間複雜度、是否穩定。

7.快排的partition函數與歸併的Merge函數。

8.對冒泡與快排的改進。

9.二分查找，與變種二分查找。

10.二叉樹、B+樹、AVL樹、紅黑樹、哈夫曼樹。

11.二叉樹的前中後續遍歷：遞歸與非遞歸寫法，層序遍歷算法。

12.圖的BFS與DFS算法，最小生成樹prim算法與最短路徑Dijkstra算法。

13. KMP算法。

14.排列組合問題。

15.動態規劃、貪心算法、分治算法。（通常不會問到）

16.大數據處理：相似10億條數據找出最大的1000個數.........等等

算法的話實際上是個重點，由於最後都是要你寫代碼，因此算法仍是須要花很多時間準備，這裏有太多算法題，寫不全，個人建議是沒事多在OJ上刷刷題（牛客網、leetcode等），劍指offer上的算法要能理解並本身寫出來，編程之美也推薦看一看。

推薦書籍：《大話數據結構》《劍指offer》《編程之美》

如下是我常問的幾個問題，若是須要能夠參考：

1.貴公司一貫以XXX著稱，能不能說明一下公司這方面的特色？

2.貴公司XXX業務發展很好，這是公司發展的重點麼？

3.對技術和業務怎麼看？

4.貴公司通常的團隊是多大，幾我的負責一個產品或者業務？

5.貴公司的開發中是否會使用到一些最新技術？

6.對新人有沒有什麼培訓，會不會安排導師？

7.對Full Stack怎麼看？

8.你以爲我有哪些須要提升的地方？

網易小袁兵總結：

1 java concurrent包下有哪些類，瞭解哪些鎖
2 hashmap和concurrenthashmap有什麼區別？各自的機制是什麼樣的？hashmap如何解決鏈表過長？紅黑樹有哪些特性？

·      * 每一個結點要麼是「紅色」，要麼是「黑色」(後面將說明)

·      * 全部的葉結點都是空結點，而且是「黑色」的

·      * 若是一個結點是「紅色」的，那麼它的兩個子結點都是「黑色」的

·      * (注:也就是說，若是結點是黑色的，那麼它的子節點能夠是紅色或者是黑色的)。

·      * 結點到其子孫結點的每條簡單路徑都包含相同數目的「黑色」結點

·      * 根結點永遠是「黑色」的

紅黑樹可以以O(log2 n)的時間複雜度進行搜索、插入、刪除操做。此外，因爲它的設計，任何不平衡都會在三次旋轉以內解決。

·  之因此稱爲紅黑樹的緣由就在於它的每一個結點都被「着色」爲紅色或黑色。這些結點顏色被用來檢測樹的平衡性。但須要注意的是，紅黑樹並非平衡二叉樹，偏偏相反，紅黑樹放鬆了平衡二叉樹的某些要求，因爲必定限度的「不平衡」，紅黑樹的性能獲得了提高。

·

·  從根結點到葉結點的黑色結點數被稱爲樹的「黑色高度」(black-height)。前面關於紅黑樹的性質保證了從根結點到葉結點的路徑長度不會超過任何其餘路徑的兩倍。

對於給定的黑色高度爲n的紅黑樹，從根到葉結點的簡單路徑的最短長度爲n-1，最大長度爲2(n-1)。

3 怎麼樣實現公平鎖？實現機制？

同步隊列啊有頭信息得到鎖以前看是否有前驅節點沒有得到鎖。
4 java引用類型有哪些？各有什麼特色？

StrongReference

就能夠他的名字同樣，任什麼時候候GC是不能回收他的，哪怕內存不足時，系統會直接拋出異常OutOfMemoryError，也不會去回收，首先要說明的是java中默認就是強引用，

SoftReference

軟引用他的特色是當內存足夠時不會回收這種引用類型的對象，只有當內存不夠用時纔會回收，這種特色很適合最一些緩存。

SoftReference<Person> personSoftReference = new SoftReference<>(jack);

WeakReference

虛引用的特色是隻要GC一運行就會把給回收了，我的感受沒多大用處，由於只要GC一運行他就會被回收了。

WeakReference<Person> personSoftReference = new WeakReference<Person>(jack);

5 遇過哪些內存泄漏的問題？什麼緣由？

指因爲疏忽或錯誤形成程序未能釋放已經再也不使用的內存的狀況。內存泄漏並不是指內存在物理上的消失，而是應用程序分配某段內存後，因爲設計錯誤，失去了對該段內存的控制，於是形成了內存的浪費。就算數據失效了，可是就是不能夠gc.

內存泄露是指無用對象（再也不使用的對象）持續佔有內存或無用對象的內存得不到及時釋放，從而形成的內存空間的浪費稱爲內存泄露。

一、靜態集合類引發內存泄露：
像HashMap、Vector等的使用最容易出現內存泄露，這些靜態變量的生命週期和應用程序一致，他們所引用的全部的對象Object也不能被釋放，由於他們也將一直被Vector等引用着。
例:
Static Vector v = new Vector(10);
for (int i = 1; i<100; i++)
{
Object o = new Object();
v.add(o);
o = null;
}//
在這個例子中，循環申請Object對象，並將所申請的對象放入一個Vector中，若是僅僅釋放引用自己（o=null），那麼Vector仍然引用該對象，因此這個對象對GC來講是不可回收的。所以，若是對象加入到Vector後，還必須從Vector中刪除，最簡單的方法就是將Vector對象設置爲null。

二、當集合裏面的對象屬性被修改後，再調用remove（）方法時不起做用。

例：
public static void main(String[] args)
{
Set<Person> set = new HashSet<Person>();
Person p1 = new Person("唐僧","pwd1",25);
Person p2 = new Person("孫悟空","pwd2",26);
Person p3 = new Person("豬八戒","pwd3",27);
set.add(p1);
set.add(p2);
set.add(p3);
System.out.println("總共有:"+set.size()+" 個元素!"); //結果：總共有:3 個元素!
p3.setAge(2); //修改p3的年齡,此時p3元素對應的hashcode值發生改變

set.remove(p3); //此時remove不掉，形成內存泄漏

set.add(p3); //從新添加，竟然添加成功
System.out.println("總共有:"+set.size()+"個元素!"); //結果：總共有:4個元素!
for (Person person : set)
{
System.out.println(person);
}
}

三、監聽器
在java編程中，咱們都須要和監聽器打交道，一般一個應用當中會用到不少監聽器，咱們會調用一個控件的諸如addXXXListener()等方法來增長監聽器，但每每在釋放對象的時候卻沒有記住去刪除這些監聽器，從而增長了內存泄漏的機會。

四、各類鏈接
好比數據庫鏈接（dataSourse.getConnection()），網絡鏈接(socket)和io鏈接，除非其顯式的調用了其close（）方法將其鏈接關閉，不然是不會自動被GC回收的。對於Resultset和Statement對象能夠不進行顯式回收，但Connection必定要顯式回收，由於Connection在任什麼時候候都沒法自動回收，而Connection一旦回收，Resultset和Statement對象就會當即爲NULL。可是若是使用鏈接池，狀況就不同了，除了要顯式地關閉鏈接，還必須顯式地關閉Resultset Statement對象（關閉其中一個，另一個也會關閉），不然就會形成大量的Statement對象沒法釋放，從而引發內存泄漏。這種狀況下通常都會在try裏面去的鏈接，在finally裏面釋放鏈接。

五、內部類和外部模塊等的引用
內部類的引用是比較容易遺忘的一種，並且一旦沒釋放可能致使一系列的後繼類對象沒有釋放。此外程序員還要當心外部模塊不經意的引用，例如程序員A負責A模塊，調用了B模塊的一個方法如：
public void registerMsg(Object b);
這種調用就要很是當心了，傳入了一個對象，極可能模塊B就保持了對該對象的引用，這時候就須要注意模塊B是否提供相應的操做去除引用。

六、單例模式
不正確使用單例模式是引發內存泄露的一個常見問題，單例對象在被初始化後將在JVM的整個生命週期中存在（以靜態變量的方式），若是單例對象持有外部對象的引用，那麼這個外部對象將不能被jvm正常回收，致使內存泄露，考慮下面的例子：
class A{
public A(){
B.getInstance().setA(this);
}
....
}
//B類採用單例模式
class B{
private A a;
private static B instance=new B();
public B(){}
public static B getInstance(){
return instance;
}
public void setA(A a){
this.a=a;
}
//getter...
}
顯然B採用singleton模式，它持有一個A對象的引用，而這個A類的對象將不能被回收。想象下若是A是個比較複雜的對象或者集合類型會發生什麼狀況

6 怎麼樣實現list的線程安全？

Copyandwritearraylist concurrent...Vector
7 怎麼樣實現一個緩存中的LRU算法？

yes
8 listhashmap的原理

Java LinkedHashMap工做原理及實現

2016/03/22 |分類：基礎技術 | 0條評論 |標籤：LinkedHashMap

分享到：11

原文出處：Yikun

1. 概述

在理解了#7介紹的HashMap後，咱們來學習LinkedHashMap的工做原理及實現。首先仍是相似的，咱們寫一個簡單的LinkedHashMap的程序：

1 2 3 4 5 6 7 8 9 10 11 12

LinkedHashMap<String, Integer> lmap = new LinkedHashMap<String, Integer>(); lmap.put("語文", 1); lmap.put("數學", 2); lmap.put("英語", 3); lmap.put("歷史", 4); lmap.put("政治", 5); lmap.put("地理", 6); lmap.put("生物", 7); lmap.put("化學", 8); for(Entry<String, Integer> entry : lmap.entrySet()) { System.out.println(entry.getKey() + ": " + entry.getValue()); }

運行結果是：

1 2 3 4 5 6 7 8

語文: 1 數學: 2 英語: 3 歷史: 4 政治: 5 地理: 6 生物: 7 化學: 8

咱們能夠觀察到，和HashMap的運行結果不一樣，LinkedHashMap的迭代輸出的結果保持了插入順序。是什麼樣的結構使得LinkedHashMap具備如此特性呢？咱們仍是同樣的看看LinkedHashMap的內部結構，對它有一個感性的認識：

沒錯，正如官方文檔所說：

Hash table and linked list implementation of the Map interface, with predictable iteration order. This implementation differs from HashMap in that it maintains a doubly-linked listrunning through all of its entries. This linked list defines the iteration ordering, which is normally the order in which keys were inserted into the map (insertion-order).

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

2. 三個重點實現的函數

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

1 2 3 4

// Callbacks to allow LinkedHashMap post-actions void afterNodeAccess(Node<K,V> p) { } void afterNodeInsertion(boolean evict) { } void afterNodeRemoval(Node<K,V> p) { }

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

afterNodeAccess函數

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

void afterNodeAccess(Node<K,V> e) { // move node to last LinkedHashMap.Entry<K,V> last; // 若是定義了accessOrder，那麼就保證最近訪問節點放到最後 if (accessOrder && (last = tail) != e) { LinkedHashMap.Entry<K,V> p = (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after; p.after = null; if (b == null) head = a; else b.after = a; if (a != null) a.before = b; else last = b; if (last == null) head = p; else { p.before = last; last.after = p; } tail = p; ++modCount; } }

就是說在進行put以後就算是對節點的訪問了，那麼這個時候就會更新鏈表，把最近訪問的放到最後，保證鏈表。

afterNodeInsertion函數

1 2 3 4 5 6 7 8

void afterNodeInsertion(boolean evict) { // possibly remove eldest LinkedHashMap.Entry<K,V> first; // 若是定義了移除規則，則執行相應的溢出 if (evict && (first = head) != null && removeEldestEntry(first)) { K key = first.key; removeNode(hash(key), key, null, false, true); } }

若是用戶定義了removeEldestEntry的規則，那麼即可以執行相應的移除操做。

afterNodeRemoval函數

1 2 3 4 5 6 7 8 9 10 11 12 13 14

void afterNodeRemoval(Node<K,V> e) { // unlink // 從鏈表中移除節點 LinkedHashMap.Entry<K,V> p = (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after; p.before = p.after = null; if (b == null) head = a; else b.after = a; if (a == null) tail = b; else a.before = b; }

這個函數是在移除節點後調用的，就是將節點從雙向鏈表中刪除。

咱們從上面3個函數看出來，基本上都是爲了保證雙向鏈表中的節點次序或者雙向鏈表容量所作的一些額外的事情，目的就是保持雙向鏈表中節點的順序要從eldest到youngest。

9 手寫一個算法，隨便一個整數num，一個表明進制的整數k（小於10），實現num的k進制轉換
10 實現一個算法，數據庫有一個按順序排列的歌單，用戶在前臺修改了順序，現要把數據庫的歌單修改爲一樣的順序，問怎麼樣操做最少.
11 實現一個算法，一個文檔有若干單詞（內存放不下），現要求出10個頻度最高的單詞
12 jvm中適合高吞吐量的垃圾回收器

http://blog.csdn.net/lghuntfor/article/details/51052737

(1)特色:
–同ParNew回收器同樣， 不一樣的地方在於，它很是關注系統的吞吐量(經過參數控制)
–使用複製算法
–支持自適應的GC調節策略

(3)設置參數:

-XX:+UseParallelGC新生代用ParallelGC回收器, 老年代使用串行回收器
-XX:+UseParallelOldGC新生代用ParallelGC回收器, 老年代使用ParallelOldGC回收器系統吞吐量的控制:
-XX:MaxGCPauseMillis=n(單位ms) 設置垃圾回收的最大停頓時間,
-XX:GCTimeRatio=n(n在0-100之間)　　設置吞吐量的大小, 假設值爲n, 那系統將花費不超過1/(n+1)的時間用於垃圾回收
-XX:+UseAdaptiveSizePolicy打開自適應GC策略, 在這種模式下, 新生代的大小, eden,survivior的比例, 晉升老年代的對象年齡等參數會被自動調整,以達到堆大小, 吞吐量, 停頓時間之間的平衡點

13 cms垃圾回收器的特色
14 有幾種垃圾回收算法
15 計算機網絡osi模型
16 tcp如何實現擁塞控制和流量控制？具體算法是什麼？

http://blog.csdn.net/honour2sword/article/details/45191115

http://blog.csdn.net/yechaodechuntian/article/details/25429143

17 http頭部格式

HTTP請求消息頭部實例：

Host：rss.sina.com.cn

User-Agent：Mozilla/五、0 (Windows; U; Windows NT 五、1; zh-CN; rv:一、八、一、14) Gecko/20080404 Firefox/二、0、0、14

Accept：text/xml,application/xml,application/xhtml+xml,text/html;q=0、9,text/plain;q=0、8,image/png,*/*;q=0、5

Accept-Language：zh-cn,zh;q=0、5

Accept-Encoding：gzip,deflate

Accept-Charset：gb2312,utf-8;q=0、7,*;q=0、7

Keep-Alive：300

Connection：keep-alive

Cookie：userId=C5bYpXrimdmsiQmsBPnE1Vn8ZQmdWSm3WRlEB3vRwTnRtW <-- Cookie

If-Modified-Since：Sun, 01 Jun 2008 12:05:30 GMT

Cache-Control：max-age=0

HTTP響應消息頭部實例：

Status：OK - 200 <--響應狀態碼，表示web服務器處理的結果。

Date：Sun, 01 Jun 2008 12:35:47 GMT

Server：Apache/二、0、61 (Unix)

Last-Modified：Sun, 01 Jun 2008 12:35:30 GMT

Accept-Ranges：bytes

Content-Length：18616

Cache-Control：max-age=120

Expires：Sun, 01 Jun 2008 12:37:47 GMT

Content-Type：application/xml

Age：2

X-Cache：HIT from 236-4一、D0707195一、sina、com、cn <--反向代理服務器使用的HTTP頭部

Via：1.0 236-41.D07071951.sina.com.cn:80 (squid/2.6.STABLE13)

Connection：close
18 實現一個用戶登陸功能，在不使用https的狀況下完成安全傳輸

19 有哪些非對稱加密算法

RSA, EI Gamal, ECC, Knapsack, etc.
RSA是企業級應用標準，不少第三方的加密軟件使用RSA 2048bit加密。
ECC更高效，164bitECC約等於1024bit的RSA，常用在移動設備上。

20 linux瞭解嗎？
21 class字節碼文件格式是什麼？

ClassFile中的字段簡單說明以下：

一、MagicNumber：MagicNumber是用來標誌class文件的，虛擬機加載class文件的時候會先檢查這四個字節，若是不是cafe babe則虛擬機拒絕加載該文件，這樣就能夠防止加載非class文件而浪費系統資源。這個字段的長度是4個字節，值是固定的cafebabe。

二、Version：version字段有2個長度都爲2字節的字段組成，分別是Major Version和Minor Version，分別表明當前class文件的主版本號和次版本號。隨着Java技術的不斷髮展，Java class文件格式會增長一些新的內容來支持Java語言的新特性。同時，不一樣的虛擬機支持的Java class文件的版本範圍是不一樣的，因此在加載class文件以前能夠先看看該class文件是否在當前虛擬機的支持範圍以內，避免加載不支持的class文件。

三、常量池

首先是2個字節的長度字段constant_pool_count，代表常量池包含了多少個常量。

後面跟着就是constant_pool_count個常量，常量池裏放的是字面常量和符號引用。

字面常量主要包含文本串以及被聲明爲final的常量等；符號引用包含類和接口的全侷限定名，字段的名稱和描述符，方法的名稱和描述符，由於java語言在編譯的時候沒有鏈接這一步，全部的引用都是運行時動態加載的，因此就須要把這些引用的信息保存在class文件裏。

這裏的常量又根據具體的類型分紅字符串，整形，長整型，浮點型，雙精度浮點型這幾種基本類型。

而符號引用保存的是對應的引用的全侷限定名，因此保存的是字符串。

四、access_flag 保存了當前類的訪問權限

五、this_cass  保存了當前類的全侷限定名在常量池裏的索引

六、super class 保存了當前類的父類的全侷限定名在常量池裏的索引

七、interfaces 保存了當前類實現的接口列表，包含兩部份內容：interfaces_count 和interfaces[interfaces_count]

interfaces_count 指的是當前類實現的接口數目

interfaces[] 是包含interfaces_count個接口的全侷限定名的索引的數組

八、fields 保存了當前類的成員列表，包含兩部分的內容：fields_count 和 fields[fields_count]

fields_count是類變量和實例變量的字段的數量總和。

fileds[]是包含字段詳細信息的列表。

九、methods 保存了當前類的方法列表，包含兩部分的內容：methods_count和methods[methods_count]

methods_count是該類或者接口顯示定義的方法的數量。

method[]是包含方法信息的一個詳細列表。

十、attributes 包含了當前類的attributes列表，包含兩部份內容：attributes_count 和 attributes[attributes_count]

class文件的最後一部分是屬性，它描述了該類或者接口所定義的一些屬性信息。attributes_count指的是attributes列表中包含的attribute_info的數量。

屬性能夠出如今class文件的不少地方，而不僅是出如今attributes列表裏。若是是attributes表裏的屬性，那麼它就是對整個class文件所對應的類或者接口的描述；若是出如今fileds的某一項裏，那麼它就是對該字段額外信息的描述；若是出如今methods的某一項裏，那麼它就是對該方法額外信息的描述。
22 模擬一個數據庫死鎖？如何解決死鎖問題

http://blog.csdn.net/hexieshangwang/article/details/47189213
23 mysql如何實現分頁功能？
24 若是有一百萬的數據，mysql如何實現高性能分頁
25 數據庫三個範式分別是什麼？
26 堆排序時間複雜度，nlogn紅黑樹時間複雜度logn
27 jdk的bin目錄下有哪些工具？怎麼用？

28 類加載機制是什麼，爲何實現雙親委派模型？

http://www.cnblogs.com/wxd0108/p/6681618.html
29 java的異常如何分類？

30 分佈式的二階段提交算法

可用於分佈式任務

31 post和get有什麼區別
32 ThreadLocal有什麼問題 內存溢出 this.thread -> threadlocalmap ->(threadlocal實例，而後value)
33 不加鎖實現阻塞隊列

2017-9-12

三次握手：

第一次

第一次握手：創建鏈接時，客戶端發送syn包（syn=j）到服務器，並進入SYN_SENT狀態，等待服務器確認；SYN：同步序列編號（Synchronize Sequence Numbers）。

第二次

第二次握手：服務器收到syn包，必須確認客戶的SYN（ack=j+1），同時本身也發送一個SYN包（syn=k），即SYN+ACK包，此時服務器進入SYN_RECV狀態；

第三次

第三次握手：客戶端收到服務器的SYN+ACK包，向服務器發送確認包ACK(ack=k+1），此包發送完畢，客戶端和服務器進入ESTABLISHED（TCP鏈接成功）狀態，完成三次握手。

· 客戶端先發送FIN，進入FIN_WAIT1狀態

· 服務端收到FIN，發送ACK，進入CLOSE_WAIT狀態，客戶端收到這個ACK，進入FIN_WAIT2狀態

· 服務端發送FIN，進入LAST_ACK狀態

· 客戶端收到FIN，發送ACK，進入TIME_WAIT狀態，服務端收到ACK，進入CLOSE狀態

· 客戶端TIME_WAIT持續2倍MSL時長，在linux體系中大概是60s，轉換成CLOSE狀態

能不能發送完ACK以後不進入TIME_WAIT就直接進入CLOSE狀態呢？不行的，這個是爲了TCP協議的可靠性，因爲網絡緣由，ACK可能會發送失敗，那麼這個時候，被動一方會主動從新發送一次FIN，這個時候若是主動方在TIME_WAIT狀態，則還會再發送一次ACK，從而保證可靠性。那麼從這個解釋來講，2MSL的時長設定是能夠理解的，MSL是報文最大生存時間，若是從新發送，一個FIN＋一個ACK，再加上不按期的延遲時間，大體是在2MSL的範圍。

回到上面的問題，go寫了一個HTTP服務，壓測發現TIME_WAIT過多。

首先判斷是否是壓測程序放在服務的同一臺機器...固然不會犯這麼低級的錯誤...

那麼這個感受就有點奇怪了，HTTP服務並無依賴外部mysql或者redis等服務，就是一個簡單的Hello world，而TIME_WAIT的是主動斷開方纔會出現的，因此主動斷開方是服務端？

答案是是的。在HTTP1.1協議中，有個Connection頭，Connection有兩個值，close和keep-alive，這個頭就至關於客戶端告訴服務端，服務端你執行完成請求以後，是關閉鏈接仍是保持鏈接，保持鏈接就意味着在保持鏈接期間，只能由客戶端主動斷開鏈接。還有一個keep-alive的頭，設置的值就表明了服務端保持鏈接保持多久。

HTTP默認的Connection值爲close，那麼就意味着關閉請求的一方几乎都會是由服務端這邊發起的。那麼這個服務端產生TIME_WAIT過多的狀況就很正常了。

雖然HTTP默認Connection值爲close，可是如今的瀏覽器發送請求的時候通常都會設置Connection爲keep-alive了。因此，也有人說，如今沒有必要經過調整參數來使TIME_WAIT下降了。

短鏈接與長鏈接

通俗來說，瀏覽器和服務器每進行一次通訊，就創建一次鏈接，任務結束就中斷鏈接，即短鏈接。相反地，假如通訊結束（如完成了某個HTML文件的信息獲取）後保持鏈接則爲長鏈接。在HTTP/1.0中，默認使用短鏈接。從HTTP/1.1起，默認使用長鏈接，這樣作的優勢是顯而易見的，一個網頁的加載可能須要HTML文件和多個CSS或者JS，假如每獲取一個靜態文件都創建一次鏈接，那麼就太浪費時間了，而在保持鏈接的狀況下，繼續GET便可。

對於頻繁請求資源的客戶來講，較適用長鏈接。但鏈接數最好進行限制，防止創建太多鏈接拖累服務端。通常瀏覽器對一個網站的鏈接是有限制的幾個，因此網站會將資源部署在多個域名上以實現瀏覽器同時請求。

短/長鏈接應當在TCP鏈接的範疇中來討論。有人常說HTTP的短鏈接和長鏈接如何如何，可是HTTP只是一個應用層協議，又是無狀態的，最終實質性的保持鏈接仍是得靠傳輸層，即TCP。

舉個例子，NginX做爲代理的一種常見配置方式是在NginX與客戶端之間的鏈接使用長鏈接，NginX與後端服務器之間的鏈接使用短鏈接。

keep-alive

咱們使用瀏覽器的開發者工具查看網絡請求和響應信息時常常在HTTP請求頭部看到Connection: keep-alive，通常的瀏覽器都會帶着個頭去請求數據，假若有特殊需求能夠用Connection: close斷開。HTTP頭部的Connection也不必定就被客戶端或服務端老老實實地遵循，畢竟各有各的考慮，尤爲是在HTTP/1.0這還只是個實驗性的功能，而在HTTP/1.1默認長鏈接因而沒有對長鏈接作特殊的規定。

長鏈接也不能無限期地長，服務端有可能在頭部放Keep-Alive，其中timeout等於一個值來規定保持鏈接的秒數，還能夠用max來規定多少次請求後斷開。若是沒有說明怎麼斷開，主動發起四次握手也能夠實現鏈接的斷開。

如今有一個問題就是HTTP的keep-alive與TCP的keep-alive究竟是什麼關係。其實這是兩種不一樣的機制，能夠認爲沒有什麼關係。HTTP在頭部的Connection中聲明keep-alive能夠告訴對方要長鏈接不當即斷開，可是TCP的keep-alive則是一種檢查對方是否仍舊和本身保持着鏈接的機制以免自做多情半開放的鏈接。假如發出一個探測段，成功收到響應，這證實鏈接正常保持；假如發出一個探測段一段時間後，一個響應都沒收到，對方可能已掛斷、機器異常或網絡異常；假如對方收到探測段但重置，說明原來的鏈接已經由於某些緣由掛斷，目前是由於未進行三次握手新創建鏈接而被掛斷。

算法性能測試？壓力測試

互斥鎖信號量

信號量與普通整型變量的區別：

①信號量(semaphore)是非負整型變量，除了初始化以外，它只能經過兩個標準原子操做：wait(semap) , signal(semap) ;來進行訪問；

②操做也被成爲PV原語（P來源於Dutch proberen"測試"，V來源於Dutch verhogen"增長"），而普通整型變量則能夠在任何語句塊中被訪問；

信號量與互斥鎖之間的區別：

1. 互斥量用於線程的互斥，信號線用於線程的同步。
這是互斥量和信號量的根本區別，也就是互斥和同步之間的區別。
互斥：是指某一資源同時只容許一個訪問者對其進行訪問，具備惟一性和排它性。但互斥沒法限制訪問者對資源的訪問順序，即訪問是無序的。
同步：是指在互斥的基礎上（大多數狀況），經過其它機制實現訪問者對資源的有序訪問。在大多數狀況下，同步已經實現了互斥，特別是全部寫入資源的狀況一定是互斥的。少數狀況是指能夠容許多個訪問者同時訪問資源
2.互斥量值只能爲0/1，信號量值能夠爲非負整數。
也就是說，一個互斥量只能用於一個資源的互斥訪問，它不能實現多個資源的多線程互斥問題。信號量能夠實現多個同類資源的多線程互斥和同步。當信號量爲單值信號量是，也能夠完成一個資源的互斥訪問。
3.互斥量的加鎖和解鎖必須由同一線程分別對應使用，信號量能夠由一個線程釋放，另外一個線程獲得。

項目的系統架構圖》》》》

功能的流程圖》》》

軟件架構方面硬件架構方面

剝洋蔥：客戶端（技術）服務器（登陸服務器業務邏輯服務器數據庫服務器）每一個服務器的業務需求。

服務器卡頓怎麼排查：

free，top，iostat等等看看CPU，內存，網絡狀況

阻塞」與"非阻塞"與"同步"與「異步"不能簡單的從字面理解，提供一個從分佈式系統角度的回答。
1.同步與異步
同步和異步關注的是消息通訊機制 (synchronous communication/ asynchronous communication)
所謂同步，就是在發出一個*調用*時，在沒有獲得結果以前，該*調用*就不返回。可是一旦調用返回，就獲得返回值了。
換句話說，就是由*調用者*主動等待這個*調用*的結果。

而異步則是相反，*調用*在發出以後，這個調用就直接返回了，因此沒有返回結果。換句話說，當一個異步過程調用發出後，調用者不會馬上獲得結果。而是在*調用*發出後，*被調用者*經過狀態、通知來通知調用者，或經過回調函數處理這個調用。

典型的異步編程模型好比Node.js

舉個通俗的例子：
你打電話問書店老闆有沒有《分佈式系統》這本書，若是是同步通訊機制，書店老闆會說，你稍等，」我查一下"，而後開始查啊查，等查好了（多是5秒，也多是一天）告訴你結果（返回結果）。
而異步通訊機制，書店老闆直接告訴你我查一下啊，查好了打電話給你，而後直接掛電話了（不返回結果）。而後查好了，他會主動打電話給你。在這裏老闆經過「回電」這種方式來回調。

2.阻塞與非阻塞
阻塞和非阻塞關注的是程序在等待調用結果（消息，返回值）時的狀態.

阻塞調用是指調用結果返回以前，當前線程會被掛起。調用線程只有在獲得結果以後纔會返回。
非阻塞調用指在不能馬上獲得結果以前，該調用不會阻塞當前線程。

仍是上面的例子，
你打電話問書店老闆有沒有《分佈式系統》這本書，你若是是阻塞式調用，你會一直把本身「掛起」，直到獲得這本書有沒有的結果，若是是非阻塞式調用，你無論老闆有沒有告訴你，你本身先一邊去玩了， 固然你也要偶爾過幾分鐘check一下老闆有沒有返回結果。
在這裏阻塞與非阻塞與是否同步異步無關。跟老闆經過什麼方式回答你結果無關。

若是是關心blocking IO/ asynchronous IO, 參考 Unix Network Programming View Book

linux進程間通信的幾種方式的特色和優缺點，和適用場合

因爲不一樣的進程運行在各自不一樣的內存空間中．一方對於變量的修改另外一方是沒法感知的．所以．進程之間的信息傳遞不可能經過變量或其它數據結構直接進行，只能經過進程間通訊來完成。

管道 ( pipe )：

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

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

信號量( semophore )：

信號量是一個計數器，能夠用來控制多個進程對共享資源的訪問。

它常做爲一種鎖機制，防止某進程正在訪問共享資源時，其餘進程也訪問該資源。所以，主要做

爲進程間以及同一進程內不一樣線程之間的同步手段。  # 消息隊列( message queue ) ： 消息隊列是由消息的鏈表，存放在內核中並由消息隊列標識

符標識。消息隊列克服了信號傳遞信息少、管道只能承載無格式字節流以及緩衝區大小受限等缺點。

信號 ( sinal ) ：

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

#共享內存( shared memory)：共享內存就是映射一段能被其餘進程所訪問的內存，這段共享內存由一個進程建立，但多個進程均可以訪問。共享內存是最快的IPC

方式，它是針對其餘進程間通訊方式運行效率低而專門設計的。它每每與其餘通訊機制，

如信號量，配合使用，來實現進

程間的同步和通訊。

# 套接字( socket ) ：

套解口也是一種進程間通訊機制，與其餘通訊機制不一樣的是，它可用於不一樣及其間的進程通訊。

管道的主要侷限性正體如今它的特色上：

只支持單向數據流；

只能用於具備親緣關係的進程之間； 沒有名字；

管道的緩衝區是有限的（管道制存在於內存中，在管道建立時，爲緩衝區分配一個頁面大小）；

管道所傳送的是無格式字節流，這就要求管道的讀出方和寫入方必須事先約定好數據的格式，好比多少字節算做一個消息（或命令、或記錄）等等；

管道通訊(PIPE)
兩個進程利用管道進行通訊時．發送信息的進程稱爲寫進程．接收信息的進程稱爲讀進程。管道通訊方式的中間介質就是文件．一般稱這種文件爲管道文件．它就像管道同樣將一個寫進程和一個讀進程鏈接在一塊兒，實現兩個進程之間的通訊。寫進程經過寫入端(發送端)往管道文件中寫入信息；讀進程經過讀出端(接收端)從管道文件中讀取信息。兩個進程協調不斷地進行寫和讀，便會構成雙方經過管道傳遞信息的流水線。
利用系統調用PIPE()能夠建立一個無名管道文件，一般稱爲無名管道或PIPE；利用系統調用MKNOD()能夠建立一個有名管道文件．一般稱爲有名管道或FIFO。無名管道是一種非永
久性的管道通訊機構．當它訪問的進程所有終止時，它也將隨之被撤消。無名管道只能用在具備家族聯繫的進程之間。有名管道能夠長期存在於系統之中．並且提供給任意關係的進程使用，可是使用不當容易致使出錯．因此操做系統將命名管道的管理權交由系統來加以控制管道文件被建立後，能夠經過系統調用WRITE()和READ()來實現對管道的讀寫操做；通訊完後，可用CLOSE()將管道文件關閉。

消息緩衝通訊(MESSAGE)
多個獨立的進程之間能夠經過消息緩衝機制來相互通訊．這種通訊的實現是以消息緩衝區爲中間介質．通訊雙方的發送和接收操做均以消息爲單位。在存儲器中，消息緩衝區被組織成隊列，一般稱之爲消息隊列。消息隊列一旦建立後便可由多進程共享．發送消息的進程能夠在任意時刻發送任意個消息到指定的消息隊列上，並檢查是否有接收進程在等待它所發送的消息。如有則喚醒它：而接收消息的進程能夠在須要消息的時候到指定的消息隊列上獲取消息．若是消息尚未到來．則轉入睡眠狀態等待。

共享內存通訊(SHARED MEMORY)
針對消息緩衝須要佔用CPU進行消息複製的缺點．OS提供了一種進程間直接進行數據交換的通訊方式一共享內存 顧名思義．這種通訊方式容許多個進程在外部通訊協議或同步，互斥機制的支持下使用同一個內存段(做爲中間介質)進行通訊．它是一種最有效的數據通訊方式，其特色是沒有中間環節．直接將共享的內存頁面經過附接．映射到相互通訊的進程各自的虛擬地址空間中．從而使多個進程能夠直接訪問同一個物理內存頁面．如同訪問本身的私有空間同樣(但實質上不是私有的而是共享的)。所以這種進程間通訊方式是在同一個計算機系統中的諸進程間實現通訊的最快捷的方法．而它的侷限性也在於此．即共享內存的諸進程必須共處同一個計算機系統．有物理內存能夠共享才行。

三種方式的特色（優缺點）：

1.無名管道簡單方便．但侷限於單向通訊的工做方式．而且只能在建立它的進程及其子孫進程之間實現管道的共享：有名管道雖然能夠提供給任意關係的進程使用．可是因爲其長期存在於系統之中，使用不當容易出錯。

2.消息緩衝能夠再也不侷限於父子進程．而容許任意進程經過共享消息隊列來實現進程間通訊．並由系統調用函數來實現消息發送和接收之間的同步．從而使得用戶在使用消息緩衝進行通訊時再也不須要考慮同步問題．使用方便，可是信息的複製須要額外消耗CPU的時間．不適宜於信息量大或操做頻繁的場合。

3.共享內存針對消息緩衝的缺點改而利用內存緩衝區直接交換信息，無須複製，快捷、信息量大是其優勢。可是共享內存的通訊方式是經過將共享的內存緩衝區直接附加到進程的虛擬地址空間中來實現的．所以，這些進程之間的讀寫操做的同步問題操做系統沒法實現。必須由各進程利用其餘同步工具解決。另外，因爲內存實體存在於計算機系統中．因此只能由處於同一個計算機系統中的諸進程共享。不方便網絡通訊。

MySQL實現了四種通訊協議

1. TCP/IP協議，一般咱們經過來鏈接MySQL，各類主要編程語言都是根據這個協議實現了鏈接模塊

2. Unix Socket協議，這個一般咱們登入MySQL服務器中使用這個協議，由於要使用這個協議鏈接MySQL須要一個物理文件，文件的存放位置在配置文件中有定義，值得一提的是，這是全部協議中最高效的一個。

一、介紹Java中全部的集合；

二、ArrayList和LinkedList的增刪改查的效率問題；

三、Set,Map和List集合共同繼承什麼類；

四、介紹同步鎖，使用情景，均可以再哪裏使用；

五、假若有兩個線程，一個線程A，一個線程B都會訪問一個加鎖方法，可能存在併發狀況，可是線程B訪問頻繁，線程A訪問次數不多，問如何優化。(我第一次遇到這個問題，說不會，而後面試官說有了解太重度鎖和輕度鎖嗎)

六、介紹下線程和進程的關係；

七、進程間都有哪些通訊方式；

八、講一下AIDL；

九、瞭解Handler機制嗎，講解下；

十、MessageQueue的工做原理；

十一、假若有一個一秒和三秒延遲的消息在MessageQueue裏面，請問在加入一個兩秒延遲的消息插入順序是怎樣的；

十二、假如消息隊列裏有3個消息，分別是延遲1秒，延遲2秒，延遲3秒，若是1秒的已經消耗了500毫秒，這時延遲2秒的會變成1.5秒，而且在插入一個2秒的會排在1.5秒以後，請講解下這個原理；

1三、這個算法，給紙和筆，有一個整數，轉換爲二進制，請找出全部的1的數量；

1四、你以爲Java是徹底面相對象的語言嗎？

面向對象是一種約束規範，並非絕對的，好比靜態屬性好比int這些

1五、講解下你對抽象，多態的理解；

1六、講解下安卓的四大組建，對哪一個比較熟；

1七、Activity的生命週期；

1八、那你講下，Activity中的onCreate方法裏調用finish方法後，會調用哪些方法；

1九、講解下安卓的網絡請求，httpclient瞭解過嗎，講解下Java裏調用網絡的累都有哪些；

20、講解下http請求裏的header有什麼做用；

2一、講解下本身的項目，同時還現場去個人GitHub裏看個人開源項目；

2二、有什麼想問個人，我問了個人缺點和優點；

介紹本身。

Tcp和udp的區別。分別適用於哪些場景。

可靠鏈接面向數據流面向報文（實時通信視頻）（文件http）

三次握手四次揮手。。是否能夠兩次握手，爲什麼要四次揮手。

微服務相關。

Get和post區別。

Http協議相關。

Java有沒有多繼承，接口和抽象類區別。jvm 理解

jre和jdk的區別

數據庫四個範式的區別。在設計數據庫的時候如何考量。

數據庫設計三範式

爲了創建冗餘較小、結構合理的數據庫，設計數據庫時必須遵循必定的規則。在關係型數據庫中這種規則就稱爲範式。範式是符合某一種設計要求的總結。要想設計一個結構合理的關係型數據庫，必須知足必定的範式。

在實際開發中最爲常見的設計範式有三個：

1．第一範式(確保每列保持原子性)

第一範式是最基本的範式。若是數據庫表中的全部字段值都是不可分解的原子值，就說明該數據庫表知足了第一範式。

第一範式的合理遵循須要根據系統的實際需求來定。好比某些數據庫系統中須要用到「地址」這個屬性，原本直接將「地址」屬性設計成一個數據庫表的字段就行。可是若是系統常常會訪問「地址」屬性中的「城市」部分，那麼就非要將「地址」這個屬性從新拆分爲省份、城市、詳細地址等多個部分進行存儲，這樣在對地址中某一部分操做的時候將很是方便。這樣設計纔算知足了數據庫的第一範式，以下表所示。

上表所示的用戶信息遵循了第一範式的要求，這樣在對用戶使用城市進行分類的時候就很是方便，也提升了數據庫的性能。

2．第二範式(確保表中的每列都和主鍵相關)

第二範式在第一範式的基礎之上更進一層。第二範式須要確保數據庫表中的每一列都和主鍵相關，而不能只與主鍵的某一部分相關（主要針對聯合主鍵而言）。也就是說在一個數據庫表中，一個表中只能保存一種數據，不能夠把多種數據保存在同一張數據庫表中。

好比要設計一個訂單信息表，由於訂單中可能會有多種商品，因此要將訂單編號和商品編號做爲數據庫表的聯合主鍵，以下表所示。

訂單信息表

這樣就產生一個問題：這個表中是以訂單編號和商品編號做爲聯合主鍵。這樣在該表中商品名稱、單位、商品價格等信息不與該表的主鍵相關，而僅僅是與商品編號相關。因此在這裏違反了第二範式的設計原則。

而若是把這個訂單信息表進行拆分，把商品信息分離到另外一個表中，把訂單項目表也分離到另外一個表中，就很是完美了。以下所示。

這樣設計，在很大程度上減少了數據庫的冗餘。若是要獲取訂單的商品信息，使用商品編號到商品信息表中查詢便可。

3．第三範式(確保每列都和主鍵列直接相關,而不是間接相關)

第三範式須要確保數據表中的每一列數據都和主鍵直接相關，而不能間接相關。

好比在設計一個訂單數據表的時候，能夠將客戶編號做爲一個外鍵和訂單表創建相應的關係。而不能夠在訂單表中添加關於客戶其它信息（好比姓名、所屬公司等）的字段。以下面這兩個表所示的設計就是一個知足第三範式的數據庫表。

這樣在查詢訂單信息的時候，就能夠使用客戶編號來引用客戶信息表中的記錄，也沒必要在訂單信息表中屢次輸入客戶信息的內容，減少了數據冗餘。

4.範式總結

第一範式：具備原子性

第二範式：主鍵列與非主鍵列遵循徹底函數依賴關係

第三範式：非主鍵列之間沒有傳遞函數依賴關係

數據庫設計原則

在您開始閱讀這篇文章以前，我得明確地告訴您，我並非一個數據庫設計領域的大師。如下列出的 11 點是我對本身在平時項目實踐和閱讀中學習到的經驗總結出來的我的看法。我我的認爲它們對個人數據庫設計提供了很大的幫助。實屬一家之言，歡迎拍磚 : )

我之因此寫下這篇這麼完整的文章是由於，不少開發者一參與到數據庫設計，就會很天然地把 「三範式」 看成銀彈同樣來使用。他們每每認爲遵循這個規範就是數據庫設計的惟一標準。因爲這種心態，他們每每儘管一路碰壁也會堅持把項目作下去。

你們都說標準規範是重要的指導方針而且也這麼作着，可是把它看成石頭上的一塊標記來記着（死記硬背）仍是會帶來麻煩的。如下 11 點是我在數據庫設計時最優先考慮的規則。

◆規則 1：弄清楚將要開發的應用程序是什麼性質的（OLTP 仍是 OPAP）？

當你要開始設計一個數據庫的時候，你應該首先要分析出你爲之設計的應用程序是什麼類型的，它是 「事務處理型」（Transactional） 的仍是 「分析型」 （Analytical）的？你會發現許多開發人員採用標準化作法去設計數據庫，而不考慮目標程序是什麼類型的，這樣作出來的程序很快就會陷入性能、客戶定製化的問題當中。正如前面所說的，這裏有兩種應用程序類型， 「基於事務處理」 和 「基於分析」，下面讓咱們來了解一下這兩種類型究竟說的是什麼意思。

事務處理型：這種類型的應用程序，你的最終用戶更關注數據的增查改刪（CRUD，Creating/Reading/Updating/Deleting）。這種類型更加官方的叫法是 「OLTP」 。

分析型：這種類型的應用程序，你的最終用戶更關注數據分析、報表、趨勢預測等等功能。這一類的數據庫的 「插入」 和 「更新」 操做相對來講是比較少的。它們主要的目的是更加快速地查詢、分析數據。這種類型更加官方的叫法是 「OLAP」 。

那麼換句話說，若是你認爲插入、更新、刪除數據這些操做在你的程序中更爲突出的話，那就設計一個規範化的表不然的話就去建立一個扁平的、不規範化的數據庫結構。

如下這個簡單的圖表顯示了像左邊 Names 和 Address 這樣的簡單規範化的表，怎麼經過應用不規範化結構來建立一個扁平的表結構。

◆規則 2：將你的數據按照邏輯意義分紅不一樣的塊，讓事情作起來更簡單

這個規則其實就是 「三範式」 中的第一範式。違反這條規則的一個標誌就是，你的查詢使用了不少字符串解析函數

例如 substring、charindex 等等。若真如此，那就須要應用這條規則了。

好比你看到的下面圖片上有一個有學生名字的表，若是你想要查詢學生名字中包含「Koirala」，但不包含「Harisingh」的記錄，你能夠想象一下你將會獲得什麼樣的結果。

因此更好的作法是將這個字段拆分爲更深層次的邏輯分塊，以便咱們的表數據寫起來更乾淨，以及優化查詢。

◆規則 3：不要過分使用 「規則 2」

開發者都是一羣很可愛的生物。若是你告訴他們這是一條解決問題的正路，他們就會一直這麼作下去，作到過了頭致使了一些沒必要要的後果。這也能夠應用於咱們剛剛在前面提到的規則2。當你考慮字段分解時，先暫停一下，而且問問你本身是否真的須要這麼作。正如所說的，分解應該是要符合邏輯的。

例如，你能夠看到電話號碼這個字段，你不多會把電話號碼的 ISD 代碼單獨分開來操做（除非你的應用程序要求這麼作）。因此一個很明智的決定就是讓它保持原樣，不然這會帶來更多的問題。

◆規則 4：把重複、不統一的數據當成你最大的敵人來對待

集中那些重複的數據而後重構它們。我我的更加擔憂的是這些重複數據帶來的混亂而不是它們佔用了多少磁盤空間。

例以下面這個圖表，你能夠看到 "5th Standard" 和 "Fifth standard" 是同樣的意思，它們是重複數據。如今你可能會說是因爲那些錄入者錄入了這些重複的數據或者是差勁的驗證程序沒有攔住，讓這些重複的數據進入到了你的系統。如今，若是你想導出一份將本來在用戶眼裏十分困惑的數據顯示爲不一樣實體數據的報告，該怎麼作呢？

解決方法之一是將這些數據完整地移到另一個主表，而後經過外鍵引用過來。在下面這個圖表中你能夠看到咱們是如何建立一個名爲 「Standards」（課程級別） 的主表，而後一樣地使用簡單的外鍵鏈接過去。

◆規則 5：小心被分隔符分割的數據，它們違反了「字段不可再分」

前面的規則 2 即「第一範式」說的是避免 「重複組」 。下面這個圖表做爲其中的一個例子解釋了 「重複組」是什麼樣子的。若是你仔細的觀察 syllabus（課程） 這個字段，會發如今這一個字段裏實在是填充了太多的數據了。像這些字段就被稱爲 「重複組」 了。若是咱們又得必須使用這些數據，那麼這些查詢將會十分複雜而且我也懷疑這些查詢會有性能問題。

這些被塞滿了分隔符的數據列須要特別注意，而且一個較好的辦法是將這些字段移到另一個表中，使用外鍵鏈接過去，一樣地以便於更好的管理。

那麼，讓咱們如今就應用規則2（第一範式） 「避免重複組」 吧。你能夠看到上面這個圖表，我建立了一個單獨的 syllabus（課程） 表，而後使用 「多對多」 關係將它與 subject（科目） 表關聯起來。

經過這個方法，主表（student 表）的 syllabus（課程） 字段就再也不有重複數據和分隔符了。

◆規則 6：小心那些僅僅部分依賴主鍵的列

留心注意那些僅僅部分依賴主鍵的列。例如上面這個圖表，咱們能夠看到這個表的主鍵是 Roll No.+Standard。如今請仔細觀察 syllabus 字段，能夠看到 syllabus（課程） 字段僅僅關聯（依賴） Standard（課程級別） 字段而不是直接地關聯（依賴）某個學生（Roll No. 字段）。

Syllabus（課程） 字段關聯的是學生正在學習的哪一個課程級別（Standard 字段）而不是直接關聯到學生自己。那若是明天咱們要更新教學大綱（課程）的話還要痛苦地爲每一個同窗也修改一下，這明顯是不符合邏輯的（不正常的作法）。更有意義的作法是將這些字段從這個表移到另一個表，而後將它們與 Standard（課程級別）表關聯起來。

你能夠看到咱們是如何移動 syllabus（課程）字段而且一樣地附上 Standard 表。

這條規則只不過是 「三範式」 裏的 「第二範式」：「全部字段都必須完整地依賴主鍵而不是部分依賴」。

◆規則 7：仔細地選擇派生列

若是你正在開發一個 OLTP 型的應用程序，那強制不去使用派生字段會是一個很好的思路，除非有迫切的性能要求，好比常常須要求和、計算的 OLAP 程序，爲了性能，這些派生字段就有必要存在了。

經過上面的這個圖表，你能夠看到 Average 字段是如何依賴 Marks 和 Subjects 字段的。這也是冗餘的一種形式。所以對於這樣的由其餘字段獲得的字段，須要思考一下它們是否真的有必要存在。

這個規則也被稱爲 「三範式」 裏的第三條：「不該該有依賴於非主鍵的列」 。 個人我的見解是不要盲目地運用這條規則，應該要看實際狀況，冗餘數據並不老是壞的。若是冗餘數據是計算出來的，看看實際狀況再來決定是否應用這第三範式。

◆規則 8：若是性能是關鍵，不要執拗地去避免冗餘

不要把 「避免冗餘」 看成是一條絕對的規則去遵循。若是對性能有迫切的需求，考慮一下打破常規。常規狀況下你須要作多個表的鏈接操做，而在很是規的狀況下這樣的多表鏈接是會大大地下降性能的。

◆規則 9：多維數據是各類不一樣數據的聚合

OLAP 項目主要是解決多維數據問題。好比你能夠看看下面這個圖表，你會想拿到每一個國家、每一個顧客、每段時期的銷售額狀況。簡單的說你正在看的銷售額數據包含了三個維度的交叉。

爲這種狀況作一個實際的設計是一個更好的辦法。簡單的說，你能夠建立一個簡單的主要銷售表，它包含了銷售額字段，經過外鍵將其餘全部不一樣維度的錶鏈接起來。

◆規則 10：將那些具備「名值表」特色的表統一塊兒來設計

不少次我都遇到過這種 「名值表」 。 「名值表」 意味着它有一些鍵，這些鍵被其餘數據關聯着。好比下面這個圖表，你能夠看到咱們有 Currency（貨幣型）和 Country（國家）這兩張表。若是你仔細觀察你會發現實際上這些表都只有鍵和值。

對於這種表，建立一個主要的表，經過一個 Type（類型）字段來區分不一樣的數據將會更有意義。

◆規則 11：無限分級結構的數據，引用本身的主鍵做爲外鍵

咱們會常常碰到一些無限父子分級結構的數據（樹形結構？）。例如考慮一個多級銷售方案的狀況，一個銷售人員之下能夠有多個銷售人員。注意到都是 「銷售人員」 。也就是說數據自己都是一種。可是層級不一樣。這時候咱們能夠引用本身的主鍵做爲外鍵來表達這種層級關係，從而達成目的。

這篇文章的用意不是叫你們不要遵循範式，而是叫你們不要盲目地遵循範式。根據你的項目性質和須要處理的數據類型來作出正確的選擇。

詳細設計數據庫步驟。

1、關於java基礎
一、一致性hash
（1）提出一致性hash是爲了解決什麼問題？
（2）hash的性能評估指標（單調性、容錯性、可擴展性）
二、java鎖機制
（1）synchronized關鍵字、volatile關鍵字
（2）java.util.concurrent.locks包
（3）synchronized和ReentrantLock（重入鎖）的區別，synchronized用在代碼塊、方法、靜態方法時鎖的都是什麼
三、ConcurrentHashMap的原理，都用的是哪一種鎖，segment有沒可能增大（不會，只會增大每一個segment中的entry數組）
四、進程和線程的區別
五、AtomicInteger實現原理（CAS自旋）
六、值傳遞和引用傳遞
七、java有沒有多繼承，接口和抽象類區別
八、jdk和jre的區別
九、講述一下併發編程與多線程
十、String、StringBuffer和StringBuilder的區別
十一、int在32位和64位機中的區別
十二、java中基本類型的位數
1三、static關鍵字的用法
1四、java的訪問權限，成員的可見性
1五、HashmMap、HashTable、ConcurrentHashMap的區別與聯繫
1六、char可否存儲漢字？
1七、Spring轉成int型，能不能轉，怎麼轉
1八、HashMap和HashSet的實現原理
1九、動態代理的原理
20、包裝類型和基本數據類型的比較問題（例如：Integer可否== int類型變量，可否作比較，何時不能作比較）
2一、ArrayList和LinkedList的比較
2二、單例模式都有什麼，是否線程安全，怎麼改進（從synchronized到雙重檢驗鎖到枚舉）
2三、java線程安全都體如今哪些方面，如何維護線程安全？
2四、反射機制中能夠獲取private成員的值嗎（沒有set和get函數）
2五、寫一段synchronized可能發生死鎖的代碼
2六、死鎖的條件，摒棄死鎖的條件有哪些？

2、關於java虛擬機
一、垃圾回收算法，爲何要分代處理
二、GC停頓緣由，如何下降停頓
三、JVM如何調優，參數怎麼調
四、如何使用工具分析jvm狀態
五、類加載機制
六、什麼是java虛擬機，對jvm的理解
七、jvm內存模型，各個區的做用
八、堆的做用
九、JVM調試工具
十、堆和棧的區別
十一、內存溢出了怎麼辦
十二、何時會棧溢出

3、關於java後臺
一、介紹Spring的IOC和AOP，分別是如何實現的（反射機制和動態代理）
二、redis如何處理分佈式服務器併發形成的不一致，若是數據庫不提供隔離呢？
三、解釋MySQL索引、b樹，爲啥不用平衡二叉樹或紅黑樹（磁盤與內存的存儲方式不一樣）
四、Spring的bean加載機制，bean生成的具體步驟
五、IOC的注入方式（set注入、構造方法注入）
六、Spring什麼時候建立applicationContext（web.xml中使用listener）
七、listener是監聽哪一個事件
八、SpringMVC的具體流程
九、Spring的特性，SpringMVC中控制器的名字及其配置
十、Spring用到哪些設計模式？
十一、controller怎麼處理的請求

4、關於數據結構與算法
一、01矩陣，相鄰的1是一個島嶼，找出全部島嶼數（遞歸解決）
二、2個雞蛋，100高的樓，最少的次數測出雞蛋碎掉的臨界層，沒碎的雞蛋能夠反覆使用
三、大量字符串找出數量最多的K個，考慮內存放得下和放不下兩種狀況
四、跳錶的基本原理
五、最長迴文子串
六、找到數組中最多的那個數，除了hashset還有沒有其餘方法（蒙特卡羅法）
七、輸入合法的數字字符串，輸出貨幣字符（就是每隔三位加逗號，考慮邊界處理）
八、有1-10 10個數，和一個數sum，計算用10個數連加獲得sum有多少種系數組合（遞歸）
九、如何實現高效的同步鏈表
十、層次遍歷二叉樹，偶數層輸出，且逆序輸出
十一、給定一個字符串，寫出全部可能的全排列（遞歸）
十二、5億條淘寶交易訂單，輸出銷售次數最多的100個商品。
1三、給出年月日，如何求出這天是這年的第幾天？
1四、64個馬有8個跑道，沒有計時工具，最少須要多少次跑，能夠找到跑的最快的那個馬，若是換成找到最快的四匹呢？
1五、給一個函數，返回0和1，機率爲p和1-p，請你實現一個函數，使得返回0和1的機率同樣
1六、10億個url，每一個url大小小於56B，要求去重，內存4G
1七、吧一個BST轉化成一個雙向鏈表
1八、手寫一個全排列
1九、B數和B+數
20、介紹一下hash，怎麼解決hash衝突
2一、給一個文件，找出其中每一個單詞的個數
2二、1000瓶藥有1瓶有毒，若是小白鼠服用有毒的藥，則24小時後死亡。如今需設計一種策略，使用盡量少的小白鼠，在24小時內找出有毒的藥。（將串行的二分法並行使用）

5、關於Http協議
一、TCP和UDP的區別，分別適用於哪些場景？
二、三次握手四次握手，是否能夠兩次握手，爲什麼要四次握手？
三、get和post的區別
四、Http協議相關

6、關於Linux
一、epoll、epollh和select的區別
二、Linux下的一些指令，怎麼查看進程，按照內存大小，CPU佔用排序等

7、關於數據庫
一、數據庫四個範式的區別，在設計數據庫的時候怎麼考量，詳細設計數據庫的步驟。
二、MySQL和Oracle的區別，如何選擇？
三、SQL中replace和update的區別
四、事務管理acid
五、數據庫的索引有什麼用，帶來的問題是什麼？
六、數據庫查詢時間優化
七、

8、設計模式
一、單例模式
二、生產者模式、消費者模式

文件A100億記錄，文件B100萬記錄，找出A中不在B中的記錄

如何攔截5分鐘前惡意登陸（用戶名密碼不正確）超多必定次數的ip

十二、數據傳輸：服務器與服務器之間傳輸文件夾下的文件，一個文件夾下有10個文件，另外一個文件夾下有100個文件，兩個文件夾大小相等，問，哪一個傳輸更快？（http協議）

1三、數據庫兩個表關聯的方式

1四、數據庫表關聯的內部算法

1五、數據庫鎖的實現

1六、數據庫表裏有100萬條數據，想要刪除80萬條數據，可是由於鎖的緣由，刪除很慢，如今想要快速刪除怎麼辦

網易內推

一面（項目）

1. 項目的架構，怎麼實現的

2. 會不會java web的知識

3. 對一個登陸窗口進行測試

4. 測試人員須要的能力

5. 有沒有比較熟的b/s架構

二面（測試思惟）（未經過）

1. 寫代碼：找出一組數中最大的數

2. 所接觸到的測試的內容

3. 對淘寶的搜索欄進行測試（1.寶貝，店鋪，天貓選項；2.搜索欄；3.搜索按鈕）

4. 與他人相比，你的優點（此處最好答熱情和測試行業大趨勢和前景）

中興

一面（現場+技術）
1.簡單介紹一下本身
2.簡單介紹一下項目
3.性能測試有哪些
4.TCP的擁塞控制
5.http中的get和post請求的區別
6.怎麼確認post請求發送完畢
7.專利是第一做者麼
8.loadrunner用來幹了什麼
二面（現場+綜合面試）
1.英語介紹本身的學校
2.遇到過最大的挫折
3.看什麼書，重點講一本
4.本身的優缺點
5.若是你帶領一個團隊作一款產品，你想作什麼，爲何（後面會有無數個坑，壓力面的核心）
6.怎麼調節負面情緒
7.有什麼愛好

58面試

一面（基礎）
1.介紹一下項目
2.流行的加密算法（Lz是信息安全方向的碩士，不少面試官都會稍微考考信息安全的問題，考察一下對專業知識的瞭解）
3.寫代碼（找出數組中不重複的數）
4.寫上述代碼的測試用例
5.SQL（寫語句，top，count，group by，order by，select）
6.linux（cd..，cd-，mkdir，vi，netstat）
7.java（忘記了）
8.網絡（get和post的區別，七層分別是什麼，應用層的協議）
9.測試（測試一個系統的性能，具體不記得了）
二面（基礎）
1.自我介紹
2.寫代碼（單例模式）
3.SQL（索引，多表查找）
4.數組和鏈表的區別
5.hash的用處
6.怎麼解決hash衝突
7.linux就不問了
8.DNS劫持的原理
三面（HR）
1.自我介紹
2.有什麼符合軟件測試崗位的優點
3.用三個詞形容本身
4.遇到過什麼困難
5.有沒有考慮過離鄉背井的艱難

美團
一面（基礎+項目）
1.介紹項目
2.項目中的模糊檢索怎麼實現（項目挖的比較深，會一直追着問）
3.項目界面和數據庫怎麼交互？數據流向
4.項目怎麼測試
5.軟件測試的基本流程
6.TCP和UDP的區別和應用場景
7.寫代碼（一個數的個位十位百位相加，判斷結果的個位是否是3）
二面（基礎+算法）
1.自我介紹
2.講一下項目
3.java回收機制
4.java內存泄露
5.重載和重寫的區別
6.http的關鍵字
7.TCP和UDP的區別
8.寫一個SQL語句
9.group by和order by的區別
10.寫代碼（全排列）
11.寫代碼（A to I）
12.上一個代碼的測試用例
13.1G數據怎麼排序
三面（總監+宏觀把控）
1.cookie和session的區別（總監面的每一個問題都會問的比較深，延伸得比較廣；並且每一個問題回答完以後都會着「你肯定？再想想」）
2.session存在服務器的哪一個地方
3.在地址欄鍵入網址以後的過程是什麼樣的，數據流向，哪個過程最耗時間
4.怎麼優化數據庫
5.平時怎麼學習的
6.java和c++最大的區別
7.有些什麼測試方法
8.路由表中存的是什麼
9.B/S和C/S架構的區別
10.有沒有用過框架
四面（現場+HR）
1.自我介紹
2.最有成就的事
3.遇到過什麼挫折
4.優缺點
5.對工做地點有沒有要求
6.最想去哪家互聯網公司，有什麼地方吸引你
7.對美團有什麼瞭解
8.平時喜歡幹什麼
9.有什麼問題

百度
一面（基礎）
1.寫代碼（從數組中找出兩個相加等於n的下標）
2.測試三邊能不能組成三角形（考測試思惟全面性和邏輯是否清晰）
3.爲何報測試
4.常見的測試類型，性能測試指標
5.SQL（多表查詢，左連接和右連接的區別）
6.linux（查看一個文檔，顯示出文檔的最後五條數據）
7.JAVA（int和Integer的區別）
8.網絡（搜索百度主頁的全過程，整個過程的物理設備，網路協議，數據流向；session）
9.怎麼與人合做的
10.怎麼證實本身學習能力強
11.做爲測試的優點
12.怎麼考慮工做地點離家遠的問題
13.有什麼要問的
二面（處理能力+思惟全面性）
1.自我介紹
2.項目的具體算法
3.怎麼判斷鏈表有環，並優化（要求寫出時間複雜度最優的算法）
4.怎麼測試string to int程序（要說的很全面，一直問「還有嗎」）
5.平時有什麼愛好
6.對測試的瞭解
7.作測試的優點
8.在一個環形商場裏有不少商家，商家的錢數事先知道。讓你去搶錢，而且保證不搶連續兩家，怎麼保證搶錢數目最多
9.讓你去實習，能夠去麼
10.有什麼要問的
三面（總監+宏觀把控）
1.自我介紹一下
2.你怎麼學的測試
3.簡單介紹一下項目
4.對工做地點是怎麼選擇的
5.對測試的一些想法
6.優缺點
7.有什麼要問的

滴滴
一面（基礎）
1.簡單自我介紹一下
2.項目介紹
3.對測試的理解
4.java中的框架
5.瞭解到的鎖的知識
6.進程間通訊的方式
7.寫代碼（二叉樹的非遞歸後續遍歷）
8.對上面的代碼寫單測
9.linux相關
10.數據庫的優化
11.線程的狀態轉化
12.TCP和UDP的區別
13.詳細講講擁塞控制

14.java中的集合的底層實現
二面（算法）
1.三人三鬼安全運過河（不詳述）
2.兩個一樣大小的罐子，一個裝鹽，一個裝糖。首先從鹽罐舀一勺鹽到糖罐，再將糖罐中的混合物攪拌均勻，再從糖罐舀一勺混合物到鹽罐，問，最後是糖罐的鹽多仍是鹽罐的糖多（用公式計算的還不行，要一下就能得出結果的想法）
3.寫代碼（判斷字符串數組是否能夠收尾相連成環路）
4.寫代碼（從int型數組中找出和連續子串，要求和最大）
5.測一個存儲系統B（系統B有上級系統A，系統B中有1T存儲容量，天天0點定時更新，還有分佈式的緩存……）
三面（現場+交叉面）（未經過）
1.自我介紹
2.什麼是有效的溝通
3.對一個功能進行壓力測試
4.滴滴搶單給出了新思路（大概是就用搶單以後會等10s，對搶單的司機進行最優匹配），讓設計整個架構，並列出測試點
5.對滴滴的瞭解

總結：1.現場要求寫代碼，最好先理清思路，考慮一下時間複雜度和空間複雜度，能寫出最優算法是會加分很多的。（這兒也有坑，某公司的面試官讓寫了個代碼，看完以後問「有沒有更加優化的代碼？」Lz又看了大概5分鐘，確實沒想出來。答「想不出來。」面試官笑着說「想不出來是由於的確沒有更優的了。我還真怕你給我胡謅一個出來。」Lz「……」。因此回答問題實事求是，按正常的思路走，不會的時候不要亂說）；

2.對於每一個知識點，最好說出本身的理解，不要直接背書上的1234點。就拿java中問的比較常見「抽象類和接口的區別」舉例。若是你回答1.java中抽象類只能單繼承，但能夠實現多個接口，2.抽象類中能夠有方法的定義與實現，接口中方法不能實現………………這樣的回答你們都會，因此若是說完上述這些，再加入一點本身實際學習中的理解會更好。好比：一般，我會把phone定義爲一個抽象類，它是各類不一樣手機類的一個抽象。然而有的手機具備指紋解鎖的功能，有的手機具備防水防塵的功能，對於這些附加的功能，我會把它們分別定義成不一樣的接口。當我須要這個功能的時候，在具體的類中再去實現這個功能。這樣會更加符合面向對象中高內聚低耦合的特色…………就是這相似這樣的回答，會更加突出你學習中的思考過程。

3.既然投了測試，確定會問測試相關的知識，因此仍是得早點看看書，多看看博客，逛逛論壇；

4.面試官都很不錯，有的時候會給你一些提示和引導，因此放輕鬆，太緊張只會思路混亂；

5.通常面試的酒店可能會比較遠，保證比約定時間早到30分鐘就好了。簽到以後整理一下本身的衣着，整潔乾淨就行。看看筆記，調動一下思惟。

6.最後面試官問你有什麼問題的時候必定要問問，Lz以前被某公司內推時的一個HR宣傳視頻誤導了，覺得最後純粹是面試官客套一下，不用問。以後跟一些面試官的溝經過程中發現應聘者問的問題仍是挺重要的，這個問題會暴露你的關注點。儘可能讓面試官瞭解到你對將來工做細節的關注，讓他知道你對這個工做很感興趣。可是最好不要問關於薪酬，福利的問題，等到談offer的時候天然會跟你說這些。

一、HTTP請求的過程，越清楚越好（我從dns解析到TCP三次握手，四次揮手，還有後臺請求邏輯講了一遍）

二、Java線程池ThreadPoolEcecutor參數，基本參數，使用場景

三、HashMap、HashTable、CurrentHashMap的區別及場景，說一下你的理解。HashMap的負載因子，幹啥用的。

四、ArrayList與LinkedList的區別及使用場景，有沒有ArrayList增刪效率比LinkedList高的場景。ArrayList底層採用什麼實現數據的拷貝。

五、MySQL的ACID講一下，延伸到隔離級別

六、JMM講一下，volite關鍵字及使用場景。

七、JVM的內存佈局以及垃圾回收原理及過程講一下。講一下CMS垃圾收集器垃圾回收的流程。以及CMS的缺點（忘了。。）

八、 智力題（聊着聊着忽然來個），兩個杯子，一個有3升水，一個有5升水，請問如何倒出4升水。。（我回答說，使二者水平面一致。。。。一看到題，就這樣啊。。但其答案不是我回答的這。。）

九、 手寫二叉樹的中序遍歷與層序遍歷

十、 手寫二分查找（很基礎）

十一、最後還聊了一下項目，聊一下難點。

十二、最後就是你有什麼要問的。一、表現二、大家那邊主要用那些java技術三、若是過，啥時通知下一面結果。