ReetranLock 源码解析

ReetranLock 类

1. 方法含义

方法	说明
lock()	阻塞的获得锁
tryLock()	非阻塞式获取锁
unlock()	释放锁
newCondition()
tryLock(long timeout, TimeUnit unit)

2. 方法解析

public void lock() {
   
    // 直接调用同步器的lock()
    sync.lock();
}
/** 
 * 非阻塞式获取锁
 */
public boolean tryLock() {
   
    // 直接调用非公平锁的获锁方法
    return sync.nonfairTryAcquire(1);
}

public boolean tryLock(long timeout, TimeUnit unit)
        throws InterruptedException {
   
    return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}

1. 队列同步器

1.1 队列同步器中的锁操作

public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer
    implements java.io.Serializable {
   
	
    // 阻塞式获取锁
    public final void acquire(int arg) {
   
        /*
        1. 尝试非阻塞是获取锁，
        2. 获取锁失败，addWaiter(Node.EXCLUSIVE),将线程添加到等待队列
        3. 添加成功，自旋于 acquireQueued()
        */
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }
    
    // 自旋，直到获取到锁
    final boolean acquireQueued(final Node node, int arg) {
   
        boolean failed = true;
        try {
   
            boolean interrupted = false;
            for (;;) {
   
                // 获取当前节点的前一个节点
                final Node p = node.predecessor();
                // 如果前一个结点是头节点，尝试非阻塞式获取锁
                if (p == head && tryAcquire(arg)) {
   
                    // 获取锁成功
                    // 将当前节点设置为等待队列头节点
                    setHead(node);
                    // 去点前一个结点的next引用
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
   
            // 如果faile等于true，当前节点取消等待
            if (failed)
                cancelAcquire(node);
        }
    }
    
    
    
}

1.2 队列同步器中的等待队列操作