搞定项目中死锁问题！java项目中常见的死锁与解决办法

最新推荐文章于 2025-06-20 14:00:43 发布
原创 最新推荐文章于 2025-06-20 14:00:43 发布 · 1.9k 阅读 · 19 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言 #后端 #spring boot #sql #spring cloud

前言

       工作与日常开发中，事务对数据进行在增删查改（CRUD）操作难免会出现死锁情况，单体应用项目需要找出死锁原因还是比较容易，很多小伙伴在搭建复杂的微服务项目调用的时候经常出现死锁情况，微服务调用排查比较困难，需要把业务熟悉做好逻辑梳理排查问题更得心应手。数据库的死锁通常是由于多个数据库操作相互竞争锁资源，导致系统无法继续执行的情况。死锁发生的典型场景是两个或更多的事务在并发执行时，互相等待对方释放锁，最终导致每个事务都无法继续执行。博主经常遇到类似的问题，希望下面的这篇文章给您带来收获与解决意识。

一、死锁的概念：

1、死锁的原因

死锁是指两个或多个线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法继续前进。在Java多线程编程中，死锁通常发生在以下几种情况：

  1. 互斥条件：至少有一个资源必须处于非共享模式，即一次只有一个线程能使用资源。
  2. 占有并等待：一个线程至少持有一个资源，并等待另一个资源，而该资源为其他线程所持有。
  3. 非抢占式（不可剥夺）：资源不能被抢占，即资源只能被线程显式地释放。
  4. 循环等待：存在一种线程资源的循环等待链，每个线程持有一个线程在下一个环节中所
    在这里插入图片描述

2、死锁的常见原因

  1. 事务中的多个查询和更新操作（行级锁竞争）。
  2. 长时间持有锁，导致其他事务无法执行。
  3. 不同事务以不同的顺序获取锁（例如先获取锁A，再获取锁B，而另一个事务则先获取锁B，再获取锁A）。

3、在增删查改（CRUD）操作中，死锁可能发生在以下几种情况下：

  1. 两个或更多事务竞争对数据库的资源（如行锁、表锁等）。
  2. 事务顺序错误或并发控制不当。

二、死锁代码示例场景

1、死锁发生场景

假设我们有一个简单的库存管理系统，包含两个表：products 和 orders。两个用户（线程）同时尝试更新库存数量和创建订单，可能会导致死锁。

  • 表结构
CREATE TABLE products (
    id INT PRIMARY KEY,
    name VARCHAR(255),
    stock INT
);

CREATE TABLE orders (
    id INT PRIMARY KEY AUTO_INCREMENT,
    product_id INT,
    quantity INT,
    FOREIGN KEY (product_id) REFERENCES products(id)
);
  • 案例代码

1.第一个事务：

@Service
public class InventoryService1 {

    @Autowired
    private ProductRepository productRepository;

    @Autowired
    private OrderRepository orderRepository;

    @Transactional
    public void placeOrder(int productId, int quantity) {
        Product product = productRepository.findById(productId).orElseThrow(() -> new RuntimeException("Product not found"));
        if (product.getStock() < quantity) {
            throw new RuntimeException("Insufficient stock");
        }

        // 更新库存
        product.setStock(product.getStock() - quantity);
        productRepository.saveOrUpdate(product);

        // 创建订单
        Order order = new Order();
        order.setProductId(productId);
        order.setQuantity(quantity);
        orderRepository.save(order);

        System.out.println("Order placed successfully");
    }
}

2.第二个事务：

@Service
public class InventoryService2 {

    @Autowired
    private ProductRepository productRepository;

    @Autowired
    private OrderRepository orderRepository;

    @Transactional
    public void placeOrder(int productId, int quantity) {

         // 创建订单
        Order order = new Order();
        order.setProductId(productId);
        order.setQuantity(quantity);
        orderRepository.save(order);
        
        Product product = productRepository.findById(productId).orElseThrow(() -> new RuntimeException("Product not found"));
        if (product.getStock() < quantity) {
            throw new RuntimeException("Insufficient stock");
        }

        // 更新库存
        product.setStock(product.getStock() - quantity);
        productRepository.saveOrUpdate(product);

        System.out.println("Order placed successfully");
    }
}

在上面的两个事务中：

  1. 事务1 先更新 product表（获得product表锁），然后尝试插入数据到 order表。
  2. 事务2 先更新 order表（获得order表锁），然后尝试更新 Product表。

如果两个事务同时运行，它们可能会互相等待对方释放锁：

  • 事务1 拿到了 product表的锁，但在更新 order表时，需要等待事务2 释放 order表的锁。
  • 事务2 拿到了 order表的锁，但在更新 product表时，需要等待事务1 释放 product表的锁。

