ThreadLocal(線程變數(shù)副本)

Synchronized實(shí)作記憶體共享，ThreadLocal為每個執(zhí)行緒維護(hù)一個本地變數(shù)。
採用空間換時間，它用於執(zhí)行緒間的資料隔離，為每一個使用該變數(shù)的執(zhí)行緒提供一個副本，每個執(zhí)行緒都可以獨(dú)立地改變自己的副本，而不會和其他執(zhí)行緒的副本衝突。
ThreadLocal類別中維護(hù)一個Map，用於儲存每個線程的變數(shù)副本，Map中元素的鍵為線程對象，而值為對應(yīng)線程的變數(shù)副本。
ThreadLocal在Spring中發(fā)揮著巨大的作用，在管理Request作用域中的Bean、事務(wù)管理、任務(wù)調(diào)度、AOP等模組都出現(xiàn)了它的身影。
Spring中絕大部分Bean都可以聲明成Singleton作用域，採用ThreadLocal進(jìn)行封裝，因此有狀態(tài)的Bean就能夠以singleton的方式在多線程中正常工作了。

Java虛擬機(jī)器規(guī)格中將Java執(zhí)行時間資料分為六種。
1.程式計(jì)數(shù)器：是一個資料結(jié)構(gòu)，用來保存目前正常執(zhí)行的程式的記憶體位址。 Java虛擬機(jī)的多執(zhí)行緒就是透過執(zhí)行緒輪流切換並分配處理器時間來實(shí)現(xiàn)的，為了執(zhí)行緒切換後能恢復(fù)到正確的位置，每個執(zhí)行緒都需要一個獨(dú)立的程式計(jì)數(shù)器，互不影響，該區(qū)域?yàn)椤熬€程私有」。
2.Java虛擬機(jī)棧：執(zhí)行緒私有的，與執(zhí)行緒生命週期相同，用於儲存局部變數(shù)表，操作棧，方法傳回值。局部變數(shù)表放著基本資料型別，還有物件的參考。
3.本地方法堆疊：跟虛擬機(jī)器堆疊很像，不過它是為虛擬機(jī)器使用到的Native方法服務(wù)。
4.Java堆：所有執(zhí)行緒共享的一塊記憶體區(qū)域，物件實(shí)例幾乎都在這裡分配記憶體。
5.方法區(qū)：各個執(zhí)行緒共享的區(qū)域，儲存虛擬機(jī)器載入的類別信息，常數(shù)，靜態(tài)變量，編譯後的程式碼。
6.運(yùn)行時常數(shù)池：代表運(yùn)行時每個class檔案中的常數(shù)量表。包括幾種常數(shù)：編譯時的數(shù)字常數(shù)、方法或域的引用。

「你能不能談?wù)?，java GC是在什麼時候，對什麼東西，做了什麼事情？」
在什麼時候：
1.新生代有一個Eden區(qū)和兩個survivor區(qū)，先將物件放入Eden區(qū)，如果空間不足就向其中的一個survivor區(qū)上放，如果仍然放不下就會引發(fā)一次發(fā)生在新生代的minor GC，將存活的對象放入另一個survivor區(qū)中，然後清空Eden和之前的那個survivor區(qū)的記憶體。在某次GC過程中，如果發(fā)現(xiàn)仍然又放不下的對象，就將這些對象放入老年代記憶體裡去。
2.大對像以及長期存活的對象直接進(jìn)入老年區(qū)。
3.當(dāng)每次執(zhí)行minor GC的時候應(yīng)該對要晉升到老年代的對象進(jìn)行分析，如果這些馬上要到老年區(qū)的老年對象的大小超過了老年區(qū)的剩餘大小，那麼執(zhí)行一次Full GC以盡可能獲得老年區(qū)的空間。
對什麼東西：從GC Roots搜尋不到，而且經(jīng)過一次標(biāo)記清理之後仍沒有復(fù)活的對象。
做什麼： 新生代：複製清理；老年代：標(biāo)記-清除和標(biāo)記-壓縮演算法； 永久代：存放Java中的類別和載入類別的類別載入器本身。
GC Roots都有哪些： 1. 虛擬機(jī)棧中的引用的對象2. 方法區(qū)中靜態(tài)屬性引用的對象，常數(shù)引用的對象3. 本地方法棧中JNI（即一般說的Native方法）引用的對象。

Synchronized 與Lock都是可重入鎖，同一個執(zhí)行緒再次進(jìn)入同步程式碼的時候.可以使用自己已經(jīng)取得到的鎖。
Synchronized是悲觀鎖定機(jī)制，獨(dú)佔(zhàn)鎖。而Locks.ReentrantLock是，每次不加鎖而是假設(shè)沒有衝突而去完成某項(xiàng)操作，如果因?yàn)樾n突失敗就重試，直到成功為止。 ReentrantLock適用場景

1. 某個執(zhí)行緒在等待一個鎖的控制權(quán)的這段時間需要中斷

2. 需要分開處理一些wait-notify ，ReentrantLock裡面的Condition應(yīng)用，能夠控制notify哪個線程，鎖可以綁定多個條件。

