并发编程中的常见问题

1 竞态条件 (Race Condition)

定义：竞态条件是指多个线程在访问共享资源时，由于执行顺序的不同导致结果不确定的情况。

示例：

public class Counter {
   
    private int count = 0;

    public void increment() {
   
        count++;
    }

    public int getCount() {
   
        return count;
    }
}

在多线程环境下，多个线程同时调用 increment 方法时，可能会导致 count 的值不正确。

解决方案：

• 使用互斥锁 (Mutex)：

  import java.util.concurrent.locks.Lock;
  import java.util.concurrent.locks.ReentrantLock;
  
  public class Counter {
       
      private int count = 0;
      private final Lock lock = new ReentrantLock();
  
      public void increment() {
       
          lock.lock();
          try {
       
              count++;
          } finally {
       
              lock.unlock();
          }
      }
  
      public int getCount() {
       
          lock.lock();
          try {
       
              return count;
          } finally {
       
              lock.unlock();
          }
      }
  }
  

• 使用原子变量 (Atomic Variables)：

  import java.util.concurrent.atomic.AtomicInteger;
  
  public class Counter {
       
      private AtomicInteger count = new AtomicInteger(0);
  
      public void increment() {
       
          count.incrementAndGet();
      }
  
      public int getCount() {
       
          return count.get();
      }
  }
  

2 死锁 (Deadlock)

定义：死锁是指两个或多个线程互相持有对方需要的资源，并且都在等待对方释放资源，导致所有涉及的线程都无法继续执行的情况。

示例：

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

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