Java多线程并发中常见的死锁案例

原创亦凉 2024-11-06 10:33 26阅读 0赞

在Java多线程并发编程中，死锁是指两个或多个线程在执行过程中，因争夺资源而造成的一种僵局，导致这些线程无法继续执行下去。以下是一些常见的死锁案例：

1. **资源分配不当**：
-两个线程分别请求两个不同的资源，但请求的顺序不同，导致互相等待对方释放资源。

```java public class DeadlockExample {
 private static final Object resource1 = new Object();
 private static final Object resource2 = new Object();

public static void main(String[] args) {
Thread t1 = new Thread(() -> {
 synchronized (resource1) {
 try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
 }
 synchronized (resource2) {
 System.out.println("Thread1 acquired both resources");
 }
 }
 });

Thread t2 = new Thread(() -> {
 synchronized (resource2) {
 try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
 }
 synchronized (resource1) {
 System.out.println("Thread2 acquired both resources");
 }
 }
 });

t1.start();
t2.start();
 }
 }
 ```2. **嵌套同步块**：
-一个线程在持有一个锁的同时尝试获取另一个锁，而另一个线程也持有另一个锁并尝试获取第一个锁。

```java public class NestedDeadlockExample {
 private static final Object outer = new Object();
 private static final Object inner = new Object();

public static void main(String[] args) {
Thread t1 = new Thread(() -> {
 synchronized (outer) {
 System.out.println("Thread1: outer lock acquired");
 synchronized (inner) {
 System.out.println("Thread1: inner lock acquired");
 }
 }
 });

Thread t2 = new Thread(() -> {
 synchronized (inner) {
 System.out.println("Thread2: inner lock acquired");
 synchronized (outer) {
 System.out.println("Thread2: outer lock acquired");
 }
 }
 });

t1.start();
t2.start();
 }
 }
 ```3. **继承导致的死锁**：
-子类覆盖了父类的方法，并且在方法中获取了父类已经持有的锁。

```java public class Parent {
 public void parentMethod() {
 synchronized (this) {
 System.out.println("Parent method");
 }
 }
 }

public class Child extends Parent {
 public void childMethod() {
 synchronized (this) {
 System.out.println("Child method");
 parentMethod();
 }
 }
 }

public class InheritanceDeadlockExample {
 public static void main(String[] args) {
Child child = new Child();
Thread t1 = new Thread(child::childMethod);
Thread t2 = new Thread(child::childMethod);
t1.start();
t2.start();
 }
 }
 ```4. **数据库操作中的死锁**：
-两个事务分别锁定了不同的行，然后尝试锁定对方已经锁定的行。

```java//假设有两个线程分别执行以下SQL语句// Thread1: SELECT * FROM table WHERE id =1 FOR UPDATE;
// Thread2: SELECT * FROM table WHERE id =2 FOR UPDATE;
//然后Thread1尝试执行：SELECT * FROM table WHERE id =2 FOR UPDATE;
// Thread2尝试执行：SELECT * FROM table WHERE id =1 FOR UPDATE;
 ```要避免死锁，可以采取以下措施：

-确保所有线程以相同的顺序请求资源。
- 使用`tryLock()`方法尝试获取锁，而不是无限期地等待。
-限制持有锁的时间，尽快释放锁。
- 使用一个全局的锁管理器来管理所有资源的锁定和释放。
-避免嵌套同步块，或者确保嵌套顺序一致。
- 使用数据库事务时，确保所有事务以相同的顺序访问资源。