听说微信搜索《Java 鱼仔》会变更强哦！

本文收录于JavaStarter ，里面有我完整的 Java 系列文章，学习或面试都可以看看哦

并发编程算是 Java 的一个难点，经常做业务相关的程序员基本上用不到 juc 的包，但是这些知识点十分重要，所以不管在哪里，时刻保持学习真的很重要。

（一）AQS 概述

Java 并发编程的核心在于 java.concurrent.util 包，juc 中大多数同步器的实现都围绕了一个公共的行为，比如等待队列、条件队列、独占获取、共享获取等，这个行为的抽象就是基于 AbstractQueuedSynchronized（AQS）。AQS 定义了多线程访问共享资源的同步器框架。

简单来讲，AQS 就好比一个行为准则，而并发包中的大多数同步器在这个准则下实现。

AQS 具备以下的几个特性：阻塞等待队列、共享/独占、公平/非公平、可重入、允许中断。

如果你点开 JUC 发源码，会发现大量同步器的实现，比如：Lock、Latch、Barrier 等都基于 AQS 实现。

（二）几个重要的知识点

在 AQS 中，我们需要记住几个重要的知识点：

1、AQS 的实现通常是定义内部类 Sync 继承 AQS，将同步器的所有调用都映射到 Sync 对应的方法上。

2、AQS 内部有个属性叫 state，表示资源的可用状态。state 有三种访问方式 getState()、setState()、compareAndSetState()

3、AQS 定义了两种资源的共享方式：独占（Exclusive）如 ReentrantLock、共享（Share）如 Semaphore 或 CountDownLatch

4、AQS 中定义了同步等待队列，用于存放等待线程的一个队列。

这几个知识点会在后面的内容中使用到。

（三）ReentrantLock

我们通过 ReentrantLock 这个示例来更深入的了解 AQS。我会通过上面四个知识点去讲解 ReentrantLock 中 AQS 的使用。

1、首先进入 ReentrantLock 的源码内部，直接就能看到 ReentrantLock 中定义的内部类 Sync

Sync 继承了 AQS，按 AQS 去指定同步规则。

2、既然继承了 AQS，ReentrantLock 内部也相当于有了 state，这个 state 用来记录上锁的次数，ReentrantLock 是个可重入锁，如果多次上锁，state 会记录上锁的次数，需要释放同样次数的锁才算把锁释放完。

3、ReentrantLock 的资源是独占的，AbstractQueuedSynchronized 继承了一个叫 AbstractOwnableSynchronizer 的抽象类：

在这个类中，有个变量叫 exclusiveOwnerThread，这个变量记录着当前是哪个线程独占了锁。

4、同步等待队列：由于 ReentrantLock 是个独占的锁，当有一个线程在使用这个锁的时候，其他线程就要到队列中去等待，这个队列是一种基于双向链表的队列（类 CLH 队列），节点中存放线程信息。

（四）可重入锁

在介绍 AQS 时，我们讲到了 AQS 中有个状态值 state，这个值用来判断当前资源的可用状态。可重入锁的意思就是对一个对象可以实现多次加锁，state 就用来记录加锁的次数。下面写一段代码：

public class ReentrantLockTest {    //定义全局的锁对象    private static final Lock lock=new ReentrantLock(true);    public static int count=0;    public static void main(String[] args) {        new Thread(new Runnable() {            @Override            public void run() {                testlock();            }        },"线程A").start();        new Thread(new Runnable() {            @Override            public void run() {                testlock();            }        },"线程B").start();    }
    private static void testlock() {        lock.lock();        count++;        System.out.println(Thread.currentThread().getName()+"第一次加锁"+count);        lock.lock();        count++;        System.out.println(Thread.currentThread().getName()+"第二次加锁"+count);        count--;        lock.unlock();        System.out.println(Thread.currentThread().getName()+"第一次解锁"+count);        count--;        lock.unlock();        System.out.println(Thread.currentThread().getName()+"第二次解锁"+count);    }}

生成两个线程，让他们去执行 testlock 方法，然后在 testlock 方法的开始和结束加锁，保证同时只有一个线程可以执行里面的方法。最后的结果是线程有序执行：

在代码中，我们进行了两次 lock，这就是可重入锁。我们通过断点调试，来分析第二次加锁后 lock 中的值，下面给出了说明。

（五）公平锁与非公平锁

我们在用构造方法创建 ReentrantLock 的时候，可以传入一个 boolean 类型的参数，true 或 false

private static final Lock lock=new ReentrantLock(true);

这里的 true 和 false 代表了创建的 ReentrantLock 对象是公平锁还是非公平锁

通过上文的学习，我们知道当有线程在使用锁的时候，其他线程是处于等待队列中的，而一旦锁被释放后，他会去唤醒等待队列中的第一个锁：

如果是公平锁，当有新的线程来的时候，他会先去看看等待队列中有没有等待的线程，如果有，则乖乖跑到最后去排队。

如果是非公平锁，当有新的线程来的时候，直接看 state 的状态，如果发现是 0，不管等待队列有没有等待的线程，直接去和被唤醒的锁竞争，如果竞争失败了，则乖乖跑到队列最后去排队，否则就直接占有锁。