JAVA基礎
不可以，因為String類有final修飾符，而final修飾的類是不能被繼承的，實現細節不允許改變。平常我們定義的String str=”a”;其實和String str=new String(“a”)還是有差異的。
前者默認調用的是String.valueOf來返回String實例對象，至于調用哪個則取決于你的賦值，比如String num=1,調用的是
public static String valueOf(int i) {
return Integer.toString(i);
}
后者則是調用如下部分：
public String(String original) {
this.value = original.value;
this.hash = original.hash;
}
最后我們的變量都存儲在一個char數組中
private final char value[];
String， Stringbuffer， StringBuilder 的區別。
String 字符串常量(final修飾，不可被繼承)，String是常量，當創建之后即不能更改。(可以通過StringBuffer和StringBuilder創建String對象(常用的兩個字符串操作類)。)
StringBuffer 字符串變量（線程安全）,其也是final類別的，不允許被繼承，其中的絕大多數方法都進行了同步處理，包括常用的Append方法也做了同步處理(synchronized修飾)。其自jdk1.0起就已經出現。其toString方法會進行對象緩存，以減少元素復制開銷。
public synchronized String toString() {
if (toStringCache == null) {
toStringCache = Arrays.copyOfRange(value, 0, count);
}
return new String(toStringCache, true);
}
StringBuilder 字符串變量（非線程安全）其自jdk1.5起開始出現。與StringBuffer一樣都繼承和實現了同樣的接口和類，方法除了沒使用synch修飾以外基本一致，不同之處在于最后toString的時候，會直接返回一個新對象。
public String toString() {
// Create a copy, don’t share the array
return new String(value, 0, count);
}
ArrayList和LinkedList都實現了List接口，有以下的不同點：
1、ArrayList是基于索引的數據接口，它的底層是數組。它可以以O(1)時間復雜度對元素進行隨機訪問。與此對應，LinkedList是以元素列表的形式存儲它的數據，每一個元素都和它的前一個和后一個元素鏈接在一起，在這種情況下，查找某個元素的時間復雜度是O(n)。
2、相對于ArrayList，LinkedList的插入，添加，刪除操作速度更快，因為當元素被添加到集合任意位置的時候，不需要像數組那樣重新計算大小或者是更新索引。
3、LinkedList比ArrayList更占內存，因為LinkedList為每一個節點存儲了兩個引用，一個指向前一個元素，一個指向下一個元素。
講講類的實例化順序，比如父類靜態數據，構造函數，字段，子類靜態數據，構造函數，字段，當 new 的時候， 他們的執行順序。
此題考察的是類加載器實例化時進行的操作步驟（加載–>連接->初始化）。
父類靜態代變量、
父類靜態代碼塊、
子類靜態變量、
子類靜態代碼塊、
父類非靜態變量（父類實例成員變量）、
父類構造函數、
子類非靜態變量（子類實例成員變量）、
子類構造函數。
測試demo：http://blog.csdn.net/u014042066/article/details/77574956
參閱我的博客《深入理解類加載》：http://blog.csdn.net/u014042066/article/details/77394480
用過哪些 Map 類，都有什么區別，HashMap 是線程安全的嗎,并發下使用的 Map 是什么，他們內部原理分別是什么，比如存儲方式， hashcode，擴容， 默認容量等。
hashMap是線程不安全的，HashMap是數組+鏈表+紅黑樹（JDK1.8增加了紅黑樹部分）實現的，采用哈希表來存儲的，
參照該鏈接：https://zhuanlan.zhihu.com/p/21673805
JAVA8 的 ConcurrentHashMap 為什么放棄了分段鎖，有什么問題嗎，如果你來設計，你如何設計。
參照：https://yq.aliyun.com/articles/36781
有沒有有順序的 Map 實現類， 如果有， 他們是怎么保證有序的。
TreeMap和LinkedHashMap是有序的（TreeMap默認升序，LinkedHashMap則記錄了插入順序）。
參照：http://uule.iteye.com/blog/1522291
抽象類和接口的區別，類可以繼承多個類么，接口可以繼承多個接口么,類可以實現多個接口么。
1、抽象類和接口都不能直接實例化，如果要實例化，抽象類變量必須指向實現所有抽象方法的子類對象，接口變量必須指向實現所有接口方法的類對象。
2、抽象類要被子類繼承，接口要被類實現。
3、接口只能做方法申明，抽象類中可以做方法申明，也可以做方法實現
4、接口里定義的變量只能是公共的靜態的常量，抽象類中的變量是普通變量。
5、抽象類里的抽象方法必須全部被子類所實現，如果子類不能全部實現父類抽象方法，那么該子類只能是抽象類。同樣，一個實現接口的時候，如不能全部實現接口方法，那么該類也只能為抽象類。
6、抽象方法只能申明，不能實現。abstract void abc();不能寫成abstract void abc(){}。
7、抽象類里可以沒有抽象方法
8、如果一個類里有抽象方法，那么這個類只能是抽象類
9、抽象方法要被實現，所以不能是靜態的，也不能是私有的。
10、接口可繼承接口，并可多繼承接口，但類只能單根繼承。
繼承指的是一個類（稱為子類、子接口）繼承另外的一個類（稱為父類、父接口）的功能，并可以增加它自己的新功能的能力，繼承是類與類或者接口與接口之間最常見的關系；在Java中此類關系通過關鍵字extends明確標識，在設計時一般沒有爭議性；
聚合是關聯關系的一種特例，他體現的是整體與部分、擁有的關系，即has-a的關系，此時整體與部分之間是可分離的，他們可以具有各自的生命周期，部分可以屬于多個整體對象，也可以為多個整體對象共享；比如計算機與CPU、公司與員工的關系等；表現在代碼層面，和關聯關系是一致的，只能從語義級別來區分；
參考：http://www.cnblogs.com/jiqing9006/p/5915023.html
講講你理解的 nio和 bio 的區別是啥，談談 reactor 模型。
IO是面向流的，NIO是面向緩沖區的
參考：https://zhuanlan.zhihu.com/p/23488863
http://developer.51cto.com/art/201103/252367.htm
http://www.lxweimin.com/p/3f703d3d804c
參照：http://www.lxweimin.com/p/3ea4a6b57f87?amp
http://blog.csdn.net/yongjian1092/article/details/7364451
反射中，Class.forName 和 ClassLoader 區別。
https://my.oschina.net/gpzhang/blog/486743
Jdk cglib jdk底層是利用反射機制，需要基于接口方式，這是由于
Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(), this);
Cglib則是基于asm框架，實現了無反射機制進行代理，利用空間來換取了時間，代理效率高于jdk
http://lrd.ele.me/2017/01/09/dynamic_proxy/
同上（基于invocationHandler和methodInterceptor）
同上
類、變量、方法
http://www.importnew.com/7553.html
懶漢式單例，餓漢式單例，雙重檢查等
參考：https://my.oschina.net/dyyweb/blog/609021
如何在父類中為子類自動完成所有的 hashcode 和 equals 實現？這么做有何優劣。
同時復寫hashcode和equals方法，優勢可以添加自定義邏輯，且不必調用超類的實現。
參照：http://java-min.iteye.com/blog/1416727
請結合 OO 設計理念，談談訪問修飾符 public、private、protected、default 在應用設計中的作用。
訪問修飾符，主要標示修飾塊的作用域，方便隔離防護
同一個類? ? 同一個包? ? 不同包的子類? 不同包的非子類
Private √
Default √ √
Protected √ √ √
Public √ √ √ √
public： Java語言中訪問限制最寬的修飾符，一般稱之為“公共的”。被其修飾的類、屬性以及方法不
僅可以跨類訪問，而且允許跨包（package）訪問。
private: Java語言中對訪問權限限制的最窄的修飾符，一般稱之為“私有的”。被其修飾的類、屬性以
及方法只能被該類的對象訪問，其子類不能訪問，更不能允許跨包訪問。
protect: 介于public 和 private 之間的一種訪問修飾符，一般稱之為“保護形”。被其修飾的類、
屬性以及方法只能被類本身的方法及子類訪問，即使子類在不同的包中也可以訪問。
default：即不加任何訪問修飾符，通常稱為“默認訪問模式“。該模式下，只允許在同一個包中進行訪
問。
http://www.oschina.net/translate/java-copy-shallow-vs-deep-in-which-you-will-swim
http://blog.csdn.net/snow_wu/article/details/53172721
error 和 exception 的區別，CheckedException，RuntimeException 的區別
http://blog.csdn.net/woshixuye/article/details/8230407
同上
在自己的代碼中，如果創建一個 java.lang.String 對象，這個對象是否可以被類加載器加載？為什么
類加載無須等到“首次使用該類”時加載，jvm允許預加載某些類。。。。
http://www.cnblogs.com/jasonstorm/p/5663864.html
說一說你對 java.lang.Object 對象中 hashCode 和 equals 方法的理解。在什么場景下需要重新實現這兩個方法。
參考上邊試題
在 jdk1.5 中，引入了泛型，泛型的存在是用來解決什么問題。
泛型的本質是參數化類型，也就是說所操作的數據類型被指定為一個參數，泛型的好處是在編譯的時候檢查類型安全，并且所有的強制轉換都是自動和隱式的，以提高代碼的重用率
http://baike.baidu.com/item/java%E6%B3%9B%E5%9E%8B
這樣的 a.hashcode() 有什么用，與 a.equals(b)有什么關系。
hashcode
hashcode（）方法提供了對象的hashCode值，是一個native方法，返回的默認值與System.identityHashCode(obj)一致。
通常這個值是對象頭部的一部分二進制位組成的數字，具有一定的標識對象的意義存在，但絕不定于地址。
作用是：用一個數字來標識對象。比如在HashMap、HashSet等類似的集合類中，如果用某個對象本身作為Key，即要基于這個對象實現Hash的寫入和查找，那么對象本身如何實現這個呢？就是基于hashcode這樣一個數字來完成的，只有數字才能完成計算和對比操作。
hashcode是否唯一
hashcode只能說是標識對象，在hash算法中可以將對象相對離散開，這樣就可以在查找數據的時候根據這個key快速縮小數據的范圍，但hashcode不一定是唯一的，所以hash算法中定位到具體的鏈表后，需要循環鏈表，然后通過equals方法來對比Key是否是一樣的。
equals與hashcode的關系
equals相等兩個對象，則hashcode一定要相等。但是hashcode相等的兩個對象不一定equals相等。
https://segmentfault.com/a/1190000004520827
有
底層是基于hashmap實現的
http://wiki.jikexueyuan.com/project/java-collection/hashset.html
什么是序列化，怎么序列化，為什么序列化，反序列化會遇到什么問題，如何解決。
http://www.importnew.com/17964.html
如果線程請求的棧深度大于虛擬機所允許的深度，將拋出StackOverflowError異常。 如果虛擬機在動態擴展棧時無法申請到足夠的內存空間，則拋出OutOfMemoryError異常。
參照：http://wiki.jikexueyuan.com/project/java-vm/storage.html
eden 和 survior 是按8比1分配的
http://blog.csdn.net/lojze_ly/article/details/49456255
jvm 中一次完整的 GC 流程是怎樣的，對象如何晉升到老年代，說說你知道的幾種主要的jvm 參數。
對象誕生即新生代->eden，在進行minor gc過程中，如果依舊存活，移動到from，變成Survivor，進行標記代數，如此檢查一定次數后，晉升為老年代，
http://www.cnblogs.com/redcreen/archive/2011/05/04/2037056.html
http://ifeve.com/useful-jvm-flags/
https://wangkang007.gitbooks.io/jvm/content/jvmcan_shu_xiang_jie.html
你知道哪幾種垃圾收集器，各自的優缺點，重點講下 cms，包括原理，流程，優缺點
Serial、parNew、ParallelScavenge、SerialOld、ParallelOld、CMS、G1
https://wangkang007.gitbooks.io/jvm/content/chapter1.html
http://www.importnew.com/13493.html
首先分析是什么類型的內存溢出，對應的調整參數或者優化代碼。
https://wangkang007.gitbooks.io/jvm/content/4jvmdiao_you.html
JVM 內存模型的相關知識了解多少，比如重排序，內存屏障，happen-before，主內存，工作內存等。
內存屏障：為了保障執行順序和可見性的一條cpu指令
重排序：為了提高性能，編譯器和處理器會對執行進行重拍
happen-before：操作間執行的順序關系。有些操作先發生。
主內存：共享變量存儲的區域即是主內存
工作內存：每個線程copy的本地內存，存儲了該線程以讀/寫共享變量的副本
http://ifeve.com/java-memory-model-1/
http://www.lxweimin.com/p/d3fda02d4cae
http://blog.csdn.net/kenzyq/article/details/50918457
類加載器的分類（bootstrap,ext,app,curstom），類加載的流程(load-link-init)
http://blog.csdn.net/gjanyanlig/article/details/6818655/
Java程序在運行狀態可以動態的獲取類的所有屬性和方法，并實例化該類，調用方法的功能
-server
Xms6000M
-Xmx6000M
-Xmn500M
-XX:PermSize=500M
-XX:MaxPermSize=500M
-XX:SurvivorRatio=65536
-XX:MaxTenuringThreshold=0
-Xnoclassgc
-XX:+DisableExplicitGC
-XX:+UseParNewGC
-XX:+UseConcMarkSweepGC
-XX:+UseCMSCompactAtFullCollection
-XX:CMSFullGCsBeforeCompaction=0
-XX:+CMSClassUnloadingEnabled
-XX:-CMSParallelRemarkEnabled
-XX:CMSInitiatingOccupancyFraction=90
-XX:SoftRefLRUPolicyMSPerMB=0
-XX:+PrintClassHistogram
-XX:+PrintGCDetails
-XX:+PrintGCTimeStamps
-XX:+PrintHeapAtGC
-Xloggc:log/gc.log
g1 和 cms 區別,吞吐量優先和響應優先的垃圾收集器選擇。
Cms是以獲取最短回收停頓時間為目標的收集器。基于標記-清除算法實現。比較占用cpu資源，切易造成碎片。
G1是面向服務端的垃圾收集器，是jdk9默認的收集器，基于標記-整理算法實現。可利用多核、多cpu，保留分代，實現可預測停頓，可控。
http://blog.csdn.net/linhu007/article/details/48897597
請解釋如下 jvm 參數的含義：
-server -Xms512m -Xmx512m -Xss1024K
-XX:PermSize=256m -XX:MaxPermSize=512m -XX:MaxTenuringThreshold=20
XX:CMSInitiatingOccupancyFraction=80 -XX:+UseCMSInitiatingOccupancyOnly。
Server模式啟動
最小堆內存512m
最大512m
每個線程棧空間1m
永久代256
最大永久代256
最大轉為老年代檢查次數20
Cms回收開啟時機：內存占用80%
命令JVM不基于運行時收集的數據來啟動CMS垃圾收集周期
Server- –多個service
Container級別的：–>engine–》host–>context
Listenter
Connector
Logging、Naming、Session、JMX等等
通過WebappClassLoader 加載class
http://www.ibm.com/developerworks/cn/java/j-lo-tomcat1/
http://blog.csdn.net/dc_726/article/details/11873343
http://www.cnblogs.com/xing901022/p/4574961.html
http://www.lxweimin.com/p/62ec977996df
硬件上選擇，操作系統選擇，版本選擇，jdk選擇，配置jvm參數，配置connector的線程數量，開啟gzip壓縮，trimSpaces，集群等
http://blog.csdn.net/lifetragedy/article/details/7708724
通過listener入口，核心是在AbstractApplicationContext的refresh方法，在此處進行裝載bean工廠，bean，創建bean實例，攔截器，后置處理器等。
https://www.ibm.com/developerworks/cn/java/j-lo-spring-principle/
七種傳播屬性。
事務傳播行為
所謂事務的傳播行為是指，如果在開始當前事務之前，一個事務上下文已經存在，此時有若干選項可以指定一個事務性方法的執行行為。在TransactionDefinition定義中包括了如下幾個表示傳播行為的常量：
TransactionDefinition.PROPAGATION_REQUIRED：如果當前存在事務，則加入該事務；如果當前沒有事務，則創建一個新的事務。
TransactionDefinition.PROPAGATION_REQUIRES_NEW：創建一個新的事務，如果當前存在事務，則把當前事務掛起。
TransactionDefinition.PROPAGATION_SUPPORTS：如果當前存在事務，則加入該事務；如果當前沒有事務，則以非事務的方式繼續運行。
TransactionDefinition.PROPAGATION_NOT_SUPPORTED：以非事務方式運行，如果當前存在事務，則把當前事務掛起。
TransactionDefinition.PROPAGATION_NEVER：以非事務方式運行，如果當前存在事務，則拋出異常。
TransactionDefinition.PROPAGATION_MANDATORY：如果當前存在事務，則加入該事務；如果當前沒有事務，則拋出異常。
TransactionDefinition.PROPAGATION_NESTED：如果當前存在事務，則創建一個事務作為當前事務的嵌套事務來運行；如果當前沒有事務，則該取值等價于TransactionDefinition.PROPAGATION_REQUIRED。
https://www.ibm.com/developerworks/cn/education/opensource/os-cn-spring-trans/
編程式和聲明式
同上
Spring 怎么配置事務（具體說出一些關鍵的 xml 元素）。
說說你對 Spring 的理解，非單例注入的原理？它的生命周期？循環注入的原理， aop 的實現原理，說說 aop 中的幾個術語，它們是怎么相互工作的。
核心組件：bean，context，core，單例注入是通過單例beanFactory進行創建，生命周期是在創建的時候通過接口實現開啟，循環注入是通過后置處理器，aop其實就是通過反射進行動態代理，pointcut，advice等。
Aop相關：http://blog.csdn.net/csh624366188/article/details/7651702/
Springmvc 中 DispatcherServlet 初始化過程。
入口是web.xml中配置的ds，ds繼承了HttpServletBean，FrameworkServlet，通過其中的init方法進行初始化裝載bean和實例，initServletBean是實際完成上下文工作和bean初始化的方法。
http://www.mamicode.com/info-detail-512105.html
Tcp/ip io cpu memory
net.ipv4.tcp_syncookies = 1
#啟用syncookies
net.ipv4.tcp_max_syn_backlog = 8192
#SYN隊列長度
net.ipv4.tcp_synack_retries=2
#SYN ACK重試次數
net.ipv4.tcp_fin_timeout = 30
#主動關閉方FIN-WAIT-2超時時間
net.ipv4.tcp_keepalive_time = 1200
#TCP發送keepalive消息的頻度
net.ipv4.tcp_tw_reuse = 1
#開啟TIME-WAIT重用
net.ipv4.tcp_tw_recycle = 1
#開啟TIME-WAIT快速回收
net.ipv4.ip_local_port_range = 1024 65000
#向外連接的端口范圍
net.ipv4.tcp_max_tw_buckets = 5000
#最大TIME-WAIT數量，超過立即清除
net.ipv4.tcp_syn_retries = 2
#SYN重試次數
echo “fs.file-max=65535” >> /etc/sysctl.conf
sysctl -p
http://www.haiyun.me/category/system/
阻塞式io，非阻塞io，io復用模型，信號驅動io模型，異步io模型。
https://yq.aliyun.com/articles/46404
https://yq.aliyun.com/articles/46402
select的本質是采用32個整數的32位，即32*32= 1024來標識，fd值為1-1024。當fd的值超過1024限制時，就必須修改FD_SETSIZE的大小。這個時候就可以標識32*max值范圍的fd。
對于單進程多線程，每個線程處理多個fd的情況，select是不適合的。
1.所有的線程均是從1-32*max進行掃描，每個線程處理的均是一段fd值，這樣做有點浪費
2.1024上限問題，一個處理多個用戶的進程，fd值遠遠大于1024
所以這個時候應該采用poll，
poll傳遞的是數組頭指針和該數組的長度，只要數組的長度不是很長，性能還是很不錯的，因為poll一次在內核中申請4K（一個頁的大小來存放fd），盡量控制在4K以內
epoll還是poll的一種優化，返回后不需要對所有的fd進行遍歷，在內核中維持了fd的列表。select和poll是將這個內核列表維持在用戶態，然后傳遞到內核中。但是只有在2.6的內核才支持。
epoll更適合于處理大量的fd ，且活躍fd不是很多的情況，畢竟fd較多還是一個串行的操作
https://yq.aliyun.com/articles/10525
Ls,find,tar,tail,cp,rm,vi，grep,ps,pkill等等
https://yq.aliyun.com/articles/69417?spm=5176.100240.searchblog.18.Zrbh9R
Tail -n 5 filename
ps -ef|grep Java
控制權的轉換，根據優先級切換上下文（用戶，寄存器，系統）
http://www.cnblogs.com/kkshaq/p/4544426.html
Linux 實現并沒有區分這兩個概念（進程和線程）
1. 進程：程序的一次執行
2. 線程：CPU的基本調度單位
一個進程可以包含多個線程。
http://www.ruanyifeng.com/blog/2013/04/processes_and_threads.html
實現runable接口，繼承thread類。
http://ifeve.com/java-multi-threading-concurrency-interview-questions-with-answers/
Volatile利用內存柵欄機制來保持變量的一致性。不能代替鎖，其只具備數據可見性一致性，不具備原子性。
http://blog.csdn.net/gongzi2311/article/details/20715185
新建，可運行，運行中， 睡眠，阻塞，等待，死亡。
http://ifeve.com/thread-status
Sleep是休眠線程，wait是等待，sleep是thread的靜態方法，wait則是object的方法。
Sleep依舊持有鎖，并在指定時間自動喚醒。wait則釋放鎖。
http://www.lxweimin.com/p/4ec3f4b3903d
首先兩者都保持了并發場景下的原子性和可見性，區別則是synchronized的釋放鎖機制是交由其自身控制，且互斥性在某些場景下不符合邏輯，無法進行干預，不可人為中斷等。
而lock常用的則有ReentrantLock和readwritelock兩者，添加了類似鎖投票、定時鎖等候和可中斷鎖等候的一些特性。此外，它還提供了在激烈爭用情況下更佳的性能。
http://blog.csdn.net/vking_wang/article/details/9952063
synchronized 的原理是什么，解釋以下名詞：重排序，自旋鎖，偏向鎖，輕量級鎖，可重入鎖，公平鎖，非公平鎖，樂觀鎖，悲觀鎖。
Synchronized底層是通過監視器的enter和exit實現
https://my.oschina.net/cnarthurs/blog/847801
http://blog.csdn.net/a314773862/article/details/54095819
AtomicInteger； AtomicLong； AtomicReference； AtomicBoolean；基于CAS原語實現 ，比較并交換、加載鏈接/條件存儲，最壞的情況下是旋轉鎖
https://www.ibm.com/developerworks/cn/java/j-jtp11234/index.html
http://www.jmatrix.org/java/848.html
用過線程池嗎，newCache 和 newFixed 有什么區別，他們的原理簡單概括下，構造函數的各個參數的含義是什么，比如 coreSize，maxsize 等。
newSingleThreadExecutor返回以個包含單線程的Executor,將多個任務交給此Exector時，這個線程處理完一個任務后接著處理下一個任務，若該線程出現異常，將會有一個新的線程來替代。
newFixedThreadPool返回一個包含指定數目線程的線程池，如果任務數量多于線程數目，那么沒有沒有執行的任務必須等待，直到有任務完成為止。
newCachedThreadPool根據用戶的任務數創建相應的線程來處理，該線程池不會對線程數目加以限制，完全依賴于JVM能創建線程的數量，可能引起內存不足。
底層是基于ThreadPoolExecutor實現，借助reentrantlock保證并發。
coreSize核心線程數，maxsize最大線程數。
http://ifeve.com/java-threadpoolexecutor/
Shutdown shutdownNow tryTerminate 清空工作隊列，終止線程池中各個線程，銷毀線程池
http://blog.csdn.net/xxcupid/article/details/51993235
假如有一個第三方接口，有很多個線程去調用獲取數據，現在規定每秒鐘最多有 10 個線程同時調用它，如何做到。
ScheduledThreadPoolExecutor 設置定時，進行調度。
public ScheduledThreadPoolExecutor(int corePoolSize,
ThreadFactory threadFactory) {
super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,
new DelayedWorkQueue(), threadFactory);
}
http://ifeve.com/java-scheduledthreadpoolexecutor/
spring 的 controller 是單例還是多例，怎么保證并發的安全。
單例
通過單例工廠 DefaultSingletonBeanRegistry實現單例
通過保AsyncTaskExecutor持安全
用三個線程按順序循環打印 abc 三個字母，比如 abcabcabc。
public static void main(String[] args) {
final String str=”abc”;
ExecutorService executorService= Executors.newFixedThreadPool(3);
executorService.execute(new Runnable() {
@Override
public void run() {
System.out.println(“1”+str);
}
});executorService.execute(new Runnable() {
@Override
public void run() {
System.out.println(“2”+str);
}
});executorService.execute(new Runnable() {
@Override
public void run() {
System.out.println(“2”+str);
}
});
}
ThreadLocal 用過么，用途是什么，原理是什么，用的時候要注意什么。
Threadlocal底層是通過threadlocalMap進行存儲鍵值 每個ThreadLocal類創建一個Map，然后用線程的ID作為Map的key，實例對象作為Map的value，這樣就能達到各個線程的值隔離的效果。
ThreadLocal的作用是提供線程內的局部變量，這種變量在線程的生命周期內起作用，減少同一個線程內多個函數或者組件之間一些公共變量的傳遞的復雜度。
誰設置誰負責移除
Collections.synchronizedList() ConcurrentLinkedQueue
http://blog.csdn.net/xingjiarong/article/details/48046751
LockFree，CAS
基于jdk提供的原子類原語實現，例如AtomicReference
http://blog.csdn.net/b_h_l/article/details/8704480
首先這兩個方法只能在同步代碼塊中調用，wait會釋放掉對象鎖，等待notify喚醒。
http://blog.csdn.net/ithomer/article/details/7685594
根據具體情況（sleep,wait,join等），酌情選擇notifyAll，notify進行線程喚醒。
http://blog.chinaunix.net/uid-122937-id-215913.html
countdowlatch 和 cyclicbarrier 的內部原理和用法，以及相互之間的差別。
CountDownLatch是一個同步輔助類，在完成一組正在其他線程中執行的操作之前，它運行一個或者多個線程一直處于等待狀態。
CyclicBarrier要做的事情是，讓一組線程到達一個屏障（也可以叫同步點）時被阻塞，直到最后一個線程到達屏障時，屏障才會開門，所有被屏障攔截的線程才會繼續運行。
CyclicBarrier初始化的時候，設置一個屏障數。線程調用await()方法的時候，這個線程就會被阻塞，當調用await()的線程數量到達屏障數的時候，主線程就會取消所有被阻塞線程的狀態。
前者是遞減，不可循環，后者是遞加，可循環用
countdowlatch 基于abq cb基于ReentrantLock Condition
http://www.lxweimin.com/p/a101ae9797e3
http://blog.csdn.net/tolcf/article/details/50925145
使用 synchronized 修飾靜態方法和非靜態方法有什么區別。
對象鎖和類鎖
https://yq.aliyun.com/articles/24226
簡述 ConcurrentLinkedQueue LinkedBlockingQueue 的用處和不同之處。
LinkedBlockingQueue 是一個基于單向鏈表的、范圍任意的（其實是有界的）、FIFO 阻塞隊列。
ConcurrentLinkedQueue是一個基于鏈接節點的無界線程安全隊列，它采用先進先出的規則對節點進行排序，當我們添加一個元素的時候，它會添加到隊列的尾部，當我們獲取一個元素時，它會返回隊列頭部的元素。它采用了“wait－free”算法來實現，該算法在Michael & Scott算法上進行了一些修改, Michael & Scott算法的詳細信息可以參見參考資料一。
http://ifeve.com/concurrentlinkedqueue/
http://ifeve.com/juc-linkedblockingqueue/
http://blog.csdn.net/xiaohulunb/article/details/38932923
死鎖問題是多線程特有的問題，它可以被認為是線程間切換消耗系統性能的一種極端情況。在死鎖時，線程間相互等待資源，而又不釋放自身的資源，導致無窮無盡的等待，其結果是系統任務永遠無法執行完成。死鎖問題是在多線程開發中應該堅決避免和杜絕的問題。
一般來說，要出現死鎖問題需要滿足以下條件：
1. 互斥條件：一個資源每次只能被一個線程使用。
2. 請求與保持條件：一個進程因請求資源而阻塞時，對已獲得的資源保持不放。
3. 不剝奪條件：進程已獲得的資源，在未使用完之前，不能強行剝奪。
4. 循環等待條件：若干進程之間形成一種頭尾相接的循環等待資源關系。
只要破壞死鎖 4 個必要條件之一中的任何一個，死鎖問題就能被解決。
https://www.ibm.com/developerworks/cn/java/j-lo-deadlock/
非常多個線程（可能是不同機器），相互之間需要等待協調，才能完成某種工作，問怎么設計這種協調方案。
此問題的本質是保持順序執行。可以使用executors
