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;
}