Java多线程编程中的死锁现象实例-蒲公英云

Java多线程编程中的死锁现象实例

原创旧城等待， 2024-11-29 16:12 31阅读 0赞

死锁是多线程编程中的一种严重问题，当两个或更多线程因争夺资源而造成的一种相互等待的现象时，就会发生死锁。

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

// 线程1需要资源A和资源B
class Thread1 extends Thread {
    private Object resourceA;
    private Object resourceB;
    public Thread1(Object resourceA, Object resourceB) {
        this.resourceA = resourceA;
        this.resourceB = resourceB;
    }
    @Override
    public void run() {
        synchronized (resourceA) {
            synchronized (resourceB) {
                System.out.println("Thread 1: Acquiring resources...");
                // 这里模拟资源的获取，可能会阻塞
                try {
                    Thread.sleep(2000); // 模拟耗时操作
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 1: Resources acquired, waiting for resourceB...");
                // 这里再次模拟资源的等待，可能会阻塞
                try {
                    Thread.sleep(2000); // 模拟耗时操作
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 1: ResourceB acquired, acquiring resourceA...");
                // 此处可能会导致资源A和资源B的循环等待，即死锁
                synchronized (resourceB) {
                    synchronized (resourceA) {
                        System.out.println("Thread 1: Resources acquired and released.");
                    }
                }
            }
        }
    }
}
// 线程2需要资源A和资源C
class Thread2 extends Thread {
    private Object resourceA;
    private Object resourceC;
    public Thread2(Object resourceA, Object resourceC) {
        this.resourceA = resourceA;
        this.resourceC = resourceC;
    }
    @Override
    public void run() {
        synchronized (resourceA) {
            synchronized (resourceC) {
                System.out.println("Thread 2: Acquiring resources...");
                // 这里模拟资源的获取，可能会阻塞
                try {
                    Thread.sleep(2000); // 模拟耗时操作
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 2: Resources acquired, waiting for resourceC...");
                // 这里再次模拟资源的等待，可能会阻塞
                try {
                    Thread.sleep(2000); // 模拟耗时操作
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 2: ResourceC acquired, acquiring resourceA...");
                // 此处可能会导致资源A和资源C的循环等待，即死锁
                synchronized (resourceC) {
                    synchronized (resourceA) {
                        System.out.println("Thread 2: Resources acquired and released.");
                    }
                }
            }
        }
    }
}
// 启动线程
Thread1 thread1 = new Thread1(new Object(), new Object()));
thread1.start();
Thread2 thread2 = new Thread2(new Object(), new Object()));
thread2.start();