如何在 Java 中避免线程死锁

2024年9月10日 | 11 分钟阅读

线程死锁是多线程 Java 程序中可能出现的一个常见问题。当两个或两个以上的线程因互相等待对方释放资源而无法继续运行时，就会发生死锁。以下是一些避免 Java 中线程死锁的方法：

按一致的顺序获取锁： 如果多个线程需要获取多个对象的锁，请确保它们始终以相同的顺序获取锁。这可以避免一种情况：一个线程持有另一个线程所需的锁，而第一个线程却持有第二个线程需要释放的锁。
及时释放锁： 当线程完成对共享资源的使用后，应尽快释放相关联的锁。这允许其他线程获取锁并继续执行。
使用超时： 获取锁时，可以指定一个超时时间。如果在指定时间内无法获取锁，线程可以释放锁并稍后重试。
使用单个锁： 如果可能，使用一个锁来保护多个资源。为了避免死锁，这确保了一次只有一个线程可以访问这些资源。
使用线程安全类： 与其实现自己的同步机制，不如使用 Java API 提供的线程安全类。这些类已经过设计和测试，可以正确处理多线程。
避免嵌套锁： 避免以嵌套方式获取多个对象的锁。这可能导致死锁，增加两个或多个线程以不同顺序获取锁的可能性。

如何在 Java 程序中避免线程死锁

要避免 Java 程序中的线程死锁，您可以遵循以下最佳实践：

1. 避免嵌套同步块

多个线程试图访问同一资源，其中一个线程正在等待另一个线程释放它，这可能导致死锁。为了避免这种情况，您应该避免嵌套同步块。

嵌套同步块发生在线程以嵌套方式获取多个锁时。这会导致死锁，因为等待锁的线程最终可能会等待另一个线程持有的锁。

文件名： DeadlockExample.java

// Java program to create a deadlock by creating two threads
// and each thread trying to acquire a lock of both locks
public class DeadlockExample {
static Object lock1 = new Object(); // Create object for lock1
static Object lock2 = new Object(); // Create object for lock2
public static void main(String[] args) {
// Create the first thread
Thread t1 = new Thread(new Runnable() {
public void run() {
synchronized (lock1) {
System.out.println("Thread 1: Holding lock 1...");
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread 1: Waiting for lock 2...");
synchronized (lock2) {
System.out.println("Thread 1: Holding lock 1 & 2...");
}
}
}
});
  // Create a second thread
  Thread t2 = new Thread(new Runnable() {
     public void run() {
        synchronized (lock2) {
           System.out.println("Thread 2: Holding lock 2...");
           try {
              Thread.sleep(10);
           } catch (InterruptedException e) {
              e.printStackTrace();
           }
           System.out.println("Thread 2: Waiting for lock 1...");
           synchronized (lock1) {
              System.out.println("Thread 2: Holding lock 1 & 2...");
           }
        }
     }
  });
  // Start both threads
  t1.start();
  t2.start();
}
}

输出

Thread 1: Holding lock 1...
Thread 2: Holding lock 2...
Thread 2: Waiting for lock 1...
Thread 1: Waiting for lock 2...

解释： 在示例中，线程 1 和线程 2 都试图获取 lock1 和 lock2，但它们获取的顺序不同。死锁是指两个线程卡住，等待对方释放它们需要的锁。为了避免死锁，建议尽可能避免嵌套同步块。

2. 按一致的顺序获取锁

当多个线程访问共享资源时，请确保每个线程都以一致的方式获取锁。这将防止死锁发生。

这意味着，如果多个线程访问共享资源，它们应该始终以相同的顺序获取锁。这有助于防止死锁的发生。

文件名： DeadlockAvoidanceExample.java

