ReentrantLock原理

实现了Lock接口
内部也维护了一个同步器Sync继承自AQS，Sync是抽象的，两个实现NonFairSync和FairSync

public ReentrantLock() {
    sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

非公平锁加锁解锁流程

// 加锁
CAS修改State状态0->1
修改成功,则将Owner线程设置为当前线程
修改失败
调用AQS中的acquire方法
public final void acquire(int arg) {
    if (!tryAcquire(arg) &&  // 再次尝试获取锁
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}
获取失败,addWaiter将当前线程封装为一个Node对象,加入到等待的双向Node链表中
进入acquireQueued逻辑
acquireQueued会在一个死循环中不断尝试获得锁,失败后park阻塞
1.如果是紧邻着head(head指向的Node节点的下一个Node节点),那么可以再次tryAcquire尝试获取锁,当然这时state仍为1,失败
2.进入shouldParkAfterFailedAcquire逻辑,将前驱node,即head的waitStatus改为-1,这次返回false
3.当再次进入shouldParkAfterFailedAcquire时,这时因为其前驱node的waitStatus已经是-1,这次返回true
4.进入parkAndCheckInterrupt,阻塞

// 解锁
调用了AQS的release方法
public final boolean release(int arg) {
	// tryRelease中将OwnerThread设置为null,将state设置为0
    if (tryRelease(arg)) { // 调用ReentrantLock中Sync内部类的tryRelease方法
        Node h = head;	// 看head的指向是否为null以及waitstatus
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h); // 找到等待链表中离head最近的一个Node(没取消的),unpark恢复其运行
        return true;
    }
    return false;
}
// 线程被唤醒后
final boolean acquireQueued(final Node node, int arg) {
    boolean interrupted = false;
	for (;;) {
	    final Node p = node.predecessor();
	    if (p == head && tryAcquire(arg)) { // 唤醒后恢复运行拿到锁
	        setHead(node); // 将head指向为自己的Node节点,自己的Node节点也不再关联线程
	        p.next = null; // help GC,将之前head指向的Node节点断开
	        return interrupted;
	    }
	    if (shouldParkAfterFailedAcquire(p, node))
	        interrupted |= parkAndCheckInterrupt(); // 获取锁时,是在这里被park阻塞的,所以也从这里恢复运行
	}
}

非公平锁，当释放锁的时候，又来了一个线程，会和刚被唤醒的线程竞争
被唤醒的线程没竞争过，则又会park，去睡觉

可重入原理

获取锁时，如果state已经为1，会判断当前线程是不是Owner线程
如果是，表示发生了锁重入，会让state++
释放锁时调用tryRelease方法，会让state减1，减完之后发现不是0，则返回false，不会释放锁
只有当state减完之后变为0了，才会释放锁，返回true

可打断原理

默认是不可打断的，因为被打断后恢复运行，会继续尝试获得锁，获得到会将打断标记true作为结果返回，获得不到会继续阻塞

final boolean acquireQueued(final Node node, int arg) {
	boolean interrupted = false;
	for (;;) {
		final Node p = node.predecessor();
		if (p == head && tryAcquire(arg)) {
			setHead(node);
			p.next = null; // help GC
			return interrupted; // 获取锁时,会将打断标记作为结果返回
		}
		if (shouldParkAfterFailedAcquire(p, node))
			// 被打断唤醒后会将打断标记清除(为了下面获取锁失败时还可以park住),将true赋给interrupted
			interrupted |= parkAndCheckInterrupt();
	}
}
// 这里acquireQueued返回true,表示是被打断后恢复运行拿到了锁
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) {
    	// 竞争锁之前先判断等待链表中的情况
        if (!hasQueuedPredecessors() &&
            compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // 判断当前线程是不是Owner线程
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}
// java.util.concurrent.locks.AbstractQueuedSynchronizer#hasQueuedPredecessors
public final boolean hasQueuedPredecessors() {
    Node h, s;
    if ((h = head) != null) { // head是否为null
        if ((s = h.next) == null || s.waitStatus > 0) {
            s = null; // traverse in case of concurrent cancellation
            for (Node p = tail; p != h && p != null; p = p.prev) {
                if (p.waitStatus <= 0)
                    s = p;
            }
        }
        // 如果有head指向的Node节点的下一个Node节点,且关联的线程不是自己
        // 则自己就不要去竞争锁了
        if (s != null && s.thread != Thread.currentThread())
            return true;
    }
    return false;
}

条件变量实现原理

每个条件变量对应着一个等待链表，实现类是ConditionObject，维护了一个双向链表
await流程

public final void await() throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    Node node = addConditionWaiter();// 创建Node对象,添加到等待链表中.Adds a new waiter to wait queue.
    long savedState = fullyRelease(node);// 释放锁,唤醒AQS等待链表中的一个Node节点
    int interruptMode = 0;
    while (!isOnSyncQueue(node)) {
        LockSupport.park(this); // 阻塞住
    }
}

signal流程
先检查当前线程是不是锁的持有者，不是则抛出异常
将ConditionObject维护的等待链表中的第一个Node节点移除，转移到AQS的等待链表中