如何用Synchronized避免死锁

在Java中，synchronized关键字用于控制多个线程对共享资源的访问。当多个线程试图同时访问一个资源时，synchronized可以确保一次只有一个线程能够执行该代码块，从而避免数据不一致和并发问题。然而，如果不正确地使用synchronized，可能会导致死锁。

死锁是指两个或多个线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法继续执行下去。

为了避免死锁，你可以遵循以下几个原则：

1. 避免嵌套锁：尽量避免在一个线程已经持有某个锁的情况下，再去请求另一个锁。如果确实需要这样做，确保以相同的顺序获取锁，并在完成后以相反的顺序释放锁。
2. 使用定时锁：在尝试获取锁时，可以使用tryLock()方法而不是lock()方法。tryLock()允许你指定一个等待时间，如果在这段时间内无法获取锁，线程将不会无限期地阻塞。
3. 使用单个锁：尽量减少锁的数量，只对必要的代码块进行同步。这样可以降低死锁的风险。
4. 使用并发集合：对于一些常见的并发操作，可以考虑使用Java提供的并发集合类，如ConcurrentHashMap、CopyOnWriteArrayList等。这些集合类内部已经实现了高效的并发控制，可以避免手动加锁带来的问题。
5. 使用Lock接口：除了synchronized关键字外，Java还提供了Lock接口及其实现类（如ReentrantLock）来进行更灵活的锁定控制。使用Lock接口可以提供更多的功能，如公平锁、非阻塞锁等，有助于避免死锁。

以下是一个简单的示例，展示了如何使用synchronized关键字来避免死锁：

public class DeadlockAvoidance {

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

    public void method1() {
        synchronized (lock1) {
            System.out.println("method1 acquired lock1");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lock2) {
                System.out.println("method1 acquired lock2");
            }
        }
    }

    public void method2() {
        synchronized (lock1) { // 注意这里获取锁的顺序与method1相同
            System.out.println("method2 acquired lock1");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lock2) {
                System.out.println("method2 acquired lock2");
            }
        }
    }

    public static void main(String[] args) {
        DeadlockAvoidance deadlockAvoidance = new DeadlockAvoidance();

        Thread thread1 = new Thread(deadlockAvoidance::method1);
        Thread thread2 = new Thread(deadlockAvoidance::method2);

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

在这个示例中，method1()和method2()都以相同的顺序获取lock1和lock2，从而避免了死锁的发生。