// A class to demonstrate deadlock avoidance in Java
public class DeadlockAvoidanceExample {
static Object lock1 = new Object(); // Create the first lock
static Object lock2 = new Object(); // Create the second lock
public static void main(String[] args) {
// Create the first thread
Thread t1 = new Thread(new Runnable() {
public void run() {
synchronized (lock1) { // Acquire lock1
System.out.println("Thread 1: Holding lock 1...");
try {
Thread.sleep(10); // Pause for 10 milliseconds
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread 1: Waiting for lock 2...");
synchronized (lock2) { // Acquire lock2
System.out.println("Thread 1: Holding lock 1 & 2...");
}
}
}
});
  // Create the second thread
  Thread t2 = new Thread(new Runnable() {
     public void run() {
        synchronized (lock1) { // Acquire lock1
           System.out.println("Thread 2: Holding lock 1...");
           try {
              Thread.sleep(10); // Pause for 10 milliseconds
           } catch (InterruptedException e) {
              e.printStackTrace();
           }
           System.out.println("Thread 2: Waiting for lock 2...");
           synchronized (lock2) { // Acquire lock2
              System.out.println("Thread 2: Holding lock 1 & 2...");
           }
        }
     }
  });
  
  t1.start(); // Start the first thread
  t2.start(); // Start the second thread
}
}

输出

Thread 1: Holding lock 1...
Thread 1: Waiting for lock 2...
Thread 1: Holding lock 1 & 2...
Thread 2: Holding lock 1...
Thread 2: Waiting for lock 2...
Thread 2: Holding lock 1 & 2...

解释： 在此示例中，线程 1 在获取 lock2 之前先获取 lock1。它们永远不会陷入死锁，因为它们以相同的顺序获取锁。这是获取锁的顺序一致如何帮助防止 Java 程序中发生死锁的一个示例。

3. 避免无限期等待锁

线程不应无限期地等待锁。相反，为锁设置超时时间，以便如果锁未及时获取，线程可以继续执行。

要避免无限期等待锁，您可以使用 `java.util.concurrent.locks.ReentrantLock` 类的 `tryLock()` 方法。 `tryLock()` 方法尝试获取锁，但如果无法获取则立即返回。这允许您防止线程无限期地等待锁。

文件名： DeadlockAvoidanceExample3.java

import java.util.concurrent.locks.ReentrantLock;
public class DeadlockAvoidanceExample3 {
static ReentrantLock lock1 = new ReentrantLock();
static ReentrantLock lock2 = new ReentrantLock();
public static void main(String[] args) {
Thread t1 = new Thread(new Runnable() {
public void run() {
boolean lock1Acquired = lock1.tryLock(); // Attempt to acquire lock1
if (!lock1Acquired) { // If unable to acquire lock1, return
System.out.println("Thread 1: Unable to acquire lock 1");
return;
}
System.out.println("Thread 1: Holding lock 1...");
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread 1: Waiting for lock 2...");
boolean lock2Acquired = lock2.tryLock(); // Attempt to acquire lock2
if (!lock2Acquired) { // If unable to acquire lock2, release lock1 and return
System.out.println("Thread 1: Unable to acquire lock 2");
lock1.unlock();
return;
}
System.out.println("Thread 1: Holding lock 1 & 2...");
lock2.unlock(); // Release lock2
lock1.unlock(); // Release lock1
}
});
  Thread t2 = new Thread(new Runnable() {
     public void run() {
        boolean lock2Acquired = lock2.tryLock(); // Attempt to acquire lock2
        if (!lock2Acquired) { // If unable to acquire lock2, return
           System.out.println("Thread 2: Unable to acquire lock 2");
           return;
        }
        System.out.println("Thread 2: Holding lock 2...");
        try {
           Thread.sleep(10);
        } catch (InterruptedException e) {
           e.printStackTrace();
        }
        System.out.println("Thread 2: Waiting for lock 1...");
        boolean lock1Acquired = lock1.tryLock(); // Attempt to acquire lock1
        if (!lock1Acquired) { // If unable to acquire lock1, release lock2 and return
           System.out.println("Thread 2: Unable to acquire lock 1");
           lock2.unlock();
           return;
        }
        System.out.println("Thread 2: Holding lock 1 & 2...");
        lock1.unlock(); // Release lock1
        lock2.unlock(); // Release lock2
     }
  });
  t1.start();
  t2.start();
}
}

输出

Thread 1: Holding lock 1...
Thread 2: Holding lock 2...
Thread 1: Waiting for lock 2...
Thread 1: Unable to acquire lock 2
Thread 2: Waiting for lock 1...
Thread 2: Holding lock 1 & 2...

解释： 在此示例中，我们使用 `tryLock()` 方法来尝试获取锁。如果无法获取锁，该方法会立即结束，线程会继续执行其他任务。这有助于避免无限期等待锁，并有助于防止 Java 程序中发生死锁。

4. 使用可重入锁

可重入锁可以以无死锁的方式控制对资源的访问。它们允许单个线程多次锁定资源，这有助于避免死锁。

可重入锁是一种特殊的锁，它允许同一个线程多次获取锁。这意味着一个线程可以获取锁，释放它，然后再次获取它，而不会导致死锁。这在避免复杂的、多线程应用程序中的死锁时非常有用。

文件名： DeadlockAvoidanceExample4

// Importing ReentrantLock class from Java.util.concurrent.locks package
import java.util.concurrent.locks.ReentrantLock;

public class DeadlockAvoidanceExample4 {
// Creating two ReentrantLock objects lock1 and lock2
static ReentrantLock lock1 = new ReentrantLock();
static ReentrantLock lock2 = new ReentrantLock();

public static void main(String[] args) {
// Creating and starting Thread t1
Thread t1 = new Thread(new Runnable() {
public void run() {
lock1.lock();
System.out.println("Thread 1: Holding lock 1...");
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread 1: Waiting for lock 2...");
lock2.lock();
System.out.println("Thread 1: Holding lock 1 & 2...");
lock2.unlock();
lock1.unlock();
}
});
  // Creating and starting Thread t2
  Thread t2 = new Thread(new Runnable() {
     public void run() {
        lock2.lock();
        System.out.println("Thread 2: Holding lock 2...");
        try {
           Thread.sleep(10);
        } catch (InterruptedException e) {
           e.printStackTrace();
        }
        System.out.println("Thread 2: Waiting for lock 1...");
        lock1.lock();
        System.out.println("Thread 2: Holding lock 1 & 2...");
        lock1.unlock();
        lock2.unlock();
     }
  });

  // Starting both threads
  t1.start();
  t2.start();
}
}}

