Java多线程编程：常见同步问题实例

原创雨点打透心脏的1/2处 2024-10-08 09:24 85阅读 0赞

Java多线程编程中，常见的同步问题包括死锁、活锁、饥饿等问题。下面我将通过几个实例来解释这些问题。

1. 死锁：
   **例子**：
   ```java
   class BankAccount {
       int amount;
       BankAccount(int amount) { this.amount = amount; }
   }

class Bank {
       Map<BankAccount, Thread> accounts;
       Bank() { accounts = new HashMap<>(); }
   }

class ServiceA implements Runnable {
       void service() { System.out.println("Service A called."); }
       @Override
       public void run() { service(); Bank bank = new Bank();
       BankAccount account1 = new BankAccount(10);
       BankAccount account2 = new BankAccount(5);

bank.accounts.put(account1, this);
       bank.accounts.put(account2, Thread.currentThread());

// 现在银行账户和线程的关联已经建立
       // 如果这时服务A执行完毕，会尝试释放account1

try {
           bank.accounts.get(account1).join();
           System.out.println("Service A released account1.");
         } catch (InterruptedException e) {
           e.printStackTrace();
         }
       }
   }

class ServiceB implements Runnable {
       void service() { System.out.println("Service B called."); }
       @Override
       public void run() { service(); Bank bank = new Bank();
       Thread.currentThread().join(); // 服务B执行完毕，会尝试释放当前线程

try {
           bank.accounts.remove(Thread.currentThread()));
           System.out.println("Service B released current thread.");
         } catch (NoSuchElementException e) {
           e.printStackTrace();
         }
       }
   }

public class Main {
       public static void main(String[] args) {
           ServiceA serviceA = new ServiceA();
           Thread threadA = new Thread(serviceA);
           threadA.start();

ServiceB serviceB = new ServiceB();
           Thread threadB = new Thread(serviceB);
           threadB.start();

// 服务A和B执行完毕，会尝试释放自己的线程
           // 注意：实际多线程环境下，线程的生命周期由操作系统管理，并不是像上面的例子那样简单地通过join()方法来控制。

}
   }
```
在这个例子中，存在死锁的可能性。当ServiceA完成其服务并调用`bank.accounts.get(account1)).join()`时，如果此时ServiceB还没有执行完并尝试释放当前线程（也就是Thread.currentThread().join()），那么就会出现互相等待的情况，形成死锁。

为了避免这种情况，通常在多线程编程中会采取一些策略来防止死锁，比如超时机制、资源有序分配等。