Java并发编程中常见锁问题实例解析

原创女爷i 2024-12-03 15:03 24阅读 0赞

在Java并发编程中，常见的锁问题主要包括死锁、活锁、饥饿等问题。下面以几个实例解析：

1. 死锁：多个线程相互等待对方释放资源导致的僵局。例如：

```java
// 线程A和B，它们分别持有资源X和Y
class ThreadA extends Thread {
    private Object resourceX;

public ThreadA(Object resourceX) {
        this.resourceX = resourceX;
    }

@Override
    public void run() {
        try {
            // 获取资源X
            synchronized (resourceX) {
                System.out.println("Thread A: Acquire resource X");
                Thread.sleep(1000); // 模拟耗时操作

// 资源X已获取，尝试获取资源Y
                // 注意这里没有直接同步resourceY，如果资源Y不是线程私有的，这样可能会导致死锁
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class ThreadB extends Thread {
    private Object resourceY;

public ThreadB(Object resourceY) {
        this.resourceY = resourceY;
    }

@Override
    public void run() {
        try {
            // 获取资源Y
            synchronized (resourceY) {
                System.out.println("Thread B: Acquire resource Y");
                Thread.sleep(1000); // 模拟耗时操作

// 资源Y已获取，尝试获取资源X
                // 注意这里同步资源X，这样就会形成死锁
                synchronized (resourceX) {
                    System.out.println("Thread B: Attempt to acquire resource X");
                    Thread.sleep(1000); // 模拟耗时操作
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        ThreadA threadA = new ThreadA(new Object());
        ThreadB threadB = new ThreadB(new Object());

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

// 线程同步，等待线程完成
        try {
            threadA.join();
            threadB.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

上述代码中，ThreadA持有资源X，ThreadB持有资源Y。由于两个线程相互等待对方释放资源（例如，ThreadB获取资源X后，再释放给ThreadA），这就导致了死锁现象。

解决死锁的方法通常包括设置超时、避免循环等待、使用死锁预防或检测机制等。