JAVA多线程编程中的那些“坑”与“避坑指南”

在这个数字化飞速发展的时代，多线程编程已经成为Java开发者不可或缺的技能之一。它就像是程序员手中的魔法工具，能让程序在多个任务之间高效切换，极大地提升性能。但就像任何强大的魔法都有它的代价，多线程编程也有不少“坑”，稍有不慎就可能让你的程序陷入混乱甚至崩溃。今天，我们就来聊聊这些“坑”，以及如何优雅地避开它们。

一、资源竞争：共享数据的战争

想象一下，你正在厨房里准备晚餐，而两个孩子都想从同一个碗里拿勺子。如果他们都不注意协调，可能会发生“勺子争夺战”，最终谁都吃不到饭。同样的事情也可能发生在多线程编程中。

坑1：竞态条件

案例重现
假设我们有一个计数器变量count，两个线程同时执行count++操作。理论上应该增加两次，但实际情况可能是增加了一次或者根本没有变化。

public class Counter {
    private int count = 0;

    public void increment() {
        count++;
    }
}

解决之道：加锁

Java提供了synchronized关键字来解决这个问题。通过加锁，我们可以确保同一时间只有一个线程能够访问共享资源。

public synchronized void increment() {
    count++;
}

或者使用ReentrantLock类来实现更细粒度的锁定机制。

private final Lock lock = new ReentrantLock();

public void increment() {
    lock.lock();
    try {
        count++;
    } finally {
        lock.unlock();
    }
}

二、死锁：程序的“睡美人之吻”

再回到厨房的例子，这次不是勺子的问题，而是两个孩子各自拿着一把刀和叉子，谁也不愿意先放下自己的餐具去拿对方的。这种情况下，所有人都只能在那里干等着。

坑2：死锁

当两个或多个线程都在等待对方释放资源时，就会发生死锁。比如：

public class DeadlockExample {
    private static final Object resourceA = new Object();
    private static final Object resourceB = new Object();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (resourceA) {
                System.out.println("Thread 1: locked resource A");
                try { Thread.sleep(100); } catch (InterruptedException e) {}
                synchronized (resourceB) {
                    System.out.println("Thread 1: locked resource B");
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (resourceB) {
                System.out.println("Thread 2: locked resource B");
                try { Thread.sleep(100); } catch (InterruptedException e) {}
                synchronized (resourceA) {
                    System.out.println("Thread 2: locked resource A");
                }
            }
        });

        thread1.start();
        thread2.start();
    }
}

解决之道：避免循环依赖

尽量减少资源锁定的范围和顺序，确保所有线程都按照相同的顺序获取锁。

public static void main(String[] args) {
    Thread thread1 = new Thread(() -> {
        synchronized (resourceA) {
            System.out.println("Thread 1: locked resource A");
            try { Thread.sleep(100); } catch (InterruptedException e) {}
            synchronized (resourceB) {
                System.out.println("Thread 1: locked resource B");
            }
        }
    });

    Thread thread2 = new Thread(() -> {
        synchronized (resourceA) { // 和thread1保持一致
            System.out.println("Thread 2: locked resource A");
            try { Thread.sleep(100); } catch (InterruptedException e) {}
            synchronized (resourceB) {
                System.out.println("Thread 2: locked resource B");
            }
        }
    });

    thread1.start();
    thread2.start();
}

三、线程安全集合：避免“数据泄露”

有时候，你以为已经安全了，但线程安全的背后可能还藏着小秘密。

坑3：非线程安全集合的假象

Java中的某些集合类，默认情况下并不是线程安全的。比如ArrayList，如果你在一个多线程环境中共享这个列表，可能会导致意想不到的结果。

List<String> list = new ArrayList<>();
// 多线程并发操作list

解决之道：使用线程安全的集合

Java提供了
Collections.synchronizedList()方法来创建线程安全的集合，或者直接使用CopyOnWriteArrayList等专门设计用于多线程环境的集合。

List<String> safeList = Collections.synchronizedList(new ArrayList<>());
// 或者
List<String> copyList = new CopyOnWriteArrayList<>();

四、线程池管理：别让池塘变成“垃圾场”

线程池是多线程编程中的重要工具，它可以帮助我们复用线程，避免频繁创建和销毁线程带来的开销。但如果管理不当，线程池也可能成为“垃 圾场”。

坑4：线程池配置不当

常见的错误包括设置核心线程数过大、最大线程数过小，或者是队列容量设置不合理，导致任务堆积或者线程耗尽。

解决之道：合理配置线程池

根据业务需求选择合适的线程池类型（如FixedThreadPool、CachedThreadPool等），并合理设置参数。

ExecutorService executor = Executors.newFixedThreadPool(10);

此外，定期监控线程池的状态，及时调整配置，确保其健康运行。

五、异常处理：不让程序“掉线”

最后一个“坑”就是异常处理不当，这会让我们的多线程程序像断了线的风筝一样失控。

坑5：未捕获的异常

线程内部抛出的异常如果没有被捕获，会导致线程突然终止，影响整个应用程序的稳定性。

解决之道：使用线程池中的异常处理器

可以通过自定义ThreadFactory来捕获线程中的异常。

ThreadFactory factory = r -> {
    Thread t = new Thread(r);
    t.setUncaughtExceptionHandler((th, ex) -> {
        System.err.println("Exception in thread " + th.getName() + ": " + ex.getMessage());
    });
    return t;
};

或者在线程池中设置全局的未捕获异常处理器。

Thread.setDefaultUncaughtExceptionHandler((t, e) -> {
    System.err.println("Exception in thread " + t.getName() + ": " + e.getMessage());
});

总结一下，多线程编程虽然强大，但也充满了陷阱。只有深入了解这些潜在的风险，并采取相应的措施加以防范，才能让我们的程序既高效又稳定。记住，编程就像烹饪，掌握好火候才能做出美味佳肴！