并发写覆盖问题解决方案

最新推荐文章于 2025-05-20 22:23:34 发布
最新推荐文章于 2025-05-20 22:23:34 发布
阅读量1.1k 收藏 7
点赞数 26
文章标签： java mysql 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42080371/article/details/148066456
版权

一、问题描述

在并发环境下，多个请求同时对同一条数据库记录进行写操作时，可能会导致数据覆盖问题（即对同一条数据库记录并发写可能会导致一个请求的数据更新被另外一个请求覆盖）。例如：

  • 请求A读取库存为100
  • 请求B读取库存为100
  • 请求A扣减库存10，更新为90
  • 请求B扣减库存20，更新为80
  • 最终库存为80，而不是预期的70（100-10-20）

本质原因：并发覆写本质是多个请求基于旧值更新，导致后操作覆盖了前操作，解决方案的核心是确保更新操作的原子性或通过锁/版本控制协调并发；

二、解决方案

方案总结

1.增量更新方式

        增量更新是指在更新数据时，仅对字段进行增加或减少操作，而不是直接覆盖字段的值。如：

  • 库存减少：stock = stock - 5
  • 点赞数增加：like_count = like_count + 1

2.悲观锁，如使用select for update 把响应的记录行锁住；

3.乐观锁，如使用版本字段，每次更新时检查该版本字段和读取时是否一致，相同则更新；

方案瓶颈

悲观锁：以电商库存系统为例，大促场景下悲观锁方案会带来大量行锁问题，导致库存行的操作性能非常差，直至不断超时，最终卡住后继链路，并且也会存在影响系统吞吐量问题；

乐观锁：在电商大促场景，大流量下会产生大量的事务回滚，最终也会影响到系统吞吐量；

增量更新（推荐方案）：虽然是推荐方案，但是需要结合业务进行代码处理不能单独使用；

     例如：

  1.  仅适用于数值型字段，增量更新依赖于字段的 可叠加性（如加减操作），因此仅适用于数值型字段（如库存、计数器）。

  2.   无法处理复杂业务逻辑，增量更新是 纯数值操作，无法表达复杂的业务条件（如“库存不能低于0”、“更新前需要校验其他字段”），无法满足业务对库存数据的要求，不能单独使用，需要进行业务层面的代码控制，对于订单占用或者订单扣减是否会存在超额占用或者库存为负的情况，从业务逻辑的角度来看增量更新不能保证。insert on duplicate key update其实是数据库层面做的insertOrUpdate操作，本质也不能解决这个问题，常见的做法是通过批量查询缓存，提高查询性能，然后使用where条件如 where inventory-num>=0 and occupy+num<=inventory来从业务上进行控制；

1. 增量更新方案

1.1 原理（为什么能解决并发写覆盖？）
  • 原子性：UPDATE table SET stock = stock - 5 WHERE id = 1执行数据库操作是原子的（不可拆分），那么即使多个请求同时执行，数据库会按顺序处理，避免中间状态被覆盖。
  • 避免覆盖：增量更新不会直接覆盖字段值，而是基于当前值进行计算，确保每个请求的操作都能叠加生效。

通过SQL直接对数据进行加减操作，避免先读后写的操作方式。

1.2 单机环境实现
@Service
public class InventoryService {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    /**
     * 直接使用SQL进行库存扣减
     * 通过 stock + ? >= 0 确保库存不会出现负数
     */
    public boolean updateStock(Long productId, int quantity) {
        String sql = "UPDATE inventory SET stock = stock + ? WHERE product_id = ? AND stock + ? >= 0";
        int updated = jdbcTemplate.update(sql, -quantity, productId, -quantity);
        return updated > 0;
    }
}
1.3 分布式环境实现
@Service
public class DistributedInventoryService {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    @Autowired
    private RedisTemplate redisTemplate;
    
    /**
     * 分布式环境下的库存更新
     * 1. 更新数据库
     * 2. 删除缓存，采用Cache-Aside模式
     */
    public boolean updateStock(Long productId, int quantity) {
        // 1. 更新数据库
        String sql = "UPDATE inventory SET stock = stock + ? WHERE product_id = ? AND stock + ? >= 0";
        int updated = jdbcTemplate.update(sql, -quantity, productId, -quantity);
        
        if (updated > 0) {
            // 2. 删除缓存
            String cacheKey = "inventory:" + productId;
            redisTemplate.delete(cacheKey);
            return true;
        }
        return false;
    }
    
