Redis实现分布式锁

最新推荐文章于 2024-09-27 11:30:45 发布
最新推荐文章于 2024-09-27 11:30:45 发布
阅读量82 收藏
点赞数
文章标签： 数据库 lua java
原文链接：https://my.oschina.net/u/2474629/blog/1635636
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

一、Redis set命令

set key value [ex seconds] [px milliseconds] [nx|xx]

ex: seconds：为键设置秒级过期时间。

px: milliseconds：为键设置毫秒级过期时间。

nx：键必须不存在，才可以设置成功，用于添加。

xx：与nx相反，键必须存在，才可以设置成功，用于更新。

二、Redis事务相关的命令

主要有multi，exec，watch，discard

将一组需要一起执行的命令放到multi和exec两个命令之间。multi命令代表事务开始，exec命令代表事务结束，它们之间的命令是原子顺序执行的，可以使用discard命令替换exec表示放弃事务。

在multi和exec之间的命令其实是被加入一个队列中的，直到执行exec命令才一次执行，所有我们可以看到multi和exec直接的名返回的是QUEUED。

WATCH命令可以监控一个或多个键，一旦其中有一个键被修改（或删除），之后的事务就不会执行。监控一直持续到EXEC命令

注意:Redis是不支持事务回滚的，也就是说如果multi和exec命令之间的命令只执行了一些，另一些因为错误终止，也不会回退到最初的状态。

三、Redis 与 Luau相关

使用eval执行脚本：

eval 脚本内容 key个数 key列表 参数列表
eval 'return "hello " .. KEYS[1] .. ARGV[1]' 1 redis world

注意Lua脚本的下标是从1开始的。

Lua使用redis.call函数实现对Redis的操作：

redis.call("set", "hello", "world")
redis.call("get", "hello")
eval 'return redis.call("get", KEYS[1])' 1 hello "world"

Lua除了使用redis.call函数，还可以使用redis.pcall函数实现对Redis的调用，redis.call和redis.pcall的不同在于，如果redis.call执行失败，那么脚本执行结束会直接返回错误，而redis.pcall会忽略错误继续执行脚本

使用evalsha执行脚本：

evalsha 脚本SHA1值 key个数 key列表 参数列表
evalsha 7413dc2440db1fea7c0a0bde841fa68eefaf149c 1 redis world

evalsha只是用脚本文件的sha1的值替换了eval的脚本内容而已，本质和eval是一样的。

四、通过set来实现获取锁

