Java并发编程深度解析：从理论到实践#

🧵 并发编程核心要点

深入理解Java内存模型和happens-before原则

掌握synchronized、volatile、Lock等同步机制

熟练运用线程池和并发工具类

了解常见并发问题的原因和解决方案

学习高性能并发编程的最佳实践

🎯 为什么需要并发编程？#

在现代计算机系统中，CPU通常拥有多个核心，为了充分利用硬件资源，提升程序性能，我们需要让程序能够同时执行多个任务。这就是并发编程的核心价值。

并发 vs 并行#

graph LR subgraph "并发(Concurrency)" A[Task1] -.-> B[Task2] B -.-> C[Task3] C -.-> A end subgraph "并行(Parallelism)" D[Task1] E[Task2] F[Task3] end A --> G[单核CPU时间片轮转] D --> H[多核CPU同时执行]

🧠 Java内存模型 (JMM)#

内存模型基础#

graph TB subgraph "JVM内存结构" A[主内存 Main Memory] subgraph "线程1" B[工作内存1] C[本地变量副本] end subgraph "线程2" D[工作内存2] E[本地变量副本] end B <--> A D <--> A C -.-> B E -.-> D end

Happens-Before规则#

1
public class HappensBeforeExample {
2
    private int x = 0;
3
    private volatile boolean flag = false;
4

5
    // 线程1执行
6
    public void writer() {
7
        x = 42;           // 1
8
        flag = true;      // 2
9
    }
10

11
    // 线程2执行
12
    public void reader() {
13
        if (flag) {       // 3
14
            int y = x;    // 4, y的值一定是42
15
        }
16
    }
17
}

分析：由于flag是volatile变量，操作2 happens-before 操作3，而操作1在操作2之前，操作4在操作3之后，所以操作1 happens-before 操作4。

🔐 同步机制详解#

1. synchronized关键字#

1
public class SynchronizedExample {
2
    private int count = 0;
3
    private final Object lock = new Object();
4

5
    // 同步方法
6
    public synchronized void increment1() {
7
        count++;
8
    }
9

10
    // 同步代码块 - 实例锁
11
    public void increment2() {
12
        synchronized (this) {
13
            count++;
14
        }
15
    }
16

17
    // 同步代码块 - 私有锁
18
    public void increment3() {
19
        synchronized (lock) {
20
            count++;
21
        }
22
    }
23

24
    // 静态同步方法 - 类锁
25
    public static synchronized void staticMethod() {
26
        // 静态操作
27
    }
28
}

synchronized底层实现#

1
// 编译后的字节码（简化版）
2
public void increment() {
3
    // monitorenter  // 获取锁
4
    count++;
5
    // monitorexit   // 释放锁
6
}

2. volatile关键字#

1
public class VolatileExample {
2
    private volatile boolean running = true;
3
    private volatile int counter = 0;
4

5
    public void stop() {
6
        running = false;  // 立即对所有线程可见
7
    }
8

9
    public void run() {
10
        while (running) {
11
            // 执行任务
12
            counter++;    // 注意：volatile不保证原子性
13
        }
14
    }
15

16
    // 错误示例：volatile不能保证复合操作的原子性
17
    private volatile int volatileCount = 0;
18

19
    public void wrongIncrement() {
20
        volatileCount++;  // 这不是原子操作！包含读取、计算、写入三步
21
    }
22

23
    // 正确做法：使用AtomicInteger
24
    private final AtomicInteger atomicCount = new AtomicInteger(0);
25

26
    public void correctIncrement() {
27
        atomicCount.incrementAndGet();  // 这是原子操作
28
    }
29
}

3. Lock接口和ReentrantLock#

1
public class LockExample {
2
    private final ReentrantLock lock = new ReentrantLock();
3
    private final Condition condition = lock.newCondition();
4
    private int count = 0;
5

6
    public void increment() {
7
        lock.lock();
8
        try {
9
            count++;
10
            condition.signalAll();  // 唤醒等待的线程
11
        } finally {
12
            lock.unlock();  // 确保在finally块中释放锁
13
        }
14
    }
15

16
    public void waitForCondition() throws InterruptedException {
17
        lock.lock();
18
        try {
19
            while (count < 10) {
20
                condition.await();  // 等待条件满足
21
            }
22
            // 条件满足后的处理逻辑
23
        } finally {
24
            lock.unlock();
25
        }
26
    }
27

28
    // 可中断的锁获取
29
    public void interruptibleLock() throws InterruptedException {
30
        if (lock.tryLock(5, TimeUnit.SECONDS)) {  // 尝试获取锁，最多等待5秒
31
            try {
32
                // 执行临界区代码
33
            } finally {
34
                lock.unlock();
35
            }
36
        } else {
37
            throw new RuntimeException("无法获取锁");
38
        }
39
    }
40
}

