Java中的并发工具类：让多线程编程更轻松

1. 引言：多线程编程的“痛”

多线程编程是Java开发中的一大难点，尤其是在高并发场景下，稍有不慎就会遇到线程安全问题、死锁、性能瓶颈等问题。比如：

public class Counter {private int count = 0;public void increment() {count++; // 非线程安全！}public int getCount() {return count;}
}

在多线程环境下，count++操作可能会导致数据不一致。为了解决这些问题，Java提供了丰富的并发工具类，让我们能够更轻松地编写高效、安全的多线程代码。

2. Java并发工具类简介

Java的java.util.concurrent包提供了许多强大的并发工具类，主要包括：

原子类：如AtomicInteger、AtomicReference。
锁：如ReentrantLock、ReadWriteLock。
同步工具：如CountDownLatch、CyclicBarrier、Semaphore。
线程池：如ThreadPoolExecutor、ScheduledThreadPoolExecutor。

3. 常用并发工具类实战

3.1 原子类（Atomic Classes）

原子类通过CAS（Compare-And-Swap）操作保证线程安全，适用于简单的计数器、标志位等场景。

import java.util.concurrent.atomic.AtomicInteger;public class Counter {private AtomicInteger count = new AtomicInteger(0);public void increment() {count.incrementAndGet(); // 线程安全！}public int getCount() {return count.get();}
}

3.2 可重入锁（ReentrantLock）

ReentrantLock提供了比synchronized更灵活的锁机制，支持公平锁、可中断锁等特性。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;public class Counter {private int count = 0;private Lock lock = new ReentrantLock();public void increment() {lock.lock();try {count++;} finally {lock.unlock();}}public int getCount() {return count;}
}

3.3 倒计时门闩（CountDownLatch）

CountDownLatch用于等待多个线程完成任务后再继续执行。

import java.util.concurrent.CountDownLatch;public class Main {public static void main(String[] args) throws InterruptedException {int threadCount = 5;CountDownLatch latch = new CountDownLatch(threadCount);for (int i = 0; i < threadCount; i++) {new Thread(() -> {System.out.println("线程完成任务");latch.countDown();}).start();}latch.await(); // 等待所有线程完成任务System.out.println("所有线程完成任务，继续执行主线程");}
}

3.4 信号量（Semaphore）

Semaphore用于控制同时访问某个资源的线程数量。

import java.util.concurrent.Semaphore;public class Main {public static void main(String[] args) {int permits = 3;Semaphore semaphore = new Semaphore(permits);for (int i = 0; i < 10; i++) {new Thread(() -> {try {semaphore.acquire();System.out.println("线程获取许可，开始执行任务");Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();} finally {semaphore.release();System.out.println("线程释放许可");}}).start();}}
}

4. 并发工具类的最佳实践

4.1 避免过度同步

同步操作会降低性能，尽量减少同步代码块的范围。

4.2 使用线程池

避免频繁创建和销毁线程，使用线程池管理线程资源。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class Main {public static void main(String[] args) {ExecutorService executor = Executors.newFixedThreadPool(5);for (int i = 0; i < 10; i++) {executor.submit(() -> {System.out.println("线程执行任务");});}executor.shutdown();}
}

4.3 避免死锁

确保锁的获取顺序一致，避免嵌套锁。

4.4 使用并发集合

Java提供了许多线程安全的集合类，如ConcurrentHashMap、CopyOnWriteArrayList。

import java.util.concurrent.ConcurrentHashMap;public class Main {public static void main(String[] args) {ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();map.put("key", 1);System.out.println(map.get("key"));}
}

5. 实战案例：多线程下载器

5.1 需求描述

我们需要实现一个多线程下载器，将一个大文件分成多个部分，由多个线程同时下载。

5.2 实现代码

import java.util.concurrent.CountDownLatch;public class MultiThreadDownloader {private static final int THREAD_COUNT = 5;public static void main(String[] args) throws InterruptedException {CountDownLatch latch = new CountDownLatch(THREAD_COUNT);for (int i = 0; i < THREAD_COUNT; i++) {new Thread(() -> {System.out.println("线程开始下载文件部分");try {Thread.sleep(1000); // 模拟下载过程} catch (InterruptedException e) {e.printStackTrace();}System.out.println("线程完成下载文件部分");latch.countDown();}).start();}latch.await();System.out.println("所有线程完成下载，开始合并文件");}
}