Java并发问题：线程同步死锁示例

原创 客官°小女子只卖身不卖艺 2024-10-24 14:48 134阅读 0赞

在Java中，线程同步和死锁是两个重要的并发概念。下面是一个简单的死锁示例：

```java
// 定义资源（锁）
Lock lock1 = new ReentrantLock();
Lock lock2 = new ReentrantLock();

// 两个线程，各自获取一个锁
Thread thread1 = new Thread(() -> {
try {
// 获取lock1
lock1.lock();
System.out.println(“Thread 1 locked resource 1”);

  1.     // 延迟释放lock1，以便等待资源2
  2.     Thread.sleep(500);
  4.     // 获取lock2
  5.     lock2.lock();
  6.     System.out.println("Thread 1 locked resource 2");
  8. } catch (InterruptedException e) {
  9.     e.printStackTrace();
  10. } finally {
  11.     // 无论是否成功获取资源，都需要释放锁
  12.     try {
  13.         lock1.unlock();
  14.         lock2.unlock();
  15.     } catch (Exception e) {
  16.         e.printStackTrace();
  17.     }
  18. }

}));
Thread thread2 = new Thread(() -> {
try {
// 获取lock2
lock2.lock();
System.out.println(“Thread 2 locked resource 2”);

  1.     // 延迟释放lock2，以便等待资源1
  2.     Thread.sleep(500);
  4.     // 获取lock1
  5.     lock1.lock();
  6.     System.out.println("Thread 2 locked resource 1");
  8. } catch (InterruptedException e) {
  9.     e.printStackTrace();
  10. } finally {
  11.     // 无论是否成功获取资源，都需要释放锁
  12.     try {
  13.         lock1.unlock();
  14.         lock2.unlock();
  15.     } catch (Exception e) {
  16.         e.printStackTrace();
  17.     }
  18. }

}));

// 启动线程
thread1.start();
thread2.start();

// 注意这里可能会发生死锁，因为两个线程都试图先获取资源2再获取资源1。
// 如果资源2的获得依赖于资源1的拥有，而资源1的获得又依赖于资源2的拥有，
// 这就形成了”环状等待”，即每个线程都在等待对方释放资源，从而导致死锁。

在实际编程中，要避免这种情况的发生，通常需要使用一些线程同步机制，如synchronized关键字、Lock接口等。

文章版权声明：注明蒲公英云原创文章，转载或复制请以超链接形式并注明出处。

发表评论

表情：
评论列表 （有 0 条评论，134人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Java线程同步问题：死锁示例

    Java中的死锁是指两个或多个线程在执行过程中，因争夺资源而造成的一种僵局，导致这些线程无法继续执行下去。死锁发生时，每个线程都在等待其他线程释放资源，但因为没有线程愿意释放资

    - 日理万妓- 日理万妓/ 0 赞/ 114 阅读

    相关 线程同步问题：死锁示例

    死锁是多线程编程中的一个关键概念，它发生在两个或更多的线程互相等待对方释放资源时的一种僵局状态。 下面是一个经典的银行家系统（Banker's Algorithm）的死锁示例

    青旅半醒青旅半醒/ 0 赞/ 155 阅读