频繁出现的Java并发问题实例

原创秒速五厘米 2024-09-21 05:24 63阅读 0赞

在Java并发编程中，常见的问题包括死锁、饥饿、活锁、资源泄露等。以下是一些实例：

1. 死锁：两个或多个进程互相等待对方释放资源，从而造成无法继续运行的状态。
   ```java
   // 进程A
   class A {
       void acquire(B b) {
           if (b.isLocked()) throw new IllegalStateException();
           b.lock();
           System.out.println("A acquired B");
       }

void release(B b) {
           if (!b.isLocked()) throw new IllegalStateException();
           b.unlock();
           System.out.println("A released B");
       }
   }

// 进程B
   class B extends A {
       boolean isLocked() {
           return lock != null;
       }

Lock lock = new Lock(); // 自定义锁

@Override
       void acquire(A a) {
           super.acquire(a);
           System.out.println("B acquired A");
       }
   }

public class Main {
       public static void main(String[] args) {
           B b = new B();
           A a = new A();

b.acquire(a); // B先获取A
           Thread.sleep(1000); // 暂停程序执行

// 这里假设A释放了对B的锁
           a.release(b);

System.out.println("All resources released");
       }
   }
   ```

2. 饿汉：始终拥有资源（例如锁）但并不使用。
   ```java
   class Singleton {
       private Singleton instance;

Singleton() {
           if (instance != null) throw new IllegalStateException("Singleton already created");
           instance = this;
       }

public static Singleton getInstance() {
           return instance != null ? instance : new Singleton();
       }
   }
   ```

3. 活锁：进程反复申请但始终未能获得的资源。
   ```java
   class Resource {
       private Lock lock;

Resource() {
           lock = new Lock(); // 自定义锁
       }

public synchronized void acquire() throws InterruptedException {
           while (lock != null && !lock.tryLock())) {
               System.out.println("Thread waiting for resource");
               Thread.sleep(100);
               // 你可以在这里加入一些逻辑来避免死循环，比如检查是否到达最大重试次数等
           }
           lock = lock;
           System.out.println("Resource acquired by thread");
       }

public synchronized void release() {
           if (lock == null) throw new IllegalStateException("Resource not acquired");
           lock.unlock();
           lock = null;
           System.out.println("Resource released by thread");
       }
   }

// 使用示例
   class Main {
       public static void main(String[] args) {
           Resource resource = Resource.getInstance(); // 获取资源实例

Thread thread1 = new Thread(() -> {
               try {
                   resource.acquire(); // 请求获取资源
                   Thread.sleep(500); // 暂停500毫秒
                   resource.release(); // 释放资源
               } catch (InterruptedException e) {
                   System.out.println("Interrupt caught: " + e.getMessage());
                   Thread.currentThread().interrupt();
               }
           }));

Thread thread2 = new Thread(() -> {
               try {
                   resource.acquire(); // 请求获取资源
                   Thread.sleep(500); // 暂停500毫秒
                   // 这里假设资源使用完毕
                   resource.release(); // 释放资源
               } catch (InterruptedException e) {
                   System.out.println("Interrupt caught: " + e.getMessage());
                   Thread.currentThread().interrupt();
               }
           }));

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

// 等待所有线程结束
           while (!thread1.isAlive() && !thread2.isAlive())) {
               System.out.println("All threads finished");
               break;
           }
       }
   }
}
```