java多线程死锁及解决

原创admin 分类：热门问答 2024-05-04 19:59:22 0

java多线程死锁及解决
在软件开发中，多线程编程是一种常见的提高程序性能的方式。然而，多线程环境下的死锁问题，却是一个让开发者头疼的问题。死锁是指两个或多个进程在执行过程中，因争夺资源而造成的一种僵局，若无外力作用，这些进程将无法向前推进。

死锁的发生需要满足四个条件：互斥条件、占有和等待条件、不可剥夺条件以及循环等待条件。这四个条件缺一不可，只有当它们同时满足时，死锁才会发生。

死锁与饥饿的区别

死锁与饥饿是多线程编程中的两个常见问题，它们有相似之处，但也有明显的区别。死锁是指多个线程因为争夺资源而陷入僵局，而饥饿则是指某个线程长时间得不到资源，导致无法执行。

死锁通常涉及到多个线程，它们互相等待对方释放资源，而饥饿则可能是由于线程的优先级低或者资源分配策略不当导致的单一线程问题。在解决策略上，死锁需要通过避免四个死锁条件的满足来解决，而饥饿则需要通过优化资源分配策略来解决。

核心类与方法

在Java中，处理死锁问题时，通常会涉及到以下核心类与方法：

Thread 类：用于创建和管理线程。
synchronized 关键字：用于实现同步，防止多个线程同时访问共享资源。
wait() 方法：线程等待某个条件成立时调用此方法，释放锁。
notify() 方法：唤醒等待的线程。
notifyAll() 方法：唤醒所有等待的线程。

使用场景

死锁通常发生在以下场景：

资源分配：线程A持有资源1，线程B持有资源2，它们互相等待对方释放资源。
共享资源访问：多个线程需要按特定顺序访问共享资源，否则可能发生死锁。

代码案例

以下是两个简单的死锁案例及解决方案：

案例一：资源分配死锁

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("Thread1 locked resource1");
                try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); }
                synchronized (resource2) {
                    System.out.println("Thread1 locked resource2");
                }
            }
        }).start();

        new Thread(() -> {
            synchronized (resource2) {
                System.out.println("Thread2 locked resource2");
                try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); }
                synchronized (resource1) {
                    System.out.println("Thread2 locked resource1");
                }
            }
        }).start();
    }
}

解决方法：确保资源分配顺序一致

// 所有线程都按照相同的顺序锁定资源

案例二：共享资源访问死锁

public class DeadlockExample2 {
    public static void main(String[] args) {
        final Object lock1 = new Object();
        final Object lock2 = new Object();

        Thread t1 = new Thread(() -> {
            synchronized (lock1) {
                System.out.println("Thread 1 locked lock1");
                try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); }
                synchronized (lock2) {
                    System.out.println("Thread 1 locked lock2");
                }
            }
        });

        Thread t2 = new Thread(() -> {
            synchronized (lock2) {
                System.out.println("Thread 2 locked lock2");
                try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); }
                synchronized (lock1) {
                    System.out.println("Thread 2 locked lock1");
                }
            }
        });

        t1.start();
        t2.start();
    }
}

解决方法：使用锁顺序或锁超时

// 使用tryLock尝试获取锁，并设置超时时间

死锁条件	解决方法
互斥条件	不适用，是死锁的基础条件
占有和等待	一次性锁定所有资源或按顺序锁定资源
不可剥夺	允许可剥夺资源，即线程可以释放已占有的资源
循环等待	确保资源的有序分配，避免循环条件