ReentrantLock vs synchronized#

特性	synchronized	ReentrantLock
使用简便性	🟢 简单	🟡 需要手动管理
功能丰富性	🟡 基础功能	🟢 功能丰富
性能	🟢 JVM优化	🟡 相当
可中断性	❌ 不支持	✅ 支持
公平锁	❌ 不支持	✅ 支持
条件变量	❌ 单一wait/notify	✅ 多个Condition

🧵 线程池详解#

ThreadPoolExecutor参数解析#

1
public class ThreadPoolExample {
2

3
    public static void main(String[] args) {
4
        // 自定义线程池
5
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
6
            5,                              // corePoolSize: 核心线程数
7
            10,                             // maximumPoolSize: 最大线程数
8
            60L,                            // keepAliveTime: 空闲线程存活时间
9
            TimeUnit.SECONDS,               // unit: 时间单位
10
            new ArrayBlockingQueue<>(100),  // workQueue: 任务队列
11
            new ThreadPoolExecutor.CallerRunsPolicy()  // handler: 拒绝策略
12
        );
13

14
        // 提交任务
15
        for (int i = 0; i < 20; i++) {
16
            final int taskNum = i;
17
            executor.submit(() -> {
18
                System.out.println("执行任务 " + taskNum +
19
                    " - 线程: " + Thread.currentThread().getName());
20
                try {
21
                    Thread.sleep(2000);
22
                } catch (InterruptedException e) {
23
                    Thread.currentThread().interrupt();
24
                }
25
            });
26
        }
27

28
        // 优雅关闭
29
        executor.shutdown();
30
        try {
31
            if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
32
                executor.shutdownNow();
33
            }
34
        } catch (InterruptedException e) {
35
            executor.shutdownNow();
36
        }
37
    }
38
}

线程池执行流程#

flowchart TD A[提交任务] --> B{核心线程池是否已满?} B -->|否| C[创建核心线程执行] B -->|是| D{任务队列是否已满?} D -->|否| E[任务加入队列等待] D -->|是| F{最大线程池是否已满?} F -->|否| G[创建非核心线程执行] F -->|是| H[执行拒绝策略] C --> I[任务执行完成] E --> I G --> I

常用拒绝策略#

1
public class RejectionPolicyExample {
2

3
    // 1. CallerRunsPolicy - 调用者运行
4
    ThreadPoolExecutor executor1 = new ThreadPoolExecutor(
5
        2, 4, 60L, TimeUnit.SECONDS,
6
        new ArrayBlockingQueue<>(2),
7
        new ThreadPoolExecutor.CallerRunsPolicy()  // 主线程执行被拒绝的任务
8
    );
9

10
    // 2. AbortPolicy - 抛出异常（默认）
11
    ThreadPoolExecutor executor2 = new ThreadPoolExecutor(
12
        2, 4, 60L, TimeUnit.SECONDS,
13
        new ArrayBlockingQueue<>(2),
14
        new ThreadPoolExecutor.AbortPolicy()  // 抛出RejectedExecutionException
15
    );
16

17
    // 3. DiscardPolicy - 静默丢弃
18
    ThreadPoolExecutor executor3 = new ThreadPoolExecutor(
19
        2, 4, 60L, TimeUnit.SECONDS,
20
        new ArrayBlockingQueue<>(2),
21
        new ThreadPoolExecutor.DiscardPolicy()  // 直接丢弃任务，不抛异常
22
    );
23

24
    // 4. DiscardOldestPolicy - 丢弃最旧的
25
    ThreadPoolExecutor executor4 = new ThreadPoolExecutor(
26
        2, 4, 60L, TimeUnit.SECONDS,
27
        new ArrayBlockingQueue<>(2),
28
        new ThreadPoolExecutor.DiscardOldestPolicy()  // 丢弃队列头部最旧的任务
29
    );
30

31
    // 5. 自定义拒绝策略
32
    ThreadPoolExecutor executor5 = new ThreadPoolExecutor(
33
        2, 4, 60L, TimeUnit.SECONDS,
34
        new ArrayBlockingQueue<>(2),
35
        (task, executor) -> {
36
            // 自定义处理逻辑，如记录日志、降级处理等
37
            System.err.println("任务被拒绝: " + task.toString());
38
            // 可以选择将任务存储到数据库或消息队列中
39
        }
40
    );
41
}

