Java多线程同步：死锁示例-蒲公英云

Java多线程同步：死锁示例

原创 Dear 丶 2024-12-10 19:51 100阅读 0赞

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

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

// 创建两个互斥的资源
class Resource {
    private boolean locked;
    Resource() {
        locked = false;
    }
    // 锁定资源，如果已被锁定则返回false
    synchronized void lock() {
        if (locked) {
            System.out.println("Resource is already locked by another thread.");
            return;
        }
        locked = true;
        System.out.println("Resource " + this + " is locked by thread " + Thread.currentThread().getName());
    }
    // 解锁资源
    synchronized void unlock() {
        if (!locked) {
            System.out.println("Resource is already unlocked by another thread.");
            return;
        }
        locked = false;
        System.out.println("Resource " + this + " is unlocked by thread " + Thread.currentThread().getName());
    }
}
// 创建两个线程，分别尝试获取资源
class ThreadA extends Thread {
    Resource resource;
    ThreadA(Resource res) {
        resource = res;
    }
    public void run() {
        try {
            System.out.println("Thread A starting to acquire resource " + resource);
            resource.lock(); // 线程A尝试锁定资源
            System.out.println("Thread A successfully acquired resource " + resource);
            Thread.sleep(2000); // 模拟长时间操作，防止死锁的发生
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            try {
                if (resource.isLocked()) { // 确认资源是否已被其他线程锁定
                    System.out.println("Thread A detected that resource " + resource + " is still locked by another thread.");
                    resource.unlock(); // 解锁资源，释放其他线程等待的锁
                    }
                else {
                    System.out.println("Resource " + resource + " was already unlocked by another thread.");
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        System.out.println("Thread A ending.");
    }
}
class ThreadB extends Thread {
    Resource resource;
    ThreadB(Resource res) {
        resource = res;
    }
    public void run() {
        try {
            System.out.println("Thread B starting to acquire resource " + resource);
            resource.lock(); // 线程B尝试锁定资源
            System.out.println("Thread B successfully acquired resource " + resource);
            Thread.sleep(2000); // 模拟长时间操作，防止死锁的发生
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            try {
                if (resource.isLocked()) { // 确认资源是否已被其他线程锁定
                    System.out.println("Thread B detected that resource " + resource + " is still locked by another thread.");
                    resource.unlock(); // 解锁资源，释放其他线程等待的锁
                    }
                else {
                    System.out.println("Resource " + resource + " was already unlocked by another thread.");
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        System.out.println("Thread B ending.");
    }
}
// 创建两个互斥资源
Resource resource1 = new Resource();
Resource resource2 = new Resource();
// 启动两个线程，分别尝试获取资源
new ThreadA(resource1).start();
new ThreadB(resource2).start();