3. 具有公平鎖定功能，每個到來的執(zhí)行緒都會排隊(duì)等候。

StringBuffer是線程安全的，每次操作字串，String會產(chǎn)生一個新的對象，而StringBuffer不會；StringBuilder是非線程安全的

fail- fast：機(jī)制是java集合(Collection)中的一種錯誤機(jī)制。當(dāng)多個執(zhí)行緒對同一個集合的內(nèi)容進(jìn)行操作時，就可能會產(chǎn)生fail-fast事件。
例如：當(dāng)某一個執(zhí)行緒A透過iterator去遍歷某集合的過程中，若該集合的內(nèi)容被其他執(zhí)行緒改變了；那麼執(zhí)行緒A存取集合時，就會拋出ConcurrentModificationException異常，產(chǎn)生fail-fast事件

happens-before:如果兩個操作之間有happens-before 關(guān)係，那麼前一個操作的結(jié)果就會對後面一個操作可見。
1.程式順序規(guī)則：一個執(zhí)行緒中的每個操作，happens- before 於該執(zhí)行緒中的任意後續(xù)操作。
2.監(jiān)視器鎖規(guī)則：對一個監(jiān)視器鎖的解鎖，happens- before 於隨後對這個監(jiān)視器鎖的加鎖。
3.volatile變數(shù)規(guī)則：對一個volatile域的寫，happens- before於任意後續(xù)對這個volatile域的讀。
4.傳遞性：如果A happens- before B，且B happens- before C，那麼A happens- before C。
5.線程啟動規(guī)則：Thread物件的start()方法happens- before於此線程的每一個動作。

Volatile和Synchronized四個不同點(diǎn)：
1 粒度不同，前者針對變量，後者鎖定物件和類別
2 syn阻塞，volatile線程不阻塞
3 syn保證三大特性，volatile不保證原子性
4 syn編譯器優(yōu)化，volatile不優(yōu)化volatile具備兩種特性：

1.保證此變數(shù)對所有執(zhí)行緒的可見性，指一條執(zhí)行緒修改了這個變數(shù)的值，新值對於其他執(zhí)行緒來說是可見的，但並不是多執(zhí)行緒安全的。
2.禁止指令重新排序最佳化。

Volatile如何保證記憶體可見性:

1.當(dāng)寫一個volatile變數(shù)時，JMM會把該執(zhí)行緒對應(yīng)的本地記憶體中的共享變數(shù)刷新到主內(nèi)存。
2.當(dāng)讀取一個volatile變數(shù)時，JMM會把該執(zhí)行緒對應(yīng)的本地記憶體置為無效。線程接下來將從主記憶體中讀取共享變數(shù)。

同步：就是一個任務(wù)的完成需要依賴另一個任務(wù)，只有等待被依賴的任務(wù)完成後，依賴任務(wù)才能完成。
非同步：不需要等待被依賴的任務(wù)完成，只是通知被依賴的任務(wù)要完成什麼工作，只要自己任務(wù)完成了就算完成了，被依賴的任務(wù)是否完成會通知回來。 （非同步的特點(diǎn)就是通知）。打電話和發(fā)短信來比喻同步和非同步操作。
阻塞：CPU停下來等一個慢的操作完成以後，才會接著完成其他的工作。
非阻塞：非阻塞就是在這個慢的執(zhí)行時，CPU去做其他工作，等這個慢的完成後，CPU才會接著完成後續(xù)的操作。
非阻塞會造成執(zhí)行緒切換增加，增加CPU的使用時間能不能補(bǔ)償系統(tǒng)的切換成本需要考慮。

CAS（Compare And Swap） 無鎖定演算法： CAS是樂觀鎖技術(shù)，當(dāng)多個執(zhí)行緒嘗試使用CAS同時更新同一個變數(shù)時，只有其中一個執(zhí)行緒能更新變數(shù)的值，而其它線程都失敗，失敗的線程並不會被掛起，而是被告知這次競爭中失敗，並且可以再次嘗試。 CAS有3個運(yùn)算元，記憶體值V，舊的預(yù)期值A(chǔ)，要修改的新值B。當(dāng)且僅當(dāng)預(yù)期值A(chǔ)和記憶體值V相同時，將記憶體值V修改為B，否則什麼都不做。

執(zhí)行緒池的作用： 在程式啟動的時候就建立若干執(zhí)行緒來回應(yīng)處理，它們稱為執(zhí)行緒池，裡面的執(zhí)行緒叫做工作執(zhí)行緒
第一：降低資源消耗。透過重複利用已建立的執(zhí)行緒來降低執(zhí)行緒建立和銷毀造成的消耗。
第二：提高反應(yīng)速度。當(dāng)任務(wù)到達(dá)時，任務(wù)可以不需要等到執(zhí)行緒建立就能立即執(zhí)行。
第三：提高執(zhí)行緒的可管理性。
常用執(zhí)行緒池：ExecutorService 是主要的實(shí)作類，其中常用的有 Executors.newSingleThreadPool(),newFixedThreadPool(),newcachedTheadPool(),newScheduledThreadPool()。