先看一下代码:

 /**
     * 尝试获取分布式锁
     * @param lockKey 锁名称
     * @param requestId 获取锁客户端标识 只有获取客户端能够释放锁
     * @param expireTime 超时时间，避免死锁
     * @return
     */
    public static boolean getLock(String lockKey, String requestId, long expireTime) {
        Jedis jedis = null;
        try {
            String result;
            synchronized (setLock) {//避免多个线程同时执行，全部获取失败
                jedis = pool.getResource();
                if (jedis == null)
                    return false;
                result = jedis.set(lockKey, requestId, NOT_EXIST, P_EXPIRE_TIME, expireTime);
            }
            if (SUCCESS.equals(result)) {
                return true;
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            jedis.close();
        }
        return false;
    }

有4个要注意的地方：

  1. 使用set key value [ex | px] nx这个命令保证原子性和超时时间，避免死锁
  2. 使用requestId来标志加锁的客户端，保证释放的时候是同一个客户端
  3. 把获取jedis连接的代码放在同步块中，避免多个线程阻塞连接耗尽的问题
  4. 注意jedis不是线程安全的

五、使用事务相关命令来释放锁

public static void releaseLock(String lockKey, String requestId) {
        Jedis jedis = null;
        try {
            jedis = pool.getResource();
            if(jedis == null)
                return;
            jedis.watch(lockKey);//避免因为锁超时，其他客户端重新获取到锁情况的误释放锁
            final String rid = jedis.get(lockKey);
            final Transaction transaction = jedis.multi();
            if (requestId.equals(rid)) {
                transaction.del(lockKey);
            }
            transaction.exec();//不要放在if里面避免共享连接时候watch没有释放
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            jedis.close();
        }
    }
  1. 使用watch命令，避免get命令之后lockKey超时其他客户端设置了新值情况的误释放锁
  2. get不要放在multi中，因为multi是队列返回的是queue，exec才执行
  3. 虽然只有一个del命令还是使用multi，exec吧，watch命令必须exec来释放

六、使用Lua脚本来释放锁

public static void releaseLockByLua(String lockKey, String requestId) {
        Jedis jedis = null;
        try {
            jedis = pool.getResource();
            if (jedis == null)
                return;
            String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
            jedis.eval(script, Collections.singletonList(lockKey), Collections.singletonList(requestId));
        }finally {
            jedis.close();
        }
    }

好像使用Lua脚本比较简洁，没有什么可以说的。

七、使用Redisson锁

public static void redissonCountPlusPlus(){
        RLock lock = redisson.getLock(COUNT_LOCK);
        boolean isLock = false;
        do {
            try {
                isLock = lock.tryLock(2,10,TimeUnit.SECONDS);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }while (!isLock);
        for(int i=0;i<100;i++)
            count++;
        lock.unlock();
    }

使用Redison封装的锁来实现感觉比较简单，和JDK只带的锁风格一致。想上面的：

lock.tryLock(2,10,TimeUnit.SECONDS);

就是尝试获取锁，最多等2秒,10秒之后自动释放锁。

还可以直接使用

lock.lock()

这个会阻塞，这个有可能永远挂起的风险

后面附录完整的代码，有一个简单的本地测试，不是分布式的，可以参考一下。

八、附录

链接

Redisson

Redisson官网

完整代码

import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.Transaction;

import java.util.Collections;
import java.util.UUID;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public final class RedisDislock {

    private static final String SUCCESS = "OK";

    private static final String NOT_EXIST = "NX";

    private static final String P_EXPIRE_TIME = "PX";

    private  static JedisPool pool = new JedisPool();

    private  static RedissonClient redisson;

    private static final Object setLock = new Object();

    private static int count = 0;

    public static final String COUNT_LOCK = "COUNT_LOCK";

    static {
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(200);
        config.setMaxIdle(100);
        config.setMaxWaitMillis(20000);
        config.setTestOnBorrow(false);
        config.setTestOnReturn(false);
        pool = new JedisPool(config,"localhost");

        Config rconfig = new Config();
        rconfig.useSingleServer().setAddress("127.0.0.1:6379");
        redisson = Redisson.create(rconfig);
    }

    /**
     * 尝试获取分布式锁
     * @param lockKey 锁名称
     * @param requestId 获取锁客户端标识 只有获取客户端能够释放锁
     * @param expireTime 超时时间，避免死锁
     * @return
     */
    public static boolean getLock(String lockKey, String requestId, long expireTime) {
        Jedis jedis = null;
        try {
            String result;
            synchronized (setLock) {//避免多个线程同时执行，全部获取失败
                jedis = pool.getResource();
                if (jedis == null)
                    return false;
                result = jedis.set(lockKey, requestId, NOT_EXIST, P_EXPIRE_TIME, expireTime);
            }
            if (SUCCESS.equals(result)) {
                return true;
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            jedis.close();
        }
        return false;
    }

    public static void releaseLock(String lockKey, String requestId) {
        Jedis jedis = null;
        try {
            jedis = pool.getResource();
            if(jedis == null)
                return;
            jedis.watch(lockKey);//避免因为锁超时，其他客户端重新获取到锁情况的误释放锁
            final String rid = jedis.get(lockKey);
            final Transaction transaction = jedis.multi();
            if (requestId.equals(rid)) {
                transaction.del(lockKey);
            }
            transaction.exec();//不要放在if里面避免共享连接时候watch没有释放
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            jedis.close();
        }
    }

    public static void releaseLockByLua(String lockKey, String requestId) {
        Jedis jedis = null;
        try {
            jedis = pool.getResource();
            if (jedis == null)
                return;
            String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
            jedis.eval(script, Collections.singletonList(lockKey), Collections.singletonList(requestId));
        }finally {
            jedis.close();
        }
    }

    public static void main(String[] args) {
        final ExecutorService es = Executors.newCachedThreadPool();
        for(int i=0;i<100;i++){
            es.submit(new Runnable() {
                @Override
                public void run() {
                    countPlusPlus();
//                    redissonCountPlusPlus();
                }
            });
        }
        es.shutdown();
        while (true){
            if(es.isTerminated()){
                System.out.println(count);
                break;
            }
        }
        System.out.println("done");
    }

    public static void countPlusPlus() {
        String uuid = UUID.randomUUID().toString().replaceAll("-", "");
        boolean lock;
        do{
            lock = getLock(COUNT_LOCK, uuid, 1000);
        }while (!lock);
        for(int i=0;i<100;i++)
            count++;
//        releaseLock(COUNT_LOCK, uuid);
        releaseLockByLua(COUNT_LOCK, uuid);
    }

    public static void redissonCountPlusPlus(){
        RLock lock = redisson.getLock(COUNT_LOCK);
        boolean isLock = false;
        do {
            try {
                isLock = lock.tryLock(2,10, TimeUnit.SECONDS);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }while (!isLock);
        for(int i=0;i<100;i++)
            count++;
        lock.unlock();
    }
}

部分pom

<properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring.version>4.3.6.RELEASE</spring.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.11</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.1.2</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
            <version>1.1.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>3.9</version>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.3.2</version>
        </dependency>
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>21.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml-schemas</artifactId>
            <version>3.9</version>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml</artifactId>
            <version>3.9</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.6.1</version>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>org.codehaus.jackson</groupId>
            <artifactId>jackson-mapper-asl</artifactId>
            <version>1.9.13</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.40</version>
        </dependency>

        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.1.2</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.7.0</version>
        </dependency>

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.7.0</version>
        </dependency>

        <dependency>
            <groupId>taglibs</groupId>
            <artifactId>standard</artifactId>
            <version>1.1.2</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.2.8</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.2.2</version>
        </dependency>

        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>3.7.2</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.35</version>
            <type>jar</type>
            <scope>compile</scope>
        </dependency>


        <!-- COMMONS BEGIN -->
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>commons-pool</groupId>
            <artifactId>commons-pool</artifactId>
            <version>1.6</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.1</version>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.6</version>
        </dependency>

        <!--test-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>3.2.13.RELEASE</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

转载于:https://my.oschina.net/u/2474629/blog/1635636

weixin_34364071
关注
Redis实现分布式锁(附源码+讲义)
07-01
分布式锁有很多种解决方案，今天我们要讲的是怎么使用缓存数据库Redis来实现分布式锁。 课程目标:  理解redis分布式锁的应用场景  掌握redis分布式锁的实现原理  掌握redis分布式锁在微服务项目中的应用  掌握...
redis实现分布式锁,自旋式加锁,lua原子性解锁
07-16
本文将深入探讨如何使用Redis实现分布式锁，以及如何利用自旋式加锁和Lua脚本实现原子性解锁。 首先，我们来理解分布式锁的基本概念。分布式锁是在多节点之间共享资源时，用于协调各个节点的访问控制机制。在分布式...
Redis分布式锁实现
zp_zhang的博客
11-06 149
一，Jedis分布式锁实现——单点     1，Jar包引入 &lt;!-- https://mvnrepository.com/artifact/redis.clients/jedis --&gt; &lt;dependency&gt; &lt;groupId&gt;redis.clients&lt;/groupId&gt; &lt;artifactId&g...
多线程-ReentrantLock的tryLock和tryLock(long time, TimeUnit unit)在获取失败后还会执行吗？是否会抛出异常
u013282737的博客
11-03 1370
答案是：会，还会继续执行下面的代码。不会进入异常。 因此实际业务中，需要按照tryLock的返回值，进行判断后执行后面的业务代码 package test; import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * @author ：sunshine * @date ：Created
多线程环境中lock.trylock方法争抢锁
一只猿的自我修养
01-10 2559
在多线程或分布式环境中，经常需要用到锁，trylock有两种用法，一种是不带参数：不设置等待时间，获取失败立即返回false。另一种是带等待时间的，线程会先挂起等待设置的时间结束如果还未获取到锁则返回false。 下面来看一个多线程争抢锁的实例： public void execWithLock(Lock lock, Supplier<Boolean> supplier) { //Lock lock = new ReentrantLock(); //obtainLock(l
java中ReentrantLock类的tryLock和tryLock的例子和用法
qq_43650923的博客
09-22 2098
ReentrantLock类的tryLock和tryLock(时间) tryLock的方法就是试一下，如果能得到锁，就返回真，如果当时得不到，马上就返回假，绝不等。tryLock(时间)的用法就是 在规定的时间内设法得到锁。如果在规定的时间内最终不能得到锁，就返回假。注意，这个方法是可以被打断的，打断后的处理方法和上面的例子 lockInterruptibly的处理一样。 例1.9.8_a: ...
Redisson锁学习
钟渊博客
03-23 1271
1、可重入锁public void reentrantLockTest(){ RLock rLock = redisson.getLock("reentrantLock"); try { boolean tryLock = rLock.tryLock(10,TimeUnit.SECONDS); if(tryLock){ //doSomething }...
Springboot中使用Redis实现分布式锁
热门推荐
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
05-06 5万+
在分布式系统中，为了保证数据的一致性和任务的互斥执行，分布式锁是一种常见的解决方案。Redis凭借其高性能和丰富的数据结构，成为了实现分布式锁的优选工具之一。本文将指导你在Spring Boot应用中如何利用Redisson客户端来实现分布式锁。
Java基于redis实现分布式锁代码实例
08-19
Java基于Redis实现分布式锁代码实例 分布式锁的必要性 在多线程环境中，资源竞争是一个常见的问题。例如，在一个简单的用户操作中，一个线程修改用户状态，首先在内存中读取用户状态，然后在内存中进行修改，然后...
基于redis实现分布式锁的原理与方法
12-14
redis实现分布式锁 数据库实现分布式锁 zk实现分布式锁 今天我们介绍通过redis实现分布式锁。实际上这三种和java对比看属于一类。都是属于程序外部锁。 原理剖析 上述三种分布式锁都是通过各自为依据对各个请求...
SpringBoot使用Redis实现分布式锁
08-19
SpringBoot 使用 Redis 实现分布式锁 分布式锁是指在分布式系统中，多个节点或机器之间对共享资源的访问进行控制和协调，以避免冲突和竞争的机制。SpringBoot 使用 Redis 实现分布式锁是指使用 SpringBoot 框架和 ...
ReentrantLock里面lock和tryLock的区别
GracefulGuigui的博客
06-24 4248
ReentrantLock ReentrantLock（轻量级锁）也可以叫对象锁，可重入锁，互斥锁。synchronized重量级锁，JDK前期的版本lock比synchronized更快，在JDK1.5之后synchronized引入了偏向锁，轻量级锁和重量级锁。以致两种锁性能旗鼓相当，看个人喜欢，本文主要介绍一下lock和tryLock的区别。 public void lock() { sync.lock(); } public void lockInterruptibly() thro
Online DDL (Data Definition Language)
09-23 266
是MySQL中的一个功能，允许在修改表结构（如添加、删除或修改列）的同时，允许对表进行并发读写操作。在传统的DDL操作中，对表结构的修改会导致整个表被锁定，从而阻止其他事务对该表进行读写操作，这可能导致长时间的锁定和性能问题。Online DDL的引入解决了这个问题，它允许在修改表结构的同时，保持对表的并发访问。MySQL从5.6版本开始引入了Online DDL的部分功能，而在8.0版本中对Online DDL进行了进一步的优化。
Postgresql特殊关键字
czjnoe的博客
09-25 279
表字段名称如果出现这些特殊关键字，则需要通过单引号访问字段，如offset、group。PostgreSQL特殊关键字。
基于JavaWeb开发的Java+SpringMvc+vue+element实现驾校管理系统详细设计
央顺科技官方博客
09-24 903
机遇与挑战始终并存。在开放的互联网平台面前，驾校预约管理系统的信息管理面临着巨大的挑战。传统的管理模式局限于简单数据的管理，无法适应不断变化的市场格局。在早期阶段，在将计算机技术和网络技术融入驾校预约管理系统数据管理方法之前，所有管理方式都通过人工操作完成了管理信息的。系统管理也都将通过计算机进行整体智能化操作，对于驾校预约管理系统所牵扯的管理及数据保存都是非常多的，举例像所有详细信息包括，管理员；首页、个人中心、学员管理、驾校教练管理、驾校车辆管理、预约管理、取消预约管理、驾校公告管理、系统管理。
Java Alibaba Druid 数据库连接池
miracle的专栏
09-24 744
在Java开发中，数据库连接池是性能优化的重要一环。而作为一款强大的数据库连接池解决方案，凭借其和对多种数据库的支持，成为了许多企业级应用的首选。本篇文章将介绍Druid的核心特性，并结合不同数据库的实际用法。
JPA+Thymeleaf增删改查
y050505的博客
09-25 465
在使用JPA（Java Persistence API）和Thymeleaf作为模板引擎进行Web开发时，实现增删改查（CRUD）操作是一个常见的需求。下面，我将简要介绍如何使用Spring Boot框架结合JPA和Thymeleaf来实现这一功能。
k8s搭建一主三从的mysql8集群---无坑
最新发布
oopxiajun博客专栏
09-27 656
对于构建基于MySQL的大规模、高性能应用来讲，需要使用水平扩展(集群)的数据库架构方式。在MySQL内建的复制功能可以实现，通过为服务器配置一个或多个备库的方式来进行数据同步。同时复制功能不仅有利于构建高性能的应用，也是高可用性、可扩展性、容灾、备份以及数据仓库等工作的基础。复制的基本原理是让一台服务器的数据与其他服务器保持同步。一台主库的数据可以同步到多台备库上，备库本身也可以被配置成另外一台服务器的主库。主库和备库之间可以有多种不同的组合方式。
使用Redis实现分布式锁详解
在实际使用Redis实现分布式锁时，还需要考虑一些额外的问题，比如**锁的续期**，以防止锁在预期时间内未被释放而超时，以及**锁的公平性**，确保等待最久的客户端能优先获得锁。此外，为了防止**锁的泄漏**，可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值