Java并发框架中的AQS详细解析

public final void acquire(int arg) {
    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);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
		//如果不是继续等待
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

private Node addWaiter(Node mode) {
	//把当前线程改造称为Node，
    Node node = new Node(Thread.currentThread(), mode);
    // Try the fast path of enq; backup to full enq on failure
    Node pred = tail;
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    enq(node);
    return node;
}

public class MyLock implements Lock {
    private Helper helper = new Helper();
    //按照官方文档所说，构建内部帮助类
    private class Helper extends AbstractQueuedSynchronizer {
        //构建尝试获取锁的方法
        @Override
        protected boolean tryAcquire(int arg) {
            int state = getState();
            if (0 == state) {
                //利用cas的原理修改state
                if (compareAndSetState(0, arg)) {
                    //设置当前线程拥有资源
                    setExclusiveOwnerThread(Thread.currentThread());
                    return true;
                }
            }//同一个线程获取被锁住的资源时，直接分配给这个线程，实现可重入性
            else if(getExclusiveOwnerThread()==Thread.currentThread()){ //删除这个else if条件，就会变为一个不可重入锁
                setState(getState()+arg);
                return true;
            }
            return false;
        }
        //构建尝试释放锁的方法
        @Override
        protected boolean tryRelease(int arg) {
            //arg是传递进来的state的期望值
            int state = getState() - arg;
            //判断释放后状态是否为0
            if (0 == state) {
                setExclusiveOwnerThread(null);
                setState(0);
                return true;
            }
            //因为需要修改的线程就是当前占有锁的线程，所以此时直接重置是没有线程安全问题的，也就是当前线程独占了资源state
            setState(state);
            return false;
        }
        public Condition newConditionObject(){
            return new ConditionObject();
        }
    }
    //加锁方法
    @Override
    public void lock() {
        helper.acquire(1); //AbstractQueuedSynchronizer原生方法
    }
    //锁中断
    @Override
    public void lockInterruptibly() throws InterruptedException {
        helper.acquireInterruptibly(1); //AbstractQueuedSynchronizer原生方法
    }
	//尝试获取锁
    @Override
    public boolean tryLock() {
        return helper.tryAcquire(1); //使用自己实现的tryAcquire()方法
    }
    //尝试加锁
    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return helper.tryAcquireNanos(1,unit.toNanos(time)); //AbstractQueuedSynchronizer原生方法
    }
	//释放锁
    @Override
    public void unlock() {
        helper.tryRelease(1);  //使用自己实现的tryRelease()方法
    }
	//条件
    @Override
    public Condition newCondition() {
        return helper.newConditionObject(); //AbstractQueuedSynchronizer原生方法
    }
}