# Java并发编程实战：线程安全集合与死锁问题解析

## 引言：多线程环境下的集合安全

在多线程并发环境中，传统的集合类如ArrayList、HashMap等会出现数据不一致、竞争条件等问题。Java并发包提供了多种线程安全的集合类，同时开发者需要警惕死锁等并发陷阱。本文将深入探讨线程安全集合的实现原理、使用场景，并系统分析死锁的产生原因与解决方案。

## 线程安全集合类详解

### 同步包装器与并发容器

```java

import java.util.*;

import java.util.concurrent.*;

public class ThreadSafeCollectionsDemo {

    

    /**

     * 同步包装器：Collections.synchronizedXXX

     * 通过方法级同步实现线程安全

     */

    public static void demonstrateSynchronizedWrappers() {

        System.out.println("=== 同步包装器示例 ===");

        

        // 创建同步List

        List<String> syncList = Collections.synchronizedList(new ArrayList<>());

        

        // 创建同步Map

        Map<String, Integer> syncMap = Collections.synchronizedMap(new HashMap<>());

        

        // 使用示例

        Runnable listTask = () -> {

            for (int i = 0; i < 1000; i++) {

                syncList.add("Item-" + Thread.currentThread().getId() + "-" + i);

            }

        };

        

        Thread t1 = new Thread(listTask);

        Thread t2 = new Thread(listTask);

        

        t1.start();

        t2.start();

        

        try {

            t1.join();

            t2.join();

        } catch (InterruptedException e) {

            Thread.currentThread().interrupt();

        }

        

        System.out.println("同步List大小: " + syncList.size());

        

        // 注意：迭代时需要手动同步

        synchronized(syncList) {

            Iterator<String> it = syncList.iterator();

            while (it.hasNext()) {

                it.next();

                // 迭代操作

            }

        }

    }

    

    /**

     * ConcurrentHashMap：分段锁实现的高并发Map

     */

    public static void demonstrateConcurrentHashMap() {

        System.out.println("\n=== ConcurrentHashMap示例 ===");

        

        ConcurrentHashMap<String, Integer> concurrentMap = new ConcurrentHashMap<>();

        

        // 并发put操作

        Runnable mapTask = () -> {

            for (int i = 0; i < 1000; i++) {

                String key = "Key-" + Thread.currentThread().getId() + "-" + i;

                concurrentMap.put(key, i);

                

                // 使用原子操作方法

                concurrentMap.computeIfAbsent("counter", k -> 0);

                concurrentMap.compute("counter", (k, v) -> v + 1);

            }

        };

        

        Thread t1 = new Thread(mapTask);

        Thread t2 = new Thread(mapTask);

        

        t1.start();

        t2.start();

        

        try {

            t1.join();

            t2.join();

        } catch (InterruptedException e) {

            Thread.currentThread().interrupt();

        }

        

        System.out.println("ConcurrentHashMap大小: " + concurrentMap.size());

        System.out.println("counter值: " + concurrentMap.get("counter"));

        

        // 遍历操作（弱一致性）

        System.out.println("\n遍历ConcurrentHashMap:");

        concurrentMap.forEach((k, v) -> {

            if (k.startsWith("Key-")) {

                // 遍历操作

            }

        });

    }

    

    /**

     * CopyOnWriteArrayList：写时复制List

     * 适合读多写少的场景

     */

    public static void demonstrateCopyOnWriteArrayList() {

        System.out.println("\n=== CopyOnWriteArrayList示例 ===");

        

        CopyOnWriteArrayList<String> copyOnWriteList = new CopyOnWriteArrayList<>();

        

        // 初始化数据

        copyOnWriteList.add("A");

        copyOnWriteList.add("B");

        copyOnWriteList.add("C");

        

        // 并发读写测试

        Runnable reader = () -> {

            // 读操作不需要同步

            for (String item : copyOnWriteList) {

                System.out.println(Thread.currentThread().getName() + " 读取: " + item);

                try {

                    Thread.sleep(10);

                } catch (InterruptedException e) {

                    Thread.currentThread().interrupt();

                }

            }

        };

        

        Runnable writer = () -> {

            // 写操作会复制新数组

            copyOnWriteList.add("D-" + Thread.currentThread().getId());

            System.out.println(Thread.currentThread().getName() + " 写入新元素");

        };

        

        Thread reader1 = new Thread(reader, "Reader-1");

        Thread reader2 = new Thread(reader, "Reader-2");

        Thread writer1 = new Thread(writer, "Writer-1");

        

        reader1.start();

        reader2.start();

        writer1.start();

        

        try {

            reader1.join();

            reader2.join();

            writer1.join();

        } catch (InterruptedException e) {

            Thread.currentThread().interrupt();

        }

        

        System.out.println("最终List内容: " + copyOnWriteList);

    }

    

    /**

     * BlockingQueue：阻塞队列实现

     */

    public static void demonstrateBlockingQueue() {

        System.out.println("\n=== BlockingQueue示例 ===");

        

        BlockingQueue<String> queue = new ArrayBlockingQueue<>(10);

        

        // 生产者

        Runnable producer = () -> {

            try {

                for (int i = 0; i < 5; i++) {

                    String item = "Item-" + Thread.currentThread().getId() + "-" + i;

                    queue.put(item); // 队列满时阻塞

                    System.out.println(Thread.currentThread().getName() 

                        + " 生产: " + item);

                    Thread.sleep(100);

                }

            } catch (InterruptedException e) {

                Thread.currentThread().interrupt();

            }

        };

        

        // 消费者

        Runnable consumer = () -> {

            try {

                for (int i = 0; i < 5; i++) {

                    String item = queue.take(); // 队列空时阻塞

                    System.out.println(Thread.currentThread().getName() 

                        + " 消费: " + item);

                    Thread.sleep(150);

                }

            } catch (InterruptedException e) {

                Thread.currentThread().interrupt();

            }

        };

        

        Thread producer1 = new Thread(producer, "Producer-1");

        Thread producer2 = new Thread(producer, "Producer-2");

        Thread consumer1 = new Thread(consumer, "Consumer-1");

        

        producer1.start();

        producer2.start();

        consumer1.start();

        

        try {

            producer1.join();

            producer2.join();

            consumer1.join();

        } catch (InterruptedException e) {

            Thread.currentThread().interrupt();

        }

    }

}

// 运行线程安全集合示例

ThreadSafeCollectionsDemo.demonstrateSynchronizedWrappers();

ThreadSafeCollectionsDemo.demonstrateConcurrentHashMap();

ThreadSafeCollectionsDemo.demonstrateCopyOnWriteArrayList();

ThreadSafeCollectionsDemo.demonstrateBlockingQueue();

```

