java死锁的简单例子

原创admin 分类：热门问答 2024-04-16 18:59:35 0

java死锁的简单例子
在多线程编程中，死锁是一个常见的问题，它会导致程序无法继续执行。今天，我将通过两个简单的Java代码示例来讲解死锁的概念、产生条件以及如何避免和解决死锁。

Java死锁的基本概念

在Java中，死锁通常发生在多个线程同时尝试获取对方持有的资源时。如果每个线程都在等待对方释放资源而自己又不释放已持有的资源，那么就会形成一个循环等待的状态，导致所有线程都无法继续执行。这种情况下，没有任何一个线程能够继续执行下去，形成了死锁。

死锁的产生条件

要产生死锁，必须同时满足以下四个条件：

互斥：至少有一个资源被且只能被一个线程持有。
占有并等待：线程T1已经获得共享资源X，在等待获取共享资源Y的同时，它不会释放已经占有的共享资源X。
不可抢占：线程不能抢占其他线程已经占有的共享资源。
循环等待：存在一组线程，它们都在等待同一个资源，而这个资源又正在被另外一些线程所持有。

代码案例分析

示例一：简单的死锁示例

public class SimpleDeadlock {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();

    public void method1() {
        synchronized (lock1) {
            System.out.println("Method 1 acquired lock1");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Method 1 releasing lock1");
            lock1.notifyAll(); // 方法1释放了lock1锁
        }
    }

    public void method2() {
        synchronized (lock2) {
            System.out.println("Method 2 acquired lock2");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System对比表t.out.println("Method 2 releasing lock2");
            lock2.notifyAll(); // 方法2释放了lock2锁
        }
    }

    public static void main(String[] args) {
        SimpleDeadlock example = new SimpleDeadlock();
        new Thread(() -> example.method1()).start();
        new Thread(() -> example.method2()).start();
    }
}

在这个例子中，method1和method2分别持有lock1和lock2两个锁。当两个线程同时运行时，它们会陷入等待对方释放锁的状态，从而导致死锁。

示例二：顺序死锁示例

public class OrderDeadlock {
    private final Object right = new Object();
    private final Object left = new Object();

    public void method1() {
        synchronized (right) {
            System.out.println("Method 1 acquired right");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Method 1 releasing right");
            right.notifyAll(); // 方法1释放了right锁
        }
    }

    public void method2() {
        synchronized (left) {
            System.out.println("Method 2 acquired left");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Method 2 releasing left");
            left.notifyAll(); // 方法2释放了left锁
        }
    }

    public static void main(String[] args) {
        OrderDeadlock example = new OrderDeadlock();
        new Thread(() -> example.method1()).start();
        new Thread(() -> example.method2()).start();
    }
}

在这个例子中，method1首先获取right锁，然后释放right锁并获取left锁；而method2则相反，先获取left锁，再释放left锁并获取right锁。这样，两个线程在获取对方持有的锁时会陷入等待状态，形成顺序死锁。

解决方案

为了避免死锁，可以采取以下措施：

避免嵌套锁：尽量不要在一个synchronized块内再次使用synchronized关键字。
使用Lock接口：相比于synchronized，Lock提供了更多的灵活性和控制能力，可以通过显式的lock()和unlock()方法来管理锁的获取和释放。
按照相同的顺序获取锁：确保所有线程都按照相同的顺序获取锁，这样可以避免循环等待的情况。
设置超时时间：在等待锁的过程中设置一个

上一篇：java死锁的发生必须满足四个条件

下一篇：java熔断器怎么配置,机制是什么