多執行緒建立方式
1.繼承thread類，重寫run方法
CreateThread createThread = new CreateThread(); ------createThread 繼承過thread的類
2。實現runnable介面
Thread thread = new Thread(createThread); ----------createThread 是new出來的實現介面的類
3.匿名內部類
new thread（），然後在引數裡new runnable介面
常用執行緒api方法
start（）
currentThread()
getid（）
getname（）
sleep（）
守護執行緒
thread.setDaemon(true); 使用setDaemon(true)方法設定為守護執行緒
多執行緒執行狀態
join()方法作用
join作用是讓其他執行緒變為等待, t1.join();// 讓其他執行緒變為等待，直到當前t1執行緒執行完畢，才釋放。
thread.Join把指定的執行緒加入到當前執行緒，可以將兩個交替執行的執行緒合併為順序執行的執行緒。比如線上程B中呼叫了執行緒A的Join()方法，直到執行緒A執行完畢後，才會繼續執行執行緒B。
優先順序
範圍為1-10，其中10最高，預設值為5。
// 注意設定了優先順序，不代表每次都一定會被執行。只是CPU排程會有限分配
t1.setPriority(10);
Yield方法
Thread.yield()方法的作用：暫停當前正在執行的執行緒，並執行其他執行緒。（可能沒有效果）
如何停止執行緒？
1. 使用退出標誌，使執行緒正常退出，也就是當run方法完成後執行緒終止。
使用flag
class StopThread implements Runnable { private boolean flag = true; @Override public synchronized void run() { while (flag) { try { wait(); } catch (Exception e) { //e.printStackTrace(); stopThread(); } System.out.println("thread run.."); } } public void stopThread() { flag = false; } }
2. 使用stop方法強行終止執行緒（這個方法不推薦使用，因為stop和suspend、resume一樣，也可能發生不可預料的結果）。
3. 使用interrupt方法中斷執行緒。
為什麼有執行緒安全問題？
當多個執行緒同時共享，同一個全域性變數或靜態變數，做寫的操作時，可能會發生資料衝突問題，也就是執行緒安全問題。但是做讀操作是不會發生資料衝突問題。
問:如何解決多執行緒之間執行緒安全問題?
答:使用多執行緒之間同步synchronized或使用鎖(lock)。
問:為什麼使用執行緒同步或使用鎖能解決執行緒安全問題呢？
答:將可能會發生資料衝突問題(執行緒不安全問題)，只能讓當前一個執行緒進行執行。程式碼執行完成後釋放鎖，讓後才能讓其他執行緒進行執行。這樣的話就可以解決執行緒不安全問題。
問:什麼是多執行緒之間同步？
答:當多個執行緒共享同一個資源,不會受到其他執行緒的干擾。
同步程式碼塊
什麼是同步程式碼塊？
答:就是將可能會發生執行緒安全問題的程式碼，給包括起來。
synchronized(同一個資料){
可能會發生執行緒衝突問題
}
就是同步程式碼塊
synchronized(物件)//這個物件可以為任意物件
{
需要被同步的程式碼
}
物件如同鎖，持有鎖的執行緒可以在同步中執行
沒持有鎖的執行緒即使獲取CPU的執行權，也進不去
同步的前提：
1，必須要有兩個或者兩個以上的執行緒
2，必須是多個執行緒使用同一個鎖
必須保證同步中只能有一個執行緒在執行
好處：解決了多執行緒的安全問題
弊端：多個執行緒需要判斷鎖，較為消耗資源、搶鎖的資源。
同步函式
什麼是同步函式？
答：在方法上修飾synchronized 稱為同步函式
同學們思考問題？同步函式用的是什麼鎖？
答：同步函式使用this鎖。
證明方式: 一個執行緒使用同步程式碼塊(this明鎖),另一個執行緒使用同步函式。如果兩個執行緒搶票不能實現同步，那麼會出現資料錯誤。
靜態同步函式
答：什麼是靜態同步函式？
方法上加上static關鍵字，使用synchronized 關鍵字修飾 或者使用類.class檔案。
靜態的同步函式使用的鎖是 該函式所屬位元組碼檔案物件
可以用 getClass方法獲取，也可以用當前 類名.class 表示。
什麼是ThreadLoca
ThreadLocal提供一個執行緒的區域性變數，訪問某個執行緒擁有自己區域性變數。
當使用ThreadLocal維護變數時，ThreadLocal為每個使用該變數的執行緒提供獨立的變數副本，所以每一個執行緒都可以獨立地改變自己的副本，而不會影響其它執行緒所對應的副本。
ThreadLocal類介面很簡單，只有4個方法，我們先來了解一下：
- void set(Object value)設定當前執行緒的執行緒區域性變數的值。
- public Object get()該方法返回當前執行緒所對應的執行緒區域性變數。
- public void remove()將當前執行緒區域性變數的值刪除，目的是為了減少記憶體的佔用，該方法是JDK 5.0新增的方法。需要指出的是，當執行緒結束後，對應該執行緒的區域性變數將自動被垃圾回收，所以顯式呼叫該方法清除執行緒的區域性變數並不是必須的操作，但它可以加快記憶體回收的速度。
- protected Object initialValue()返回該執行緒區域性變數的初始值，該方法是一個protected的方法，顯然是為了讓子類覆蓋而設計的。這個方法是一個延遲呼叫方法，線上程第1次呼叫get()或set(Object)時才執行，並且僅執行1次。ThreadLocal中的預設實現直接返回一個null。
class Res { // 生成序列號共享變數 public static Integer count = 0; public static ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>() { protected Integer initialValue() { return 0; }; }; public Integer getNum() { int count = threadLocal.get() + 1; threadLocal.set(count); return count; } } public class ThreadLocaDemo2 extends Thread { private Res res; public ThreadLocaDemo2(Res res) { this.res = res; } @Override public void run() { for (int i = 0; i < 3; i++) { System.out.println(Thread.currentThread().getName() + "---" + "i---" + i + "--num:" + res.getNum()); } } public static void main(String[] args) { Res res = new Res(); ThreadLocaDemo2 threadLocaDemo1 = new ThreadLocaDemo2(res); ThreadLocaDemo2 threadLocaDemo2 = new ThreadLocaDemo2(res); ThreadLocaDemo2 threadLocaDemo3 = new ThreadLocaDemo2(res); threadLocaDemo1.start(); threadLocaDemo2.start(); threadLocaDemo3.start(); } }
ThreadLoca實現原理
ThreadLoca通過map集合
Map.put(“當前執行緒”,值)；
什麼是多執行緒死鎖？
答:同步中巢狀同步,導致鎖無法釋放
多執行緒有三大特性
原子性、可見性、有序性
什麼是原子性
即一個操作或者多個操作 要麼全部執行並且執行的過程不會被任何因素打斷，要麼就都不執行。
一個很經典的例子就是銀行賬戶轉賬問題
比如從賬戶A向賬戶B轉1000元，那麼必然包括2個操作：從賬戶A減去1000元，往賬戶B加上1000元。這2個操作必須要具備原子性才能保證不出現一些意外的問題。
我們運算元據也是如此，比如i = i+1；其中就包括，讀取i的值，計算i，寫入i。這行程式碼在Java中是不具備原子性的，則多執行緒執行肯定會出問題，所以也需要我們使用同步和lock這些東西來確保這個特性了。
原子性其實就是保證資料一致、執行緒安全一部分，
什麼是可見性
當多個執行緒訪問同一個變數時，一個執行緒修改了這個變數的值，其他執行緒能夠立即看得到修改的值。
若兩個執行緒在不同的cpu，那麼執行緒1改變了i的值還沒重新整理到主存，執行緒2又使用了i，那麼這個i值肯定還是之前的，執行緒1對變數的修改執行緒沒看到這就是可見性問題。
什麼是有序性
程式執行的順序按照程式碼的先後順序執行。
一般來說處理器為了提高程式執行效率，可能會對輸入程式碼進行優化，它不保證程式中各個語句的執行先後順序同程式碼中的順序一致，但是它會保證程式最終執行結果和程式碼順序執行的結果是一致的。如下：
int a = 10; //語句1
int r = 2; //語句2
a = a + 3; //語句3
r = a*a; //語句4
則因為重排序，他還可能執行順序為 2-1-3-4，1-3-2-4
但絕不可能 2-1-4-3，因為這打破了依賴關係。
顯然重排序對單執行緒執行是不會有任何問題，而多執行緒就不一定了，所以我們在多執行緒程式設計時就得考慮這個問題了。
Java記憶體模型
共享記憶體模型指的就是Java記憶體模型(簡稱JMM)，JMM決定一個執行緒對共享變數的寫入時,能對另一個執行緒可見。從抽象的角度來看，JMM定義了執行緒和主記憶體之間的抽象關係：執行緒之間的共享變數儲存在主記憶體（main memory）中，每個執行緒都有一個私有的本地記憶體（local memory），本地記憶體中儲存了該執行緒以讀/寫共享變數的副本。本地記憶體是JMM的一個抽象概念，並不真實存在。它涵蓋了快取，寫緩衝區，暫存器以及其他的硬體和編譯器優化。
總結：什麼是Java記憶體模型：java記憶體模型簡稱jmm，定義了一個執行緒對另一個執行緒可見。共享變數存放在主記憶體中，每個執行緒都有自己的本地記憶體，當多個執行緒同時訪問一個資料的時候，可能本地記憶體沒有及時重新整理到主記憶體，所以就會發生執行緒安全問題。
Volatile
什麼是Volatile
Volatile 關鍵字的作用是變數在多個執行緒之間可見。
Volatile非原子性
注意: Volatile非原子性
volatile與synchronized區別
僅靠volatile不能保證執行緒的安全性。（原子性）
①volatile輕量級，只能修飾變數。synchronized重量級，還可修飾方法
②volatile只能保證資料的可見性，不能用來同步，因為多個執行緒併發訪問volatile修飾的變數不會阻塞。
synchronized不僅保證可見性，而且還保證原子性，因為，只有獲得了鎖的執行緒才能進入臨界區，從而保證臨界區中的所有語句都全部執行。多個執行緒爭搶synchronized鎖物件時，會出現阻塞。
執行緒安全性
執行緒安全性包括兩個方面，①可見性。②原子性。
從上面自增的例子中可以看出：僅僅使用volatile並不能保證執行緒安全性。而synchronized則可實現執行緒的安全性。
Vector與ArrayList區別
HasTable與HasMap
synchronizedMap
Collections.synchronized*(m) 將執行緒不安全額集合變為執行緒安全集合
ConcurrentHashMap
ConcurrentMap介面下有倆個重要的實現 :
ConcurrentHashMap
ConcurrentskipListMap (支援併發排序功能。彌補ConcurrentHas hMa p)
ConcurrentHashMap內部使用段(Segment)來表示這些不同的部分，每個段其實就是一個
小的HashTable,它們有自己的鎖。只要多個修改操作發生在不同的段上，它們就可以並
發進行。把一個整體分成了16個段(Segment.也就是最高支援16個執行緒的併發修改操作。
這也是在重執行緒場景時減小鎖的粒度從而降低鎖競爭的一種方案。並且程式碼中大多共享變
量使用volatile關鍵字宣告，目的是第一時間獲取修改的內容，效能非常好。
CountDownLatch
CountDownLatch類位於java.util.concurrent包下，利用它可以實現類似計數器的功能。比如有一個任務A，它要等待其他4個任務執行完畢之後才能執行，此時就可以利用CountDownLatch來實現這種功能了。
public class Test002 { public static void main(String[] args) throws InterruptedException { System.out.println("等待子執行緒執行完畢..."); CountDownLatch countDownLatch = new CountDownLatch(2); new Thread(new Runnable() { @Override public void run() { System.out.println("子執行緒," + Thread.currentThread().getName() + "開始執行..."); countDownLatch.countDown();// 每次減去1 System.out.println("子執行緒," + Thread.currentThread().getName() + "結束執行..."); } }).start(); new Thread(new Runnable() { @Override public void run() { System.out.println("子執行緒," + Thread.currentThread().getName() + "開始執行..."); countDownLatch.countDown(); System.out.println("子執行緒," + Thread.currentThread().getName() + "結束執行..."); } }).start(); countDownLatch.await();// 呼叫當前方法主執行緒阻塞 countDown結果為0, 阻塞變為執行狀態 System.out.println("兩個子執行緒執行完畢...."); System.out.println("繼續主執行緒執行.."); } }
CyclicBarrier
CyclicBarrier初始化時規定一個數目，然後計算呼叫了CyclicBarrier.await()進入等待的執行緒數。當執行緒數達到了這個數目時，所有進入等待狀態的執行緒被喚醒並繼續。
CyclicBarrier就象它名字的意思一樣，可看成是個障礙， 所有的執行緒必須到齊後才能一起通過這個障礙。
CyclicBarrier初始時還可帶一個Runnable的引數， 此Runnable任務在CyclicBarrier的數目達到後，所有其它執行緒被喚醒前被執行。
class Writer extends Thread { private CyclicBarrier cyclicBarrier; public Writer(CyclicBarrier cyclicBarrier){ this.cyclicBarrier=cyclicBarrier; } @Override public void run() { System.out.println("執行緒" + Thread.currentThread().getName() + ",正在寫入資料"); try { Thread.sleep(3000); } catch (Exception e) { // TODO: handle exception } System.out.println("執行緒" + Thread.currentThread().getName() + ",寫入資料成功....."); try { cyclicBarrier.await(); } catch (Exception e) { } System.out.println("所有執行緒執行完畢.........."); } } public class Test001 { public static void main(String[] args) { CyclicBarrier cyclicBarrier=new CyclicBarrier(5); for (int i = 0; i < 5; i++) { Writer writer = new Writer(cyclicBarrier); writer.start(); } } }
Semaphore
Semaphore是一種基於計數的訊號量。它可以設定一個閾值，基於此，多個執行緒競爭獲取許可訊號，做自己的申請後歸還，超過閾值後，執行緒申請許可訊號將會被阻塞。Semaphore可以用來構建一些物件池，資源池之類的，比如資料庫連線池，我們也可以建立計數為1的Semaphore，將其作為一種類似互斥鎖的機制，這也叫二元訊號量，表示兩種互斥狀態。它的用法如下：
availablePermits函式用來獲取當前可用的資源數量
wc.acquire(); //申請資源
wc.release();// 釋放資源
// 建立一個計數閾值為5的訊號量物件 // 只能5個執行緒同時訪問 Semaphore semp = new Semaphore(5); try { // 申請許可 semp.acquire(); try { // 業務邏輯 } catch (Exception e) { } finally { // 釋放許可 semp.release(); } } catch (InterruptedException e) { }
併發佇列
在併發佇列上JDK提供了兩套實現，一個是以ConcurrentLinkedQueue為代表的高效能隊
列，一個是以BlockingQueue介面為代表的阻塞佇列，無論哪種都繼承自Queue。
執行緒池作用
執行緒池是為突然大量爆發的執行緒設計的，通過有限的幾個固定執行緒為大量的操作服務，減少了建立和銷燬執行緒所需的時間，從而提高效率。
如果一個執行緒的時間非常長，就沒必要用執行緒池了(不是不能作長時間操作，而是不宜。)，況且我們還不能控制執行緒池中執行緒的開始、掛起、和中止。
執行緒池的分類
Executor框架的最頂層實現是ThreadPoolExecutor類，Executors工廠類中提供的newScheduledThreadPool、newFixedThreadPool、newCachedThreadPool方法其實也只是ThreadPoolExecutor的建構函式引數不同而已。通過傳入不同的引數，就可以構造出適用於不同應用場景下的執行緒池，那麼它的底層原理是怎樣實現的呢，這篇就來介紹下ThreadPoolExecutor執行緒池的執行過程。
corePoolSize： 核心池的大小。 當有任務來之後，就會建立一個執行緒去執行任務，當執行緒池中的執行緒數目達到corePoolSize後，就會把到達的任務放到快取佇列當中
maximumPoolSize： 執行緒池最大執行緒數，它表示線上程池中最多能建立多少個執行緒；
keepAliveTime： 表示執行緒沒有任務執行時最多保持多久時間會終止。
unit： 引數keepAliveTime的時間單位，有7種取值，在TimeUnit類中有7種靜態屬性
執行緒池四種建立方式
Java通過Executors（jdk1.5併發包）提供四種執行緒池，分別為：
newCachedThreadPool建立一個可快取執行緒池，如果執行緒池長度超過處理需要，可靈活回收空閒執行緒，若無可回收，則新建執行緒。
案例演示:
newFixedThreadPool 建立一個定長執行緒池，可控制執行緒最大併發數，超出的執行緒會在佇列中等待。
newScheduledThreadPool 建立一個定長執行緒池，支援定時及週期性任務執行。
newSingleThreadExecutor 建立一個單執行緒化的執行緒池，它只會用唯一的工作執行緒來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先順序)執行。
執行緒池原理剖析
提交一個任務到執行緒池中，執行緒池的處理流程如下：
1、判斷執行緒池裡的核心執行緒是否都在執行任務，如果不是（核心執行緒空閒或者還有核心執行緒沒有被建立）則建立一個新的工作執行緒來執行任務。如果核心執行緒都在執行任務，則進入下個流程。
2、執行緒池判斷工作佇列是否已滿，如果工作佇列沒有滿，則將新提交的任務儲存在這個工作佇列裡。如果工作佇列滿了，則進入下個流程。
3、判斷執行緒池裡的執行緒是否都處於工作狀態，如果沒有，則建立一個新的工作執行緒來執行任務。如果已經滿了，則交給飽和策略來處理這個任務。
合理配置執行緒池
要想合理的配置執行緒池，就必須首先分析任務特性，可以從以下幾個角度來進行分析：
任務的性質：CPU密集型任務，IO密集型任務和混合型任務。
任務的優先順序：高，中和低。
任務的執行時間：長，中和短。
任務的依賴性：是否依賴其他系統資源，如資料庫連線。
任務性質不同的任務可以用不同規模的執行緒池分開處理。CPU密集型任務配置儘可能少的執行緒數量，如配置Ncpu+1個執行緒的執行緒池。IO密集型任務則由於需要等待IO操作，執行緒並不是一直在執行任務，則配置儘可能多的執行緒，如2*Ncpu。混合型的任務，如果可以拆分，則將其拆分成一個CPU密集型任務和一個IO密集型任務，只要這兩個任務執行的時間相差不是太大，那麼分解後執行的吞吐率要高於序列執行的吞吐率，如果這兩個任務執行時間相差太大，則沒必要進行分解。我們可以通過Runtime.getRuntime().availableProcessors()方法獲得當前裝置的CPU個數。
優先順序不同的任務可以使用優先順序佇列PriorityBlockingQueue來處理。它可以讓優先順序高的任務先得到執行，需要注意的是如果一直有優先順序高的任務提交到佇列裡，那麼優先順序低的任務可能永遠不能執行。
執行時間不同的任務可以交給不同規模的執行緒池來處理，或者也可以使用優先順序佇列，讓執行時間短的任務先執行。
依賴資料庫連線池的任務，因為執行緒提交SQL後需要等待資料庫返回結果，如果等待的時間越長CPU空閒時間就越長，那麼執行緒數應該設定越大，這樣才能更好的利用CPU。
一般總結哦，有其他更好的方式，希望各位留言，謝謝。
CPU密集型時，任務可以少配置執行緒數，大概和機器的cpu核數相當，這樣可以使得每個執行緒都在執行任務
IO密集型時，大部分執行緒都阻塞，故需要多配置執行緒數，2*cpu核數
作業系統之名稱解釋：
某些程式花費了絕大多數時間在計算上，而其他則在等待I/O上花費了大多是時間，
前者稱為計算密集型（CPU密集型）computer-bound，後者稱為I/O密集型，I/O-bound。
Java鎖的深度化
悲觀鎖與樂觀鎖
悲觀鎖:悲觀鎖悲觀的認為每一次操作都會造成更新丟失問題，在每次查詢時加上排他鎖。
每次去拿資料的時候都認為別人會修改，所以每次在拿資料的時候都會上鎖，這樣別人想拿這個資料就會block直到它拿到鎖。傳統的關係型資料庫裡邊就用到了很多這種鎖機制，比如行鎖，表鎖等，讀鎖，寫鎖等，都是在做操作之前先上鎖。
Select * from xxx for update;
樂觀鎖:樂觀鎖會樂觀的認為每次查詢都不會造成更新丟失,利用版本欄位控制
重入鎖
鎖作為併發共享資料，保證一致性的工具，在JAVA平臺有多種實現(如 synchronized 和 ReentrantLock等等 ) 。這些已經寫好提供的鎖為我們開發提供了便利。
重入鎖，也叫做遞迴鎖，指的是同一執行緒 外層函式獲得鎖之後 ，內層遞迴函式仍然有獲取該鎖的程式碼，但不受影響。
讀寫鎖
相比Java中的鎖(Locks in Java)裡Lock實現，讀寫鎖更復雜一些。假設你的程式中涉及到對一些共享資源的讀和寫操作，且寫操作沒有讀操作那麼頻繁。在沒有寫操作的時候，兩個執行緒同時讀一個資源沒有任何問題，所以應該允許多個執行緒能在同時讀取共享資源。但是如果有一個執行緒想去寫這些共享資源，就不應該再有其它執行緒對該資源進行讀或寫（譯者注：也就是說：讀-讀能共存，讀-寫不能共存，寫-寫不能共存）。這就需要一個讀/寫鎖來解決這個問題。
CAS無鎖機制
（1）與鎖相比，使用比較交換（下文簡稱CAS）會使程式看起來更加複雜一些。但由於其非阻塞性，它對死鎖問題天生免疫，並且，執行緒間的相互影響也遠遠比基於鎖的方式要小。更為重要的是，使用無鎖的方式完全沒有鎖競爭帶來的系統開銷，也沒有執行緒間頻繁排程帶來的開銷，因此，它要比基於鎖的方式擁有更優越的效能。
（2）無鎖的好處：
第一，在高併發的情況下，它比有鎖的程式擁有更好的效能；
第二，它天生就是死鎖免疫的。
就憑藉這兩個優勢，就值得我們冒險嘗試使用無鎖的併發。
（3）CAS演算法的過程是這樣：它包含三個引數CAS(V,E,N): V表示要更新的變數，E表示預期值，N表示新值。僅當V值等於E值時，才會將V的值設為N，如果V值和E值不同，則說明已經有其他執行緒做了更新，則當前執行緒什麼都不做。最後，CAS返回當前V的真實值。
（4）CAS操作是抱著樂觀的態度進行的，它總是認為自己可以成功完成操作。當多個執行緒同時使用CAS操作一個變數時，只有一個會勝出，併成功更新，其餘均會失敗。失敗的執行緒不會被掛起，僅是被告知失敗，並且允許再次嘗試，當然也允許失敗的執行緒放棄操作。基於這樣的原理，CAS操作即使沒有鎖，也可以發現其他執行緒對當前執行緒的干擾，並進行恰當的處理。
（5）簡單地說，CAS需要你額外給出一個期望值，也就是你認為這個變數現在應該是什麼樣子的。如果變數不是你想象的那樣，那說明它已經被別人修改過了。你就重新讀取，再次嘗試修改就好了。
（6）在硬體層面，大部分的現代處理器都已經支援原子化的CAS指令。在JDK 5.0以後，虛擬機器便可以使用這個指令來實現併發操作和併發資料結構，並且，這種操作在虛擬機器中可以說是無處不在。
自旋鎖
自旋鎖是採用讓當前執行緒不停地的在迴圈體內執行實現的，當迴圈的條件被其他執行緒改變時 才能進入臨界區。
分散式鎖
如果想在不同的jvm中保證資料同步，使用分散式鎖技術。
有資料庫實現、快取實現、Zookeeper分散式鎖