S12L22 - 多线程中的死锁

html

理解 deadlock 在 multithreading 中：全面指南
目录

介绍 ................................................................................... 1
什么是 deadlock？ ...................................................................... 3

2.1 定义 .................................................................................. 3
2.2 现实世界的类比 .................................................................... 4


deadlock 的原因 ....................................................................... 6

3.1 资源占用 ........................................................................ 6
3.2 互斥排他 ........................................................................ 7
3.3 无抢占 ............................................................................ 8
3.4 循环等待 ............................................................................ 9


重现 deadlock 场景 .................................................. 11

4.1 设置环境 .................................................... 11
4.2 理解代码 ................................................................ 13
4.3 执行并观察 deadlock ......................................... 16


防止 deadlock ......................................................................... 19

5.1 可重入锁 ......................................................................... 19
5.2 尝试锁 ................................................................................... 21


结论 ........................................................................................ 24


介绍
在 multithreading 领域，高效管理资源对确保应用程序性能顺畅且无错误至关重要。开发人员遇到的最臭名昭著的问题之一是 deadlock。deadlock 可能使应用程序停滞不前，导致其无响应并难以调试。
本指南深入探讨了 multithreaded applications 中 deadlock 的概念，清晰阐述了 deadlock 的定义、发生方式及预防策略。无论您是刚涉足 multithreading 的初学者，还是希望巩固基础知识的开发人员，这份全面的指南都能满足您的需求。
涵盖的关键点：

deadlock 的定义及现实世界的类比
导致 deadlock 的常见原因
使用 Java 逐步重现 deadlock 场景
代码分析及详细解释
在您的应用程序中避免 deadlock 的预防技术

理解 deadlock 不仅有助于编写高效的代码，还能确保您的应用程序稳健可靠。

什么是 deadlock？
2.1 定义
一个 deadlock 是 multithreaded application 中的一种特定条件，其中两个或多个线程永久阻塞，彼此等待对方释放资源。简单来说，这是一种僵局情况，线程被卡住，因为每个线程都持有另一个线程需要继续进行的资源。
2.2 现实世界的类比
想象一下两个朋友，Alice 和 Bob，他们试图使用两个共享资源：一支笔和一本笔记本。

Alice 首先拿起 pen。
Bob 首先拿起 notebook。
现在，Alice 需要使用 notebook 继续，但 Bob 占有它。
同时，Bob 需要 pen 继续，但 Alice 占有它。

他们都无法继续，导致了一个 deadlock。
这个情景说明了在没有适当同步的情况下，互相占有资源如何可能无限期地停止进展。

deadlock 的原因
理解 deadlock 的根本原因对于防止应用程序中发生 deadlock 至关重要。发生 deadlock 时必须同时满足四个主要条件：
3.1 资源占用
一个线程至少持有一个资源，并且正在等待获取当前被其他线程占用的额外资源。
3.2 互斥排他
至少有一个资源必须以不可共享的模式持有。任何时刻只有一个线程可以使用该资源。
3.3 无抢占
资源不能从持有它们的线程中被强制移除，直到资源被完全使用。
3.4 循环等待
一组线程在循环链中相互等待，每个线程持有下一个线程在等待的资源。

重现 deadlock 场景
为了实际掌握 deadlock 的概念，让我们通过一个故意创建 deadlock 情况的 Java 示例来进行说明。
4.1 设置环境
我们将创建一个简单的 Java 应用程序，该程序会生成两个线程，每个线程试图以相反的顺序获取两个锁，导致 deadlock。
分步指南：

创建两个锁：

        



		
		
			
			
Java
			
			String lock1 = "lock1";
String lock2 = "lock2";
			
				
					
				
					1
2
				
						String lock1 = "lock1";
String lock2 = "lock2";
					
				
			
		


    
初始化两个线程：

        



		
		
			
			
