CVTE Java后台电话一面
目錄
學習Java多久了
使用Java做過什么東西
項目中遇到的問題，然后我說了幾個，他貌似不感興趣，然后問了我內存溢出遇到過沒有
Servlet的生命周期
對Java的集合類了解哪一些，回答了Collection和Map這兩個以及他們的子類，扯到hashMap
在什么情況下使用過hashMap，對hashmap的底層結構可以說一下嗎
hashMap是線程安全的嗎，回答不是，然后又扯到ConcurrentHashMap,然后問ConcurrentHashMap的細節
問數據庫，回答學的mysql，問有幾種引擎，回答有好幾種，主要就兩種
索引有了解嗎
數據庫的三大范式
線程可以簡單講講嗎，然后問線程和線程之間如何進行通信
JVM了解多少，把自己知道的都說了，不過他沒問細節
學習Java多久了
使用Java做過什么東西
項目中遇到的問題，然后我說了幾個，他貌似不感興趣，然后問了我內存溢出遇到過沒有
Servlet的生命周期
Servlet生命周期
加載和實例化Servlet
我們來看一下Tomcat是如何加載的：
? ? ?1. 如果已配置自動裝入選項，則在啟動時自動載入。
? ? ?2. 在服務器啟動時，客戶機首次向Servlet發出請求。
? ? ?3. 重新裝入Servlet時。
? ? ? 當啟動Servlet容器時，容器首先查找一個配置文件web.xml，這個文件中記錄了可以提供服務的Servlet。每個Servlet被指定一個Servlet名，也就是這個Servlet實際對應的Java的完整class文件名。Servlet容器會為每個自動裝入選項的Servlet創建一個實例。所以，每個Servlet類必須有一個公共的無參數的構造器。
初始化
? ? ? 當Servlet被實例化后，Servlet容器將調用每個Servlet的init方法來實例化每個實例，執行完init方法之后，Servlet處于“已初始化”狀態。所以說，一旦Servlet被實例化，那么必將調用init方法。通過Servlet在啟動后不立即初始化，而是收到請求后進行。在web.xml文件中用<load-on-statup> ...... </load-on-statup>對Servlet進行預先初始化。
? ? ? 初始化失敗后，執行init()方法拋出ServletException異常，Servlet對象將會被垃圾回收器回收，當客戶端第一次訪問服務器時加載Servlet實現類，創建對象并執行初始化方法。
請求處理
? ? ? Servlet 被初始化以后，就處于能響應請求的就緒狀態。每個對Servlet 的請求由一個Servlet Request 對象代表。Servlet 給客戶端的響應由一個Servlet Response對象代表。對于到達客戶機的請求，服務器創建特定于請求的一個“請求”對象和一個“響應”對象。調用service方法，這個方法可以調用其他方法來處理請求。
? ? ? Service方法會在服務器被訪問時調用，Servlet對象的生命周期中service方法可能被多次調用，由于web-server啟動后，服務器中公開的部分資源將處于網絡中，當網絡中的不同主機（客戶端）并發訪問服務器中的同一資源，服務器將開設多個線程處理不同的請求，多線程同時處理同一對象時，有可能出現數據并發訪問的錯誤。
? ? ? 另外注意，多線程難免同時處理同一變量時（如：對同一文件進行寫操作），且有讀寫操作時，必須考慮是否加上同步，同步添加時，不要添加范圍過大，有可能使程序變為純粹的單線程，大大削弱了系統性能；只需要做到多個線程安全的訪問相同的對象就可以了。
卸載Servlet
? ? ? 當服務器不再需要Servlet實例或重新裝入時，會調用destroy方法，使用這個方法，Servlet可以釋放掉所有在init方法申請的資源。一個Servlet實例一旦終止，就不允許再次被調用，只能等待被卸載。
? ? ? Servlet一旦終止，Servlet實例即可被垃圾回收，處于“卸載”狀態，如果Servlet容器被關閉，Servlet也會被卸載，一個Servlet實例只能初始化一次，但可以創建多個相同的Servlet實例。如相同的Servlet可以在根據不同的配置參數連接不同的數據庫時創建多個實例。
session和cookie的區別
二者的定義：
當你在瀏覽網站的時候，WEB 服務器會先送一小小資料放在你的計算機上，Cookie 會幫你在網站上所打的文字或是一些選擇，都紀錄下來。當下次你再光臨同一個網站，WEB 服務器會先看看有沒有它上次留下的 Cookie 資料，有的話，就會依據 Cookie里的內容來判斷使用者，送出特定的網頁內容給你。 Cookie 的使用很普遍，許多有提供個人化服務的網站，都是利用 Cookie來辨認使用者，以方便送出使用者量身定做的內容，像是 Web 接口的免費 email 網站，都要用到 Cookie。
具體來說cookie機制采用的是在客戶端保持狀態的方案，而session機制采用的是在服務器端保持狀態的方案，同時我們也看到，由于采用服務器端保持狀態的方案在客戶端也需要保存一個標識，所以session機制可能需要借助于cookie機制來達到保存標識的目的，但實際上它還有其他選擇。
cookie機制。正統的cookie分發是通過擴展HTTP協議來實現的，服務器通過在HTTP的響應頭中加上一行特殊的指示以提示瀏覽器按照指示生成相應的cookie。然而純粹的客戶端腳本如JavaScript或者VBScript也可以生成cookie。而cookie的使用是由瀏覽器按照一定的原則在后臺自動發送給服務器的。瀏覽器檢查所有存儲的cookie，如果某個cookie所聲明的作用范圍大于等于將要請求的資源所在的位置，則把該cookie附在請求資源的HTTP請求頭上發送給服務器。
?
cookie的內容主要包括：名字，值，過期時間，路徑和域。路徑與域一起構成cookie的作用范圍。若不設置過期時間，則表示這個cookie的生命期為瀏覽器會話期間，關閉瀏覽器窗口，cookie就消失。這種生命期為瀏覽器會話期的cookie被稱為會話cookie。?
會話cookie一般不存儲在硬盤上而是保存在內存里，當然這種行為并不是規范規定的。若設置了過期時間，瀏覽器就會把cookie保存到硬盤上,關閉后再次打開瀏覽器，這些cookie仍然有效直到超過設定的過期時間。存儲在硬盤上的cookie可以在不同的瀏覽器進程間共享，比如兩個IE窗口。而對于保存在內存里的cookie，不同的瀏覽器有不同的處理方式。
session機制是一種服務器端的機制，服務器使用一種類似于散列表的結構（也可能就是使用散列表）來保存信息。?當程序需要為某個客戶端的請求創建一個session時，服務器首先檢查這個客戶端的請求里是否已包含了一個session標識（稱為session id），如果已包含則說明以前已經為此客戶端創建過session，服務器就按照session id把這個session檢索出來使用（檢索不到，會新建一個），如果客戶端請求不包含session id，則為此客戶端創建一個session并且生成一個與此session相關聯的session id，session id的值應該是一個既不會重復，又不容易被找到規律以仿造的字符串，這個session id將被在本次響應中返回給客戶端保存。保存這個session id的方式可以采用cookie，這樣在交互過程中瀏覽器可以自動的按照規則把這個標識發送給服務器。一般這個cookie的名字都是類似于SEEESIONID。但cookie可以被人為的禁止，則必須有其他機制以便在cookie被禁止時仍然能夠把session id傳遞回服務器。
經常被使用的一種技術叫做URL重寫，就是把session id直接附加在URL路徑的后面。還有一種技術叫做表單隱藏字段。就是服務器會自動修改表單，添加一個隱藏字段，以便在表單提交時能夠把session id傳遞回服務器。比如：?
<form name="testform" action="/xxx">?
<input type="hidden" name="jsessionid" value="ByOK3vjFD75aPnrF7C2HmdnV6QZcEbzWoWiBYEnLerjQ99zWpBng!-145788764">?
<input type="text">?
</form>?
實際上這種技術可以簡單的用對action應用URL重寫來代替。
cookie 和session 的區別：
1、cookie數據存放在客戶的瀏覽器上，session數據放在服務器上。
2、cookie不是很安全，別人可以分析存放在本地的COOKIE并進行COOKIE欺騙，考慮到安全應當使用session。
3、session會在一定時間內保存在服務器上。當訪問增多，會比較占用你服務器的性能，? ?考慮到減輕服務器性能方面，應當使用COOKIE。
4、單個cookie保存的數據不能超過4K，很多瀏覽器都限制一個站點最多保存20個cookie。
5、所以個人建議：
?? 將登陸信息等重要信息存放為SESSION
?? 其他信息如果需要保留，可以放在COOKIE中
對Java的集合類了解哪一些，回答了Collection和Map這兩個以及他們的子類，扯到hashMap
在什么情況下使用過hashMap，對hashmap的底層結構可以說一下嗎
1. HashMap的數據結構
數據結構中有數組和鏈表來實現對數據的存儲，但這兩者基本上是兩個極端。
數組
數組存儲區間是連續的，占用內存嚴重，故空間復雜的很大。但數組的二分查找時間復雜度小，為O(1)；數組的特點是：尋址容易，插入和刪除困難；
鏈表
鏈表存儲區間離散，占用內存比較寬松，故空間復雜度很小，但時間復雜度很大，達O（N）。鏈表的特點是：尋址困難，插入和刪除容易。
哈希表
那么我們能不能綜合兩者的特性，做出一種尋址容易，插入刪除也容易的數據結構？答案是肯定的，這就是我們要提起的哈希表。哈希表（(Hash table）既滿足了數據的查找方便，同時不占用太多的內容空間，使用也十分方便。
哈希表有多種不同的實現方法，我接下來解釋的是最常用的一種方法——?拉鏈法，我們可以理解為“鏈表的數組”?，如圖：
?
?
從上圖我們可以發現哈希表是由數組+鏈表組成的，一個長度為16的數組中，每個元素存儲的是一個鏈表的頭結點。那么這些元素是按照什么樣的規則存儲到數組中呢。一般情況是通過hash(key)%len獲得，也就是元素的key的哈希值對數組長度取模得到。比如上述哈希表中，12%16=12,28%16=12,108%16=12,140%16=12。所以12、28、108以及140都存儲在數組下標為12的位置。
HashMap其實也是一個線性的數組實現的,所以可以理解為其存儲數據的容器就是一個線性數組。這可能讓我們很不解，一個線性的數組怎么實現按鍵值對來存取數據呢？這里HashMap有做一些處理。
首先HashMap里面實現一個靜態內部類Entry，其重要的屬性有?key , value, next，從屬性key,value我們就能很明顯的看出來Entry就是HashMap鍵值對實現的一個基礎bean，我們上面說到HashMap的基礎就是一個線性數組，這個數組就是Entry[]，Map里面的內容都保存在Entry[]里面。
????/**
?????*?The?table,?resized?as?necessary.?Length?MUST?Always?be?a?power?of?two.
?????*/
????transient?Entry[]?table;
2. HashMap的存取實現
? ? ?既然是線性數組，為什么能隨機存取？這里HashMap用了一個小算法，大致是這樣實現：
// 存儲時:
int?hash?=?key.hashCode();?// 這個hashCode方法這里不詳述,只要理解每個key的hash是一個固定的int值
int?index?=?hash?%?Entry[].length;
Entry[index]?=?value;
// 取值時:
int?hash?=?key.hashCode();
int?index?=?hash?%?Entry[].length;
return?Entry[index];
?
1）put
?
疑問：如果兩個key通過hash%Entry[].length得到的index相同，會不會有覆蓋的危險？
這里HashMap里面用到鏈式數據結構的一個概念。上面我們提到過Entry類里面有一個next屬性，作用是指向下一個Entry。打個比方， 第一個鍵值對A進來，通過計算其key的hash得到的index=0，記做:Entry[0] = A。一會后又進來一個鍵值對B，通過計算其index也等于0，現在怎么辦？HashMap會這樣做:B.next = A,Entry[0] = B,如果又進來C,index也等于0,那么C.next = B,Entry[0] = C；這樣我們發現index=0的地方其實存取了A,B,C三個鍵值對,他們通過next這個屬性鏈接在一起。所以疑問不用擔心。也就是說數組中存儲的是最后插入的元素。到這里為止，HashMap的大致實現，我們應該已經清楚了。
?public?V?put(K?key,?V?value)?{
????????if?(key?==?null)
????????????return?putForNullKey(value);?//null總是放在數組的第一個鏈表中
????????int?hash?=?hash(key.hashCode());
????????int?i?=?indexFor(hash,?table.length);
????????//遍歷鏈表
????????for?(Entry<K,V>?e?=?table[i];?e?!=?null;?e?=?e.next)?{
????????????Object?k;
????????????//如果key在鏈表中已存在，則替換為新value
????????????if?(e.hash?==?hash?&&?((k?=?e.key)?==?key?||?key.equals(k)))?{
????????????????V?oldValue?=?e.value;
????????????????e.value?=?value;
????????????????e.recordAccess(this);
????????????????return?oldValue;
????????????}
????????}
?
????????modCount++;
????????addEntry(hash,?key,?value,?i);
????????return?null;
????}
?
void?addEntry(int?hash,?K?key,?V?value,?int?bucketIndex)?{
????Entry<K,V>?e?=?table[bucketIndex];
????table[bucketIndex]?=?new?Entry<K,V>(hash,?key,?value,?e);?//參數e, 是Entry.next
????//如果size超過threshold，則擴充table大小。再散列
????if?(size++?>=?threshold)
????????????resize(2?*?table.length);
}
當然HashMap里面也包含一些優化方面的實現，這里也說一下。比如：Entry[]的長度一定后，隨著map里面數據的越來越長，這樣同一個index的鏈就會很長，會不會影響性能？HashMap里面設置一個因子，隨著map的size越來越大，Entry[]會以一定的規則加長長度。
2）get
?public?V?get(Object?key)?{
????????if?(key?==?null)
????????????return?getForNullKey();
????????int?hash?=?hash(key.hashCode());
??????? //先定位到數組元素，再遍歷該元素處的鏈表
????????for?(Entry<K,V>?e?=?table[indexFor(hash,?table.length)];
?????????????e?!=?null;
?????????????e?=?e.next)?{
????????????Object?k;
????????????if?(e.hash?==?hash?&&?((k?=?e.key)?==?key?||?key.equals(k)))
????????????????return?e.value;
????????}
????????return?null;
}
?
3）null key的存取
null key總是存放在Entry[]數組的第一個元素。
???private?V?putForNullKey(V?value)?{
????????for?(Entry<K,V>?e?=?table[0];?e?!=?null;?e?=?e.next)?{
????????????if?(e.key?==?null)?{
????????????????V?oldValue?=?e.value;
????????????????e.value?=?value;
????????????????e.recordAccess(this);
????????????????return?oldValue;
????????????}
????????}
????????modCount++;
????????addEntry(0,?null,?value,?0);
????????return?null;
????}
?
????private?V?getForNullKey()?{
????????for?(Entry<K,V>?e?=?table[0];?e?!=?null;?e?=?e.next)?{
????????????if?(e.key?==?null)
????????????????return?e.value;
????????}
????????return?null;
????}
?
?
?
?
4）確定數組index：hashcode % table.length取模
HashMap存取時，都需要計算當前key應該對應Entry[]數組哪個元素，即計算數組下標；算法如下：
???/**
?????*?Returns?index?for?hash?code?h.
?????*/
????static?int?indexFor(int?h,?int?length)?{
????????return?h?&?(length-1);
????}
?
按位取并，作用上相當于取模mod或者取余%。
這意味著數組下標相同，并不表示hashCode相同。
?
5）table初始大小
?
??public?HashMap(int?initialCapacity,?float?loadFactor)?{
????????.....
?
????????//?Find?a?power?of?2?>=?initialCapacity
????????int?capacity?=?1;
????????while?(capacity?<?initialCapacity)
????????????capacity?<<=?1;
?
????????this.loadFactor?=?loadFactor;
????????threshold?=?(int)(capacity?*?loadFactor);
????????table?=?new?Entry[capacity];
????????init();
????}
注意table初始大小并不是構造函數中的initialCapacity！！
而是 >= initialCapacity的2的n次冪！！！！
————為什么這么設計呢？——
3. 解決hash沖突的辦法
Java中hashmap的解決辦法就是采用的鏈地址法。
?
4.?再散列rehash過程
當哈希表的容量超過默認容量時，必須調整table的大小。當容量已經達到最大可能值時，那么該方法就將容量調整到Integer.MAX_VALUE返回，這時，需要創建一張新表，將原表的映射到新表中。
???/**
?????*?Rehashes?the?contents?of?this?map?into?a?new?array?with?a
?????*?larger?capacity.??This?method?is?called?automatically?when?the
?????*?number?of?keys?in?this?map?reaches?its?threshold.
?????*
?????*?If?current?capacity?is?MAXIMUM_CAPACITY,?this?method?does?not
?????*?resize?the?map,?but?sets?threshold?to?Integer.MAX_VALUE.
?????*?This?has?the?effect?of?preventing?future?calls.
?????*
?????*?@param?newCapacity?the?new?capacity,?MUST?be?a?power?of?two;
?????*????????must?be?greater?than?current?capacity?unless?current
?????*????????capacity?is?MAXIMUM_CAPACITY?(in?which?case?value
?????*????????is?irrelevant).
?????*/
????void?resize(int?newCapacity)?{
????????Entry[]?oldTable?=?table;
????????int?oldCapacity?=?oldTable.length;
????????if?(oldCapacity?==?MAXIMUM_CAPACITY)?{
????????????threshold?=?Integer.MAX_VALUE;
????????????return;
????????}
?
????????Entry[]?newTable?=?new?Entry[newCapacity];
????????transfer(newTable);
????????table?=?newTable;
????????threshold?=?(int)(newCapacity?*?loadFactor);
????}
?
????/**
?????*?Transfers?all?entries?from?current?table?to?newTable.
?????*/
????void?transfer(Entry[]?newTable)?{
????????Entry[]?src?=?table;
????????int?newCapacity?=?newTable.length;
????????for?(int?j?=?0;?j?<?src.length;?j++)?{
????????????Entry<K,V>?e?=?src[j];
????????????if?(e?!=?null)?{
????????????????src[j]?=?null;
????????????????do?{
????????????????????Entry<K,V>?next?=?e.next;
????????????????????//重新計算index
????????????????????int?i?=?indexFor(e.hash,?newCapacity);
????????????????????e.next?=?newTable[i];
????????????????????newTable[i]?=?e;
????????????????????e?=?next;
????????????????}?while?(e?!=?null);
????????????}
????????}
????}
hashMap是線程安全的嗎，回答不是，然后又扯到ConcurrentHashMap,然后問ConcurrentHashMap的細節
ConcurrentHashMap是Java 5中支持高并發、高吞吐量的線程安全HashMap實現。在這之前我對ConcurrentHashMap只有一些膚淺的理解，僅知道它采用了多個鎖，大概也足夠了。但是在經過一次慘痛的面試經歷之后，我覺得必須深入研究它的實現。面試中被問到讀是否要加鎖，因為讀寫會發生沖突，我說必須要加鎖，我和面試官也因此發生了沖突，結果可想而知。還是閑話少說，通過仔細閱讀源代碼，現在總算理解ConcurrentHashMap實現機制了，其實現之精巧，令人嘆服，與大家共享之。
實現原理?
鎖分離 (Lock Stripping)
ConcurrentHashMap允許多個修改操作并發進行，其關鍵在于使用了鎖分離技術。它使用了多個鎖來控制對hash表的不同部分進行的修改。ConcurrentHashMap內部使用段(Segment)來表示這些不同的部分，每個段其實就是一個小的hash table，它們有自己的鎖。只要多個修改操作發生在不同的段上，它們就可以并發進行。
有些方法需要跨段，比如size()和containsValue()，它們可能需要鎖定整個表而而不僅僅是某個段，這需要按順序鎖定所有段，操作完畢后，又按順序釋放所有段的鎖。這里“按順序”是很重要的，否則極有可能出現死鎖，在ConcurrentHashMap內部，段數組是final的，并且其成員變量實際上也是final的，但是，僅僅是將數組聲明為final的并不保證數組成員也是final的，這需要實現上的保證。這可以確保不會出現死鎖，因為獲得鎖的順序是固定的。不變性在多線程編程占有很重要的地位，下面還要談到。
Java代碼??
不變(Immutable)和易變(Volatile)
ConcurrentHashMap完全允許多個讀操作并發進行，讀操作并不需要加鎖。如果使用傳統的技術，如HashMap中的實現，如果允許可以在hash鏈的中間添加或刪除元素，讀操作不加鎖將得到不一致的數據。ConcurrentHashMap實現技術是保證HashEntry幾乎是不可變的。HashEntry代表每個hash鏈中的一個節點，其結構如下所示：
Java代碼??
可以看到除了value不是final的，其它值都是final的，這意味著不能從hash鏈的中間或尾部添加或刪除節點，因為這需要修改next引用值，所有的節點的修改只能從頭部開始。對于put操作，可以一律添加到Hash鏈的頭部。但是對于remove操作，可能需要從中間刪除一個節點，這就需要將要刪除節點的前面所有節點整個復制一遍，最后一個節點指向要刪除結點的下一個結點。這在講解刪除操作時還會詳述。為了確保讀操作能夠看到最新的值，將value設置成volatile，這避免了加鎖。
其它
為了加快定位段以及段中hash槽的速度，每個段hash槽的的個數都是2^n，這使得通過位運算就可以定位段和段中hash槽的位置。當并發級別為默認值16時，也就是段的個數，hash值的高4位決定分配在哪個段中。但是我們也不要忘記《算法導論》給我們的教訓：hash槽的的個數不應該是2^n，這可能導致hash槽分配不均，這需要對hash值重新再hash一次。（這段似乎有點多余了?）
這是重新hash的算法，還比較復雜，我也懶得去理解了。
Java代碼??
?
這是定位段的方法：
Java代碼??
數據結構
?
關于Hash表的基礎數據結構，這里不想做過多的探討。Hash表的一個很重要方面就是如何解決hash沖突，ConcurrentHashMap和HashMap使用相同的方式，都是將hash值相同的節點放在一個hash鏈中。與HashMap不同的是，ConcurrentHashMap使用多個子Hash表，也就是段(Segment)。下面是ConcurrentHashMap的數據成員：
?
Java代碼??
?
所有的成員都是final的，其中segmentMask和segmentShift主要是為了定位段，參見上面的segmentFor方法。
每個Segment相當于一個子Hash表，它的數據成員如下：
?
Java代碼??
count用來統計該段數據的個數，它是volatile，它用來協調修改和讀取操作，以保證讀取操作能夠讀取到幾乎最新的修改。協調方式是這樣的，每次修改操作做了結構上的改變，如增加/刪除節點(修改節點的值不算結構上的改變)，都要寫count值，每次讀取操作開始都要讀取count的值。這利用了Java 5中對volatile語義的增強，對同一個volatile變量的寫和讀存在happens-before關系。modCount統計段結構改變的次數，主要是為了檢測對多個段進行遍歷過程中某個段是否發生改變，在講述跨段操作時會還會詳述。threashold用來表示需要進行rehash的界限值。table數組存儲段中節點，每個數組元素是個hash鏈，用HashEntry表示。table也是volatile，這使得能夠讀取到最新的table值而不需要同步。loadFactor表示負載因子。
實現細節
?
修改操作
?
先來看下刪除操作remove(key)。
Java代碼??
整個操作是先定位到段，然后委托給段的remove操作。當多個刪除操作并發進行時，只要它們所在的段不相同，它們就可以同時進行。下面是Segment的remove方法實現：
Java代碼??
?整個操作是在持有段鎖的情況下執行的，空白行之前的行主要是定位到要刪除的節點e。接下來，如果不存在這個節點就直接返回null，否則就要將e前面的結點復制一遍，尾結點指向e的下一個結點。e后面的結點不需要復制，它們可以重用。下面是個示意圖，我直接從這個網站?上復制的（畫這樣的圖實在是太麻煩了，如果哪位有好的畫圖工具，可以推薦一下）。
?
?
刪除元素之前：
?
?
?
刪除元素3之后：
?
第二個圖其實有點問題，復制的結點中應該是值為2的結點在前面，值為1的結點在后面，也就是剛好和原來結點順序相反，還好這不影響我們的討論。
?
整個remove實現并不復雜，但是需要注意如下幾點。第一，當要刪除的結點存在時，刪除的最后一步操作要將count的值減一。這必須是最后一步操作，否則讀取操作可能看不到之前對段所做的結構性修改。第二，remove執行的開始就將table賦給一個局部變量tab，這是因為table是volatile變量，讀寫volatile變量的開銷很大。編譯器也不能對volatile變量的讀寫做任何優化，直接多次訪問非volatile實例變量沒有多大影響，編譯器會做相應優化。
?
?
接下來看put操作，同樣地put操作也是委托給段的put方法。下面是段的put方法：
Java代碼??
該方法也是在持有段鎖的情況下執行的，首先判斷是否需要rehash，需要就先rehash。接著是找是否存在同樣一個key的結點，如果存在就直接替換這個結點的值。否則創建一個新的結點并添加到hash鏈的頭部，這時一定要修改modCount和count的值，同樣修改count的值一定要放在最后一步。put方法調用了rehash方法，reash方法實現得也很精巧，主要利用了table的大小為2^n，這里就不介紹了。
?
修改操作還有putAll和replace。putAll就是多次調用put方法，沒什么好說的。replace甚至不用做結構上的更改，實現要比put和delete要簡單得多，理解了put和delete，理解replace就不在話下了，這里也不介紹了。
?
?
獲取操作
?
首先看下get操作，同樣ConcurrentHashMap的get操作是直接委托給Segment的get方法，直接看Segment的get方法：
?
Java代碼??
?
get操作不需要鎖。第一步是訪問count變量，這是一個volatile變量，由于所有的修改操作在進行結構修改時都會在最后一步寫count變量，通過這種機制保證get操作能夠得到幾乎最新的結構更新。對于非結構更新，也就是結點值的改變，由于HashEntry的value變量是volatile的，也能保證讀取到最新的值。接下來就是對hash鏈進行遍歷找到要獲取的結點，如果沒有找到，直接訪回null。對hash鏈進行遍歷不需要加鎖的原因在于鏈指針next是final的。但是頭指針卻不是final的，這是通過getFirst(hash)方法返回，也就是存在table數組中的值。這使得getFirst(hash)可能返回過時的頭結點，例如，當執行get方法時，剛執行完getFirst(hash)之后，另一個線程執行了刪除操作并更新頭結點，這就導致get方法中返回的頭結點不是最新的。這是可以允許，通過對count變量的協調機制，get能讀取到幾乎最新的數據，雖然可能不是最新的。要得到最新的數據，只有采用完全的同步。
?
最后，如果找到了所求的結點，判斷它的值如果非空就直接返回，否則在有鎖的狀態下再讀一次。這似乎有些費解，理論上結點的值不可能為空，這是因為put的時候就進行了判斷，如果為空就要拋NullPointerException?？罩档奈ㄒ辉搭^就是HashEntry中的默認值，因為HashEntry中的value不是final的，非同步讀取有可能讀取到空值。仔細看下put操作的語句：tab[index] = new HashEntry<K,V>(key, hash, first, value)，在這條語句中，HashEntry構造函數中對value的賦值以及對tab[index]的賦值可能被重新排序，這就可能導致結點的值為空。這種情況應當很罕見，一旦發生這種情況，ConcurrentHashMap采取的方式是在持有鎖的情況下再讀一遍，這能夠保證讀到最新的值，并且一定不會為空值。
?
Java代碼??
?
?
另一個操作是containsKey，這個實現就要簡單得多了，因為它不需要讀取值：
Java代碼??
?
?
跨段操作?
?
有些操作需要涉及到多個段，比如說size(), containsValaue()。先來看下size()方法：
?
Java代碼??
?
size方法主要思路是先在沒有鎖的情況下對所有段大小求和，如果不能成功（這是因為遍歷過程中可能有其它線程正在對已經遍歷過的段進行結構性更新），最多執行RETRIES_BEFORE_LOCK次，如果還不成功就在持有所有段鎖的情況下再對所有段大小求和。在沒有鎖的情況下主要是利用Segment中的modCount進行檢測，在遍歷過程中保存每個Segment的modCount，遍歷完成之后再檢測每個Segment的modCount有沒有改變，如果有改變表示有其它線程正在對Segment進行結構性并發更新，需要重新計算。
?
?
其實這種方式是存在問題的，在第一個內層for循環中，在這兩條語句sum += segments[i].count; mcsum += mc[i] = segments[i].modCount;之間，其它線程可能正在對Segment進行結構性的修改，導致segments[i].count和segments[i].modCount讀取的數據并不一致。這可能使size()方法返回任何時候都不曾存在的大小，很奇怪javadoc居然沒有明確標出這一點，可能是因為這個時間窗口太小了吧。size()的實現還有一點需要注意，必須要先segments[i].count，才能segments[i].modCount，這是因為segment[i].count是對volatile變量的訪問，接下來segments[i].modCount才能得到幾乎最新的值（前面我已經說了為什么只是“幾乎”了）。這點在containsValue方法中得到了淋漓盡致的展現：
?
?
Java代碼??
?
同樣注意內層的第一個for循環，里面有語句int c = segments[i].count; 但是c卻從來沒有被使用過，即使如此，編譯器也不能做優化將這條語句去掉，因為存在對volatile變量count的讀取，這條語句存在的唯一目的就是保證segments[i].modCount讀取到幾乎最新的值。關于containsValue方法的其它部分就不分析了，它和size方法差不多。
?
?
跨段方法中還有一個isEmpty()方法，其實現比size()方法還要簡單，也不介紹了。最后簡單地介紹下迭代方法，如keySet(), values(), entrySet()方法，這些方法都返回相應的迭代器，所有迭代器都繼承于Hash_Iterator類(提交時居然提醒我不能包含sh It，只得加了下劃線)，里實現了主要的方法。其結構是：
?
Java代碼??
?
?nextSegmentIndex是段的索引，nextTableIndex是nextSegmentIndex對應段中中hash鏈的索引，currentTable是nextSegmentIndex對應段的table。調用next方法時主要是調用了advance方法：
?
?
Java代碼??
不想再多介紹了，唯一需要注意的是跳到下一個段時，一定要先讀取下一個段的count變量。?
?
這種迭代方式的主要效果是不會拋出ConcurrentModificationException。一旦獲取到下一個段的table，也就意味著這個段的頭結點在迭代過程中就確定了，在迭代過程中就不能反映對這個段節點并發的刪除和添加，對于節點的更新是能夠反映的，因為節點的值是一個volatile變量。
問數據庫，回答學的mysql，問有幾種引擎，回答有好幾種，主要就兩種
（1）：MyISAM存儲引擎
不支持事務、也不支持外鍵，優勢是訪問速度快，對事務完整性沒有 要求或者以select，insert為主的應用基本上可以用這個引擎來創建表
支持3種不同的存儲格式，分別是：靜態表；動態表；壓縮表
靜態表：表中的字段都是非變長字段，這樣每個記錄都是固定長度的，優點存儲非常迅速，容易緩存，出現故障容易恢復；缺點是占用的空間通常比動態表多（因為存儲時會按照列的寬度定義補足空格）ps：在取數據的時候，默認會把字段后面的空格去掉，如果不注意會把數據本身帶的空格也會忽略。
動態表：記錄不是固定長度的，這樣存儲的優點是占用的空間相對較少；缺點：頻繁的更新、刪除數據容易產生碎片，需要定期執行OPTIMIZE TABLE或者myisamchk-r命令來改善性能
壓縮表：因為每個記錄是被單獨壓縮的，所以只有非常小的訪問開支
（2）InnoDB存儲引擎*
該存儲引擎提供了具有提交、回滾和崩潰恢復能力的事務安全。但是對比MyISAM引擎，寫的處理效率會差一些，并且會占用更多的磁盤空間以保留數據和索引。?
InnoDB存儲引擎的特點：支持自動增長列，支持外鍵約束
(3)：MEMORY存儲引擎
Memory存儲引擎使用存在于內存中的內容來創建表。每個memory表只實際對應一個磁盤文件，格式是.frm。memory類型的表訪問非常的快，因為它的數據是放在內存中的，并且默認使用HASH索引，但是一旦服務關閉，表中的數據就會丟失掉。?
MEMORY存儲引擎的表可以選擇使用BTREE索引或者HASH索引，兩種不同類型的索引有其不同的使用范圍
Hash索引優點：?
Hash 索引結構的特殊性，其檢索效率非常高，索引的檢索可以一次定位，不像B-Tree 索引需要從根節點到枝節點，最后才能訪問到頁節點這樣多次的IO訪問，所以 Hash 索引的查詢效率要遠高于 B-Tree 索引。?
Hash索引缺點： 那么不精確查找呢，也很明顯，因為hash算法是基于等值計算的，所以對于“like”等范圍查找hash索引無效，不支持；
Memory類型的存儲引擎主要用于哪些內容變化不頻繁的代碼表，或者作為統計操作的中間結果表，便于高效地對中間結果進行分析并得到最終的統計結果，。對存儲引擎為memory的表進行更新操作要謹慎，因為數據并沒有實際寫入到磁盤中，所以一定要對下次重新啟動服務后如何獲得這些修改后的數據有所考慮。
（4）MERGE存儲引擎
?
Merge存儲引擎是一組MyISAM表的組合，這些MyISAM表必須結構完全相同，merge表本身并沒有數據，對merge類型的表可以進行查詢，更新，刪除操作，這些操作實際上是對內部的MyISAM表進行的。
索引有了解嗎
mysql索引需要了解的幾個注意
板子之前做過2年web開發培訓（入門？），獲得挺多學生好評，這是蠻有成就感的一件事，準備花點時間根據當時的一些備課內容整理出一系列文章出來，希望能給更多人帶來幫助，這是系列文章的第一篇
注：科普文章一篇，大牛繞道
索引是做什么的?
索引用于快速找出在某個列中有一特定值的行。不使用索引，MySQL必須從第1條記錄開始然后讀完整個表直到找出相關的行。
表越大，花費的時間越多。如果表中查詢的列有一個索引，MySQL能快速到達一個位置去搜尋到數據文件的中間，沒有必要看所有數據。
大多數MySQL索引(PRIMARY KEY、UNIQUE、INDEX和FULLTEXT)在B樹中存儲。只是空間列類型的索引使用R-樹，并且MEMORY表還支持hash索引。
索引好復雜，我該怎么理解索引，有沒一個更形象點的例子？
有，想象一下，你面前有本詞典，數據就是書的正文內容，你就是那個cpu，而索引，則是書的目錄
索引越多越好？
大多數情況下索引能大幅度提高查詢效率，但：
- 數據的變更（增刪改）都需要維護索引，因此更多的索引意味著更多的維護成本
- 更多的索引意味著也需要更多的空間?（一本100頁的書，卻有50頁目錄？）
- 過小的表，建索引可能會更慢哦 ：）? （讀個2頁的宣傳手冊，你還先去找目錄？）
索引的字段類型問題
- text類型，也可建索引（需指定長度）
- myisam存儲引擎索引鍵長度綜合不能超過1000字節
- 用來篩選的值盡量保持和索引列同樣的數據類型
?like 不能用索引？
- 盡量減少like，但不是絕對不可用，”xxxx%” 是可以用到索引的，
想象一下，你在看一本成語詞典，目錄是按成語拼音順序建立，查詢需求是，你想找以 “一”字開頭的成語（”一%“），和你想找包含一字的成語（“%一%”）
- 除了like，以下操作符也可用到索引：
<，<=，=，>，>=，BETWEEN，IN
<>，not in ，！=則不行
什么樣的字段不適合建索引？
- 一般來說，列的值唯一性太小（如性別，類型什么的），不適合建索引（怎樣叫太小？一半說來，同值的數據超過表的百分之15，那就沒必要建索引了）
- 太長的列，可以選擇只建立部分索引，（如：只取前十位做索引）
- 更新非常頻繁的數據不適宜建索引（怎樣叫非常？意會）
?一次查詢能用多個索引嗎?
不能
多列查詢該如何建索引?
一次查詢只能用到一個索引，所以 首先槍斃 a，b各建索引方案
a還是b？ 誰的區分度更高（同值的最少），建誰！
當然，聯合索引也是個不錯的方案，ab，還是ba，則同上，區分度高者，在前
聯合索引的問題?
where a = “xxx” 可以使用 AB 聯合索引
where b = “xxx” 則不可 （再想象一下，這是書的目錄？）
所以，大多數情況下，有AB索引了，就可以不用在去建一個A索引了
哪些常見情況不能用索引?
- like “%xxx”
- not in ， ！=
- 對列進行函數運算的情況（如 where md5(password) = “xxxx”）
- WHERE index=1 OR A=10
- 存了數值的字符串類型字段（如手機號），查詢時記得不要丟掉值的引號，否則無法用到該字段相關索引，反之則沒關系
也即
select * from test where mobile = 13711112222;
可是無法用到mobile字段的索引的哦（如果mobile是char 或 varchar類型的話）
btw，千萬不要嘗試用int來存手機號（為什么？自己想！要不自己試試）
?
覆蓋索引(Covering Indexes)擁有更高效率
索引包含了所需的全部值的話，就只select 他們，換言之，只select 需要用到的字段，如無必要，可盡量避免select *
NULL 的問題
NULL會導致索引形同虛設，所以在設計表結構時應避免NULL 的存在（用其他方式表達你想表達的NULL，比如 -1？）
如何查看索引信息，如何分析是否正確用到索引?
show index from tablename;
explain select ……;
關于explain，改天可以找個時間專門寫一篇入門帖，在此之前，可以嘗試 google
了解自己的系統，不要過早優化!
過早優化，一直是個非常討厭而又時刻存在的問題，大多數時候就是因為不了解自己的系統，不知道自己系統真正的承載能力
比如：幾千條數據的新聞表，每天幾百幾千次的正文搜索，大多數時候我們可以放心的去like，而不要又去建一套全文搜索什么的，畢竟cpu還是比人腦厲害太多
分享個小案例：
曾經有個朋友找板子，說：大師幫看看，公司網站打不開
板子笑了笑：大師可不敢當啊，待我看看再說
板子花了10分鐘分析了下：中小型企業站，量不大（兩三萬pv每天），獨立服務器，數據量不大（100M不到），應該不至于太慢
某個外包團隊做的項目，年久失修，徹底改造？不現實！
于是，板子花了20分鐘給可以加索引的字段都加上了索引，于是，世界安靜了
朋友說：另外一個哥們說，優化至少得2w外包費，你只用30分鐘，看來，大師你是當之無愧了，選個最好的餐館吧
板子：那就來點西餐吧，常熟路地鐵站肯德基等你！
數據庫的三大范式
第一范式
? ?1、每一列屬性都是不可再分的屬性值，確保每一列的原子性
?
? ?2、兩列的屬性相近或相似或一樣，盡量合并屬性一樣的列，確保不產生冗余數據。
?
?
?
如果需求知道那個省那個市并按其分類，那么顯然第一個表格是不容易滿足需求的，也不符合第一范式。
?
?
?
顯然第一個表結構不但不能滿足足夠多物品的要求，還會在物品少時產生冗余。也是不符合第一范式的。
?
第二范式
?
每一行的數據只能與其中一列相關，即一行數據只做一件事。只要數據列中出現數據重復，就要把表拆分開來。
?
?
一個人同時訂幾個房間，就會出來一個訂單號多條數據，這樣子聯系人都是重復的，就會造成數據冗余。我們應該把他拆開來。
?
?
?
?
?
這樣便實現啦一條數據做一件事，不摻雜復雜的關系邏輯。同時對表數據的更新維護也更易操作。
?
第三范式
?數據不能存在傳遞關系，即沒個屬性都跟主鍵有直接關系而不是間接關系。像：a-->b-->c ?屬性之間含有這樣的關系，是不符合第三范式的。
比如Student表（學號，姓名，年齡，性別，所在院校，院校地址，院校電話）
這樣一個表結構，就存在上述關系。 學號-->?所在院校 --> (院校地址，院校電話)
這樣的表結構，我們應該拆開來，如下。
（學號，姓名，年齡，性別，所在院校）--（所在院校，院校地址，院校電話）
?
最后：
三大范式只是一般設計數據庫的基本理念，可以建立冗余較小、結構合理的數據庫。如果有特殊情況，當然要特殊對待，數據庫設計最重要的是看需求跟性能，需求>性能>表結構。所以不能一味的去追求范式建立數據庫。
線程可以簡單講講嗎，然后問線程和線程之間如何進行通信
一，介紹
本總結我對于JAVA多線程中線程之間的通信方式的理解，主要以代碼結合文字的方式來討論線程間的通信，故摘抄了書中的一些示例代碼。
?
二，線程間的通信方式
①同步
這里講的同步是指多個線程通過synchronized關鍵字這種方式來實現線程間的通信。
參考示例：
public class MyObject {synchronized public void methodA() {//do something....}synchronized public void methodB() {//do some other thing} }public class ThreadA extends Thread {private MyObject object; //省略構造方法@Overridepublic void run() {super.run();object.methodA();} }public class ThreadB extends Thread {private MyObject object; //省略構造方法@Overridepublic void run() {super.run();object.methodB();} }public class Run {public static void main(String[] args) {MyObject object = new MyObject();//線程A與線程B 持有的是同一個對象:objectThreadA a = new ThreadA(object);ThreadB b = new ThreadB(object);a.start();b.start();} }由于線程A和線程B持有同一個MyObject類的對象object，盡管這兩個線程需要調用不同的方法，但是它們是同步執行的，比如：線程B需要等待線程A執行完了methodA()方法之后，它才能執行methodB()方法。這樣，線程A和線程B就實現了 通信。
這種方式，本質上就是“共享內存”式的通信。多個線程需要訪問同一個共享變量，誰拿到了鎖（獲得了訪問權限），誰就可以執行。
?
②while輪詢的方式
代碼如下：
1 import java.util.ArrayList;2 import java.util.List;3 4 public class MyList {5 6 private List<String> list = new ArrayList<String>();7 public void add() {8 list.add("elements");9 } 10 public int size() { 11 return list.size(); 12 } 13 } 14 15 import mylist.MyList; 16 17 public class ThreadA extends Thread { 18 19 private MyList list; 20 21 public ThreadA(MyList list) { 22 super(); 23 this.list = list; 24 } 25 26 @Override 27 public void run() { 28 try { 29 for (int i = 0; i < 10; i++) { 30 list.add(); 31 System.out.println("添加了" + (i + 1) + "個元素"); 32 Thread.sleep(1000); 33 } 34 } catch (InterruptedException e) { 35 e.printStackTrace(); 36 } 37 } 38 } 39 40 import mylist.MyList; 41 42 public class ThreadB extends Thread { 43 44 private MyList list; 45 46 public ThreadB(MyList list) { 47 super(); 48 this.list = list; 49 } 50 51 @Override 52 public void run() { 53 try { 54 while (true) { 55 if (list.size() == 5) { 56 System.out.println("==5, 線程b準備退出了"); 57 throw new InterruptedException(); 58 } 59 } 60 } catch (InterruptedException e) { 61 e.printStackTrace(); 62 } 63 } 64 } 65 66 import mylist.MyList; 67 import extthread.ThreadA; 68 import extthread.ThreadB; 69 70 public class Test { 71 72 public static void main(String[] args) { 73 MyList service = new MyList(); 74 75 ThreadA a = new ThreadA(service); 76 a.setName("A"); 77 a.start(); 78 79 ThreadB b = new ThreadB(service); 80 b.setName("B"); 81 b.start(); 82 } 83 }在這種方式下，線程A不斷地改變條件，線程ThreadB不停地通過while語句檢測這個條件(list.size()==5)是否成立 ，從而實現了線程間的通信。但是這種方式會浪費CPU資源。之所以說它浪費資源，是因為JVM調度器將CPU交給線程B執行時，它沒做啥“有用”的工作，只是在不斷地測試 某個條件是否成立。就類似于現實生活中，某個人一直看著手機屏幕是否有電話來了，而不是： 在干別的事情，當有電話來時，響鈴通知TA電話來了。關于線程的輪詢的影響，可參考：JAVA多線程之當一個線程在執行死循環時會影響另外一個線程嗎？
這種方式還存在另外一個問題：
輪詢的條件的可見性問題，關于內存可見性問題，可參考：JAVA多線程之volatile 與 synchronized 的比較中的第一點“一，volatile關鍵字的可見性”
線程都是先把變量讀取到本地線程?？臻g，然后再去再去修改的本地變量。因此，如果線程B每次都在取本地的 條件變量，那么盡管另外一個線程已經改變了輪詢的條件，它也察覺不到，這樣也會造成死循環。
?
③wait/notify機制
代碼如下：
1 import java.util.ArrayList;2 import java.util.List;3 4 public class MyList {5 6 private static List<String> list = new ArrayList<String>();7 8 public static void add() {9 list.add("anyString"); 10 } 11 12 public static int size() { 13 return list.size(); 14 } 15 } 16 17 18 public class ThreadA extends Thread { 19 20 private Object lock; 21 22 public ThreadA(Object lock) { 23 super(); 24 this.lock = lock; 25 } 26 27 @Override 28 public void run() { 29 try { 30 synchronized (lock) { 31 if (MyList.size() != 5) { 32 System.out.println("wait begin " 33 + System.currentTimeMillis()); 34 lock.wait(); 35 System.out.println("wait end " 36 + System.currentTimeMillis()); 37 } 38 } 39 } catch (InterruptedException e) { 40 e.printStackTrace(); 41 } 42 } 43 } 44 45 46 public class ThreadB extends Thread { 47 private Object lock; 48 49 public ThreadB(Object lock) { 50 super(); 51 this.lock = lock; 52 } 53 54 @Override 55 public void run() { 56 try { 57 synchronized (lock) { 58 for (int i = 0; i < 10; i++) { 59 MyList.add(); 60 if (MyList.size() == 5) { 61 lock.notify(); 62 System.out.println("已經發出了通知"); 63 } 64 System.out.println("添加了" + (i + 1) + "個元素!"); 65 Thread.sleep(1000); 66 } 67 } 68 } catch (InterruptedException e) { 69 e.printStackTrace(); 70 } 71 } 72 } 73 74 public class Run { 75 76 public static void main(String[] args) { 77 78 try { 79 Object lock = new Object(); 80 81 ThreadA a = new ThreadA(lock); 82 a.start(); 83 84 Thread.sleep(50); 85 86 ThreadB b = new ThreadB(lock); 87 b.start(); 88 } catch (InterruptedException e) { 89 e.printStackTrace(); 90 } 91 } 92 }線程A要等待某個條件滿足時(list.size()==5)，才執行操作。線程B則向list中添加元素，改變list 的size。
A,B之間如何通信的呢？也就是說，線程A如何知道 list.size() 已經為5了呢？
這里用到了Object類的 wait() 和 notify() 方法。
當條件未滿足時(list.size() !=5)，線程A調用wait() 放棄CPU，并進入阻塞狀態。---不像②while輪詢那樣占用CPU
當條件滿足時，線程B調用 notify()通知 線程A，所謂通知線程A，就是喚醒線程A，并讓它進入可運行狀態。
這種方式的一個好處就是CPU的利用率提高了。
但是也有一些缺點：比如，線程B先執行，一下子添加了5個元素并調用了notify()發送了通知，而此時線程A還執行；當線程A執行并調用wait()時，那它永遠就不可能被喚醒了。因為，線程B已經發了通知了，以后不再發通知了。這說明：通知過早，會打亂程序的執行邏輯。
?
④管道通信就是使用java.io.PipedInputStream 和 java.io.PipedOutputStream進行通信
具體就不介紹了。分布式系統中說的兩種通信機制：共享內存機制和消息通信機制。感覺前面的①中的synchronized關鍵字和②中的while輪詢 “屬于” 共享內存機制，由于是輪詢的條件使用了volatile關鍵字修飾時，這就表示它們通過判斷這個“共享的條件變量“是否改變了，來實現進程間的交流。
而管道通信，更像消息傳遞機制，也就是說：通過管道，將一個線程中的消息發送給另一個。
JVM了解多少，把自己知道的都說了，不過他沒問細節
轉載于:https://www.cnblogs.com/strawqqhat/p/10602226.html
總結
以上是生活随笔為你收集整理的CVTE Java后台电话一面的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 李开复致中国大学生父母的一封信
- 下一篇： 中科院，量子计算机,中科院传来喜讯，中国