无锁秒杀系统设计：基于Java的高效实现

引言

在电商促销活动中，秒杀场景是非常常见的。为了确保高并发下的数据一致性、性能以及用户体验，本文将介绍几种不依赖 Redis 实现的无锁秒杀方案，并提供简化后的 Java 代码示例和架构图。

一、基于数据库乐观锁机制

✅ 实现思路：

• 使用版本号字段控制库存更新，避免超卖问题。
• 每次扣减前检查版本号是否匹配，保证原子性操作。

📌 架构图：

🧱 数据库表结构（伪 SQL）：

CREATE TABLE product_stock (product_id BIGINT PRIMARY KEY,stock_count INT NOT NULL,version INT DEFAULT 0
);

🧾 核心实体类（Lombok）：

@Data
public class ProductStock {private Long productId;private Integer stockCount;private Integer version;
}

🔐 乐观锁服务类：

@Service
public class OptimisticLockService {@Autowiredprivate JdbcTemplate jdbcTemplate;public boolean reduceStock(Long productId) {String selectSql = "SELECT stock_count, version FROM product_stock WHERE product_id = ?";Map<String, Object> result = jdbcTemplate.queryForMap(selectSql, productId);int stockCount = (int) result.get("stock_count");int version = (int) result.get("version");if (stockCount <= 0) return false;String updateSql = "UPDATE product_stock SET stock_count = ?, version = ? WHERE product_id = ? AND version = ?";int rowsAffected = jdbcTemplate.update(updateSql,stockCount - 1,version + 1,productId,version);return rowsAffected > 0;}
}

---

二、利用数据库唯一约束防重下单

✅ 实现思路：

• 利用数据库唯一索引特性防止重复下单。
• 先插入预订单记录，再执行库存扣除。

📌 架构图：

🧱 数据库表结构（伪 SQL）：

CREATE TABLE pre_order (user_id BIGINT,product_id BIGINT,created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,PRIMARY KEY(user_id, product_id)
);

🧾 核心实体类：

@Data
public class PreOrder {private Long userId;private Long productId;
}

🔐 防重下单服务类：

@Service
public class UniqueConstraintService {@Autowiredprivate JdbcTemplate jdbcTemplate;public boolean placeOrder(Long userId, Long productId) {try {// 插入预订单（唯一约束）jdbcTemplate.update("INSERT INTO pre_order(user_id, product_id) VALUES (?, ?)", userId, productId);// 扣减库存int rowsAffected = jdbcTemplate.update("UPDATE product_stock SET stock_count = stock_count - 1 WHERE product_id = ? AND stock_count > 0", productId);if (rowsAffected == 0) {rollbackOrder(userId, productId);return false;}return true;} catch (DuplicateKeyException e) {// 唯一键冲突return false;}}private void rollbackOrder(Long userId, Long productId) {jdbcTemplate.update("DELETE FROM pre_order WHERE user_id = ? AND product_id = ?", userId, productId);}
}

---

三、消息队列结合批量处理（异步化削峰填谷）

✅ 实现思路：

• 将所有秒杀请求放入消息队列中。
• 后台消费者按批次处理，避免瞬时冲击数据库。

📌 架构图：

🧾 消息体定义：

@Data
public class OrderMessage {private Long userId;private Long productId;
}

🧾 消息生产者（Spring Boot 示例）：

@Component
public class MessageProducer {@Autowiredprivate RabbitTemplate rabbitTemplate;public void sendOrder(OrderMessage message) {rabbitTemplate.convertAndSend("order_queue", message);}
}

🧾 消费者逻辑（模拟批量处理）：

@Component
public class OrderConsumer {@RabbitListener(queues = "order_queue")public void process(OrderMessage message) {// 异步处理下单逻辑System.out.println("Processing order: " + message.getUserId() + " -> " + message.getProductId());// 调用库存服务或其他实际业务逻辑}
}

---

四、内存计算 + 定期同步至数据库（推荐用于超高频读写）

✅ 实现思路：

• 使用 ConcurrentHashMap 维护商品库存缓存。
• 用户请求优先修改内存中的值，降低 DB 压力。
• 定时任务定期将变更同步到数据库。

📌 架构图：

🧾 内存库存管理器：

@Component
public class InMemoryStockManager {private final Map<Long, Integer> stockCache = new ConcurrentHashMap<>();public void initStock(Long productId, int stockCount) {stockCache.put(productId, stockCount);}public boolean reduceStock(Long productId) {return stockCache.computeIfPresent(productId, (k, v) -> v > 0 ? v - 1 : v) != null;}public int getStock(Long productId) {return stockCache.getOrDefault(productId, 0);}
}

🧾 异步下单服务：

@Service
public class AsyncOrderService {@Autowiredprivate InMemoryStockManager stockManager;private final ExecutorService executor = Executors.newFixedThreadPool(5);public void placeOrder(Long userId, Long productId) {if (stockManager.reduceStock(productId)) {executor.submit(() -> savePreOrderToDB(userId, productId));} else {System.out.println("库存不足");}}private void savePreOrderToDB(Long userId, Long productId) {// 这里可以调用 DAO 或 JdbcTemplate 插入预订单System.out.println("保存预订单：" + userId + " 购买了商品ID：" + productId);}
}

🧾 定时同步任务：

@Component
public class SyncTask {@Scheduled(fixedRate = 60_000) // 每分钟执行一次public void syncOrdersToDatabase() {List<PreOrder> orders = fetchUnsyncedOrders();for (PreOrder order : orders) {updateProductStock(order.getProductId());}deleteSyncedOrders(orders);}private List<PreOrder> fetchUnsyncedOrders() {// 查询待同步订单return List.of(new PreOrder(1L, 1001L), new PreOrder(2L, 1001L));}private void updateProductStock(Long productId) {// 执行更新库存System.out.println("同步库存：" + productId);}private void deleteSyncedOrders(List<PreOrder> orders) {// 删除已经同步的订单orders.forEach(order -> System.out.println("删除订单：" + order));}
}

---

✅ 总结与建议

方案	特点	适用场景
乐观锁	简单、数据一致性高	并发量适中
唯一约束下单	防止重复下单	单用户限购
消息队列异步	解耦、削峰填谷	大流量场景
内存计算+定时同步	高吞吐、低延迟	超高并发秒杀

💡 推荐组合使用：

• “内存计算 + 唯一约束” + “定时同步” 是一个非常实用且高效的组合，在秒杀中表现优异。
• 可根据业务阶段动态启用不同策略，例如前 5 秒使用内存计算，后续切为乐观锁。