Java并发编程：死锁和资源争用示例

原创曾经终败给现在 2024-09-11 06:27 64阅读 0赞

在Java并发编程中，死锁和资源争用是两个重要的概念。以下分别给出这两个问题的示例：

1. 死锁示例：
```java
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class DeadlockExample {
    private Lock lockA = new ReentrantLock();
    private Lock lockB = new ReentrantLock();

public void methodA() throws InterruptedException {
        lockA.lock(); // 1. 获取锁A
        System.out.println("Method A is executing.");
        // 进行任务
        Thread.sleep(2000); // 模拟耗时操作

lockA.unlock(); // 2. 释放锁A
    }

public void methodB() throws InterruptedException {
        lockB.lock(); // 3. 获取锁B
        System.out.println("Method B is executing.");
        // 进行任务
        Thread.sleep(1000); // 模拟耗时操作

lockB.unlock(); // 4. 释放锁B
    }

public void bothMethods() throws InterruptedException {
        methodA();
        methodB();
    }
}

public class Main {
    public static void main(String[] args) {
        DeadlockExample example = new DeadlockExample();
        example.bothMethods(); // 尝试运行两个方法，可能会导致死锁
    }
}
```
在这个示例中，线程A和B分别尝试获取锁A和B。如果顺序是1-2（A->B）或3-4（B->A），那么就可能产生死锁。

2. 资源争用示例：
```java
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class Resource争用Example {
    private Lock lock = new ReentrantLock();

public void method() throws InterruptedException {
        // 先获取锁，模拟资源访问
        lock.lock();
        System.out.println("Method is executing, accessing resource.");
        // 模拟耗时操作
        Thread.sleep(2000);

// 释放锁，表示资源归还
        lock.unlock();
    }
}

public class Main {
    public static void main(String[] args) {
        Resource争用Example example = new Resource争用Example();
        example.method(); // 运行方法，可能会导致资源争用问题
    }
}
```
在这个示例中，线程尝试获取锁来访问资源。如果多个线程同时尝试获取同一个锁，那么就可能导致资源争用。

总结：
Java并发编程中的死锁和资源争用是常见的问题。理解这些概念，并在实践中注意避免它们，对于编写高效并发程序至关重要。