在当今分布式系统盛行的时代，Spring Boot 框架凭借其便捷性与高效性，成为构建 Java 应用的热门选择。在 Spring Boot 项目里，当涉及到多个服务或节点对共享资源的并发访问时，数据一致性就成了棘手问题。这时，分布式锁与事务协调机制便派上用场，它们协同工作，确保数据的准确性与完整性。接下来，我们深入探讨在 Spring Boot 项目中如何巧妙运用分布式锁与事务协调。
分布式锁：保障资源访问秩序
分布式锁的概念与作用
分布式锁，简而言之，是一种用于协调分布式系统中多个进程对共享资源访问的机制。在分布式架构下，多个服务实例可能同时尝试操作同一资源，例如电商系统中多个订单服务实例对同一商品库存的扣减操作。若没有有效控制，极易出现数据不一致，像 “超卖” 这类问题就会频繁发生。分布式锁的存在，就是确保同一时刻仅有一个服务实例能够访问共享资源，避免并发冲突。
常见分布式锁实现方式
1.基于 Redis 实现分布式锁：Redis 作为高性能内存缓存数据库，其SETNX（set if not exists）命令非常适合构建分布式锁。实现过程如下：
使用SETNX命令设置一个唯一标识符（如 UUID）作为锁。若设置成功，说明获取到锁；若失败，代表锁已被其他进程占用。
为锁设置过期时间，防止因服务异常导致锁永久占用资源，引发死锁。
操作完成后，通过DEL命令删除锁，释放资源。
示例代码（Java + RedisTemplate）：
@Autowired private RedisTemplate<String, String> redisTemplate; public boolean tryLock(String lockKey, String requestId, int expireTime) { Boolean result = redisTemplate.opsForValue().setIfAbsent(lockKey, requestId); if (result != null && result) { redisTemplate.expire(lockKey, expireTime, TimeUnit.SECONDS); return true; } return false; } public void unlock(String lockKey, String requestId) { String value = redisTemplate.opsForValue().get(lockKey); if (requestId.equals(value)) { redisTemplate.delete(lockKey); } }Redis 分布式锁的优势在于性能卓越，锁的获取与释放操作极为高效，适用于业务操作频繁且耗时短的场景。但需注意合理设置锁过期时间，避免锁未及时释放；同时，要考虑 Redis 节点故障导致锁失效问题，可采用 Redis 集群模式提升可靠性。
当然，我们平时项目使用较多的是org.redisson.api包下的RedissonClient，RedissonClient封装了获取Rlock的方法，例如getLock。
2. 基于 Zookeeper 实现分布式锁：Zookeeper 是分布式协调服务，通过创建临时有序节点实现分布式锁功能。主要步骤如下：
使用CuratorFramework提供的InterProcessMutex互斥锁。
创建临时节点来获取锁，当锁释放时，对应的临时节点会自动删除。
若服务崩溃，Zookeeper 会自动清理临时节点，有效避免死锁。
示例代码（Java + Curator）：
@Autowired private CuratorFramework curatorFramework; public void zkLock(String lockPath) throws Exception { InterProcessMutex mutex = new InterProcessMutex(curatorFramework, lockPath); mutex.acquire(); try { // 执行业务逻辑 } finally { mutex.release(); } }Zookeeper 分布式锁具备高可靠性与强一致性，适用于对锁持久性要求高的场景，如电商库存管理。然而，其性能逊于 Redis，更适合长时间持有锁的情况，且部署与运维成本相对较高。
3. 基于数据库实现分布式锁：利用数据库自身特性也能实现分布式锁。常见做法是借助数据库的INSERT操作与唯一约束条件，确保同一时刻只有一个事务能成功插入锁记录，获取锁。操作完成后删除锁记录释放锁。
示例代码（Java + JDBC）：
@Autowired private DataSource dataSource; public boolean dbLock(String lockKey) { String sql = "INSERT INTO lock_table (lock_key, create_time) VALUES (?, NOW()) ON DUPLICATE KEY UPDATE create_time = NOW()"; try (Connection connection = dataSource.getConnection(); PreparedStatement statement = connection.prepareStatement(sql)) { statement.setString(1, lockKey); int result = statement.executeUpdate(); return result == 1; } catch (SQLException e) { e.printStackTrace(); return false; } } public void dbUnlock(String lockKey) { String sql = "DELETE FROM lock_table WHERE lock_key =?"; try (Connection connection = dataSource.getConnection(); PreparedStatement statement = connection.prepareStatement(sql)) { statement.setString(1, lockKey); statement.executeUpdate(); } catch (SQLException e) { e.printStackTrace(); } }基于数据库实现分布式锁的优点是无需引入外部组件，直接依赖现有数据库，易于集成。但数据库性能瓶颈可能影响锁的获取与释放效率，适用于小型系统或单点锁需求场景。
事务协调：确保操作原子性
事务的概念与特性
事务是数据库操作的逻辑单元，它包含一组操作，这些操作要么全部成功执行，要么全部失败回滚，以此保证数据的一致性与完整性。事务具备 ACID 四大特性：
- 原子性（Atomicity）：事务中的所有操作被视为一个不可分割的整体，要么全部执行成功，要么全部失败回滚。
- 一致性（Consistency）：事务执行前后，数据库的完整性约束不会被破坏，数据从一个合法状态转换到另一个合法状态。
- 隔离性（Isolation）：多个事务并发执行时，一个事务的执行不应被其他事务干扰，各事务之间相互隔离。
- 持久性（Durability）：一旦事务提交成功，其对数据库所做的修改将永久保存，即便系统发生故障也不会丢失。
Spring Boot 中事务的配置与使用
1.启用事务管理：在 Spring Boot 应用中，通过在配置类上添加@EnableTransactionManagement注解启用事务管理，也可通过配置属性进行启用。
@Configuration @EnableTransactionManagement public class TransactionConfig { }
2.定义事务边界：明确事务的作用范围，事务应涵盖需原子性处理的最小工作单元。例如，在一个涉及数据库插入、更新等多个操作的业务方法上添加@Transactional注解，确保这些操作在同一个事务中执行。
@Service public class UserService { @Autowired private UserRepository userRepository; @Transactional public void saveUser(User user) { userRepository.save(user); // 其他相关操作 } }
3.选择合适的隔离级别：根据业务需求选择恰当的事务隔离级别。Spring Boot 默认隔离级别通常为READ_COMMITTED，它在数据一致性与性能间取得较好平衡。但对于某些特殊业务场景，可能需要调整隔离级别，如SERIALIZABLE可提供最高级别的数据一致性，但性能开销较大。
@Transactional(isolation = Isolation.SERIALIZABLE) public void specialBusinessMethod() { // 业务逻辑 }
4.事务传播行为管理：在事务上下文内调用其他方法时，需关注事务传播行为。@Transactional注解的propagation属性可控制事务如何在方法间传播。例如，Propagation.REQUIRED表示若当前存在事务，则加入该事务；若不存在，则创建新事务。
@Service public class OrderService { @Autowired private ProductService productService; @Transactional(propagation = Propagation.REQUIRED) public void placeOrder(Order order) { // 订单相关操作 productService.updateStock(order.getProductId(), order.getQuantity()); } } @Service public class ProductService { @Autowired private ProductRepository productRepository; @Transactional(propagation = Propagation.REQUIRES_NEW) public void updateStock(Long productId, int quantity) { // 库存更新操作 } }
分布式锁与事务协调使用场景
电商系统中的订单与库存管理
在电商系统中，订单创建与库存扣减是典型场景。当用户下单时，需先获取分布式锁，确保同一时刻只有一个订单服务实例能操作库存。同时，订单创建与库存扣减操作需在同一个事务中进行，保证数据一致性。若订单创建成功但库存扣减失败，事务回滚，避免库存与订单数据不一致。
@Service public class OrderServiceImpl implements OrderService { @Autowired private RedisTemplate<String, String> redisTemplate; @Autowired private OrderRepository orderRepository; @Autowired private ProductRepository productRepository; @Override @Transactional public void placeOrder(Order order) { String lockKey = "product:" + order.getProductId() + ":lock"; String requestId = UUID.randomUUID().toString(); try { if (tryLock(lockKey, requestId, 30)) { Product product = productRepository.findById(order.getProductId()).orElseThrow(); if (product.getStock() >= order.getQuantity()) { product.setStock(product.getStock() - order.getQuantity()); productRepository.save(product); orderRepository.save(order); } else { throw new InsufficientStockException("库存不足"); } } else { throw new LockException("获取锁失败"); } } finally { unlock(lockKey, requestId); } } private boolean tryLock(String lockKey, String requestId, int expireTime) { Boolean result = redisTemplate.opsForValue().setIfAbsent(lockKey, requestId); if (result != null && result) { redisTemplate.expire(lockKey, expireTime, TimeUnit.SECONDS); return true; } return false; } private void unlock(String lockKey, String requestId) { String value = redisTemplate.opsForValue().get(lockKey); if (requestId.equals(value)) { redisTemplate.delete(lockKey); } } }
分布式任务调度中的资源保护
在分布式任务调度系统中，可能存在多个任务实例同时尝试处理同一资源的情况。此时，可借助分布式锁保证同一时刻只有一个任务实例能操作资源，同时结合事务确保任务处理过程的原子性。例如，在数据同步任务中，获取分布式锁后，在事务内执行数据读取、转换与写入操作，若过程中出现异常，事务回滚，避免数据不一致。
@Service public class DataSyncService { @Autowired private ZookeeperLock zookeeperLock; @Autowired private DataSource sourceDataSource; @Autowired private DataSource targetDataSource; @Transactional public void syncData() { String lockPath = "/dataSyncLock"; try { zookeeperLock.lock(lockPath); // 从源数据库读取数据 String sql = "SELECT * FROM source_table"; try (Connection sourceConnection = sourceDataSource.getConnection(); PreparedStatement sourceStatement = sourceConnection.prepareStatement(sql); ResultSet resultSet = sourceStatement.executeQuery()) { while (resultSet.next()) { // 数据转换与写入目标数据库 String targetSql = "INSERT INTO target_table (column1, column2) VALUES (?,?)"; try (Connection targetConnection = targetDataSource.getConnection(); PreparedStatement targetStatement = targetConnection.prepareStatement(targetSql)) { targetStatement.setString(1, resultSet.getString("column1")); targetStatement.setString(2, resultSet.getString("column2")); targetStatement.executeUpdate(); } } } } catch (Exception e) { e.printStackTrace(); throw new RuntimeException("数据同步失败"); } finally { zookeeperLock.unlock(lockPath); } } }
总结与展望
在 Spring Boot 分布式项目中，分布式锁与事务协调使用是保障数据一致性与系统稳定性的关键手段。通过合理选择分布式锁实现方式，如 Redis、Zookeeper 或数据库，并结合 Spring Boot 强大的事务管理功能，能有效应对复杂业务场景下的并发访问问题。随着分布式系统的不断发展，未来我们还需持续关注新技术、新方案，进一步优化分布式锁与事务协调机制，提升系统性能与可靠性。在实际项目开发中，务必根据业务需求与系统架构特点，精心设计与实现分布式锁与事务逻辑，为构建高质量分布式应用筑牢根基。最后，一定要记住，在使用分布式锁和事务过程中，分布式锁要放在最外层，防止锁先释放、事务后提交的情况，否则有可能会导致不同线程操作同一数据时数据值错乱！
扫一扫
1257
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
