通过Lua脚本手写redis分布式锁

最新推荐文章于 2025-03-31 22:46:38 发布
原创 最新推荐文章于 2025-03-31 22:46:38 发布 · 612 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#redis #分布式 #数据库

1、手写 Redis 分布式锁，包括上锁、解锁、自动续期。

此功能实现采用 Lua脚本实现，Lua脚本可以保证原子性。

setnx可以实现分布式锁，但是无法实现可重入锁，所以用hset来代替setnx实现可重入的分布式锁。

-- lock
if redis.call('exists',KEYS[1]) == 0 or redis.call('hexists',KEYS[1],ARGV[1]) == 1 then
    redis.call('hincrby',KEYS[1],ARGV[1],1)
    redis.call('expire',KEYS[1],ARGV[2])
    return 1
else
    return 0
end
-- unlock
if redis.call('hexists',KEYS[1],ARGV[1]) == 0 then
    return nil
elseif redis.call('hincrby',KEYS[1],ARGV[1],-1) == 0 then
    return redis.call('del',KEYS[1])
else
    return 0
end
-- expire
if redis.call('hexists',KEYS[1],ARGV[1]) == 0 then
    return redis.call('expire',KEYS[1],ARGV[2])
else
    return 0
end

2、工具类如下：

/**
 * @author xxx
 * @descpription: 自定义redis分布式锁
 * @date 2024/7/24
 */
public class MyRedissonLua implements Lock {

    /**
     *  加锁脚本
     */
    private static final String lockScript =
            "if redis.call('exists',KEYS[1]) == 0 or redis.call('hexists',KEYS[1],ARGV[1]) == 1 then " +
                    "redis.call('hincrby',KEYS[1],ARGV[1],1)    " +
                    "redis.call('expire',KEYS[1],ARGV[2])    " +
                    "return 1 " +
            "else    " +
                    "return 0 " +
            "end";
    /**
     * 解锁脚本
     */
    private static final String unLockScript =
            "if redis.call('HEXISTS',KEYS[1],ARGV[1]) == 0 then    " +
                    "return nil " +
            "elseif redis.call('HINCRBY',KEYS[1],ARGV[1],-1) == 0 then    " +
                    "return redis.call('del',KEYS[1]) " +
            "else    " +
                    "return 0 " +
            "end";

    /**
     *  续期脚本
     */
    private static final String expireScript =
            "if redis.call('HEXISTS',KEYS[1],ARGV[1]) == 0 then  " +
            "    return redis.call('EXPIRE',KEYS[1],ARGV[2])     " +
            "else " +
            "    return 0 " +
            "end";

    private StringRedisTemplate stringRedisTemplate;
    /**
     * KEYS[1]
     */
    private String lockName;
    /**
     * ARGV[1]
     */
    private String uuidValue;
    /**
     * ARGV[2]
     */
    private Long expireTime;

    public MyRedissonLua(StringRedisTemplate stringRedisTemplate, String lockName,String uuid) {
        this.stringRedisTemplate = stringRedisTemplate;
        this.lockName = lockName;
        this.uuidValue = uuid + ":" + Thread.currentThread().getId();
        this.expireTime = 30L;
    }

    @Override
    public void lock() {
        tryLock();
    }

    @Override
    public void unlock() {
        Long flag = stringRedisTemplate.execute(new DefaultRedisScript<>(unLockScript, Long.class), Arrays.asList(lockName), uuidValue);
        System.out.println("unlock lockName:" + lockName + "\tuuidValue:" + uuidValue + "\t expireTime:" + expireTime);
        if(flag == null) {
            throw new IllegalMonitorStateException("释放锁异常");
        }else {
            System.out.println("释放锁成功");
        }
    }

