详解Java多线程并发问题案例

原创柔情只为你懂 2024-12-09 13:45 0阅读 0赞

Java多线程并发问题是编程中常见的挑战，主要涉及到资源竞争、死锁、活锁等问题。以下是一些具体的案例：

1. **资源竞争**：
   ```java
   // 假设两个线程分别对一个共享变量a进行操作
   class ThreadA extends Thread {
       private int a;

public ThreadA(int a) {
           this.a = a;
       }

@Override
       public void run() {
           a++;
           System.out.println("Thread A: " + a);
       }
    }

class ThreadB extends Thread {
       private int a;

public ThreadB(int a) {
           this.a = a;
       }

@Override
       public void run() {
           a--;
           System.out.println("Thread B: " + a);
       }
    }

ThreadA a1 = new ThreadA(0);
    ThreadA a2 = new ThreadA(1);

ThreadB b1 = new ThreadB(2);
    ThreadB b2 = new ThreadB(3);

a1.start();
    a2.start();

b1.start();
    b2.start();
   ```
   这个例子中，线程A和B分别对共享变量a进行加1或减1的操作。由于没有同步机制，可能会出现a的值不准确或者交错的问题。

2. **死锁**：
   ```java
   // 假设两个线程同时等待对方释放资源
   class WaiterThread extends Thread {
       private int waiterNum;
       private Object resource;

public WaiterThread(int waiterNum, Object resource) {
           this.waiterNum = waiterNum;
           this.resource = resource;
       }

@Override
       public void run() {
           while (true) {
               try {
                   // 模拟线程等待资源释放
                   synchronized (resource) {
                       if (waiterNum == 1) {
                           System.out.println("Thread " + waiterNum + " acquired resource");
                           break;
                         }
                       System.out.println("Thread " + waiterNum + " waiting for resource release");
                       resource.wait();
                       // 模拟线程资源释放
                       if (waiterNum == 2) {
                           System.out.println("Thread " + waiterNum + " released resource to thread " + waiterNum - 1);
                           break;
                         }
                       System.out.println("Thread " + waiterNum + " released resource to itself");
                       resource.notifyAll();
                   }
               } catch (InterruptedException e) {
                   e.printStackTrace();
                   // 如果中断，那么线程应该停止并清理资源
                   if (waiterNum == 1) {
                       System.out.println("Thread " + waiterNum + " interrupted - releasing resource");
                       resource.notifyAll();
                       break;
                     }
                   System.out.println("Thread " + waiterNum + " interrupted - cleaning resources");
                   // 清理资源，例如重置计数器
                   // 然后再次抛出InterruptedException来通知线程中断
                   Thread.currentThread().interrupt();
               }
           }
       }
   }

WaiterThread t1 = new WaiterThread(1, new Object());
   WaiterThread t2 = new WaiterThread(2, new Object());

t1.start();
   t2.start();
   ```
   这个例子中，线程t1和t2都在等待对方释放资源。但由于没有正确的同步机制，可能会出现死锁：两个或多个线程互相等待对方释放资源，导致它们都无法继续执行。

3. **活锁**：
   活锁与死锁类似，只是线程并未真正进入阻塞状态，而是陷入了无限循环的困境。

解决Java多线程并发问题通常需要使用同步机制，如synchronized关键字、wait/notify方法等。同时理解并掌握避免死锁和活锁的策略也很重要。