Java并发编程复杂性体现：锁竞态和死锁示例

原创比眉伴天荒 2024-11-12 03:15 1阅读 0赞

Java并发编程的复杂性主要体现在对共享资源的访问控制上，其中锁竞态和死锁是两个常见的问题。下面我将分别给出锁竞态和死锁的示例代码，以展示这些复杂性是如何体现的。

###锁竞态示例锁竞态（Race Condition）是指多个线程同时访问共享资源，并且至少有一个线程在修改共享资源，最终结果取决于线程执行的顺序。

```javapublic class Counter {
 private int count =0;

public void increment() {
 count++; //这里存在竞态条件 }

public int getCount() {
 return count;
 }
}
```在这个例子中，`increment` 方法没有同步，多个线程同时调用这个方法时，`count++`操作可能被中断，导致最终的 `count`值不是预期的。

###死锁示例死锁是指两个或多个线程在等待对方释放资源，导致它们都永远阻塞的情况。

```javapublic class DeadlockExample {
 private static final Object lock1 = new Object();
 private static final Object lock2 = new Object();

public static void main(String[] args) {
Thread t1 = new Thread(() -> {
 synchronized (lock1) {
 System.out.println("Thread1: Locked lock1");
 try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
 }
 synchronized (lock2) {
 System.out.println("Thread1: Locked lock2");
 }
 }
 });

Thread t2 = new Thread(() -> {
 synchronized (lock2) {
 System.out.println("Thread2: Locked lock2");
 try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
 }
 synchronized (lock1) {
 System.out.println("Thread2: Locked lock1");
 }
 }
 });

t1.start();
t2.start();
 }
}
```在这个例子中，`t1` 和 `t2`两个线程分别尝试先锁定 `lock1` 和 `lock2`，然后锁定另一个锁。如果 `t1`先锁定了 `lock1`，`t2`先锁定了 `lock2`，那么它们都会等待对方释放锁，导致死锁。

###解决方案1. **锁竞态解决方案**：使用 `synchronized` 关键字或 `ReentrantLock`来同步访问共享资源。
2. **死锁解决方案**：避免嵌套锁定，使用 `tryLock`尝试获取锁，或者使用 `Lock`接口的 `lockInterruptibly` 方法来响应中断。

通过这些示例，我们可以看到Java并发编程中锁竞态和死锁的复杂性，以及如何通过适当的同步机制来解决这些问题。