秒杀抢购场景下实战JVM级别锁与分布式锁

背景历史

在电商系统中，秒杀抢购活动是一种常见的营销手段。它通过设定极低的价格和有限的商品数量，吸引大量用户在特定时间点抢购，从而迅速增加销量、提升品牌曝光度和用户活跃度。然而，这种活动也对系统的性能和稳定性提出了极高的要求。特别是在秒杀开始的瞬间，系统需要处理海量的并发请求，同时确保数据的准确性和一致性。

为了解决这些问题，系统开发者们引入了锁机制。锁机制是一种用于控制对共享资源的并发访问的技术，它能够确保在同一时间只有一个进程或线程能够操作某个资源，从而避免数据不一致或冲突。在秒杀抢购场景下，锁机制显得尤为重要，它能够保证商品库存的扣减操作是原子性的，避免出现超卖或数据不一致的情况。

锁机制的发展经历了从单机锁到分布式锁的过程。早期的系统大多运行在单机环境中，因此主要使用JVM级别的锁，如synchronized和ReentrantLock等。随着分布式系统的兴起，传统的JVM级别锁已经无法满足需求，于是分布式锁应运而生。分布式锁能够在多个节点之间协调对共享资源的访问，确保数据的一致性和系统的稳定性。

业务场景

秒杀抢购活动通常具有以下几个特点：

瞬时大流量：秒杀活动吸引大量用户参与，活动开始时会有海量的并发请求涌入系统。
热点数据：用户通常抢购的是同一商品，因此该商品的库存数据会成为热点数据，需要频繁读写。
数据一致性：秒杀活动需要确保数据的一致性，避免出现超卖或数据不一致的情况。

在秒杀抢购场景下，锁机制主要用于以下几个方面：

库存扣减：在用户下单时，需要确保库存扣减操作是原子性的，避免出现多个请求同时扣减库存导致超卖的情况。
订单生成：在用户下单成功后，需要生成订单并扣减库存，这个过程也需要确保原子性。
支付确认：在用户支付成功后，需要确认支付并释放库存，这个过程同样需要确保原子性。

底层原理

JVM级别锁

JVM级别锁是运行在单JVM进程中的锁机制，它主要通过Java对象头中的锁标记来实现。在Java中，每个对象都有一个对象头，对象头中包含了锁标记、哈希码等信息。根据锁的状态不同，锁标记的内容也会有所不同。

JVM级别锁主要包括以下几种：

synchronized：synchronized是Java中最基本的锁机制，它可以用于修饰方法或代码块。当线程进入synchronized修饰的方法或代码块时，会尝试获取对象的锁。如果锁已经被其他线程持有，则当前线程会进入阻塞状态，直到锁被释放。

synchronized锁的实现原理可以归纳为以下几个步骤：

获取锁：当线程进入synchronized修饰的方法或代码块时，会检查对象头中的锁标记。如果锁标记为未加锁状态，则当前线程会尝试获取锁，并将锁标记设置为锁定状态。如果锁已经被其他线程持有，则当前线程会进入阻塞状态。
释放锁：当线程退出synchronized修饰的方法或代码块时，会释放锁，并将锁标记设置为未加锁状态。其他等待的线程会重新尝试获取锁。

synchronized锁具有以下几个特点：

可重入：同一个线程可以多次获取同一个锁，而不会导致死锁。
不可中断：获取锁的线程在锁被释放之前无法被中断。
公平锁/非公平锁：synchronized锁默认是非公平锁，即线程获取锁的顺序不是按照请求的顺序来的。

ReentrantLock：ReentrantLock是Java中另一种常用的锁机制，它提供了比synchronized更灵活的锁控制。ReentrantLock实现了Lock接口，支持显式地获取和释放锁，以及设置锁的超时时间等。

ReentrantLock的实现原理与synchronized类似，也是通过改变对象头中的锁标记来实现锁的控制。不过，ReentrantLock提供了更多的功能，如可重入性、公平锁/非公平锁、锁超时等。

ReadWriteLock：ReadWriteLock是一种读写锁，它允许多个线程同时读取共享资源，但只允许一个线程写入共享资源。ReadWriteLock提供了更好的并发性能，适用于读多写少的场景。
StampedLock：StampedLock是Java 8中引入的一种新的锁机制，它提供了一种乐观读锁的机制。StampedLock允许线程在没有获取锁的情况下读取共享资源，但如果读取过程中资源被修改，则读取操作会失败。StampedLock适用于读多写少的场景，且读操作对性能要求较高的场景。

分布式锁

分布式锁是运行在多个节点之间的锁机制，它能够在多个节点之间协调对共享资源的访问。分布式锁的实现通常依赖于一些外部的、可靠的存储或服务，如Redis、ZooKeeper、数据库等。

分布式锁主要包括以下几种：