    @Override
    public boolean tryLock() {
        boolean result;
        try {
            result = tryLock(-1L, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        return result;
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        if (time == -1L){
            System.out.println("lockName:" + lockName + "\tuuidValue:" + uuidValue + "\t expireTime:" + expireTime);
            //可重入
            while (!stringRedisTemplate.execute(new DefaultRedisScript<>(lockScript, Boolean.class), Arrays.asList(lockName), uuidValue, String.valueOf(expireTime))){
                TimeUnit.MILLISECONDS.sleep(60);
            }
            //后台扫描程序，检测key的ttl，来实现续期
            reExpire();
            return true;
        }
        return false;
    }

    private void reExpire() {
        //每 10s 续期一次
        new Timer().schedule(new TimerTask(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " 续期");
                if (stringRedisTemplate.execute(new DefaultRedisScript<>(lockScript, Boolean.class), Arrays.asList(lockName), uuidValue, String.valueOf(expireTime))){
                    reExpire();
                }
            }
        },(this.expireTime * 1000) / 3);
    }

    @Override
    public void lockInterruptibly() {

    }

    @Override
    public Condition newCondition() {
        return null;
    }
}

3、由于实现分布式锁的方式有很多，故采用工厂模式

/**
 * @author xxx
 * @descpription: 工厂模式生产分布式锁
 * @date 2024/7/24
 */
@Component
public class DistributedLockFactory {

    private String lockName;
    private String uuid;

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    public DistributedLockFactory() {
        this.uuid = IdUtil.simpleUUID();
    }

    public Lock getDistributedLock(String lockType){
        if (lockType == null) {
            return null;
        }
        if (lockType.equals("REDIS")){
            lockName = "zzyyRedisLock";
            return new MyRedissonLua(stringRedisTemplate, lockName,uuid);
        } else if (lockType.equals("ZOOKEEPER")) {
            lockName = "zzyyZookeeperLock";
            //...Zookeeper版本的分布式锁
            return null;
        }
        return null;
    }
}

4、业务代码

import cn.hutool.core.util.IdUtil;
import com.coco.service.ICardService;
import com.coco.utils.lua.DistributedLockFactory;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.Arrays;
import java.util.Objects;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;

/**
 * @author xxx
 * @descpription: 
 * @date 2024/7/18
 */
@Service
public class ICardServiceImpl implements ICardService {
    

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    private static final String KEY = "sale001";

    @Value("${server.port}")
    private String port;

    @Resource
    private RedissonClient redissonClient;

    /**
     * 自定义的redis分布式锁
     */
//    private Lock lock = new MyRedissonLua(stringRedisTemplate, "zzyyRedisLock");
    /**
     * 通过工厂获取自定义的redis分布式锁
     */
    @Resource
    private DistributedLockFactory distributedLockFactory;

    @Override
    public String sale() {
        version7();
        return "success";
    }

    private void version7() {
        Lock lock = distributedLockFactory.getDistributedLock("REDIS");
        lock.lock();
        try{
            String countStr = stringRedisTemplate.opsForValue().get(KEY);
            Integer count = countStr == null ? 0 : Integer.parseInt(countStr);
            if (count > 0) {
                stringRedisTemplate.opsForValue().set(KEY,String.valueOf(--count));
                System.out.println("剩余库存为：" + stringRedisTemplate.opsForValue().get(KEY) + "服务端口：" + port);
                //演示自动续期
                try {TimeUnit.SECONDS.sleep(120);} catch (InterruptedException e) {throw new RuntimeException(e);}
            }else {
                System.out.println("没有库存了");
            }
        }finally {
            lock.unlock();
        }
    }

    /**
     * 可重入锁
     */
    private void version6() {
        Lock lock = distributedLockFactory.getDistributedLock("REDIS");
        lock.lock();
        try{
            String countStr = stringRedisTemplate.opsForValue().get(KEY);
            Integer count = countStr == null ? 0 : Integer.parseInt(countStr);
            if (count > 0) {
                stringRedisTemplate.opsForValue().set(KEY,String.valueOf(--count));
                System.out.println("剩余库存为：" + stringRedisTemplate.opsForValue().get(KEY) + "服务端口：" + port);
                //可重入
                testReEntry();
            }else {
                System.out.println("没有库存了");
            }
        }finally {
            lock.unlock();
        }
    }

