MySQL做分布式锁

已于 2024-06-02 22:25:29 修改
阅读量1.6k 收藏 5
点赞数 2
分类专栏： 数据库 springcloud 文章标签： mysql 分布式 数据库
于 2023-08-01 22:29:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Forbidden_City/article/details/132052106
版权

分布式锁mysql实现方式
方式1：唯一索引

  • 创建锁表，内部存在字段表示资源名及资源描述，同一资源名使用数据库唯一性限制。
  • 多个进程同时往数据库锁表中写入对某个资源的占有记录，当某个进程成功写入时则表示其获取锁成功
  • 其他进程由于资源字段唯一性限制插入失败陷入自旋并且失败重试。
  • 当执行完业务后持有该锁的进程则删除该表内的记录，此时回到步骤一。
    在这里插入图片描述
    表数据
create table `database_lock`(
	`id` BIGINT NOT NULL AUTO_INCREMENT,
	`resource` INT NOT NULL COMMENT '锁资源',
	`description` varchar(1024) NOT NULL DEFAULT "" COMMENT '描述',
	PRIMARY KEY (`id`),
	UNIQUE KEY `resource` (`resource`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='数据库分布式锁表';

db.properties

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/distribute_lock?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=Asia/Shanghai
user=root
password=123456
  • PropertiesReader
@Slf4j
public class PropertiesReader {

    // Properties缓存文件
    private static final Map<String, Properties> propertiesCache = new HashMap<String, Properties>();

    public static Properties getProperties(String propertiesName) throws IOException {
        if (propertiesCache.containsKey(propertiesName)) {
            return propertiesCache.get(propertiesName);
        }
        loadProperties(propertiesName);
        return propertiesCache.get(propertiesName);
    }

    private synchronized static void loadProperties(String propertiesName) throws IOException {
        FileReader fileReader = null;
        try {
            // 创建Properties集合类
            Properties pro = new Properties();
            // 获取src路径下的文件--->ClassLoader类加载器
            ClassLoader classLoader = PropertiesReader.class.getClassLoader();
            URL resource = classLoader.getResource(propertiesName);
            // 获取配置路径
            String path = resource.getPath();
            // 读取文件
            fileReader = new FileReader(path);
            // 加载文件
            pro.load(fileReader);
            // 初始化
            propertiesCache.put(propertiesName, pro);
        } catch (IOException e) {
            log.error("读取Properties文件失败，Properties名为:" + propertiesName);
            throw e;
        } finally {
            try {
                if (fileReader != null) {
                    fileReader.close();
                }
            } catch (IOException e) {
                log.error("fileReader关闭失败！", e);
            }
        }
    }
}
  • JDBCUtils
@Slf4j
public class JDBCUtils {
    private static String url;
    private static String user;
    private static String password;

    static {
        //读取文件，获取值
        try {
            Properties properties = PropertiesReader.getProperties("db.properties");
            url = properties.getProperty("url");
            user = properties.getProperty("user");
            password = properties.getProperty("password");
            String driver = properties.getProperty("driver");
            //4.注册驱动
            Class.forName(driver);
        } catch (IOException | ClassNotFoundException e) {
            log.error("初始化jdbc连接失败！", e);
        }
    }

    /**
     * 获取连接
     * @return 连接对象
     */
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url, user, password);
    }

    /**
     * 释放资源
     * @param rs
     * @param st
     * @param conn
     */
    public static void close(ResultSet rs, Statement st, Connection conn) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (st != null) {
            try {
                st.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

数据库操作类

/**
 * MySQL 锁操作类（加锁+释放锁）
 */
@Slf4j
public class MySQLDistributedLockService {

    private static Connection connection;
    private static Statement statement;
    private static ResultSet resultSet;

    static{
        try {
            connection = JDBCUtils.getConnection();
            statement = connection.createStatement();
            resultSet = null;
        } catch (SQLException e) {
            log.error("数据库连接失败！");
        }
    }

    /**
     * 锁表 - 获取锁
     * @param resource      资源
     * @param description   锁描述
     * @return  是否操作成功
     */
    public static boolean tryLock(int resource,String description){
        String sql = "insert into database_lock (resource,description) values (" + resource + ", '" + description + "');";
        //获取数据库连接
        try {
            int stat = statement.executeUpdate(sql);
            return stat == 1;
        } catch (SQLException e) {
            return false;
        }
    }
    /**
     * 锁表-释放锁
     * @return
     */
    public static boolean releaseLock(int resource) throws SQLException {
        String sql = "delete from database_lock where resource = " + resource;
        //获取数据库连接
        int stat = statement.executeUpdate(sql);
        return stat == 1;
    }
    /**
     * 关闭连接
     */
    public static void close(){
        log.info("当前线程： " + ManagementFactory.getRuntimeMXBean().getName().split("@")[0] +
                ",关闭了数据库连接！");
        JDBCUtils.close(resultSet,statement,connection);
    }
}

LockTable

/**
 * mysql分布式锁
 *      执行流程： 多进程抢占数据库某个资源，然后执行业务，执行完释放资源
 *      锁机制： 单一进程获取锁时，则其他进程提交失败
 */
@Slf4j
public class LockTable extends Thread {
    @Override
    public void run() {
        super.run();
        //获取Java虚拟机的进程ID
        String pid = ManagementFactory.getRuntimeMXBean().getName().split("@")[0];
        try{
            while(true){
                log.info("当前进程PID：" + pid + ",尝试获取锁资源！");
                if(MySQLDistributedLockService.tryLock(1,"测试锁")){
                    log.info("当前进程PID：" + pid + ",获取锁资源成功！");
                    //sleep模拟业务处理过程
                    log.info("开始处理业务！");
                    Thread.sleep(10*1000);
                    log.info("业务处理完成！");
                    MySQLDistributedLockService.releaseLock(1);
                    log.info("当前进程PID： " + pid + ",释放了锁资源！");
                    break;
                }else{
                    log.info("当前进程PID： " + pid + "，获取锁资源失败！");
                    Thread.sleep(2000);
                }
            }
        }catch (Exception e){
            log.error("抢占锁发生错误！",e);
        }finally {
            MySQLDistributedLockService.close();
        }
    }
    // 程序入口
    public static void main(String[] args) {
        new LockTable().start();
    }
}

测试
运行时开启并行执行选项，每次运行三个或三个以上进程. Allow parallel run 运行并行执行
image.png
image.png
注意事项：

  • 该锁为非阻塞的
  • 当某进程持有锁并且挂死时候会造成资源一直不释放的情况，造成死锁，因此需要维护一个定时清理任务去清理持有过久的锁
  • 要注意数据库的单点问题，最好设置备库，进一步提高可靠性
  • 该锁为非可重入锁，如果要设置成可重入锁需要添加数据库字段记录持有该锁的设备信息以及加锁次数

方式二：基于乐观锁

  • 每次执行业务前首先进行数据库查询，查询当前的需要修改的资源值（或版本号）。
  • 进行资源的修改操作，并且修改前进行资源（或版本号）的比对操作，比较此时数据库中的值是否和上一步查询结果相同。
  • 查询结果相同则修改对应资源值，不同则回到第一步。
    image.png

例子：数据库中设定某商品基本信息（名为外科口罩，数量为10），多进程对该商品进行抢购，当商品数量为0时结束抢购。
在这里插入图片描述
代码实现

    /**
     * 乐观锁-获取资源
     * @param id 资源ID
     * @return result
     */
    public static ResultSet getGoodCount(int id) throws SQLException {

        String sql = "select  * from  database_lock_2 where id = " + id;

        //查询数据
        resultSet = statement.executeQuery(sql);
        return resultSet;
    }


    /**
     * 乐观锁-修改资源
     * @param id        资源ID
     * @param goodCount 资源
     * @return  修改状态
     */
    public static boolean setGoodCount(int id, int goodCount) throws SQLException {

        String sql = "update database_lock_2 set good_count = good_count - 1 where id =" + id +"  and good_count = " + goodCount;

        int stat = statement.executeUpdate(sql);
        return stat == 1;
    }

    /**
     * 乐观锁-开启事务自动提交
     */
    public static void AutoCommit(){
        try {
            connection.setAutoCommit(true);
        } catch (SQLException e) {
            log.error("开启自动提交！",e);
        }
    }

OptimisticLock测试类

/**
 * mysql分布式锁-乐观锁
 *  执行流程： 多进程抢购同一商品，每次抢购成功商品数量-1，商品数据量为0时退出
 *  锁机制： 单一进程获取锁时，则其他进程提交失败
 */
@Slf4j
public class OptimisticLock extends Thread{

    @Override
    public void run() {
        super.run();
        String pid = ManagementFactory.getRuntimeMXBean().getName().split("@")[0];

        ResultSet resultSet = null;
        String goodName = null;
        int goodCount = 0;
        try {
            while(true){
                log.info("当前线程：" + pid + "，开始抢购商品！");
                //获取当前商品信息
                resultSet = MySQLDistributedLockService.getGoodCount(1);
                while (resultSet.next()){
                    goodName = resultSet.getString("good_name");
                    goodCount = resultSet.getInt("good_count");
                }
                log.info("获取库存成功，当前商品名为：" + goodName + "，当前库存剩余量为：" + goodCount);
                //模拟执行业务操作
                Thread.sleep(2*3000);
                if(0 == goodCount){
                    log.info("抢购失败，当前库存为0！ ");
                    break;
                }
                //修改库存信息，库存量-1
                if(MySQLDistributedLockService.setGoodCount(1,goodCount)){
                    log.info("当前线程：" + pid + " 抢购商品：" + goodName + "成功，剩余库存为：" + (goodCount -1));
                    //模拟延迟，防止锁每次被同一进程获取
                    Thread.sleep(2 * 1000);
                }else{
                    log.error("抢购商品：" + goodName +"失败，商品数量已被修改");
                }
            }
        }catch (Exception e){
            log.error("抢购商品发生错误！",e);
        }finally {
            if(resultSet != null){
                try {
                    resultSet.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                    log.error("关闭Result失败！" , e);
                }
            }
            MySQLDistributedLockService.close();
        }
    }

    public static void main(String[] args) {
        new OptimisticLock().start();
    }
}

代码测试
开启三个进程，查看执行情况
image.png
image.png
image.png
注意事项：

  • 该锁为非阻塞的
  • 该锁对于业务具有侵入式，如果设置版本号校验则增加的额外的字段，增加了数据库冗余
  • 当并发量过高时会有大量请求访问数据库的某行记录，对数据库造成很大的写压力
  • 因此乐观锁适用于并发量不高，并且写操作不频繁的场景

方式三：悲观锁实现方式（利用事务加上行/表锁）
在这里插入图片描述
实现思路

  • 关闭jdbc连接自动commit属性
  • 每次执行业务前先使用查询语句后接for update表示锁定该行数据（注意查询条件如果未命中主键或索引，此时将会从行锁变为表锁）
  • 执行业务流程修改表资源
  • 执行commit操作

代码实现
MySQLDistributedLockService


    /**
     * 悲观锁-获取资源
     * @param id 资源ID
     * @return result
     */
    public static ResultSet getGoodCount2(int id) throws SQLException {
        String sql = "select  * from  database_lock_2 where id = " + id + "for update";
        //查询数据
        resultSet = statement.executeQuery(sql);
        return resultSet;
    }

    /**
     * 悲观锁-修改资源
     * @param id        资源ID
     * @return  修改状态
     */
    public static boolean setGoodCount2(int id) throws SQLException {

        String sql = "update database_lock_2 set good_count = good_count - 1 where id =" + id;
        int stat = statement.executeUpdate(sql);
        return stat == 1;
    }

    /**
     * 悲观锁-关闭事务自动提交
     */
    public static void closeAutoCommit(){
        try {
            connection.setAutoCommit(false);
        } catch (SQLException e) {
            log.error("关闭自动提交失败！",e);
        }
    }

    /**
     * 悲观锁-提交事务
     */
    public static void commit(String pid,String goodName,int goodCount) throws SQLException {
        connection.commit();
        log.info("当前线程：" + pid + "抢购商品： " + goodName + "成功，剩余库存为：" + (goodCount-1));
    }

    /**
     * 悲观锁-回滚
     */
    public static void rollBack() throws SQLException {
        connection.rollback();
    }

PessimisticLock

/**
 * mysql 分布式锁-悲观锁
 *     执行流程：多个进程抢占同一个商品，执行业务完毕则通过connection.commit() 释放锁
 *     锁机制：单一进程获取锁时，则其他进程将阻塞等待
 */
@Slf4j
public class PessimisticLock extends Thread {
    @Override
    public void run() {
        super.run();
        ResultSet resultSet = null;
        String goodName = null;
        int goodCount = 0;
        String pid = ManagementFactory.getRuntimeMXBean().getName().split("@")[0];
        //关闭自动提交
        MySQLDistributedLockService.closeAutoCommit();
        try{
            while(true){
                log.info("当前线程：" + pid + "");
                //获取库存
                resultSet = MySQLDistributedLockService.getGoodCount2(1);
                while (resultSet.next()) {
                    goodName = resultSet.getString("good_name");
                    goodCount = resultSet.getInt("good_count");
                }
                log.info("获取库存成功，当前商品名称为:" + goodName + ",当前库存剩余量为:" + goodCount);
                // 模拟执行业务事件
                Thread.sleep(2 * 1000);
                if (0 == goodCount) {
                    log.info("抢购失败，当前库存为0！");
                    break;
                }
                // 抢购商品
                if (MySQLDistributedLockService.setGoodCount2(1)) {
                    // 模拟延时，防止锁每次被同一进程获取
                    MySQLDistributedLockService.commit(pid, goodName, goodCount);
                    Thread.sleep(2 * 1000);
                } else {
                    log.error("抢购商品:" + goodName + "失败!");
                }
            }
        }catch (Exception e){
            //抢购失败
            log.error("抢购商品发生错误！",e);
            try {
                MySQLDistributedLockService.rollBack();
            } catch (SQLException ex) {
                log.error("回滚失败！ ",e);
            }
        }finally {
            if(resultSet != null){
                try {
                    resultSet.close();
                } catch (SQLException e) {
                    log.error("Result关闭失败！",e);
                }
            }
            MySQLDistributedLockService.close();
        }
    }

    public static void main(String[] args) {
        new PessimisticLock().start();
    }
}

测试结果
image.png
image.png
image.png
注意事项：

  • 该锁为阻塞锁
  • 每次请求存在额外加锁的开销
  • 在并发量很高的情况下会造成系统中存在大量阻塞的请求，影响系统的可用性
  • 因此悲观锁适用于并发量不高，读操作不频繁的写场景

总结：

  • 在实际使用中，由于受到性能以及稳定性约束，对于关系型数据库实现的分布式锁一般很少被用到。但是对于一些并发量不高、系统仅提供给内部人员使用的单一业务场景可以考虑使用关系型数据库分布式锁，因为其复杂度较低，可靠性也能够得到保证。
渔阳节度使
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MySQL和Redis实现分布式锁
Lzc的博客
07-24 2777
MySQL和Redis实现分布式锁1. 为何需要分布式锁2. 分布式锁的一些特点3. 常见的分布式锁4. Mysql实现分布式锁4.1 lock()4.2 tryLock()和tryLock(long timeout)4.3 unlock()4.4 锁超时4.5 MySQL实现方式小结4.6 乐观锁5. Redis实现分布式锁5.1 使用setnx实现5.2 使用Redission来实现5.3 R...
MySQL之锁
wang_zhao_的博客
06-01 353
锁1. 什么是锁2. lock 与 latch3. InnoDB 中的锁3.1 锁的类型3.2 一致性非锁定读3.3 一致性锁定读3.4 自增长与锁3.5 外键和锁4. 锁的算法4.1 行锁的 3 种算法4.2 解决 Phantom Problem5. 锁问题5.1 脏读5.2 不可重复读5.3 丢失更新6. 阻塞7. 死锁7.1 死锁的概念7.2 死锁概率7.3 死锁的示例8. 锁升级 1. 什么是锁 2. lock 与 latch 3. InnoDB 中的锁 3.1 锁的类型 3.2 一致性非锁定读
Mysql实现分布式锁的三种方式
探索大数据世界 - 深入解析数据存储、分布式计算与人工智能
02-03 2982
mysql实现分布式锁的三种方式
使用MySQL实现一个分布式锁
09-08
在分布式系统中，分布锁是一个最基础的工具类。这篇文章主要介绍了用MySQL实现一个分布式锁，本文通过实例代码相结合给大家介绍的非常详细，具有一定的参考借鉴价值,需要的朋友可以参考下
分布式锁：场景和使用方法(通俗讲解)
最新发布
leader_song的博客
05-16 1283
对于锁大家肯定不会陌生，比如 synchronized 关键字 和 ReentrantLock 可重入锁，一般我们用其在多线程环境中控制对资源的并发访问。但是随着业务的发展，分布式的概念逐渐出现在我们系统中，我们在开发的过程中经常需要进行多个系统之间的交互，于是上面的加锁方法就会失去作用。于是在分布式锁就自然而然的诞生了，接下来我们来聊一聊分布式锁实现的几种方式。
​【五一创作】基于mysql关系型实现分布式锁
一个菜鸡的博客
05-02 4177
在多线程高并发场景下，为了保证资源的线程安全问题，jdk为我们提供了synchronized关键字和ReentrantLock可重入锁，但是它们只能保证一个jvm内的线程安全。在分布式集群、微服务、云原生横行的当下，如何保证不同进程、不同服务、不同机器的线程安全问题，jdk并没有给我们提供既有的解决方案。此时，我们就必须借助于相关技术手动实现了。目前主流的实现有三种方式：1. 基于mysql关系型实现2. 基于redis非关系型数据实现3. 基于zookeeper实现。
使用 Mysql 实现分布式锁
weixin_36001569的博客
06-02 1122
mysql 分布式锁
一种基于mysql实现分布式锁的方式
heouheou的博客
03-26 922
分布式锁，即分布式系统中的锁。在单体应用中我们通过锁解决的是控制共享资源访问的问题，而分布式锁，就是解决了分布式系统中控制共享资源访问的问题。与单体应用不同的是，分布式系统中竞争共享资源的最小粒度从线程升级成了进程。目前比较常见的实现分布式锁的方式主要有三种：基于数据库实现、基于Zookeeper实现、基于redis实现。本文主要介绍了一种基于mysql数据库实现分布式锁的方式，从最简单的实现方式开始，一步步构造一个拥有基本分布式锁条件的程序。
mysql实现分布式锁
qq_25379811的博客
09-23 2580
数据库锁
MySQL借助DB实现分布式锁思路详解
09-09
MySQL借助DB实现分布式锁是一种在分布式环境中协调多个节点访问共享资源的方法。分布式锁的主要目标是保证数据的一致性和避免并发冲突。在没有第三方组件如Redis或Zookeeper的情况下，使用MySQL数据库来实现分布式锁...
分布式锁实现（基于redis-mysql）1
08-03
本文主要探讨了三种常见的分布式锁实现方式，包括基于Redis、MySQL以及Zookeeper的实现方法。 **基于Redis实现分布式锁** Redis是一个内存数据库，其命令执行是单线程的，这使得它非常适合用来实现分布式锁。Redis...
Spring Boot基于数据库如何实现简单的分布式锁
08-25
【Spring Boot基于数据库实现分布式锁】的方案是解决多节点并发问题的一种常见方法。在分布式系统中，确保同一时刻只有一个节点执行特定操作是至关重要的，而数据库作为一种普遍存在的中间件，可以用来创建分布式锁...
分布式锁的实现- mysql
ajun_studio的专栏
08-26 2523
大家好，我是飓风，今天我们来聊聊分布式锁的原理、以及基于 mysql 怎么来实现分布式锁。那么大家现在能不能想一想，分布式锁的使用场景都有哪些呢？下面我列举一些分布式锁的场景：记住一点，一定是在分布式的环境下，所以肯定是多个服务，或者多个进程来操作一个共享资源。扣减库存订单支付，检查订单是否进行了重复支付的操作缓存击穿/缓存雪崩，防止大并发对 DB 的操作。......
如何用MySQL设计一个分布式锁？
meser88的博客
08-04 778
分布式锁想必大家都不陌生，可以用来解决在分布式环境下，多个用户在同一时间读取/更新相同的资源带来的问题。比如秒杀场景下的库存问题、redis key失效情况下请求直接打到MySQL中造成MySQL负载过大的问题，这些问题都可以通过分布式锁来解决。关于如何实现分布式锁，大家可能对基于Redis实现比较熟悉，但是往往很多情况是一些并发量不大的项目用不上RedisRedis往往适用于并发量比较大的场景。但是MySQL基本都是有的，所以今天我来谈谈如何基于MySQL实现我们的分布式锁。
分布式前修课：MySQL实现分布式锁
m0_71777195的博客
07-30 885
基于MySQL的分布式锁在实际开发过程中很少使用，但是我们还是要有一个思路在。那么本节针对MySQL的分布式锁实现到这里就结束了，掌握了MySQL的基础锁，那么就会非常简单了。httpshttps。
10、分布式锁使用mysql实现
分享java学习路上的一些笔记，不足之处多多见谅。
06-13 571
是的，使用MySQL实现分布式锁的常见方式之一就是利用INSERT语句的行级锁。当多个事务同时尝试插入同一行数据时，只有一个事务能够成功插入，其他事务会因为锁冲突而被阻塞等待。在执行该语句时，MySQL会自动对该行数据进行加锁，确保只有一个事务能够成功插入。其他事务在插入同一行时会因为锁冲突而被阻塞等待锁的释放。需要注意的是，MySQL作为一个数据库系统，并不是专门设计用于实现分布式锁的。一种常见的方法是使用MySQL的行级锁和事务机制。在释放锁时，通过执行DELETE语句将对应的记录从锁表中删除。
分布式锁--（mysql-redis方式）
weixin_53472653的博客
10-02 1327
在多线程高并发场景下，为了保证资源的线程安全问题，jdk为我们提供了关键字和可重入锁，但是它们只能保证一个jvm内的线程安全。在分布式集群、微服务、云原生横行的当下，如何保证不同进程、不同服务、不同机器的线程安全问题，jdk并没有给我们提供既有的 解决方案。此时，我们就必须借助于相关技术手动实现了。目前主流的实现有三种方式：1.基于mysql关系型实现2.基于redis非关系型数据实现3.基于zookeeper实现2.案例演示（超买现象）并且使用jvm提供的锁。
分布式锁的三种实现方式
lingshengxiyou的博客
04-07 511
这里推荐一个Apache的开源库Curator，它是一个ZooKeeper客户端，Curator提供的InterProcessMutex是分布式锁的实现，acquire方法用于获取锁，release方法用于释放锁。（1）获取锁的时候，使用setnx加锁，并使用expire命令为锁添加一个超时时间，超过该时间则自动释放锁，锁的value值为一个随机生成的UUID，通过此在释放锁的时候进行判断。（3）释放锁的时候，通过UUID判断是不是该锁，若是该锁，则执行delete进行锁释放。利用select …
请说出为什么不用mysql做分布式锁而用redis做分布式的原因
06-09
使用 Redis 做分布式锁有以下几个原因： 1. Redis 基于内存，读写速度快，适合作为分布式锁的存储介质。 2. Redis 提供 SETNX（SET if Not eXists）命令可以实现分布式锁的原子性操作，避免了多个客户端同时获取锁的问题。 3. Redis 提供了 EXPIRE 命令可以为锁设置过期时间，避免因为客户端程序异常而导致锁一直存在的问题。 4. Redis 的订阅与发布功能可以实现分布式锁的自动释放，避免了客户端程序异常时锁未能及时释放的问题。 综上所述，Redis 具有高性能、原子性、可靠性等优点，适合作为分布式锁的存储介质。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值