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

原创逃离我推掉我的手 2024-10-21 14:30 63阅读 0赞

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

1. **资源竞争**：
   ```java
   class Counter {
       private int count = 0;
       
       public synchronized void increment() {
           count++;
           notifyAll(); //唤醒等待的线程
       }
   
       public synchronized int getCount() {
           return count;
       }
   }
   ```
   在这个例子中，Counter类有一个计数器和两个同步方法。如果多个线程同时调用increment方法，就可能会出现资源竞争。

2. **死锁**：
   ```java
   class DeadlockExample {
       private Object lock1 = new Object();
       private Object lock2 = new Object();

public void threadA() throws InterruptedException {
           synchronized (lock1) { //持有锁1
               while (!acquireLock(lock2))) { //尝试获取锁2，但失败了
                   wait(lock1); //释放锁1，进入等待状态
               }
               System.out.println("Thread A acquired lock 2"); //成功获取锁2
               releaseLock(lock2); //释放锁2
               notifyAll(); //唤醒所有等待的线程
           }
       }

public void threadB() throws InterruptedException {
           synchronized (lock1) { //持有锁1
               while (!acquireLock(lock2))) { //尝试获取锁2，但失败了
                   wait(lock1); //释放锁1，进入等待状态
               }
               System.out.println("Thread B acquired lock 2"); //成功获取锁2
               releaseLock(lock2); //释放锁2
               notifyAll(); //唤醒所有等待的线程
           }
       }

public void startThreads() {
           Thread threadA = new Thread(() -> threadA()));
           Thread threadB = new Thread(() -> threadB()));

threadA.start();
           threadB.start();
       }
   }
   ```
   在这个例子中，两个线程（threadA和threadB）分别尝试获取锁1和锁2。如果一个线程在获取锁的过程中失败，它会释放已持有的锁并进入等待状态。

当两个线程都处于等待状态时，它们将一直等待直到其他线程释放了锁或死锁发生。

3. **活锁与饿死**：
   活锁是指线程在循环中持续尝试获取一个资源，而这个资源当前已经被其他线程占用。由于资源被长时间占用，线程会陷入无限等待，无法完成任务。

饿死是指当线程一直等待某个条件满足（如获得锁）而没有获得任何资源时，就会出现这种情况。这种状态对线程来说是不利的，因为它不能执行任何操作来改善其状况。

总结：在多线程并发编程中，理解和避免这些常见的同步问题是非常重要的。