    /**
     * 查询库存
     * 优先从缓存获取，缓存未命中则从数据库查询并更新缓存
     */
    public Integer getStock(Long productId) {
        String cacheKey = "inventory:" + productId;
        
        // 1. 从缓存获取
        Integer stock = (Integer) redisTemplate.opsForValue().get(cacheKey);
        if (stock != null) {
            return stock;
        }
        
        // 2. 从数据库查询
        String sql = "SELECT stock FROM inventory WHERE product_id = ?";
        stock = jdbcTemplate.queryForObject(sql, Integer.class, productId);
        
        // 3. 更新缓存
        if (stock != null) {
            redisTemplate.opsForValue().set(cacheKey, stock, 1, TimeUnit.HOURS);
        }
        
        return stock;
    }
}

2. 悲观锁方案

2.1 单机环境实现
@Service
public class PessimisticLockService {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    /**
     * 使用SELECT FOR UPDATE锁定行
     * 在事务中执行，确保数据一致性
     */
    @Transactional
    public boolean updateStock(Long productId, int quantity) {
        // 1. 锁定行并查询库存
        String selectSql = "SELECT stock FROM inventory WHERE product_id = ? FOR UPDATE";
        Integer currentStock = jdbcTemplate.queryForObject(selectSql, Integer.class, productId);
        
        if (currentStock < quantity) {
            return false;
        }
        
        // 2. 更新库存
        String updateSql = "UPDATE inventory SET stock = stock - ? WHERE product_id = ?";
        jdbcTemplate.update(updateSql, quantity, productId);
        return true;
    }
}
2.2 分布式环境实现

根据不同的分布式数据库架构，实现方式有所不同：

2.2.1 单数据库实例/数据库集群场景（主从复制）
@Service
public class SingleDBInventoryService {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    /**
     * 使用数据库行锁保证并发安全
     * 适用于单数据库实例或数据库集群场景
     */
    @Transactional
    public boolean updateStock(Long productId, int quantity) {
        // 1. 使用行锁查询库存
        String selectSql = "SELECT stock FROM inventory WHERE product_id = ? FOR UPDATE";
        Integer currentStock = jdbcTemplate.queryForObject(selectSql, Integer.class, productId);
        
        if (currentStock < quantity) {
            return false;
        }
        
        // 2. 更新库存
        String updateSql = "UPDATE inventory SET stock = stock - ? WHERE product_id = ?";
        jdbcTemplate.update(updateSql, quantity, productId);
        return true;
    }
}
2.2.2 分库分表场景
@Service
public class ShardingInventoryService {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    @Autowired
    private RedissonClient redissonClient;
    
    /**
     * 使用分布式锁保证并发安全
     * 适用于分库分表场景
     */
    public boolean updateStock(Long productId, int quantity) {
        // 获取分布式锁
        RLock lock = redissonClient.getLock("inventory:lock:" + productId);
        try {
            // 尝试获取分布式锁
            if (lock.tryLock(5, 10, TimeUnit.SECONDS)) {
                try {
                    // 直接更新库存，不需要行锁
                    String sql = "UPDATE inventory SET stock = stock - ? WHERE product_id = ? AND stock >= ?";
                    int updated = jdbcTemplate.update(sql, quantity, productId, quantity);
                    return updated > 0;
                } finally {
                    lock.unlock();
                }
            }
            return false;
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return false;
        }
    }
}

3. 乐观锁方案

3.1 单机环境实现
@Service
public class OptimisticLockService {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    /**
     * 使用版本号实现乐观锁
     * 更新时检查版本号是否匹配
     */
    public boolean updateStock(Long productId, int quantity, int version) {
        String sql = "UPDATE inventory SET stock = stock - ?, version = version + 1 " +
                    "WHERE product_id = ? AND version = ? AND stock >= ?";
        int updated = jdbcTemplate.update(sql, quantity, productId, version, quantity);
        return updated > 0;
    }
    
