Zookeeper开源客户端curator 分布式锁

最新推荐文章于 2024-07-23 10:29:11 发布
最新推荐文章于 2024-07-23 10:29:11 发布
阅读量421 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： # Zookeeper 文章标签： 分布式锁 zookeeper分布式锁 zookeeper 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Weixiaohuai/article/details/113569369

目录

一、概述

二、InterProcessMutex分布式可重入排它锁

三、InterProcessReadWriteLock读写锁

四、总结

一、概述

前面我们已经介绍过zookeeper是分布式锁的实现方案之一，它是利用临时有序节点的特性来保证唯一性的。

Zookeeper分布式锁原理：

  • 获取锁

在zookeeper中，一个分布式锁对应到zookeeper中的一个文件夹，每个客户端线程请求获取分布式锁的时候，就需要在这个文件夹创建一个临时有序节点，有两种情况：

  • 1）、创建的临时顺序节点是文件夹下的第一个节点，则认为是获取分布式锁成功；
  • 2）、创建的临时顺序节点不是文件夹下的第一个节点，则认为当前锁已经被另一个客户端线程获取，此时当前线程进入阻塞等待，这个时候它会监听上一个节点【序号小于当前节点的节点】，等待前一个节点释放锁的时候唤醒当前线程；

阻塞-唤醒逻辑：把文件夹下的节点顺序排一下序，找到当前节点的前一个节点，使用watcher机制监听前面一个节点的变化，当前一个节点被删除时会触发Watch事件，进而唤醒当前阻塞的线程。

如果前一个节点对应的客户端崩溃了，则节点对应的Watch事件也会触发，也会唤醒后一个节点对应的客户端线程，此时仍需要判断当前节点是第一个节点之后才能获取锁，否则继续进入阻塞并监听前面一个节点。

  • 可重入性

当某个客户端线程第一次获取锁成功之后，在JVM内存中的一个ConcurrentMap中存储当前线程对应的锁路径及重入次数，后面同一个线程再次获取锁时，先检查该Map中当前锁是否已被当前线程占用即可，如果已占用，则只需要递增重入次数即可。

注意：只考虑同一个客户端、同一个线程获取同一个分布式锁的可重入性。

  • 释放锁

释放锁时，首先将锁的重入次数减一，然后判断重入次数是否已经为0：

  • 1）如果重入次数为0，则删除当前客户端线程对应的临时顺序节点，删除操作会触发此节点的Watch事件，如果有别的客户端线程正在阻塞等待，则会通过Watch机制唤醒；
  • 2）如果重入次数非0，则说明还未完全释放锁，直接返回即可；

二、InterProcessMutex分布式可重入排它锁

