线程执行完之后会释放吗_java多线程并发：CAS+AQS+HashMap+volatile+ThreadLocal，乐分享...
CyclicBarrier、CountDownLatch、Semaphore 的用法
CountDownLatch(線程計數器 )
CountDownLatch 類位于 java.util.concurrent 包下，利用它可以實現類似計數器的功能。比如有一個任務 A，它要等待其他 4 個任務執行完畢之后才能執行，此時就可以利用 CountDownLatch來實現這種功能了。
final CountDownLatch latch = new CountDownLatch(2);new Thread(){public void run() {
System.out.println("子線程"+Thread.currentThread().getName()+"正在執行");
Thread.sleep(3000);
System.out.println("子線程"+Thread.currentThread().getName()+"執行完畢");
latch.countDown();
};}.start();
new Thread(){ public void run() {
System.out.println("子線程"+Thread.currentThread().getName()+"正在執行");
Thread.sleep(3000);
System.out.println("子線程"+Thread.currentThread().getName()+"執行完畢");
latch.countDown();
};}.start();
System.out.println("等待 2 個子線程執行完畢...");
latch.await();
System.out.println("2 個子線程已經執行完畢");
System.out.println("繼續執行主線程");
}
CyclicBarrier(回環柵欄-等待至 barrier 狀態再全部同時執行)
字面意思回環柵欄，通過它可以實現讓一組線程等待至某個狀態之后再全部同時執行。叫做回環是因為當所有等待線程都被釋放以后，CyclicBarrier 可以被重用。我們暫且把這個狀態就叫做barrier，當調用 await()方法之后，線程就處于 barrier 了。
CyclicBarrier 中最重要的方法就是 await 方法，它有 2 個重載版本：
1. public int await()：用來掛起當前線程，直至所有線程都到達 barrier 狀態再同時執行后續任務；
2. public int await(long timeout, TimeUnit unit)：讓這些線程等待至一定的時間，如果還有線程沒有到達 barrier 狀態就直接讓到達 barrier 的線程執行后續任務。
具體使用如下，另外 CyclicBarrier 是可以重用的。
public static void main(String[] args) {int N = 4;
CyclicBarrier barrier = new CyclicBarrier(N);
for(int i=0;inew Writer(barrier).start();
}
static class Writer extends Thread{
private CyclicBarrier cyclicBarrier;
public Writer(CyclicBarrier cyclicBarrier) {
this.cyclicBarrier = cyclicBarrier;
}
@Override
public void run() {
try {
Thread.sleep(5000); //以睡眠來模擬線程需要預定寫入數據操作
System.out.println("線程"+Thread.currentThread().getName()+"寫入數據完
畢，等待其他線程寫入完畢");
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
}catch(BrokenBarrierException e){
e.printStackTrace();
}
System.out.println("所有線程寫入完畢，繼續處理其他任務，比如數據操作");
}
}
Semaphore(信號量-控制同時訪問的線程個數)
Semaphore 翻譯成字面意思為 信號量，Semaphore 可以控制同時訪問的線程個數，通過acquire() 獲取一個許可，如果沒有就等待，而 release() 釋放一個許可。
Semaphore 類中比較重要的幾個方法：
1. public void acquire(): 用來獲取一個許可，若無許可能夠獲得，則會一直等待，直到獲得許可。
2. public void acquire(int permits):獲取 permits 個許可
3. public void release() { } :釋放許可。注意，在釋放許可之前，必須先獲獲得許可。
4. public void release(int permits) { }:釋放 permits 個許可。
上面 4 個方法都會被阻塞，如果想立即得到執行結果，可以使用下面幾個方法
1. public boolean tryAcquire():嘗試獲取一個許可，若獲取成功，則立即返回 true，若獲取失敗，則立即返回 false
2. public boolean tryAcquire(long timeout, TimeUnit unit):嘗試獲取一個許可，若在指定的時間內獲取成功，則立即返回 true，否則則立即返回 false。
3. public boolean tryAcquire(int permits):嘗試獲取 permits 個許可，若獲取成功，則立即返
回 true，若獲取失敗，則立即返回 false。
4. public boolean tryAcquire(int permits, long timeout, TimeUnit unit): 嘗試獲取 permits個許可，若在指定的時間內獲取成功，則立即返回 true，否則則立即返回 false。
5. 還可以通過 availablePermits()方法得到可用的許可數目。
例子：若一個工廠有 5 臺機器，但是有 8 個工人，一臺機器同時只能被一個工人使用，只有使用完了，其他工人才能繼續使用。那么我們就可以通過 Semaphore 來實現：
int N = 8; //工人數Semaphore semaphore = new Semaphore(5); //機器數目
for(int i=0;inew Worker(i,semaphore).start();
}
static class Worker extends Thread{
private int num;
private Semaphore semaphore;
public Worker(int num,Semaphore semaphore){
this.num = num;
this.semaphore = semaphore;
}
@Override
public void run() {
try {
semaphore.acquire();
System.out.println("工人"+this.num+"占用一個機器在生產...");
Thread.sleep(2000);
System.out.println("工人"+this.num+"釋放出機器");
semaphore.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
? CountDownLatch 和 CyclicBarrier 都能夠實現線程之間的等待，只不過它們側重點不同；CountDownLatch 一般用于某個線程 A 等待若干個其他線程執行完任務之后，它才執行；而 CyclicBarrier 一般用于一組線程互相等待至某個狀態，然后這一組線程再同時執行；另外，CountDownLatch 是不能夠重用的，而 CyclicBarrier 是可以重用的。
? Semaphore 其實和鎖有點類似，它一般用于控制對某組資源的訪問權限。
volatile 關鍵字的作用(變量可見性、禁止重排序)
Java 語言提供了一種稍弱的同步機制，即 volatile 變量，用來確保將變量的更新操作通知到其他線程。volatile 變量具備兩種特性，volatile 變量不會被緩存在寄存器或者對其他處理器不可見的地方，因此在讀取 volatile 類型的變量時總會返回最新寫入的值。
變量可見性
其一是保證該變量對所有線程可見，這里的可見性指的是當一個線程修改了變量的值，那么新的值對于其他線程是可以立即獲取的。
禁止重排序
volatile 禁止了指令重排。
比 sychronized 更輕量級的同步鎖
在訪問 volatile 變量時不會執行加鎖操作，因此也就不會使執行線程阻塞，因此 volatile 變量是一種比 sychronized 關鍵字更輕量級的同步機制。volatile 適合這種場景：一個變量被多個線程共享，線程直接給這個變量賦值。
當對非 volatile 變量進行讀寫的時候，每個線程先從內存拷貝變量到 CPU 緩存中。如果計算機有多個 CPU，每個線程可能在不同的 CPU 上被處理，這意味著每個線程可以拷貝到不同的 CPUcache 中。而聲明變量是 volatile 的，JVM 保證了每次讀變量都從內存中讀，跳過 CPU cache這一步。
適用場景
值得說明的是對 volatile 變量的單次讀/寫操作可以保證原子性的，如 long 和 double 類型變量，但是并不能保證 i++這種操作的原子性，因為本質上 i++是讀、寫兩次操作。在某些場景下可以代替 Synchronized。但是,volatile 的不能完全取代 Synchronized 的位置，只有在一些特殊的場景下，才能適用 volatile。總的來說，必須同時滿足下面兩個條件才能保證在并發環境的線程安全：
(1)對變量的寫操作不依賴于當前值(比如 i++)，或者說是單純的變量賦值(booleanflag = true)。
(2)該變量沒有包含在具有其他變量的不變式中，也就是說，不同的 volatile 變量之間，不能互相依賴。只有在狀態真正獨立于程序內其他內容時才能使用 volatile。
如何在兩個線程之間共享數據
Java 里面進行多線程通信的主要方式就是共享內存的方式，共享內存主要的關注點有兩個：可見性和有序性原子性。Java 內存模型(JMM)解決了可見性和有序性的問題，而鎖解決了原子性的問題，理想情況下我們希望做到“同步”和“互斥”。有以下常規實現方法：
將數據抽象成一個類，并將數據的操作作為這個類的方法
1. 將數據抽象成一個類，并將對這個數據的操作作為這個類的方法，這么設計可以和容易做到同步，只要在方法上加”synchronized“
public class MyData {private int j=0;
public synchronized void add(){
j++;
System.out.println("線程"+Thread.currentThread().getName()+"j 為："+j);
}
public synchronized void dec(){
j--;
System.out.println("線程"+Thread.currentThread().getName()+"j 為："+j);
}
public int getData(){
return j;
}
}
public class AddRunnable implements Runnable{
MyData data;
public AddRunnable(MyData data){
this.data= data;
}public void run() {
data.add();
}
}
public class DecRunnable implements Runnable {
MyData data;
public DecRunnable(MyData data){
this.data = data;
}
public void run() {
data.dec();
}
}
public static void main(String[] args) {
MyData data = new MyData();
Runnable add = new AddRunnable(data);
Runnable dec = new DecRunnable(data);
for(int i=0;i<2;i++){
new Thread(add).start();
new Thread(dec).start();
}
Runnable 對象作為一個類的內部類
2. 將 Runnable 對象作為一個類的內部類，共享數據作為這個類的成員變量，每個線程對共享數據的操作方法也封裝在外部類，以便實現對數據的各個操作的同步和互斥，作為內部類的各個 Runnable 對象調用外部類的這些方法。
public class MyData {private int j=0;
public synchronized void add(){
j++;
System.out.println("線程"+Thread.currentThread().getName()+"j 為："+j);
}
public synchronized void dec(){
j--;
System.out.println("線程"+Thread.currentThread().getName()+"j 為："+j);
}
public int getData(){
return j;
}
}
public class TestThread {
public static void main(String[] args) {
final MyData data = new MyData();
for(int i=0;i<2;i++){
new Thread(new Runnable(){
public void run() {
data.add();
}
}).start();
new Thread(new Runnable(){
public void run() {
data.dec();
}
}).start();
}
}
}
ThreadLocal 作用(線程本地存儲)
ThreadLocal，很多地方叫做線程本地變量，也有些地方叫做線程本地存儲，ThreadLocal 的作用是提供線程內的局部變量，這種變量在線程的生命周期內起作用，減少同一個線程內多個函數或者組件之間一些公共變量的傳遞的復雜度。
ThreadLocalMap(線程的一個屬性)
1. 每個線程中都有一個自己的 ThreadLocalMap 類對象，可以將線程自己的對象保持到其中，各管各的，線程可以正確的訪問到自己的對象。
2. 將一個共用的 ThreadLocal 靜態實例作為 key，將不同對象的引用保存到不同線程的ThreadLocalMap 中，然后在線程執行的各處通過這個靜態 ThreadLocal 實例的 get()方法取得自己線程保存的那個對象，避免了將這個對象作為參數傳遞的麻煩。
3. ThreadLocalMap 其實就是線程里面的一個屬性，它在 Thread 類中定義
ThreadLocal.ThreadLocalMap threadLocals = null;
使用場景
最常見的 ThreadLocal 使用場景為 用來解決 數據庫連接、Session 管理等。
private static final ThreadLocal threadSession = new ThreadLocal();public static Session getSession() throws InfrastructureException {
Session s = (Session) threadSession.get();
try {
if (s == null) {
s = getSessionFactory().openSession();
threadSession.set(s);
}
} catch (HibernateException ex) {
throw new InfrastructureException(ex);
}
return s;
}
synchronized 和 ReentrantLock 的區別
兩者的共同點：
1. 都是用來協調多線程對共享對象、變量的訪問
2. 都是可重入鎖，同一線程可以多次獲得同一個鎖
3. 都保證了可見性和互斥性
兩者的不同點：
1. ReentrantLock 顯示的獲得、釋放鎖，synchronized 隱式獲得釋放鎖
2. ReentrantLock 可響應中斷、可輪回，synchronized 是不可以響應中斷的，為處理鎖的不可用性提供了更高的靈活性
3. ReentrantLock 是 API 級別的，synchronized 是 JVM 級別的
4. ReentrantLock 可以實現公平鎖
5. ReentrantLock 通過 Condition 可以綁定多個條件
6. 底層實現不一樣， synchronized 是同步阻塞，使用的是悲觀并發策略，lock 是同步非阻塞，采用的是樂觀并發策略
7. Lock 是一個接口，而 synchronized 是 Java 中的關鍵字，synchronized 是內置的語言實現。
8. synchronized 在發生異常時，會自動釋放線程占有的鎖，因此不會導致死鎖現象發生；
而 Lock 在發生異常時，如果沒有主動通過 unLock()去釋放鎖，則很可能造成死鎖現象，因此使用 Lock 時需要在 finally 塊中釋放鎖。
9. Lock 可以讓等待鎖的線程響應中斷，而 synchronized 卻不行，使用 synchronized 時，等待的線程會一直等待下去，不能夠響應中斷。
10. 通過 Lock 可以知道有沒有成功獲取鎖，而 synchronized 卻無法辦到。
11. Lock 可以提高多個線程進行讀操作的效率，既就是實現讀寫鎖等。
ConcurrentHashMap 并發
減小鎖粒度
減小鎖粒度是指縮小鎖定對象的范圍，從而減小鎖沖突的可能性，從而提高系統的并發能力。減小鎖粒度是一種削弱多線程鎖競爭的有效手段，這種技術典型的應用是 ConcurrentHashMap(高性能的 HashMap)類的實現。對于 HashMap 而言，最重要的兩個方法是 get 與 set 方法，如果我們對整個 HashMap 加鎖，可以得到線程安全的對象，但是加鎖力度太大。Segment 的大小也被稱為 ConcurrentHashMap 的并發度。
ConcurrentHashMap 分段鎖
ConcurrentHashMap，它內部細分了若干個小的 HashMap，稱之為段(Segment)。默認情況下一個 ConcurrentHashMap 被進一步細分為 16 個段，既就是鎖的并發度。
如果需要在 ConcurrentHashMap 中添加一個新的表項，并不是將整個 HashMap 加鎖，而是首先根據 hashcode 得到該表項應該存放在哪個段中，然后對該段加鎖，并完成 put 操作。在多線程環境中，如果多個線程同時進行 put操作，只要被加入的表項不存放在同一個段中，則線程間可以做到真正的并行。
ConcurrentHashMap 是由 Segment 數組結構和 HashEntry 數組結構組成
ConcurrentHashMap 是由 Segment 數組結構和 HashEntry 數組結構組成。Segment 是一種可重入鎖 ReentrantLock，在 ConcurrentHashMap 里扮演鎖的角色，HashEntry 則用于存儲鍵值對數據。一個 ConcurrentHashMap 里包含一個 Segment 數組，Segment 的結構和 HashMap類似，是一種數組和鏈表結構， 一個 Segment 里包含一個 HashEntry 數組，每個 HashEntry 是一個鏈表結構的元素， 每個 Segment 守護一個 HashEntry 數組里的元素,當對 HashEntry 數組的數據進行修改時，必須首先獲得它對應的 Segment 鎖。
Java 中用到的線程調度
搶占式調度：
搶占式調度指的是每條線程執行的時間、線程的切換都由系統控制，系統控制指的是在系統某種運行機制下，可能每條線程都分同樣的執行時間片，也可能是某些線程執行的時間片較長，甚至某些線程得不到執行的時間片。在這種機制下，一個線程的堵塞不會導致整個進程堵塞。
協同式調度：
協同式調度指某一線程執行完后主動通知系統切換到另一線程上執行，這種模式就像接力賽一樣，一個人跑完自己的路程就把接力棒交接給下一個人，下個人繼續往下跑。線程的執行時間由線程本身控制，線程切換可以預知，不存在多線程同步問題，但它有一個致命弱點：如果一個線程編寫有問題，運行到一半就一直堵塞，那么可能導致整個系統崩潰。
JVM 的線程調度實現(搶占式調度)
java 使用的線程調使用搶占式調度，Java 中線程會按優先級分配 CPU 時間片運行，且優先級越高越優先執行，但優先級高并不代表能獨自占用執行時間片，可能是優先級高得到越多的執行時間片，反之，優先級低的分到的執行時間少但不會分配不到執行時間。
線程讓出 cpu 的情況：
1. 當前運行線程主動放棄 CPU，JVM 暫時放棄 CPU 操作(基于時間片輪轉調度的 JVM 操作系統不會讓線程永久放棄 CPU，或者說放棄本次時間片的執行權)，例如調用 yield()方法。
2. 當前運行線程因為某些原因進入阻塞狀態，例如阻塞在 I/O 上。
3. 當前運行線程結束，即運行完 run()方法里面的任務。
進程調度算法
優先調度算法
1. 先來先服務調度算法(FCFS)
當在作業調度中采用該算法時，每次調度都是從后備作業隊列中選擇一個或多個最先進入該隊列的作業，將它們調入內存，為它們分配資源、創建進程，然后放入就緒隊列。在進程調度中采用 FCFS 算法時，則每次調度是從就緒隊列中選擇一個最先進入該隊列的進程，為之分配處理機，使之投入運行。該進程一直運行到完成或發生某事件而阻塞后才放棄處理機，特點是：算法比較簡單，可以實現基本上的公平。
2. 短作業(進程)優先調度算法
短作業優先(SJF)的調度算法是從后備隊列中選擇一個或若干個估計運行時間最短的作業，將它們調入內存運行。而短進程優先(SPF)調度算法則是從就緒隊列中選出一個估計運行時間最短的進程，將處理機分配給它，使它立即執行并一直執行到完成，或發生某事件而被阻塞放棄處理機時再重新調度。該算法未照顧緊迫型作業。
高優先權優先調度算法
為了照顧緊迫型作業，使之在進入系統后便獲得優先處理，引入了最高優先權優先(FPF)調度算法。當把該算法用于作業調度時，系統將從后備隊列中選擇若干個優先權最高的作業裝入內存。
當用于進程調度時，該算法是把處理機分配給就緒隊列中優先權最高的進程。
1. 非搶占式優先權算法
在這種方式下，系統一旦把處理機分配給就緒隊列中優先權最高的進程后，該進程便一直執行下去，直至完成；或因發生某事件使該進程放棄處理機時。這種調度算法主要用于批處理系統中；也可用于某些對實時性要求不嚴的實時系統中。
2. 搶占式優先權調度算法
在這種方式下，系統同樣是把處理機分配給優先權最高的進程，使之執行。但在其執行期間，只要又出現了另一個其優先權更高的進程，進程調度程序就立即停止當前進程(原優先權最高的進程)的執行，重新將處理機分配給新到的優先權最高的進程。顯然，這種搶占式的優先權調度算法能更好地滿足緊迫作業的要求，故而常用于要求比較嚴格的實時系統中，以及對性能要求較高的批處理和分時系統中。
2．高響應比優先調度算法
在批處理系統中，短作業優先算法是一種比較好的算法，其主要的不足之處是長作業的運行得不到保證。如果我們能為每個作業引入前面所述的動態優先權，并使作業的優先級隨著等待時間的增加而以速率 a 提高，則長作業在等待一定的時間后，必然有機會分配到處理機。該優先權的變化規律可描述為：
(1) 如果作業的等待時間相同，則要求服務的時間愈短，其優先權愈高，因而該算法有利于短作業。
(2) 當要求服務的時間相同時，作業的優先權決定于其等待時間，等待時間愈長，其優先權愈高，因而實現的是先來先服務
(3) 對于長作業，作業的優先級可以隨等待時間的增加而提高，當其等待時間足夠長時，其優先級便可升到很高，從而也可獲得處理機。簡言之，該算法既照顧了短作業，又考慮了作業到達的先后次序，不會使長作業長期得不到服務。因此，該算法實現了一種較好的折衷。當然，在利用該算法時，每要進行調度之前，都須先做響應比的計算，這會增加系統開銷。
基于時間片的輪轉調度算法
1. 時間片輪轉法
在早期的時間片輪轉法中，系統將所有的就緒進程按先來先服務的原則排成一個隊列，每次調度時，把 CPU 分配給隊首進程，并令其執行一個時間片。時間片的大小從幾 ms 到幾百 ms。當執行的時間片用完時，由一個計時器發出時鐘中斷請求，調度程序便據此信號來停止該進程的執行，并將它送往就緒隊列的末尾；然后，再把處理機分配給就緒隊列中新的隊首進程，同時也讓它執行一個時間片。這樣就可以保證就緒隊列中的所有進程在一給定的時間內均能獲得一時間片的處理機執行時間。
2. 多級反饋隊列調度算法
(1) 應設置多個就緒隊列，并為各個隊列賦予不同的優先級。第一個隊列的優先級最高，第二個隊列次之，其余各隊列的優先權逐個降低。該算法賦予各個隊列中進程執行時間片的大小也各不相同，在優先權愈高的隊列中，為每個進程所規定的執行時間片就愈小。例如，第二個隊列的時間片要比第一個隊列的時間片長一倍，……，第 i+1 個隊列的時間片要比第 i 個隊列的時間片長一倍。
(2) 當一個新進程進入內存后，首先將它放入第一隊列的末尾，按 FCFS 原則排隊等待調度。當輪到該進程執行時，如它能在該時間片內完成，便可準備撤離系統；如果它在一個時間片結束時尚未完成，調度程序便將該進程轉入第二隊列的末尾，再同樣地按 FCFS 原則等待調度執行；如果它在第二隊列中運行一個時間片后仍未完成，再依次將它放入第三隊列，……，如此下去，當一個長作業(進程)從第一隊列依次降到第 n 隊列后，在第 n 隊列便采取按時間片輪轉的方式運行。
(3) 僅當第一隊列空閑時，調度程序才調度第二隊列中的進程運行；僅當第 1～(i-1)隊列均空時，才會調度第 i 隊列中的進程運行。如果處理機正在第 i 隊列中為某進程服務時，又有新進程進入優先權較高的隊列(第 1～(i-1)中的任何一個隊列)，則此時新進程將搶占正在運行進程的處理機，即由調度程序把正在運行的進程放回到第 i 隊列的末尾，把處理機分配給新到的高優先權進程。
在多級反饋隊列調度算法中，如果規定第一個隊列的時間片略大于多數人機交互所需之處理時間時，便能夠較好的滿足各種類型用戶的需要。
什么是 CAS(比較并交換-樂觀鎖機制-鎖自旋)
概念及特性
CAS(Compare And Swap/Set)比較并交換，CAS 算法的過程是這樣：它包含 3 個參數CAS(V,E,N)。V 表示要更新的變量(內存值)，E 表示預期值(舊的)，N 表示新值。當且僅當 V 值等于 E 值時，才會將 V 的值設為 N，如果 V 值和 E 值不同，則說明已經有其他線程做了更新，則當
前線程什么都不做。最后，CAS 返回當前 V 的真實值。
CAS 操作是抱著樂觀的態度進行的(樂觀鎖)，它總是認為自己可以成功完成操作。當多個線程同時使用 CAS 操作一個變量時，只有一個會勝出，并成功更新，其余均會失敗。失敗的線程不會被掛起，僅是被告知失敗，并且允許再次嘗試，當然也允許失敗的線程放棄操作。基于這樣的原理，CAS 操作即使沒有鎖，也可以發現其他線程對當前線程的干擾，并進行恰當的處理。
原子包?
java.util.concurrent.atomic(鎖自旋)
JDK1.5 的原子包：
java.util.concurrent.atomic 這個包里面提供了一組原子類。其基本的特性就是在多線程環境下，當有多個線程同時執行這些類的實例包含的方法時，具有排他性，即當某個線程進入方法，執行其中的指令時，不會被其他線程打斷，而別的線程就像自旋鎖一樣，一直等到該方法執行完成，才由 JVM 從等待隊列中選擇一個另一個線程進入，這只是一種邏輯上的理解。相對于對于 synchronized 這種阻塞算法，CAS 是非阻塞算法的一種常見實現。由于一般 CPU 切換時間比 CPU 指令集操作更加長， 所以 J.U.C 在性能上有了很大的提升。如下代碼：
private volatile int value;
public final int get() {
return value;
}
public final int getAndIncrement() {
for (;;) { //CAS 自旋，一直嘗試，直達成功
int current = get();
int next = current + 1;
if (compareAndSet(current, next))
return current;
}
}
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
}
getAndIncrement 采用了 CAS 操作，每次從內存中讀取數據然后將此數據和+1 后的結果進行CAS 操作，如果成功就返回結果，否則重試直到成功為止。而 compareAndSet 利用 JNI 來完成CPU 指令的操作。
ABA 問題
CAS 會導致“ABA 問題”。CAS 算法實現一個重要前提需要取出內存中某時刻的數據，而在下時刻比較并替換，那么在這個時間差類會導致數據的變化。
比如說一個線程 one 從內存位置 V 中取出 A，這時候另一個線程 two 也從內存中取出 A，并且two 進行了一些操作變成了 B，然后 two 又將 V 位置的數據變成 A，這時候線程 one 進行 CAS 操作發現內存中仍然是 A，然后 one 操作成功。盡管線程 one 的 CAS 操作成功，但是不代表這個過程就是沒有問題的。
部分樂觀鎖的實現是通過版本號(version)的方式來解決 ABA 問題，樂觀鎖每次在執行數據的修改操作時，都會帶上一個版本號，一旦版本號和數據的版本號一致就可以執行修改操作并對版本號執行+1 操作，否則就執行失敗。因為每次操作的版本號都會隨之增加，所以不會出現 ABA 問題，因為版本號只會增加不會減少。
什么是 AQS(抽象的隊列同步器)
AbstractQueuedSynchronizer 類如其名，抽象的隊列式的同步器，AQS 定義了一套多線程訪問共享資源的同步器框架，許多同步類實現都依賴于它，如常用的
ReentrantLock/Semaphore/CountDownLatch。
它維護了一個 volatile int state(代表共享資源)和一個 FIFO 線程等待隊列(多線程爭用資源被阻塞時會進入此隊列)。這里 volatile 是核心關鍵詞，具體 volatile 的語義，在此不述。state 的訪問方式有三種:
getState()
setState()
compareAndSetState()
AQS 定義兩種資源共享方式
Exclusive 獨占資源-ReentrantLock
Exclusive(獨占，只有一個線程能執行，如 ReentrantLock)
Share 共享資源-Semaphore/CountDownLatch
Share(共享，多個線程可同時執行，如 Semaphore/CountDownLatch)。
AQS 只是一個框架，具體資源的獲取/釋放方式交由自定義同步器去實現，AQS 這里只定義了一個接口，具體資源的獲取交由自定義同步器去實現了(通過 state 的 get/set/CAS)之所以沒有定義成abstract ，是 因 為獨 占模 式 下 只 用實現 tryAcquire-tryRelease ，而 共享 模 式 下 只用 實 現
tryAcquireShared-tryReleaseShared。如果都定義成abstract，那么每個模式也要去實現另一模式下的接口。不同的自定義同步器爭用共享資源的方式也不同。自定義同步器在實現時只需要實現共享資源 state 的獲取與釋放方式即可，至于具體線程等待隊列的維護(如獲取資源失敗入隊/喚醒出隊等)，AQS 已經在頂層實現好了。自定義同步器實現時主要實現以下幾種方法：
1．isHeldExclusively()：該線程是否正在獨占資源。只有用到 condition 才需要去實現它。
2．tryAcquire(int)：獨占方式。嘗試獲取資源，成功則返回 true，失敗則返回 false。
3．tryRelease(int)：獨占方式。嘗試釋放資源，成功則返回 true，失敗則返回 false。
4．tryAcquireShared(int)：共享方式。嘗試獲取資源。負數表示失敗；0 表示成功，但沒有剩余可用資源；正數表示成功，且有剩余資源。
5．tryReleaseShared(int)：共享方式。嘗試釋放資源，如果釋放后允許喚醒后續等待節點返回true，否則返回 false。
同步器的實現是 ABS 核心(state 資源狀態計數)
同步器的實現是 ABS 核心，以 ReentrantLock 為例，state 初始化為 0，表示未鎖定狀態。A 線程lock()時，會調用 tryAcquire()獨占該鎖并將 state+1。此后，其他線程在 tryAcquire()時就會失敗，直到 A 線程 unlock()到 state=0(即釋放鎖)為止，其它線程才有機會獲取該鎖。當然，釋放鎖之前，A 線程自己是可以重復獲取此鎖的(state 會累加)，這就是可重入的概念。但要注意，獲取多少次就要釋放多少次，這樣才能保證 state 是能回到零態的。
以 CountDownLatch 以例，任務分為 N 個子線程去執行，state 也初始化為 N(注意 N 要與線程個數一致)。這 N 個子線程是并行執行的，每個子線程執行完后 countDown()一次，state會 CAS 減 1。等到所有子線程都執行完后(即 state=0)，會 unpark()主調用線程，然后主調用線程就會從 await()函數返回，繼續后余動作。
ReentrantReadWriteLock 實現獨占和共享兩種方式
一般來說，自定義同步器要么是獨占方法，要么是共享方式，他們也只需實現 tryAcquiretryRelease、
tryAcquireShared-tryReleaseShared 中的一種即可。但 AQS 也支持自定義同步器同時實現獨占和共享兩種方式，如 ReentrantReadWriteLock。
多多轉發關注不迷路~~~~~
創作挑戰賽新人創作獎勵來咯，堅持創作打卡瓜分現金大獎總結
以上是生活随笔為你收集整理的线程执行完之后会释放吗_java多线程并发：CAS+AQS+HashMap+volatile+ThreadLocal，乐分享...的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： searchview 点击后被覆盖_03
- 下一篇： ++ 多核cpu 并行_一文读懂什么是多