1、概述

• ReentrantLock ：Lock 接口最常用的实现类，可重入的互斥锁，功能类似于 synchronized，但是会比 synchronized 更强大灵活。

• ReentrantReadWriteLock ：读写锁，允许多个读线程同时访问，但只允许一个写线程访问，其会阻塞所有的读写线程。适用于读多写少的场景。

• CountDownLatch ：让一个或多个线程等待，直到其他线程执行的操作完成后再执行。

• CyclicBarrier ：让一组线程等待至某个状态之后再全部同时执行。功能和 CountDownLatch 类似，但是CountDownLatch只能使用一次，而CyclicBarrier可以重复使用。

• Semaphore：信号量，用于限制同时访问资源的线程数。

• Phaser（简单了解）：功能上类似于 CyclicBarrier 和 CountDownLatch ，适用于在多线程环境下同步协调分阶段计算任务（Fork/Join框架中的子任务之间需同步时，优先使用Phaser）

• Exchanger（简单了解）：允许两个线程在某个同步点交换数据，类似于 SynchronousQueue的双向形式，适用于管道设计。

2、ReentrantLock

• 等待可中断：ReentrantLock 中一个线程可以通过 interrupt 方法取消另一个线程的锁等待。

• 可实现公平锁：ReentrantLock 提供了公平锁和非公平锁两种实现，公平锁可以保证线程先来先得。而 synchronized 依赖于 CPU 调度，多个线程同时竞争锁，不能保证先到先得的公平性。

• 可绑定多个条件：ReentrantLock 可以绑定多个 Condition ，每个 Condition 对应一个等待队列；而 synchronized竞争失败的线程都只会进入该对象锁的 Monitor 的阻塞队列中，也就是没有条件可以选择。

• 可设置竞争锁资源的超时时间：ReentrantLock 可以设置竞争锁资源的超时时间，而 synchronized 只能无限等待。

2.1 Lock 接口

• Lock 接口支持那些语义不同（重入、公平等）的锁规则，代表实现类是ReentrantLock 。

• ReadWriteLock 接口定义了读写锁，读锁可以共享，写锁只能独占。此包只提供了一个实现，即 ReentrantReadWriteLock。

synchronized 和 Lock 之间的关联：

• synchronized配合 wait 和 notify 可以实现线程在条件不满足时等待，条件满足时唤醒。

• Lock 接口使用Condition 对象来实现 wait 和 notify 的功能。
• Condition 接口表示与锁有关联的条件变量，一个 Lock 可以与多个 Condition 对象关联。Condition 可以看做是 Obejct 类的 wait()、notify()、 notifyAll() 方法的替代品，但是提供了更强大的功能。
• Condition 接口实现是 ConditionObject。因为Condition 的操作需要获取相关联的锁，所以ConditionObject 设置为 AQS 里面的内部类。

2.1.1 lock()

2.1.2 tryLock() & tryLock(long time, TimeUnit unit)

2.1.3 lockInterruptibly()

2.1.4 newCondition()

• 调用 condition 的 await() 或者 signal() 方法之前必须先获取锁。

• 如果 lock 绑定了多个 condition，已经获取到 lock 的线程在任意一个 condition 上执行 await() 方法都会立刻退出放弃 lock。

• 被唤醒线程从 await()返回后不是立刻获取到 lock，而是加入竞争锁的同步队列，和其他线程一起竞争锁。

2.2 ReentrantLock使用

2.2.1 锁重入

2.2.2 可中断

2.2.3 绑定多条件

2.3 ReentrantLock原理

• ReentrantLock 实现了 Lock 接口。

• ReentrantLock 中有一个 Sync 类型类型的成员变量 sync，Sync 是一个抽象类继承于 AQS。

• Sync 有两个子类 NonfairSync 和 FairSync，分别对应非公平锁和公平锁。

• ReentrantLock 中的 AQS 使用 state 表示占有线程对锁的持有数量，为 0 表示锁未被持有，为 1 表示锁被某个线程持有，> 1 表示锁被某个线程持有多次（即重入）。

• 非公平锁：当前线程释放锁之后（时间片用完或者被中断退出），由于当前线程的业务逻辑没有完成，当前线程继续参与下一轮锁竞争的时候极有可能会继续获取锁成功（因为可以减少线程切换开销，线程调度器更倾向于当前线程），并没有遵循 CLH 队列先到先得得原则，所以才叫非公平锁，容易会造成其他线程饥饿。

• 公平锁：竞争锁的时候按照先到先得得原则，FairSync 需要检查当前线程是否是 CLH 队列的第一个，如果不是的话就获取锁失败，然后把当前线程线程放到 CLH 队列的队尾。

3、ReentrantReadWriteLock

3.1 ReentrantReadWriteLock使用

3.2 ReentrantReadWriteLock原理

• ReentrantReadWriteLock 实现了 ReadWriteLock 接口，需要实现 readLock() 和 writeLock() 两个方法。不同于一般的 Lock 接口实现类只需要实现一个锁，ReadWriteLock 接口实现类需要实现读锁和写锁两个锁。

• ReentrantReadWriteLock 的内部类 Sync 继承了 AQS，可以实现重入的功能。Sync 还有两个子类 NonfairSync 和 FairSync 分别实现了非公平锁和公平锁的功能，以上和 ReentrantLock 的实现思路相同。