🛠️ 并发工具类#

1. CountDownLatch - 倒计时门闩#

1
public class CountDownLatchExample {
2

3
    public static void main(String[] args) throws InterruptedException {
4
        int numTasks = 3;
5
        CountDownLatch latch = new CountDownLatch(numTasks);
6

7
        // 启动多个任务
8
        for (int i = 0; i < numTasks; i++) {
9
            final int taskId = i;
10
            new Thread(() -> {
11
                try {
12
                    System.out.println("任务 " + taskId + " 开始执行");
13
                    Thread.sleep(1000 + taskId * 500);  // 模拟任务执行
14
                    System.out.println("任务 " + taskId + " 执行完成");
15
                } catch (InterruptedException e) {
16
                    Thread.currentThread().interrupt();
17
                } finally {
18
                    latch.countDown();  // 完成一个任务，计数减1
19
                }
20
            }).start();
21
        }
22

23
        // 等待所有任务完成
24
        System.out.println("等待所有任务完成...");
25
        latch.await();
26
        System.out.println("所有任务已完成！");
27
    }
28
}

2. CyclicBarrier - 循环栅栏#

1
public class CyclicBarrierExample {
2

3
    public static void main(String[] args) {
4
        int numThreads = 3;
5

6
        CyclicBarrier barrier = new CyclicBarrier(numThreads, () -> {
7
            System.out.println("所有线程都到达栅栏，开始执行汇总操作！");
8
        });
9

10
        for (int i = 0; i < numThreads; i++) {
11
            final int threadId = i;
12
            new Thread(() -> {
13
                try {
14
                    // 第一阶段工作
15
                    System.out.println("线程 " + threadId + " 完成第一阶段工作");
16
                    Thread.sleep(1000 + threadId * 200);
17

18
                    barrier.await();  // 等待其他线程完成第一阶段
19

20
                    // 第二阶段工作
21
                    System.out.println("线程 " + threadId + " 开始第二阶段工作");
22
                    Thread.sleep(500);
23
                    System.out.println("线程 " + threadId + " 完成第二阶段工作");
24

25
                } catch (InterruptedException | BrokenBarrierException e) {
26
                    e.printStackTrace();
27
                }
28
            }).start();
29
        }
30
    }
31
}

3. Semaphore - 信号量#

1
public class SemaphoreExample {
2
    private static final Semaphore semaphore = new Semaphore(3);  // 允许3个线程同时执行
3

4
    public static void main(String[] args) {
5
        for (int i = 0; i < 10; i++) {
6
            final int taskId = i;
7
            new Thread(() -> accessResource(taskId)).start();
8
        }
9
    }
10

11
    private static void accessResource(int taskId) {
12
        try {
13
            System.out.println("任务 " + taskId + " 等待获取许可证...");
14
            semaphore.acquire();  // 获取许可证
15

16
            System.out.println("任务 " + taskId + " 获得许可证，开始执行");
17
            Thread.sleep(2000);  // 模拟资源使用
18
            System.out.println("任务 " + taskId + " 执行完成，释放许可证");
19

20
        } catch (InterruptedException e) {
21
            Thread.currentThread().interrupt();
22
        } finally {
23
            semaphore.release();  // 释放许可证
24
        }
25
    }
26
}

4. 原子类家族#

