Java多线程同步问题：五个常见案例

原创末蓝、 2024-09-23 07:51 139阅读 0赞

在Java多线程编程中，常见的同步问题包括资源竞争、死锁、活锁等。下面列举五个常见案例：

1. **资源竞争**：
   当多个线程共享同一份资源（如缓冲区）时，就可能导致数据不一致。
   例如：
   ```java
   class SharedBuffer {
       int data;
       // 线程1和2都尝试修改data
     }
   Thread t1 = new Thread(() -> {
       SharedBuffer buffer = ...; // 初始化共享资源
       buffer.data++; // 修改数据
   }));
   Thread t2 = new Thread(() -> {
       SharedBuffer buffer = ...; // 初始资源
       buffer.data--; // 修改数据
   }));
   ```
   解决方案：使用锁、信号量或者ReentrantLock等机制来保护共享资源。

2. **死锁**：
   当两个或多个线程在执行过程中相互等待对方释放资源时，就可能出现死锁。
   例如：
   ```java
   class Bank {
       Account[] accounts; // 账户数组
       Lock lock; // 锁

// 创建账户
       void createAccount(int accountNum) {
           lock.lock();
           try {
               accounts[accountNum] = new Account(accountNum);
           } finally {
               lock.unlock();
           }
       }

// 存款
       void deposit(int accountNum, int amount)) {
           lock.lock();
           try {
               accounts[accountNum].deposit(amount);
           } finally {
               lock.unlock();
           }
       }

// 取款
       void withdraw(int accountNum, int amount)) {
           lock.lock();
           try {
               accounts[accountNum].withdraw(amount);
           } finally {
               lock.unlock();
           }
       }
   }
   class Account {
     int accountNum;
     int balance;

Lock lock; // 锁

// 创建账户
     void create(int accountNum) {
         lock.lock();
         try {
             this.accountNum = accountNum;
             this.balance = 0;
         } finally {
             lock.unlock();
         }
       }

// 存款
       void deposit(int amount) {
           lock.lock();
           try {
               this.balance += amount;
           } finally {
               lock.unlock();
           }
       }

// 取款
       void withdraw(int amount) {
           lock.lock();
           try {
               if (this.balance < amount) {
                   throw new IllegalArgumentException("Insufficient balance.");
                 }
               this.balance -= amount;
           } finally {
               lock.unlock();
           }
       }
   }
   ```
   解决方案：在设计多线程系统时，需要遵循“银行家算法”来避免死锁。例如，在上述案例中，当一个线程尝试取款后，如果另一个线程试图存款超过当前账户余额，就可能发生死锁。

3. **活锁**：
   当一个线程由于某种原因长时间等待资源（如锁）时，这个线程可能会陷入无限循环的活锁状态。
   例如：
   ```java
   class Bank {
       Account[] accounts; // 账户数组
       Lock lock; // 锁

// 创建账户
       void createAccount(int accountNum) {
           // 这里假设获取锁的逻辑失败，导致线程长时间等待
           lock.lock();
           try {
               this.accounts[accountNum] = new Account(accountNum);
           } finally {
               lock.unlock();
           }
       }

// 存款
       void deposit(int accountNum, int amount)) {
           lock.lock();
           try {
               accounts[accountNum].deposit(amount);
           } finally {
               lock.unlock();
           }
       }
   }
   ```
   解决方案：为了避免活锁，线程在获取资源（如锁）之前，应该检查当前资源的状态。如果发现可能引发活锁的条件，则可以采用以下策略之一：

- **避免循环等待**：设计算法或逻辑，确保线程不会因多次尝试获取同一资源而陷入死循环。
- **设置超时**：为获取资源设一个超时时间，若在超时时间内仍无法获得资源，就放弃此次获取并重新尝试。
- **随机化锁的获取顺序**：当多个线程争抢同一个锁时，可以通过随机化获取锁的顺序来避免循环等待。

4. **资源争抢**：
   在多线程环境下，由于同一时间只能一个线程执行特定的任务（如访问和修改共享数据），因此可能会出现线程间的资源争抢。
   例如：
   ```java
   class SharedResource {
       int data;
       // 线程1和2都尝试修改data
     }
   Thread t1 = new Thread(() -> {
       SharedResource resource = ...; // 初始化共享资源
       resource.data++; // 修改数据
   }));
   Thread t2 = new Thread(() -> {
       SharedResource resource = ...; // 初始资源
       resource.data--; // 修改数据
   }));
   ```
   解决方案：为避免资源争抢，可以采取以下策略：

- **线程池**：使用线程池来管理线程。当一个任务完成后，线程池会自动回收线程，从而避免过度消耗资源。
- **优先级和截止时间**：为每个任务设置优先级和截止时间。高优先级的任务会被优先执行，这样可以确保关键任务能够及时完成。
- **原子操作**：对于需要共享的资源，使用原子操作（如Java的Atomic类）来保证在并发环境下对数据的正确处理。
- **锁策略优化**：针对多线程环境下的锁管理问题，可以采用更高级别的锁策略，如读写锁、条件变量等，以实现更高效和无阻塞的资源共享。