併發編程專題五-AbstractQueuedSynchronizer源碼分析

時間 2019-11-06

標籤併發編程專題 abstractqueuedsynchronizer 源碼分析简体版

原文原文鏈接

PS：外號鴿子王不是白來的，鴿了好幾天，也是由於比較忙，時間太少了，這篇東西有點多，須要慢慢消化。不知不覺竟然寫了4個多小時....java

1、什麼是AQS

aqs是AbstractQueuedSynchronizer的簡稱，是用來構建鎖或者其餘同步組件（信號量、事件等）的基礎框架類。JDK中許多併發工具類的內部實現都依賴於AQS，如ReentrantLock, Semaphore, CountDownLatch等等。算法

2、AQS的設計模式

2.1模板方法設計模式

在學習原理和源碼以前，咱們先了解一中設計模式。模板方法設計模式。編程

模板方法設計模式定義一個操做中算法的骨架，而將一些步驟延遲到子類中，模板方法使得子類能夠不改變算法的結構便可重定義該算法的某些特定步驟。設計模式

通俗來講就是完成一件事情，有固定的數個步驟，可是每一個步驟根據對象的不一樣，而實現細節不一樣；就能夠在父類中定義一個完成該事情的總方法，按照完成事件須要的步驟去調用其每一個步驟的實現方法。每一個步驟的具體實現，由子類完成。微信

例如發短信有如下有如下四個步驟：數據結構

1,須要發送給的人; 2 編寫內容; 3，發送日期 4，調用短信網關發送多線程

發郵件也一樣有如下四個步驟：併發

1,須要發送給的人; 2 編寫內容; ，發送日期 4，調用郵箱服務發送框架

這時，能夠清楚地發現，不管是發短信仍是發郵件，它們的步驟幾乎是相同的： 1，須要發送給的人; 2 發送內容 3，發送日期 4，發送。只有具體到發送方法的時候，它們有些步驟纔不一樣。這時咱們就能夠把相同的步驟提取出來，生成一個模版，進行共用，而到具體的內容時，它們再有具本的實現。具體到代碼時，模版就能夠用抽象類實現，具體的內容能夠到它的子類中實現。ide

代碼以下

import java.util.Date;

/**
 * @Auther: DarkKing
 * @Date: 2019/4/21 12:09
 * @Description:
 */
public abstract class SendTemplate {

	//發送給誰，具體發送給誰須要子類去實現
	public abstract void toUser();
	//發送內容，具體發送內容須要子類去實現
	public abstract void content();
	//發送日期,由於日期都是同樣的，因此父類就能夠實現掉
	public void date() {
		System.out.println(new Date());
	}
	//發送方法，不一樣的發送方式確定要實現不一樣的發送方法
	public abstract void send();
	
	//發送消息，框架方法-模板方法
	public void sendMessage() {
		toUser();
		content();
		date();
		send();
	}

}

/**
 * @Auther: DarkKing
 * @Date: 2019/4/21 12:09
 * @Description: 短信發送模板實現類
 */
public class SendSms extends SendTemplate {

	@Override
	public void toUser() {
		System.out.println("to Pistachio");
	}

	@Override
	public void content() {
		System.out.println(" I LOVE YOU ❤");

	}

	@Override
	public void send() {
		System.out.println("set sms");

	}
	
	public static void main(String[] args) {
		SendTemplate sendSms = new SendSms();
		sendSms.sendMessage();
	}

}

AQS就是採用了模板方法的設計模式，除了AQS，Spring加載配置的過程一樣也是使用了這種設計模式。具體之後Spring源碼專題在給你們詳細說明

2.2AQS中的方法

既然知道AQS所使用的是模板方法設計模式，那具體都有哪些方法，咱們如今列舉一下。

一、模板方法

獨佔式(獨佔鎖)	共享式（共享鎖）	方法描述
acquire	acquireShared	獲取鎖方法,獲取同步狀態
acquireInterruptibly	acquireSharedInterruptibly	獲取鎖方法，同acquire，但能夠響應中斷
tryAcquireNanos	tryAcquireSharedNanos	獲取鎖方法
release	releaseShared	釋放鎖

二、須要子類覆蓋的流程方法

獨佔式獲取 tryAcquire

獨佔式釋放 tryRelease

共享式獲取 tryAcquireShared

共享式釋放 tryReleaseShared

這些方法咱們能夠看到，AQS中只拋出了一個UnsupportedOperationException異常，因此須要咱們在子類中具體去實現。

三、其餘方法

isHeldExclusively:判斷同步器是否處於獨佔模式

除此以外，AQS還定義了一個volatile變量state，用於記錄鎖的狀態

getState:獲取當前的同步狀態

setState:設置當前同步狀態

compareAndSetState:使用CAS設置狀態，保證狀態設置的原子性

爲何Doug Lea大師要這樣設計AQS呢？AQS面向的是鎖的實現者，而咱們在使用Lock鎖的時候，只須要調用Lock對應的方法便可，屏蔽了實現細節。而對於鎖的實現者來講，簡化了鎖的實現方式，例如同步狀態管理，線程排隊等底層操做。隔離了鎖的實現者和鎖的使用者。從而進行了解耦，當咱們在使用ReentrantLock等鎖的時候，徹底感受不到AQS的存在。

2.3自定義鎖的實現

既然咱們瞭解了AQS中的一些方法，那咱們就經過實現父類中的方法，來本身實現一個鎖，加深下對模板方法的理解。

本身實現鎖的話，首先咱們實現Lock接口，Lock共有6個接口，以前咱們都已經講過了，你們若是感興趣，個人併發編程專題裏查看哈~

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

