Java多线程编程最佳实践：从基础到高级

前言

在现代软件开发中，多线程编程已经成为提升应用性能的重要手段。Java作为企业级开发的主流语言，提供了丰富的多线程支持。本文将从基础概念出发，深入探讨Java多线程编程的最佳实践。

🚀 多线程基础概念

线程与进程的区别

进程：操作系统分配资源的基本单位
线程：CPU调度的基本单位，同一进程内的线程共享内存空间

Java中的线程创建方式

1. 继承Thread类

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("线程执行：" + Thread.currentThread().getName());
    }
}

// 使用
MyThread thread = new MyThread();
thread.start();

2. 实现Runnable接口（推荐）

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("线程执行：" + Thread.currentThread().getName());
    }
}

// 使用
Thread thread = new Thread(new MyRunnable());
thread.start();

3. 使用Lambda表达式（Java 8+）

Thread thread = new Thread(() -> {
    System.out.println("线程执行：" + Thread.currentThread().getName());
});
thread.start();

🔒 线程安全与同步机制

synchronized关键字

public class Counter {
    private int count = 0;
    
    // 同步方法
    public synchronized void increment() {
        count++;
    }
    
    // 同步代码块
    public void decrement() {
        synchronized(this) {
            count--;
        }
    }
    
    public synchronized int getCount() {
        return count;
    }
}

ReentrantLock的使用

import java.util.concurrent.locks.ReentrantLock;

public class LockCounter {
    private int count = 0;
    private final ReentrantLock lock = new ReentrantLock();
    
    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock(); // 确保锁被释放
        }
    }
    
    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

🏊‍♂️ 线程池的使用

为什么使用线程池？

降低资源消耗：重复利用已创建的线程
提高响应速度：任务到达时无需等待线程创建
提高线程的可管理性：统一分配、调优和监控

常用线程池类型

import java.util.concurrent.*;

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 固定大小线程池
        ExecutorService fixedPool = Executors.newFixedThreadPool(5);
        
        // 缓存线程池
        ExecutorService cachedPool = Executors.newCachedThreadPool();
        
        // 单线程池
        ExecutorService singlePool = Executors.newSingleThreadExecutor();
        
        // 定时任务线程池
        ScheduledExecutorService scheduledPool = Executors.newScheduledThreadPool(3);
        
        // 自定义线程池（推荐）
        ThreadPoolExecutor customPool = new ThreadPoolExecutor(
            2,                      // 核心线程数
            5,                      // 最大线程数
            60L,                    // 空闲线程存活时间
            TimeUnit.SECONDS,       // 时间单位
            new LinkedBlockingQueue<>(100), // 工作队列
            new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
        );
        
        // 提交任务
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            customPool.submit(() -> {
                System.out.println("执行任务 " + taskId + 
                    " 线程：" + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }
        
        // 关闭线程池
        customPool.shutdown();
    }
}

🔄 并发工具类

CountDownLatch - 倒计时门闩

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    public static void main(String[] args) throws InterruptedException {
        int threadCount = 5;
        CountDownLatch latch = new CountDownLatch(threadCount);
        
        for (int i = 0; i < threadCount; i++) {
            final int taskId = i;
            new Thread(() -> {
                try {
                    System.out.println("任务 " + taskId + " 开始执行");
                    Thread.sleep(2000); // 模拟任务执行
                    System.out.println("任务 " + taskId + " 执行完成");
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    latch.countDown(); // 计数器减1
                }
            }).start();
        }
        
        latch.await(); // 等待所有任务完成
        System.out.println("所有任务执行完成！");
    }
}

CyclicBarrier - 循环屏障

import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierExample {
    public static void main(String[] args) {
        int threadCount = 3;
        CyclicBarrier barrier = new CyclicBarrier(threadCount, () -> {
            System.out.println("所有线程都到达屏障点，开始下一阶段！");
        });
        
        for (int i = 0; i < threadCount; i++) {
            final int taskId = i;
            new Thread(() -> {
                try {
                    System.out.println("线程 " + taskId + " 到达屏障点");
                    barrier.await(); // 等待其他线程
                    System.out.println("线程 " + taskId + " 继续执行");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

📊 性能优化技巧

1. 合理设置线程池参数

// CPU密集型任务：线程数 = CPU核心数 + 1
int cpuIntensiveThreads = Runtime.getRuntime().availableProcessors() + 1;

// IO密集型任务：线程数 = CPU核心数 * 2
int ioIntensiveThreads = Runtime.getRuntime().availableProcessors() * 2;

2. 使用无锁数据结构

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.ConcurrentHashMap;

public class LockFreeExample {
    private AtomicInteger counter = new AtomicInteger(0);
    private ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();
    
    public void increment() {
        counter.incrementAndGet(); // 原子操作，无需加锁
    }
    
    public void putValue(String key, String value) {
        map.put(key, value); // 线程安全的Map操作
    }
}

3. 避免死锁

public class DeadlockAvoidance {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();
    
    // 错误示例：可能导致死锁
    public void method1() {
        synchronized(lock1) {
            synchronized(lock2) {
                // 业务逻辑
            }
        }
    }
    
    public void method2() {
        synchronized(lock2) {
            synchronized(lock1) {
                // 业务逻辑
            }
        }
    }
    
    // 正确示例：按固定顺序获取锁
    public void safeMethod1() {
        synchronized(lock1) {
            synchronized(lock2) {
                // 业务逻辑
            }
        }
    }
    
    public void safeMethod2() {
        synchronized(lock1) { // 同样的顺序
            synchronized(lock2) {
                // 业务逻辑
            }
        }
    }
}