由于它们互相等待对方释放锁，导致了死锁。

2、死锁的检测

数据库一般会在检测到死锁时自动回滚一个事务，以解除死锁。例如，MySQL 的 InnoDB 存储引擎会自动检测死锁，并回滚其中一个事务，以便其他事务能够继续执行。死锁会通过日志记录，开发人员可以查看日志来诊断问题。

3、死锁解决方法

  1. 统一锁获取顺序：确保多个事务获取锁的顺序一致。比如，始终按照 products表 -> order表的顺序获取锁，这样可以避免交叉锁竞争。
  2. 减少事务的持有锁的时间：尽量减少事务中持有锁的时间，比如尽量避免长时间的数据库查询和业务逻辑处理。
  3. 使用悲观锁（Pessimistic Locking）：对于可能导致死锁的场景，使用悲观锁来避免并发冲突。可以通过 FOR UPTATE 子句在 SQL 查询中显式地锁住行。
  4. 使用乐观锁（Optimistic Locking）：如果业务场景允许，可以使用乐观锁机制，避免事务之间的相互依赖。乐观锁常常通过版本号或者时间戳来管理并发。

三、死锁解决方法代码示例

1、通过统一锁获取顺序来避免死锁：

@Service
public class InventoryService1 {

    @Autowired
    private ProductRepository productRepository;

    @Autowired
    private OrderRepository orderRepository;

    @Transactional
    public void placeOrder(int productId, int quantity) {
        Product product = productRepository.findById(productId).orElseThrow(() -> new RuntimeException("Product not found"));
        if (product.getStock() < quantity) {
            throw new RuntimeException("Insufficient stock");
        }

        // 更新库存
        product.setStock(product.getStock() - quantity);
        productRepository.saveOrUpdate(product);

        // 创建订单
        Order order = new Order();
        order.setProductId(productId);
        order.setQuantity(quantity);
        orderRepository.save(order);

        System.out.println("Order placed successfully");
    }
}

@Service
public class InventoryService2 {

    @Autowired
    private ProductRepository productRepository;

    @Autowired
    private OrderRepository orderRepository;

    @Transactional
    public void placeOrder(int productId, int quantity) {
        Product product = productRepository.findById(productId).orElseThrow(() -> new RuntimeException("Product not found"));
        if (product.getStock() < quantity) {
            throw new RuntimeException("Insufficient stock");
        }

        // 更新库存
        product.setStock(product.getStock() - quantity);
        productRepository.saveOrUpdate(product);

        // 创建订单
        Order order = new Order();
        order.setProductId(productId);
        order.setQuantity(quantity);
        orderRepository.save(order);

        System.out.println("Order placed successfully");
    }
}

2、设置事务超时时间

在数据库配置中设置事务的超时时间，当事务等待超过指定时间后自动回滚，避免长时间等待导致系统资源浪费。

spring:
  jpa:
    properties:
      hibernate:
        transaction:
          timeout: 30 # 设置事务超时时间为30秒

3、使用悲观锁

通过使用悲观锁，我们可以确保每个事务在对数据进行操作时会显式地锁定行，防止其他事务同时操作这些数据。例如，使用 FOR UPDATE 锁定某一行：使用 SELECT … FOR UPDATE 显式加锁

@Transactional
public void placeOrder(int productId, int quantity) {
    // 使用 SELECT ... FOR UPDATE 显式加锁
    Product product = productRepository.findForUpdate(productId);
    if (product.getStock() < quantity) {
        throw new RuntimeException("Insufficient stock");
    }

    // 更新库存
    product.setStock(product.getStock() - quantity);
    productRepository.saveOrUpdate(product);

    // 创建订单
    Order order = new Order();
    order.setProductId(productId);
    order.setQuantity(quantity);
    orderRepository.save(order);

    System.out.println("Order placed successfully");
}

4、使用乐观锁

乐观锁是一种并发控制机制，它假设冲突不常发生，因此不会主动加锁，而是在提交时检查是否有冲突。如果发生冲突，则重试事务。通过这种方式，如果两个事务尝试并发修改相同的用户数据，后提交的事务会因版本号冲突而失败，从而避免死锁。

  1. 数据库表结构：
@Entity
public class Product {
    @Id
    private int id;
    private String name;
    private int stock;

    @Version
    private int version; // 添加版本字段用于乐观锁

    // getters and setters
}
  1. 更新时检查版本号：
