关于ReetrantLock

ReetrantLock   内部静态类  Sync  继承AbstractQueuedSynchronizer（负责阻塞队列，线程去枪战锁,并且包含了node）

NonfairSync  extends Sync extends AbstractQueuedSynchronizer

FairSync extends Sync extends AbstractQueuedSynchronizer

AbstractQueuedSynchronizer 中有一个模板方法 tryacquire（模板模式）

非公平锁NonfairSync

 final void lock() {

　　　　//直接枪占啊。基于cas保证state操作在并发的时候是正确的
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

公平锁FairSync
        final void lock() {
            acquire(1);
        }

acquire的方法 是在AbstractQueuedSynchronizer中实现的

public final void acquire(int arg) {

//addWaiter是加入到队列尾巴 吧线程封装成node  acquireQueued里面又做了循环。所有线程去抢占锁。至于里面的对线程的状态的切换不用关系
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

tryAcquire 在AbstractQueuedSynchronizer 只是实现了个方法

 protected boolean tryAcquire(int arg) {
        throw new UnsupportedOperationException();
    }

具体的实现分别在NonfairSync  FairSync

前者

 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 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;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }