redis实现红锁的示例代码_Redis

举个真实的例子：你的团队刚上线了一个秒杀系统，用redis锁来防止超卖。测试环境明明跑得好好的，但大促当晚却出现了100件库存卖出了120单的灵异事件。查看日志才发现：就在用户疯狂点击的瞬间，redis主节点突然挂了，新的主节点还没拿到锁的信息，结果两个用户同时抢到了"同一把锁"。

这就是很多开发者踩过的坑——你以为用了redis分布式锁就万事大吉，其实这些情况随时可能让锁失效：

主节点刚给你加完锁就崩溃了，从节点接班时一脸懵：“什么锁？我没听说过啊”
你的程序正处理到一半突然卡住了（比如gc停顿），等回过神来锁早就过期了
网络抽风导致锁信息没传到位，多个客户端都觉得自己拿到了锁

为了解决这些头疼问题，redis作者提出了**红锁（redlock）**方案。简单来说就是"不要把鸡蛋放在一个篮子里"：让多个独立的redis节点投票决定锁的归属，只有半数以上同意才算真正拿到锁。

但这套方案也引发过激烈争论，有人甚至说它"数学上就不安全"。本文将用最直白的语言：

先带你看看传统redis锁在集群环境为什么容易翻车
拆解红锁这个"少数服从多数"的解决方案
手把手教你用java代码实现红锁
揭秘redisson框架如何简化红锁的使用

读完本文你会明白：没有完美的分布式锁，只有适合场景的选择。下次设计系统时，至少能清楚知道手里的锁到底有几成把握。

集群锁的缺陷与挑战

在redis cluster环境中，传统的setnx分布式锁存在以下致命缺陷：主从切换导致锁失效。

问题步骤复现：

客户端a通过set key random_val nx px 30000在主节点成功获取锁
主节点宕机，redis cluster触发故障转移，从节点升级为新主节点
由于redis主从复制是异步的，锁可能未同步到新主节点
客户端b向新主节点申请相同资源的锁，成功获取导致数据竞争

# 主节点写入锁
set resource_1 8a3e72 nx px 10000  
ok

# 主节点宕机，从节点晋升但未同步锁数据
# 新主节点处理客户端b的请求
set resource_1 5b9fd2 nx px 10000  
ok  # 锁被重复获取！

红锁（redlock）的设计与实现

在n个独立redis节点（非cluster模式）中，当客户端在半数以上节点成功获取锁，且总耗时小于锁有效期时，才认为锁获取成功。

实现步骤详解

假设部署5个redis节点（n=5）：

获取当前时间：记录开始时间t1（毫秒精度）
依次向所有节点申请锁：

set lock_key valuenx px $ttl

value：全局唯一值（如uuid）
ttl：锁自动释放时间（如10秒）

计算锁有效性：

客户端计算获取锁总耗时t_elapsed = t2 - t1（t2为最后响应时间）
仅当以下两个条件满足时，锁才有效：

成功获取锁的节点数 ≥ 3（n/2 + 1）

t_elapsed < ttl（确保锁未过期）

加锁成功，去操作共享资源
释放锁：向所有节点发送lua脚本删除锁（需验证值）

if redis.call("get",keys[1]) == argv[1] then
   return redis.call("del",keys[1])
else
   return 0
end

npc争议问题

红锁算法自诞生起就伴随着**n（网络延迟）、p（进程暂停）、c（时钟漂移）**三个核心争议，这些现实世界中的不确定因素，动摇了红锁在数学意义上的绝对安全性。

网络延迟（network delay）的致命时间差

问题场景：

客户端在节点a、b、c成功获取锁，总耗时48ms（小于ttl 50ms）
但由于跨机房网络波动，实际锁在节点上的有效时间存在差异：
- 节点a记录的锁过期时间：客户端本地时间+50ms = t+50
- 节点b因网络延迟，实际锁过期时间为t+52
- 节点c因网络拥塞，实际锁过期时间仅t+48
在时间窗口t+48到t+50之间，客户端认为锁仍有效，但节点c的锁已提前失效

后果：
其他客户端可能在此期间获取节点c的锁，导致锁状态分裂，多个客户端同时进入临界区。

进程暂停（process pause）的「薛定谔锁」

经典案例：

