Java並發編程之ReentrantLock實現原理及源碼剖析

ReentrantLock lock = new ReentrantLock();
lock.lock();
try {
	System.out.println("獲取瞭鎖");
} catch (Exception e) {
	e.printStackTrace();
} finally {
	lock.unlock();
}

public class ReentrantLockTest {
    private Integer counter = 0;
    private ReentrantLock lock = new ReentrantLock();
    
    public void modifyResources(String threadName){
        System.out.println("線程:--->"+threadName+"等待獲取鎖");
        lock.lock();
        System.out.println("線程:--->"+threadName+"第一次加鎖");
        counter++;
        System.out.println("線程:"+threadName+"做第"+counter+"件事");
        //重入該鎖,我還有一件事情要做,沒做完之前不能把鎖資源讓出去
        lock.lock();
        System.out.println("線程:--->"+threadName+"第二次加鎖");
        counter++;
        System.out.println("線程:"+threadName+"做第"+counter+"件事");
        lock.unlock();
        System.out.println("線程:"+threadName+"釋放一個鎖");
        lock.unlock();
        System.out.println("線程:"+threadName+"釋放一個鎖");
    }
 
    public static void main(String[] args) throws InterruptedException {
        ReentrantLockTest tp = new ReentrantLockTest();
 
        new Thread(()->{
            String threadName = Thread.currentThread().getName();
            tp.modifyResources(threadName);
        },"Thread:張三").start();
 
        new Thread(()->{
            String threadName = Thread.currentThread().getName();
            tp.modifyResources(threadName);
        },"Thread:李四").start();
 
        Thread.sleep(100);
    }
}

public void lock() {
	sync.lock();
}

final void lock() {
	/**
	 * 第一步：直接嘗試加鎖
	 * 與公平鎖實現的加鎖行為一個最大的區別在於，此處不會去判斷同步隊列(CLH隊列)中
	 * 是否有排隊等待加鎖的節點，上來直接加鎖（判斷state是否為0,CAS修改state為1）
	 * ，並將獨占鎖持有者 exclusiveOwnerThread 屬性指向當前線程
	 * 如果當前有人占用鎖，再嘗試去加一次鎖
	 */
	if (compareAndSetState(0, 1))
		setExclusiveOwnerThread(Thread.currentThread());
	else
		//AQS定義的方法,加鎖
		acquire(1);
}

public final void acquire(int arg) {
	if (!tryAcquire(arg) &&
			acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
		selfInterrupt();
}

protected final boolean tryAcquire(int acquires) {
	return nonfairTryAcquire(acquires);
}

final boolean nonfairTryAcquire(int acquires) {
	//acquires = 1
	final Thread current = Thread.currentThread();
	int c = getState();
	/**
	 * 不需要判斷同步隊列（CLH）中是否有排隊等待線程
	 * 判斷state狀態是否為0，不為0可以加鎖
	 */
	if (c == 0) {
		//unsafe操作，cas修改state狀態
		if (compareAndSetState(0, acquires)) {
			//獨占狀態鎖持有者指向當前線程
			setExclusiveOwnerThread(current);
			return true;
		}
	}
	/**
	 * state狀態不為0，判斷鎖持有者是否是當前線程，
	 * 如果是當前線程持有 則state+1
	 */
	else if (current == getExclusiveOwnerThread()) {
		int nextc = c + acquires;
		if (nextc < 0) // overflow
			throw new Error("Maximum lock count exceeded");
		setState(nextc);
		return true;
	}
	//加鎖失敗
	return false;
}

public void unlock() {
	sync.release(1);
}

public final boolean release(int arg) {
	if (tryRelease(arg)) {//釋放一次鎖
		Node h = head;
		if (h != null && h.waitStatus != 0)
			unparkSuccessor(h);//喚醒後繼結點
		return true;
	}
	return false;
}

/**
 * 釋放鎖
 */
protected final boolean tryRelease(int releases) {
	int c = getState() - releases;
	if (Thread.currentThread() != getExclusiveOwnerThread())
		throw new IllegalMonitorStateException();
	boolean free = false;
	if (c == 0) {
		free = true;
		setExclusiveOwnerThread(null);
	}
	setState(c);
	return free;
}

public void lock() {
	sync.lock();
}

final void lock() {
	acquire(1);
}

public final void acquire(int arg) {
	if (!tryAcquire(arg) &&
			acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
		selfInterrupt();
}

protected final boolean tryAcquire(int acquires) {
	final Thread current = Thread.currentThread();
	int c = getState();
	if (c == 0) {
		/**
		 * 與非公平鎖中的區別，需要先判斷隊列當中是否有等待的節點
		 * 如果沒有則可以嘗試CAS獲取鎖
		 */
		if (!hasQueuedPredecessors() &&
				compareAndSetState(0, acquires)) {
			//獨占線程指向當前線程
			setExclusiveOwnerThread(current);
			return true;
		}
	}
	else if (current == getExclusiveOwnerThread()) {
		int nextc = c + acquires;
		if (nextc < 0)
			throw new Error("Maximum lock count exceeded");
		setState(nextc);
		return true;
	}
	return false;
}