## 死锁问题深度分析

### 死锁产生原理与必要条件

```java

// 死锁示例与分析

public class DeadlockAnalysis {

    

    /**

     * 经典死锁示例：资源竞争死锁

     */

    public static void demonstrateClassicDeadlock() {

        System.out.println("=== 经典死锁示例 ===");

        

        final Object resourceA = new Object();

        final Object resourceB = new Object();

        

        Thread thread1 = new Thread(() -> {

            synchronized (resourceA) {

                System.out.println("线程1 获取 resourceA");

                try {

                    Thread.sleep(100); // 模拟处理时间

                } catch (InterruptedException e) {

                    Thread.currentThread().interrupt();

                }

                

                System.out.println("线程1 尝试获取 resourceB");

                synchronized (resourceB) {

                    System.out.println("线程1 获取 resourceB");

                }

            }

        });

        

        Thread thread2 = new Thread(() -> {

            synchronized (resourceB) {

                System.out.println("线程2 获取 resourceB");

                try {

                    Thread.sleep(100); // 模拟处理时间

                } catch (InterruptedException e) {

                    Thread.currentThread().interrupt();

                }

                

                System.out.println("线程2 尝试获取 resourceA");

                synchronized (resourceA) {

                    System.out.println("线程2 获取 resourceA");

                }

            }

        });

        

        thread1.start();

        thread2.start();

        

        // 等待一段时间后检查死锁

        try {

            Thread.sleep(2000);

        } catch (InterruptedException e) {

            Thread.currentThread().interrupt();

        }

        

        // 检查线程状态

        System.out.println("\n线程1状态: " + thread1.getState());

        System.out.println("线程2状态: " + thread2.getState());

        

        if (thread1.getState() == Thread.State.BLOCKED && 

            thread2.getState() == Thread.State.BLOCKED) {

            System.out.println("⚠️ 检测到死锁！");

        }

    }

    

    /**

     * 死锁产生的必要条件分析

     */

    public static void analyzeDeadlockConditions() {

        System.out.println("\n=== 死锁产生的四个必要条件 ===");

        

        System.out.println("1. 互斥条件 (Mutual Exclusion):");

        System.out.println("   资源一次只能被一个线程占用");

        System.out.println("   示例: synchronized关键字创建互斥锁");

        

        System.out.println("\n2. 持有并等待 (Hold and Wait):");

        System.out.println("   线程持有资源并等待其他资源");

        System.out.println("   示例: 线程1持有A，等待B；线程2持有B，等待A");

        

        System.out.println("\n3. 不可抢占 (No Preemption):");

        System.out.println("   资源不能被强制从持有者那里抢占");

        System.out.println("   示例: synchronized锁不能强制释放");

        

        System.out.println("\n4. 循环等待 (Circular Wait):");

        System.out.println("   存在一个循环等待资源链");

        System.out.println("   示例: T1等待T2的资源，T2等待T1的资源");

        

        System.out.println("\n预防死锁：破坏任意一个条件即可");

    }

    

    /**

     * 数据库死锁示例

     */

    public static void demonstrateDatabaseDeadlock() {

        System.out.println("\n=== 数据库死锁示例 ===");

        

        // 模拟数据库连接

        class DatabaseResource {

            private final String name;

            

            DatabaseResource(String name) {

                this.name = name;

            }

            

            public void update() {

                System.out.println(Thread.currentThread().getName() 

                    + " 更新资源: " + name);

            }

        }

        

        DatabaseResource accountA = new DatabaseResource("账户A");

        DatabaseResource accountB = new DatabaseResource("账户B");

        

        // 事务1：A向B转账

        Thread transaction1 = new Thread(() -> {

            synchronized (accountA) {

                System.out.println("事务1 锁定账户A");

                try {

                    Thread.sleep(100);

                } catch (InterruptedException e) {

                    Thread.currentThread().interrupt();

                }

                

                synchronized (accountB) {

                    System.out.println("事务1 锁定账户B");

                    accountA.update();

                    accountB.update();

                    System.out.println("事务1 完成转账");

                }

            }

        }, "转账事务1");

        

        // 事务2：B向A转账

        Thread transaction2 = new Thread(() -> {

            synchronized (accountB) {

                System.out.println("事务2 锁定账户B");

                try {

                    Thread.sleep(100);

                } catch (InterruptedException e) {

                    Thread.currentThread().interrupt();

                }

                

                synchronized (accountA) {

                    System.out.println("事务2 锁定账户A");

                    accountB.update();

                    accountA.update();

                    System.out.println("事务2 完成转账");

                }

            }

        }, "转账事务2");

        <"d2.p5k3.org.cn"><"h5.p5k3.org.cn"><"v1.p5k3.org.cn">

        transaction1.start();

        transaction2.start();

        

        // 监控线程状态

        new Thread(() -> {

            try {

                Thread.sleep(500);

                System.out.println("\n事务1状态: " + transaction1.getState());

                System.out.println("事务2状态: " + transaction2.getState());

                

                if (transaction1.isAlive() && transaction2.isAlive() &&

                    transaction1.getState() == Thread.State.BLOCKED &&

                    transaction2.getState() == Thread.State.BLOCKED) {

                    System.out.println("⚠️ 数据库事务死锁检测！");

                }

            } catch (InterruptedException e) {

                Thread.currentThread().interrupt();

            }

        }).start();

    }

}

// 运行死锁分析示例

DeadlockAnalysis.demonstrateClassicDeadlock();

DeadlockAnalysis.analyzeDeadlockConditions();

DeadlockAnalysis.demonstrateDatabaseDeadlock();

```