// 伪代码：获取锁后执行业务逻辑
if (redlock.trylock()) {
    // 触发full gc暂停300ms
    system.gc(); 
    
    // 此时锁已过期，但客户端仍在写数据
    updateinventory(); 
}

关键时间线：

t0: 获取锁（ttl=200ms）
t0+100ms: 进入gc暂停，持续300ms
t0+400ms: gc结束，继续执行业务逻辑
锁实际在t0+200ms已失效，但客户端在t0+400ms仍以为自己持有锁

数据灾难：
其他客户端在t0+200ms到t0+400ms期间可能修改数据，导致最终结果错乱。

时钟漂移（clock drift）的时空扭曲

物理机时钟偏移实验数据：

节点	时钟误差范围	常见诱因
节点a	±200ms/分钟	虚拟机时钟不同步
节点b	±500ms/天	ntp服务异常
节点c	±10秒/小时	宿主机硬件时钟故障

连锁反应：

客户端计算锁有效期基于本地时钟（假设为t+100ms）
但节点b的时钟比实际快30秒，导致其记录的锁过期时间为t-29000ms
锁在客户端认为的有效期内提前被节点b自动释放

行业领袖的正面交锋

martin kleppmann（《数据密集型应用设计》作者）：

“红锁依赖的假设——『客户端能准确感知锁存活时间』，在异步分布式系统中根本无法保证。即使没有节点故障，npc问题也会导致锁状态的不确定性。”

antirez（redis作者）的反驳：

"工程实践中可以通过以下手段控制风险：

使用带温度补偿的原子钟硬件

禁用ntp服务的时钟跳变调整

监控进程暂停（如gc日志分析）

为锁ttl设置冗余缓冲时间（如额外20%）"

红锁的java实现示例

使用jedis客户端实现红锁：

package com.morris.redis.demo.redlock;

import redis.clients.jedis.jedis;
import redis.clients.jedis.jedispool;
import redis.clients.jedis.params.setparams;

import java.util.collections;
import java.util.list;
import java.util.uuid;
import java.util.concurrent.timeunit;

/**
 * 使用jedis手写redlock
 */
public class jedisredlock {

    public static final int expire_time = 30_000;

    private final list<jedispool> jedispoollist;

    private final string lockkey;

    private final string lockvalue;

    public jedisredlock(list<jedispool> jedispoollist, string lockkey) {
        this.jedispoollist = jedispoollist;
        this.lockkey = lockkey;
        this.lockvalue = uuid.randomuuid().tostring();
    }

    public void lock() {
        while (!trylock()) {
            try {
                timeunit.milliseconds.sleep(100); // 失败后短暂等待
            } catch (interruptedexception e) {
                throw new runtimeexception(e);
            }
        }
    }

    public boolean trylock() {
        long starttime = system.currenttimemillis();
        int successcount = 0;
        try {
            for (jedispool jedispool : jedispoollist) {
                try (jedis jedis = jedispool.getresource();) {
                    // 原子化加锁：set lockkey uuid nx px expiretime
                    string result = jedis.set(lockkey, lockvalue,
                            setparams.setparams().nx().px(expire_time));
                    if ("ok".equals(result)) {
                        successcount++;
                    }
                }
            }
            // 计算获取锁耗时
            long elapsedtime = system.currenttimemillis() - starttime;

            // 验证：多数节点成功 且 耗时小于ttl
            return successcount >= (jedispoollist.size() / 2 + 1) && elapsedtime < expire_time;
        } finally {
            // 若加锁失败，立即释放已获得的锁
            if (successcount < (jedispoollist.size() / 2 + 1)) {
                unlock();
            }
        }
    }

    public void unlock() {
        string script = "if redis.call('get', keys[1]) == argv[1] then return redis.call('del', keys[1]) else return 0 end";

        for (jedispool jedispool : jedispoollist) {
            try (jedis jedis = jedispool.getresource()) {
                jedis.eval(script, collections.singletonlist(lockkey), collections.singletonlist(lockvalue));
            }
        }
    }

}

手写redlock的使用：

package com.morris.redis.demo.redlock;

import redis.clients.jedis.jedispool;
import redis.clients.jedis.jedispoolconfig;

import java.util.arraylist;
import java.util.list;
import java.util.concurrent.countdownlatch;
import java.util.concurrent.executorservice;
import java.util.concurrent.executors;
import java.util.concurrent.timeunit;

