目录
1. ReentrantReadWriteLock（可重入读写锁）
JUC是Java提供的用于并发编程的工具集合，它包含在java.util.concurrent包中。JUC提供了一组框架、工具和类，以简化并发编程，使得开发者更容易编写线程安全的、高效的并发代码。以下是java.util.concurrent包中一些主要的类和接口：
Executor框架：
Executor：定义了用于执行任务的基本接口。
ExecutorService：扩展了Executor接口，提供了一些管理生命周期的方法，例如启动和关闭。
ThreadPoolExecutor：实现了ExecutorService接口的线程池实现。
ScheduledExecutorService：扩展了ExecutorService，提供了在预定时间或者周期性执行任务的功能。
ScheduledThreadPoolExecutor：实现了ScheduledExecutorService接口的线程池。
锁框架：
ReentrantLock：可重入锁，类似于传统的synchronized关键字，但提供了更多的灵活性和功能。
ReentrantReadWriteLock：可重入读写锁，支持多个线程同时读取共享资源，但只允许一个线程写入。
StampedLock：支持三种模式的锁：写锁、悲观读锁和乐观读。
ReadWriteLock接口的其他实现：除了ReentrantReadWriteLock，还有StampedLock等。
Lock：提供了一种比使用synchronized关键字更灵活的锁机制。
Lock接口的其他实现：例如ReentrantLock之外，还有ReentrantReadWriteLock.ReadLock和ReentrantReadWriteLock.WriteLock。
Reentrant:/ri??entr?nt/可重入，可再入的
原子变量：
AtomicInteger、AtomicLong：提供了原子操作的整数和长整数变量。
AtomicReference：提供了对引用类型的原子操作。AtomicBoolean、AtomicReferenceArray、AtomicIntegerArray和AtomicLongArray：提供了对布尔值、引用数组、整数数组和长整数数组的原子操作。
并发集合：
ConcurrentHashMap：线程安全的哈希表实现。
CopyOnWriteArrayList：线程安全的动态数组实现。
ConcurrentLinkedQueue：线程安全的队列实现。
ConcurrentSkipListMap和ConcurrentSkipListSet：基于跳表实现的并发Map和Set。
并发执行框架：
ForkJoinTask：用于实现可分解任务的基类。
RecursiveTask：可递归地分解的任务。
RecursiveAction：无返回值的可递归分解任务。
并发工具类：
CompletableFuture：异步编程的工具，支持将多个异步操作组合在一起。
BlockingQueue：提供了一组阻塞队列，用于在多线程之间传递数据。
Semaphore：用于控制同时访问特定资源的线程数目。
Phaser：提供了更灵活的同步控制机制，允许线程在多个阶段协同工作。
Exchanger：允许两个线程在一个点交换对象。
Semaphore：用于控制对特定资源的访问的线程数。
CountedCompleter：用于支持基于任务的异步框架。
并发队列的实现：
LinkedBlockingDeque：基于链表实现的双端阻塞队列。
LinkedTransferQueue：支持非阻塞的、一对一传输的队列。
ArrayBlockingQueue：基于数组的有界阻塞队列。
PriorityBlockingQueue：无界的并发优先级队列。
线程安全的工具类：
ThreadLocalRandom：为线程提供本地化的随机数生成器。
ThreadLocal：提供线程本地变量，每个线程都有一个独立的实例。
同步器：
CountDownLatch：允许一个或多个线程等待其他线程完成操作。
CyclicBarrier：允许一组线程相互等待，直到到达某个公共屏障点。
Semaphore：提供了一种计数信号量的实现。
JUC工具类：
TimeUnit：提供了用于处理时间单位的工具类。
Executors：提供了一些工厂方法，用于创建不同类型的ExecutorService。
ThreadFactory：定义了用于创建线程的工厂接口。
异步编程支持：
CompletableFuture：支持异步编程，可以串行或并行执行一系列异步任务。
并发框架的性能工具：
LockSupport：提供了一些基本的阻塞和解除阻塞的方法，用于线程的高级控制。
基于JDK1.8
| 普通 | atomic | locks |
| AbstractExecutorService ArrayBlockingQueue BlockingDeque BlockingQueue BrokenBarrierException Callable CancellationException CompletableFuture CompletionException CompletionService CompletionStage ConcurrentHashMap ConcurrentLinkedDeque ConcurrentLinkedQueue ConcurrentMap ConcurrentNavigableMap ConcurrentSkipListMap ConcurrentSkipListSet CopyOnWriteArrayList CopyOnWriteArraySet CountDownLatch CountedCompleter CyclicBarrier Delayed DelayQueue Exchanger ExecutionException Executor ExecutorCompletionService Executors ExecutorService ForkJoinPool ForkJoinTask ForkJoinWorkerThread Future FutureTask LinkedBlockingDeque LinkedBlockingQueue LinkedTransferQueue Phaser PriorityBlockingQueue RecursiveAction RecursiveTask RejectedExecutionException RejectedExecutionHandler RunnableFuture RunnableScheduledFuture ScheduledExecutorService ScheduledFuture ScheduledThreadPoolExecutor Semaphore SynchronousQueue ThreadFactory ThreadLocalRandom ThreadPoolExecutor TimeoutException TimeUnit TransferQueue | AtomicBoolean AtomicInteger AtomicIntegerArray AtomicIntegerFieldUpdater AtomicLong AtomicLongArray AtomicLongFieldUpdater AtomicMarkableReference AtomicReference AtomicReferenceArray AtomicReferenceFieldUpdater AtomicStampedReference DoubleAccumulator DoubleAdder LongAccumulator LongAdder Striped64 | AbstractOwnableSynchronizer AbstractQueuedLongSynchronizer AbstractQueuedSynchronizer Condition Lock LockSupport ReadWriteLock ReentrantLock ReentrantReadWriteLock StampedLock |
1. AbstractExecutorService: (implements ExecutorService) 抽象执行器服务接口。
2. ArrayBlockingQueue: (implements BlockingQueue) 基于数组的有界阻塞队列，用于多线程数据共享。
3. BlockingDeque: (extends BlockingQueue, implements BlockingDeque) 阻塞双端队列，支持在两端插入和移除元素。
4. BlockingQueue: (extends Queue) 阻塞队列接口，用于多线程数据传递。
5. Executors: 提供了创建不同类型执行器服务的工厂方法。
6. Executor: 执行提交的任务的简单接口。
7. ExecutorService: (extends Executor) 扩展Executor接口，提供更丰富的任务执行控制。
8. ForkJoinPool: (extends AbstractExecutorService) 分治任务的线程池。
9. RunnableFuture: (extends Runnable, Future) 代表可运行的任务，可被取消，返回结果。
10. RunnableScheduledFuture: (extends RunnableFuture, ScheduledFuture) 可调度任务的接口。
11. ScheduledExecutorService: (extends ExecutorService) 扩展ExecutorService，支持定时执行任务。
12. ScheduledFuture: (extends Delayed, Future) 可调度任务的延迟执行结果。
13. ScheduledThreadPoolExecutor: (extends ThreadPoolExecutor, implements ScheduledExecutorService) 基于线程池的定时任务执行器。
14. ThreadPoolExecutor: (extends AbstractExecutorService) 灵活的线程池实现，支持动态调整。
15. ThreadFactory: 创建新线程的工厂接口。
16. ConcurrentHashMap: (implements ConcurrentMap) 高并发访问的线程安全哈希表。
17. ConcurrentLinkedDeque: (implements BlockingDeque) 无界非阻塞双端队列。
18. ConcurrentLinkedQueue: (implements Queue) 无界非阻塞队列。
19. ConcurrentMap: (extends Map) 线程安全Map接口。
20. ConcurrentNavigableMap: (extends ConcurrentMap, NavigableMap) 可导航的线程安全Map接口。
21. ConcurrentSkipListMap: (implements ConcurrentNavigableMap) 基于跳表的线程安全Map。
22. ConcurrentSkipListSet: (implements NavigableSet, ConcurrentNavigableSet) 基于跳表的线程安全Set。
23. CopyOnWriteArrayList: (implements List) 线程安全List，通过复制机制实现并发访问。
24. CopyOnWriteArraySet: (implements Set) 线程安全Set，通过复制机制实现并发访问。
25. LinkedBlockingDeque: (implements BlockingDeque) 基于链表的双端阻塞队列。
26. LinkedBlockingQueue: (implements BlockingQueue) 基于链表的阻塞队列。
27. LinkedTransferQueue: (implements TransferQueue) 无界队列，支持优先级。
28. PriorityBlockingQueue: (implements BlockingQueue) 支持优先级的无界阻塞队列。
29. SynchronousQueue: (implements BlockingQueue) 不存储元素的阻塞队列，用于直接传递数据。
30. CountDownLatch: (implements java.io.Serializable) 倒计时计数器，等待一组线程执行完毕。
31. CyclicBarrier: (implements java.io.Serializable) 循环屏障，等待一组线程达到某个状态。
32. Exchanger: (implements java.io.Serializable) 两个线程之间交换数据。
33. Phaser: (implements java.io.Serializable) 高级同步屏障，支持动态注册参与者。
34. Semaphore: (implements java.io.Serializable) 信号量，控制同时访问某个资源的线程数量。
35. StampedLock: (implements java.io.Serializable) 乐观读写锁，支持读写锁的优化。
36. LockSupport: 基本的线程同步工具。
37. Callable: (implements java.util.concurrent.Callable) 可调用任务的接口，支持返回结果和抛出异常。
38. CompletableFuture: (implements Future, CompletionStage) 异步计算的结果，支持链式调用。
39. CompletionException: (extends RuntimeException) 异步计算中出现的异常。
40. CompletionService: (implements Executor) 异步执行服务，按完成顺序获取结果。
41. CompletionStage: 异步计算阶段的接口，支持链式操作。
42. Future: (implements java.util.concurrent.Future) 代表异步计算的结果，支持取消和等待。
43. FutureTask: (implements RunnableFuture) 可取消的异步计算任务。
44. AtomicBoolean: (implements java.io.Serializable) 原子布尔型变量。
45. AtomicInteger: (implements java.io.Serializable) 原子整型变量。
46. AtomicIntegerArray: (implements java.io.Serializable) 原子整型数组。
47. AtomicIntegerFieldUpdater: (abstract class) 原子更新整型字段。
48. AtomicLong: (implements java.io.Serializable) 原子长整型变量。
49. AtomicLongArray: (implements java.io.Serializable) 原子长整型数组。
50. AtomicLongFieldUpdater: (abstract class) 原子更新长整型字段。
51. AtomicMarkableReference: (implements java.io.Serializable) 原子更新带有标记位的引用。
52. AtomicReference: (implements java.io.Serializable) 原子引用类型变量。
53. AtomicReferenceArray: (implements java.io.Serializable) 原子引用类型数组。
54. AtomicReferenceFieldUpdater: (abstract class) 原子更新引用类型字段。
55. AtomicStampedReference: (implements java.io.Serializable) 原子更新带有版本号的引用。
56. ForkJoinTask: (implements Future) 支持分治任务的抽象基类。
57. ForkJoinWorkerThread: (extends Thread) 用于执行ForkJoinTask的工作线程。
58. RecursiveAction: (extends ForkJoinTask) 递归无结果的ForkJoinTask。
59. RecursiveTask: (extends ForkJoinTask) 递归有结果的ForkJoinTask。
60. BrokenBarrierException: (extends Exception) 循环屏障中的异常，表示某个线程被中断。
61. CancellationException: (extends IllegalStateException) 取消操作时抛出的异常。
62. ExecutionException: (extends Exception) 执行过程中出现的异常。
63. RejectedExecutionException: (extends RuntimeException) 拒绝执行任务时抛出的异常。
64. TimeoutException: (extends Exception) 在等待一段时间后仍未获得结果时抛出的异常。
65. TimeUnit: (implements java.io.Serializable) 表示时间单位的枚举类。
66. Delayed: (extends Comparable) 用于支持延迟执行的接口。
67. AbstractOwnableSynchronizer: (abstract class) 提供了独占模式同步器的基本实现。
68. AbstractQueuedLongSynchronizer: (abstract class) 提供了64位整数同步器的基本实现。
69. AbstractQueuedSynchronizer: (abstract class) 提供了基于队列的同步器的基本实现。
Reentrant:/ri??entr?nt/可重入，可再入的
70. Condition: (subinterface of java.util.concurrent.locks.Lock) 条件变量，用于在锁上等待或唤醒线程。
71. Lock: (interface) 锁的基本接口。
72. ReadWriteLock: (interface) 读写锁的接口，支持多个读线程同时访问。
73. ReentrantLock: (implements Lock, java.io.Serializable) 可重入锁的实现。
74. ReentrantReadWriteLock: (implements ReadWriteLock, java.io.Serializable) 可重入读写锁的实现。
75. StampedLock: (implements java.io.Serializable) 支持乐观读、悲观读和写锁的锁。
76. DoubleAccumulator: (implements java.io.Serializable) 支持原子累加的双精度浮点型变量。
77. DoubleAdder: (implements java.io.Serializable) 支持原子累加的双精度浮点型累加器。
78. LongAccumulator: (implements java.io.Serializable) 支持原子累加的长整型变量。
79. LongAdder: (implements java.io.Serializable) 支持原子累加的长整型累加器。
80. ThreadLocalRandom: 提供线程本地的随机数生成器。
81. Striped64: (abstract class) 用于实现分离状态的原子变量。
82. InterruptedException: (extends Exception) 在阻塞操作中被中断时抛出的异常。
83. RunnableFuture: (implements Runnable, Future) 代表可运行的任务，可被取消，并返回结果。
84. Callable: (interface) 可调用任务的接口，支持返回结果和抛出异常。
85. ThreadLocalRandom: 提供线程本地的随机数生成器。
ReentrantReadWriteLock 提供了读锁和写锁，用于更细粒度地控制对共享资源的访问。多个线程可以同时持有读锁，但只允许一个线程持有写锁。与普通的ReentrantLock相比，ReentrantReadWriteLock分为读锁和写锁，提供了更高的并发性。
读锁：
多个线程可以同时持有读锁，以允许并发读取操作。
当没有线程持有写锁时，多个线程可以同时获取读锁。
读锁是共享的，不会阻止其他线程获取读锁。
ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
// 读锁的获取
rwLock.readLock().lock();
try {
????// 执行读操作
} finally {
????// 读锁的释放
????rwLock.readLock().unlock();
}写锁：
只有一个线程可以持有写锁，以防止并发写入操作。
当有线程持有写锁时，其他线程无法获取读锁或写锁。
ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
// 写锁的获取
rwLock.writeLock().lock();
try {
// 执行写操作
} finally {
// 写锁的释放
rwLock.writeLock().unlock();
}锁降级（Lock Downgrading）：
如果线程持有写锁，它可以获取读锁，然后释放写锁，从而实现锁降级。这允许在保持写锁期间执行读取操作。
锁升级（Lock Upgrading）：
允许在持有读锁的情况下获取写锁，但不允许在持有写锁的情况下获取读锁。这是为了防止死锁。
重入性（Reentrancy）：
与ReentrantLock一样，ReentrantReadWriteLock支持重入性，允许线程在已经持有锁的情况下重新获取相同类型的锁，而不会死锁。
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class SharedResource {
????private int data = 0;
????private ReadWriteLock lock = new ReentrantReadWriteLock();
????public int readData() {
????????lock.readLock().lock();
????????try {
????????????// 读取共享资源的操作
????????????return data;
????????} finally {
????????????lock.readLock().unlock();
????????}
????}
????public void writeData(int newValue) {
????????lock.writeLock().lock();
????????try {
????????????// 写入共享资源的操作
????????????data = newValue;
????????} finally {
????????????lock.writeLock().unlock();
????????}
????}
}在上面的示例中，readData方法使用读锁进行访问，而writeData方法使用写锁进行访问。这样可以实现在读操作时允许多个线程并发访问，但在写操作时只允许一个线程访问，确保数据的一致性和线程安全性。
ReentrantLock 是一种可重入锁，它允许线程重复地获取同一把锁，提供了与 synchronized 关键字类似的互斥性。但相比于 synchronized，ReentrantLock 提供了更多的灵活性和额外的功能：
锁的获取和释放：
ReentrantLock lock = new ReentrantLock();
// 锁的获取
lock.lock();
try {
????// 执行被保护的临界区代码
} finally {
????// 锁的释放，一般在 finally 块中确保锁的释放，防止发生异常时锁无法释放
????lock.unlock();
}条件变量（Condition）：
Condition condition = lock.newCondition();
// 在某个条件上等待
condition.await();
// 在某个条件上唤醒等待的线程
condition.signal();ReentrantLock 提供了与锁关联的 Condition 对象，用于在特定条件下进行线程间的协作。
公平锁和非公平锁：
ReentrantLock 可以选择是公平锁还是非公平锁，默认是非公平锁。在公平锁中，线程按照请求锁的顺序获取锁；而在非公平锁中，线程有机会“插队”获取锁。
StampedLock 是 Java 8 引入的，是 ReentrantReadWriteLock 的升级版。它引入了乐观读（Optimistic Reading）模式，允许线程尝试读取而无需获取读锁，当读操作较多时，性能更好。
乐观读：
StampedLock stampedLock = new StampedLock();
long stamp = stampedLock.tryOptimisticRead();
// 读取数据
if (!stampedLock.validate(stamp)) {
????// 如果在读取期间有写操作发生，需要使用悲观读锁
????stamp = stampedLock.readLock();
????try {
????????// 重新读取数据
????} finally {
????????stampedLock.unlockRead(stamp);
????}
}悲观读和写锁：
StampedLock stampedLock = new StampedLock();
// 获取悲观读锁
long stamp = stampedLock.readLock();
try {
????// 执行读操作
} finally {
????stampedLock.unlockRead(stamp);
}
// 获取写锁
long writeStamp = stampedLock.writeLock();
try {
????// 执行写操作
} finally {
????stampedLock.unlockWrite(writeStamp);
}除了 ReentrantLock，ReentrantReadWriteLock 和 StampedLock 外，JUC 还提供了其他实现了 Lock 接口的类，如 FairLock、ConditionLock 等，以满足不同场景下的需求。