@Transactional
public void placeOrder(int productId, int quantity) {
    try {
        // 读取数据时同时获取版本号
        Product product = productRepository.findById(productId).orElseThrow(() -> new RuntimeException("Product not found"));
        if (product.getStock() < quantity) {
            throw new RuntimeException("Insufficient stock");
        }
        // 执行业务逻辑时，检查版本号是否一致

        // 更新库存
        product.setStock(product.getStock() - quantity);
        //productRepository.save(product);
        int updatedRows = jdbcTemplate.update(
            "UPDATE product SET stock = product.getStock() - quantity, version = version + 1 WHERE id = ? AND version = ?",
            product.getId(), product.getVersion()
        );

        if (updatedRows == 0) {
            throw new OptimisticLockException("Version mismatch, transaction aborted");
        }

        // 创建订单
        Order order = new Order();
        order.setProductId(productId);
        order.setQuantity(quantity);
        orderRepository.save(order);

        System.out.println("Order placed successfully");
    } catch (OptimisticLockException e) {
        // 处理乐观锁异常，重试事务
        System.out.println("Concurrency conflict detected, retrying...");
        placeOrder(productId, quantity);
    }
}

四、总结

       以上可以在很大程度上避免数据库死锁的发生，确保系统的稳定性和高效性。具体选择哪种方法取决于项目的实际需求和业务逻辑。建议结合多种策略，综合考虑性能、并发性和可靠性。