Java
			
			Thread thread1 = new Thread(new Runnable() {
    public void run() {
        synchronized(lock1) {
            System.out.println("Thread1: Holding lock1...");
            try { Thread.sleep(100); } catch (InterruptedException e) {}
            System.out.println("Thread1: Waiting for lock2...");
            synchronized(lock2) {
                System.out.println("Thread1: Holding lock1 & lock2...");
            }
        }
    }
});

Thread thread2 = new Thread(new Runnable() {
    public void run() {
        synchronized(lock2) {
            System.out.println("Thread2: Holding lock2...");
            try { Thread.sleep(100); } catch (InterruptedException e) {}
            System.out.println("Thread2: Waiting for lock1...");
            synchronized(lock1) {
                System.out.println("Thread2: Holding lock2 & lock1...");
            }
        }
    }
});
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
				
						Thread thread1 = new Thread(new Runnable() {
    public void run() {
        synchronized(lock1) {
            System.out.println("Thread1: Holding lock1...");
            try { Thread.sleep(100); } catch (InterruptedException e) {}
            System.out.println("Thread1: Waiting for lock2...");
            synchronized(lock2) {
                System.out.println("Thread1: Holding lock1 & lock2...");
            }
        }
    }
});
 
Thread thread2 = new Thread(new Runnable() {
    public void run() {
        synchronized(lock2) {
            System.out.println("Thread2: Holding lock2...");
            try { Thread.sleep(100); } catch (InterruptedException e) {}
            System.out.println("Thread2: Waiting for lock1...");
            synchronized(lock1) {
                System.out.println("Thread2: Holding lock2 & lock1...");
            }
        }
    }
});
					
				
			
		


    
启动线程：

        



		
		
			
			
Java
			
			thread1.start();
thread2.start();
thread1.join();
thread2.join();
System.out.println("Main thread finished.");
			
				
					
				
					1
2
3
4
5
				
						thread1.start();
thread2.start();
thread1.join();
thread2.join();
System.out.println("Main thread finished.");
					
				
			
		


    

4.2 理解代码
让我们分解代码中的动作：

锁的创建：

        



		
		
			
			
Java
			
			String lock1 = "lock1";
String lock2 = "lock2";
			
				
					
				
					1
2
				
						String lock1 = "lock1";
String lock2 = "lock2";
					
				
			
		


两个字符串对象被用作锁。在 Java 中，任何对象都可以作为同步的锁。

线程1 执行：

        



		
		
			
			
