JAVA解决超卖问题

最新推荐文章于 2025-09-01 21:26:03 发布

原创最新推荐文章于 2025-09-01 21:26:03 发布 · 563 阅读

9 ·

CC 4.0 BY-SA版权

文章标签：

#java #数据库 #oracle

Java深入学习专栏收录该内容

8 篇文章

订阅专栏

该文章已生成可运行项目，

在Java中，解决超卖问题通常需要结合数据库的事务管理和并发控制机制。以下是几种常见的解决方案：

1. 使用数据库的悲观锁（Pessimistic Locking）

悲观锁通过在读取数据时加锁，确保在事务提交之前其他事务无法修改数据。可以通过SELECT ... FOR UPDATE语句实现。

示例代码：

java复制代码

import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import javax.persistence.EntityManager; import javax.persistence.LockModeType; import javax.persistence.PersistenceContext; @Service public class ProductService { @PersistenceContext private EntityManager entityManager; @Transactional public void reduceStock(Long productId, int quantity) { Product product = entityManager.find(Product.class, productId, LockModeType.PESSIMISTIC_WRITE); if (product.getStock() < quantity) { throw new IllegalArgumentException("Not enough stock"); } product.setStock(product.getStock() - quantity); entityManager.merge(product); } }

优点：

简单直接，适合高并发场景。
确保数据一致性。

缺点：

锁粒度较大，可能导致性能下降。
不适合长时间运行的事务。

2. 使用乐观锁（Optimistic Locking）

乐观锁通过版本号或时间戳来检测数据是否被其他事务修改。如果检测到冲突，则回滚并重试。

示例代码：

java复制代码

import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; @Service public class ProductService { @Autowired private ProductRepository productRepository; @Transactional public void reduceStock(Long productId, int quantity) { while (true) { try { Product product = productRepository.findById(productId).orElseThrow(); if (product.getStock() < quantity) { throw new IllegalArgumentException("Not enough stock"); } product.setStock(product.getStock() - quantity); productRepository.save(product); break; // 成功提交，退出循环 } catch (OptimisticLockException e) { // 乐观锁异常，说明有其他事务修改了数据，重试 } } } }

优点：

无锁化，并发性能较好。
适合读多写少的场景。

缺点：

在高并发写操作下，可能导致频繁重试。
不适合长时间运行的事务。

3. 使用分布式锁（Distributed Locking）

在分布式系统中，可以使用Redis、ZooKeeper等工具实现分布式锁，确保同一时间只有一个线程可以修改库存。

示例代码（基于Redis）：

java复制代码

import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.redis.core.StringRedisTemplate; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import java.util.concurrent.TimeUnit; @Service public class ProductService { @Autowired private ProductRepository productRepository; @Autowired private StringRedisTemplate redisTemplate; @Transactional public void reduceStock(Long productId, int quantity) { String lockKey = "lock:product:" + productId; boolean acquired = redisTemplate.opsForValue().setIfAbsent(lockKey, "lock", 10, TimeUnit.SECONDS); if (!acquired) { throw new RuntimeException("Could not acquire lock"); } try { Product product = productRepository.findById(productId).orElseThrow(); if (product.getStock() < quantity) { throw new IllegalArgumentException("Not enough stock"); } product.setStock(product.getStock() - quantity); productRepository.save(product); } finally { redisTemplate.delete(lockKey); // 释放锁 } } }

优点：

适合分布式系统。
确保全局唯一性。

缺点：

需要引入外部依赖（如Redis）。
锁管理复杂，需要考虑锁超时和死锁问题。

4. 原子操作（Atomic Operations）

在某些数据库中，可以使用原子操作（如MySQL的UPDATE语句）来确保库存扣减的原子性。

示例代码：

java复制代码

import org.springframework.beans.factory.annotation.Autowired; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; @Service public class ProductService { @Autowired private JdbcTemplate jdbcTemplate; @Transactional public void reduceStock(Long productId, int quantity) { String sql = "UPDATE product SET stock = stock - ? WHERE id = ? AND stock >= ?"; int result = jdbcTemplate.update(sql, quantity, productId, quantity); if (result == 0) { throw new IllegalArgumentException("Not enough stock or update failed"); } } }