古桐树
关注
java线程与死锁问题，讲的太详细太好懂了，再也不用怕了
csdn681的博客
04-24 318
线程介绍 线程（Thread）是程序运行的执行单元，依托于进程存在。一个进程中可以包含多个线程，多线程可以共享一块内存空间和一组系统资源，因此线程之间的切换更加节省资源、更加轻量化，因而也被称为轻量级的进程。 什么是进程 进程（Processes）是程序的一次动态执行，是系统进行资源分配和调度的基本单位，是操作系统运行的基础，通常每一个进程都拥有自己独立的内存空间和系统资源。简单来说，进程可...
Java线程安全五步破解：死锁、竞态、饥饿？看这招！
java专栏
06-20 680
🔥关注墨瑾轩，带你探索编程的奥秘！🚀🔥超萌技术攻略，轻松晋级编程高手🚀🔥技术宝库已备好，就等你来挖掘🚀🔥订阅墨瑾轩，智趣学习不孤单🚀🔥即刻启航，编程之旅更有趣🚀。
Java中死锁产生的原因及解决方法
m0_49622667的博客
04-20 8756
一、什么是死锁 死锁就是指两个或两个以上的线程在执行过程中，由于竞争资源或者由于彼此通信而造成的现象，若无外力作用，他们都无法推进下去。 简单来说就是A和B若同时都有一个资源，在此之外还想拥有对方的资源，由于资源如果在某个人手里，其他人就无法获得，所以变成了你不让我，我不让你，就僵持下了。 下面我们来看下具体代码： public class CreateDeadThread { public static void main(String[] args) throws InterruptedExce
Java源码房门终于被打开了（解决死锁的方法）.rar
11-01
Java源码房门终于被打开了（解决死锁的方法）.rar
Java死锁的原因及解决方法
最新发布
泡^泡
06-20 287
Java死锁分析及解决方案 死锁是指多线程环境下，线程因互相等待资源而永久阻塞的现象。Java死锁形成需要满足四个必要条件：互斥条件、占有且等待、不可抢占和循环等待。典型表现为两个线程互相持有对方需要的锁，如示例代码所示。检测死锁可用jstack、VisualVM等工具。解决方案包括： 固定锁获取顺序 使用tryLock()设置超时机制 减小锁粒度 避免锁嵌套调用 采用并发集合类。通过合理设计锁策略，可以有效预防死锁发生。
java 死锁及解决
乐在其中/Leo在其中
08-19 597
Java线程死锁如何避免这一悲剧  Java线程死锁需要如何解决，这个问题一直在我们不断的使用中需要只有不断的关键。不幸的是，使用上锁会带来其他问题。让我们来看一些常见问题以及相应的解决方法： 　　Java线程死锁 　　Java线程死锁是一个经典的多线程问题，因为不同的线程都在等待那些根本不可能被释放的锁，从而导致所有的工作都无法完成。假设有两个线程，分别代表两个饥饿的人，他们必须共享刀叉并轮...
Java中的死锁及其解决方案
weixin_45936627的博客
03-01 7457
Java中的死锁相关问题，不同方式手写死锁及其解决方案
java程序死锁怎么办
weixin_35750953的博客
12-22 713
Java程序死锁是指两个或多个线程在互相等待对方释放所占有的资源的情况。这样就造成了一种僵局，导致程序无法继续执行下去。 解决Java程序死锁的方法有以下几种： 使用jstack工具检测死锁 使用jstack工具可以检测出程序中的死锁情况，并打印出死锁的线程堆栈信息。这可以帮助我们了解死锁的原因，从而找出解决方案。 避免资源竞争 如果可以的话，可以尽量避免在程序中使用多个锁。如果必须使用多...
【Java并发编程实战】（五）：死锁问题
少侠露飞的学习笔记
04-01 535
一不小心就死锁了，可咋整？
24、java 多线程之三：线程的死锁(详细案例)、Lock锁解决线程安全(方式三)、线程通信(生产者/消费者问题)、实现 Callable 接口创建线程(方式三)、使用线程池创建线程(方式四)
狮子座的男孩
12-24 1497
2都被释放后)，再执行第一个线程的结果;都被释放后)，再执行第二个线程的结果;的情况，因此在线程同步的情况下可能。)正在被主线程使用并未被释放，因此。，否则该程序将会一直执行下去;，这是该程序最常遇到的情况，// 项目输出信息如下，并。的同步监视器(即：锁)是。的同步监视器(即：锁)是。的同步监视器(即：锁)是。的同步监视器(即：锁)是。// 该线程是生成前。
Java技术类校招面试题汇总：mysql批量insert死锁
m0_57066131的博客
07-07 1475
面试题模块介绍： 一、Java 基础 JDK 和 JRE 有什么区别？ == 和 equals 的区别是什么？ 两个对象的 hashCode()相同，则 equals()也一定为 true，对吗？ final 在 java 中有什么作用？ java 中的 Math.round(-1.5) 等于多少？ String 属于基础的数据类型吗？ java 中操作字符串都有哪些类？它们之间有什么区别？ String str="i"与 String str=new String(“i”)一样吗？ 如何将字符串反转？
java 门锁终于被打开了（解决死锁）
06-21
java 门锁终于被打开了（解决死锁） java 门锁终于被打开了（解决死锁）
java中常见的死锁以及解决方法代码
08-26
主要介绍了java中常见的死锁以及解决方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2024 Java面试宝典合集
05-20
8. **12万字 java 面经总结**：这是一份详尽的面试经验汇总，涵盖了大量实际面试中可能出现的问题，包括但不限于Java性能优化、设计模式、JVM调优、数据库操作、分布式系统等。 9. **头条java面试题**：这个可能是...
java 线程死锁问题_Java 线程死锁的问题解决办法
weixin_35997546的博客
02-13 156
Java 线程死锁的问题解决办法【线程死锁】原因：两个线程相互等待被对方锁定的资源代码模拟：public class DeadLock {public static void main(String[] args) {Object obj = new Object();Object obj1 = new Object();DeadLockThread1 D1 = new DeadLockThrea...
Java中各种死锁详细讲述及其解决方案（图文并茂，浅显易懂
2301_79058522的博客
04-08 1801
由于细节内容实在太多了，为了不影响文章的观赏性，只截出了一部分知识点大致的介绍一下，每个小节点里面都有更细化的内容！小编准备了一份Java进阶学习路线图（Xmind）以及来年金三银四必备的一份《Java面试必备指南》《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！[外链图片转存中…(img-0i6oPdYo-1712587614815)][外链图片转存中…(img-2gMTCjNx-1712587614815)]
Java中遇到死锁该怎么办
CatchLight的博客
12-15 598
死锁（Deadlock）是指两个或多个线程因争夺资源而造成的一种互相等待的状态。如果没有外部干预，死锁线程将永远无法继续执行。线程1持有资源A，试图获取资源B。线程2持有资源B，试图获取资源A。两个线程互相等待对方释放资源，导致程序无法前进。死锁是多线程编程中一个常见且危险的问题。在实际开发中，理解其发生的原因和条件非常重要。通过合理设计锁的使用、规范资源获取顺序以及利用Java并发工具，可以有效避免死锁的发生。同时，利用Java的监控工具可以帮助快速检测和定位死锁问题。
Java 死锁及解决方案
mengxianglong123的博客
03-13 332
死锁的概念 “死锁”指的是： 多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能进行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。 因此， 某一个同步块需要同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题。下面案例中，“化妆线程”需要同时拥有“镜子对象”、“口红对象”才能运行同步块。那么，实际运行时，“小丫的化妆线...
解决Java中的死锁问题的技术方案
微赚开发者技术分享博客
07-07 364
合理设计和使用锁机制，以及采取预防和处理策略，有助于减少甚至避免死锁问题的发生，提高多线程程序的健壮性和稳定性。在这个例子中，两个线程分别持有不同的锁，并试图获取对方已持有的锁，从而导致死锁的发生。死锁是指两个或多个线程在执行过程中，因争夺资源而造成的一种互相等待的现象，导致所有参与的线程都无法继续执行下去。：实现死锁检测机制，当检测到死锁时，采取措施进行恢复，比如中断某些线程，回滚操作，重新获取资源等。：统一资源管理，尽量减少锁的持有时间，降低锁粒度，或者使用更高级别的同步工具，如。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值