频繁遇到的Java并发问题实例

原创你的名字 2024-09-11 19:09 49阅读 0赞

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

1. 线程安全问题：
   ```java
   class Counter {
       private int count = 0;
       
       public synchronized void increment() {
           count++;
           notifyAll();
       }
       
       public synchronized int decrement() {
           if (count > 0) {
               count--;
               notifyAll();
               return count;
           } else {
               throw new RuntimeException("Counter underflow!");
           }
       }
       
       public synchronized int getCount() {
           return count;
       }
   }
   
   Thread thread1 = new Thread(() -> Counter.counter.increment()));
   Thread thread2 = new Thread(() -> Counter.counter.decrement()));

thread1.start();
thread2.start();

try {
    thread1.join();
    thread2.join();
} catch (InterruptedException e) {
    e.printStackTrace();
}
```
这里线程1和线程2会因为Counter的increment()和decrement()方法没有正确同步而发生数据不一致的问题。

2. 死锁问题：
   ```
   class DeadlockExample {
       Object lockA = new Object();
       Object lockB = new Object();

void methodA() {
           synchronized (lockA) {
               // ...业务逻辑
               synchronized (lockB) { // 错误，锁B没有先获取到
                   // ...死循环等待锁B
               }
           }
       }

void methodB() {
           synchronized (lockB) {
               // ...业务逻辑
               synchronized (lockA) { // 错误，锁A没有先获取到
                   // ...死循环等待锁A
               }
           }
       }
   }
   
   DeadlockExample example = new DeadlockExample();
   Thread threadA = new Thread(() -> example.methodA()));
   Thread threadB = new Thread(() -> example.methodB()));

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

// 死锁，两个线程互等待对方释放锁
```
这里通过方法A获取锁A并进行业务处理，然后尝试获取锁B；类似地，方法B会先获取锁B并处理业务。由于死锁定义是：两个或多个进程在执行过程中，因争夺资源而造成的一种互相阻止对方继续执行的状态。

所以当线程A和线程B按照这种方式各自获取到锁后，它们会形成一个无法继续的循环等待状态，从而导致死锁的发生。