Java并发编程JUC包：8个方法

▌ 技术引导
我见过太多人把Java并发编程里的JUC包当成银弹，结果项目一上线就炸。JUC包不是万能的，它有其适用场景，也有自己踩过的坑。比如在使用ReentrantLock时，容易忘记写unlock，导致死锁；再比如在并发集合里，误用ConcurrentHashMap的put方法，没意识到它内部是分段锁，影响性能。真要说值钱的信息，就是JUC包里的8个关键方法，能帮你避开这些雷。
这些方法包括AtomicInteger、CountDownLatch、CyclicBarrier、Semaphore、ReentrantLock、Condition、FutureTask和BlockingQueue。每个方法都有对应的锁机制、等待方式、线程同步策略。比如AtomicInteger可以做无锁的原子操作，但别以为它能替代所有同步需求，它的吞吐量在某些场景下比synchronized还低。
我之前用CountDownLatch做异步任务等待，结果在任务数量变化时没控制好，导致主线程提前结束，整个程序崩溃。现在明白，必须用final变量或者volatile变量来保证可见性。再比如CyclicBarrier的await方法，有时候会卡死，必须设置breakable参数，否则一旦有一个线程抛出异常，整个屏障就会阻塞。
ReentrantLock虽然比synchronized灵活，但它不是万能的，有时候配合Condition能实现更细粒度的等待，但锁的粒度控制不好，反而会引入更多竞争。而FutureTask配合ExecutorService，能做异步任务返回结果，但要注意线程池的配置，否则任务堆积会拖垮整个系统。
说到底，JUC包里的8个方法是工具，不是灵丹妙药。使用它们要结合业务场景，不能盲目。比如在高并发写入时，用ConcurrentHashMap会比HashMap更稳，但它的读写性能不如CopyOnWriteArrayList。每个方法都有自己的特点，得靠试错积累经验，才知道哪个更适合你的项目。

▌ 技术参考
Java并发编程中JUC包的核心在于提供更高级的同步工具。其中AtomicInteger是基于CAS（Compare and Swap）实现的原子操作类，他常用于计数器场景。CAS操作在多线程环境下能避免锁的开销，但它的性能表现取决于底层硬件支持。比如在单核CPU上，CAS可能会影响性能，而在多核环境下，CAS的效率提升非常明显。需要注意的是，AtomicInteger的getAndIncrement方法是线程安全的，但不能保证多个操作的原子性，比如先get再increment，这种组合操作必须用其他工具来保证顺序性。

CountDownLatch是JUC中一个非常实用的同步工具，它允许一个或多个线程等待其他线程完成操作。默认情况下，CountDownLatch是不可重置的，一旦倒计数归零，就不能再使用。在实际使用中，如果任务数量是动态变化的，最好用CyclicBarrier替代。CountDownLatch的await方法会阻塞当前线程，直到计数器归零，但这种阻塞是不可中断的，如果在等待过程中抛出异常，可能需要重新创建一个CountDownLatch。尝试过在主线程中等待多个子线程完成任务，发现如果子线程数量过多，CountDownLatch的性能会明显下降。

CyclicBarrier和CountDownLatch类似，但前者可以重用。它的await方法支持中断和超时，所以更适合长时间阻塞的场景。比如在并行任务中，每个线程完成任务后调用await，等待所有线程完成，再继续下一步。我之前在项目中用CyclicBarrier做任务分组，结果没设置breakable参数，导致其中一个线程抛出异常后，整个屏障被阻塞，影响了后续任务的执行。因此，建议在使用CyclicBarrier时，明确设置是否可中断，并合理处理异常。它的内部实现是基于ReentrantLock和Condition的，所以性能上和CountDownLatch差不多，但灵活性更强。

Semaphore用于限制同时访问共享资源的线程数量，是资源访问控制的利器。它有两种模式：公平模式和非公平模式。在实际使用中，非公平模式会更常见，因为它能减少线程等待时间，提升并发性能。但非公平模式可能导致饥饿问题，某些线程一直得不到资源。我曾在一个高并发读写数据库的场景中使用Semaphore做流量控制，结果发现某些线程因为CPU调度问题一直得不到资源，最终导致程序响应变慢。这时候，采取线程池+Semaphore的组合比单独用Semaphore更合适。它的acquire和release方法必须成对使用，否则会出现资源泄露。

ReentrantLock是JUC中替代synchronized的锁机制，支持公平锁和非公平锁。在使用时，建议尽量使用tryLock尝试获取锁，避免线程长时间阻塞。非公平锁的吞吐量比公平锁高，但容易出现线程饥饿。我之前在多线程写入缓存的场景中，误用了ReentrantLock的锁粒度，导致多个线程争夺同一个锁，反而降低性能。后来改用分段锁，比如使用ConcurrentHashMap，效果明显提升。ReentrantLock还支持Condition，可以实现更复杂的等待通知机制，比如在等待队列中暂停线程，直到特定条件触发。

FutureTask是JUC中用于封装异步任务的类，它和ExecutorService配合使用，能实现任务的异步执行和结果获取。在使用FutureTask时，必须注意其返回值的获取方式。比如调用get方法会阻塞当前线程，如果任务还未完成，线程会一直等待。有时候为了防止阻塞，会用FutureTask配合CompletableFuture，这样能提升异步代码的可读性。另外，FutureTask的cancel方法需要传入一个参数，表示是否中断正在执行的任务。如果任务已经完成，cancel方法不会有任何效果，必须在任务尚未执行时调用。

