RedLock加锁源码分析

已于 2022-05-10 14:09:38 修改
阅读量698 收藏
点赞数
分类专栏： Redis 文章标签： java 开发语言
于 2022-05-08 18:50:01 首次发布
鹿少年
本文链接：https://blog.csdn.net/huanglu0314/article/details/124598870
版权

目录

Redis获取锁

加锁操作

lockInterruptibly

unLock

Redis获取锁

首先了解下Redisson，获取RLock  RedissionLock

   public RLock getLock(String name) {
        return new RedissonLock(connectionManager.getCommandExecutor(), name);
    }

   //公平锁
    public RLock getFairLock(String name) {
        return new RedissonFairLock(connectionManager.getCommandExecutor(), name);
    }
    //读写锁
    public RReadWriteLock getReadWriteLock(String name) {
        return new RedissonReadWriteLock(connectionManager.getCommandExecutor(), name);
    }

加锁操作

 public void lock() {      

  try {
            lockInterruptibly();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }


  public void lock(long leaseTime, TimeUnit unit) {
        try {
            lockInterruptibly(leaseTime, unit);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

首先解析下Lock()方法，该方法不传递参数，主要方法 lockInterruptibly();下面进入该方法查看

public void lockInterruptibly() throws InterruptedException {
    lockInterruptibly(-1, null);
}
public void lockInterruptibly(long leaseTime, TimeUnit unit)

参数 leaseTime 持有锁的时长

参数unit 时间单位

lockInterruptibly

接着开始解析lockInterruptibly(long leaseTime, TimeUnit unit)方法

 public void lockInterruptibly(long leaseTime, TimeUnit unit) throws InterruptedException {
        //拿到线程Id 当面获取锁的线程唯一的
        long threadId = Thread.currentThread().getId();
        //得到锁的有效时长
        Long ttl = tryAcquire(leaseTime, unit, threadId);
        // lock acquired
        if (ttl == null) {
            return;
        }
        //订阅 开启异步线程去监听
        RFuture<RedissonLockEntry> future = subscribe(threadId);
        commandExecutor.syncSubscription(future);

        try {
          //循环直到锁失效 /释放
            while (true) {
                ttl = tryAcquire(leaseTime, unit, threadId);
                // lock acquired
                if (ttl == null) {
                    break;
                }

                // waiting for message
                if (ttl >= 0) {
                    getEntry(threadId).getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);
                } else {
                    getEntry(threadId).getLatch().acquire();
                }
            }
        } finally {
           //结束异步线程订阅
            unsubscribe(future, threadId);
        }
//        get(lockAsync(leaseTime, unit));
    }

分步讲解：

1：进入方法

Long tryAcquire(long leaseTime, TimeUnit unit, long threadId)
private Long tryAcquire(long leaseTime, TimeUnit unit, long threadId) {
    return get(tryAcquireAsync(leaseTime, unit, threadId));
}
 <T> RFuture<Long> tryAcquireAsync(long leaseTime, TimeUnit unit, final long threadId)

该方法就是得到一个RFuture 异步定时任务，后面会定时去更新这个锁的有效时间

protected <V> V get(RFuture<V> future) {
    return commandExecutor.get(future);
}

拿到这个定时任务每次更新得到的剩余有效时间

 查看一下 tryAcquireAsync 方法

private <T> RFuture<Long> tryAcquireAsync(long leaseTime, TimeUnit unit, final long threadId) {
 //对于 Lock()无参而言  leaseTime =-1 会走下一步
    if (leaseTime != -1) {
        return tryLockInnerAsync(leaseTime, unit, threadId, RedisCommands.EVAL_LONG);
    }
//拿到获取剩下有效时长的Future
    RFuture<Long> ttlRemainingFuture = tryLockInnerAsync(commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout(), TimeUnit.MILLISECONDS, threadId, RedisCommands.EVAL_LONG);
    ttlRemainingFuture.addListener(new FutureListener<Long>() {
        @Override
        public void operationComplete(Future<Long> future) throws Exception {
            if (!future.isSuccess()) {
                return;
            }

            Long ttlRemaining = future.getNow();
            // lock acquired
            if (ttlRemaining == null) {
                scheduleExpirationRenewal(threadId);
            }
        }
    });
    return ttlRemainingFuture;
}
ttlRemainingFuture.addListener(new FutureListener<Long>(){})

会交给netty去执行，开启异步线程

执行监听的时候执行逻辑是这样的 

Long ttlRemaining = future.getNow() 返回null
接着执行scheduleExpirationRenewal(threadId)

commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout() 

这个是获取看门狗超时时长 

private long lockWatchdogTimeout = 30 * 1000; 默认时长3秒

也就是默认是持有锁的时间是30秒 ，如果当面线程加锁成功会给加锁setnx  key value expire 30s

public long getLockWatchdogTimeout() {
    return lockWatchdogTimeout;
}

接着看 

<T> RFuture<T> tryLockInnerAsync(long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand<T> command) {
  //时间转换为毫秒 这里T是Long类型  要get()的结果就是锁的剩余有效时长单位毫秒
    internalLockLeaseTime = unit.toMillis(leaseTime);
   
    return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, command,
              "if (redis.call('exists', KEYS[1]) == 0) then " +
                  "redis.call('hset', KEYS[1], ARGV[2], 1); " +
                  "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                  "return nil; " +
              "end; " +
              "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
                  "redis.call('hincrby', KEYS[1], ARGV[2], 1); " +
                  "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                  "return nil; " +
              "end; " +
              "return redis.call('pttl', KEYS[1]);",
                Collections.<Object>singletonList(getName()), internalLockLeaseTime, getLockName(threadId));
}

ARGV[1] = internalLockLeaseTime

ARGV[2]=getLockName(threadId)  

String getLockName(long threadId) {
    return id + ":" + threadId;
}

主要就是去执行下面这段luna脚本的，首选判断redis key是否存在，key就是getName()，也就是你使用锁的时候加锁的名称redission.getLock(lockName),第一个线程加锁肯定是不存在的可以继续操作，也就是set命令执行写操作 value就是getLockName(threadId)  ,然后设置有效时长

"if (redis.call('exists', KEYS[1]) == 0) then " + "redis.call('hset', KEYS[1], ARGV[2], 1); " + "redis.call('pexpire', KEYS[1], ARGV[1]); " + "return nil; " + "end; " + "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " + "redis.call('hincrby', KEYS[1], ARGV[2], 1); " + "redis.call('pexpire', KEYS[1], ARGV[1]); " + "return nil; " + "end; " + "return redis.call('pttl', KEYS[1]);", Collections.<Object>singletonList(getName()),

如果再往下面看就是执行 下面的逻辑的，这些暂不介绍

public <T, R> RFuture<R> evalWriteAsync(String key, Codec codec, RedisCommand<T> evalCommandType, String script, List<Object> keys, Object... params) {
    NodeSource source = getNodeSource(key);
    return evalAsync(source, false, codec, evalCommandType, script, keys, params);
}

 真正执行的这段luna脚本 eval script args 

 会在redis里写入key USER_LOCK_KEY_1 value  46b48db8-9759-41c5-9108-ab1f41ee17a0:73 

pexpire  30000

 回到tryAcquireAsync方法，将key value写进redis后会返回一个RFuture，这东西继承了Future

public interface RFuture<V> extends java.util.concurrent.Future<V>, CompletionStage<V>

然后添加线程监听器，监听锁的有效时间是否过时或者锁是否已经被释放

接着看下面这个方法

private void scheduleExpirationRenewal(final long threadId)

根据方法名就可以知道，该方法就是重新设置过期时间的，会根据当前的线程Id去获取线程加的锁，去查看锁的有效时间，根据定时任务去每次间隔三分之一的internalLockLeaseTim时间执行一次

 再回到方法

<T> RFuture<Long> tryAcquireAsync(long leaseTime, TimeUnit unit, final long threadId) 

可以知道获取到ttlRemainingFuture后就会开启监听，启动线程一直去定时刷新锁的剩余时间，直到锁被释放

接着 看lockInterruptibly（）方法

RFuture<RedissonLockEntry> future = subscribe(threadId);
commandExecutor.syncSubscription(future);

 subscriber是redis的消息订阅模式，会执行PublishSubscribe类的方法

public RFuture<E> subscribe(final String entryName, final String channelName, final PublishSubscribeService subscribeService) {
    final AtomicReference<Runnable> listenerHolder = new AtomicReference<Runnable>();
    final AsyncSemaphore semaphore = subscribeService.getSemaphore(channelName);
    final RPromise<E> newPromise = new RedissonPromise<E>() {
        @Override
        public boolean cancel(boolean mayInterruptIfRunning) {
            return semaphore.remove(listenerHolder.get());
        }
    };

    Runnable listener = new Runnable() {

        @Override
        public void run() {
            E entry = entries.get(entryName);
            if (entry != null) {
                entry.aquire();
                semaphore.release();
                entry.getPromise().addListener(new TransferListener<E>(newPromise));
                return;
            }
            
            E value = createEntry(newPromise);
            value.aquire();
            
            E oldValue = entries.putIfAbsent(entryName, value);
            if (oldValue != null) {
                oldValue.aquire();
                semaphore.release();
                oldValue.getPromise().addListener(new TransferListener<E>(newPromise));
                return;
            }
            
            RedisPubSubListener<Object> listener = createListener(channelName, value);
            subscribeService.subscribe(LongCodec.INSTANCE, channelName, semaphore, listener);
        }
    };
    semaphore.acquire(listener);
    listenerHolder.set(listener);
    
    return newPromise;
}

后面就是简单的一个循环，在while循环里面调用tryAcquire 方法 更新锁的有效时间，最后取消订阅

while (true) {
    ttl = tryAcquire(leaseTime, unit, threadId);
    // lock acquired
    if (ttl == null) {
        break;
    }

    // waiting for message
    if (ttl >= 0) {
        getEntry(threadId).getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);
    } else {
        getEntry(threadId).getLatch().acquire();
    }
} finally {
    unsubscribe(future, threadId);
}