## 死锁预防与解决策略

### 资源排序法

```java

// 死锁预防策略实现

public class DeadlockPrevention {

    

    /**

     * 资源排序法：统一资源获取顺序

     */

    public static void demonstrateResourceOrdering() {

        System.out.println("\n=== 资源排序法预防死锁 ===");

        

        final Object resourceA = new Object();

        final Object resourceB = new Object();

        final Object resourceC = new Object();

        

        // 定义资源获取顺序

        List<Object> resourceOrder = Arrays.asList(resourceA, resourceB, resourceC);

        

        Runnable task1 = () -> {

            // 按照统一顺序获取资源

            synchronized (resourceOrder.get(0)) { // resourceA

                System.out.println("任务1 获取资源A");

                synchronized (resourceOrder.get(1)) { // resourceB

                    System.out.println("任务1 获取资源B");

                    // 业务处理

                    try {

                        Thread.sleep(100);

                    } catch (InterruptedException e) {

                        Thread.currentThread().interrupt();

                    }

                }

            }

        };

        

        Runnable task2 = () -> {

            // 同样按照统一顺序获取资源

            synchronized (resourceOrder.get(0)) { // resourceA

                System.out.println("任务2 获取资源A");

                synchronized (resourceOrder.get(2)) { // resourceC

                    System.out.println("任务2 获取资源C");

                    // 业务处理

                    try {

                        Thread.sleep(100);

                    } catch (InterruptedException e) {

                        Thread.currentThread().interrupt();

                    }

                }

            }

        };

        

        Thread thread1 = new Thread(task1, "Task-1");

        Thread thread2 = new Thread(task2, "Task-2");

        

        thread1.start();

        thread2.start();

        

        try {

            thread1.join();

            thread2.join();

        } catch (InterruptedException e) {

            Thread.currentThread().interrupt();

        }

        

        System.out.println("✅ 资源排序法成功避免死锁");

    }

    

    /**

     * 超时机制预防死锁

     */

    public static void demonstrateTimeoutMechanism() {

        System.out.println("\n=== 超时机制预防死锁 ===");

        

        final Object resource1 = new Object();

        final Object resource2 = new Object();

        

        Runnable task = () -> {

            boolean acquiredBoth = false;

            

            while (!acquiredBoth) {

                // 尝试获取第一个资源（带超时）

                synchronized (resource1) {

                    System.out.println(Thread.currentThread().getName() 

                        + " 获取资源1");

                    

                    // 尝试获取第二个资源，设置超时

                    long startTime = System.currentTimeMillis();

                    long timeout = 500; // 500毫秒超时

                    

                    while (System.currentTimeMillis() - startTime < timeout) {

                        synchronized (resource2) {

                            System.out.println(Thread.currentThread().getName() 

                                + " 获取资源2");

                            acquiredBoth = true;

                            

                            // 执行业务逻辑

                            try {

                                Thread.sleep(200);

                            } catch (InterruptedException e) {

                                Thread.currentThread().interrupt();

                            }

                            break;

                        }

                        

                        if (!acquiredBoth) {

                            try {

                                Thread.sleep(50); // 重试间隔

                            } catch (InterruptedException e) {

                                Thread.currentThread().interrupt();

                            }

                        }

                    }

                    

                    if (!acquiredBoth) {

                        System.out.println(Thread.currentThread().getName() 

                            + " 获取资源2超时，释放资源1并重试");

                        // 会自动释放resource1的锁

                        try {

                            Thread.sleep(100); // 避免活锁

                        } catch (InterruptedException e) {

                            Thread.currentThread().interrupt();

                        }

                    }

                }

            }

        };

        

        Thread thread1 = new Thread(task, "Thread-1");

        Thread thread2 = new Thread(task, "Thread-2");

        

        thread1.start();

        thread2.start();

        

        try {

            thread1.join();

            thread2.join();

        } catch (InterruptedException e) {

            Thread.currentThread().interrupt();

        }

        

        System.out.println("✅ 超时机制成功避免死锁");

    }

    

    /**

     * 使用Lock接口的tryLock方法

     */

    public static void demonstrateTryLock() {

        System.out.println("\n=== 使用Lock.tryLock预防死锁 ===");

        

        import java.util.concurrent.locks.Lock;

        import java.util.concurrent.locks.ReentrantLock;

        

        Lock lockA = new ReentrantLock();

        Lock lockB = new ReentrantLock();

        

        Runnable task = () -> {

            boolean acquiredA = false;

            boolean acquiredB = false;

            

            try {

                while (true) {

                    // 尝试获取锁A

                    acquiredA = lockA.tryLock(100, TimeUnit.MILLISECONDS);

                    if (acquiredA) {

                        System.out.println(Thread.currentThread().getName() 

                            + " 获取锁A");

                        

                        // 尝试获取锁B

                        acquiredB = lockB.tryLock(100, TimeUnit.MILLISECONDS);

                        if (acquiredB) {

                            System.out.println(Thread.currentThread().getName() 

                                + " 获取锁B");

                            

                            // 执行业务逻辑

                            try {

                                Thread.sleep(200);

                            } catch (InterruptedException e) {

                                Thread.currentThread().interrupt();

                            }

                            break;

                        } else {

                            // 获取B失败，释放A

                            lockA.unlock();

                            acquiredA = false;

                            System.out.println(Thread.currentThread().getName() 

                                + " 获取锁B失败，释放锁A");

                        }

                    }

                    

                    // 等待后重试

                    try {

                        Thread.sleep(50);

                    } catch (InterruptedException e) {

                        Thread.currentThread().interrupt();

                    }

                }

            } catch (InterruptedException e) {

                Thread.currentThread().interrupt();

            } finally {

                // 确保释放锁

                if (acquiredB) {

                    lockB.unlock();

                }

                if (acquiredA) {

                    lockA.unlock();

                }

                System.out.println(Thread.currentThread().getName() 

                    + " 释放所有锁");

            }

        };

        

        Thread thread1 = new Thread(task, "Thread-1");

        Thread thread2 = new Thread(task, "Thread-2");

        

        thread1.start();

        thread2.start();

        

        try {

            thread1.join();

            thread2.join();

        } catch (InterruptedException e) {

            Thread.currentThread().interrupt();

        }

        

        System.out.println("✅ Lock.tryLock成功避免死锁");

    }

}

// 运行死锁预防示例

DeadlockPrevention.demonstrateResourceOrdering();

DeadlockPrevention.demonstrateTimeoutMechanism();

DeadlockPrevention.demonstrateTryLock();

```