BlockingQueue是线程间通信的常用工具，它支持阻塞式读写操作。常用的实现类有ArrayBlockingQueue、LinkedBlockingQueue和SynchronousQueue。在使用时，要注意队列的容量，否则可能导致内存溢出。比如在生产者-消费者模型中，ArrayBlockingQueue需要在初始化时指定容量，而LinkedBlockingQueue默认是Integer.MAX_VALUE，这种情况下容易出现内存过度占用。另外，BlockingQueue的take和poll方法有不同的行为，take在队列为空时会阻塞，poll则会返回null或设定超时时间。在实际项目中，我用LinkedBlockingQueue实现过任务调度，发现它的吞吐量比SynchronousQueue高，但内存占用也更大。

ConcurrentHashMap是JUC中最常用的并发集合之一，其内部采用分段锁机制，能显著提升并发性能。在写入操作时，它会根据键的哈希值锁定对应的分段，读取操作则不需要加锁。这种设计使得ConcurrentHashMap在高并发读写环境下表现优于HashMap。但如果你的场景主要是读取，而不是频繁写入，那么CopyOnWriteArrayList可能更适合。我曾用ConcurrentHashMap做缓存，结果因为写入操作过于频繁，导致分段锁竞争激烈，程序性能下降。后来改用ConcurrentSkipListMap，性能提升明显。

ConcurrentSkipListMap是另一种线程安全的排序Map实现，它基于跳表结构，适用于读多写少的场景。相比ConcurrentHashMap，它的写入性能较差，但读操作的性能更高。在使用时，可以设置负载因子和初始容量，以优化内存占用和性能。如果需要精确的排序，ConcurrentSkipListMap是更可靠的选择。我之前在实现一个需要按时间排序的缓存时，误用了ConcurrentHashMap，结果出现数据顺序错乱的问题，后来换成ConcurrentSkipListMap才解决。

ReentrantReadWriteLock是JUC中支持读写锁分离的工具，能提高并发性能。它允许多个读线程同时访问数据，但写线程需要独占锁。在使用时，需要明确区分读锁和写锁，避免因锁竞争导致性能下降。我曾在一个数据库连接池中使用ReentrantReadWriteLock管理连接，结果发现读锁的获取比写锁更频繁，导致写操作被阻塞。后来改用更细粒度的锁管理，性能提升显著。它的读写锁可以设置公平策略，但公平策略会降低吞吐量。

ForkJoinPool是JUC中用于执行并行任务的线程池，它基于分治算法，适合处理可以拆分成子任务的工作。在使用时，可以创建ForkJoinPool实例，并指定并行级别。比如调用ForkJoinPool.commonPool()可以获取默认线程池，但特定任务可能需要自定义线程池。我之前用ForkJoinPool处理图片处理任务，发现当任务数量较少时，线程池的利用率不高，后来改为使用普通的线程池，反而更稳定。它的invoke方法会阻塞直到任务完成，而submit方法则会立即返回。

CompletableFuture是JUC中用于处理异步任务的高级工具，它支持链式调用和组合操作，能简化回调逻辑。在使用时，可以通过thenApply、thenAccept、thenRun等方法组合多个任务。我曾用CompletableFuture实现过异步HTTP请求，结果没有正确处理异常，导致错误信息被忽略。后来改用exceptionally方法捕获异常，避免了程序崩溃。它还能通过supplyAsync和runAsync实现异步执行，但注意默认线程池是ForkJoinPool.commonPool()，如果任务密集，建议自定义线程池。

CopyOnWriteArrayList是JUC中线程安全的List实现，它适合读多写少的场景。每次写入操作都会复制整个数组，这样读操作不需要加锁，但写入性能较低。我之前在一个日志系统中使用CopyOnWriteArrayList，结果写入操作频繁，导致内存占用过高和性能下降。后来改用ConcurrentLinkedQueue，发现它的性能更稳定，而且内存占用更低。它的contains方法是线程安全的，但因为每次都要遍历整个列表，所以性能不如ConcurrentHashMap。

AtomicReferenceArray是JUC中用于操作数组的原子类，它支持CAS操作，能在不加锁的情况下实现原子更新。在使用时，必须注意数组的索引范围，否则会抛出ArrayIndexOutOfBoundsException。我曾用它做状态机的切换，结果因为索引计算错误，导致状态更新失败。后来改为用AtomicIntegerArray，发现它更适合处理整数数组的原子操作。它的compareAndSet方法在并发环境下能保证线程安全，但如果是复杂对象，需要自己实现CAS逻辑，否则容易出错。

AtomicLongArray和AtomicIntegerArray类似，用于处理长整型数组的原子操作。它们的CAS方法在高并发环境下表现良好，但写入性能不如普通的数组。我曾在一个计数器系统中用AtomicLongArray做并发递增，结果发现它的吞吐量不如使用synchronized关键字。后来分析发现，是因为CAS失败率较高，导致频繁重试。这时候，使用LongAdder反而更合适。它的add方法是线程安全的，而且在高并发下性能更好。

LockSupport是JUC中用于线程阻塞和唤醒的底层工具，它提供了park和unpark方法。在使用时，需要注意线程的唤醒只能由unpark方法触发，否则线程会一直处于阻塞状态。我曾用LockSupport实现过线程等待机制，结果在异常处理时没有正确唤醒线程，导致程序死锁。后来改用Condition配合ReentrantLock，问题迎刃而解。它的park方法可以指定超时时间，但必须配对使用unpark，否则无法保证唤醒的准确性。

Semaphore和CountDownLatch的区别在于，前者是资源限制，后者是任务等待。在使用Semaphore时，可以设置公平策略，但会影响性能。我曾用Semaphore控制数据库连接池的使用，结果在高并发下发现某些线程无法获取资源，后来改用更细粒度的锁，比如ReentrantLock，问题得到解决。它的acquire和release方法必须成对使用，否则会导致资源泄露，甚至死锁。在实际项目中，建议使用tryAcquire方法尝试获取资源，以提高并发效率。