1
public class AtomicExample {
2

3
    // 基本类型原子类
4
    private final AtomicInteger counter = new AtomicInteger(0);
5
    private final AtomicLong longCounter = new AtomicLong(0);
6
    private final AtomicBoolean flag = new AtomicBoolean(false);
7

8
    // 数组类型原子类
9
    private final AtomicIntegerArray array = new AtomicIntegerArray(10);
10

11
    // 引用类型原子类
12
    private final AtomicReference<User> userRef = new AtomicReference<>();
13

14
    public void basicAtomicOperations() {
15
        // 基本操作
16
        int oldValue = counter.get();                    // 获取当前值
17
        int newValue = counter.incrementAndGet();        // 原子递增并返回新值
18
        boolean success = counter.compareAndSet(1, 2);   // CAS操作
19

20
        // 数组操作
21
        array.set(0, 100);                              // 设置指定位置的值
22
        int arrayValue = array.getAndIncrement(0);       // 原子递增指定位置
23

24
        // 自定义更新逻辑
25
        counter.updateAndGet(current -> current * 2);    // 当前值乘以2
26
        counter.accumulateAndGet(10, Integer::sum);      // 当前值加10
27
    }
28

29
    // 自定义原子操作
30
    public void customAtomicOperation() {
31
        AtomicReference<Node> head = new AtomicReference<>();
32

33
        // 无锁栈的push操作
34
        Node newNode = new Node("data");
35
        Node currentHead;
36
        do {
37
            currentHead = head.get();
38
            newNode.next = currentHead;
39
        } while (!head.compareAndSet(currentHead, newNode));
40
    }
41

42
    static class User {
43
        String name;
44
        int age;
45

46
        User(String name, int age) {
47
            this.name = name;
48
            this.age = age;
49
        }
50
    }
51

52
    static class Node {
53
        String data;
54
        Node next;
55

56
        Node(String data) {
57
            this.data = data;
58
        }
59
    }
60
}

🚨 常见并发问题和解决方案#

1. 死锁问题#

1
public class DeadlockExample {
2
    private final Object lock1 = new Object();
3
    private final Object lock2 = new Object();
4

5
    // 可能发生死锁的代码
6
    public void method1() {
7
        synchronized (lock1) {
8
            System.out.println("方法1获得lock1");
9
            try { Thread.sleep(100); } catch (InterruptedException e) {}
10

11
            synchronized (lock2) {
12
                System.out.println("方法1获得lock2");
13
            }
14
        }
15
    }
16

17
    public void method2() {
18
        synchronized (lock2) {
19
            System.out.println("方法2获得lock2");
20
            try { Thread.sleep(100); } catch (InterruptedException e) {}
21

22
            synchronized (lock1) {
23
                System.out.println("方法2获得lock1");
24
            }
25
        }
26
    }
27

28
    // 解决方案1：统一获取锁的顺序
29
    public void safeMethod1() {
30
        synchronized (lock1) {
31
            synchronized (lock2) {
32
                // 业务逻辑
33
            }
34
        }
35
    }
36

37
    public void safeMethod2() {
38
        synchronized (lock1) {  // 与method1保持相同的锁顺序
39
            synchronized (lock2) {
40
                // 业务逻辑
41
            }
42
        }
43
    }
44

45
    // 解决方案2：使用tryLock设置超时
46
    private final ReentrantLock reentrantLock1 = new ReentrantLock();
47
    private final ReentrantLock reentrantLock2 = new ReentrantLock();
48

49
    public void timeoutMethod() {
50
        boolean lock1Acquired = false;
51
        boolean lock2Acquired = false;
52

53
        try {
54
            lock1Acquired = reentrantLock1.tryLock(1, TimeUnit.SECONDS);
55
            if (lock1Acquired) {
56
                lock2Acquired = reentrantLock2.tryLock(1, TimeUnit.SECONDS);
57
                if (lock2Acquired) {
58
                    // 执行业务逻辑
59
                }
60
            }
61
        } catch (InterruptedException e) {
62
            Thread.currentThread().interrupt();
63
        } finally {
64
            if (lock2Acquired) reentrantLock2.unlock();
65
            if (lock1Acquired) reentrantLock1.unlock();
66
        }
67
    }
68
}

2. 生产者-消费者问题#

1
public class ProducerConsumerExample {
2
    private final BlockingQueue<String> queue = new ArrayBlockingQueue<>(10);
3
    private final AtomicBoolean running = new AtomicBoolean(true);
4

5
    // 生产者
6
    class Producer implements Runnable {
7
        @Override
8
        public void run() {
9
            int count = 0;
10
            while (running.get()) {
11
                try {
12
                    String item = "Item-" + count++;
13
                    queue.put(item);  // 队列满时会阻塞
14
                    System.out.println("生产: " + item);
15
                    Thread.sleep(100);
16
                } catch (InterruptedException e) {
17
                    Thread.currentThread().interrupt();
18
                    break;
19
                }
20
            }
21
        }
22
    }
23

24
    // 消费者
25
    class Consumer implements Runnable {
26
        private final String name;
27

28
        Consumer(String name) {
29
            this.name = name;
30
        }
31

32
        @Override
33
        public void run() {
34
            while (running.get() || !queue.isEmpty()) {
35
                try {
36
                    String item = queue.poll(1, TimeUnit.SECONDS);  // 超时等待
37
                    if (item != null) {
38
                        System.out.println(name + " 消费: " + item);
39
                        Thread.sleep(150);  // 模拟处理时间
40
                    }
41
                } catch (InterruptedException e) {
42
                    Thread.currentThread().interrupt();
43
                    break;
44
                }
45
            }
46
        }
47
    }
48

49
    public void start() {
50
        // 启动1个生产者和2个消费者
51
        new Thread(new Producer()).start();
52
        new Thread(new Consumer("消费者1")).start();
53
        new Thread(new Consumer("消费者2")).start();
54

55
        // 10秒后停止
56
        new Thread(() -> {
57
            try {
58
                Thread.sleep(10000);
59
                running.set(false);
60
                System.out.println("停止生产消费");
61
            } catch (InterruptedException e) {
62
                Thread.currentThread().interrupt();
63
            }
64
        }).start();
65
    }
66
}