類別載入器工作機(jī)制：
1.裝載：將Java二進(jìn)位程式碼匯入jvm中，產(chǎn)生Class檔案。
2.連接：a）校驗(yàn)：檢查載入Class檔案資料的正確性b）準(zhǔn)備：給類別的靜態(tài)變數(shù)分配儲存空間c）解析：將符號引用轉(zhuǎn)成直接引用
3：初始化：對類別的靜態(tài)變數(shù)，靜態(tài)方法和靜態(tài)程式碼區(qū)塊執(zhí)行初始化工作。
雙親委派模型：類別載入器收到類別載入請求，首先將請求委派給父類別載入器完成使用者自訂載入器->應(yīng)用程式載入器->擴(kuò)充類別載入器->啟動類加載器。

一致性雜湊：
Memcahed快?。?br>資料結(jié)構(gòu)：key,value對
使用方法：get,put等方法

Redis資料結(jié)構(gòu): String—字串（key-value 類型）
Hash—字典(hashmap) Redis的雜湊結(jié)構(gòu)可以讓你像在資料庫中更新一個屬性一樣只修改某一項(xiàng)屬性值
List —列表實(shí)現(xiàn)訊息佇列
Set—集合利用唯一性
Sorted Set—有序集合可以進(jìn)行排序可以實(shí)現(xiàn)資料持久化

java自動裝箱拆箱深入剖析
談?wù)凧ava反射機(jī)制
如何寫一個不可變類別？

索引：B ，B-,全文索引
Mysql的索引是一個資料結(jié)構(gòu)，旨在使資料庫高效的查找資料。
常用的資料結(jié)構(gòu)是B Tree，每個葉子節(jié)點(diǎn)不但存放了索引鍵的相關(guān)資訊還增加了指向相鄰葉子節(jié)點(diǎn)的指針，這樣就形成了帶有順序訪問指針的B Tree，做這個優(yōu)化的目的是提高不同區(qū)間存取的效能。
什麼時候使用索引：

1. 經(jīng)常出現(xiàn)在group by,order by和distinc關(guān)鍵字後面的欄位

2. 經(jīng)常與其他表進(jìn)行連接的表，在連接字段上應(yīng)該建立索引

3. 經(jīng)常出現(xiàn)在Where子句中的字段

4. 經(jīng)常出現(xiàn)用作查詢選擇的欄??位

Spring IOC （控制反轉(zhuǎn)，依賴注入）
Spring支援三種依賴注入方式，分別是屬性（Setter方法）注入，建構(gòu)注入和介面注入。
在Spring中，那些組成應(yīng)用的主體及由Spring IOC容器所管理的物件被稱之為Bean。
Spring的IOC容器透過反射的機(jī)制實(shí)例化Bean並建立Bean之間的依賴關(guān)係。
簡單地講，Bean就是由Spring IOC容器初始化、組裝及被管理的物件。
取得Bean物件的過程，先透過Resource載入設(shè)定檔並啟動IOC容器，然後透過getBean方法取得bean對象，就可以呼叫他的方法。
Spring Bean的作用域：
Singleton：Spring IOC容器中只有一個共享的Bean實(shí)例，一般都是Singleton作用域。
Prototype：每一個請求，都會產(chǎn)生一個新的Bean實(shí)例。
Request：每次http請求都會產(chǎn)生一個新的Bean實(shí)例。

代理程式的共同優(yōu)點(diǎn)：業(yè)務(wù)類別只需要專注於業(yè)務(wù)邏輯本身，並保證了業(yè)務(wù)類別的重複使用性。
Java靜態(tài)代理：
代理物件和目標(biāo)物件實(shí)作了相同的接口，目標(biāo)物件作為代理物件的屬性，具體介面實(shí)作中，代理物件可以在呼叫目標(biāo)物件對應(yīng)方法前後加上其他業(yè)務(wù)處理邏輯。
缺點(diǎn)：一個代理類別只能代理一個業(yè)務(wù)類別。如果業(yè)務(wù)類別增加方法時，對應(yīng)的代理類別也要增加方法。
Java動態(tài)代理：
Java動態(tài)代理是寫一個類別實(shí)作InvocationHandler接口，重寫Invoke方法，在Invoke方法可以進(jìn)行增強(qiáng)處理的邏輯的編寫，這個公共代理類別在運(yùn)行的時候才能明確自己要代理的對象，同時可以實(shí)現(xiàn)該被代理類別的方法的實(shí)現(xiàn)，然後在實(shí)現(xiàn)類別方法的時候可以進(jìn)行增強(qiáng)處理。
實(shí)際上：代理物件的方法= 增強(qiáng)處理被代理物件的方法

