Java集合框架中的并发问题示例

原创 - 日理万妓 2024-10-23 17:48 22阅读 0赞

在Java的集合框架中，由于多线程的存在，可能会引发各种并发问题。以下是一些常见的示例：

1. **数据不一致**：
   - `ConcurrentModificationException`：当一个集合被正在修改它的线程所操作时，会抛出这个异常。
   ```java
   List<String> list = new ArrayList<>();
   // thread modifies list
   list.add("new item");
   ```

2. **死锁**：
   - 在多线程环境中，两个或多个线程相互等待对方释放资源的现象被称为死锁。
   ```java
   class LockA {
       public synchronized void lock() { ... }
       public synchronized void unlock() { ... }
    }

class LockB {
       private LockA lockA;

public synchronized LockA getLockA() { return lockA; }
       public synchronized void setLockA(LockA lock) { this.lockA = lock; }

public synchronized void lockB() {
           lockA.lock();
           // do something
           lockA.unlock();
       }
    }
   ```

3. **资源泄露**：
   - 当线程持有某个资源但没有释放时，可能会导致资源泄露。
   ```java
   class Resource {
       private int count;

public synchronized void acquire() { this.count++; }
       public synchronized void release() { if (count > 0) { count--; } else { throw new IllegalStateException("Cannot release non-acquired resource"); } }
    }

class ThreadA extends Thread {
       private Resource resource;

public ThreadA(Resource resource) { this.resource = resource; }

@Override
       public void run() {
           try {
               while (true) { // simulate busy loop
                   resource.acquire();
                   // do something
                   resource.release();
               }
           } catch (Exception e) {
               e.printStackTrace();
           }
       }
    }

class ThreadB extends Thread {
       private Resource resource;

public ThreadB(Resource resource) { this.resource = resource; }

@Override
       public void run() {
           try {
               while (true) { // simulate busy loop
                   resource.lockB(); // should throw exception
                   // do something
                   resource.unlockB();
               }
           } catch (Exception e) {
               e.printStackTrace();
           }
       }
    }

ThreadA threadA = new ThreadA(new Resource()));
    ThreadB threadB = new ThreadB(new Resource());

threadA.start();
    threadB.start();

// wait for threads to finish
   try {
       threadA.join();
       threadB.join();
   } catch (InterruptedException e) {
       e.printStackTrace();
   }
   ```

以上示例展示了Java集合框架中可能出现的并发问题和解决方案。