    /**
     * 查询库存信息（包含版本号）
     */
    public StockInfo getStockInfo(Long productId) {
        String sql = "SELECT stock, version FROM inventory WHERE product_id = ?";
        return jdbcTemplate.queryForObject(sql, (rs, rowNum) -> 
            new StockInfo(rs.getInt("stock"), rs.getInt("version")), productId);
    }
}
3.2 分布式环境实现

根据不同的分布式数据库架构，实现方式有所不同：

3.2.1 单数据库实例/数据库集群场景
@Service
public class SingleDBOptimisticLockService {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    /**
     * 使用版本号实现乐观锁
     * 适用于单数据库实例或数据库集群场景
     */
    public boolean updateStock(Long productId, int quantity, int version) {
        String sql = "UPDATE inventory SET stock = stock - ?, version = version + 1 " +
                    "WHERE product_id = ? AND version = ? AND stock >= ?";
        int updated = jdbcTemplate.update(sql, quantity, productId, version, quantity);
        return updated > 0;
    }
}
3.2.2 分库分表场景
@Service
public class ShardingOptimisticLockService {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    @Autowired
    private RedissonClient redissonClient;
    
    /**
     * 分库分表场景下的乐观锁实现
     * 使用分布式锁 + 乐观锁
     */
    public boolean updateStock(Long productId, int quantity, int version) {
        RLock lock = redissonClient.getLock("inventory:lock:" + productId);
        try {
            if (lock.tryLock(5, 10, TimeUnit.SECONDS)) {
                try {
                    String sql = "UPDATE inventory SET stock = stock - ?, version = version + 1 " +
                                "WHERE product_id = ? AND version = ? AND stock >= ?";
                    int updated = jdbcTemplate.update(sql, quantity, productId, version, quantity);
                    return updated > 0;
                } finally {
                    lock.unlock();
                }
            }
            return false;
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return false;
        }
    }
}

三、方案对比

1. 增量更新

  • 优点：
    • 实现简单
    • 性能好
    • 无需额外的锁机制
  • 缺点：
    • 只适用于简单的加减操作
    • 不支持复杂的业务逻辑

2. 悲观锁

2.1 单数据库实例/数据库集群
  • 优点：
    • 实现简单
    • 保证数据一致性
    • 适合写多读少的场景
  • 缺点：
    • 并发性能较差
    • 容易造成死锁
    • 锁的粒度较大
2.2 分库分表
  • 优点：
    • 可以跨数据库实例保证并发安全
    • 实现相对简单
  • 缺点：
    • 依赖分布式锁服务
    • 分布式锁可能因为网络问题导致锁失效
    • 系统复杂度增加

3. 乐观锁

  • 优点：
    • 并发性能好
    • 不会产生死锁
    • 适合读多写少的场景
  • 缺点：
    • 实现相对复杂 
    • 需要处理版本冲突
    • 可能出现更新失败需要重试的情况
