避免 java 并发中的死锁和争用条件：避免死锁: 使用锁排序，始终以相同的顺序获取锁。避免争用条件: 使用同步机制（锁或原子变量）确保共享数据在同一时间只被一个线程访问。

避免 Java 函数中的死锁和争用条件

简介

死锁和争用条件是 Java 并发编程中常见的错误，可能导致程序长时间阻塞或产生不一致的结果。本文将介绍如何避免这些问题，并通过实战案例进行说明。

立即学习“Java免费学习笔记（深入）”；

死锁

死锁发生在两个或多个线程互相等待对方释放锁时。例如：

public class Deadlock {

    private static Object lock1 = new Object();
    private static Object lock2 = new Object();

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            synchronized (lock1) {
                // 等待获取 lock2
                synchronized (lock2) {
                    // 操作代码
                }
            }
        });

        Thread t2 = new Thread(() -> {
            synchronized (lock2) {
                // 等待获取 lock1
                synchronized (lock1) {
                    // 操作代码
                }
            }
        });

        t1.start();
        t2.start();
    }
}

在这种情况下，t1 获取了 lock1，并等待 lock2；而 t2 获取了 lock2，并等待 lock1。这会导致死锁，因为两个线程都无限期地等待对方释放锁。

避免死锁

避免死锁的一种方法是使用锁排序：始终以相同的顺序获取锁。在上面的示例中，我们可以将 lock1 和 lock2 进行排序，并始终先获取 lock1，然后再获取 lock2。

争用条件

争用条件发生在多个线程同时访问共享数据时，并且该数据不被正确同步。例如：

public class RaceCondition {

    private static int counter;

    public static void main(String[] args) {
        Thread[] threads = new Thread[10];
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    counter++;
                }
            });
        }

        for (Thread thread : threads) {
            thread.start();
        }

        for (Thread thread : threads) {
            thread.join();
        }

        System.out.println("最终计数：" + counter);
    }
}

在这个示例中，多个线程同时递增 counter 变量。由于没有同步，该变量可能会被读写多次，导致最终计数不正确。

避免争用条件

避免争用条件的一种方法是使用同步机制，例如锁或原子变量。在上面的示例中，我们可以使用锁来确保一次只有一个线程可以修改 counter 变量：

private static final Object lock = new Object();

public static void main(String[] args) {
    // ... 同样设置线程和计数器 ...

    for (Thread thread : threads) {
        thread.start();
    }

    for (Thread thread : threads) {
        thread.join();
    }

    synchronized (lock) {
        System.out.println("最终计数：" + counter);
    }
}