package com.wsh.zookeeper.zookeeperapidemo.curator;

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.locks.InterProcessLock;
import org.apache.curator.framework.recipes.locks.InterProcessMutex;
import org.apache.curator.retry.ExponentialBackoffRetry;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class CuratorInterProcessMutexDemo {

    private static final Logger logger = LoggerFactory.getLogger(CuratorInterProcessMutexDemo.class);
    private static final String ZOOKEEPER_SERVER_ADDRESS = "192.168.179.128:2181,192.168.179.129:2181,192.168.179.133:2181";

    /**
     * Curator对象
     */
    private static CuratorFramework curatorFramework;

    static {
        //初始化curator对象
        curatorFramework = CuratorFrameworkFactory
                .builder()
                //会话超时时间
                .sessionTimeoutMs(5000)
                //服务器集群地址
                .connectString(ZOOKEEPER_SERVER_ADDRESS)
                //重试策略
                .retryPolicy(new ExponentialBackoffRetry(1000, 3))
                .build();
        //开启客户端
        curatorFramework.start();
    }


    private static void getLock(InterProcessLock interProcessLock) {
        try {
            interProcessLock.acquire();
            logger.info("线程：" + Thread.currentThread().getName() + "获取锁成功......");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                interProcessLock.release();
                logger.info("线程：" + Thread.currentThread().getName() + "释放锁成功......");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        //分布式可重入排它锁
        InterProcessMutex interProcessMutex = new InterProcessMutex(curatorFramework, "/distributeLock");
        new Thread(() -> getLock(interProcessMutex), "T1").start();
        new Thread(() -> getLock(interProcessMutex), "T2").start();
        new Thread(() -> getLock(interProcessMutex), "T3").start();
        new Thread(() -> getLock(interProcessMutex), "T4").start();
    }

}

运行程序，观察后端日志：

14:41:37.532 [T2] INFO com.wsh.zookeeper.zookeeperapidemo.curator.CuratorInterProcessMutexDemo - 线程：T2获取锁成功......
14:41:37.538 [T2] INFO com.wsh.zookeeper.zookeeperapidemo.curator.CuratorInterProcessMutexDemo - 线程：T2释放锁成功......

14:41:37.543 [T4] INFO com.wsh.zookeeper.zookeeperapidemo.curator.CuratorInterProcessMutexDemo - 线程：T4获取锁成功......
14:41:37.554 [T4] INFO com.wsh.zookeeper.zookeeperapidemo.curator.CuratorInterProcessMutexDemo - 线程：T4释放锁成功......

14:41:37.555 [T3] INFO com.wsh.zookeeper.zookeeperapidemo.curator.CuratorInterProcessMutexDemo - 线程：T3获取锁成功......
14:41:37.559 [T3] INFO com.wsh.zookeeper.zookeeperapidemo.curator.CuratorInterProcessMutexDemo - 线程：T3释放锁成功......

14:41:37.560 [T1] INFO com.wsh.zookeeper.zookeeperapidemo.curator.CuratorInterProcessMutexDemo - 线程：T1获取锁成功......
14:41:37.564 [T1] INFO com.wsh.zookeeper.zookeeperapidemo.curator.CuratorInterProcessMutexDemo - 线程：T1释放锁成功......

如上可见，多个线程争夺一个共享锁的时候，相互之间是互斥的。流程分析如下图所示：

三、InterProcessReadWriteLock读写锁

curator实现了跨JVM的可重入读写互斥锁。读写锁包含了读锁、写锁两个，它们的互斥关系如下：

  • 1）读写互斥；
  • 2）写写互斥；
  • 3）读读不互斥；

案例：读写互斥

package com.wsh.zookeeper.zookeeperapidemo.curator;

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.locks.InterProcessMutex;
import org.apache.curator.framework.recipes.locks.InterProcessReadWriteLock;
import org.apache.curator.retry.ExponentialBackoffRetry;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class CuratorInterProcessReadWriteLockDemo {

    private static final Logger logger = LoggerFactory.getLogger(CuratorInterProcessReadWriteLockDemo.class);
    private static final String ZOOKEEPER_SERVER_ADDRESS = "192.168.179.128:2181,192.168.179.129:2181,192.168.179.133:2181";

    /**
     * Curator对象
     */
    private static CuratorFramework curatorFramework;
    /**
     * curator读锁对象
     */
    private static InterProcessMutex readLock;
    /**
     * curator写锁对象
     */
    private static InterProcessMutex writeLock;

    static {
        //初始化curator对象
        curatorFramework = CuratorFrameworkFactory
                .builder()
                //会话超时时间
                .sessionTimeoutMs(5000)
                //服务器集群地址
                .connectString(ZOOKEEPER_SERVER_ADDRESS)
                //重试策略
                .retryPolicy(new ExponentialBackoffRetry(1000, 3))
                .build();
        //开启客户端
        curatorFramework.start();
        InterProcessReadWriteLock interProcessReadWriteLock = new InterProcessReadWriteLock(curatorFramework, "/distribute-lock");
        readLock = interProcessReadWriteLock.readLock();
        writeLock = interProcessReadWriteLock.writeLock();
    }

    public static void main(String[] args) {
        new Thread(() -> {
            try {
                readLock.acquire();
                logger.info("线程：" + Thread.currentThread().getName() + "获取读锁...");
                Thread.sleep(3000);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    readLock.release();
                    logger.info("线程：" + Thread.currentThread().getName() + "释放读锁...");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, "T1").start();

        new Thread(() -> {
            try {
                Thread.sleep(2000);
                writeLock.acquire();
                logger.info("线程：" + Thread.currentThread().getName() + "获取写锁...");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    writeLock.release();
                    logger.info("线程：" + Thread.currentThread().getName() + "释放写锁...");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, "T2").start();
    }

}
15:22:11.460 [T1] INFO com.wsh.zookeeper.zookeeperapidemo.curator.CuratorInterProcessReadWriteLockDemo - 线程：T1获取读锁...
15:22:14.468 [T1] INFO com.wsh.zookeeper.zookeeperapidemo.curator.CuratorInterProcessReadWriteLockDemo - 线程：T1释放读锁...

15:22:14.470 [T2] INFO com.wsh.zookeeper.zookeeperapidemo.curator.CuratorInterProcessReadWriteLockDemo - 线程：T2获取写锁...
15:22:14.473 [T2] INFO com.wsh.zookeeper.zookeeperapidemo.curator.CuratorInterProcessReadWriteLockDemo - 线程：T2释放写锁...

由上日志可见，读锁先获取到锁资源后，写锁必须等待锁释放之后，才能获取锁。

案例：读读不互斥

package com.wsh.zookeeper.zookeeperapidemo.curator;

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.locks.InterProcessMutex;
import org.apache.curator.framework.recipes.locks.InterProcessReadWriteLock;
import org.apache.curator.retry.ExponentialBackoffRetry;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class CuratorInterProcessReadWriteLockDemo {

    private static final Logger logger = LoggerFactory.getLogger(CuratorInterProcessReadWriteLockDemo.class);
    private static final String ZOOKEEPER_SERVER_ADDRESS = "192.168.179.128:2181,192.168.179.129:2181,192.168.179.133:2181";

    /**
     * Curator对象
     */
    private static CuratorFramework curatorFramework;
    /**
     * curator读锁对象
     */
    private static InterProcessMutex readLock;
    /**
     * curator写锁对象
     */
    private static InterProcessMutex writeLock;

    static {
        //初始化curator对象
        curatorFramework = CuratorFrameworkFactory
                .builder()
                //会话超时时间
                .sessionTimeoutMs(5000)
                //服务器集群地址
                .connectString(ZOOKEEPER_SERVER_ADDRESS)
                //重试策略
                .retryPolicy(new ExponentialBackoffRetry(1000, 3))
                .build();
        //开启客户端
        curatorFramework.start();
        InterProcessReadWriteLock interProcessReadWriteLock = new InterProcessReadWriteLock(curatorFramework, "/distribute-lock");
        readLock = interProcessReadWriteLock.readLock();
        writeLock = interProcessReadWriteLock.writeLock();
    }

    public static void main(String[] args) {
        new Thread(() -> {
            try {
                readLock.acquire();
                logger.info("线程：" + Thread.currentThread().getName() + "获取读锁...");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    readLock.release();
                    logger.info("线程：" + Thread.currentThread().getName() + "释放读锁...");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, "T1").start();

        new Thread(() -> {
            try {
                readLock.acquire();
                logger.info("线程：" + Thread.currentThread().getName() + "获取读锁...");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    readLock.release();
                    logger.info("线程：" + Thread.currentThread().getName() + "释放读锁...");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, "T2").start();
    }

}
15:32:30.347 [T2] INFO com.wsh.zookeeper.zookeeperapidemo.curator.CuratorInterProcessReadWriteLockDemo - 线程：T2获取读锁...
15:32:30.347 [T1] INFO com.wsh.zookeeper.zookeeperapidemo.curator.CuratorInterProcessReadWriteLockDemo - 线程：T1获取读锁...

15:32:30.354 [T1] INFO com.wsh.zookeeper.zookeeperapidemo.curator.CuratorInterProcessReadWriteLockDemo - 线程：T1释放读锁...
15:32:30.354 [T2] INFO com.wsh.zookeeper.zookeeperapidemo.curator.CuratorInterProcessReadWriteLockDemo - 线程：T2释放读锁...

 由上面的日志可见，两个读线程之间获取锁资源的话，是可以同时获取到锁的，并不互斥。

案例：写写互斥

package com.wsh.zookeeper.zookeeperapidemo.curator;

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.locks.InterProcessMutex;
import org.apache.curator.framework.recipes.locks.InterProcessReadWriteLock;
import org.apache.curator.retry.ExponentialBackoffRetry;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class CuratorInterProcessReadWriteLockDemo {

    private static final Logger logger = LoggerFactory.getLogger(CuratorInterProcessReadWriteLockDemo.class);
    private static final String ZOOKEEPER_SERVER_ADDRESS = "192.168.179.128:2181,192.168.179.129:2181,192.168.179.133:2181";

    /**
     * Curator对象
     */
    private static CuratorFramework curatorFramework;
    /**
     * curator读锁对象
     */
    private static InterProcessMutex readLock;
    /**
     * curator写锁对象
     */
    private static InterProcessMutex writeLock;

    static {
        //初始化curator对象
        curatorFramework = CuratorFrameworkFactory
                .builder()
                //会话超时时间
                .sessionTimeoutMs(5000)
                //服务器集群地址
                .connectString(ZOOKEEPER_SERVER_ADDRESS)
                //重试策略
                .retryPolicy(new ExponentialBackoffRetry(1000, 3))
                .build();
        //开启客户端
        curatorFramework.start();
        InterProcessReadWriteLock interProcessReadWriteLock = new InterProcessReadWriteLock(curatorFramework, "/distribute-lock");
        readLock = interProcessReadWriteLock.readLock();
        writeLock = interProcessReadWriteLock.writeLock();
    }

    public static void main(String[] args) {
        new Thread(() -> {
            try {
                writeLock.acquire();
                logger.info("线程：" + Thread.currentThread().getName() + "获取写锁...");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    writeLock.release();
                    logger.info("线程：" + Thread.currentThread().getName() + "释放写锁...");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, "T1").start();

        new Thread(() -> {
            try {
                writeLock.acquire();
                logger.info("线程：" + Thread.currentThread().getName() + "获取写锁...");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    writeLock.release();
                    logger.info("线程：" + Thread.currentThread().getName() + "释放写锁...");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, "T2").start();
    }

}
15:33:28.701 [T1] INFO com.wsh.zookeeper.zookeeperapidemo.curator.CuratorInterProcessReadWriteLockDemo - 线程：T1获取写锁...
15:33:28.706 [T1] INFO com.wsh.zookeeper.zookeeperapidemo.curator.CuratorInterProcessReadWriteLockDemo - 线程：T1释放写锁...

15:33:28.711 [T2] INFO com.wsh.zookeeper.zookeeperapidemo.curator.CuratorInterProcessReadWriteLockDemo - 线程：T2获取写锁...
15:33:28.717 [T2] INFO com.wsh.zookeeper.zookeeperapidemo.curator.CuratorInterProcessReadWriteLockDemo - 线程：T2释放写锁...

如上日志可见，两个线程同时尝试获取锁资源的时候，某个时刻只会有一个线程能获取成功，其他线程必须等待释放锁后才能尝试去获取锁。

四、总结

本文主要总结了curator分布式锁的实现原理，以及通过案例详解介绍了curator的可重入排它锁以及读写锁的使用，在分布式系统开发中，实现分布式锁的方式有很多种，如数据库方式、redis、zookeeper等，具体根据业务场景选择合适的即可。

Zookeeper 随笔（一）：使用 Curator 框架实现 ZooKeeper 分布式锁
weixin_43870380的博客
10-18 1125
实现分布式锁目前有三种流行方案，分别为基于数据库、Redis、Zookeeper 的方案，我们来看下使用 Zookeeper 如何实现分布式锁
Curator+Zookeeper实现分布式锁的示例
最新发布
潜心学习+快乐编程+事业=人生
09-09 1313
随着互联网的兴起，应用的单服务器部署已无法满足日益增长的用户需求，此时云服务+分布式技术应用而生，解决了应用弹性伸缩的问题。问题来了，分布式不同于单机，在单机应用下可以使用Java的并发编程API实现对共享资源的控制，而在分布式应用系统环境则可以借助Zookeeper来实现，Apache的顶级开源项目Curator则是为了更加方便操作Zookeeper而产生的Java项目。本文基于Curator+Zookeeper实现各种分布式锁，以实现分布式环境下对有限共享资源的并发访问。
基于zookeeper+curator的分布式锁代码实现
suodod的博客
12-13 425
zookeeper的配置和安装请移步zookeeper的安装 分布式锁的可选择性一般常用的为redis的分布式锁和zookeeper的分布式锁,redis是以一个key值作为唯一,zookeeper是以创建的临时节点下的子节点来创建一个唯一,redis分布式锁请移步基于redisson的分布式锁 下面是具体的代码实现 依赖 <dependency> <groupId>org.apache.curator</groupId> <artifac.
关于分布式锁的整理
咕噜噜的博客
03-28 3499
基于redis的分布式锁 基于zookeeper的分布式锁
分布式基础：Curator实现Zookeeper分布式锁
ReturnTmp的博客
07-21 2863
官网的说法curator是一个Java/JVM客户端库，用于zookeeper，一个分布式协调服务。它包括一个高级API框架和实用程序，使ApacheZooKeeper的使用更加简单和可靠。它还包括常见用例和扩展的方法，如服务发现和Java8异步DSL。Curator使用手册-腾讯云开发者社区-腾讯云配置zookeeper集群参考;https。...........................
ZooKeeper实战之ZkClient客户端实现分布式锁
JustryDeng
12-07 2615
声明：此博客为学习笔记，学习自极客学院ZooKeeper相关视频；本文内容是本人照着视频里的前辈所讲知识敲了 一遍的记录，个别地方按照本人理解稍作修改。非常感谢众多大牛们的知识分享。 分布式锁：多线程锁，是用于在高并发多线程时保证共享资源的访问的；而分布式锁则用于：在分布式环境下，保 护跨进程、跨主机、跨网络的共享资源，实现互斥访问，保...
Zookeeper客户端框架Curator使用实践
小小默：进无止境
07-23 589
Curator是netflix公司开源的一套zookeeper客户端，目前是Apache的顶级项目。与Zookeeper提供的原生客户端相比，Curator的抽象层次更高，简化了Zookeeper客户端的开发量。Curator解决了很多zookeeper客户端非常底层的细节开发工作，包括连接重连、反复注册wathcer和NodeExistsException 异常等。
Zookeeper开源客户端框架Curator简介与示例
08-11
Curator 是一个基于 ZooKeeper 的开源客户端框架，它为 ZooKeeper 提供了高级抽象和功能，使得开发人员能够更方便地使用 ZooKeeper。 **Curator 框架概述** Curator 包含多个模块，如 ZooKeeper 客户端连接管理、...
一文彻底理解ZooKeeper分布式锁的实现原理
01-20
在本篇文章中，我们将深入探讨如何利用Curator这个流行的开源框架，实现基于ZooKeeper的分布式锁。 一、ZooKeeper分布式锁概述 分布式锁是解决分布式环境下资源同步问题的关键工具。在多客户端环境中，为了保证...
Curator实现zookeeper分布式锁
一般社员的博客
11-02 257
Curator框架解决分布式锁问题
ZooKeeper ： Curator框架之分布式锁InterProcessSemaphoreMutex
kaven
01-17 953
InterProcessSemaphoreMutex A NON re-entrant mutex that works across JVMs. Uses Zookeeper to hold the lock. All processes in all JVMs that use the same lock path will achieve an inter-process critical section. 跨JVM工作的非可重入互斥锁。使用Zookeeper来持有锁。所有JVM中使用相同锁路径
Myabtis源码分析四-缓存模块分析 ，装饰模式的使用(1)
2401_83916435的博客
05-01 477
分享一套我整理的面试干货，这份文档结合了我多年的面试官经验，站在面试官的角度来告诉你，面试官提的那些问题他最想听到你给他的回答是什么，分享出来帮助那些对前途感到迷茫的朋友。
Zookeeper的分布式锁例子（Curator）
duke_ding2的博客
12-17 444
Zookeeper的分布式锁例子（Curator）
ZooKeeper架构篇 - Curator分布式锁
The Secret
08-18 698
本文分析Curator提供的几种分布式锁。
zookeeper 分布式锁_Apache Curator+Zookeeper 实现分布式锁 入门篇
weixin_39525355的博客
12-01 114
Zookeeper实现分布式锁需要满足以下条件1、在分布式系统环境下，一个方法在同一时间只能被一个机器的一个线程执行；2、高可用的获取锁与释放锁；3、高性能的获取锁与释放锁；4、具备可重入特性；5、具备锁失效机制，防止死锁；6、具备非阻塞锁特性，即没有获取到锁将直接返回获取锁失败。用原生的Zookeeper API接口实现分布式锁不仅仅需要考虑锁机制问题，还需要解决持续监听、session超时、级...
【Zookeeper】分布式锁案例（原生、Curator）
See_Star的博客
11-11 1186
Zookeeper分布式锁，原生分布式锁案例，Curator矿建实现分布式锁案例。
Zookeeper分布式锁实现Curator
qq_36864672的博客
02-18 224
当需要加读锁的时候，会去判断自己创建节点的前面有没有写锁，如果没写锁，那么说明前面加的都是读锁，那么读锁就能加锁成功，读读不互斥，如果前面有写锁，那么就加锁失败（自己加的写锁除外），读写互斥。前面说过，判断有没有加锁成功，会返回一个PredicateResults，这里面包含了有没有加锁成功的信息，同时如果没有加锁成功，就会返回需要监听的节点，也就是当前创建的节点的前一个节点。此时如果第二次来加锁，那么就会从threadData中获取到加锁的信息，然后将加锁次数加1，就代表了加锁成功，然后直接返回。
ZooKeeper框架Curator分布式锁实现及源代码分析
稀有气体的技术博客
11-09 6299
本原创入门教程，涵盖ZooKeeper核心内容，通过实例和大量图表，结合实战，帮助学习者理解和运用，任何问题欢迎留言。 目录： zookeeper介绍与核心概念 安装和使用 ZooKeeper分布式锁实现 ZooKeeper框架Curator分布式锁实现及源代码分析 zookeeper 开发实战（java客户端） 上一篇文章中，我们使用zookeeper的java api实现了分布式排...
开源工具（二）分布式代理锁
m0_69270256的博客
05-23 8291
在项目中使用封装的分布式代理锁已经很久了，想着做的更完善通用一点开源共享。 gitee地址：https://gitee.com/tingmailang/distributed-proxy-lock 开源的工具除了支持redisson之外还支持spring redis加锁，通过参数获取锁后缀的方式也更加灵活，可以看出工具演变的过程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

每天都要进步一点点

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

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

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

打赏作者

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

抵扣说明：

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

余额充值