Synchronized锁的死锁怎么避免

在Java中，synchronized关键字用于确保多个线程在访问共享资源时的互斥性。然而，如果不正确地使用synchronized，可能会导致死锁。死锁是指两个或多个线程互相等待对方释放资源，导致所有涉及的线程都无法继续执行。

为了避免synchronized锁导致的死锁，可以采取以下策略：

1. 避免嵌套锁

尽量避免在一个线程中获取一个锁之后再去获取另一个锁。如果必须这样做，确保所有线程都以相同的顺序获取锁。

public void methodA() {
    synchronized (lockA) {
        synchronized (lockB) {
            // do something
        }
    }
}

public void methodB() {
    synchronized (lockA) { // 确保获取锁的顺序一致
        synchronized (lockB) {
            // do something
        }
    }
}

2. 使用定时锁

使用tryLock方法而不是lock方法，这样可以在指定时间内尝试获取锁，如果超时则放弃。

Lock lockA = new ReentrantLock();
Lock lockB = new ReentrantLock();

public void methodA() {
    try {
        if (lockA.tryLock()) {
            try {
                if (lockB.tryLock()) {
                    try {
                        // do something
                    } finally {
                        lockB.unlock();
                    }
                }
            } finally {
                lockA.unlock();
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

public void methodB() {
    try {
        if (lockA.tryLock()) {
            try {
                if (lockB.tryLock()) {
                    try {
                        // do something
                    } finally {
                        lockB.unlock();
                    }
                }
            } finally {
                lockA.unlock();
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

3. 使用单个锁

尽量减少锁的数量，使用单个锁来保护所有共享资源。

public class SharedResource {
    private final Object lock = new Object();

    public void methodA() {
        synchronized (lock) {
            // do something
        }
    }

    public void methodB() {
        synchronized (lock) {
            // do something
        }
    }
}

4. 使用并发集合

对于一些常见的并发操作，可以使用Java提供的并发集合，如ConcurrentHashMap、CopyOnWriteArrayList等，这些集合内部已经处理了并发问题，不需要额外的同步。

5. 避免长时间持有锁

尽量减少持有锁的时间，只在必要时才持有锁，并在操作完成后立即释放锁。

public void methodA() {
    synchronized (lock) {
        // 快速完成操作
    }
}

6. 使用读写锁

对于读多写少的场景，可以使用读写锁（ReentrantReadWriteLock），允许多个线程同时读取共享资源，但写操作时需要独占锁。

public class SharedResource {
    private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    private final Lock readLock = rwLock.readLock();
    private final Lock writeLock = rwLock.writeLock();

    public void readMethod() {
        readLock.lock();
        try {
            // 读取操作
        } finally {
            readLock.unlock();
        }
    }

    public void writeMethod() {
        writeLock.lock();
        try {
            // 写入操作
        } finally {
            writeLock.unlock();
        }
    }
}

通过以上策略，可以有效地避免synchronized锁导致的死锁问题。