3. 缓存一致性问题#

1
public class CacheConsistencyExample {
2
    private final ConcurrentHashMap<String, String> cache = new ConcurrentHashMap<>();
3
    private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
4

5
    // 问题版本：可能出现缓存不一致
6
    public String getValue(String key) {
7
        String value = cache.get(key);
8
        if (value == null) {
9
            // 这里可能有多个线程同时执行，造成重复计算
10
            value = expensiveOperation(key);
11
            cache.put(key, value);
12
        }
13
        return value;
14
    }
15

16
    // 解决方案1：使用读写锁
17
    public String getValueWithRWLock(String key) {
18
        // 先尝试读取
19
        rwLock.readLock().lock();
20
        try {
21
            String value = cache.get(key);
22
            if (value != null) {
23
                return value;
24
            }
25
        } finally {
26
            rwLock.readLock().unlock();
27
        }
28

29
        // 需要计算值，获取写锁
30
        rwLock.writeLock().lock();
31
        try {
32
            // 双重检查
33
            String value = cache.get(key);
34
            if (value == null) {
35
                value = expensiveOperation(key);
36
                cache.put(key, value);
37
            }
38
            return value;
39
        } finally {
40
            rwLock.writeLock().unlock();
41
        }
42
    }
43

44
    // 解决方案2：使用putIfAbsent
45
    public String getValueWithPutIfAbsent(String key) {
46
        return cache.computeIfAbsent(key, this::expensiveOperation);
47
    }
48

49
    // 解决方案3：使用Future避免重复计算
50
    private final ConcurrentHashMap<String, Future<String>> futureCache = new ConcurrentHashMap<>();
51

52
    public String getValueWithFuture(String key) throws ExecutionException, InterruptedException {
53
        Future<String> future = futureCache.get(key);
54
        if (future == null) {
55
            Callable<String> callable = () -> expensiveOperation(key);
56
            FutureTask<String> futureTask = new FutureTask<>(callable);
57
            future = futureCache.putIfAbsent(key, futureTask);
58
            if (future == null) {
59
                future = futureTask;
60
                futureTask.run();
61
            }
62
        }
63
        return future.get();
64
    }
65

66
    private String expensiveOperation(String key) {
67
        try {
68
            Thread.sleep(1000);  // 模拟耗时操作
69
            return "Value for " + key;
70
        } catch (InterruptedException e) {
71
            Thread.currentThread().interrupt();
72
            throw new RuntimeException(e);
73
        }
74
    }
75
}

🎯 性能优化最佳实践#

1. 减少锁的粒度#

1
public class LockGranularityExample {
2

3
    // 粗粒度锁 - 不推荐
4
    private final Object lock = new Object();
5
    private int counter1 = 0;
6
    private int counter2 = 0;
7

8
    public void coarseGrainedLock() {
9
        synchronized (lock) {
10
            counter1++;
11
            counter2++;
12
            // 其他不相关的操作也被锁保护
13
        }
14
    }
15

16
    // 细粒度锁 - 推荐
17
    private final Object lock1 = new Object();
18
    private final Object lock2 = new Object();
19

20
    public void fineGrainedLock1() {
21
        synchronized (lock1) {
22
            counter1++;
23
        }
24
    }
25

26
    public void fineGrainedLock2() {
27
        synchronized (lock2) {
28
            counter2++;
29
        }
30
    }
31
}

2. 使用无锁数据结构#