JDK和CGLIB產(chǎn)生動態(tài)代理類別的區(qū)別：
JDK動態(tài)代理只能針對實(shí)作了介面的類別產(chǎn)生代理（實(shí)例化一個類別）。此時代理對象和目標(biāo)對象實(shí)現(xiàn)了相同的接口，目標(biāo)對像作為代理對象的一個屬性，具體接口實(shí)現(xiàn)中，可以在調(diào)用目標(biāo)對象相應(yīng)方法前後加上其他業(yè)務(wù)處理邏輯
CGLIB是針對類實(shí)現(xiàn)代理，主要是對指定的類別產(chǎn)生一個子類別（沒有實(shí)例化一個類別），覆蓋其中的方法。
Spring AOP應(yīng)用場景
效能偵測，存取控制，日誌管理，交易等。
預(yù)設(shè)的策略是如果目標(biāo)類別實(shí)作接口，則使用JDK動態(tài)代理技術(shù)，如果目標(biāo)物件沒有實(shí)作接口，則預(yù)設(shè)會採用CGLIB代理

SpringMVC運(yùn)作原理

1. #客戶端請求提交到DispatcherServlet

2. 由DispatcherServlet控制器查詢HandlerMapping，找到並分發(fā)到指定的Controller。

3. Controller呼叫業(yè)務(wù)邏輯處理後，傳回ModelAndView

4. #DispatcherServlet查詢一個或多個ViewResoler視圖解析器，找到ModelAndView指定的視圖

5. 視圖負(fù)責(zé)將結(jié)果顯示到客戶端

一個Http請求
DNS網(wǎng)域解析–> 發(fā)起TCP的三次握手–> ; 建立TCP連線後發(fā)起http請求–> 伺服器回應(yīng)http請求，瀏覽器得到 html程式碼–>瀏覽器解析html程式碼，並請求html程式碼中的資源（如javascript、css、圖片等） –>瀏覽器對頁面進(jìn)行渲染呈現(xiàn)給使用者

設(shè)計(jì)儲存海量資料的儲存系統(tǒng)：設(shè)計(jì)一個叫做「中間層」的一個邏輯層，在這個層，將資料庫的海量資料抓出來，做成緩存，運(yùn)行在伺服器的記憶體中，同理，當(dāng)有新的資料到來，也先做成緩存，再想辦法，持久化到資料庫中，這是一個簡單的思路。主要的步驟是負(fù)載平衡，將不同使用者的請求分發(fā)到不同的處理節(jié)點(diǎn)上，然後先存入緩存，定時向主資料庫更新資料。讀寫的過程採用類似樂觀鎖的機(jī)制，可以一直讀（寫資料的時候也可以），但是每次讀的時候會有個版本的標(biāo)記，如果本次讀的版本低於快取的版本，會重新讀數(shù)據(jù)，這樣的情況不多，可以忍受。

Session與Cookie：Cookie可以讓服務(wù)端追蹤每個客戶端的訪問，但是每次客戶端的訪問都必須傳回這些Cookie，如果Cookie很多，則無形的增加了客戶端與服務(wù)端的資料傳輸量，
而Session則很好地解決了這個問題，同一個客戶端每次和服務(wù)端交互時，將資料存儲通過Session到服務(wù)端，不需要每次都傳回所有的Cookie值，而是傳回一個ID，每個客戶端第一次存取伺服器產(chǎn)生的唯一的ID，客戶端只要傳回這個ID就行了，這個ID通常為NAME為JSESSIONID的一個Cookie。這樣服務(wù)端就可以透過這個ID，來將儲存到服務(wù)端的KV值取出了。
Session和Cookie的逾時問題，Cookie的安全性問題

分散式Session框架

1. 配置伺服器，Zookeeper叢集管理伺服器可以統(tǒng)一管理所有伺服器的配置檔案

2. 共享這些Session儲存在一個分散式快取中，可以隨時寫入和讀取，而且效能要很好，如Memcache，Tair。

3. 封裝一個類別繼承自HttpSession，將Session存入這個類別然後再存入分散式快取中

4. 由於Cookie不能跨域訪問，要實(shí)現(xiàn)Session同步，要同步SessionID寫到不同網(wǎng)域下。

適配器模式：將一個介面適配器到另一個接口，Java I/O中InputStreamReader將Reader類別轉(zhuǎn)接到InputStream，從而實(shí)現(xiàn)了位元組流到字元流的準(zhǔn)換。
裝飾者模式：保持原來的接口，增強(qiáng)原來有的功能。
FileInputStream 實(shí)作了InputStream的所有接口，BufferedInputStreams繼承自FileInputStream是具體的裝??飾器實(shí)作者，將InputStream讀取的內(nèi)容保存在記憶體中，而提高讀取的效能。

Spring事務(wù)配置方法：
1.切點(diǎn)信息，用於定位實(shí)施事物切面的業(yè)務(wù)類方法
2.控制事務(wù)行為的事務(wù)屬性，這些屬性包括事物隔離級別，事務(wù)傳播行為，超時時間，回滾規(guī)則。

Spring透過aop/tx Schema 命名空間和@Transaction註解技術(shù)來進(jìn)行宣告式事物配置。

