Java并发编程中线程死锁问题示例

原创浅浅的花香味﹌ 2024-09-19 00:57 7阅读 0赞

线程死锁在Java并发编程中通常是指两个或更多的线程相互等待对方释放资源，从而导致它们都无法继续执行的情况。

下面是一个简单的死锁示例：

```java
// 定义两个互斥的资源
class Resource {
    private boolean acquired;

Resource() {
        acquired = false;
    }

synchronized void acquire() {
        if (!acquired) {
            acquired = true;
            notifyAll(); // 唤醒所有等待这个资源的线程
        } else {
            System.out.println("Resource is already acquired by another thread!");
        }
    }

synchronized void release() {
        if (acquired) {
            acquired = false;
            notifyAll(); // 唤醒所有等待这个资源释放的线程
        } else {
            System.out.println("Resource is not acquired by any thread!");
        }
    }
}

// 定义两个相互依赖的线程
class ThreadA extends Thread {
    private Resource resource;

ThreadA(Resource resource) {
        this.resource = resource;
    }

@Override
    public void run() {
        try {
            resource.acquire(); // 获取资源

System.out.println("Thread A is running and using the resource...");

// 运行完业务代码后，需要释放资源
            Thread.sleep(2000); // 暂停线程2秒

resource.release(); // 释放资源
        } catch (InterruptedException e) {
            System.out.println("Thread A interrupted while acquiring/releasing resources...");
            e.printStackTrace();
        }
    }
}

class ThreadB extends Thread {
    private Resource resource;

ThreadB(Resource resource) {
        this.resource = resource;
    }

@Override
    public void run() {
        try {
            resource.acquire(); // 获取资源

System.out.println("Thread B is running and using the resource...");

// 运行完业务代码后，需要释放资源
            Thread.sleep(2000); // 暂停线程2秒

resource.release(); // 释放资源
        } catch (InterruptedException e) {
            System.out.println("Thread B interrupted while acquiring/releasing resources...");
            e.printStackTrace();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Resource resource = new Resource();

ThreadA threadA = new ThreadA(resource);
        ThreadB threadB = new ThreadB(resource);

// 启动线程
        threadA.start();
        threadB.start();

// 等待所有线程执行完毕
        try {
            threadA.join();
            threadB.join();
        } catch (InterruptedException e) {
            System.out.println("Interrupt occurred while waiting for threads to finish...");
            e.printStackTrace();
        }
    }
}
```

在这个例子中，ThreadA和ThreadB相互依赖，他们都需要获取资源才能运行。如果线程A先获得资源并运行，那么它会释放资源；如果线程B紧接着获取到资源并运行，那么它也会释放资源。这就可能导致线程B无法从线程A那里获取到资源，从而形成死锁。