Java多线程编程实战指南

一、线程安全集合的使用

1.1 ConcurrentHashMap基础用法

// 创建线程安全的Map
ConcurrentHashMap<String, Integer> scores = new ConcurrentHashMap<>();

// 多线程安全操作
scores.put("Alice", 90);
scores.computeIfPresent("Alice", (k, v) -> v + 5); // 原子更新

// 遍历操作也是线程安全的
scores.forEach((name, score) -> 
    System.out.println(name + ": " + score)
);

1.2 CopyOnWriteArrayList示例

// 适合读多写少的场景
CopyOnWriteArrayList<String> logMessages = new CopyOnWriteArrayList<>();

// 写操作会复制整个数组
logMessages.add("System started");
logMessages.add("User logged in");

// 读操作不需要同步
logMessages.forEach(System.out::println);

二、原子变量的应用

2.1 AtomicInteger计数器

AtomicInteger counter = new AtomicInteger(0);

// 多线程安全递增
IntStream.range(0, 100).parallel().forEach(i -> {
    counter.incrementAndGet();
});

System.out.println("Final count: " + counter.get());

2.2 LongAdder高性能计数

// 适合高并发统计场景
LongAdder totalRequests = new LongAdder();

// 多线程累加
IntStream.range(0, 1000).parallel().forEach(i -> {
    totalRequests.add(i);
});

System.out.println("Total requests: " + totalRequests.sum());

三、线程池最佳实践

3.1 自定义线程池配置

// 创建定制化的线程池
ThreadPoolExecutor executor = new ThreadPoolExecutor(
    4,  // 核心线程数
    8,  // 最大线程数
    30, TimeUnit.SECONDS, // 空闲线程存活时间
    new ArrayBlockingQueue<>(100), // 有界队列
    new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
);

// 提交任务
executor.execute(() -> {
    System.out.println("Task running in " + Thread.currentThread().getName());
});

// 优雅关闭
executor.shutdown();

3.2 CompletableFuture异步编程

// 链式异步任务
CompletableFuture.supplyAsync(() -> fetchDataFromDB(), executor)
    .thenApplyAsync(data -> processData(data), executor)
    .thenAcceptAsync(result -> saveResult(result), executor)
    .exceptionally(ex -> {
        System.err.println("Error: " + ex.getMessage());
        return null;
    });

四、锁的高级用法

4.1 ReentrantLock条件变量

class BoundedBuffer {
    private final Lock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();
    private final Object[] items = new Object[100];
    private int count;
    
    public void put(Object x) throws InterruptedException {
        lock.lock();
        try {
            while (count == items.length)
                notFull.await();
            items[count++] = x;
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }
    
    public Object take() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0)
                notEmpty.await();
            Object x = items[--count];
            notFull.signal();
            return x;
        } finally {
            lock.unlock();
        }
    }
}

4.2 StampedLock乐观读

class Point {
    private double x, y;
    private final StampedLock sl = new StampedLock();
    
    void move(double deltaX, double deltaY) {
        long stamp = sl.writeLock();
        try {
            x += deltaX;
            y += deltaY;
        } finally {
            sl.unlockWrite(stamp);
        }
    }
    
    double distanceFromOrigin() {
        // 尝试乐观读
        long stamp = sl.tryOptimisticRead();
        double currentX = x, currentY = y;
        if (!sl.validate(stamp)) {
            // 乐观读失败，转为悲观读
            stamp = sl.readLock();
            try {
                currentX = x;
                currentY = y;
            } finally {
                sl.unlockRead(stamp);
            }
        }
        return Math.sqrt(currentX * currentX + currentY * currentY);
    }
}

五、并发工具类实战

5.1 CountDownLatch应用

// 多任务并行执行后汇总结果
CountDownLatch latch = new CountDownLatch(3);
List<CompletableFuture> futures = new ArrayList<>();

futures.add(CompletableFuture.runAsync(() -> {
    try {
        // 执行任务1
    } finally {
        latch.countDown();
    }
}));

futures.add(CompletableFuture.runAsync(() -> {
    try {
        // 执行任务2
    } finally {
        latch.countDown();
    }
}));

latch.await(); // 等待所有任务完成
System.out.println("所有任务执行完毕");

5.2 CyclicBarrier分阶段处理

// 多阶段并行计算
CyclicBarrier barrier = new CyclicBarrier(4, () -> 
    System.out.println("所有线程完成当前阶段")
);

for (int i = 0; i < 4; i++) {
    new Thread(() -> {
        // 阶段1处理
        barrier.await();
        
        // 阶段2处理
        barrier.await();
    }).start();
}

六、性能调优技巧

6.1 避免锁竞争

// 使用细粒度锁替代粗粒度锁
class FineGrainedLock {
    private final Object[] locks;
    private final int[] counts;
    
    public FineGrainedLock(int size) {
        locks = new Object[size];
        counts = new int[size];
        for (int i = 0; i < size; i++) {
            locks[i] = new Object();
        }
    }
    
    public void increment(int index) {
        synchronized(locks[index]) {
            counts[index]++;
        }
    }
}

6.2 使用ThreadLocal

// 每个线程维护独立变量
class ThreadLocalExample {
    private static final ThreadLocal<SimpleDateFormat> dateFormat = 
        ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd"));
    
    public String formatDate(Date date) {
        return dateFormat.get().format(date);
    }
}

七、常见问题排查

7.1 死锁检测

// 使用jstack检测死锁
ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
long[] threadIds = threadMXBean.findDeadlockedThreads();
if (threadIds != null) {
    ThreadInfo[] threadInfos = threadMXBean.getThreadInfo(threadIds);
    for (ThreadInfo threadInfo : threadInfos) {
        System.out.println(threadInfo);
    }
}

7.2 线程泄漏监控

// 监控线程池状态
ScheduledExecutorService monitor = Executors.newScheduledThreadPool(1);
monitor.scheduleAtFixedRate(() -> {
    System.out.println("Active threads: " + ((ThreadPoolExecutor)executor).getActiveCount());
    System.out.println("Queue size: " + ((ThreadPoolExecutor)executor).getQueue().size());
}, 0, 1, TimeUnit.SECONDS);