unLock

redission.unLock()

  public void unlock() {
        Boolean opStatus = get(unlockInnerAsync(Thread.currentThread().getId()));
        if (opStatus == null) {
            throw new IllegalMonitorStateException("attempt to unlock lock, not locked by current thread by node id: "
                    + id + " thread-id: " + Thread.currentThread().getId());
        }
        if (opStatus) {
            cancelExpirationRenewal();
        }

//        Future<Void> future = unlockAsync();
//        future.awaitUninterruptibly();
//        if (future.isSuccess()) {
//            return;
//        }
//        if (future.cause() instanceof IllegalMonitorStateException) {
//            throw (IllegalMonitorStateException)future.cause();
//        }
//        throw commandExecutor.convertException(future);
    }

执行redis del 语句

protected RFuture<Boolean> unlockInnerAsync(long threadId) {
    return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
            "if (redis.call('exists', KEYS[1]) == 0) then " +
                "redis.call('publish', KEYS[2], ARGV[1]); " +
                "return 1; " +
            "end;" +
            "if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then " +
                "return nil;" +
            "end; " +
            "local counter = redis.call('hincrby', KEYS[1], ARGV[3], -1); " +
            "if (counter > 0) then " +
                "redis.call('pexpire', KEYS[1], ARGV[2]); " +
                "return 0; " +
            "else " +
                "redis.call('del', KEYS[1]); " +
                "redis.call('publish', KEYS[2], ARGV[1]); " +
                "return 1; "+
            "end; " +
            "return nil;",
            Arrays.<Object>asList(getName(), getChannelName()), LockPubSub.unlockMessage, internalLockLeaseTime, getLockName(threadId));

}

