线程的死锁和并发安全

在多线程编程中，线程的死锁和并发安全是两个重要的概念。理解这两个概念并正确地管理它们，对于编写高效且可靠的并发程序至关重要。

线程的死锁

死锁（Deadlock） 是指两个或多个线程相互等待对方释放已经持有的资源，导致它们无法继续执行的现象。死锁会导致程序卡住，无法继续执行。

死锁的四个必要条件

1. 互斥条件：一个资源一次只能被一个线程占用。
2. 持有并等待条件：一个线程已经持有至少一个资源，但又申请新的资源，而该资源被其他线程持有。
3. 不剥夺条件：线程已获得的资源在未使用完之前，不能被其他线程强行剥夺，只能由持有该资源的线程自行释放。
4. 环路等待条件：若干线程之间形成一种头尾相接的环形等待资源关系。

示例代码

以下代码演示了一个简单的死锁情况：

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

    public static void main(String[] args) {
        DeadlockExample example = new DeadlockExample();
        Thread thread1 = new Thread(example::method1);
        Thread thread2 = new Thread(example::method2);

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

    public void method1() {
        synchronized (lock1) {
            System.out.println("Thread 1: Holding lock 1...");
            try { Thread.sleep(100); } catch (InterruptedException e) {}
            System.out.println("Thread 1: Waiting for lock 2...");
            synchronized (lock2) {
                System.out.println("Thread 1: Holding lock 1 & 2...");
            }
        }
    }

    public void method2() {
        synchronized (lock2) {
            System.out.println("Thread 2: Holding lock 2...");
            try { Thread.sleep(100); } catch (InterruptedException e) {}
            System.out.println("Thread 2: Waiting for lock 1...");
            synchronized (lock1) {
                System.out.println("Thread 2: Holding lock 2 & 1...");
            }
        }
    }
}

在这个示例中，thread1 持有 lock1 并等待 lock2，同时 thread2 持有 lock2 并等待 lock1，这就导致了死锁。

预防死锁的方法

1. 避免嵌套锁：尽量减少持有多个锁的情况。
2. 按顺序获取锁：所有线程按照相同的顺序获取锁。
3. 使用尝试锁：使用 tryLock 方法尝试获取锁，如果无法获取就放弃。
4. 锁超时：设置锁的超时时间，避免无限等待。

并发安全

并发安全（Concurrency Safety） 是指在多线程环境下，正确地管理对共享资源的访问，避免竞争条件（Race Conditions）和数据不一致性。

竞争条件

竞争条件是指多个线程同时访问和修改共享资源时，由于访问顺序的不确定性，导致程序行为异常。

并发安全的实现

1. synchronized：内置锁机制，确保同一时间只有一个线程可以执行同步代码块或方法。

   public synchronized void synchronizedMethod() {
       // Critical section
   }
   
   public void synchronizedBlock() {
       synchronized (this) {
           // Critical section
       }
   }
   

2. Lock：显式锁机制，比 synchronized 更灵活。

   import java.util.concurrent.locks.Lock;
   import java.util.concurrent.locks.ReentrantLock;
   
   public class LockExample {
       private final Lock lock = new ReentrantLock();
   
       public void lockMethod() {
           lock.lock();
           try {
               // Critical section
           } finally {
               lock.unlock();
           }
       }
   }
   

3. volatile：保证变量的可见性，即一个线程修改了 volatile 变量的值，其他线程可以立即看到这个变化。

   public class VolatileExample {
       private volatile boolean flag = true;
   
       public void setFlag(boolean flag) {
           this.flag = flag;
       }
   
       public boolean getFlag() {
           return flag;
       }
   }
   

4. Atomic Classes：使用 java.util.concurrent.atomic 包提供的原子类，确保原子操作。

   import java.util.concurrent.atomic.AtomicInteger;
   
   public class AtomicExample {
       private final AtomicInteger counter = new AtomicInteger(0);
   
       public void increment() {
           counter.incrementAndGet();
       }
   
       public int getValue() {
           return counter.get();
       }
   }
   

5. ReadWriteLock：用于区分读锁和写锁，允许多个线程同时读取，但写操作是独占的。

   import java.util.concurrent.locks.ReadWriteLock;
   import java.util.concurrent.locks.ReentrantReadWriteLock;
   
   public class ReadWriteLockExample {
       private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
       private int data;
   
       public void writeData(int newData) {
           readWriteLock.writeLock().lock();
           try {
               data = newData;
           } finally {
               readWriteLock.writeLock().unlock();
           }
       }
   
       public int readData() {
           readWriteLock.readLock().lock();
           try {
               return data;
           } finally {
               readWriteLock.readLock().unlock();
           }
       }
   }
   

总结

• 死锁：线程相互等待对方释放资源，导致程序卡住。预防方法包括避免嵌套锁、按顺序获取锁、使用尝试锁和锁超时。
• 并发安全：确保多个线程正确地访问共享资源，避免竞争条件和数据不一致。常用工具包括 synchronized、Lock、volatile、原子类和 ReadWriteLock。

通过理解和正确使用这些工具，可以编写高效、安全的多线程程序。