Mybatis
每一個Mybatis的應(yīng)用程式都以一個SqlSessionFactory物件的實(shí)例為核心。首先用位元組流透過Resource將設(shè)定檔讀入，然後透過SqlSessionFactoryBuilder().build方法建立SqlSessionFactory，然後透過SqlSessionFactory.openSession()方法建立一個SqlSession為每個資料庫事務(wù)服務(wù)。
經(jīng)歷了Mybatis初始化–>創(chuàng)建SqlSession –>運(yùn)行SQL語句，返回結(jié)果三個過程

Servlet和Filter的區(qū)別：
整的流程是：Filter對用戶請求進(jìn)行預(yù)處理，接著將請求交給Servlet進(jìn)行處理並產(chǎn)生回應(yīng)，最後Filter再對伺服器回應(yīng)進(jìn)行後處理。

Filter有以下幾個用途：
Filter可以進(jìn)行對特定的url請求和相應(yīng)做預(yù)處理和後處理。
在HttpServletRequest到達(dá)Servlet之前，攔截客戶的HttpServletRequest。
根據(jù)需要檢查HttpServletRequest，也可以修改HttpServletRequest頭和資料。
在HttpServletResponse到達(dá)客戶端之前，攔截HttpServletResponse。
根據(jù)需要檢查HttpServletResponse，也可以修改HttpServletResponse頭和資料。

其實(shí)Filter和Servlet極為相似，差別只是Filter不能直接對使用者產(chǎn)生回應(yīng)。實(shí)際上Filter裡doFilter()方法裡的程式碼就是從多個Servlet的service()方法裡抽取的通用程式碼，透過使用Filter可以實(shí)現(xiàn)更好的複用。

Filter和Servlet的生命週期：
1.Filter在web伺服器啟動時初始化
2.如果某個Servlet配置了1 ，該Servlet也是在Tomcat（Servlet容器）啟動時初始化。
3.如果Servlet沒有配置1 ，則該Servlet不會在Tomcat啟動時初始化，而是在請求到來時初始化。
4.每次請求， Request都會被初始化，回應(yīng)請求後，請求被銷毀。
5.Servlet初始化後，將不會隨著請求的結(jié)束而註銷。
6.關(guān)閉Tomcat時，Servlet、Filter依序被註銷。

HashMap與HashTable的差異。
1、HashMap是非線程安全的，HashTable是線程安全的。
2、HashMap的鍵和值都允許null值存在，而HashTable則不行。
3、因?yàn)閳?zhí)行緒安全的問題，HashMap效率比HashTable的還要高。

HashMap的實(shí)作機(jī)制：

1. 維護(hù)一個每個元素是一個鍊錶的數(shù)組，而且鍊錶中的每個節(jié)點(diǎn)都是一個Entry[]鍵值對的資料結(jié)構(gòu)。

2. 實(shí)現(xiàn)了陣列 鍊錶的特性，查找快，插入刪除也快。

3. 對於每個key,他對應(yīng)的陣列索引下標(biāo)是int i = hash(key.hashcode)&(len-1);

4. 每個新加入的節(jié)點(diǎn)放在鍊錶首，然後該新加入的節(jié)點(diǎn)指向原始鍊錶首

HashMap和TreeMap區(qū)別

HashMap衝突

HashMap，ConcurrentHashMap與LinkedHashMap的差異

1. ConcurrentHashMap是使用了鎖分段技術(shù)技術(shù)來確保線程安全的，鎖分段技術(shù)：首先將資料分成一段一段的存儲，然後給每一段資料配一把鎖，當(dāng)一個當(dāng)執(zhí)行緒佔(zhàn)用鎖定存取其中一個段資料的時候，其他段的資料也能被其他執(zhí)行緒存取

2. #ConcurrentHashMap 是在每個區(qū)段（segment）中執(zhí)行緒安全的

3. LinkedHashMap維護(hù)一個雙鍊錶，可以將裡面的資料按寫入的順序讀出

ConcurrentHashMap應(yīng)用場景
1：ConcurrentHashMap的應(yīng)用場景是高並發(fā)，但是並不能保證線程安全，而同步的HashMap和HashMap的是鎖住整個容器，而加鎖之後ConcurrentHashMap不需要鎖住整個容器，只需要鎖住對應(yīng)的Segment就好了，所以可以保證高並發(fā)同步訪問，提升了效率。
2：可以多執(zhí)行緒寫。
ConcurrentHashMap把HashMap分成若干Segmenet
1.get時，不加鎖，先定位到segment然後在找到頭結(jié)點(diǎn)進(jìn)行讀取操作。而value是volatile變量，所以可以保證在競爭條件時保證讀取最新的值，如果讀到的value是null，則可能正在修改，那麼就調(diào)用ReadValueUnderLock函數(shù)，加鎖保證讀到的數(shù)據(jù)是正確的。
2.Put時會加鎖，一律加到hash鏈的頭部。
3.Remove時也會加鎖，由於next是final型別無法改變，所以必須把刪除的節(jié)點(diǎn)之前的節(jié)點(diǎn)都複製一遍。
4.ConcurrentHashMap允許多個修改操作並發(fā)進(jìn)行，其關(guān)鍵在於使用了鎖定分離技術(shù)。它使用了多個鎖來控制Hash表的不同Segment進(jìn)行的修改。

