java多线程学习笔记。
java多線程學習筆記
線程的優缺點：
- 多線程的好處：
- 線程的風險：
一、概念
????? ?1.進程：程序（任務）的執行過程--正在執行的（動態）?進程是資源（內存，文件）和線程的載體。
? ? ? ? ?每個進程都有獨立的代碼和數據空間（進程上下文），進程間的切換會有較大的開銷，一個進程包含1--n個線程。（進程是資源分配的最小單位）。
????? ?2.線程: 系統執行的最小單元（線程共享進程的資源）【一個進程可以有多個線程】
同一類線程共享代碼和數據空間，每個線程有獨立的運行棧和程序計數器(PC)，線程切換開銷小。（線程是cpu調度的最小單位）
????? ?3.線程的交互：互斥，同步
????? ?4.使用多線程的目的是更好的利用CPU資源
????? ?5.多線程：一個程序（進程）運行時產生了多個線程。?
????? ?6.并發與并行：
?
- 并行：多個CPU實例（多臺機器）同時執行一段處理邏輯，是真正的同時。又稱共行性，是指能處理多個同時性活動的能力；并行性指兩個或兩個以上事件或活動在同一時刻發生。在多道程序環境下，并行性使多個程序同一時刻可在不同CPU上同時執行。
- 并發：通過CPU調度算法（同一個CPU），讓用戶看上去同時執行（宏觀上來看是同時的），實際上從CPU操作層面不是真正的同時。并發往往在場景中有公用的資源，那么針對這個公用的資源往往產生瓶頸，我們會用tps或者qps來反應這個系統的處理能力。在微觀上他們都是序列被處理的，只不過資源不會在某一個上被阻塞(一般是通過時間片輪轉)。如果是同一時刻到達的請求也會根據優先級的不同，而先后進入隊列排隊等候執行。并發的實質是一個物理CPU(也可以多個物理CPU) 在若干道程序之間多路復用，并發性是對有限物理資源強制行使多用戶共享以提高效率。
- 并發和并行的區別：
1.并發是一次處理很多事情（一個人做多件事情），并行是同時做很多事情（多個人做很多事情）
2.并發是獨立執行過程的組合，而并行是同時執行（可能相關的）計算。
3.并發是兩個任務可以在重疊的時間段內啟動，運行和完成。并行是任務在同一時間運行，例如，在多核處理器上。
4.并行是指同時發生的兩個并發事件，具有并發的含義，而并發則不一定并行，也亦是說并發事件之間不一定要同一時刻發生。? -
通過多線程實現并發，并行：
- java中的Thread類定義了多線程，通過多線程可以實現并發或并行。
- 在CPU比較繁忙，資源不足的時候（開啟了很多進程），操作系統只為一個含有多線程的進程分配僅有的CPU資源，這些線程就會為自己盡量多搶時間片，這就是通過多線程實現并發，線程之間會競爭CPU資源爭取執行機會。
- 在CPU資源比較充足的時候，一個進程內的多線程，可以被分配到不同的CPU資源，這就是通過多線程實現并行。
- 至于多線程實現的是并發還是并行？上面所說，所寫多線程可能被分配到一個CPU內核中執行，也可能被分配到不同CPU執行，分配過程是操作系統所為，不可人為控制。所有，如果有人問我我所寫的多線程是并發還是并行的？我會說，都有可能。
- 不管并發還是并行，都提高了程序對CPU資源的利用率，最大限度地利用CPU資源。
二、java對線程的支持
? ? 1.Runnable接口
? ? 2.Thread類
????3.Callable接口
join()：線程A中調用線程B的B.join()方法，那么線程A放棄cpu資源，等待線程B執行完畢之后線程A再繼續執行。可以用來將并行的線程改為串行執行。并且只有線程A調用了start()方法之后才能調用join()方法。join是通過調用wait()方法來實現的。
yield():就是當前線程不忙的時候，暗示自己的資源可以讓出來。
Thread.yield();
- Yield是一個靜態的原生(native)方法
- Yield告訴當前正在執行的線程把運行機會交給線程池中擁有相同優先級的線程。
- Yield不能保證使得當前正在運行的線程迅速轉換到可運行的狀態
- 它僅能使一個線程從運行狀態轉到可運行狀態，而不是等待或阻塞狀態
- 放棄當前cpu資源，但放棄的時間不確定，有可能剛放棄，馬上又獲得cpu時間片。
?
wait():讓當前線程進入等待狀態，并釋放鎖，一直到其他線程調用當前線程的notify或者notifyall方法，或者超時，等待的線程才會被喚醒，進入可運行狀態。
notify：隨機喚醒等待同一資源的線程。
notifyall：喚醒所有等待同一資源的線程。
?
注：wait和notify必須被包含在synchronized里面，否則會拋異常，
? ? ? wait執行之后立馬釋放鎖，? notify執行之后，會繼續吧加鎖的代碼執行完了之后才釋放鎖。
?
ThreadLocal：線程可以用該類set()值，并且多線程相互之間set的值互不影響get的獲取。
InheritableThreadLocal：可以繼承父線程才值，但是如果子線程獲取值的同時，父線程修改了值，那么子線程獲取到的依然是舊的值。
?
?
Thread和Runnable的區別
????如果一個類繼承Thread，則不適合資源共享。但是如果實現了Runable接口的話，則很容易的實現資源共享。
總結：
實現Runnable接口比繼承Thread類所具有的優勢：
1）：適合多個相同的程序代碼的線程去處理同一個資源
2）：可以避免java中的單繼承的限制
3）：增加程序的健壯性，代碼可以被多個線程共享，代碼和數據獨立
4）：線程池只能放入實現Runable或callable類線程，不能直接放入繼承Thread的類
在java中，每次程序運行至少啟動2個線程。一個是main線程，一個是垃圾收集線程。因為每當使用java命令執行一個類的時候，實際上都會啟動一個ＪＶＭ，每一個ｊＶＭ實習在就是在操作系統中啟動了一個進程。
?
Callable和Runnale的區別
Callable可以有返回值和拋出異常。
?
??三、線程的狀態
? ? 線程和進程一樣分為五個階段：創建、就緒、運行、阻塞、終止。
?
?
1、新建狀態（New）：新創建了一個線程對象。
2、就緒狀態（Runnable）：線程對象創建后，其他線程調用了該對象的start()方法。該狀態的線程位于可運行線程池中，變得可運行，等待獲取CPU的使用權。
3、運行狀態（Running）：就緒狀態的線程獲取了CPU，執行程序代碼。
4、阻塞狀態（Blocked）：阻塞狀態是線程因為某種原因放棄CPU使用權，暫時停止運行。直到線程進入就緒狀態，才有機會轉到運行狀態。阻塞的情況分三種：
（一）、等待阻塞：運行的線程執行wait()方法，JVM會把該線程放入等待池中。(wait會釋放持有的鎖)
（二）、同步阻塞：運行的線程在獲取對象的同步鎖時，若該同步鎖被別的線程占用，則JVM會把該線程放入鎖池中。
（三）、其他阻塞：運行的線程執行sleep()或join()方法，或者發出了I/O請求時，JVM會把該線程置為阻塞狀態。當sleep()狀態超時、join()等待線程終止或者超時、或者I/O處理完畢時，線程重新轉入就緒狀態。（注意,sleep是不會釋放持有的鎖）
5、死亡狀態（Dead）：線程執行完了或者因異常退出了run()方法，該線程結束生命周期。
?
- 取消和中斷：
interrupt（）；
- 不安全的取消
單獨使用一個取消標志位.
Stop(),suspend(),resume()是過期的api，很大的副作用，容易導致死鎖或者數據不一致。
- 安全的終止線程
? ? ??使用線程的中斷 :
interrupt() 中斷線程標記，本質是將線程的中斷標志位設為true，其他線程向需要中斷的線程打個招呼。是否真正進行中斷由線程自己決定。
isInterrupted() ：線程檢查自己的中斷標志位，不會將狀態重置。
interrupted()：靜態方法Thread.interrupted()?返回當前中斷狀態并且將中斷標志位復位為false：配合Thread.curentThread().interrupt(),來中斷當前線程。
由上面的中斷機制可知Java里是沒有搶占式任務，只有協作式任務。
為何要用中斷，線程處于阻塞（如調用了java的sleep,wait等等方法時）的時候，是不會理會我們自己設置的取消標志位的，但是這些阻塞方法都會檢查線程的中斷標志位
當使用
Thread?t1 = new Thread(new MyThread());
t1.interrupt();
t1設置的中斷標記不會作用到MyThread類中。
?
中斷標志是Thread的而非Runnable的。
在沉睡中停止：當wait或sleep遇到interrupt，會拋出InterruptedException
?
- 不可中斷的阻塞
?java.io中的同步 socket?I/O:inputSream?和outputStream中的read和write方法都不響應中斷。通過關閉底層的Socket來使其拋出一個SocketException。
java.nio中的同步I/O：
Selector的異步I/O：
注：在Thread中通過覆寫interrupt來封裝非標準取消。
public class OverrideInterrupt extends Thread {private final Socket socket;private final InputStream in;public OverrideInterrupt(Socket socket, InputStream in) {this.socket = socket;this.in = in;}@Overridepublic void interrupt() {try {//關閉底層的套接字socket.close();} catch (IOException e) {e.printStackTrace();//.....}finally {//同時中斷線程super.interrupt();}}@Overridepublic void run(){try{byte[] buf = new byte[10];while(true){//}}catch (Exception e){//允許線程退出}} }?
線程間的通信：
通過管道來實現，pipedStream（pipedInputStream，pipedOutputStream）和pipedWriter，pipedReader
四、 線程調度
線程的調度
1、調整線程優先級：Java線程有優先級，優先級高的線程會獲得較多的運行機會。
?
Java線程的優先級用整數表示，取值范圍是1~10，Thread類有以下三個靜態常量：
static int MAX_PRIORITY
????????? 線程可以具有的最高優先級，取值為10。
static int MIN_PRIORITY
????????? 線程可以具有的最低優先級，取值為1。
static int NORM_PRIORITY
????????? 分配給線程的默認優先級，取值為5。
?
Thread類的setPriority()和getPriority()方法分別用來設置和獲取線程的優先級。
?
每個線程都有默認的優先級。主線程的默認優先級為Thread.NORM_PRIORITY。
線程的優先級有繼承關系，比如A線程中創建了B線程，那么B將和A具有相同的優先級。
JVM提供了10個線程優先級，但與常見的操作系統都不能很好的映射。如果希望程序能移植到各個操作系統中，應該僅僅使用Thread類有以下三個靜態常量作為優先級，這樣能保證同樣的優先級采用了同樣的調度方式。
?
2、線程睡眠：Thread.sleep(long millis)方法，使線程轉到阻塞狀態。millis參數設定睡眠的時間，以毫秒為單位。當睡眠結束后，就轉為就緒（Runnable）狀態。sleep()平臺移植性好。
?
3、線程等待：Object類中的wait()方法，導致當前的線程等待，直到其他線程調用此對象的 notify() 方法或 notifyAll() 喚醒方法。這個兩個喚醒方法也是Object類中的方法，行為等價于調用 wait(0) 一樣。
?
4、線程讓步：Thread.yield() 方法，暫停當前正在執行的線程對象，把執行機會讓給相同或者更高優先級的線程。
?
5、線程加入：join()方法，等待其他線程終止。在當前線程中調用另一個線程的join()方法，則當前線程轉入阻塞狀態，直到另一個進程運行結束，當前線程再由阻塞轉為就緒狀態。
?
6、線程喚醒：Object類中的notify()方法，喚醒在此對象監視器上等待的單個線程。如果所有線程都在此對象上等待，則會選擇喚醒其中一個線程。選擇是任意性的，并在對實現做出決定時發生。線程通過調用其中一個 wait 方法，在對象的監視器上等待。 直到當前的線程放棄此對象上的鎖定，才能繼續執行被喚醒的線程。被喚醒的線程將以常規方式與在該對象上主動同步的其他所有線程進行競爭；例如，喚醒的線程在作為鎖定此對象的下一個線程方面沒有可靠的特權或劣勢。類似的方法還有一個notifyAll()，喚醒在此對象監視器上等待的所有線程。
?注意：Thread中suspend()和resume()兩個方法在JDK1.5中已經廢除，不再介紹。因為有死鎖傾向。
五、常用函數?
?六、volitale
(1)java內存與多線程中的三個概念
1. 原子性：指一些操作要么全部執行，要么全部不執行。
在java中，基本數據類型的讀取賦值都是原子性操作。即這些操作是不可被中斷的，要么執行，要么不執行。
i=3; //原子性;i = i+2;++i;j = i;2.可見性：多個線程操作一個變量，變量值被線程修改時，其他線程能夠立即看見修改后的值。
每個線程都有自己的線程棧，當線程執行需要的數據時，會再主存（內存）中數據拷貝到自己的線程棧中，然后對自己線程棧中的副本進行操作，操作完了之后將數據save回到內存中。
java提供的volitale可以保證數據的可見性
3.有序性：程序按照代碼的先后順序執行，編譯器編譯時會對代碼進行指令重排，編譯器通過限制語句的執行順序來保證程序的正確性，重排之后的代碼可能和我們寫的時候的順序不一樣。?
在單線程中，改變指令的順序可能不會產生不良后果，但是在多線程中就不一定了。例如：
?
//線程1: context = loadContext(); //語句1 inited = true; //語句2//線程2: while(!inited ){sleep() } doSomethingwithconfig(context);由于語句1和語句2沒有數據依賴性，所以編譯器可能會將兩條指令重新排序，如果先執行語句2，這時線程1被阻塞，然后線程2的while循環條件不滿足，接著往下執行，但是由于context沒有賦值，于是會產生錯誤。
(2)volitale關鍵字的作用
volitale保障了可見性和一定程度的有序性，但是不保證原子性。
?
一旦一個共享變量（類的成員變量、類的靜態成員變量）被volatile修飾之后，那么就具備了兩層語義：
1）保證了不同線程對這個變量進行操作時的可見性，即一個線程修改了某個變量的值，這新值對其他線程來說是立即可見的。
2）禁止進行指令重排序。
先看一段代碼，假如線程1先執行，線程2后執行：
//線程1 boolean stop = false; while(!stop){doSomething(); }//線程2 stop = true;?
這段代碼是很典型的一段代碼，很多人在中斷線程時可能都會采用這種標記辦法。但是事實上，這段代碼會完全運行正確么？即一定會將線程中斷么？不一定，也許在大多數時候，這個代碼能夠把線程中斷，但是也有可能會導致無法中斷線程（雖然這個可能性很小，但是只要一旦發生這種情況就會造成死循環了）。
下面解釋一下這段代碼為何有可能導致無法中斷線程。在前面已經解釋過，每個線程在運行過程中都有自己的工作內存，那么線程1在運行的時候，會將stop變量的值拷貝一份放在自己的工作內存當中。
那么當線程2更改了stop變量的值之后，但是還沒來得及寫入主存當中，線程2轉去做其他事情了，那么線程1由于不知道線程2對stop變量的更改，因此還會一直循環下去。
但是用volatile修飾之后就變得不一樣了：
第一：使用volatile關鍵字會強制將修改的值立即寫入主存；
第二：使用volatile關鍵字的話，當線程2進行修改時，會導致線程1的工作內存中緩存變量stop的緩存行無效；
第三：由于線程1的工作內存中緩存變量stop的緩存行無效，所以線程1再次讀取變量stop的值時會去主存讀取。
那么在線程2修改stop值時（當然這里包括2個操作，修改線程2工作內存中的值，然后將修改后的值寫入內存），會使得線程1的工作內存中緩存變量stop的緩存行無效，然后線程1讀取時，發現自己的緩存行無效，它會等待緩存行對應的主存地址被更新之后，然后去對應的主存讀取最新的值。
那么線程1讀取到的就是最新的正確的值。
2、volitale關鍵字不能保證原子性?
下面看一個例子：?
?
根源就在這里，自增操作不是原子性操作，而且volatile也無法保證對變量的任何操作都是原子性的。
3、volitale關鍵字在一定程度上保證有序性
在前面提到volatile關鍵字能禁止指令重排序，所以volatile能在一定程度上保證有序性。
volatile關鍵字禁止指令重排序有兩層意思：
1）當程序執行到volatile變量的讀操作或者寫操作時，在其前面的操作的更改肯定全部已經進行，且結果已經對后面的操作可見；在其后面的操作肯定還沒有進行；
2）在進行指令優化時，不能將在對volatile變量訪問的語句放在其后面執行，也不能把volatile變量后面的語句放到其前面執行。
?
即使不使用volatile關鍵字，jvm也會盡量保證變量的可見性，比如sleep一段時間后，其它線程再去取就能取到最新，但是如果cpu一直很繁忙，那么就不能保證可見性，volatile是強制保證變量的可見性。
volatile修飾引用類型的時候，它只關心引用的變化，不關心引用內部屬性的變化，所以volatile最好只修飾基本類型，不要去修飾引用類型。
結論：當沒有把握的時候，最好不要使用。
volatile基于內存屏障實現，保證一定的有序性
volatile基于實現保證可見性
總線風暴：
由于Volatile的MESI緩存一致性協議，需要不斷的從主內存嗅探和cas不斷循環，無效交互會導致總線帶寬達到峰值。
解決辦法：部分volatile和cas使用synchronize
鎖
概念：
鎖(lock)或互斥(mutex)是一種同步機制，用于在有許多執行線程的環境中強制對資源的訪問限制。鎖旨在強制實施互斥排他、并發控制策略。
1、鎖開銷 lock overhead 鎖占用內存空間、 cpu初始化和銷毀鎖、獲取和釋放鎖的時間。程序使用的鎖越多，相應的鎖開銷越大
2、鎖競爭 lock contention 一個進程或線程試圖獲取另一個進程或線程持有的鎖，就會發生鎖競爭。鎖粒度越小，發生鎖競爭的可能性就越小
3、死鎖 deadlock 至少兩個任務中的每一個都等待另一個任務持有的鎖的情況鎖粒度是衡量鎖保護的數據量大小，通常選擇粗粒度的鎖(鎖的數量少，每個鎖保護大量的數據)，在當單進程訪問受保護的數據時鎖開銷小，但是當多個進程同時訪問時性能很差。因為增大了鎖的競爭。相反，使用細粒度的鎖(鎖數量多，每個鎖保護少量的數據)增加了鎖的開銷但是減少了鎖競爭。例如數據庫中，鎖的粒度有表鎖、頁鎖、行鎖、字段鎖、字段的一部分鎖?
java的線程是映射到操作系統原生線程之上的，如果要阻塞或喚醒一個線程就需要操作系統介入，線程狀態切換會消耗cpu的處理時間。
1.鎖的分類（按特性）：
- 公平鎖/非公平鎖
- 可重入鎖(遞歸鎖)
- 獨享鎖/共享鎖
- 互斥鎖/讀寫鎖
- 樂觀鎖/悲觀鎖
- 分段鎖
- 偏向鎖/輕量級鎖/重量級鎖
- 自旋鎖
1.1公平鎖/非公平鎖：
公平鎖：指多個線程按照申請鎖的順序來獲取鎖。CLH隊列排隊
非公平鎖：不按照申請鎖的順序來獲取鎖。可能會造成優先級反轉或者饑餓現象，如:synchronized。 上來不排隊，直接插隊。
區別：非公平鎖的吞吐量比公平鎖大；
1.2可重入鎖(遞歸鎖):
同一個線程在外層方法獲取鎖的時候，在進入內層方法會自動獲取鎖。好處是可一定程度避免死鎖。如：ReentrantLock，synchronized
可重入鎖加鎖和解鎖的次數要相等。
1.3獨享鎖/共享鎖：
都是通過AQS來實現的
獨享鎖：一次只能被一個線程所持有，如：synchronized，ReentrantLock，ReadWriteLock的寫鎖。
共享鎖：可被多個線程所持有，如：ReadWriteLock的讀鎖。
1.4互斥鎖/讀寫鎖:
互斥鎖 :ReentrantLock
讀寫鎖:ReadWriteLock
1.5分段鎖：
分段鎖的設計目的是細化鎖的粒度，當操作不需要更新整個數組的時候，就僅僅針對數組中的一項進行加鎖操作；
如：ConcurrentHashMap 其并發的實現就是通過分段鎖的形式來實現高效的并發操作。
ConcurrentHashMap中的分段鎖稱為Segment，它即類似于HashMap（JDK7與JDK8中HashMap的實現）的結構，即內部擁有一個Entry數組，數組中的每個元素又是一個鏈表；同時又是一個ReentrantLock（Segment繼承了ReentrantLock)。
當需要put元素的時候，并不是對整個hashmap進行加鎖，而是先通過hashcode來知道他要放在那一個分段中，然后對這個分段進行加鎖，所以當多線程put的時候，只要不是放在一個分段中，就實現了真正的并行的插入。
但是，在統計size的時候，可就是獲取hashmap全局信息的時候，就需要獲取所有的分段鎖才能統計。
1.6偏向鎖/輕量級鎖/重量級鎖：
是針對Synchronized的狀態的鎖，這三種鎖的狀態是通過對象監視器在對象頭中的字段來表明的。
從jdk1.6開始為了減少獲得鎖和釋放鎖帶來的性能消耗，引入了“偏向鎖”和“輕量級鎖”。
偏向鎖：是指一段同步代碼一直被一個線程所訪問，那么該線程會自動獲取鎖。降低獲取鎖的代價。
輕量級鎖：是指當鎖是偏向鎖的時候，被另一個線程所訪問，偏向鎖就會升級為輕量級鎖，其他線程會通過自旋的形式嘗試獲取鎖，不會阻塞，提高性能。
重量級鎖：是指當鎖為輕量級鎖的時候，另一個線程雖然是自旋，但自旋不會一直持續下去，當自旋一定次數的時候，還沒有獲取到鎖，就會進入阻塞，該鎖膨脹為重量級鎖。重量級鎖會讓其他申請的線程進入阻塞，性能降低。
鎖共有四種狀態，級別從低到高分別是：無鎖狀態、偏向鎖狀態、輕量級鎖狀態和重量級鎖狀態。隨著競爭情況鎖狀態逐漸升級、鎖可以升級但不能降級。
詳解轉自：https://blog.csdn.net/u010648018/article/details/79750608
1.7自旋鎖：
自旋鎖是指嘗試獲取鎖的線程不會立即阻塞，而是采用循環的方式去嘗試獲取鎖，這樣的好處是減少線程上下文切換的消耗，缺點是循環會消耗CPU。
public class SpinLock {private AtomicReference<Thread> sign =new AtomicReference<>();public void lock(){Thread current = Thread.currentThread();while(!sign.compareAndSet(null, current)){}}public void unlock (){Thread current = Thread.currentThread();sign.compareAndSet(current, null);}}使用了CAS原子操作，lock函數將owner設置為當前線程，并且預測原來的值為空。unlock函數將owner設置為null，并且預測值為當前線程。
當有第二個線程調用lock操作時由于owner值不為空，導致循環一直被執行，直至第一個線程調用unlock函數將owner設置為null，第二個線程才能進入臨界區。
由于自旋鎖只是將當前線程不停地執行循環體，不進行線程狀態的改變，所以響應速度更快。但當線程數不停增加時，性能下降明顯，因為每個線程都需要執行，占用CPU時間。如果線程競爭不激烈，并且保持鎖的時間段。適合使用自旋鎖。
注：該例子為非公平鎖，獲得鎖的先后順序，不會按照進入lock的先后順序進行。
?
1.8樂觀鎖/悲觀鎖:
悲觀鎖：（Pessimistic Lock）它指的是對數據被外界（包括本系統當前的其他事務，以及來自外部系統的事務處理）修改持保守態度。有極強的占有和排他性。整個過程，數據呈現鎖死狀態，悲觀鎖一般依靠數據庫的鎖機制。悲觀的認為，不加鎖的并發操作一定會出問題
樂觀鎖：（ Optimistic Locking ）因為悲觀鎖往往依靠數據庫的鎖機制來實現，這樣對數據庫的性能有影響，樂觀鎖解決了這個問題，通過數據版本機制來實現樂觀鎖，給數據制定一個版本，讀取數據的時候把版本一起讀出來，更新數據時，版本號加1，在提交的時候，把讀取的版本號和數據庫當前的版本號進行比較，如果提交的版本號大于數據庫版本號，則執行更新，否則失敗。樂觀的認為，不加鎖的并發操作是沒有事情的。
悲觀鎖就是java的鎖機制，樂觀鎖就是不加鎖，而通過CAS算法來實現。
java中的樂觀鎖：通過CAS來實現樂觀鎖的思想，比如AtomicInteger。當多個線程嘗試使用CAS同時更新一個變量時，只有一個線程操作能執行成功，其他的都執行失敗，并且失敗的線程不會被掛起，并且可以再次嘗試（循環）。
CAS操作中包含三個操作數：
?V：需要讀寫的內存位置
?A：用于比較的預期原值，類似數據的版本號。
?B：將被寫入的新值
如果V的值與A的值相匹配，那么處理器就會講該位置更新為B。反之，不做操作。?
CAS缺點：
1.ABA問題：線程1讀取值為B，其他線程將A改為B再改為A，那么線程1最后去比較的時候，是能匹配的，但是其實值在中途已經被其他線程改過了。通過每次修改加標識（如版本號）來解決，如AtomicStampedReference就是這樣解決的。
2.開銷大：因為可能會自旋（循環），所以會有很大的開銷。如果JVM能支持處理器提供的pause指令，那么在效率上會有一定的提升。
3.只能保證一個共享變量的原子操作：多個共享變量就會出現問題。通過將多個變量封裝到一個對象中來解決，AtomicReference提供了保證引用對象之間的原子性。
當線程競爭少的時候使用樂光鎖，當線程競爭大的時候就直接使用悲觀鎖。
2.synchronized
多線程訪問同步方法的7種情況：
串行執行
并行方法，不是一個對象。
串行執行，只有一個Class對象
串行執行
串行，this是同一個
?并行執行，鎖對象不是同一個
synchronized會自動釋放，Lock等不會
核心思想
例外：鎖對象是*.class以及synchronized修飾的是static方法的時候，所有對象共用同一把類鎖（對應2、3、4、6種情況）
ps:不能使用string常量，Integer,Long來做鎖，因為重寫了equals，雖然連個字符串相等，但是實際上不是一個對象。要使用的話要使用，string.intern()；
synchronized（"A"）;synchronized（"A"）; 兩個A雖然相等，但是實際上是兩個對象。
性質：
1、可重入：
? 同一個線程的外層函數獲取鎖后，內層函數可以直接再次獲取該鎖。
2、不可中斷
原理
1、加鎖和釋放鎖的原理：Monitor
2、可重入原理：加鎖次數計數器。
3、可見性原理：內存模型圖
https://www.cnblogs.com/paddix/p/5367116.html
https://www.jianshu.com/p/d53bf830fa09
http://www.importnew.com/21866.html
實現原理：https://blog.csdn.net/thousa_ho/article/details/77992743
https://ifeve.com/java-synchronized/?tdsourcetag=s_pcqq_aiomsg
缺點
1、效率低
- 鎖的釋放情況少
- 視圖獲取鎖時不能設置超時時間
- 不能中斷一個正在視圖獲取鎖的線程
2、靈活度較差
- 加鎖和釋放鎖的時機單一
- 每個鎖僅有單一的對象
3、無法知道是否成功獲取到鎖
用法：
對象鎖：只要多線程訪問的是同一個對象（new?object（）），就會有鎖。
類鎖：多線程訪問的是對象屬于同一個類型，才會有鎖。
注：無論synchronized怎么使用（修飾方法或者修飾代碼塊，相同或者不同的方法或者代碼塊）
? ? ? ?只要是對象鎖，同一個對象就會有鎖；
? ? ? ?只要是類鎖，只要是同一個類就會有鎖。
1、synchronized 修飾方法時?
???a.修飾非靜態方法時，鎖住的是對象
?b.修飾靜態方法時，鎖住的是類
2.synchronized修飾代碼塊
a.靜態方法中的代碼塊，只能synchronized（obj.class）,鎖住類
b.非靜態方法中的代碼塊，synchronized既可以鎖對象，也可以是類，如：
synchronized(this)//當前對象
synchronized(obj)//某個對象
synchronized(obj.class)//某個對象的類型
?注：synchronized關鍵字不會被子類繼承，override的時候，如果沒有重寫則可以繼承，可以通過子類的鎖調用父類的加鎖方法。
?
?
注意點
1、鎖對象不能為空、作用域不宜過大、避免死鎖
2、盡量使用JUC包下的類，再考慮Synchronized，再考慮Lock
3.Lock
https://www.cnblogs.com/dolphin0520/p/3923167.html
https://www.cnblogs.com/aishangJava/p/6555291.html
ReentrantLock：https://blog.csdn.net/u014730165/article/details/82144848
ReentrantReadWriteLock：https://www.cnblogs.com/zaizhoumo/p/7782941.html
?
AQS:https://www.cnblogs.com/daydaynobug/p/6752837.html
https://blog.csdn.net/zhangdong2012/article/details/79983404
設計模式：模板方法
CLH隊列：雙向鏈表
?
?
?
4.lock和synchronized的區別
https://www.cnblogs.com/iyyy/p/7993788.html
https://blog.csdn.net/u012403290/article/details/64910926?locationNum=11&fps=1
線程池
1.?線程池的優點
- 降低資源的消耗
- 提高響應速度，任務：T1創建線程時間，T2任務執行時間，T3線程銷毀時間，線程池沒有或者減少T1和T3
- 提高線程的可管理性。
2.?線程池的主要處理流程
1）線程池判斷核心線程池里的線程是否都在執行任務。如果不是，則創建一個新的工作線程來執行任務。如果核心線程池里的線程都在執行任務，則進入下個流程。
2）線程池判斷工作隊列是否已經滿。如果工作隊列沒有滿，則將新提交的任務存儲在這個工作隊列里。如果工作隊列滿了，則進入下個流程。
3）線程池判斷線程池的線程是否都處于工作狀態。如果沒有，則創建一個新的工作線程來執行任務。如果已經滿了，則交給飽和策略來處理這個任務。
3.?ThreadPoolExecutor
1）如果當前運行的線程少于corePoolSize，則創建新線程來執行任務（注意，執行這一步驟需要獲取全局鎖）。
2）如果運行的線程等于或多于corePoolSize，則將任務加入BlockingQueue。
3）如果無法將任務加入BlockingQueue（隊列已滿），則創建新的線程來處理任務（注意，執行這一步驟需要獲取全局鎖）。
4）如果創建新線程將使當前運行的線程超出maximumPoolSize，任務將被拒絕，并調用RejectedExecutionHandler.rejectedExecution()方法。
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler)
corePoolSize
線程池中的核心線程數，當提交一個任務時，線程池創建一個新線程執行任務，直到當前線程數等于corePoolSize；
如果當前線程數為corePoolSize，繼續提交的任務被保存到阻塞隊列中，等待被執行；
如果執行了線程池的prestartAllCoreThreads()方法，線程池會提前創建并啟動所有核心線程。
maximumPoolSize
線程池中允許的最大線程數。如果當前阻塞隊列滿了，且繼續提交任務，則創建新的線程執行任務，前提是當前線程數小于maximumPoolSize
keepAliveTime
線程空閑時的存活時間，即當線程沒有任務執行時，繼續存活的時間。默認情況下，該參數只在線程數大于corePoolSize時才有用
TimeUnit
keepAliveTime的時間單位
workQueue
workQueue必須是BlockingQueue阻塞隊列。當線程池中的線程數超過它的corePoolSize的時候，線程會進入阻塞隊列進行阻塞等待。通過workQueue，線程池實現了阻塞功能
threadFactory
創建線程的工廠，通過自定義的線程工廠可以給每個新建的線程設置一個具有識別度的線程名
Executors靜態工廠里默認的threadFactory，線程的命名規則是“pool-數字-thread-數字”
RejectedExecutionHandler（飽和策略）
線程池的飽和策略，當阻塞隊列滿了，且沒有空閑的工作線程，如果繼續提交任務，必須采取一種策略處理該任務，線程池提供了4種策略：
（1）AbortPolicy：直接拋出異常，默認策略；
（2）CallerRunsPolicy：用調用者所在的線程來執行任務；
（3）DiscardOldestPolicy：丟棄阻塞隊列中靠最前的任務，并執行當前任務；
（4）DiscardPolicy：直接丟棄任務；
當然也可以根據應用場景實現RejectedExecutionHandler接口，自定義飽和策略，如記錄日志或持久化存儲不能處理的任務。
?
關閉線程池
ShutDown():interrupt方法來終止線程
shutDownNow() 嘗試停止所有正在執行的線程
????? ?
合理地配置線程池
? ? ? ? 線程數配置：
-
任務：計算密集型，IO密集型，混合型
-
計算密集型=計算機的cpu數或計算機的cpu數+1（應付頁缺失）
-
IO密集型=計算機的cpu數*2
-
混合型，拆分成計算密集型，IO密集型
-
Runtime.getRuntime().availableProcessors();當前機器中的cpu核心個數
-
盡量有界隊列，不要使用無界隊列
?
Executor框架調度模型：
在HotSpot VM的線程模型中，Java線程（java.lang.Thread）被一對一映射為本地操作系統線程。Java線程啟動時會創建一個本地操作系統線程；當該Java線程終止時，這個操作系統線程也會被回收。操作系統會調度所有線程并將它們分配給可用的CPU。
在上層，Java多線程程序通常把應用分解為若干個任務，然后使用用戶級的調度器（Executor框架）將這些任務映射為固定數量的線程；在底層，操作系統內核將這些線程映射到硬件處理器上。
應用程序通過Executor框架控制上層的調度；而下層的調度由操作系統內核控制，下層的調度不受應用程序的控制。
?
?
三大組成部分：任務，任務的執行，異步計算的結果
????????
任務
包括被執行任務需要實現的接口：Runnable接口或Callable接口。
任務的執行
包括任務執行機制的核心接口Executor，以及繼承自Executor的ExecutorService接口。Executor框架有兩個關鍵類實現了ExecutorService接口（ThreadPoolExecutor和ScheduledThreadPoolExecutor）。
異步計算的結果
包括接口Future和實現Future接口的FutureTask類。
成員結構
Executor是一個接口，它是Executor框架的基礎，它將任務的提交與任務的執行分離開來。
ExecutorService接口繼承了Executor，在其上做了一些shutdown()、submit()的擴展，可以說是真正的線程池接口；
AbstractExecutorService抽象類實現了ExecutorService接口中的大部分方法；
ThreadPoolExecutor是線程池的核心實現類，用來執行被提交的任務。
ScheduledExecutorService接口繼承了ExecutorService接口，提供了帶"周期執行"功能ExecutorService；
ScheduledThreadPoolExecutor是一個實現類，可以在給定的延遲后運行命令，或者定期執行命令。ScheduledThreadPoolExecutor比Timer更靈活，功能更強大。
Future接口和實現Future接口的FutureTask類，代表異步計算的結果。
Runnable接口和Callable接口的實現類，都可以被ThreadPoolExecutor或Scheduled-ThreadPoolExecutor執行。
Executor框架基本使用流程
主線程首先要創建實現Runnable或者Callable接口的任務對象。
工具類Executors可以把一個Runnable對象封裝為一個Callable對象（Executors.callable（Runnable task）或Executors.callable（Runnable task，Object resule））。然后可以把Runnable對象直接交給ExecutorService執行（ExecutorService.execute（Runnablecommand））；或者也可以把Runnable對象或Callable對象提交給ExecutorService執行（Executor-Service.submit（Runnable task）或ExecutorService.submit（Callable<T>task））。
如果執行ExecutorService.submit（…），ExecutorService將返回一個實現Future接口的對象（到目前為止的JDK中，返回的是FutureTask對象）。由于FutureTask實現了Runnable，程序員也可以創建FutureTask，然后直接交給ExecutorService執行。
最后，主線程可以執行FutureTask.get()方法來等待任務執行完成。主線程也可以執行FutureTask.cancel（boolean mayInterruptIfRunning）來取消此任務的執行。
?
ThreadPoolExecutor通常使用工廠類Executors來創建。Executors可以創建3種類型的ThreadPoolExecutor：SingleThreadExecutor、FixedThreadPool和CachedThreadPool。
FixedThreadPool
創建使用固定線程數的FixedThreadPool的API。適用于為了滿足資源管理的需求，而需要限制當前線程數量的應用場景，適用于負載比較重的服務器。FixedThreadPool的corePoolSize和maximumPoolSize都被設置為創建FixedThreadPool時指定的參數nThreads。
當線程池中的線程數大于corePoolSize時，keepAliveTime為多余的空閑線程等待新任務的最長時間，超過這個時間后多余的線程將被終止。這里把keepAliveTime設置為0L，意味著多余的空閑線程會被立即終止。
FixedThreadPool使用無界隊列LinkedBlockingQueue作為線程池的工作隊列（隊列的容量為Integer.MAX_VALUE）。使用無界隊列作為工作隊列會對線程池帶來如下影響。
1）當線程池中的線程數達到corePoolSize后，新任務將在無界隊列中等待，因此線程池中的線程數不會超過corePoolSize。
2）由于1，使用無界隊列時maximumPoolSize將是一個無效參數。
3）由于1和2，使用無界隊列時keepAliveTime將是一個無效參數。
4）由于使用無界隊列，運行中的FixedThreadPool（未執行方法shutdown()或
shutdownNow()）不會拒絕任務（不會調用RejectedExecutionHandler.rejectedExecution方法）。
SingleThreadExecutor
創建使用單個線程的SingleThread-Executor的API，適用于需要保證順序地執行各個任務；并且在任意時間點，不會有多個線程是活動的應用場景。
corePoolSize和maximumPoolSize被設置為1。其他參數與FixedThreadPool相同。SingleThreadExecutor使用無界隊列LinkedBlockingQueue作為線程池的工作隊列（隊列的容量為Integer.MAX_VALUE）。
CachedThreadPool
創建一個會根據需要創建新線程的CachedThreadPool的API。大小無界的線程池，適用于執行很多的短期異步任務的小程序，或者是負載較輕的服務器。
corePoolSize被設置為0，即corePool為空；maximumPoolSize被設置為Integer.MAX_VALUE，即maximumPool是無界的。這里把keepAliveTime設置為60L，意味著CachedThreadPool中的空閑線程等待新任務的最長時間為60秒，空閑線程超過60秒后將會被終止。
FixedThreadPool和SingleThreadExecutor使用無界隊列LinkedBlockingQueue作為線程池的工作隊列。CachedThreadPool使用沒有容量的SynchronousQueue作為線程池的工作隊列，但CachedThreadPool的maximumPool是無界的。這意味著，如果主線程提交任務的速度高于maximumPool中線程處理任務的速度時，CachedThreadPool會不斷創建新線程。極端情況下，CachedThreadPool會因為創建過多線程而耗盡CPU和內存資源。
WorkStealingPool
利用所有運行的處理器數目來創建一個工作竊取的線程池，使用forkjoin實現。
ScheduledThreadPoolExecutor
使用工廠類Executors來創建。Executors可以創建2種類
型的ScheduledThreadPoolExecutor，如下。
·ScheduledThreadPoolExecutor。包含若干個線程的ScheduledThreadPoolExecutor。
·SingleThreadScheduledExecutor。只包含一個線程的ScheduledThreadPoolExecutor。
ScheduledThreadPoolExecutor適用于需要多個后臺線程執行周期任務，同時為了滿足資源管理的需求而需要限制后臺線程的數量的應用場景。
SingleThreadScheduledExecutor適用于需要單個后臺線程執行周期任務，同時需要保證順序地執行各個任務的應用場景。
?
對這4個步驟的說明。
1）線程1從DelayQueue中獲取已到期的ScheduledFutureTask（DelayQueue.take()）。到期任務是指ScheduledFutureTask的time大于等于當前時間。
2）線程1執行這個ScheduledFutureTask。
3）線程1修改ScheduledFutureTask的time變量為下次將要被執行的時間。
4）線程1把這個修改time之后的ScheduledFutureTask放回DelayQueue中（Delay-
Queue.add()）。
有關提交定時任務的四個方法：
//向定時任務線程池提交一個延時Runnable任務（僅執行一次）
public?ScheduledFuture<?> schedule(Runnable command, long?delay, TimeUnit unit)
?
//向定時任務線程池提交一個延時的Callable任務（僅執行一次）
public?<V> ScheduledFuture<V> schedule(Callable<V> callable, long?delay, TimeUnit unit);
?
//向定時任務線程池提交一個固定時間間隔執行的任務
public?ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long?initialDelay,
??????????????????????????????????????????????????long?period, TimeUnit unit)
?
//向定時任務線程池提交一個固定延時間隔執行的任務
public?ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long?initialDelay,
??????????????????????????????????????????????????????long?delay, TimeUnit unit);
固定時間間隔的任務不論每次任務花費多少時間，下次任務開始執行時間是確定的，當然執行任務的時間不能超過執行周期。
固定延時間隔的任務是指每次執行完任務以后都延時一個固定的時間。由于操作系統調度以及每次任務執行的語句可能不同，所以每次任務執行所花費的時間是不確定的，也就導致了每次任務的執行周期存在一定的波動。
注意：定時或延時任務中所涉及到時間、周期不能保證實時性及準確性，實際運行中會有一定的誤差。
ScheduleThreadPoolExecutor與Timer相比的優勢:
（1）Timer是基于絕對時間的延時執行或周期執行，當系統時間改變，則任務的執行會受到的影響。而ScheduleThreadPoolExecutore中，任務時基于相對時間進行周期或延時操作。
（2）Timer也可以提交多個TimeTask任務，但只有一個線程來執行所有的TimeTask，這樣并發性受到影響。而ScheduleThreadPoolExecutore可以設定池中線程的數量。
（3）Timer不會捕獲TimerTask的異常，只是簡單地停止，這樣勢必會影響其他TimeTask的執行。而ScheduleThreadPoolExecutore中，如果一個線程因某些原因停止，線程池可以自動創建新的線程來維護池中線程的數量。
scheduleAtFixedRate定時任務超時問題
若任務處理時長超出設置的定時頻率時長,本次任務執行完才開始下次任務,下次任務已經處于超時狀態,會馬上開始執行.
若任務處理時長小于定時頻率時長,任務執行完后,定時器等待,下次任務會在定時器等待頻率時長后執行
如下例子:
設置定時任務每60s執行一次
若第一次任務時長80s,第二次任務時長20ms,第三次任務時長50ms
第一次任務第0s開始,第80s結束;
第二次任務第80s開始,第110s結束;(上次任務已超時,本次不會再等待60s,會馬上開始),
第三次任務第150s開始,第200s結束.
第四次任務第210s開始.....
?
Callable、Future和FutureTask詳解
Future接口和實現Future接口的FutureTask類用來表示異步計算的結果。
當我們把Runnable接口或Callable接口的實現類提交（submit）給ThreadPoolExecutor或ScheduledThreadPoolExecutor時，ThreadPoolExecutor或ScheduledThreadPoolExecutor會向我們返回一個FutureTask對象。
Runnable接口和Callable接口的實現類，都可以被ThreadPoolExecutor或Scheduled-ThreadPoolExecutor執行。它們之間的區別是Runnable不會返回結果，而Callable可以返回結果。
除了可以自己創建實現Callable接口的對象外，還可以使用工廠類Executors來把一個Runnable包裝成一個Callable。
Executors提供的，把一個Runnable包裝成一個Callable的API。
public static Callable<Object> callable(Runnable task)? // 假設返回對象Callable1
Executors提供的，把一個Runnable和一個待返回的結果包裝成一個Callable的API。
public static <T> Callable<T> callable(Runnable task, T result)? // 假設返回對象Callable2
當任務成功完成后FutureTask.get()將返回該任務的結果。例如，如果提交的是對象Callable1，FutureTask.get()方法將返回null；如果提交的是對象Callable2，FutureTask.get()方法將返回result對象。
FutureTask除了實現Future接口外，還實現了Runnable接口。因此，FutureTask可以交給Executor執行，也可以由調用線程直接執行（FutureTask.run()）。
當FutureTask處于未啟動或已啟動狀態時，執行FutureTask.get()方法將導致調用線程阻塞；當FutureTask處于已完成狀態時，執行FutureTask.get()方法將導致調用線程立即返回結果或拋出異常。
當FutureTask處于未啟動狀態時，執行FutureTask.cancel()方法將導致此任務永遠不會被執行；當FutureTask處于已啟動狀態時，執行FutureTask.cancel（true）方法將以中斷執行此任務線程的方式來試圖停止任務；當FutureTask處于已啟動狀態時，執行FutureTask.cancel（false）方法將不會對正在執行此任務的線程產生影響（讓正在執行的任務運行完成）；當FutureTask處于已完成狀態時，執行FutureTask.cancel（…）方法將返回false。
CompletionService詳解
CompletionService實際上可以看做是Executor和BlockingQueue的結合體。CompletionService在接收到要執行的任務時，通過類似BlockingQueue的put和take獲得任務執行的結果。CompletionService的一個實現是ExecutorCompletionService，ExecutorCompletionService把具體的計算任務交給Executor完成。在實現上，ExecutorCompletionService在構造函數中會創建一個BlockingQueue（使用的基于鏈表的無界隊列LinkedBlockingQueue），該BlockingQueue的作用是保存Executor執行的結果。當計算完成時，調用FutureTask的done方法。當提交一個任務到ExecutorCompletionService時，首先將任務包裝成QueueingFuture，它是FutureTask的一個子類，然后改寫FutureTask的done方法，之后把Executor執行的計算結果放入BlockingQueue中。
與ExecutorService最主要的區別在于submit的task不一定是按照加入時的順序完成的。CompletionService對ExecutorService進行了包裝，內部維護一個保存Future對象的BlockingQueue。只有當這個Future對象狀態是結束的時候，才會加入到這個Queue中，take()方法其實就是Producer-Consumer中的Consumer。它會從Queue中取出Future對象，如果Queue是空的，就會阻塞在那里，直到有完成的Future對象加入到Queue中。所以，先完成的必定先被取出。這樣就減少了不必要的等待時間。
總結：
使用方法一，自己創建一個集合來保存Future存根并循環調用其返回結果的時候，主線程并不能保證首先獲得的是最先完成任務的線程返回值。它只是按加入線程池的順序返回。因為take方法是阻塞方法，后面的任務完成了，前面的任務卻沒有完成，主程序就那樣等待在那兒，只到前面的完成了，它才知道原來后面的也完成了。
使用方法二，使用CompletionService來維護處理線程不的返回結果時，主線程總是能夠拿到最先完成的任務的返回值，而不管它們加入線程池的順序。
?
?
減少鎖的競爭:
快進快出，縮小鎖的范圍，將與鎖無關的，有大量計算或者阻塞操作的代碼移出同步范圍。
減小鎖的粒度，多個相互獨立的狀態變量可以使用多個鎖來保護，每個鎖只保護一個變量。
鎖的分段，例如ConcurrentHashMap中的實現。
減少獨占鎖的使用，例如讀多寫少的情況下，用讀寫鎖替換排他鎖。
?
?
底層實現原理和JMM
?
?
?
CountDownLatch
是一個同步工具類，用來協調多個線程之間的同步。
CountDownLatch countDownLatch = new CountDownLatch(N);
當線程1.執行countDownLatch.await();方法后，進入等待（等同wait()），當其他線程執行N次countDownLatch..countDown();之后，才會被喚醒。?
內部實現： AQS。
ps:只能在初始化的時候，定義N。并且只能使用一次。
?
CyclicBarrier：循環柵欄
讓所有線程都等待完成后才會繼續下一步行動。等到一批數量集合完成之后，再進行下一步。
CyclicBarrier 的字面意思是可循環使用（Cyclic）的屏障（Barrier）。它要做的事情是，讓一組線程到達一個屏障（也可以叫同步點）時被阻塞，直到最后一個線程到達屏障時，屏障才會開門，所有被屏障攔截的線程才會繼續干活。CyclicBarrier默認的構造方法是CyclicBarrier(int parties)，其參數表示屏障攔截的線程數量，每個線程調用await方法告訴CyclicBarrier我已經到達了屏障，然后當前線程被阻塞。?
await();進入等待，當等待的線程數量達到指定的數量，就會被喚醒，繼續執行。
?
Semaphore ：信號量
基于AQS實現的。內部也定義了一個Sync ，AQS的實現類
?
LockSupport：
LockSupport是一個線程工具類，所有的方法都是靜態方法，可以讓線程在任意位置阻塞，也可以在任意位置喚醒。
主要的方法：park（阻塞線程）和unpark（喚醒線程）。
（1）wait和notify都是Object中的方法,在調用這兩個方法前必須先獲得鎖對象，但是park不需要獲取某個對象的鎖就可以鎖住線程。
（2）notify只能隨機選擇一個線程喚醒，無法喚醒指定的線程，unpark卻可以喚醒一個指定的線程。unpark可以先執行，則park不阻塞。
public static void park(Object blocker); // 暫停當前線程 public static void parkNanos(Object blocker, long nanos); // 暫停當前線程，不過有超時時間的限制 public static void parkUntil(Object blocker, long deadline); // 暫停當前線程，直到某個時間 public static void park(); // 無期限暫停當前線程 public static void parkNanos(long nanos); // 暫停當前線程，不過有超時時間的限制 public static void parkUntil(long deadline); // 暫停當前線程，直到某個時間 public static void unpark(Thread thread); // 恢復當前線程 public static Object getBlocker(Thread t);?
總結
以上是生活随笔為你收集整理的java多线程学习笔记。的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 荧光染料 ICG-HSA 吲哚菁绿修饰人
- 下一篇： Win10下双系统Ubuntu14.04