摩西蒙
关注
高并发解决方案_如何应对高并发，有以下几个解决方案
weixin_39999781的博客
11-26 3032
1.应用和静态资源分离刚开始的时候应用和静态资源是保存在一起的，当并发量达到一定程度的时候就需要将静态资源保存到专门的服务器中，静态资源主要包括图片、视频、js、css和一些资源文件等，这些文件因为没有状态所以分离比较简单，直接存放到响应的服务器就可以了，一般会使用专门的域名去访问。通过不同的域名可以让浏览器直接访问资源服务器而不需要再访问应用服务器了。架构图如下：2.页面缓存页面缓存是将应用生成...
分析MySQL并发下的问题及解决方法
09-09
并发问题的解决方案通常涉及到锁机制和事务管理。以下是对并发问题及解决方法的详细分析： 1. **表锁导致的慢查询问题** 在MySQL中，MyISAM存储引擎在执行查询时会获取表级锁，这可能导致并发性能下降。写操作会...
高并发架构及场景解决方案
qq_62877881的博客
05-06 1333
CQRS(Command Query Responsibility Segregation,命令职责查询分离)一、高并发定义与核心要素定义系统在短时间内处理大量并发请求的能力，目标是确保高负载下稳定高效运行，核心体现为高性能、高可用、可扩展。必要条件高性能：提升并行处理能力，降低响应时间（如优化算法、减少IO）。高可用：系统长期稳定运行，通过冗余、故障转移等机制减少宕机（可用性=正常运行时间/总时间）。可扩展性：通过水平扩容（增加节点）线性提升吞吐量（可扩展性=吞吐量提升比/节点增加比）。
如何解决并发问题
Flying_Fish_roe的博客
11-23 1160
加锁：使用锁机制可以限制同一时间只有一个线程访问共享资源，可以使用互斥锁、读写锁、自旋锁等不同类型的锁来控制并发访问。使用线程池：线程池可以有效控制并发线程的数量，通过设置合适的线程池大小来平衡资源占用和并发性能。使用原子操作：原子操作是不可被中断的操作，保证了操作的完整性，可以避免多个线程同时对同一变量进行修改造成的并发问题。使用并发容器：Java中提供了一些并发容器，如ConcurrentHashMap、ConcurrentLinkedQueue等，它们可以在并发环境下安全地进行读写操作。
并发事务带来的问题及解决方法
喔的嘛呀的博客
07-19 1068
总的来说，并发事务虽然能够提高系统的性能和吞吐量，但也会引入一些问题，需要通过合适的并发控制机制和事务管理策略来解决。数据库管理员和开发人员需要充分了解这些问题，并针对具体应用场景选择合适的解决方案，以确保数据库系统的稳定性和可靠性。
数据库并发问题有那些以及解决办法
m0_50742275的博客
02-24 1045
事务与隔离级别：根据应用需求选择合适的隔离级别，确保数据的一致性和完整性。例如，使用隔离级别可以防止所有并发问题，但会影响性能。乐观锁：适用于读多写少的场景，减少锁定带来的性能损耗。通过版本号或时间戳字段来检测冲突。悲观锁：适用于写操作频繁且冲突可能性大的场景，直接锁定数据防止其他事务修改。使用语句来锁定行。数据库连接池管理：优化连接池配置，提高系统的并发处理能力。确保连接池中的连接及时释放，避免连接耗尽。每种方法都有其适用的场景，开发者需要根据具体业务需求和系统特点灵活选用。
并发编程中存在的问题以及如何解决
m0_74229735的博客
09-05 1366
你已经知道，导致可见性的原因是缓存，导致有序性的原因是编译优化，那解决可见性、有序性最直接的办法就是禁用缓存和编译优化，但是这样问题虽然解决了，我们程序的性能可就堪忧了。合理的方案应该是按需禁用缓存以及编译优化。那么，如何做到“按需禁用”呢？对于并发程序，何时禁用缓存以及编译优化只有程序员知道，那所谓“按需禁用”其实就是指按照程序员的要求来禁用。所以，为了解决可见性和有序性问题，只需要提供给程序员按需禁用缓存和编译优化的方法即可。
如何解决服务器网站高并发问题,如何解决网站高并发访问？ 3大方案
weixin_42131013的博客
08-11 2157
WEB脚本和静态资源的分离。一开始，应用程序脚本和静态资源存储在一起。当并发达到一定程度时，静态资源需要存储在一个特殊的服务器上。静态资源主要包括图片、视频、js、css和一些资源文件等。这些文件很容易分离，因为它们没有状态，所以可以直接存储在响应服务器上，通常使用特殊的域名进行访问。通过不同的域名，浏览器可以直接访问资源服务器，而无需访问应用服务器。2.页面缓存。页面缓存就是缓存应用生成的页面，...
python访问数据库如何解决高并发_MySQL高并发事务问题及解决方案
weixin_39662594的博客
12-04 656
事务的概念事务 可以理解为一个 独立的工作单元, 在这个独立的工作单元中, 有一组操作; 放在事务(独立工作单元)中的多个操作, 要么全部执行成功, 要么全部执行失败。不免俗套, 这还是通过最经典的银行转账应用来解释一下假设有两个角色 'Iron Man'(余额500), 'Wolverine'(余额15), 现在 Iron Man 通过该银行应用给 Wolverine 转账100元, 那么本次转...
常见的高并发解决方案
weixin_50992793的博客
03-03 1009
适用于大规模 key-value 读写，适用于高吞吐的场景。（单个热点 key 失效后，短时间内大量请求打到数据库）（查询一个不存在的 key，导致数据库压力大）（大量缓存同时失效，导致数据库压力暴增）
php中并发读写文件冲突的解决方案
10-26
每种方案都有各自的优缺点，需要根据具体的应用场景和并发量来选择合适的解决方案。例如，如果并发量不是特别大，使用简单的超时时间加锁策略可能就足够了；而如果应用需要处理非常高的并发读写请求，则可能需要考虑...
MySQL中SELECT+UPDATE处理并发更新问题解决方案分享
09-10
本文将深入探讨如何使用`SELECT+UPDATE`策略解决这个问题，并分享两种具体的解决方案。 首先，让我们回顾一下问题的背景。假设我们有一个名为`vip_member`的InnoDB表，用于存储会员信息。会员在续费时，系统需要...
事务并发的可能问题与其解决方案.docx
10-26
并发事务可能会引发多种问题，如更新丢失、脏读、不可重复读和幻读，这些问题都需要通过适当的事务隔离级别和解决方案来处理。 更新丢失分为第一类更新丢失和第二类更新丢失。前者发生在事务撤销时，其对数据的修改...
使用Spring Boot和Spring Security构建安全的RESTful API
intwei的博客
05-17 886
本文详细介绍了如何使用Spring Boot和Spring Security构建安全的RESTful API，并结合JWT实现身份验证与授权。通过实际代码示例，帮助开发者快速上手。完整的项目代码可以在GitHub上找到。
上集：一个前端的血泪复仇记 —— 静态部署的胜利
十步杀一人-千里不留行
05-17 1349
在《上集：一个前端的血泪复仇记 —— 静态部署的胜利》中，作者分享了在部署一个前后端分离的小项目时遇到的挑战和解决方案。项目后端使用Spring Boot，前端使用Next.js。在部署过程中，前端静态资源的处理成为主要难题。作者通过将Next.js生成的静态文件直接放入Spring Boot的static目录，简化了部署流程。然而，Spring Security的默认配置阻止了对这些静态资源的访问，导致403错误。通过调整SecurityConfig和WebConfig，作者成功解决了这一问题。此外，前端
Java 09Stream流与File类
最新发布
asom12的博客
05-20 327
startWith(“张”)
HashSet
weixin_51718998的博客
05-15 937
（1）HashSet的去重机制：hashCode()+equals()，底层先通过存入对象，进行运算得到一个hash值，通过hash值得到对应的索引，如果发现table索引所在的位置，没有数据，就直接存放，如果有数据，就进行equals[遍历]比较，如果比较后，不相同就加入，否则就不加入。在开发中，选择什么集合实现类，主要取决于业务操作特点，然后根据集合实现类特性进行选择，分析如下：1）先判断存储的类型（一组对象[单列]或一组键值对[双列]）map.put("no1","hahaha");
Java大厂求职面试：探讨Spring Boot与微服务架构
linuxjavac6的博客
05-18 728
谢飞机：嗯，Spring Boot和WebSocket可以结合使用来创建实时通信应用。谢飞机：可以采用微服务架构，使用Spring Cloud进行服务拆分和负载均衡。谢飞机：STOMP是一个简单的文本导向消息协议，可以用于WebSocket的消息传输。谢飞机：可以用Spring Security进行访问控制，结合OAuth2进行认证……张老师：电商平台需要处理大量的订单数据，你会如何设计数据库架构以支持快速查询和写入？张老师：在线教育平台需要支持大量视频存储和检索，你会如何设计系统架构。
velocity简单使用-代码生成器
2509_90931430的博客
05-17 278
本文展示了如何在Maven项目中集成Velocity模板引擎，并使用JUnit进行测试。首先，通过Maven依赖引入了velocity-engine-core和junit库。接着，编写了一个Java测试方法，初始化Velocity引擎并创建模板上下文，填充数据后生成HTML文件。VM模板文件htm1.vm展示了Velocity的多种功能，包括变量输出、条件判断、循环遍历、宏定义等。通过include和parse指令，可以引入其他VM文件。最终生成的HTML文件包含了动态数据和模板逻辑，展示了Velocity
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值