java多线程中易犯的错误是什么

发布时间：2022-01-06 15:23:05 作者：iii
来源：亿速云阅读：116

# Java多线程中易犯的错误是什么

## 引言

在当今高并发的软件开发环境中，多线程编程已成为Java开发者必须掌握的核心技能。然而，多线程编程的复杂性也带来了诸多陷阱和误区。本文将深入探讨Java多线程开发中常见的错误模式，分析其产生原因，并提供经过实践验证的解决方案，帮助开发者构建更健壮、高效的并发应用程序。

## 一、线程安全基础认知错误

### 1.1 对线程安全的误解

许多开发者错误地认为只要代码能够编译通过并运行，就是线程安全的。实际上，线程安全是指当多个线程访问某个类时，这个类始终能表现出正确的行为，而不需要额外的同步或协调。

**典型错误示例：**
```java
public class UnsafeCounter {
    private int count = 0;
    
    public void increment() {
        count++;  // 非原子操作
    }
    
    public int getCount() {
        return count;
    }
}

1.2 可见性问题忽视

public class VisibilityIssue {
    private boolean flag = true;  // 未使用volatile
    
    public void toggle() {
        flag = !flag;
    }
    
    public void worker() {
        while (flag) {
            // 可能永远循环
        }
    }
}

解决方案： - 使用volatile关键字保证可见性 - 或使用synchronized方法/块

二、同步机制使用不当

2.1 同步范围不足

public class PartialSync {
    private List<String> list = new ArrayList<>();
    
    public void addIfAbsent(String item) {
        if (!list.contains(item)) {  // 非原子操作
            list.add(item);
        }
    }
}

正确做法：

public synchronized void addIfAbsent(String item) {
    if (!list.contains(item)) {
        list.add(item);
    }
}

2.2 锁对象选择错误

public class WrongLock {
    private final Integer lock = 1;  // Integer是不可变对象
    
    public void doWork() {
        synchronized(lock) {
            // ...
        }
    }
}

问题分析： - 使用基本类型包装类作为锁对象 - 字符串字面量作为锁的风险

2.3 死锁场景

// 典型死锁示例
public class DeadlockDemo {
    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) {
                // ...
            }
        }
    }
}

预防策略： 1. 固定锁获取顺序 2. 使用tryLock()带超时机制 3. 静态分析工具检测

三、线程池使用误区

3.1 不合理配置参数

参数	常见错误	推荐策略
corePoolSize	设置过大导致资源浪费	根据CPU核心数调整
maxPoolSize	设置过小导致任务拒绝	考虑I/O密集型特性
workQueue	使用无界队列导致OOM	根据业务需求选择合适队列

3.2 未处理拒绝策略

ExecutorService executor = new ThreadPoolExecutor(
    4, 8, 60, TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(100),
    // 缺少RejectedExecutionHandler
);

推荐方案：

ExecutorService executor = new ThreadPoolExecutor(
    4, 8, 60, TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(100),
    new ThreadPoolExecutor.CallerRunsPolicy()
);

3.3 线程泄露问题

ExecutorService executor = Executors.newFixedThreadPool(4);
try {
    Future<?> future = executor.submit(() -> {
        while (true) { /* 长时间任务 */ }
    });
    future.get(1, TimeUnit.SECONDS);  // 超时后未取消任务
} catch (TimeoutException e) {
    // 忘记调用future.cancel(true)
}

四、原子类和CAS误用

4.1 ABA问题

AtomicReference<String> ref = new AtomicReference<>("A");
// 线程1准备将A->C
// 线程2先将A->B，再B->A
ref.compareAndSet("A", "C");  // 仍然会成功

解决方案： - 使用AtomicStampedReference - 或AtomicMarkableReference

4.2 复合操作问题

public class AtomicMisuse {
    private AtomicInteger a = new AtomicInteger(0);
    private AtomicInteger b = new AtomicInteger(0);
    
    public void update() {
        // 非原子操作
        a.incrementAndGet();
        b.decrementAndGet();
    }
}

正确方案：

public synchronized void update() {
    a.incrementAndGet();
    b.decrementAndGet();
}

五、并发集合使用陷阱

5.1 误认为完全线程安全

ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
if (!map.containsKey("key")) {  // 非原子检查
    map.put("key", 1);          // 可能被其他线程插入
}

推荐方案：

map.putIfAbsent("key", 1);

5.2 迭代器弱一致性误解

ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<>();
// 添加元素...
for (String s : queue) {
    // 迭代过程中可能看不到最新修改
    queue.remove(s);  // 可能抛出ConcurrentModificationException
}

六、内存模型相关错误

6.1 指令重排序问题

public class Singleton {
    private static Singleton instance;
    
    public static Singleton getInstance() {
        if (instance == null) {               // 第一次检查
            synchronized (Singleton.class) {
                if (instance == null) {       // 第二次检查
                    instance = new Singleton(); // 可能发生重排序
                }
            }
        }
        return instance;
    }
}

正确实现（DCL模式）：

private volatile static Singleton instance;

6.2 happens-before关系忽视

public class PublicationIssue {
    private Resource resource;
    
    public void init() {
        resource = new Resource();  // 可能未正确发布
    }
    
    public void use() {
        if (resource != null) {
            resource.doSomething();  // 可能看到未初始化完成的对象
        }
    }
}

七、线程生命周期管理

7.1 未处理中断异常

public void run() {
    while (true) {
        try {
            Thread.sleep(1000);
            // 工作代码
        } catch (InterruptedException e) {
            // 仅记录日志，未恢复中断状态
            logger.error("Interrupted", e);
        }
    }
}