Java并发编程：死锁的实例分析

原创迷南。 2024-10-06 20:15 64阅读 0赞

死锁是并发编程中的一种严重问题，它发生在两个或更多进程互相等待对方释放资源时。以下是一个简单的Java死锁实例：

```java
// 定义两个线程，它们都需要互斥的资源

class Resource {
    private boolean acquired;

Resource() {
        acquired = false;
    }

void acquire() {
        if (!acquired) {
            acquired = true;
        } else {
            // 如果资源已经获得，但线程仍尝试获取，
            // 将进入死锁状态
            System.out.println("Resource acquisition failure, deadlock detected.");
        }
    }

void release() {
        if (acquired) {
            acquired = false;
            System.out.println("Resource released.");
        } else {
            // 如果资源没有获得，但线程仍然尝试释放，
            // 将进入死锁状态
            System.out.println("Resource is not acquired, deadlock detected.");
        }
    }
}

class ThreadA extends Thread {
    Resource resource;

ThreadA(Resource r) {
        resource = r;
    }

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

// 在这里进行一些耗时的操作，比如模拟计算

// 线程A完成操作后释放资源
            resource.release();
        } catch (Exception e) {
            System.out.println("Error in Thread A: " + e.getMessage());
        }
    }
}

class ThreadB extends Thread {
    Resource resource;

ThreadB(Resource r) {
        resource = r;
    }

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

// 在这里进行一些耗时的操作，比如模拟计算

// 无论线程A是否完成操作，线程B都会释放资源
            resource.release();
        } catch (Exception e) {
            System.out.println("Error in Thread B: " + e.getMessage());
        }
    }
}

// 创建资源对象，并启动两个线程
Resource resource = new Resource();
ThreadA threadA = new ThreadA(resource);
ThreadB threadB = new ThreadB(resource);

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

```

这个例子中，线程A和线程B互相等待对方释放资源，结果形成了死锁。