工作中或多或少都会遇到并发问题，解决此类问题最好的解决方法就是通过锁，本文通过分析最常见的类ReentrantLock的源码来了解jdk大神的实现细节。以便于在合适的时候使用锁。

public class Demo implements Runnable {
    private static int count = 0;


    public static void main(String[] args) {

        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(new Demo());
            thread.start();
        }
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("result: " + count);
    }

    @Override
    public void run() {
        //unsafe
        for (int i = 0; i < 10000; i++) {
            count++;
        }
    }

常见的例子起10个线程去分别累计10000次，因为访问了同样的变量。最终的结果不会是100000。就需要给计算方法加同步。使用ReentrantLock如下：

public class LockDemo implements Runnable {
    private static int count = 0;
    private  Lock lock = new ReentrantLock();
    public LockDemo(Lock lock){
        this.lock= lock;
    }


    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(new LockDemo(lock));
            thread.start();
        }
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("result: " + count);
    }

    @Override
    public void run() {
        try {
            this.lock.lock();
            for (int i = 0; i < 10000; i++) {
                count++;
            }
        }
        finally {
            this.lock.unlock();
        }
    }
}

ReentrantLock方法如下表：

从方法列表可以看出来，ReentrantLock的大部分实现都是由AbstractQueuedSynchronizer提供，ReentrantLock中有3个内部类，Sync直接继承了AbstractQueuedSynchronizer。NonfairSync非公平模式和FairSync公平模式又继承了Sync。具体实现细节先不讨论。至少我们知道了ReentrantLock和AbstractQueuedSynchronizer是息息相关的。那么接下来我们先看下AbstractQueuedSynchronizer是什么东西。

AbstractQueuedSynchronizer

AbstractQueuedSynchronizer抽象队列同步器，听名字就是一个线程安全的队列，实际上维护了两个队列，一个是等待获取锁的队列（AbstractQueuedSynchronizer自身维护），一个是等待被唤醒的队列（内部类ConditionObject维护）。

两个队列差别在于：

AbstractQueuedSynchronizer构建出来的队列，头节点是一个没有Thread的空节点，其标识作用，而Condition构建出来的队列，头节点就是真正等待的节点

AbstractQueuedSynchronizer构建出来的队列，节点之间有next与pred相互标识该节点的前一个节点与后一个节点的地址，而Condition构建出来的队列，只使用了nextWaiter标识下一个等待节点的地址

Condition 队列中的节点肯定是获取过锁，只是不满足人为指定的条件而主动阻塞释放锁，并且在被唤醒时会插入到AQS队列中，并不是立即执行的。

看下AbstractQueuedSynchronizer.Node持有的属性：

下图是运行中生成的两种队列结构。

运行时队列

看完了Node,下面看一下AQS中变量和方法。

看一下ConditionObject中的方法和属性