    /**
     *  可重入锁
     */
    private void testReEntry() {
        Lock lock = distributedLockFactory.getDistributedLock("REDIS");
        lock.lock();
        try {
            System.out.println("===========再次获取锁=============");
        } finally {
            lock.unlock();
        }
    }

    /**
     * 通过Lua脚本实现分布式锁解锁
     */
    private void version5() {
        String key = "zzyyRedisLock";
        String uuidValue = IdUtil.simpleUUID() +":" + Thread.currentThread().getId();
        //分布式锁(自旋)
        while (!stringRedisTemplate.opsForValue().setIfAbsent(key, uuidValue,10,TimeUnit.SECONDS)) {
            try {TimeUnit.MILLISECONDS.sleep(20);} catch (InterruptedException e) {throw new RuntimeException(e);}
        }
        try {
            String countStr = stringRedisTemplate.opsForValue().get(KEY);
            Integer count = countStr == null ? 0 : Integer.parseInt(countStr);
            if (count > 0) {
                stringRedisTemplate.opsForValue().set(KEY,String.valueOf(--count));
                System.out.println("剩余库存为：" + stringRedisTemplate.opsForValue().get(KEY) + "服务端口：" + port);
            }else {
                System.out.println("没有库存了");
            }
        } finally {
            String script =
                    "if redis.call(\"get\",KEYS[1]) == ARGV[1] then\n" +
                    "    return redis.call(\"del\",KEYS[1])\n" +
                    "else\n" +
                    "    return 0\n" +
                    "end";
            stringRedisTemplate.execute(
                    new DefaultRedisScript<>(script, Boolean.class),
                    Arrays.asList(key), uuidValue);
        }
    }

    /**
     * 添加判断防止解锁解的不是同一把锁
     */
    private void version4() {
        String key = "zzyyRedisLock";
        String uuidValue = IdUtil.simpleUUID()+":" + Thread.currentThread().getId();
        //分布式锁(自旋)
        while (!stringRedisTemplate.opsForValue().setIfAbsent(key, uuidValue,10,TimeUnit.SECONDS)) {
            try {TimeUnit.MILLISECONDS.sleep(20);} catch (InterruptedException e) {throw new RuntimeException(e);}
        }
        try {
            String countStr = stringRedisTemplate.opsForValue().get(KEY);
            Integer count = countStr == null ? 0 : Integer.parseInt(countStr);
            if (count > 0) {
                stringRedisTemplate.opsForValue().set(KEY,String.valueOf(--count));
                System.out.println("剩余库存为：" + stringRedisTemplate.opsForValue().get(KEY) + "服务端口：" + port);
            }else {
                System.out.println("没有库存了");
            }
        } finally {
            if (Objects.equals(uuidValue, stringRedisTemplate.opsForValue().get(key))){
                stringRedisTemplate.delete(key);
            }
        }
    }

    /**
     * 通过setnx实现redis分布式锁
     */
    private void version3() {
        String key = "zzyyRedisLock";
        String uuidValue = IdUtil.simpleUUID()+":" + Thread.currentThread().getId();
        //分布式锁
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, uuidValue);
        if (flag) {
            try {
                String countStr = stringRedisTemplate.opsForValue().get(KEY);
                Integer count = countStr == null ? 0 : Integer.parseInt(countStr);
                if (count > 0) {
                    stringRedisTemplate.opsForValue().set(KEY,String.valueOf(--count));
                    System.out.println("剩余库存为：" + stringRedisTemplate.opsForValue().get(KEY) + "服务端口：" + port);
                }else {
                    System.out.println("没有库存了");
                }
            } finally {
                if (Objects.equals(uuidValue, stringRedisTemplate.opsForValue().get(key))){
                    stringRedisTemplate.delete(key);
                }
            }
        }else {
            try {TimeUnit.MILLISECONDS.sleep(20);} catch (InterruptedException e) {throw new RuntimeException(e);}
            sale();
        }
    }

    /**
     * juc的lock锁
     */
    private void version2() {
//        lock.lock();
//        try {
//            Integer count = (Integer) redisTemplate.opsForValue().get(KEY);
//            if (count > 0) {
//                redisTemplate.opsForValue().decrement(KEY);
//                System.out.println("剩余库存为：" + redisTemplate.opsForValue().get(KEY) + "服务端口：" + port);
//            }else {
//                System.out.println("没有库存了");
//            }
//        } finally {
//            lock.unlock();
//        }
    }
}

