并发编程：Java线程同步和死锁问题案例分析

原创左手的ㄟ右手 2024-12-01 20:09 59阅读 0赞

Java线程同步是并发编程中的一大重要部分，它能有效地管理共享资源，防止数据竞争。以下是几个典型的同步问题及案例分析。

1. **synchronized关键字**：
   - 示例：多个类中有相同的代码块，可以用synchronized修饰。
   ```java
   class SharedResource {
       private int count = 0;

synchronized void increment() {
           count++;
           notifyAll(); // 等待通知的线程会被唤醒
       }

synchronized int getCount() {
           return count;
       }
   }

class CounterThread implements Runnable {
       private SharedResource sharedRes;

public CounterThread(SharedResource sharedRes) {
           this.sharedRes = sharedRes;
       }

@Override
       public void run() {
           while (true) {
               sharedRes.increment(); // 通知等待的线程
               try {
                   Thread.sleep(1000); // 线程休眠
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       }
   ```
2. **死锁**：
   - 示例：两个或多个线程互相等待对方释放资源，导致都无法继续执行。
   ```java
   class DeadlockExample {
       // 线程A的资源
       private Object resourceA = new Object();

// 线程B的资源
       private Object resourceB = new Object();

// 线程A和线程B的锁
       private final Lock lockA = new ReentrantLock();
       private final Lock lockB = new ReentrantLock();

public void deadlockExample() {
           // 线程A开始执行
           Thread threadA = new Thread(() -> {
               lockA.lock(); // 获取资源A的锁
               try {
                   System.out.println("线程A获取资源A，开始执行..."); // 执行逻辑

// 认为资源B已经被释放，尝试获取资源B的锁
                   lockB.lock();
                   System.out.println("线程A尝试获取资源B，但已被占用..."); // 错误信息打印，表示资源B被占用

} catch (InterruptedException e) {
                   e.printStackTrace();
                   lockB.unlock(); // 释放资源B的锁
               } finally {
                   lockA.unlock(); // 释放资源A的锁
                   lockB.unlock(); // 释放资源B的锁
               }
           }));

// 线程B开始执行
           Thread threadB = new Thread(() -> {
               lockB.lock(); // 获取资源B的锁
               try {
                   System.out.println("线程B获取资源B，开始执行..."); // 执行逻辑

// 认为资源A已经被释放，尝试获取资源A的锁
                   lockA.lock();
                   System.out.println("线程B尝试获取资源A，但已被占用..."); // 错误信息打印，表示资源A被占用

} catch (InterruptedException e) {
                   e.printStackTrace();
                   lockA.unlock(); // 释放资源A的锁
               } finally {
                   lockB.unlock(); // 释放资源B的锁
                   lockA.unlock(); // 释放资源A的锁
               }
           }));

threadA.start(); // 启动线程A
           threadB.start(); // 启动线程B
       }
   }
   ```
3. **解决死锁的方法**：
   - 避免循环等待：确保每个线程在获取资源时，总是能获取到下一个资源。
   - 设置超时时间：如果发现线程进入死锁状态，可以设置一个超时时间来终止线程。
   - 正确释放资源：在使用完共享资源后，需要正确地释放锁，避免循环等待。

以上就是Java线程同步和死锁问题的分析案例。