java死锁代码示例

原创admin 分类：热门问答 2024-04-20 17:05:58 0

java死锁代码示例
在软件开发中，多线程编程是一种常见的实践，它允许程序同时执行多个任务，从而提高效率。然而，多线程也引入了一种潜在的问题——死锁。死锁是指两个或多个进程在执行过程中，因争夺资源而造成的一种僵局，若无外力作用，这些进程将无法向前推进。

死锁的定义通常包含四个必要条件：互斥条件、占有并等待条件、不可剥夺条件和循环等待条件。理解这些条件对于识别和避免死锁至关重要。

死锁的核心类与方法

在Java中，死锁通常涉及到synchronized关键字、ReentrantLock类以及java.util.concurrent.locks.Lock接口。这些工具用于同步线程对共享资源的访问，不当的使用可能导致死锁。

死锁的使用场景

死锁可能发生在任何需要同步多个资源的场合。例如，在数据库事务处理、文件系统操作、网络编程等场景中，如果资源分配不当，就可能发生死锁。

死锁代码案例

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

示例1：使用synchronized关键字

public class DeadlockExample1 {
    private static final Object resource1 = new Object();
    private static final Object resource2 = new Object();

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (resource1) {
                System.out.println("Thread 1: Locked resource 1");
                try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); }
                synchronized (resource2) {
                    System.out.println("Thread 1: Locked resource 2");
                }
            }
        }).start();

        new Thread(() -> {
            synchronized (resource2) {
                System.out.println("Thread 2: Locked resource 2");
                try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); }
                synchronized (resource1) {
                    System.out.println("Thread 2: Locked resource 1");
                }
            }
        }).start();
    }
}

示例2：使用ReentrantLock

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class DeadlockExample2 {
    private static final Lock resource1 = new ReentrantLock();
    private static final Lock resource2 = new ReentrantLock();

    public static void main(String[] args) {
        new Thread(() -> {
            resource1.lock();
            try {
                System.out.println("Thread 1: Locked resource 1");
                Thread.sleep(100);
                resource2.lock();
                System.out.println("Thread 1: Locked resource 2");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                resource1.unlock();
                resource2.unlock();
            }
        }).start();

        new Thread(() -> {
            resource2.lock();
            try {
                System.out.println("Thread 2: Locked resource 2");
                Thread.sleep(100);
                resource1.lock();
                System.out.println("Thread 2: Locked resource 1");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                resource2.unlock();
                resource1.unlock();
            }
        }).start();
    }
}

死锁的对比表格

以下是两个示例的对比表格：

特性/示例	示例1 (synchronized)	示例2 (ReentrantLock)
锁机制	隐式锁	显示锁
可中断性	不支持	支持
公平性	无公平性保证	可配置公平性
条件变量	不直接支持	通过Condition支持

问题	回答
什么是死锁？	死锁是两个或多个进程在执行过程中，因争夺资源而造成的一种僵局。
如何避免死锁？	避免死锁的策略包括：避免嵌套锁、使用锁超时、使用顺序锁等。
`synchronized`和`ReentrantLock`有什么区别？	`synchronized`是隐式锁，而`ReentrantLock`是显示锁，后者提供了更多灵活性，如可中断性、公平性等。