iteye_9939
关注
简述Redis分布式锁该怎么实现续期 ？
weixin_39291964的博客
06-30 344
Redis分布式锁续期的本质是。
使用Redis 分布式锁防止短信验证码重复下发问题
最新发布
longgelaile的博客
08-20 1139
本文针对短信验证码重复下发问题，提出基于Redis分布式锁的解决方案。通过为每个手机号/bizType创建短周期锁实现请求串行化，结合Lua脚本保证安全释放和发送时间记录进行二次校验。方案在保持低延迟（毫秒级）的同时有效防止重复发送，适用于分布式环境。文章详细解析了实现要点（锁设计、TTL设置、异常处理）、性能分析及常见问题应对策略，并提供了Java代码示例。建议配合限流风控策略使用，同时需完善监控（锁失败率、发送频率）和故障测试（并发、网络异常场景）。该方案以简单高效的方式解决了验证码重复下发痛点。
redis在使用lua脚本以及实现redis分布式锁
牧竹子
12-05 8547
目录背景介绍环境准备redis运行lua脚本访问次数限制java调用脚本操作redisLua+Redis 断点调试环境搭建 背景介绍 Redis在2.6推出了脚本功能，允许开发者使用Lua语言编写脚本传到Redis中执行。使用脚本的好处如下: 1.减少网络开销：本来5次网络请求的操作，可以用一个请求完成，原先5次请求的逻辑放在redis服务器上完成。使用脚本，减少了网络往返时延。 2.原子操作：R...
Redis+lua脚本实现分布式锁
qq_42945407的博客
03-31 1756
Redis+Lua脚本实现分布式锁
lua+redis：分布式锁解决方案分享
yangyufneg的博客
03-15 3469
分布式锁的是确保在多个进程或多个节点之间对共享资源的访问是有序、互斥和原子的，以避免竞态条件和数据不一致性问题。在多进程或多节点环境中，分布式锁广泛应用于协调共享资源的安全访问。
Reids实战——分布式锁优化（Lua脚本）
qq_59212867的博客
12-06 1504
Reids分布式锁优化，初识Lua脚本及其用法
Lua脚本在redis分布式锁场景的运用
沉默的夏虫
03-25 354
redis分布式锁，Lua，Lua脚本，lua redis，redis lua 分布式锁，redis setnx ,redis分布式锁， Lua脚本在redis分布式锁场景的运用。 目录 锁和分布式锁 锁是什么？ 为什么需要锁？ Java中的锁 分布式锁 redis 如何实现加锁 锁超时 retry redis 如何释放锁 不该释放的锁 通过Lua脚...
LUA脚本改造redis分布式锁
hguhbh的博客
07-29 1204
因为存在这样情况：线程一获取锁，去执行逻辑，过程中遇到网络动荡，线程一卡住了，然后一段时间后，线程一获取的锁的过期时间到了，线程一的锁自动释放。然后线程二来获取锁，线程二获取成功，去执行逻辑，而在这个过程中线程一的网络动荡恢复了，线程一继续执行，线程一先于线程二执行完，线程一去释放锁，但此时线程一创建的锁已经因超时而自动释放了，所以此时线程一会去错误的释放线程二的锁，所以我们要把线程id存入加以判断，防止误删其他线程的id。并不是一步一步的执行，所以只能用乐观锁但不建议用乐观锁，推荐用lua脚本。
手写Redis分布式锁
码上知新
02-11 760
指同一个线程可以多次获取同一个锁，而不会导致死锁或其他线程无法获取该锁的情况，可重入锁是一种特殊的锁，它允许一个线程在已经持有该锁的情况下，再次获取（或重入）该锁，而不会产生冲突或死锁，synchronized和ReentrantLock就是可重入性锁。当线程拥有锁之后，往后再遇到加锁⽅法，直接将加锁次数加 1，然后再执⾏⽅法逻辑。退出加锁⽅法之后，加锁次数再减 1，当加锁次数为 0 时，锁才被真正的释放。可以看到可重⼊锁最⼤特性就是计数，计算加锁的次数。
springboot整合Redis分布式锁最佳实践
qq_34197740的博客
07-09 4152
什么是分布式锁 在单机环境中，一般在多并发多线程场景下，出现多个线程去抢占一个资源，这个时候会出现线程同步问题，造成执行的结果没有达到预期。我们会用线程间加锁的方式，比如synchronized,lock,volatile,以及JVM并发包中提供的其他工具类去处理此问题。 但是随着技术的发展，分布式系统的出现，各个应用服务都部署在不同节点，由各自的JVM去操控，资源已经不是在 线程 之间的共享，而是变成了 进程 之间的共享，以上解决线程同步问题的办法已经无法满足。 因此，引入了分布式锁的概念。 分布式锁，既
WatchDog+Redis实现分布式锁
热门推荐
何忆清风
04-16 8万+
代码说明： watchDog机制主要是用来对redis中商品key进行锁续命，防止业务处理时间过长导致的误删key值。 lua脚本则用来对redis中指令的原子性操作，注意 lua脚本中不能有复杂逻辑，防止阻塞redis /** * 创建定时任务线程工厂 */ private static final ThreadFactory THREAD_FACTORY = new ThreadFactoryBuilder().setNameFormat("watchDog-").get()
使用Redis+Lua脚本实现分布式锁
Cure The World的博客
05-09 2417
1.1加锁 // 1. 从redis中获取锁,set k1 v1 px 20000 nx String uuid = UUID.randomUUID().toString(); Boolean lock = this.redisTemplate.opsForValue().setIfAbsent("lock", uuid, 2, TimeUnit.SECONDS); 使用Lua释放锁 // 2. 释放锁 del String script = "if redis.call('get', KEYS[1])
基于redis+lua脚本的分布式锁实现
weixin_50336269的博客
08-27 635
基于lua脚本的分布式锁实现
Redis分布式锁结合Lua脚本实现
m0_67363888的博客
07-30 820
通过 Lua 脚本，Redisson 能够确保分布式锁的一系列操作（获取锁、设置过期时间、释放锁）的原子性，这对于实现分布式锁等关键功能至关重要。Lua 脚本不仅可以确保操作的原子性，还能提高性能，因为它可以避免客户端和服务器之间的多次往返通信。
redis setnx + lua脚本实现分布式锁
fanghailiang2016的博客
11-29 610
redis setnx + lua脚本实现分布式锁
Redis的分布式锁问题（九）Redis + Lua 脚本实现分布式锁
金鳞踏雨
11-22 2660
如果脚本中的key、value不想写死，可以作为参数传递。key类型参数会放入KEYS数组，其它参数会放入ARGV数组，在脚本中可以从KEYS和ARGV数组获取这些参数。Lua脚本解决unLock业务流程 获取锁中的线程标示 判断是否与指定的标示（当前线程标示）一致 如果一致则释放锁（删除） 如果不一致则什么都不做
使用 Redis 和 Lua 实现分布式锁
BXA
06-10 4532
分布式锁是一种用于多台服务器上处理同一资源的并发访问的锁机制。它用于协调分布式系统中的各个节点，确保它们的操作不会相互干扰。Redis （Remote Dictionary Server）是一种使用 C 语言编写的，开源的 in-memory 数据库系统，支持多种数据结构类型，如字符串、哈希表、列表、集合等。由于其可高效地存储键值对，并且具有多种灵活的使用方式，因此经常被用作缓存、会话存储和消息队列等场景。
【Redis】利用Java代码调用Lua脚本改造分布式锁
qq_39921135的博客
08-07 1236
现在我们实现的分布式锁其实就已经是一个生产可用的、相对完善的分布式锁了。小总结：基于Redis的分布式锁实现思路：获取锁的时候利用set nx ex获取锁，set nx目的是互斥，确保只有一个线程能拿到锁，ex是一个兜底方案，防止宕机导致锁无法释放。释放锁时先判断线程标示是否与自己一致，一致则删除锁，防止误删并且使用Lua脚本保证它的原子性，这样避免在多线程的情况下因为阻塞导致的误删。那这样的分布式锁有什么特性呢？利用set nx满足互斥性。
Redis 实现分布式锁+执行lua脚本
qq_34285557的博客
03-22 2443
本篇主要一步步演进手写redis分布式锁的实现, 包括 setnx -> set -> 过期时间 -> 误删锁 -> uuid控制锁误删-> lua脚本控制删锁的原子性等等.. 其实目前还有问题, 包括锁续期问题以及redis 可重入锁的问题有机会在完善吧需要注意 redis 中如何使用 lua脚本的, 因为一些原子性操作就是需要lua脚本来控制 包括 redission 框架也是通过lua脚本实现的.
基于redis手写分布式锁
07-14
在分布式系统中，实现一个高效的分布式锁机制是保障资源互斥访问的关键。Redis 作为一种高性能的内存数据库，非常适合用于实现分布式锁。以下是基于 Redis 实现高效分布式锁的详细方案。 ### 加锁操作 加锁的核心在于确保多个节点之间对共享资源的互斥访问。可以通过 Redis 的 `SET` 命令结合特定参数来实现原子性的加锁操作。例如： ```bash SET lock_key unique_value NX PX 30000 ``` - `lock_key` 是锁的唯一标识。 - `unique_value` 是客户端生成的唯一值，用于标识当前持有锁的客户端。 - `NX` 表示只有当键不存在时才设置成功。 - `PX 30000` 设置键的过期时间为 30,000 毫秒（即 30 秒），防止死锁[^4]。 这种命令方式可以保证设置锁和设置超时时间的操作是原子性的，从而避免了因网络中断或其他问题导致的死锁。 ### 解锁操作 解锁需要确保只有持有锁的客户端才能释放它。这可以通过 Lua 脚本来实现，以保证解锁操作的原子性。以下是一个简单的 Lua 脚本示例： ```lua if redis.call("get", KEYS[1]) == ARGV[1] then return redis.call("del", KEYS[1]) else return 0 end ``` - `KEYS[1]` 是锁的键名。 - `ARGV[1]` 是客户端持有的唯一值。 通过这种方式，只有当客户端提供的唯一值与 Redis 中存储的值匹配时，才会执行删除操作，从而安全地释放锁。 ### 阻塞与非阻塞机制 根据业务需求，可以选择阻塞式或非阻塞式的锁获取策略。对于阻塞式锁，如果尝试获取锁失败，则会持续等待直到获得锁为止；而非阻塞式则立即返回结果而不进行等待。在实际应用中，通常采用轮询的方式，在一定时间内不断尝试获取锁，一旦超过设定的时间仍未成功，则放弃此次请求。 ### 异常处理 为了应对可能出现的各种异常情况，比如持有锁的服务实例突然宕机等，应为每个锁设置合理的超时时间。这样即使某个客户端未能正常释放锁，Redis 也会自动将其删除，从而防止整个系统陷入停滞状态[^4]。 ### 使用 Jedis 客户端实现 Java 开发者可以使用 Jedis 客户端库来与 Redis 进行交互。Jedis 提供了丰富的 API 支持，使得开发人员能够轻松地实现上述功能。例如，使用 Jedis 实现加锁逻辑如下所示： ```java public String acquireLock(Jedis jedis, String lockKey, String requestId, int expireTime) { String result = jedis.set(lockKey, requestId, "NX", "PX", expireTime); if ("OK".equals(result)) { return requestId; } return null; } ``` - `jedis` 是 Jedis 实例。 - `lockKey` 是锁的名称。 - `requestId` 是客户端标识。 - `expireTime` 是锁的有效期。 以上代码展示了如何利用 Jedis 设置带有过期时间和条件判断的锁。 ###
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值