ConcurrentHashMap的應(yīng)用場景是高並發(fā)，但是並不能保證線程安全，而同步的HashMap和HashTable的是鎖住整個容器，而加鎖之後ConcurrentHashMap不需要鎖住整個容器，只需要鎖住對應(yīng)的segment就好了，所以可以保證高並發(fā)同步訪問，提升了效率。

ConcurrentHashMap能夠保證每一次呼叫都是原子操作，但是不保證多次呼叫之間也是原子操作。

Vector和ArrayList的區(qū)別

ExecutorService service = Executors…. ExecutorService service = new ThreadPoolExecutor() ExecutorService service = new ScheduledThreadPoolExecutor();

ecutor();

ecutor(); ThreadPoolExecutor原始碼分析

執(zhí)行緒池本身的狀態(tài)：

#等待任務(wù)佇列與工作集：

#線程池的主要狀態(tài)鎖定：

線程池的存活時間和大?。?/p>

1.2 ThreadPoolExecutor 的內(nèi)部工作原理
有了以上定義好的數(shù)據(jù)，以下來看看內(nèi)部是如何實(shí)現(xiàn)的。 Doug Lea 的整個思路總結(jié)起來就是 5 句話：

1. 如果當(dāng)前池大小 poolSize 小於 corePoolSize ，則建立新執(zhí)行緒執(zhí)行任務(wù)。

2. 如果目前池大小poolSize 大於corePoolSize ，且等待佇列未滿，則進(jìn)入等待佇列

3. ##如果目前池大小poolSize 大於corePoolSize 且小於maximumPoolSize ，且等待佇列已滿，則建立新執(zhí)行緒執(zhí)行任務(wù)。

4. 如果目前池大小 poolSize 大於 corePoolSize 且大於 maximumPoolSize ，且等待佇列已滿，則呼叫拒絕策略來處理該任務(wù)。

5. 執(zhí)行緒池裡的每個執(zhí)行緒執(zhí)行完任務(wù)後不會立刻退出，而是會去檢查下等待佇列裡是否還有執(zhí)行緒任務(wù)需要執(zhí)行，如果在keepAliveTime 裡等不到新的任務(wù)了，那麼執(zhí)行緒就會退出。

Executor套件結(jié)構(gòu)

#CopyOnWriteArrayList :寫時加鎖，當(dāng)添加一個元素的時候，將原來的容器進(jìn)行copy，複製出一個新的容器，然後在新的容器裡面寫，寫完之後再將原始容器的引用指向新的容器，而讀的時候是讀舊容器的數(shù)據(jù)，所以可以進(jìn)行並發(fā)的讀，但這是一種弱一致性的策略。

使用場景：CopyOnWriteArrayList適合使用在讀取操作遠(yuǎn)大於寫入操作的場景裡，例如快取。

Linux常用指令：cd，cp，mv，rm，ps（進(jìn)程），tar，cat(查看內(nèi)容)，chmod，vim，find，ls

的必要條件

#

1. 互斥至少有一個資源處於非共享狀態(tài)

2. 存在並等待

3. 非搶佔(zhàn)

4. 循環(huán)等待

解決死鎖，第一個是死鎖預(yù)防，就是不讓上面的四個條件同時成立。二是，合理分配資源。
三是使用銀行家演算法，如果該行程請求的資源作業(yè)系統(tǒng)剩餘量可以滿足，那就分配。

進(jìn)程間的通訊方式

1. 管道( pipe )：管道是一種半雙工的通訊方式，資料只能單向流動，而且只能在具有親緣關(guān)係的進(jìn)程間使用。進(jìn)程的親緣關(guān)係通常是指父子進(jìn)程關(guān)係。

2. 有名管道 (named pipe) ： 有名管道也是半雙工的通訊方式，但是它允許無親緣關(guān)係進(jìn)程間的通訊。

3. 信號量( semophore ) ： 信號量是一個計(jì)數(shù)器，可以用來控制多個行程對共享資源的存取。它常作為一種鎖機(jī)制，防止某一行程正在存取共享資源時，其他行程也會存取該資源。因此，主要作為進(jìn)程間以及同一進(jìn)程內(nèi)不同執(zhí)行緒之間的同步手段。

4. 訊息佇列( message queue ) ： 訊息佇列是由訊息的鍊錶，存放在核心中並由訊息佇列標(biāo)識符標(biāo)識。訊息佇列克服了訊號傳遞訊息少、管道只能承載無格式位元組流以及緩衝區(qū)大小受限等缺點(diǎn)。

5. 訊號 ( sinal ) ： 訊號是一種比較複雜的通訊方式，用來通知接收程序某個事件已經(jīng)發(fā)生。