• ReentrantReadWriteLock 本身并没有实现 Lock 接口，所以 ReentrantReadWriteLock 本身并没有提供 lock()/tryLock() 这些方法，但 ReentrantReadWriteLock 提供一个全局的 Sync 类的属性 sync。ReentrantReadWriteLock 的内部类 ReadLock 和 WriteLock 实现了 Lock 接口，内部使用了同一个属性 sync，所以两者的实现方法 lock()/tryLock() 都基于同一个属性 sync，也就是基于同一个 sync 内部的 state 状态。

• ReadLock 调用了 sync 的 acquireShared/releaseShared 方法，实现了共享锁功能；而 WriteLock 调用了 sync 的 acquire/release 方法，实现了互斥锁功能。

• ReentrantReadWriteLock 本身也提供了公平锁和非公平锁，原理类似于 ReentrantLock 。

• 获取读锁状态：S >> 16，右移16位，相当于将低 16 位全部抹去

• 读锁状态加1：S + (1 << 16)

• 获取写锁状态：S & 0x0000FFFF，将高 16 位全部抹去。WriteLock 提供了一个 EXCLUSIVE_MASK 变量进行&运算，值等于 0x0000FFFF。

• 写锁状态加1：S + 1

4、CountDownLatch

• CountDownLatch 的构造函数接收一个 int 型参数 N 作为计数器。

• 需要等待的线程会调用 CountDownLatch 的 await() 方法，该线程就会阻塞直到计数器的值减为 0。

• 达到自己预期的线程会调用 CountDownLatch 的 countDown()方法，计数器值减 1。

• 计数器 N 既可以代表 N 个线程，也可以是一个线程的 N 个执行步骤。特别的，当 N 的值为 1 时，退化为单一事件，即由一个线程来通知其他线程，效果等同于对象的 wait 和 notifyAll 。

4.1 CountDownLatch使用

1. 创建 CountDownLatch 并设置计数器值，值为 1。

2. 启动多线程，每个线程调用 await() 方法，子线程会在这里阻塞住。

3. 主线程调用 countDown() 方法，这样所有线程就可以一起往下执行。

1. 创建 CountDownLatch 并设置计数器值，值和线程数相同。

2. 启动多线程，每个线程在执行完任务之后调用 countDown() 方法。

3. 主线程调用 await() 方法，这样主线程的操作就会在这个方法上阻塞，直到其他线程完成各自的任务，count 值为0，主线程继续执行。

4.2 CountDownLatch原理

• countDown() 是执行任务后达到预期的线程调用的，用于将 state 值减 1，这是一个释放锁的操作，所以调用了 sync 的 tryReleaseShared() 方法。

• await() 是被阻塞线程调用的，用于等待 state 值变成 0。这是一个获取锁的操作，所以调用了 sync 的 tryAcquireShared() 方法。

5、CyclicBarrier

• CountDownLatch 只能使用一次，如果需要多次使用只能创建多个 CountDownLatch 实例。

• CountDownLatch 需要显式使用 countDown() 去唤醒被阻塞的线程。

• 每个线程在到达栅栏的时候都会调用 await() 方法将自己阻塞，当阻塞的线程数达到了 CyclicBarrier 初始的数量时，所有进入等待状态的线程被唤醒并继续。

• CyclicBarrier 会自动重置屏障，也就是说 CyclicBarrier 可以多次使用。

5.1 CyclicBarrier使用

1. CyclicBarrier 初始值为 3， 表示3个线程到达屏障后，一起向下执行

2. 3个线程都到达屏障后，屏障会自动重置，可以重复使用

5.2 CyclicBarrier原理

1. 假如初始时 count = parties = 5，当第一个线程到达栅栏处，count减1，然后把它加入到 Condition 的等待队列中，第二个线程到达栅栏处也是如此，如此重复。

2. 最后一个线程到达栅栏处，count 减为 0，调用 Condition 的 signalAll() 唤醒其他所有线程，所有线程从 Condition 的等待队列被加入 AQS 的同步队列。

3. 等待当前线程运行完毕，调用 lock.unlock() 的时候依次从 AQS 的等待队列中唤醒一个线程继续运行，也就是说实际上线程先依次（排队）到达栅栏处，再依次往下运行。

CyclicBarrier 和 CountDownLatch 的区别：

• CyclicBarrier 是最后一个线程到达时自动唤醒；CountDownLatch 需要通过显式地调用 countDown() 来唤醒。

• CyclicBarrier 基于 ReentrantLock + Condition 来实现；CountDownLatch 基于 AQS 来实现。

• CyclicBarrier 具有「代」的概念，可以重复使用；CountDownLatch 只能使用一次。

• CyclicBarrier 只能实现多个线程到达栅栏处一起运行，但是可以携带一个在栅栏处执行的任务；CountDownLatch 不仅可以实现多个线程等待一个线程条件成立，还能实现一个线程等待多个线程条件成立

6、Semaphore

6.1 Semaphore使用

6.2 Semaphore原理

7、Phaser

7.1 Phaser使用

1. 主线程先向 Phaser 注册自己，然后调用了 arriveAndDeregister() 方法注销了自己，主线程无需等待其他线程到达栅栏，即可向下执行。

2. 起 5 个线程，每个线程到达栅栏的时间不一致，线程到达栅栏后，先调用 arriveAndAwaitAdvance() 阻塞当前线程直到所有的线程都到达栅栏。等 5 个线程同时到达栅栏处后，同时向下执行。

7.2 Phaser原理

8、Exchanger

8.1 Exchanger使用