## 死锁检测与诊断工具

### Java死锁检测实践

```java

// 死锁检测与诊断

import java.lang.management.*;

import javax.management.*;

public class DeadlockDetection {

    

    /**

     * 使用ThreadMXBean检测死锁

     */

    public static void detectDeadlock() {

        System.out.println("=== 死锁检测工具使用 ===");

        

        // 创建死锁场景

        final Object lock1 = new Object();

        final Object lock2 = new Object();

        

        Thread thread1 = new Thread(() -> {

            synchronized (lock1) {

                try {

                    Thread.sleep(100);

                } catch (InterruptedException e) {

                    Thread.currentThread().interrupt();

                }

                synchronized (lock2) {

                    System.out.println("线程1完成");

                }

            }

        });

        

        Thread thread2 = new Thread(() -> {

            synchronized (lock2) {

                try {

                    Thread.sleep(100);

                } catch (InterruptedException e) {

                    Thread.currentThread().interrupt();

                }

                synchronized (lock1) {

                    System.out.println("线程2完成");

                }

            }

        });

        

        thread1.start();

        thread2.start();

        

        // 等待死锁发生

        try {

            Thread.sleep(200);

        } catch (InterruptedException e) {

            Thread.currentThread().interrupt();

        }

        

        // 检测死锁

        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();

        long[] deadlockedThreads = threadMXBean.findDeadlockedThreads();

        

        if (deadlockedThreads != null && deadlockedThreads.length > 0) {

            System.out.println("\n⚠️ 检测到死锁线程:");

            

            for (long threadId : deadlockedThreads) {

                ThreadInfo threadInfo = threadMXBean.getThreadInfo(threadId);

                System.out.println("死锁线程: " + threadInfo.getThreadName());

                

                // 获取锁信息

                LockInfo[] lockInfos = threadInfo.getLockedSynchronizers();

                if (lockInfos != null) {

                    for (LockInfo lockInfo : lockInfos) {

                        System.out.println("  持有锁: " + lockInfo.getClassName());

                    }

                }

                

                // 获取等待锁信息

                LockInfo lockInfo = threadInfo.getLockInfo();

                if (lockInfo != null) {

                    System.out.println("  等待锁: " + lockInfo.getClassName());

                }

                

                // 打印堆栈信息

                System.out.println("  堆栈跟踪:");

                for (StackTraceElement element : threadInfo.getStackTrace()) {

                    System.out.println("    " + element);

                }

            }

        } else {

            System.out.println("未检测到死锁");

        }

        

        // 中断线程以解除死锁

        thread1.interrupt();

        thread2.interrupt();

    }

    

    /**

     * 线程转储分析

     */

    public static void analyzeThreadDump() {

        System.out.println("\n=== 线程转储分析 ===");

        

        // 生成线程转储的几种方式

        

        System.out.println("1. 使用jstack命令:");

        System.out.println("   jstack <pid> > thread_dump.txt");

        

        System.out.println("\n2. 使用ThreadMXBean获取线程信息:");

        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();

        

        // 获取所有线程ID

        long[] threadIds = threadMXBean.getAllThreadIds();

        System.out.println("   活动线程数: " + threadIds.length);

        

        // 获取线程信息

        ThreadInfo[] threadInfos = threadMXBean.getThreadInfo(threadIds);

        for (ThreadInfo info : threadInfos) {

            if (info != null) {

                System.out.println("\n   线程: " + info.getThreadName());

                System.out.println("   状态: " + info.getThreadState());

                

                if (info.getLockInfo() != null) {

                    System.out.println("   等待锁: " + info.getLockInfo().getClassName());

                }

            }

        }

        

        System.out.println("\n3. 死锁预防建议:");

        System.out.println("   - 使用资源排序");

        System.out.println("   - 设置锁超时时间");

        System.out.println("   - 使用tryLock替代synchronized");

        System.out.println("   - 避免嵌套锁");

        System.out.println("   - 使用线程安全的集合类");

    }<"s8.p5k3.org.cn"><"f0.p5k3.org.cn"><"z4.p5k3.org.cn">

    

    /**

     * 监控线程状态

     */

    public static class ThreadMonitor {

        private final ScheduledExecutorService scheduler = 

            Executors.newScheduledThreadPool(1);

        

        public void startMonitoring() {

            System.out.println("\n=== 启动线程监控 ===");

            

            scheduler.scheduleAtFixedRate(() -> {

                ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();

                long[] deadlockedThreads = threadMXBean.findDeadlockedThreads();

                

                if (deadlockedThreads != null) {

                    System.out.println("监控告警: 检测到" + deadlockedThreads.length + "个死锁线程");

                    // 发送告警、记录日志等

                }

                

                // 监控线程数

                int threadCount = threadMXBean.getThreadCount();

                System.out.println("当前线程数: " + threadCount);

                

            }, 0, 5, TimeUnit.SECONDS); // 每5秒监控一次

        }

        

        public void stopMonitoring() {

            scheduler.shutdown();

        }

    }

}

// 运行死锁检测示例

DeadlockDetection.detectDeadlock();

DeadlockDetection.analyzeThreadDump();

```

