线程死锁条件#

死锁是如何发生的，如何避免死锁？

当线程A持有独占锁a，并尝试去获取独占锁b的同时，线程B持有独占锁b，并尝试获取独占锁a的情况下，就会发生AB两个线程由于互相持有对方需要的锁，而发生的阻塞现象，我们称为死锁。

1
public class DeadLockDemo {
2

3
    public static void main(String[] args) {
4
        // 线程a
5
        Thread td1 = new Thread(new Runnable() {
6
            public void run() {
7
                DeadLockDemo.method1();
8
            }
9
        });
10
        // 线程b
11
        Thread td2 = new Thread(new Runnable() {
12
            public void run() {
13
                DeadLockDemo.method2();
14
            }
15
        });
16

17
        td1.start();
18
        td2.start();
19
    }
20

21
    public static void method1() {
22
        synchronized (String.class) {
23
            try {
24
                Thread.sleep(2000);
25
            } catch (InterruptedException e) {
26
                e.printStackTrace();
27
            }
28
            System.out.println("线程a尝试获取integer.class");
29
            synchronized (Integer.class) {
30

31
            }
32
        }
33
    }
34

35
    public static void method2() {
36
        synchronized (Integer.class) {
37
            try {
38
                Thread.sleep(2000);
39
            } catch (InterruptedException e) {
40
                e.printStackTrace();
41
            }
42
            System.out.println("线程b尝试获取String.class");
43
            synchronized (String.class) {
44

45
            }
46
        }
47
    }
48
}

造成死锁的四个条件：

互斥条件：一个资源每次只能被一个线程使用。
请求与保持条件：一个线程因请求资源而阻塞时，对已获得的资源保持不放。
不剥夺条件：线程已获得的资源，在未使用完之前，不能强行剥夺。
循环等待条件：若干线程之间形成一种头尾相接的循环等待资源关系。

在并发程序中，避免了逻辑中出现数个线程互相持有对方线程所需要的独占锁的的情况，就可以避免死锁，如下所示：

1
public class BreakDeadLockDemo {
2

3
    public static void main(String[] args) {
4
        // 线程a
5
        Thread td1 = new Thread(new Runnable() {
6
            public void run() {
7
                DeadLockDemo2.method1();
8
            }
9
        });
10
        // 线程b
11
        Thread td2 = new Thread(new Runnable() {
12
            public void run() {
13
                DeadLockDemo2.method2();
14
            }
15
        });
16

17
        td1.start();
18
        td2.start();
19
    }
20

21
    public static void method1() {
22
        synchronized (String.class) {
23
            try {
24
                Thread.sleep(2000);
25
            } catch (InterruptedException e) {
26
                e.printStackTrace();
27
            }
28
            System.out.println("线程a尝试获取integer.class");
29
            synchronized (Integer.class) {
30
                System.out.println("线程a获取到integer.class");
31
            }
32

33
        }
34
    }
35

36
    public static void method2() {
37
        // 不再获取线程a需要的Integer.class锁。
38
        synchronized (String.class) {
39
            try {
40
                Thread.sleep(2000);
41
            } catch (InterruptedException e) {
42
                e.printStackTrace();
43
            }
44
            System.out.println("线程b尝试获取Integer.class");
45
            synchronized (Integer.class) {
46
                System.out.println("线程b获取到Integer.class");
47
            }
48
        }
49
    }
50
}

线程死锁条件

作者

强人自传

发布于

2023-02-04

许可协议

CC BY-NC-SA 4.0

Android 签名机制 v1、v2、v3

原子操作类了解多少？

1

线程死锁条件