6. 共享記憶體( shared memory ) ：共享記憶體就是映射一段能被其他進(jìn)程所存取的內(nèi)存，這段共享記憶體由一個進(jìn)程創(chuàng)建，但多個進(jìn)程都可以存取。共享記憶體是最快的 IPC 方式，它是針對其他進(jìn)程間通訊方式運(yùn)作效率低且專門設(shè)計(jì)的。它往往與其他通訊機(jī)制，如信號量，配合使用，來實(shí)現(xiàn)進(jìn)程間的同步和通訊。

7. 套接字( socket ) ： 套解口也是一種進(jìn)程間通訊機(jī)制，與其他通訊機(jī)制不同的是，它可用於不同機(jī)器間的進(jìn)程通訊。

進(jìn)程與執(zhí)行緒的區(qū)別和聯(lián)繫
作業(yè)系統(tǒng)的進(jìn)程調(diào)度演算法
電腦系統(tǒng)的層次儲存結(jié)構(gòu)詳解

資料庫事務(wù)是指作為單個邏輯工作單元執(zhí)行的一系列操作。

MySQL資料庫最佳化總結(jié)
MYSQL 最佳化常用方法
MySQL儲存引擎－MyISAM與InnoDB差異
關(guān)於SQL資料庫中的範(fàn)式

Hibernate的一級快取是由Session提供的，因此它只存在於Session的生命週期中，當(dāng)程式呼叫save(),update(),saveOrUpdate()等方法及呼叫查詢當(dāng)介面list,filter,iterate時，如Session快取中還不存在對應(yīng)的對象，Hibernate會把該對象加入到一級快取中，當(dāng)Session關(guān)閉的時候快取也會消失。

Hibernate的一級快取是Session所內(nèi)建的，不能被卸載，也不能進(jìn)行任何配置一級快取採用的是key-value的Map方式來實(shí)現(xiàn)的，在快取實(shí)體物件時，物件的主關(guān)鍵字ID是Map的key，實(shí)體物件就是對應(yīng)的值。

Hibernate二級快取：把獲得的所有資料物件根據(jù)ID放入到第二級快取中。 Hibernate二級快取策略，是針對於ID查詢的快取策略，刪除、更新、增加資料的時候，同時更新快取。

進(jìn)程和執(zhí)行緒的區(qū)別：

進(jìn)程：每個行程都有獨(dú)立的程式碼和資料空間（進(jìn)程上下文），進(jìn)程間的切換會有較大的開銷，一個行程包含1–n個線程。

執(zhí)行緒：同一類別執(zhí)行緒共享程式碼和資料空間，每個執(zhí)行緒有獨(dú)立的運(yùn)行堆疊和程式計(jì)數(shù)器(PC)，執(zhí)行緒切換開銷小。

執(zhí)行緒和進(jìn)程一樣分為五個階段：建立、就緒、執(zhí)行、阻塞、終止。

多進(jìn)程是指作業(yè)系統(tǒng)能同時執(zhí)行多個任務(wù)（程式）。

多執(zhí)行緒是指在同一程式中有多個順序流在執(zhí)行。

在java中要想實(shí)作多線程，有三種手段，一種是繼續(xù)Thread類，另外一種是實(shí)作Runable接口，還有就是實(shí)作Callable介面。

Switch能否用string做參數(shù)？

a.在 Java 7 之前, switch 只能支援byte,short,char,int 或其對應(yīng)的封裝類別以及 Enum 類型。在Java 7中,String 支援被加上了。

Object有哪些公用方法？

a.方法equals測試的是兩個物件是否相等

b.方法clone進(jìn)行物件拷貝

c.方法getClass傳回和目前物件相關(guān)的Class物件

d.方法notify,notifyall,wait都是用來對給定物件進(jìn)行線程同步的

Java的四種引用，強(qiáng)弱軟弱，以及用到的場景

a. Use soft references and weak references to solve the OOM problem: use a HashMap to save the mapping relationship between the path of the image and the soft reference associated with the corresponding image object. When memory is insufficient, the JVM will automatically recycle these cached image objects. space occupied, thus effectively avoiding the OOM problem.

b. Implement caching of Java objects through soft-accessible object retrieval methods: For example, if we create an Employee class, if we need to query the information of an employee each time. Even if it was queried just a few seconds ago, it needs to rebuild an instance, which takes a lot of time. We can combine soft references and HashMap. First, save the reference: reference an instance of the Employee object in the form of a soft reference and save the reference to the HashMap. The key is the employee's id and the value is the soft reference of this object. , on the other hand, is to take out the reference and see if there is a soft reference to the Employee instance in the cache. If so, get it from the soft reference. If there is no soft reference, or the instance obtained from the soft reference is null, rebuild an instance and save the soft reference to the newly created instance.

c. Strong reference: If an object has a strong reference, it will not be recycled by the garbage collector. Even if the current memory space is insufficient, the JVM will not reclaim it, but will throw an OutOfMemoryError error, causing the program to terminate abnormally. If you want to break the association between a strong reference and an object, you can explicitly assign the reference to null, so that the JVM will recycle the object at the appropriate time.