## 最佳实践与性能考量

### 线程安全集合的选择策略

```java

// 线程安全集合性能对比与选择

public class CollectionPerformanceComparison {

    

    /**

     * 不同线程安全集合的性能对比

     */

    public static void comparePerformance() {

        System.out.println("=== 线程安全集合性能对比 ===");

        

        int iterations = 100000;

        int threadCount = 10;

        

        // 测试不同集合的并发写入性能

        System.out.println("\n并发写入性能测试 (" + iterations + "次迭代):");

        

        // ConcurrentHashMap

        testCollectionPerformance(

            "ConcurrentHashMap", 

            new ConcurrentHashMap<Integer, String>(),

            iterations, 

            threadCount

        );

        

        // Collections.synchronizedMap

        testCollectionPerformance(

            "synchronizedMap", 

            Collections.synchronizedMap(new HashMap<Integer, String>()),

            iterations, 

            threadCount

        );

        

        // Hashtable

        testCollectionPerformance(

            "Hashtable", 

            new Hashtable<Integer, String>(),

            iterations, 

            threadCount

        );

        

        System.out.println("\n⚠️ 性能选择建议:");

        System.out.println("1. 高并发写入: 优先选择ConcurrentHashMap");

        System.out.println("2. 读多写少: 考虑CopyOnWriteArrayList");

        System.out.println("3. 生产者消费者: 使用BlockingQueue");

        System.out.println("4. 简单同步: Collections.synchronizedXXX");

        System.out.println("5. 排序需求: ConcurrentSkipListMap/Set");

    }

    

    private static void testCollectionPerformance(

            String name, 

            Map<Integer, String> map, 

            int iterations, 

            int threadCount) {

        

        long startTime = System.currentTimeMillis();

        

        ExecutorService executor = Executors.newFixedThreadPool(threadCount);

        List<Future<?>> futures = new ArrayList<>();

        

        for (int i = 0; i < threadCount; i++) {

            final int threadId = i;

            Future<?> future = executor.submit(() -> {

                for (int j = 0; j < iterations; j++) {

                    int key = threadId * iterations + j;

                    map.put(key, "Value-" + key);

                    map.get(key);

                }

            });

            futures.add(future);

        }

        

        // 等待所有任务完成

        for (Future<?> future : futures) {

            try {

                future.get();

            } catch (Exception e) {

                e.printStackTrace();

            }

        }

        

        executor.shutdown();

        

        long endTime = System.currentTimeMillis();

        System.out.printf("  %-20s: %d ms%n", name, (endTime - startTime));

    }

    

    /**

     * 内存一致性保证

     */

    public static void demonstrateMemoryConsistency() {

        System.out.println("\n=== 内存一致性保证 ===");

        

        // volatile变量

        class SharedData {

            private volatile int counter = 0;

            private final AtomicInteger atomicCounter = new AtomicInteger(0);

            

            public void increment() {

                counter++; // 非原子操作，即使volatile也不能保证线程安全

                atomicCounter.incrementAndGet(); // 原子操作

            }

            

            public int getCounter() {

                return counter;

            }

            

            public int getAtomicCounter() {

                return atomicCounter.get();

            }

        }

        

        SharedData data = new SharedData();

        <"j6.p5k3.org.cn"><"n3.p5k3.org.cn"><"w7.p5k3.org.cn">

        // 多个线程同时修改

        ExecutorService executor = Executors.newFixedThreadPool(5);

        for (int i = 0; i < 1000; i++) {

            executor.execute(data::increment);

        }

        

        executor.shutdown();

        try {

            executor.awaitTermination(1, TimeUnit.SECONDS);

        } catch (InterruptedException e) {

            Thread.currentThread().interrupt();

        }

        

        System.out.println("volatile counter结果: " + data.getCounter());

        System.out.println("AtomicInteger结果: " + data.getAtomicCounter());

        System.out.println("说明: volatile不能保证复合操作的原子性");

    }

    

    /**

     * 使用场景总结

     */

    public static void summarizeUseCases() {

        System.out.println("\n=== 线程安全集合使用场景总结 ===");

        

        System.out.println("1. ConcurrentHashMap:");

        System.out.println("   - 高并发键值存储");

        System.out.println("   - 需要分段锁的高性能场景");

        System.out.println("   - 支持原子操作的并发更新");

        

        System.out.println("\n2. CopyOnWriteArrayList:");

        System.out.println("   - 监听器列表");

        System.out.println("   - 读多写少的配置数据");

        System.out.println("   - 迭代期间不允许修改的场景");

        

        System.out.println("\n3. BlockingQueue:");

        System.out.println("   - 生产者消费者模式");

        System.out.println("   - 任务队列");

        System.out.println("   - 线程池工作队列");

        

        System.out.println("\n4. ConcurrentLinkedQueue:");

        System.out.println("   - 无界非阻塞队列");

        System.out.println("   - 高并发消息队列");

        System.out.println("   - 不需要阻塞操作的场景");

        

        System.out.println("\n5. Collections.synchronizedXXX:");

        System.out.println("   - 简单的同步需求");

        System.out.println("   - 代码遗留系统维护");

        System.out.println("   - 需要与现有API兼容");

    }

}

// 运行性能对比与最佳实践

CollectionPerformanceComparison.comparePerformance();

CollectionPerformanceComparison.demonstrateMemoryConsistency();

CollectionPerformanceComparison.summarizeUseCases();

```

## 总结：并发编程的安全之道

1. **线程安全集合选择原则**：

   - 根据读写比例选择合适的数据结构

   - 考虑并发级别和性能要求

   - 注意迭代器的弱一致性特性

2. **死锁预防核心策略**：

   - 统一资源获取顺序（破坏循环等待）

   - 使用超时机制（避免无限等待）

   - 减少锁的持有时间

   - 避免嵌套锁

3. **监控与诊断**：

   - 定期使用ThreadMXBean检测死锁

   - 分析线程转储定位问题

   - 建立线程状态监控机制

4. **最佳实践**：

   - 优先使用并发包中的线程安全集合

   - 合理设置集合初始容量

   - 理解不同集合的内存一致性保证

   - 在适当场景使用原子变量替代锁

通过深入理解线程安全集合的实现原理和死锁的产生机制，开发者能够编写出既安全又高效的多线程程序。记住，并发编程的核心是在保证正确性的前提下追求性能，任何性能优化都不能以牺牲正确性为代价。