解决Java并发编程常见问题：锁竞争及死锁案例

原创青旅半醒 2024-09-23 11:12 72阅读 0赞

在Java并发编程中，常见的问题包括锁竞争和死锁。下面我会分别给出这两个问题的案例。

### 锁竞争案例

**场景一：线程池中的资源争抢**

```java
import java.util.concurrent.Executors;
import java.util.concurrent.Lock;

public class LockConflict {
    private final Lock lock = new ReentrantLock();

public void concurrentAccess() {
        ExecutorService executor = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 1000; i++) {
            executor.submit(() -> {
                try {
                    lock.lock();
                    // 这里是竞争的资源
                    Thread.sleep(50); // 模拟耗时操作
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }));
        }
        executor.shutdown();
    }

public static void main(String[] args) {
        LockConflict example = new LockConflict();
        example.concurrentAccess();
    }
}
```

**场景二：多个线程同时修改共享数据**

```java
import java.util.concurrent.atomic.AtomicInteger;

public class LockConflictAtomicVariable {
    private AtomicInteger count = new AtomicInteger(0);

public void concurrentUpdate() {
        for (int i = 0; i < 1000; i++) {
            Thread thread = new Thread(() -> {
                try {
                    // 随机选择更新操作
                    int updateType = Math.random() >= 0.5 ? 1 : 2;
                    if (updateType == 1) { // 增加计数器值
                        count.incrementAndGet();
                    } else if (updateType == 2) { // 减少计数器值
                        count.decrementAndGet();
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    // 模拟耗时操作
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }));
            thread.start();
        }
    }

public static void main(String[] args) {
        LockConflictAtomicVariable example = new LockConflictAtomicVariable();
        example.concurrentUpdate();
        System.out.println("Final count: " + example.count.get()); // 输出最终计数结果
    }
}
```

### 死锁案例

**场景一：银行贷款系统中的死锁**

```java
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class BankLoanSystemDeadlock {
    private final Lock loan1Lock = new ReentrantLock();
    private final Lock loan2Lock = new ReentrantLock();

public void processLoans() throws InterruptedException {
        // 贷款A的请求
        loan1Lock.lock();
        try {
            // 确认贷款B的请求尚未被获取
            if (!loan2Lock.isHeldByAnyThread()) {
                System.out.println("批准贷款 A (金额：1000)}");
                // 处理贷款并释放锁
                processLoan(1000);
                loan1Lock.unlock();
            } else {
                System.out.println("拒绝贷款A，因为贷款B正在处理中。");
                loan1Lock.unlock();
            }
        } catch (Exception e) {
            e.printStackTrace();
            loan1Lock.unlock(); // 如果出现异常，释放锁
        }
    }

private void processLoan(int loanAmount) {
        // 贷款B的请求
        loan2Lock.lock();
        try {
            System.out.println("批准贷款 B (金额： " + loanAmount + ")");
            // 处理贷款并释放锁
            payOffLoans(loanAmount);
            loan2Lock.unlock();
        } catch (Exception e) {
            e.printStackTrace();
            loan2Lock.unlock(); // 如果出现异常，释放锁
        }
    }

private void payOffLoans(int loanAmount) {
        System.out.println("偿还贷款：" + loanAmount);
    }

public static void main(String[] args) {
        BankLoanSystemDeadlock example = new BankLoanSystemDeadlock();
        example.processLoans(); // 调用处理贷款的方法
    }
}
```

在这个场景中，两个线程分别在请求贷款A和B时竞争锁。如果一个线程请求贷款A并在得到锁后请求贷款B，另一个线程可能会因为锁被获取而一直等待，从而导致死锁。