Java多线程：死锁、同步问题实例-蒲公英云

Java多线程：死锁、同步问题实例

原创女爷i 2024-11-29 12:51 122阅读 0赞

死锁是多线程编程中的一个严重问题。当两个或更多的线程互相等待对方释放资源时，就会发生死锁。

以下是一个简单的Java多线程死锁示例：

// 线程1需要资源1和2
class Thread1 extends Thread {
    private int resource1;
    private int resource2;
    public Thread1(int resource1, int resource2) {
        this.resource1 = resource1;
        this.resource2 = resource2;
    }
    @Override
    public void run() {
        synchronized (resource1) { // 资源1先被锁住
            synchronized (resource2) { // 资源2再被锁住
                System.out.println("Thread 1 acquired resources: " + resource1 + ", " + resource2);
                if (releaseResources()) { // 如果能够释放资源，就退出循环
                    return;
                }
            }
        }
        System.out.println("Thread 1 could not release resources and is waiting.");
    }
    private boolean releaseResources() {
        // 假设这里有一个可以用来测试是否能释放资源的方法
        // 这个方法可能会抛出异常，所以我们需要捕获这些异常
        if (releaseResource1() && releaseResource2()) {
            return true;
        } else {
            System.out.println("Failed to release resources.");
            return false;
        }
    }
    private boolean releaseResource1() {
        // 假设这里有一个释放资源1的方法
        // 这个方法可能会抛出异常，所以我们需要捕获这些异常
        if (resource1 > 0) {
            resource1--;
            System.out.println("Thread 1 released resource 1.");
            return true;
        } else {
            System.out.println("Failed to release resource 1. Resource is already released.");
            return false;
        }
    }
    private boolean releaseResource2() {
        // 类似于releaseResource1的方法
        if (resource2 > 0) {
            resource2--;
            System.out.println("Thread 1 released resource 2.");
            return true;
        } else {
            System.out.println("Failed to release resource 2. Resource is already released.");
            return false;
        }
    }
}
// 线程2需要资源2和3
class Thread2 extends Thread {
    private int resource2;
    private int resource3;
    public Thread2(int resource2, int resource3) {
        this.resource2 = resource2;
        this.resource3 = resource3;
    }
    @Override
    public void run() {
        synchronized (resource2) { // 资源2先被锁住
            synchronized (resource3) { // 资源3再被锁住
                System.out.println("Thread 2 acquired resources: " + resource2 + ", " + resource3);
                if (releaseResources()) { // 如果能够释放资源，就退出循环
                    return;
                }
            }
        }
        System.out.println("Thread 2 could not release resources and is waiting.");
    }
    private boolean releaseResources() {
        // 假设这里有一个可以用来测试是否能释放资源的方法
        // 这个方法可能会抛出异常，所以我们需要捕获这些异常
        if (resource2 > 0) {
            resource2--;
            System.out.println("Thread 2 released resource 2.");
            return true;
        } else {
            System.out.println("Failed to release resource 2. Resource is already released.");
            return false;
        }
    }
    private boolean releaseResource3() {
        // 类似于releaseResource2的方法
        if (resource3 > 0) {
            resource3--;
            System.out.println("Thread 2 released resource 3.");
            return true;
        } else {
            System.out.println("Failed to release resource 3. Resource is already released.");
            return false;
        }
    }
}
public class DeadLockExample {
    public static void main(String[] args) {
        Thread1 thread1 = new Thread1(1, 2);
        Thread2 thread2 = new Thread2(2, 3);
        // 启动线程
        thread1.start();
        thread2.start();
        // 等待所有线程执行完毕
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}