Java
			
			synchronized(lock1) {
    System.out.println("Thread1: Holding lock1...");
    try { Thread.sleep(100); } catch (InterruptedException e) {}
    System.out.println("Thread1: Waiting for lock2...");
    synchronized(lock2) {
        System.out.println("Thread1: Holding lock1 & lock2...");
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
				
						synchronized(lock1) {
    System.out.println("Thread1: Holding lock1...");
    try { Thread.sleep(100); } catch (InterruptedException e) {}
    System.out.println("Thread1: Waiting for lock2...");
    synchronized(lock2) {
        System.out.println("Thread1: Holding lock1 & lock2...");
    }
}
					
				
			
		



获取 lock1
休眠 100ms 来模拟一些处理时间
尝试获取 lock2


线程2 执行：

        



		
		
			
			
Java
			
			synchronized(lock2) {
    System.out.println("Thread2: Holding lock2...");
    try { Thread.sleep(100); } catch (InterruptedException e) {}
    System.out.println("Thread2: Waiting for lock1...");
    synchronized(lock1) {
        System.out.println("Thread2: Holding lock2 & lock1...");
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
				
						synchronized(lock2) {
    System.out.println("Thread2: Holding lock2...");
    try { Thread.sleep(100); } catch (InterruptedException e) {}
    System.out.println("Thread2: Waiting for lock1...");
    synchronized(lock1) {
        System.out.println("Thread2: Holding lock2 & lock1...");
    }
}
					
				
			
		



获取 lock2
休眠 100ms
尝试获取 lock1



4.3 执行并观察 deadlock
当您运行上述程序时，会发生以下事件序列：

Thread1 启动并获取 lock1
Thread2 启动并获取 lock2
Thread1 尝试获取 lock2 但被阻塞，因为 Thread2 持有它
Thread2 尝试获取 lock1 但被阻塞，因为 Thread1 持有它
两个线程无限期等待，导致一个 deadlock

示例输出：




		
		
			
			
Java
			
			Thread1: Holding lock1...
Thread2: Holding lock2...
Thread1: Waiting for lock2...
Thread2: Waiting for lock1...
			
				
					
				
					1
2
3
4
				
						Thread1: Holding lock1...
Thread2: Holding lock2...
Thread1: Waiting for lock2...
Thread2: Waiting for lock1...
					
				
			
		


程序在此时挂起，表明发生了 deadlock。

防止 deadlock
虽然 deadlock 是一个重大问题，但有几种策略可以帮助在 multithreaded applications 中防止它们。
5.1 可重入锁
ReentrantLock 允许一个线程重新获取它已经持有的锁。这种灵活性可以通过允许线程重新获取锁而不被阻塞，来帮助防止 deadlock。
示例：




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

ReentrantLock lock1 = new ReentrantLock();
ReentrantLock lock2 = new ReentrantLock();

Thread thread1 = new Thread(() -> {
    lock1.lock();
    try {
        System.out.println("Thread1: Holding lock1...");
        Thread.sleep(100);
        lock2.lock();
        try {
            System.out.println("Thread1: Holding lock1 & lock2...");
        } finally {
            lock2.unlock();
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        lock1.unlock();
    }
});

Thread thread2 = new Thread(() -> {
    lock2.lock();
    try {
        System.out.println("Thread2: Holding lock2...");
        Thread.sleep(100);
        lock1.lock();
        try {
            System.out.println("Thread2: Holding lock2 & lock1...");
        } finally {
            lock1.unlock();
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        lock2.unlock();
    }
});

thread1.start();
thread2.start();
thread1.join();
thread2.join();
System.out.println("Main thread finished.");
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
				
						import java.util.concurrent.locks.ReentrantLock;
 
ReentrantLock lock1 = new ReentrantLock();
ReentrantLock lock2 = new ReentrantLock();
 
Thread thread1 = new Thread(() -> {
    lock1.lock();
    try {
        System.out.println("Thread1: Holding lock1...");
        Thread.sleep(100);
        lock2.lock();
        try {
            System.out.println("Thread1: Holding lock1 & lock2...");
        } finally {
            lock2.unlock();
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        lock1.unlock();
    }
});
 
Thread thread2 = new Thread(() -> {
    lock2.lock();
    try {
        System.out.println("Thread2: Holding lock2...");
        Thread.sleep(100);
        lock1.lock();
        try {
            System.out.println("Thread2: Holding lock2 & lock1...");
        } finally {
            lock1.unlock();
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        lock2.unlock();
    }
});
 
thread1.start();
thread2.start();
thread1.join();
thread2.join();
System.out.println("Main thread finished.");
					
				
			
		


解释：

ReentrantLock 允许同一线程多次获取同一个锁。
在 finally 块中正确释放锁，确保即使发生异常也能释放锁。
虽然这并不能本质上防止 deadlock，但它在锁管理方面提供了更多的灵活性。

5.2 尝试锁
使用带有超时的 tryLock() 可以帮助防止线程无限期地等待锁，从而避免 deadlock。
示例：




		
		
			
			
Java
			
			import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.TimeUnit;

ReentrantLock lock1 = new ReentrantLock();
ReentrantLock lock2 = new ReentrantLock();

Thread thread1 = new Thread(() -> {
    try {
        if(lock1.tryLock(1000, TimeUnit.MILLISECONDS)) {
            try {
                System.out.println("Thread1: Holding lock1...");
                Thread.sleep(100);
                if(lock2.tryLock(1000, TimeUnit.MILLISECONDS)) {
                    try {
                        System.out.println("Thread1: Holding lock1 & lock2...");
                    } finally {
                        lock2.unlock();
                    }
                } else {
                    System.out.println("Thread1: Could not acquire lock2.");
                }
            } finally {
                lock1.unlock();
            }
        } else {
            System.out.println("Thread1: Could not acquire lock1.");
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});

Thread thread2 = new Thread(() -> {
    try {
        if(lock2.tryLock(1000, TimeUnit.MILLISECONDS)) {
            try {
                System.out.println("Thread2: Holding lock2...");
                Thread.sleep(100);
                if(lock1.tryLock(1000, TimeUnit.MILLISECONDS)) {
                    try {
                        System.out.println("Thread2: Holding lock2 & lock1...");
                    } finally {
                        lock1.unlock();
                    }
                } else {
                    System.out.println("Thread2: Could not acquire lock1.");
                }
            } finally {
                lock2.unlock();
            }
        } else {
            System.out.println("Thread2: Could not acquire lock2.");
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});

thread1.start();
thread2.start();
thread1.join();
thread2.join();
System.out.println("Main thread finished.");
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
				
						import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.TimeUnit;
 
ReentrantLock lock1 = new ReentrantLock();
ReentrantLock lock2 = new ReentrantLock();
 
Thread thread1 = new Thread(() -> {
    try {
        if(lock1.tryLock(1000, TimeUnit.MILLISECONDS)) {
            try {
                System.out.println("Thread1: Holding lock1...");
                Thread.sleep(100);
                if(lock2.tryLock(1000, TimeUnit.MILLISECONDS)) {
                    try {
                        System.out.println("Thread1: Holding lock1 & lock2...");
                    } finally {
                        lock2.unlock();
                    }
                } else {
                    System.out.println("Thread1: Could not acquire lock2.");
                }
            } finally {
                lock1.unlock();
            }
        } else {
            System.out.println("Thread1: Could not acquire lock1.");
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});
 
Thread thread2 = new Thread(() -> {
    try {
        if(lock2.tryLock(1000, TimeUnit.MILLISECONDS)) {
            try {
                System.out.println("Thread2: Holding lock2...");
                Thread.sleep(100);
                if(lock1.tryLock(1000, TimeUnit.MILLISECONDS)) {
                    try {
                        System.out.println("Thread2: Holding lock2 & lock1...");
                    } finally {
                        lock1.unlock();
                    }
                } else {
                    System.out.println("Thread2: Could not acquire lock1.");
                }
            } finally {
                lock2.unlock();
            }
        } else {
            System.out.println("Thread2: Could not acquire lock2.");
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});
 
thread1.start();
thread2.start();
thread1.join();
thread2.join();
System.out.println("Main thread finished.");
					
				
			
		


解释：

tryLock(long timeout, TimeUnit unit): 尝试在指定的超时时间内获取锁。
如果线程无法在超时时间内获取锁，它可以优雅地处理这种情况，而不是无限期地等待。
这种方法通过防止线程被永久卡住，降低了发生 deadlock 的可能性。


结论
deadlock 是 multithreaded applications 中普遍存在的问题，导致程序无响应和调试困难的情况。通过理解 deadlock 的 原因 并实施 预防策略，如 ReentrantLocks 和 tryLock()，开发人员可以创建更稳健和可靠的应用程序。
关键要点：

Deadlock 定义： 线程永久阻塞的状态，每个线程都在等待被其他线程持有的资源。
原因： 资源占用、互斥排他、无抢占和循环等待。
预防技术： 使用 ReentrantLocks，实施带有超时的 tryLock，设计锁获取顺序。
实际影响： 适当的同步对防止 deadlock 至关重要，确保高效的资源管理和应用程序稳定性。

通过采用这些实践，您可以最小化应用程序中发生 deadlock 的风险，从而实现更顺畅和更高效的 multithreaded operations。
SEO 关键词： deadlock, multithreading, threads, synchronization, ReentrantLock, tryLock, Java deadlock example, preventing deadlocks, deadlock causes, resource management, concurrent programming, thread synchronization, multithreaded application, deadlock prevention strategies
注意： 本文由 AI 生成。