RedLock加锁源码分析

原创 已于 2022-05-10 14:09:38 修改 · 773 阅读 · 0 ·
CC 4.0 BY-SA版权
鹿少年
文章标签：

#java #开发语言

于 2022-05-08 18:50:01 首次发布
本文详细解读了Redisson库中RLock的实现，包括加锁操作、lockInterruptibly方法的工作原理，以及如何通过leaseTime设置锁的持有时间和看门狗机制。重点介绍了tryAcquire和scheduleExpirationRenewal等关键方法的内部逻辑。

目录

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 571
本篇主要讲解Redisson中得RedLock实现，但是很多知识因为和前面一样，就直接省略了 RedLock 原理理一下： （1）获取当前时间戳，单位是毫秒 （2）和RedissonMultiLock一样，一次轮询尝试去每个机器上创建锁，需要加一个超时时间，如果超过一定时间就表示获取锁失败 （3）尝试在大多数节点上建立一个锁，如果3个节点就要求创建 n/2 + 1 = 2个节点上创建锁 （4）客户端计算建立锁的时间，如果在规定时间内，建立锁成功，就代表加锁成功 （5）如果建立锁失败，那么就会依次
7.【Redisson源码】RedLock红锁加锁流程
weixiaohuai的博客
01-06 3655
红锁其实也并不能解决根本问题，只是降低问题发生的概率。完全相互独立的redis，每一台至少也要保证高可用，还是会有主从节点。既然有主从节点，在持续的高并发下，master还是可能会down机，从节点可能还没来得及同步锁的数据。很有可能多个主节点也发生这样的情况，那么问题还是回到一开始的问题，红锁只是降低了发生的概率。其实，在实际场景中，红锁是很少使用的。这是因为使用了红锁后会影响高并发环境下的性能，使得程序的体验更差。所以，在实际场景中，我们一般都是要保证Redis集群的可靠性。
Redlock原理分析
ZERO
07-16 702
转载自：https://blog.youkuaiyun.com/b644ROfP20z37485O35M/article/details/89369482      Redlock全名叫做 Redis Distributed Lock;即使用redis实现的分布式锁。使用场景：多个服务间保证同一时刻同一时间段内同一用户只能有一个请求（防止关键业务出现并发攻击）；官网文档地址如下：https://redis.i...
分布式锁：Redisson的联锁和红锁
最新发布
weixin_46619605的博客
10-09 1274
分布式锁：Redisson的联锁和红锁
redis多实例分布式锁：Python实现redlock分布式锁算法代码示例
学亮编程手记
05-08 603
Redlock是一种分布式锁算法，它可以在多个Redis实例之间协调锁。Redlock算法的基本思想是，使用多个Redis实例来协调锁，以确保在任何情况下都不会出现死锁或竞争条件。Redlock算法的实现比较复杂，需要考虑多个因素，例如时钟漂移、网络延迟等。
Redis分布式锁-Redisson源码分析
qq_33189393的博客
05-10 383
Redisson分布式锁实现源码分析
分布式锁—Redisson的公平锁
kfashfasf的博客
08-14 1010
一.非公平可重入锁锁被释放后，排队获取锁的线程会重新无序获取锁，没有任何顺序性可言。二.公平可重入锁锁被释放后，排队获取锁的线程会按照请求获取锁时候的顺序去获取锁。公平锁可以保证线程获取锁的顺序，与其请求获取锁的顺序是一样的。也就是谁先申请获取到这把锁，谁就可以先获取到这把锁。公平可重入锁会把各个线程的加锁请求进行排队处理，保证先申请获取锁的线程，可以优先获取锁，从而实现所谓的公平性。三.可重入的非公平锁和公平锁不同点可重入的非公平锁和公平锁，在整体的技术实现框架上都是一样的。
第二十章_Redis分布式锁Redlock算法和底层源码分析
sinat_31583645的博客
06-06 1131
首先，我们假设客户端能够在大多数实例中获取锁所有实例都将包含一个具有相同生存时间的密钥，然而，这个key是在不用时间设置的，所以过期也会在不同的时间过期，假设第一个key设置时间T1，最后一个key设置时间t2，我们确定第一个key的过期时间至少是MIN_VALIDITY=TTL-(T2-T1)-CLOCK_DRIFT，所以所有的key设置超时至少是这个时间，在设置大多数密钥期间，另一个客户端将无法获取锁，因为如果已经存在N/2+1个密钥，则N/2+1 set NX操作无法成功。
分布式锁：红锁redLock和联锁multiLock源码分析
qq_28807077的博客
12-17 621
原文链接：https://blog.youkuaiyun.com/u013066244/article/details/109766759 long leaseTime = 3L; lock.lock(leaseTime, TimeUnit.SECONDS); RedissonRedLock redLock = new RedissonRedLock(lock); // 有参数的情况 redLock.lock(leaseTime, TimeUnit.SECONDS); /** * leaseTime租约时
Redisson Lock源码分析
m0_70448456的博客
07-09 733
1.如果搞了 主-从：的方式用红锁 ， 但是本身还是存在那种套娃的问题（A返回，B返回但是B挂了B的从此时没有，C有获得另一个线程的锁，这样有出现了刚才的问题）读写锁怎么实现的： 用lua脚本写的hset结构，读的绑定的mode是read,写的是write，通过可冲入的方式，保证了读读可以执行，每次读都+1。8:串行转并发，对于redis无的，读缓存再放入redis里，操作，可以加tryLock，等待时间为一次完整执行的时间。对于Redisson的优化，对于读多写少的场景可以使用读写锁；
Redisson 分布式锁实现分析（一）
zuokaopuqingnian的博客
09-29 1188
  设计分布式锁要注意的问题 互斥 分布式系统中运行着多个节点，必须确保在同一时刻只能有一个节点的一个线程获得锁，这是最基本的一点。 死锁 分布式系统中，可能产生死锁的情况要相对复杂一些。分布式系统是处在复杂网络环境中的，当一个节点获取到锁，如果它在释放锁之前挂掉了，或者因网络故障无法执行释放锁的命令，都会导致其他节点无法申请到锁。 因此分布式锁有必要设置时效，确保在未来的一定时间内，...