d. Soft reference: When using soft reference, if there is enough memory space, the soft reference can continue to be used without being recycled by the garbage collector. Only when the memory is insufficient, the soft reference will Recycled by the garbage collector.

e. Weak reference: Objects with weak references have a shorter life cycle. Because when the JVM performs garbage collection, once a weak reference object is found, the weak reference will be recycled regardless of whether the current memory space is sufficient. However, since the garbage collector is a low-priority thread, it may not be able to quickly find weak reference objects.

f. Virtual reference: As the name suggests, it is in name only. If an object only holds a virtual reference, then it is equivalent to having no reference and may be recycled by the garbage collector at any time.

What is the difference between the function of Hashcode and equal?

a. It is also used to identify whether two objects are equal. There are two types of Java collections: list and set. Among them, set does not allow repeated implementation of elements. This method does not allow repeated implementation. If you use equal to For comparison, if there are 1000 elements and you create a new element, you need to call equal 1000 times to compare them one by one to see if they are the same object, which will greatly reduce efficiency. The hashcode actually returns the storage address of the object. If there is no element at this position, the element is stored directly above it. If an element already exists at this position, the equal method is called at this time to compare with the new element. If they are the same, they will not be Save it and hash it to another address.

The meaning and difference between Override and Overload
a.Overload, as the name suggests, is reloading. It can express the polymorphism of the class. It can be that the function can have the same function name but The parameter names, return values, and types cannot be the same; in other words, the parameters, types, and return values ??can be changed but the function name remains unchanged.
b. It means ride (rewrite). When the subclass inherits the parent class, the subclass can define a method with the same name and parameters as its parent class. When the subclass calls this function, it will be automatically called. Methods of subclasses, while parent classes are equivalent to being overridden (overridden).
For details, you can go to the example analysis of the difference between overloading and rewriting (overwriting) in C

The difference between abstract classes and interfaces

a. A class can only inherit a single class, but Multiple interfaces can be implemented

b. There can be constructors in abstract classes, but there cannot be constructors in interfaces

c. All methods in abstract classes do not have to be abstract, you can Choose to implement some basic methods in abstract classes. The interface requires that all methods must be abstract

d. Abstract classes can contain static methods, but interfaces cannot

e. Abstract classes can have ordinary member variables, and interfaces can Not allowed

The principles and characteristics of several methods of parsing XML: DOM, SAX, PULL

a.DOM: memory consumption: first read all xml documents into memory, and then use DOM API to access the tree structure and get data. This is very simple to write, but it consumes a lot of memory. If the data is too large and the phone is not powerful enough, the phone may crash directly

b.SAX: high parsing efficiency, small memory usage, event-driven: more simply put, it sequentially scans the document. When scanning Notify the event processing function when reaching the start and end of the document (document), the start and end of the element (element), the end of the document (document), etc., and the event processing function will take corresponding actions, and then continue the same scan until the end of the document.

c.PULL: Similar to SAX, it is also event-driven. We can call its next() method to get the next parsing event (that is, start document, end document, start tag, end tag). When at a certain When there is an element, you can call the getAttributte() method of XmlPullParser to get the value of the attribute, or you can call its nextText() to get the value of this node.

The difference between wait() and sleep()

sleep comes from the Thread class, and wait comes from the Object class

During the process of calling the sleep() method, the thread will not be released Object lock. The thread that calls the wait method will release the object lock.

Sleep does not give up system resources after sleep. Wait gives up system resources and other threads can occupy the CPU.

sleep(milliseconds) needs to specify a sleep time. It will automatically wake up as soon as it arrives

The difference between heap and stack in JAVA, let’s talk about Java’s memory mechanism

a. Basic data types, variables and object references are all allocated on the stack

b. Heap memory is used to store objects and arrays created by new

c. Class variables (statically modified variables), the program allocates memory for class variables in the heap when it is loaded. , the memory address in the heap is stored in the stack

d. Instance variables: When you use the java keyword new, the system allocates space to variables in the heap that is not necessarily continuous, but is allocated to variables based on scattered The heap memory address is converted into a long string of numbers through a hash algorithm to represent the "physical location" of this variable in the heap. The life cycle of the instance variable – when the reference to the instance variable is lost, it will be GC (garbage collector) Included in the recyclable "list", but the memory in the heap is not released immediately

e. Local variables: from being declared in a certain method or a certain code segment (such as a for loop) to executing it When the memory is allocated on the stack, when the local variable goes out of scope, the memory is released immediately

The implementation principle of JAVA polymorphism

a. Abstractly speaking, polymorphism means the same Messages can behave in many different ways depending on who they are sent to. (Sending a message is a function call)

b. The implementation principle is dynamic binding. The method called by the program is dynamically bound during the runtime. Tracing the source code can be found that the JVM finds the appropriate parameter through automatic transformation. Method.

Related recommendations:

Summary of Java collection interview questions and answers

Analysis of loading order of classes in Java (commonly used in interview questions)

以上是各大公司Java面試題目歸納整理（全）的詳細(xì)內(nèi)容。更多資訊請關(guān)注PHP中文網(wǎng)其他相關(guān)文章！