根据锁出现在Java中的时间，Java中的锁，可以分为同步锁和JUC包中的锁，同步锁指的是通过synchronized关键字来进行同步，实现对竞争资源的互斥访问的锁，同步锁的原理是：
- 对于每一个对象，有且仅有一个同步锁，不同的线程能共同访问该同步锁。
- 在同一个时间点，该同步锁能且只能被一个线程获取到。
这样，获取到同步锁的线程就能进行CPU调度，从而在CPU上执行；而没有获取到同步锁的线程，必须进行等待，直到获取到同步锁之后才能继续运行
相比同步锁，JUC包中的锁的功能更加强大，它为锁提供了一个框架，该框架允许更灵活地使用锁。
接口
接口共有三个Lock接口、ReadWriteLock以及Condition接口。
Lock接口（范式）
JUC包中的 Lock 接口支持那些语义不同(重入、公平等)的锁规则。所谓语义不同，是指锁可是有公平机制的锁、非公平机制的锁、可重入的锁等等。
- 公平机制是指"不同线程获取锁的机制是公平的，而非公平机制则是指"不同线程获取锁的机制是非公平的"，这里的公平指的是如果公平，那么等待锁的多个线程将会按照申请锁的时间顺序来依次获得锁
- 可重入的锁是指同一个锁能够被一个线程多次获取
它为实现自己的锁类提供了如下的一些方法：
void lock(); boolean tryLock(); void lockInterruptibly() throws InterruptedException; //等待可中断 boolean tryLock(long time, TimeUnit unit) throws InterruptedException; //定时可中断 void unlock(); Condition newCondition(); //组合的方式获取Condition条件
ReadWriteLock接口
ReadWriteLock 接口以和Lock类似的方式定义了一些读取者可以共享而写入者独占的锁。JUC包只有一个类实现了该接口，即 ReentrantReadWriteLock，因为它适用于大部分的标准用法上下文。但程序员可以创建自己的、适用于非标准要求的实现。方法如下：
public interface ReadWriteLock { /** * Returns the lock used for reading. * * @return the lock used for reading */ Lock readLock(); /** * Returns the lock used for writing. * * @return the lock used for writing */ Lock writeLock(); }
Condition接口
Condition需要和Lock联合使用，它的作用是代替Object监视器方法，可以通过await(),signal()来休眠/唤醒线程。Condition 接口描述了可能会与锁有关联的条件变量。这些变量在用法上与使用 Object.wait 访问的隐式监视器类似，但提供了更强大的功能。需要特别指出的是，单个 Lock 可能与多个 Condition 对象关联。为了避免兼容性问题，Condition 方法的名称与对应的 Object 版本中的不同。
void await() throws InterruptedException; void awaitUninterruptibly(); long awaitNanos(long nanosTimeout) throws InterruptedException; boolean await(long time, TimeUnit unit) throws InterruptedException; boolean awaitUntil(Date deadline) throws InterruptedException; void signal(); void signalAll();
使用起来较为简单：
Lock lock = new ReentrantLock(); Condition condition = lock.newCondition(); public void conditionWait() throws InterruptedException { lock.lock(); try { condition.await(); } finally { lock.unlock(); } } public void conditionSignal() throws InterruptedException { lock.lock(); try { condition.signal(); } finally { lock.unlock(); } }
一般都会将Condition对象作为成员变量。当调用await()方法后，当前线程会释放锁并在此等待，而其他线程调用Condition对象的signal()方法，通知当前线程后，当前线程才从await()方法返回，并且在返回前已经获取了锁
抽象类
抽象类共有三个，AbstractOwnableSynchronizer，AbstractQueuedSynchronizer，AbstractQueuedLongSynchronizer三个抽象类
AQS抽象类（模版）
AbstractQueuedSynchronizer就是被称之为AQS的类，它是一个非常有用的超类，可用来定义锁以及依赖于排队阻塞线程的其他同步器，ReentrantLock，ReentrantReadWriteLock，CountDownLatch，CyclicBarrier和Semaphore等这些类都是基于AQS类实现的
AQS原理
AQS核⼼思想是，如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的⼯作线程，并且将共享资源设置为锁定状态。如果被请求的共享资源被占⽤，那么就需要⼀套线程阻塞等待以及被唤醒时锁分配的机制，这个机制AQS是⽤CLH队列锁实现的，即将暂时获取不到锁的线程加⼊到队列中
AQS使⽤⼀个int成员变量来表示同步状态，通过内置的FIFO队列来完成获取资源线程的排队⼯作。AQS使⽤CAS对该同步状态进⾏原⼦操作实现对其值的修改
/** * The synchronization state. */ private volatile int state; /** * Returns the current value of synchronization state. * This operation has memory semantics of a {@code volatile} read. * @return current state value */ protected final int getState() { return state; } /** * Sets the value of synchronization state. * This operation has memory semantics of a {@code volatile} write. * @param newState the new state value */ protected final void setState(int newState) { state = newState; } /** * Atomically sets synchronization state to the given updated * value if the current state value equals the expected value. * This operation has memory semantics of a {@code volatile} read * and write. * * @param expect the expected value * @param update the new value * @return {@code true} if successful. False return indicates that the actual * value was not equal to the expected value. */ protected final boolean compareAndSetState(int expect, int update) { // See below for intrinsics setup to support this return unsafe.compareAndSwapInt(this, stateOffset, expect, update); }
AQS 对资源的共享⽅式
AQS定义两种资源共享⽅式
- Exclusive（独占）：只有⼀个线程能执⾏，如ReentrantLock。⼜可分为公平锁和⾮公平锁：公平锁：按照线程在队列中的排队顺序，先到者先拿到锁，⾮公平锁：当线程要获取锁时，⽆视队列顺序直接去抢锁，谁抢到就是谁的
- Share（共享）：多个线程可同时执⾏，如Semaphore、CountDownLatch、 CyclicBarrier等
- ReentrantReadWriteLock 可以看成是组合式，因为ReentrantReadWriteLock也就是读写锁允许多个线程同时对某⼀资源进⾏读。
不同的⾃定义同步器争⽤共享资源的⽅式也不同。⾃定义同步器在实现时只需要实现共享资源 state的获取与释放⽅式即可，⾄于具体线程等待队列的维护（如获取资源失败⼊队/唤醒出队等），AQS已经在顶层实现好了。
AQS底层使用了模板方法模式
同步器的设计是基于模板⽅法模式的，如果需要⾃定义同步器⼀般的⽅式是这样（模板⽅法模式很经典的⼀个应⽤）：
- 使⽤者继承AbstractQueuedSynchronizer并重写指定的⽅法。（这些重写⽅法很简单，⽆⾮是对于共享资源state的获取和释放）
- 将AQS组合在⾃定义同步组件的实现中，并调⽤其模板⽅法，⽽这些模板⽅法会调⽤使⽤者重写的⽅法。这和我们以往通过实现接⼝的⽅式有很⼤区别，这是模板⽅法模式很经典的⼀个运⽤。
AQS使⽤了模板⽅法模式，⾃定义同步器时需要重写下⾯⼏个AQS提供的模板⽅法：
isHeldExclusively()//该线程是否正在独占资源。只有⽤到condition才需要去实现它。 tryAcquire(int)//独占⽅式。尝试获取资源，成功则返回true，失败则返回false。 tryRelease(int)//独占⽅式。尝试释放资源，成功则返回true，失败则返回false。 tryAcquireShared(int)//共享⽅式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可⽤资源；正数表示成功，且有剩余资源。 tryReleaseShared(int)//共享⽅式。尝试释放资源，成功则返回true，失败则返回false。
这些⽅法的实现必须是内部线程安全的，并且通常应该简短⽽不是阻塞。AQS类中的其他⽅法都是final ，所以⽆法被其他类使⽤，只有这⼏个⽅法可以被其他类使⽤，例如ReentrantLock实现一个非公平锁
/** * Creates an instance of {@code ReentrantLock}. * This is equivalent to using {@code ReentrantLock(false)}. */ public ReentrantLock() { sync = new NonfairSync(); }
非公平锁的底层实现调用并重写了tryAcquire
static final class NonfairSync extends Sync { private static final long serialVersionUID = 7316153563782823691L; /** * Performs lock. Try immediate barge, backing up to normal * acquire on failure. */ final void lock() { if (compareAndSetState(0, 1)) setExclusiveOwnerThread(Thread.currentThread()); else acquire(1); } protected final boolean tryAcquire(int acquires) { return nonfairTryAcquire(acquires); } }
AQLS 抽象类
提供AQS相同的功能但扩展了对同步状态的 64 位的支持。
AOS 抽象类
AQS还是AQLS两者都扩展了类 AbstractOwnableSynchronizer（一个帮助记录当前保持独占同步的线程的简单类）。
private transient Thread exclusiveOwnerThread; /** * Sets the thread that currently owns exclusive access. * A {@code null} argument indicates that no thread owns access. * This method does not otherwise impose any synchronization or * {@code volatile} field accesses. * @param thread the owner thread */ protected final void setExclusiveOwnerThread(Thread thread) { exclusiveOwnerThread = thread; } /** * Returns the thread last set by {@code setExclusiveOwnerThread}, * or {@code null} if never set. This method does not otherwise * impose any synchronization or {@code volatile} field accesses. * @return the owner thread */ protected final Thread getExclusiveOwnerThread() { return exclusiveOwnerThread; }
普通类
如果说Lock接口提供了锁的行为规范，AQS接口提供了锁的复杂实现，那么接下来的普通类就是使用时候的具体实现了。
LockSupport类
当需要阻塞或唤醒一个线程的时候，都会使用LockSupport工具类来完成相应工作，底层调用的是同步原语。LockSupport定义了一组的公共静态方法，这些方法提供了最基本的线程阻塞和唤醒功能，而LockSupport也成为构建同步组件的基础工具。
public static void park() //阻塞 public static void unpark(Thread thread) //唤醒一个阻塞中的线程 public static void parkNanos(long nanos) //阻塞不超过nanos纳秒 public static void parkUntil(long deadline) //最晚阻塞到时间点
ReentrantLock类
ReentrantLock是独占锁。所谓独占锁，是指只能被独自占领，即同一个时间点只能被一个线程锁获取到的锁（互斥同步语义）。ReentrantLock锁包括公平的ReentrantLock和非公平的ReentrantLock（公平非公平语义）。ReentrantLock是可重入的锁（可重入语义）
- ReentrantLock实现了Lock接口。
- ReentrantLock中有一个成员变量sync，sync是Sync类型；Sync是一个抽象类，而且它继承于AQS。
- ReentrantLock中有公平锁类FairSync和非公平锁类NonfairSync，它们都是Sync的子类。ReentrantReadWriteLock中sync对象，是FairSync与NonfairSync中的一种，这也意味着ReentrantLock是公平锁"或非公平锁中的一种，ReentrantLock默认是非公平锁。
是否公平依据构造函数决定
/** * Creates an instance of {@code ReentrantLock} with the * given fairness policy. * * @param fair {@code true} if this lock should use a fair ordering policy */ public ReentrantLock(boolean fair) { sync = fair ? new FairSync() : new NonfairSync(); }
一般会将其与Synchronized进行比较
- 两者默认都是非公平，悲观，独享，互斥，可重入锁
- synchronized 依赖于 JVM ⽽ ReentrantLock 依赖于 API，不但可以通过一些监控工具监控synchronized的锁定，而且在代码执行时出现异常，JVM会自动释放锁定，但是使用Lock则不行，lock是通过代码实现的，要保证锁定一定会被释放，就必须将unLock放到finally{}中
- ReentrantLock 拥有Synchronized相同的并发性和内存语义，此外还多了 可实现选择性通知（锁可以绑定多个条件），定时锁等候/等待可中断，可实现公平锁
需要注意，随着Synchronized的优化，性能已不能作为二者比较的标准
ReentrantReadWriteLock类
ReentrantReadWriteLock是读写锁接口ReadWriteLock的实现类，它包括内部类ReadLock和WriteLock。ReadLock是共享锁，而WriteLock是独占锁。
/** Inner class providing readlock */ private final ReentrantReadWriteLock.ReadLock readerLock; /** Inner class providing writelock */ private final ReentrantReadWriteLock.WriteLock writerLock; /** Performs all synchronization mechanics */ final Sync sync;
其继承结构为：
- ReentrantReadWriteLock实现了ReadWriteLock接口。
- ReentrantReadWriteLock中包含sync对象，读锁readerLock和写锁writerLock。读锁ReadLock和写锁WriteLock都实现了Lock接口。
- 和ReentrantLock一样，sync是Sync类型；而且，Sync也是一个继承于AQS的抽象类。Sync也包括公平锁FairSync和非公平锁NonfairSync。
其实和ReentrantLock类似，只不过ReentrantLock实现了它的一个独占版本。