/**
 * @Auther: DarkKing
 * @Date: 2019/4/21 12:09
 * @Description:
 */
public class SelfLock implements Lock{
	
	//aqs中state 表示獲取到鎖的狀態 state=1 獲取到了鎖，state=0，表示這個鎖當前沒有線程拿到

	//定義一個內部類，實現AQS模板方法
	private static class Sync extends AbstractQueuedSynchronizer{
		
		//是否佔用
		protected boolean isHeldExclusively() {
			return getState()==1;
		}
		//嘗試獲取鎖
		protected boolean tryAcquire(int arg) {
			//CAS操做，首先對比鎖是否被獲取到，獲取到的話就將鎖的狀態置爲1，不然獲取鎖失敗
			if(compareAndSetState(0,1)) {
				//設置鎖的擁有者爲當前線程
				setExclusiveOwnerThread(Thread.currentThread());
				return true;
			}
			return false;
		}
		//嘗試釋放鎖
		protected boolean tryRelease(int arg) {
			//若是鎖的狀態爲0，則不須要釋放，拋出異常
			if(getState()==0) {
				throw new UnsupportedOperationException();
			}
			//設置鎖的擁有者爲null，而且狀態設置爲0
			setExclusiveOwnerThread(null);
			setState(0);
			return true;
		}
		//Condition對象，用於對鎖的對象喚醒和等待
		Condition newCondition() {
			return new ConditionObject();
		}
	}
	
	private final Sync sycn = new Sync();

	//獲取鎖。若是鎖已被其餘線程獲取，則進行等待
	@Override
	public void lock() {
		sycn.acquire(1);
		
	}
	//能夠直接調用父類的方法。該方法和lock的區別就是能夠響應中斷。
	@Override
	public void lockInterruptibly() throws InterruptedException {
		sycn.acquireInterruptibly(1);
		
	}
	//它表示用來嘗試獲取鎖，若是獲取成功，則返回true，若是獲取失敗返回false
	@Override
	public boolean tryLock() {
		return sycn.tryAcquire(1);
	}
	//帶時間戳的獲取鎖，若是等待時間超過，則獲取失敗
	@Override
	public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
		return sycn.tryAcquireNanos(1, unit.toNanos(time));
	}
    //釋放鎖
	@Override
	public void unlock() {
		sycn.release(1);
		
	}
	//返回Condition對象
	@Override
	public Condition newCondition() {
		return sycn.newCondition();
	}


}

以上方法咱們實現了獲取鎖和釋放鎖的接口。從實現中咱們發現獲取鎖的時候使用了CAS操做，但釋放鎖的時候沒有進行CAS操做。這樣寫會不會出現問題呢？接下來寫個測試類。測試下鎖可否正常使用

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

import com.xiangxue.tools.SleepTools;

/**
 * @Auther: DarkKing
 * @Date: 2019/4/21 12:09
 * @Description:
 */
public class TestMyLock {
    public void test() {
        final Lock lock = new SelfLock();
        
        class Worker extends Thread {
            public void run() {
                while (true) {
                    lock.lock();
                    try {
                    	SleepTools.second(1);
                        System.out.println(Thread.currentThread().getName());
                        SleepTools.second(1);
                    } finally {
                        lock.unlock();
                    }
                    SleepTools.second(2);
                }
            }
        }
        // 啓動10個子線程
        for (int i = 0; i < 10; i++) {
            Worker w = new Worker();
            w.setDaemon(true);
            w.start();
        }
        // 主線程每隔1秒換行
        for (int i = 0; i < 10; i++) {
        	SleepTools.second(1);
            System.out.println();
        }
    }

    public static void main(String[] args) {
        TestMyLock testMyLock = new TestMyLock();
        testMyLock.test();
    }
}

咱們定義了10個線程，打印出當前獲取鎖的線程。從打印咱們能夠看出來，每次只會打印出一個線程名。說明咱們寫的鎖是起做用的。那爲何釋放的時候不須要CAS操做呢。當咱們一個線程獲取到鎖，其餘線程又都在作什麼呢。接下來咱們走進AQS源碼中，進行學習。

3、AQS源碼解析

咱們上面的測試用例中。當咱們一個線程獲取到鎖，其餘線程再去獲取鎖的時候，咱們返回了false，線程進入的等待狀態，那既然線程進入了等待狀態，等待鎖被釋放的時候了進行喚醒。那麼必然要有個地方存儲咱們進行等待的線程的一個數據結構。

3.一、AQS中的數據結構-節點和同步隊列

AQS的中的等待的線程所有存儲在一個同步隊列裏，它是一個先進先出的數據結構，先進來的線程會先被喚醒。同時這個隊列仍是個雙向列表。上一個節點指向下一個節點。還有頭指示器指向第一個節點。尾指示器指向最後一個節點。

3.2 同步隊列節點屬性

打開AQS的源碼，找到Node類，全部屬性以下

字段名	屬性值	描述
CANCELLED	1	線程等待超時或者被中斷了，須要從隊列中移走
SIGNAL	-1	後續的節點等待狀態，當前節點若是完成則通知後面的節點去運行
CONDITION	-2	當前節點處於等待隊列
PROPAGATE	-3	共享，表示狀態要日後面的節點傳播
	0	初始狀態
waitStatus		標識當前節點狀態，就是上面的那幾個常量字段。
Node prev		表示當前節點的前驅節點
Node next		表示當前節點的後驅節點
Thread thread		表示當前節點存放的線程
Node nextWaiter		指向等待隊列節點