/**
 * 手写redlock的使用
 */
public class jedisredlockdemo {

    private volatile static int count;

    public static void main(string[] args) throws interruptedexception {
        list<jedispool> jedispoollist = new arraylist<>();
        jedispoollist.add(new jedispool(new jedispoolconfig(), "127.0.0.1", 6379));
        jedispoollist.add(new jedispool(new jedispoolconfig(), "127.0.0.1", 6380));
        jedispoollist.add(new jedispool(new jedispoolconfig(), "127.0.0.1", 6381));
        jedispoollist.add(new jedispool(new jedispoolconfig(), "127.0.0.1", 6382));
        jedispoollist.add(new jedispool(new jedispoolconfig(), "127.0.0.1", 6383));

        int threadcount = 3;
        countdownlatch countdownlatch = new countdownlatch(threadcount);
        executorservice executorservice = executors.newfixedthreadpool(threadcount);

        for (int i = 0; i < threadcount; i++) {
            executorservice.submit(() -> {
                jedisredlock jedisredlock = new jedisredlock(jedispoollist, "lock-key");
                jedisredlock.lock();
                try {
                    system.out.println(thread.currentthread().getname() + "获得锁，开始执行业务逻辑。。。");
                    try {
                        timeunit.seconds.sleep(3);
                    } catch (interruptedexception e) {
                        throw new runtimeexception(e);
                    }
                    system.out.println(thread.currentthread().getname() + "获得锁，结束执行业务逻辑。。。");
                    count++;
                } finally {
                    jedisredlock.unlock();
                }
                countdownlatch.countdown();
            });
        }

        countdownlatch.await();
        executorservice.shutdown();
        system.out.println(count);
    }

}

redisson中红锁的使用

redisson已封装红锁实现，自动处理节点通信与锁续期：

package com.morris.redis.demo.redlock;

import org.redisson.redisson;
import org.redisson.redissonredlock;
import org.redisson.api.rlock;
import org.redisson.api.redissonclient;
import org.redisson.config.config;

import java.util.arraylist;
import java.util.arrays;
import java.util.list;
import java.util.concurrent.countdownlatch;
import java.util.concurrent.executorservice;
import java.util.concurrent.executors;
import java.util.concurrent.timeunit;

/**
 * redisson中红锁的使用
 */
public class redissonredlockdemo {

    private volatile static int count;

    public static void main(string[] args) throws interruptedexception {

        list<string> serverlist = arrays.aslist("redis://127.0.0.1:6379", "redis://127.0.0.1:6380", "redis://127.0.0.1:6381",
                "redis://127.0.0.1:6382", "redis://127.0.0.1:6383");

        list<redissonclient> redissonclientlist = new arraylist<>(serverlist.size());
        for (string server : serverlist) {
            config config = new config();
            config.usesingleserver()
                    .setaddress(server);

            redissonclientlist.add(redisson.create(config));
        }

        list<rlock> locklist = new arraylist<>(redissonclientlist.size());
        for (redissonclient redissonclient : redissonclientlist) {
            locklist.add(redissonclient.getlock("java-lock"));
        }
        
        int threadcount = 3;
        countdownlatch countdownlatch = new countdownlatch(threadcount);
        executorservice executorservice = executors.newfixedthreadpool(threadcount);

        for (int i = 0; i < threadcount; i++) {
            executorservice.submit(() -> {
                redissonredlock redissonredlock = new redissonredlock(locklist.toarray(new rlock[0]));
                redissonredlock.lock();
                try {
                    system.out.println(thread.currentthread().getname() + "获得锁，开始执行业务逻辑。。。");
                    try {
                        timeunit.seconds.sleep(3);
                    } catch (interruptedexception e) {
                        throw new runtimeexception(e);
                    }
                    system.out.println(thread.currentthread().getname() + "获得锁，结束执行业务逻辑。。。");
                    count++;
                } finally {
                    redissonredlock.unlock();
                }
                countdownlatch.countdown();
            });
        }

        countdownlatch.await();
        executorservice.shutdown();
        system.out.println(count);

        for (redissonclient redissonclient : redissonclientlist) {
            redissonclient.shutdown();
        }
    }

}

redisson优势：