取消定时任务续命锁的有效时间

void cancelExpirationRenewal() {
    Timeout task = expirationRenewalMap.remove(getEntryName());
    if (task != null) {
        task.cancel();
    }
}

 取消任务取消的是 netty开启的 时间轮定时任务Timer 

HashedWheelTimer 类
public boolean cancel() {
    // only update the state it will be removed from HashedWheelBucket on next tick.
    if (!compareAndSetState(ST_INIT, ST_CANCELLED)) {
        return false;
    }
    // If a task should be canceled we put this to another queue which will be processed on each tick.
    // So this means that we will have a GC latency of max. 1 tick duration which is good enough. This way
    // we can make again use of our MpscLinkedQueue and so minimize the locking / overhead as much as possible.
    timer.cancelledTimeouts.add(this);
    return true;
}

记住上面在执行 tryAcquireAsync方法的时候，对于leaseTime是否传入值，会走不同的方法，再看下

private <T> RFuture<Long> tryAcquireAsync(long leaseTime, TimeUnit unit, final long threadId) {

if (leaseTime != -1) {
    return tryLockInnerAsync(leaseTime, unit, threadId, RedisCommands.EVAL_LONG);
}
RFuture<Long> ttlRemainingFuture = tryLockInnerAsync(commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout(), TimeUnit.MILLISECONDS, threadId, RedisCommands.EVAL_LONG);
ttlRemainingFuture.addListener(new FutureListener<Long>(){

  ......

        if (ttlRemaining == null) {
            scheduleExpirationRenewal(threadId);
        }
     }
  }
    return ttlRemainingFuture;
}