输出

Thread 1: Holding lock 1...
Thread 2: Holding lock 2...
Thread 1: Waiting for lock 2...
Thread 2: Waiting for lock 1...

解释： 在示例中，我们使用可重入锁来锁定和解锁资源。同一个线程可以多次获取和释放锁，使其成为复杂、多线程应用程序的理想解决方案。这有助于防止 Java 程序中发生死锁。

5. 使用 Executor Services

Java 提供了一个内置的 Executor Service，可用于管理线程执行。您可以使用此服务来管理任务的执行，并确保它们无死锁地执行。

Executor Services 是管理 Java 程序中多个线程的一种方式。它允许您通过将任务提交给执行器来在后台执行任务。然后，执行器决定应使用哪个线程来执行任务。这有助于简化多个线程的管理，并通过重用现有线程来提高性能。

文件名： DeadlockAvoidanceExample5

// import necessary classes
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class DeadlockAvoidanceExample5 {
public static void main(String[] args) {
// create a thread pool with two threads
ExecutorService executorService = Executors.newFixedThreadPool(2);
  // define tasks to be executed by threads
  Runnable task1 = new Runnable() {
     public void run() {
        System.out.println("Thread 1: Running task 1...");
     }
  };
  Runnable task2 = new Runnable() {
     public void run() {
        System.out.println("Thread 2: Running task 2...");
     }
  };
  // submit tasks to the executor service for execution
  executorService.submit(task1);
  executorService.submit(task2);  
  // shutdown the executor service when all tasks are completed
  executorService.shutdown();
}
}

输出

Thread 1: Running task 1...
Thread 2: Running task 2...

解释： 在示例中，我们使用 Executor Service 来管理多个任务的执行。 Executor Service 使用固定数量的线程池来执行任务，从而降低了死锁的风险。这使得管理多个线程更加容易，并有助于避免 Java 程序中的死锁。

6. 监控您的代码

定期监控代码中的死锁。如果发生死锁，您应尽快识别并解决它，以避免性能问题和应用程序延迟。

监控代码是监视程序行为并识别潜在死锁的过程。这可以通过记录线程的状态以及使用分析器等工具来监视程序的行为来完成。

文件名： DeadlockAvoidanceExample6

// Example code to demonstrate avoiding deadlock in Java using synchronized blocks and objects
public class DeadlockAvoidanceExample6 {
public static void main(String[] args) {
// Create two locks as objects
Object lock1 = new Object();
Object lock2 = new Object();
  // Create thread t1
  Thread t1 = new Thread(new Runnable() {
     public void run() {
        // Acquire lock1
        synchronized (lock1) {
           System.out.println("Thread 1: Holding lock 1...");
           try {
              Thread.sleep(10);
           } catch (InterruptedException e) {
              e.printStackTrace();
           }
           System.out.println("Thread 1: Waiting for lock 2...");
           // Acquire lock2
           synchronized (lock2) {
              System.out.println("Thread 1: Holding lock 1 & 2...");
           }
       }
     }
  });
  // Create thread t2
  Thread t2 = new Thread(new Runnable() {
     public void run() {
        // Acquire lock2
        synchronized (lock2) {
           System.out.println("Thread 2: Holding lock 2...");
           try {
              Thread.sleep(10);
           } catch (InterruptedException e) {
              e.printStackTrace();
           }
           System.out.println("Thread 2: Waiting for lock 1...");
           // Acquire lock1
           synchronized (lock1) {
              System.out.println("Thread 2: Holding lock 1 & 2...");
           }
        }
     }
  });
  // Start both threads
  t1.start();
  t2.start();
}
}