基于数据库的分布式锁：基于数据库的分布式锁通过在数据库中创建一个锁表来实现。锁表中包含锁的名称和锁的状态等信息。当一个节点需要获取锁时，它会在锁表中插入一条记录。如果插入成功，则表示该节点获取到了锁；如果插入失败（因为其他节点已经插入了相同的记录），则表示该节点获取锁失败。当节点使用完锁后，会删除锁表中的记录以释放锁。

基于数据库的分布式锁具有实现简单的优点，但性能较低，且如果数据库出现故障，可能会影响到锁的功能。

基于Redis的分布式锁：基于Redis的分布式锁利用Redis的SETNX命令和EXPIRE命令来实现。SETNX命令用于在key不存在时设置值，这可以确保在同一时间只有一个客户端能够获得锁。EXPIRE命令用于为key设置过期时间，这可以避免死锁的情况。当一个客户端需要获取锁时，它会尝试使用SETNX命令来设置锁。如果命令返回OK，则表示客户端成功获取了锁；如果返回nil，则表示锁已被其他客户端持有。客户端在获取锁后，可以使用EXPIRE命令为锁设置过期时间。当客户端完成操作后，需要使用DEL命令来释放锁。

基于Redis的分布式锁具有性能高、实现简单的优点，但默认是不可重入的，且如果Redis服务器出现故障，可能会导致锁无法正常工作。

基于ZooKeeper的分布式锁：基于ZooKeeper的分布式锁利用ZooKeeper的临时节点来实现。当一个节点需要获取锁时，它会尝试在ZooKeeper中创建一个临时节点。如果创建成功，则表示该节点获取到了锁；如果创建失败（因为其他节点已经创建了相同的临时节点），则表示该节点获取锁失败。当节点使用完锁后，会删除临时节点以释放锁。如果节点崩溃，ZooKeeper会自动删除临时节点，从而避免了死锁的问题。

基于ZooKeeper的分布式锁具有高效且可靠的优点，但实现相对复杂一些。

基于Etcd的分布式锁：基于Etcd的分布式锁利用Etcd的键值存储系统来实现。当一个节点需要获取锁时，它会尝试在Etcd中创建一个带有TTL（Time To Live）的键值对。如果创建成功，则表示该节点获取到了锁；如果创建失败（因为其他节点已经创建了相同的键值对），则表示该节点获取锁失败。当节点使用完锁后，会删除键值对以释放锁。如果TTL过期而节点仍未释放锁，Etcd会自动删除键值对以释放锁。

基于Etcd的分布式锁具有实现简单、性能较高的优点，但同样需要处理Redis服务器故障等潜在问题。

Java代码实现

JVM级别锁实现

以下是一个使用synchronized关键字实现秒杀抢购功能的Java代码示例：

