并发编程如何避免死锁

并发编程中避免死锁是一个重要的问题，以下是一些常见的避免死锁的策略：

1. 避免嵌套锁

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

// 不好的例子
synchronized (lockA) {
    synchronized (lockB) {
        // do something
    }
}

// 好的例子
synchronized (lockA) {
    synchronized (lockB) {
        // do something
    }
}

2. 使用定时锁

在尝试获取锁时使用超时机制，如果一段时间内无法获取锁，则放弃并重试。

try {
    if (lock.tryLock(timeout, TimeUnit.MILLISECONDS)) {
        try {
            // do something
        } finally {
            lock.unlock();
        }
    } else {
        // 处理获取锁失败的情况
    }
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
}

3. 使用单个全局锁

如果可能，尽量减少锁的数量，使用一个全局锁来保护所有共享资源。

4. 分解锁

将一个大锁分解成多个小锁，每个锁保护一部分资源，这样可以减少锁的竞争。

class FineGrainedLock {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();

    public void method1() {
        synchronized (lock1) {
            // do something
        }
    }

    public void method2() {
        synchronized (lock2) {
            // do something
        }
    }
}

5. 避免饥饿

确保所有线程都有机会获取锁，避免某些线程长时间占用锁。

6. 使用并发集合

使用Java提供的并发集合，如ConcurrentHashMap、CopyOnWriteArrayList等，这些集合在内部处理了并发问题，可以减少手动加锁的需求。

7. 使用读写锁

对于读多写少的场景，使用读写锁（ReentrantReadWriteLock）可以提高并发性能。

ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
Lock readLock = rwLock.readLock();
Lock writeLock = rwLock.writeLock();

public void read() {
    readLock.lock();
    try {
        // do something
    } finally {
        readLock.unlock();
    }
}

public void write() {
    writeLock.lock();
    try {
        // do something
    } finally {
        writeLock.unlock();
    }
}

8. 死锁检测和恢复

虽然不是预防性的策略，但可以通过监控和日志来检测死锁，并在检测到死锁时采取措施恢复，例如终止某些线程或释放某些锁。

9. 使用无锁算法

在某些情况下，可以使用无锁算法来避免锁的使用，例如使用AtomicInteger、AtomicReference等原子类。

AtomicInteger counter = new AtomicInteger(0);

public void increment() {
    int current;
    do {
        current = counter.get();
    } while (!counter.compareAndSet(current, current + 1));
}

通过这些策略，可以有效地减少并发编程中死锁的发生。