Redission源码浅析一：RedissonLock.lock与RedissonLock.tryLock
一只小星星
08-25 1998
加锁时，如果没有指定过期时间，则默认过期时间为30s且每隔10s进行锁续期操作。
【redis学习篇】Redisson实现的分布式独占锁核心流程剖析
热门推荐
一个勤勤恳恳的程序猿
03-13 1万+
我们可以看到，在前面加锁的时候其实已经subscribe了这个channel，所有解锁publish了这个解锁的消息，之前创建的监听任务就可以监听到这个解锁消息。接下来我们来看看，监听到消息后的处理。
Redisson实现分布式锁原理
程序猿进阶
12-09 2772
Redisson实现分布式锁原理 一、高效分布式锁 当我们在设计分布式锁的时候，我们应该考虑分布式锁至少要满足的一些条件，同时考虑如何高效的设计分布式锁，这里我认为以下几点是必须要考虑的。 1、互斥 在分布式高并发的条件下，我们最需要保证，同一时刻只能有一个线程获得锁，这是最基本的一点。 2、防止死锁 在分布式高并发的条件下，比如有个线程获得锁的同时，还没有来得及去释放锁，就因为系统故障或者其它原因使它无法执行释放锁的命令,导致其它线程都无法获得锁，造成死锁。所以分布式非常有必要设置锁的有效时间，确保系统
redis--20.2--锁--分布式锁(Redisson，RLock)
zhou920786312的博客
03-30 2144
在上面任务调度的方法中，也是异步执行并且设置了一个监听器，在操作执行成功之后，会回调这个方法，如果调用失败会打一个错误日志并返回，更新锁过期时间失败；然后获取异步执行的结果，如果为true，就会调用本身，如此说来又会延迟10秒钟去执行这段逻辑，所以，这段逻辑在你成功获取到锁之后，会每隔十秒钟去执行一次，并且，在锁key还没有失效的情况下，会把锁的过期时间继续延长到30 秒，也就是说只要这台服务实例没有挂掉，并且没有主动释放锁，看门狗都会每隔十秒给你续约一下，保证锁一直在你手中。类型，这里key是指。
redisson分布式锁php实现,Redisson实现分布式锁—RedissonLock
weixin_39556811的博客
03-10 269
摘要：ock的lockInterruptibly()接下来执行流程,这里理下关键几步/***1、带上默认值调另一个中断锁方法*/@OverridepublicvoidlockInterruptibly()throwsInterruptedException{lockInterruptibly(-1,null);}/***2、另一个中断锁的方法*/voidlockInterruptibly(long...
Redisson分布式锁RedissonLock介绍
张俊杰 的博客
02-09 6146
转载地址 https://www.cnblogs.com/qdhxhz/p/11055426.html RedissonLock 这篇主要讲RedissonLock和RLock。Redisson分布式锁的实现是基于RLock接口，RedissonLock实现RLock接口。 一、RLock接口 1、概念 public interface RLock extends Lock, RExpirable, RLockAsync 很明显RLock是继承Lock锁，所以他有Lock锁的所有特性，比如lock、unl
Redis 做分布式锁的常见问题和解决方案
西木风落
01-14 3131
redis 做分布式锁的三个核心要素： 1、加锁 最简单的命令是setnx，key是锁的唯一标识，按业务来决定命名，value为当前线程的线程ID。当一个线程执行setnx返回1，说明key原本不存在，该线程成功得到了锁，当其他线程执行setnx返回0，说明key已经存在，该线程抢锁失败。 2、解锁 当得到锁的线程执行完任务，需要释放锁，以便其他线程可以进入。释放锁的最简单方式是执行del...
Redisson分布式锁学习总结：RedissonMultiLock 如何同时锁住N个资源
Howinfun的博客
11-26 6429
Redisson分布式锁学习总结：RedissonMultiLock 如何同时锁住多个资源
Java分布式锁示例源码分析与实践(Redission)
- 红锁（RedLock） - 读写锁（Read-Write Lock） - 信号量（Semaphore） - 可过期性信号量（PermitExpirableSemaphore） - 闭锁（CountDownLatch） 这些锁提供了丰富的功能和灵活的控制方式，可以满足不同场景下的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

程序员路同学

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

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

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

打赏作者

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

抵扣说明：

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

余额充值