从架构设计到代码实现：skill实现的高并发解决方案

8次阅读

共计 2704 个字符，预计需要花费 7 分钟才能阅读完成。

在高并发场景下，skill 实现往往会遇到性能瓶颈和资源竞争问题。例如在电商秒杀活动中，大量用户同时抢购同一商品，如果没有合适的并发控制方案，很容易出现超卖、数据不一致等问题。类似的场景还有实时竞价系统、票务系统等。这些场景的共同特点是短时间内有大量请求涌入，对系统的吞吐量和数据一致性要求极高。

针对 skill 实现的高并发问题，常见的解决方案有以下几种：

数据库锁
优点：实现简单，直接利用数据库的锁机制
缺点：性能较差，容易成为系统瓶颈，且无法解决分布式环境下的锁问题
Redis 分布式锁
优点：性能好，支持分布式环境
缺点：需要处理锁超时、死锁等问题
消息队列
优点：解耦系统，提高吞吐量
缺点：实现复杂度较高，需要考虑消息丢失、重复消费等问题

在实际应用中，通常会结合使用 Redis 分布式锁和消息队列来获得最佳效果。

以下是使用 Java 实现的 Redis 分布式锁示例，包含锁续期机制：

public class RedisDistributedLock {
    private static final String LOCK_PREFIX = "lock:";
    private static final long DEFAULT_EXPIRE_TIME = 30_000; // 30 秒
    private static final long RETRY_INTERVAL = 100; // 100 毫秒

    private final JedisPool jedisPool;
    private final String lockKey;
    private String lockValue;
    private boolean locked = false;

    public RedisDistributedLock(JedisPool jedisPool, String lockKey) {
        this.jedisPool = jedisPool;
        this.lockKey = LOCK_PREFIX + lockKey;
    }

    public boolean tryLock(long timeout) throws InterruptedException {long end = System.currentTimeMillis() + timeout;
        lockValue = UUID.randomUUID().toString();

        try (Jedis jedis = jedisPool.getResource()) {while (System.currentTimeMillis() < end) {
                // 使用 SET 命令实现原子性加锁
                String result = jedis.set(lockKey, lockValue, "NX", "PX", DEFAULT_EXPIRE_TIME);
                if ("OK".equals(result)) {
                    locked = true;
                    // 启动一个守护线程定期续期
                    new Thread(this::renewExpiration).start();
                    return true;
                }
                Thread.sleep(RETRY_INTERVAL);
            }
        }
        return false;
    }

    private void renewExpiration() {while (locked) {try (Jedis jedis = jedisPool.getResource()) {
                // 使用 Lua 脚本保证原子性续期
                String script = "if redis.call('get', KEYS[1]) == ARGV[1] then" +
                        "return redis.call('pexpire', KEYS[1], ARGV[2])" +
                        "else return 0 end";
                jedis.eval(script, Collections.singletonList(lockKey), 
                    Arrays.asList(lockValue, String.valueOf(DEFAULT_EXPIRE_TIME)));
            }
            try {Thread.sleep(DEFAULT_EXPIRE_TIME / 3);
            } catch (InterruptedException e) {Thread.currentThread().interrupt();}
        }
    }

    public void unlock() {if (!locked) return;

        try (Jedis jedis = jedisPool.getResource()) {
            // 使用 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, Collections.singletonList(lockKey), Collections.singletonList(lockValue));
            locked = false;
        }
    }
}

在高并发场景下，我们可以将请求先放入消息队列，然后由后台消费者异步处理。架构设计如下：