ReentrantLock源码解析_we don‘t need to do so to check if current thread

    //锁对象
    abstract void lock();

    //非公平锁获取锁资源
    final boolean nonfairTryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        if (c == 0) {
            if (compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                return true;
            }
        }
        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;
    }

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

    protected final boolean isHeldExclusively() {
        // While we must in general read state before owner,
        // we don't need to do so to check if current thread is owner
        return getExclusiveOwnerThread() == Thread.currentThread();
    }

    final ConditionObject newCondition() {
        return new ConditionObject();
    }

    // Methods relayed from outer class

    final Thread getOwner() {
        return getState() == 0 ? null : getExclusiveOwnerThread();
    }

    final int getHoldCount() {
        return isHeldExclusively() ? getState() : 0;
    }

    final boolean isLocked() {
        return getState() != 0;
    }

    /**
     * Reconstitutes the instance from a stream (that is, deserializes it).
     */
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        s.defaultReadObject();
        setState(0); // reset to unlocked state
    }
}

###  非公平锁NonfairSync的实现


在ReentrantLock还有两个内部类其中一个就是NonfairSync他继承了抽象类Sync 

static final class NonfairSync extends Sync {
private static final long serialVersionUID = 7316153563782823691L;

    //非公平锁的具体实现
    final void lock() {
        // CAS比较state变量值 去更改state的值为1 尝试去获取锁
        if (compareAndSetState(0, 1))
            //获取锁成功。成功则将独占锁线程设置为当前线程  
            setExclusiveOwnerThread(Thread.currentThread());
        else
            // 失败的情况下、 再次请求同步状态
            acquire(1);
    }

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

//AQS 中的方法 尝试获取锁
public final void acquire(int arg) {
     // tryAcquire(arg) 获取锁成功为true 否则为false
    if (!tryAcquire(arg) &&
        // addWaiter 在同步队列中的队尾新增一条数据

        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))

         
        selfInterrupt();
}

//AQS 中的方法 尝试获取锁
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);
                // 并将已经获取锁的节点的后驱节点置为null 便于垃圾回收
                p.next = null;
                failed = false;
                return interrupted;
            }
            //响应中断 判断当前节点的前置节点是否为头部接口并且当前节点的线程是否被中断 
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        //获取锁失败。那么就会取消获取锁。将node节点的状态置为cancel取消状态
        if (failed)
            cancelAcquire(node);
    }
}

acquire具体的实现逻辑在sync的nonfairTryAcquire方法
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
// 尝试获取state状态
int c = getState();
// 如果state 说明资源没有被占用
if (c == 0) {
//CAS成功后变获取锁、
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
//如果资源被占用，并且被占用的线程是当前线程那么state++
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;
}

 公平锁NonfairSync的实现

static final class FairSync extends Sync {
private static final long serialVersionUID = -3000897897090466540L;

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

     
   // 公平锁获取资源的方式 与非公平说最大的区别在
     // hasQueuedPredecessors方法
    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;
            }
        }
        else if (current == getExclusiveOwnerThread()) {
            int nextc = c + acquires;