1
public class LockFreeExample {
2

3
    // 无锁队列
4
    private final ConcurrentLinkedQueue<String> lockFreeQueue = new ConcurrentLinkedQueue<>();
5

6
    // 无锁Map
7
    private final ConcurrentHashMap<String, String> lockFreeMap = new ConcurrentHashMap<>();
8

9
    // 无锁计数器
10
    private final AtomicLong lockFreeCounter = new AtomicLong(0);
11

12
    public void lockFreeOperations() {
13
        // 队列操作
14
        lockFreeQueue.offer("item");
15
        String item = lockFreeQueue.poll();
16

17
        // Map操作
18
        lockFreeMap.put("key", "value");
19
        String value = lockFreeMap.get("key");
20

21
        // 计数器操作
22
        long count = lockFreeCounter.incrementAndGet();
23
    }
24
}

3. 合理使用ThreadLocal#

1
public class ThreadLocalExample {
2

3
    // 用于存储用户会话信息
4
    private static final ThreadLocal<UserSession> userSessionThreadLocal = new ThreadLocal<>();
5

6
    // 用于格式化日期（SimpleDateFormat不是线程安全的）
7
    private static final ThreadLocal<SimpleDateFormat> dateFormatThreadLocal =
8
        ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
9

10
    public void setUserSession(UserSession session) {
11
        userSessionThreadLocal.set(session);
12
    }
13

14
    public UserSession getCurrentUser() {
15
        return userSessionThreadLocal.get();
16
    }
17

18
    public String formatDate(Date date) {
19
        return dateFormatThreadLocal.get().format(date);
20
    }
21

22
    // 重要：使用完毕后要清理ThreadLocal
23
    public void cleanup() {
24
        userSessionThreadLocal.remove();
25
        dateFormatThreadLocal.remove();
26
    }
27

28
    static class UserSession {
29
        String userId;
30
        String userName;
31
        // 其他会话信息
32
    }
33
}

🔍 并发调试技巧#

1. 线程转储分析#

1
public class ThreadDumpExample {
2

3
    public static void printThreadDump() {
4
        ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
5
        ThreadInfo[] threadInfos = threadBean.dumpAllThreads(true, true);
6

7
        for (ThreadInfo threadInfo : threadInfos) {
8
            System.out.println("线程名: " + threadInfo.getThreadName());
9
            System.out.println("线程状态: " + threadInfo.getThreadState());
10

11
            if (threadInfo.getLockName() != null) {
12
                System.out.println("等待锁: " + threadInfo.getLockName());
13
            }
14

15
            StackTraceElement[] stackTrace = threadInfo.getStackTrace();
16
            for (StackTraceElement element : stackTrace) {
17
                System.out.println("\t" + element);
18
            }
19
            System.out.println();
20
        }
21
    }
22
}

2. 并发测试工具#

1
public class ConcurrencyTestExample {
2
    private final AtomicInteger counter = new AtomicInteger(0);
3

4
    @Test
5
    public void testConcurrentIncrement() throws InterruptedException {
6
        int threadCount = 100;
7
        int operationsPerThread = 1000;
8
        CountDownLatch latch = new CountDownLatch(threadCount);
9

10
        for (int i = 0; i < threadCount; i++) {
11
            new Thread(() -> {
12
                try {
13
                    for (int j = 0; j < operationsPerThread; j++) {
14
                        counter.incrementAndGet();
15
                    }
16
                } finally {
17
                    latch.countDown();
18
                }
19
            }).start();
20
        }
21

22
        latch.await();
23

24
        // 验证结果
25
        int expected = threadCount * operationsPerThread;
26
        assertEquals(expected, counter.get());
27
    }
28
}

🚀 总结与最佳实践#

并发编程金律#

优先使用并发工具类：ConcurrentHashMap > synchronized HashMap
减少锁的范围：只锁必要的代码块
避免嵌套锁：防止死锁发生
使用不可变对象：天然线程安全
合理使用线程池：避免频繁创建销毁线程

性能优化checklist#

✅ 使用合适的并发工具类
✅ 减少锁的竞争和粒度
✅ 避免不必要的同步
✅ 合理设置线程池参数
✅ 及时释放资源（如ThreadLocal）

常见误区#

❌ 过度使用synchronized
❌ 忽略volatile的非原子性
❌ ThreadLocal内存泄漏
❌ 不合理的线程池配置

💡 记住：并发编程是一门艺术，需要在正确性、性能和复杂度之间找到平衡点。

📖 延伸阅读#

如果这篇文章对你有帮助，欢迎点赞分享！ ⭐

音乐

Pasule Blog!

音乐

Java并发编程深度解析：从理论到实践