项目中常见：Java多线程同步问题

原创墨蓝 2024-10-21 03:27 34阅读 0赞

在Java多线程编程中，同步问题主要体现在以下几个方面：

1. 竞态条件（Race Conditions）：多个线程同时访问共享资源，若无同步措施，可能会导致数据不一致。
   ```java
   // 示例：多个线程同时读写一个counter
   private int counter = 0;
   synchronized (this) {
       // 线程1: 增加counter
       if (counter < 5) {
           counter++;
           notifyAll(); // 通知其他等待的线程
       }
       
       // 线程2: 读取并打印counter
       if (counter > 0) {
           System.out.println("Counter = " + counter);
           wait(); // 释放锁，让其他线程有机会执行
       }
   }
   ```

2. 死锁（Deadlocks）：当两个或更多线程因争夺资源而造成的一种互相等待的现象时，就可能发生死锁。
   ```java
   // 示例：多个线程相互等待对方释放锁
   private Object lock1 = new Object();
   private Object lock2 = new Object();

class WorkerThread extends Thread {
       @Override
       public void run() {
           try {
               synchronized (lock1) { // 线程A: 获取锁1
                   if (/* 确定条件 */) {
                       // 执行任务
                       System.out.println("Task A executed...");
                       lock1.notifyAll(); // 通知其他等待的线程
                   } else { // 线程A: 等待锁1释放
                       lock1.wait();
                   }
               }

synchronized (lock2) { // 线程B: 获取锁2
                   if (/* 确定条件 */) {
                       // 执行任务
                       System.out.println("Task B executed...");
                       lock2.notifyAll(); // 通知其他等待的线程
                   } else { // 线程B: 等待锁2释放
                       lock2.wait();
                   }
               }

} catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
   }

public static void main(String[] args) {
       WorkerThread thread1 = new WorkerThread("Thread 1"));
       WorkerThread thread2 = new WorkerThread("Thread 2"));

// 启动线程
       thread1.start();
       thread2.start();

// 等待所有线程完成任务
       try {
           thread1.join();
           thread2.join();
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
   }
   ```

3. 资源泄露（Resource Leaks）：当一个线程释放了一个资源，但其他线程仍然持有这个资源时，就可能导致资源泄露问题。
   ```java
   // 示例：线程1创建并持有对象o，线程2尝试获取已经释放的对象o，造成资源泄露
   private Object o = new Object();

class WorkerThread extends Thread {
       @Override
       public void run() {
           try {
               // 线程1: 创建并持有对象o
               synchronized (this) {
                   o = new Object();
                   System.out.println("Object A created...");
                   notifyAll(); // 通知其他等待的线程
               }

// 等待线程2执行完释放对象o的操作
               synchronized (WorkerThread.class) {
                   while (o == null) { // 确保对象o已被释放
                       try {
                           WorkerThread.class.wait();
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                       }
                   System.out.println("Object A released...");
                   notifyAll(); // 通知其他等待的线程
               }

} catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
   }

public static void main(String[] args) {
       WorkerThread thread1 = new WorkerThread("Thread 1"));
       WorkerThread thread2 = new WorkerThread("Thread 2"));

// 启动线程
       thread1.start();
       thread2.start();

try {
           // 等待所有线程完成任务
           thread1.join();
           thread2.join();
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
   }
   ```