public class SeckillService {
// 商品库存
private int stock = 10;
// 秒杀方法
public synchronized boolean seckill(String userId) {
if (stock <= 0) {
return false; // 库存不足}stock--; // 扣减库存System.out.println(userId + " 秒杀成功！剩余库存：" + stock);
return true;}
public static void main(String[] args) {
SeckillService service = new SeckillService();
// 模拟多个用户同时秒杀
for (int i = 0; i < 20; i++) {
new Thread(() -> {
String userId = "用户" + Thread.currentThread().getId();service.seckill(userId);}).start();}}
}

在这个示例中，SeckillService类中的seckill方法使用了synchronized关键字进行修饰，以确保在同一时间只有一个线程能够执行该方法。当库存扣减成功后，会打印出秒杀成功的用户ID和剩余库存。

以下是一个使用ReentrantLock实现秒杀抢购功能的Java代码示例：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class SeckillService {
// 商品库存
private int stock = 10;
// ReentrantLock锁
private final Lock lock = new ReentrantLock();
// 秒杀方法
public boolean seckill(String userId) {lock.lock(); // 获取锁
try {
if (stock <= 0) {
return false; // 库存不足}stock--; // 扣减库存System.out.println(userId + " 秒杀成功！剩余库存：" + stock);
return true;} finally {lock.unlock(); // 释放锁}}
public static void main(String[] args) {
SeckillService service = new SeckillService();
// 模拟多个用户同时秒杀
for (int i = 0; i < 20; i++) {
new Thread(() -> {
String userId = "用户" + Thread.currentThread().getId();service.seckill(userId);}).start();}}
}

在这个示例中，SeckillService类中使用了一个ReentrantLock对象作为锁。在seckill方法中，通过调用lock.lock()方法来获取锁，并在finally块中调用lock.unlock()方法来释放锁。这样可以确保在出现异常时也能够正确释放锁。

分布式锁实现

以下是一个使用Redis实现分布式锁的Java代码示例：

import redis.clients.jedis.Jedis;
public class RedisDistributedLock {
private final Jedis jedis;
private final String lockKey;
private final String uniqueValue;
private final int lockTimeout;
public RedisDistributedLock(Jedis jedis, String lockKey, int lockTimeout) {
this.jedis = jedis;
this.lockKey = lockKey;
this.uniqueValue = UUID.randomUUID().toString(); // 生成唯一值作为锁的持有者标识
this.lockTimeout = lockTimeout;}
// 尝试获取锁
public boolean tryLock() {
String result = jedis.set(lockKey, uniqueValue, "NX", "PX", lockTimeout);
return "OK".equals(result);}
// 释放锁
public void unlock() {
// 使用Lua脚本确保只有锁的持有者才能释放锁
String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";jedis.eval(script, 1, lockKey, uniqueValue);}
public static void main(String[] args) {
Jedis jedis = new Jedis("localhost", 6379);
RedisDistributedLock lock = new RedisDistributedLock(jedis, "seckill_lock", 10000); // 锁超时时间为10秒
// 模拟多个用户同时秒杀
for (int i = 0; i < 20; i++) {
new Thread(() -> {
if (lock.tryLock()) {
try {
// 执行秒杀操作System.out.println(Thread.currentThread().getId() + " 秒杀成功！");} finally {lock.unlock(); // 确保释放锁}} else {System.out.println(Thread.currentThread().getId() + " 秒杀失败，锁已被占用");}}).start();}}
}

在这个示例中，RedisDistributedLock类封装了Redis分布式锁的实现。构造函数中接收Jedis对象、锁键名、锁超时时间等参数。tryLock方法尝试获取锁，如果获取成功则返回true，否则返回false。unlock方法使用Lua脚本确保只有锁的持有者才能释放锁。在main方法中，模拟了多个用户同时秒杀的场景，每个线程都会尝试获取锁并执行秒杀操作。

以下是一个使用ZooKeeper实现分布式锁的Java代码示例（需要引入ZooKeeper的客户端库）：

import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;
import java.io.IOException;
import java.util.concurrent.CountDownLatch;
public class ZookeeperDistributedLock {
private final ZooKeeper zooKeeper;
private final String lockPath;
private final CountDownLatch connectedSignal = new CountDownLatch(1);
public ZookeeperDistributedLock(String connectString, int sessionTimeout, String lockPath) throws IOException, InterruptedException {zooKeeper = new ZooKeeper(connectString, sessionTimeout, event -> {
if (event.getState() == Event.KeeperState.SyncConnected) {connectedSignal.countDown();}});connectedSignal.await();
this.lockPath = lockPath;}
// 尝试获取锁
public boolean tryLock() throws KeeperException, InterruptedException {
String createPath = zooKeeper.create(lockPath + "/lock_", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
String lockName = createPath.substring(lockPath.length() + 1);List<String> children = zooKeeper.getChildren(lockPath, false);children.sort(String::compareTo);
if (lockName.equals(children.get(0))) {
return true; // 获取锁成功} else {
String previousSequenceNode = lockPath + "/" + children.get(0);
Stat stat = zooKeeper.exists(previousSequenceNode, false);
if (stat != null) {zooKeeper.getData(previousSequenceNode, true, new Watcher() {
@Override
public void process(WatchedEvent event) {
if (event.getType() == Event.EventType.NodeDeleted) {
try {tryLock();} catch (KeeperException | InterruptedException e) {e.printStackTrace();}}}});}
return false; // 获取锁失败}}
// 释放锁
public void unlock() throws KeeperException, InterruptedException {zooKeeper.delete(lockPath + "/lock_" + Thread.currentThread().getId(), -1);}
public static void main(String[] args) throws Exception {
ZookeeperDistributedLock lock = new ZookeeperDistributedLock("localhost:2181", 3000, "/locks");
// 模拟多个用户同时秒杀
for (int i = 0; i < 20; i++) {
new Thread(() -> {
try {
if (lock.tryLock()) {
try {
// 执行秒杀操作System.out.println(Thread.currentThread().getId() + " 秒杀成功！");} finally {lock.unlock(); // 确保释放锁}} else {System.out.println(Thread.currentThread().getId() + " 秒杀失败，锁已被占用");}} catch (KeeperException | InterruptedException e) {e.printStackTrace();}}).start();}}
}

在这个示例中，ZookeeperDistributedLock类封装了ZooKeeper分布式锁的实现。构造函数中接收ZooKeeper连接字符串、会话超时时间、锁路径等参数。tryLock方法尝试获取锁，如果获取成功则返回true，否则返回false。在获取锁的过程中，会创建一个临时顺序节点，并根据节点的序号来判断是否获取到锁。如果当前节点是序号最小的节点，则表示获取锁成功；否则，会监听序号最小的节点的删除事件，以便在该节点被删除时重新尝试获取锁。unlock方法用于释放锁，即删除当前节点。在main方法中，模拟了多个用户同时秒杀的场景，每个线程都会尝试获取锁并执行秒杀操作。