如果你使用的是这个方法 

lock.lock(10,TimeUnit.SECONDS);是不会启动看门狗后台任务刷新锁的有效时间的为初始值30秒的

因为它没走下面的scheduleExpirationRenewal(threadId); 方法

通用的道理，对于

lock.tryLock(10,30,TimeUnit.SECONDS);
lock.lockInterruptibly(10,TimeUnit.SECONDS);

这些方法，因为已经传入默认的持有锁的时间，所以是不会走看门狗监听任务去续命锁的时间的

下面的两个方法可以获取看门狗监听任务刷新锁有效时间

lock.lockInterruptibly(); 
lock.tryLock(10,TimeUnit.SECONDS); 表示多线程下不同线程去强占锁的时候会等待10秒，如果10秒钟没有或得锁，就获取不到，需要等待，如果10秒内能够获取到锁就直接执行，不同于Lock(),这个没有等待时间

程序员路同学
关注
专栏目录
Redisson 源码初探（八） RedLock
wangxuelei036的博客
02-27 352
本篇主要讲解Redisson中得RedLock实现，但是很多知识因为和前面一样，就直接省略了 RedLock 原理理一下： （1）获取当前时间戳，单位是毫秒 （2）和RedissonMultiLock一样，一次轮询尝试去每个机器上创建锁，需要加一个超时时间，如果超过一定时间就表示获取锁失败 （3）尝试在大多数节点上建立一个锁，如果3个节点就要求创建 n/2 + 1 = 2个节点上创建锁 （4）客户端计算建立锁的时间，如果在规定时间内，建立锁成功，就代表加锁成功 （5）如果建立锁失败，那么就会依次
分布式锁：红锁redLock和联锁multiLock源码分析
qq_28807077的博客
12-17 527
原文链接：https://blog.csdn.net/u013066244/article/details/109766759 long leaseTime = 3L; lock.lock(leaseTime, TimeUnit.SECONDS); RedissonRedLock redLock = new RedissonRedLock(lock); // 有参数的情况 redLock.lock(leaseTime, TimeUnit.SECONDS); /** * leaseTime租约时
Redlock原理分析
ZERO
07-16 565
转载自：https://blog.csdn.net/b644ROfP20z37485O35M/article/details/89369482      Redlock全名叫做 Redis Distributed Lock;即使用redis实现的分布式锁。使用场景：多个服务间保证同一时刻同一时间段内同一用户只能有一个请求（防止关键业务出现并发攻击）；官网文档地址如下：https://redis.i...
redis多实例分布式锁：Python实现redlock分布式锁算法代码示例
学亮编程手记
05-08 340
Redlock是一种分布式锁算法，它可以在多个Redis实例之间协调锁。Redlock算法的基本思想是，使用多个Redis实例来协调锁，以确保在任何情况下都不会出现死锁或竞争条件。Redlock算法的实现比较复杂，需要考虑多个因素，例如时钟漂移、网络延迟等。
Redis分布式锁-Redisson源码分析
qq_33189393的博客
05-10 293
Redisson分布式锁实现源码分析
Redisson实现分布式锁原理
程序猿进阶
12-09 2274
Redisson实现分布式锁原理 一、高效分布式锁 当我们在设计分布式锁的时候，我们应该考虑分布式锁至少要满足的一些条件，同时考虑如何高效的设计分布式锁，这里我认为以下几点是必须要考虑的。 1、互斥 在分布式高并发的条件下，我们最需要保证，同一时刻只能有一个线程获得锁，这是最基本的一点。 2、防止死锁 在分布式高并发的条件下，比如有个线程获得锁的同时，还没有来得及去释放锁，就因为系统故障或者其它原因使它无法执行释放锁的命令,导致其它线程都无法获得锁，造成死锁。所以分布式非常有必要设置锁的有效时间，确保系统
基于后端开发Redisson实现分布式锁源码分析解读
Linuxhus的博客
08-10 218
一、分布式锁的概念和使用场景 分布式锁是控制分布式系统之间同步访问共享资源的一种方式。 　　在分布式系统中，常常需要协调他们的动作。如果不同的系统或是同一个系统的不同主机之间共享了一个或一组资源，那么访问这些资源的时候，往往需要互斥来防止彼此干扰来保证一致性，这个时候，便需要使用到分布式锁。 C/C++Linux后端开发技术点讲解内容知识点包括Linux，Nginx，ZeroMQ，MySQL，Redis，线程池，MongoDB，ZK，Linux内核，CDN，P2P，epoll，Docker，TCP/I
redisson 实现分布式锁的原理，源码分析
qq_40987088的博客
03-13 670
先上图，加锁场景和解锁场景。 加锁逻辑： redisson使用lua脚本操作redis来进行加锁，因为lua脚本中的代码逻辑在redis中执行能够保证原子性。 这个lua脚本就是加锁的核心代码，分析一下内容。 KEYS[1]就是要加锁的key，ARGV[1]是加锁超时时间，ARGV[2]是加锁线程唯一标识。 首先判断key是否存在； 若不存在则代表无锁状态，接下来设置锁信息，field为线程唯一标识，value是加锁次数，然后设置key的超时时间，最后返回nil，意味着获得了锁。 .
Redis分布式锁升级：RedLock+SpringBoot
lt_xiaodou的博客
10-10 733
在一个分布式系统中，多台机器上部署了多个服务，当客户端一个用户发起一个数据插入请求时，如果没有分布式锁机制保证，那么那多台机器上的多个服务可能进行并发插入操作，导致数据重复插入，对于某些不允许有多余数据的业务来说，这就会造成问题。而分布式锁机制就是为了解决类似这类问题，保证多个服务之间互斥的访问共享资源，如果一个服务抢占了分布式锁，其他服务没获取到锁，就不进行后续操作。实现分布式锁的一个非常重要的点就是set的value要具有唯一性，redisson的value是怎样保证value的唯一性呢？
分布式红锁的leaseTime的设计原理
INGNIGHT的专栏
06-23 3717
3.分布式红锁的leaseTime的设计原理 提前做2个动作: 1.先把3台 redis key全部清空（为了不受debug干扰，必须先删除锁） 127.0.0.1:6379> flushdb OK 都设置为30分钟超时 过期 2.isLock = redLock.tryLock(10006030, 10006030, TimeUnit.MILLISECONDS); leaseTime就是租约时间，就是redis key的过期时间。 long newLeaseTime = -1; if (leaseT
lock ，tryLock lockInterruptibly 区别
浩子的博客
03-29 1970
ReentrantLock 锁有好几种，除了常用的lock ，tryLock ，其中有个lockInterruptibly 。 先把API粘贴上来 lock public void lock() 获取锁。 如果该锁没有被另一个线程保持，则获取该锁并立即返回，将锁的保持计数设置为 1。 如果当前线程已经保持该锁，则将保持计数加 1，并且该方法立即返回。 如果该锁被另一个线程保持，则出于线程调
redission 分布式锁
weixin_34029949的博客
01-03 2190
https://my.oschina.net/haogrgr/blog/469439   分布式锁和Redisson实现 Aug 20, 2017 CONTENTS 概述 分布式锁特性 Redis实现之Redisson原理 概述 分布式系统有一个著名的理论CAP，指在一个分布式系统中，最多只能同时满足一致性（Consistency）、可用性（Availability）和分区容错性（Pa...
Redis深入理解六 ：Redis 分布式锁 以及 Redisson 锁续命分析、读写锁
Men-DD
03-29 6910
简单redis锁实现（思考问题） @Autowired private StringRedisTemplate stringRedisTemplate; public String testRedisLock() { String lockKey = "lock:product:1"; String clientId = UUID.randomUUID().toString(); Boolean result = stringRedisTempl
Redis 分布式锁与 Redlock 算法实现
BXA
08-24 1054
Redis是一款基于内存的高性能键值对数据库，通过提供多种数据类型支持，满足了大部分的应用场景，常用的数据类型有字符串、哈希表、列表、集合和有序集合等。在Redis中，可以使用多种方式实现分布式锁，如使用SETNX命令或RedLock算法。
分布式锁和Redisson实现
GY的的专栏
07-30 2476
概述 分布式系统有一个著名的理论CAP，指在一个分布式系统中，最多只能同时满足一致性（Consistency）、可用性（Availability）和分区容错性（Partition tolerance）这三项中的两项。所以在设计系统时，往往需要权衡，在CAP中作选择。当然，这个理论也并不一定完美，不同系统对CAP的要求级别不一样，选择需要考虑方方面面。 在微服务系统中，一个请求存在多级跨服务调用...
Redis分布式锁之：RedLock
小小少年的博客
12-04 3586
redLock也是Redis提供的一个分布式锁，和redissonLock有些区别 是什么 RedLock可以指定等待时间，也就是说，假如我指定了等待时间waitTime是2S，比如： 1.A线程来加锁，正常去执行业务逻辑 2.B线程也来加锁，此时会加锁失败，那B线程最多等待2S，如果超过了2S还没有获取到分布式锁，那B线程加锁就返回false，表示加锁失败 redLock的思想是： redLock的使用，需要有奇数台独立部署的Redis节点 在加锁的时候，会分别去N台节点上加锁，如果半数以上的节点加锁成
lockInterruptibly 和lock的区别
z69183787的专栏
09-13 2883
lockInterruptibly 与 lock比较区别在于  lockInterruptibly 优先考虑响应中断，而不是响应锁定的普通获取或重入获取  Java代码   package test;      import java.util.concurrent.TimeUnit;   import java.util.concurrent.locks.Lo
7.【Redisson源码】RedLock红锁加锁流程
weixiaohuai的博客
01-06 2924
红锁其实也并不能解决根本问题，只是降低问题发生的概率。完全相互独立的redis，每一台至少也要保证高可用，还是会有主从节点。既然有主从节点，在持续的高并发下，master还是可能会down机，从节点可能还没来得及同步锁的数据。很有可能多个主节点也发生这样的情况，那么问题还是回到一开始的问题，红锁只是降低了发生的概率。其实，在实际场景中，红锁是很少使用的。这是因为使用了红锁后会影响高并发环境下的性能，使得程序的体验更差。所以，在实际场景中，我们一般都是要保证Redis集群的可靠性。
redLock与redis实现并发控制
最新发布
weixin_41721295的博客
04-09 157
多个并发，下一个请求依赖上一个请求的处理结果，因此需求让多个并发处于队列中，依次执行。egg.js + nodejs包redlock + redis。
redisson加锁失败
10-21
RedissonLock和RedLock底层都有加锁失败的场景处理。当一个线程A在加锁失败之后，会返回当前已经加锁的线程B还有多久到期，然后线程A就会休眠指定的时间，然后再进行加锁。具体来说，RedissonLock在加锁失败时，会...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员路同学

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值