Java多线程同步问题：竞态条件与锁机制

原创刺骨的言语ヽ痛彻心扉 2024-12-08 23:27 13阅读 0赞

在Java中，多线程编程可能会遇到两种常见的同步问题：竞态条件和锁机制。

1. 竞态条件：
   - **定义**：当多个线程试图访问和修改共享资源时，如果它们的执行顺序不同，就会导致数据不一致，这种情况称为竞态条件。
   
   - **示例**：
     ```java
     class Counter {
         private int count = 0;
         
         public synchronized void increment() {
             count++;
             notifyAll(); // 唤醒等待的线程
         }
         
         public synchronized int decrement() {
             if (count > 0) {
                 count--;
                 if (count == 0) { // 如果计数为零，表示资源已释放
                     notifyAll(); // 唤醒等待的线程
                 } else { // 否则，直接返回减去后的值
                     return count;
                 }
             } else {
                 throw new RuntimeException("Counter is already zero!"); // 抛出异常，防止竞态条件继续发生
             }
         }
     }
     
     class CounterThread implements Runnable {
         private Counter counter;
         
         public CounterThread(Counter counter) {
             this.counter = counter;
         }
         
         @Override
         public void run() {
             while (true) { // 无限循环，模拟线程持续运行
                 try {
                     counter.increment(); // 增加计数
                     System.out.println("Incremented count: " + counter.decrement()); // 确保计数正确减去后返回
                 } catch (InterruptedException | RuntimeException e) { // 处理可能发生的异常
                     System.err.println("Error encountered in CounterThread: " + e.getMessage());
                     e.printStackTrace();
                     Thread.currentThread().interrupt(); // 阻塞当前线程，避免死循环
                 }
             }
         }
     }
     
     public class Main {
         public static void main(String[] args) {
             Counter counter = new Counter(); // 创建Counter对象
             
             // 创建并启动两个线程来操作Counter
             Thread thread1 = new Thread(new CounterThread(counter))), "Thread 1"; // 线程1的名称和参数
             Thread thread2 = new Thread(new CounterThread(counter))), "Thread 2"; // 线程2的名称和参数
             
             // 启动线程
             thread1.start();
             thread2.start();
         }
     }
     ```

在这个示例中，我们通过创建两个线程（`CounterThread`），分别操作同一个共享的`Counter`对象。由于线程执行顺序的不同，可能会导致计数不一致的问题。

要解决这个问题，Java引入了锁机制（Synchronized关键字和Lock接口）。在上述示例中，可以在`CounterThread`类的方法上使用`synchronized (counter)`来锁定`Counter`对象，保证同一时间只有一个线程可以访问并修改共享资源。