输出

Thread 1: Holding lock 1...
Thread 2: Holding lock 2...
Thread 1: Waiting for lock 2...
Thread 2: Waiting for lock 1...

解释： 在示例中，我们记录每个线程的状态，以帮助识别任何潜在的死锁。这可以帮助您了解程序的行为，并在问题变得关键之前识别潜在问题。此外，您还可以使用分析器来监视程序的行为并识别可能导致死锁的性能问题。通过监控代码并使用工具来帮助识别潜在死锁，您可以确保您的 Java 程序顺利运行并避免死锁。

7. 避免循环依赖

如果多个线程相互依赖，它们可能会陷入循环死锁。为了避免这种情况，您应该避免循环依赖，并确保线程之间的依赖关系是明确定义的。

当两个或多个对象以产生循环的方式相互依赖时，可能会发生循环依赖。这可能导致死锁，因为每个对象都等待另一个对象释放所需的资源。为了避免循环依赖，在设计程序时防止这些依赖关系形成非常重要。

文件名： DeadlockAvoidanceExample7

// It program demonstrates a simple example of avoiding deadlock in Java using synchronized blocks and locking objects
// Two threads are created that synchronize on two different objects in the opposite order, thereby avoiding any potential deadlock
public class DeadlockAvoidanceExample7 {
public static void main(String[] args) {
// Create two objects to be used as locks
final Object lock1 = new Object();
final Object lock2 = new Object();
  // Create the first thread that synchronizes on lock1, then lock2
  Thread t1 = new Thread(new Runnable() {
     public void run() {
        synchronized (lock1) {
           System.out.println("Thread 1: Holding lock 1...");
           try {
              Thread.sleep(10);
           } catch (InterruptedException e) {
              e.printStackTrace();
           }
           System.out.println("Thread 1: Waiting for lock 2...");
           synchronized (lock2) {
              System.out.println("Thread 1: Holding lock 1 & 2...");
           }
        }
     }
  });
  // Create a second thread that synchronizes on lock2, then lock1
  Thread t2 = new Thread(new Runnable() {
     public void run() {
        synchronized (lock2) {
           System.out.println("Thread 2: Holding lock 2...");
           try {
              Thread.sleep(10);
           } catch (InterruptedException e) {
              e.printStackTrace();
           }
           System.out.println("Thread 2: Waiting for lock 1...");
           synchronized (lock1) {
              System.out.println("Thread 2: Holding lock 1 & 2...");
           }
        }
     }
  });
  // Start both threads
  t1.start();
  t2.start();
}
}

输出

Thread 2: Holding lock 2...
Thread 1: Holding lock 1...
Thread 1: Waiting for lock 2...
Thread 2: Waiting for lock 1...

解释： 在示例中，我们通过确保每个线程以不同的顺序获取锁来避免循环依赖。这可以防止形成循环，因为每个线程都可以获得所需的锁，而无需等待另一个线程释放它们。通过避免循环依赖，您可以确保您的 Java 程序顺利运行并避免死锁。

下一主题Java 中的方形数组数量

如何在 Java 中避免线程死锁

如何在 Java 程序中避免线程死锁

1. 避免嵌套同步块

2. 按一致的顺序获取锁

3. 避免无限期等待锁

4. 使用可重入锁

5. 使用 Executor Services

6. 监控您的代码

7. 避免循环依赖

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

如何在 Java 中避免线程死锁

如何在 Java 程序中避免线程死锁

1. 避免嵌套同步块

2. 按一致的顺序获取锁

3. 避免无限期等待锁

4. 使用可重入锁

5. 使用 Executor Services

6. 监控您的代码

7. 避免循环依赖

相关帖子

Banking Application in Java

Prim's algorithm Java

Java 中的支付网关集成

Java 中的矩阵中查找最大矩形

Java 中的图像处理 - 创建随机像素图像

Party of Couples Problem in Java

Java assert Keyword

Java 中从数组中删除重复项

Power of a Number in Java

Java 中查找最长公共前缀的最小偏移量

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器