多线程模式下保证事物的一致性

已于 2023-12-07 10:39:10 修改
阅读量4k 收藏 15
点赞数 7
分类专栏： mybatis 文章标签： java spring 多线程 事物 mysql 1024程序员节
于 2022-12-27 23:39:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38637558/article/details/128457701
版权

目录

前置

在一些特殊的场景下, 我们需要一些特定的操作.
比如我有一个接口, 做如下操作, 需要保持事物的一致性, 即: 全部成功则提交, 一个异常则全部回滚:
1.insert订单、(耗时1秒)
2.insert订单商品、(耗时1秒)
3.insert子订单、(耗时1秒)
4.insert操作记录、(耗时1秒)
在这波insert操作下来, 就需要花费4秒钟, 那么我们是否可以采用异步的方式进行保存, 将时间保持在1秒钟, 并保持事物一致性
故有了下面的方法

项目地址: https://gitee.com/xmaxm/chaim-code-template/tree/master/chaim-mybatis-plus

大致思路

要做异步操作, 就得做多线程, 但是事物是和线程是绑定在一起的,
同时我们知道, commit和rollback是和DML语句一起使用的, 也就是我们能知道这条SQL是成功还是失败
通过上面, 我们就可以进行线程等待, 在所有的DML语句执行之后, 统一进行commit还是rollback, 执行快的等待执行慢的, 当同时OK就进行统一操作
就可采用下面所列的方式, 当然还有很多别的方式也可以进行

强调:

多测, 做线程循环测试跑. 比如AB, JMeter, apifox, 下面列举的InsertBatchErrorServiceImpl在普通测试过程中不会出现问题, 但是当次数过多就会出现无法唤醒的情况. 一定要测试, 有些场景需要多跑几遍才能够进行重现

代码部分

InsertBatchSuccessServiceImpl:
该实现采用的是CountDownLatch, countDown()递减锁的数量, await()等待直到当前计数器数量为0, 释放所有等待线程

InsertBatchErrorServiceImpl:
该实现采用的 LockSupport.park()悬停、LockSupport.unpark(thread)唤醒. 但在实际使用过程中发现会出现无法唤醒的情况, 我发布了问题(可供参考 ), 但是目前还没有得到解决, 不得不暂时放弃

InsertBatchSuccessServiceImpl.java

package com.chaim.mybatis.service.impl;

import com.chaim.mybatis.converter.SysUserConverter;
import com.chaim.mybatis.dto.SysUserDTO;
import com.chaim.mybatis.entitys.SysUser;
import com.chaim.mybatis.mappers.SysUserMapper;
import com.chaim.mybatis.service.InsertBatchService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.stereotype.Service;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicBoolean;

/**
 * @author Chaim
 * @date 2022/12/24 16:06
 */
@Service
@RequiredArgsConstructor
@Slf4j
public class InsertBatchSuccessServiceImpl implements InsertBatchService {
    private final SysUserMapper sysUserMapper;
    private final SysUserConverter sysUserConverter;
    private final DataSourceTransactionManager dataSourceTransactionManager;

    @Override
    public Object insertBatch(SysUserDTO.InsertSysUserDTO insertSysUserDTO) {
        // 定义开启的线程数
        final int i = 3;
        CountDownLatch latch = new CountDownLatch(i);
        // 事务定义
        DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
        // 所有开启事务的线程中, 是否存在异常
        AtomicBoolean isException = new AtomicBoolean(Boolean.FALSE);

        List<CompletableFuture<Void>> list = new ArrayList<>();
        list.add(this.save(insertSysUserDTO, latch, definition, isException));
        list.add(this.save1(insertSysUserDTO, latch, definition, isException));
        list.add(this.save2(insertSysUserDTO, latch, definition, isException));
        // 调用Future的阻塞接口, 等待全部future实例异步执行结束
        CompletableFuture.allOf(list.toArray(new CompletableFuture[i])).join();

        return "SUCCESS";
    }


    private CompletableFuture<Void> save(SysUserDTO.InsertSysUserDTO insertSysUserDTO, CountDownLatch latch, DefaultTransactionDefinition definition, AtomicBoolean isException) {
        return CompletableFuture.runAsync(() -> {
            // 获得事务状态
            TransactionStatus status = dataSourceTransactionManager.getTransaction(definition);
            SysUser sysUser = sysUserConverter.insertUserDTOToSysUser(insertSysUserDTO);
            try {
                sysUser.setPassword("123456");
                sysUser.setSalt(1234);
                sysUserMapper.insert(sysUser);
                this.threadBlocking(latch, status, isException);
            } catch (Exception exception) {
                log.error("方法: [save] 异常: {}", exception.getMessage());
                this.errorRollback(latch, status, isException);
            }
        });

    }

    private CompletableFuture<Void> save1(SysUserDTO.InsertSysUserDTO insertSysUserDTO, CountDownLatch latch, DefaultTransactionDefinition definition, AtomicBoolean isException) {
        return CompletableFuture.runAsync(() -> {
            TransactionStatus status = dataSourceTransactionManager.getTransaction(definition);
            SysUser sysUser = sysUserConverter.insertUserDTOToSysUser(insertSysUserDTO);
            try {
                sysUser.setPassword("123456");
                sysUser.setSalt(9876);
                sysUser.setUsername(sysUser.getUsername().concat(": 子线程1"));
                sysUserMapper.insert(sysUser);
                this.threadBlocking(latch, status, isException);
            } catch (Exception exception) {
                log.error("方法: [save1] 异常: {}", exception.getMessage());
                this.errorRollback(latch, status, isException);
            }
        });
    }

    private CompletableFuture<Void> save2(SysUserDTO.InsertSysUserDTO insertSysUserDTO, CountDownLatch latch, DefaultTransactionDefinition definition, AtomicBoolean isException) {
        return CompletableFuture.runAsync(() -> {
            TransactionStatus status = dataSourceTransactionManager.getTransaction(definition);
            SysUser sysUser = sysUserConverter.insertUserDTOToSysUser(insertSysUserDTO);
            try {
                sysUser.setPassword("123456");
                sysUser.setSalt(9876);
                sysUser.setUsername(sysUser.getUsername().concat(": 子线程2"));
                sysUserMapper.insert(sysUser);
                this.threadBlocking(latch, status, isException);
            } catch (Exception exception) {
                log.error("方法: [save2] 异常: {}", exception.getMessage());
                this.errorRollback(latch, status, isException);
            }
        });
    }

    /**
     * 进行线程阻塞操作
     *
     * @param latch
     * @param status
     * @param isException
     */
    private void threadBlocking(CountDownLatch latch, TransactionStatus status, AtomicBoolean isException) throws InterruptedException {
        log.info("计数器递减");
        latch.countDown();
        log.info("开始悬停, 剩余计数数量: {}", latch.getCount());
        latch.await();

        // 以下步骤抛出异常进入catch, 做countDown操作, 不会影响. 走到这一步已经没有阻塞了
        if (isException.get()) {
            log.info("开始回滚");
            dataSourceTransactionManager.rollback(status);
        } else {
            log.info("开始提交");
            dataSourceTransactionManager.commit(status);
        }
    }

    /**
     * 程序异常, 进行回滚, 线程唤醒
     *
     * @param latch
     * @param status
     * @param isException
     */
    private void errorRollback(CountDownLatch latch, TransactionStatus status, AtomicBoolean isException) {
        // 设定线程中存在异常信息
        isException.set(Boolean.TRUE);
        latch.countDown();
        log.info("开始回滚, 程序异常, 计数器递减, 剩余数量: {}", latch.getCount());
        // 本线程回滚
        dataSourceTransactionManager.rollback(status);
    }
}

InsertBatchErrorServiceImpl.java

关于该方式存在的问题, 我已经在问答区提出疑问, 可供参考

package com.chaim.mybatis.service.impl;

import com.chaim.mybatis.converter.SysUserConverter;
import com.chaim.mybatis.dto.SysUserDTO;
import com.chaim.mybatis.entitys.SysUser;
import com.chaim.mybatis.mappers.SysUserMapper;
import com.chaim.mybatis.service.InsertBatchService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.stereotype.Service;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.LockSupport;

/**
 * @author Chaim
 * @date 2022/12/24 22:06
 */
@Service
@RequiredArgsConstructor
@Slf4j
public class InsertBatchErrorServiceImpl implements InsertBatchService {
    private final SysUserMapper sysUserMapper;
    private final SysUserConverter sysUserConverter;
    private final DataSourceTransactionManager dataSourceTransactionManager;

    @Override
    public Object insertBatch(SysUserDTO.InsertSysUserDTO insertSysUserDTO) {
        // 定义开启的线程数
        AtomicInteger totalThreadCount = new AtomicInteger(3);
        // 事务定义
        DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
        // 所有开启事务的线程中, 是否存在异常
        AtomicBoolean isException = new AtomicBoolean(Boolean.FALSE);
        // 定义没有执行结束的线程集合
        List<Thread> unFinishedThread = Collections.synchronizedList(new ArrayList<>());

        List<CompletableFuture<Void>> list = new ArrayList<>();
        list.add(this.save(insertSysUserDTO, unFinishedThread, totalThreadCount, definition, isException));
        list.add(this.save1(insertSysUserDTO, unFinishedThread, totalThreadCount, definition, isException));
        list.add(this.save2(insertSysUserDTO, unFinishedThread, totalThreadCount, definition, isException));
        // 调用Future的阻塞接口, 等待全部future实例异步执行结束
        CompletableFuture.allOf(list.toArray(new CompletableFuture[totalThreadCount.get()])).join();

        return "SUCCESS";
    }


    private CompletableFuture<Void> save(SysUserDTO.InsertSysUserDTO insertSysUserDTO, List<Thread> unFinishedThread, AtomicInteger totalThreadCount, DefaultTransactionDefinition definition, AtomicBoolean isException) {
        return CompletableFuture.runAsync(() -> {
            // 获得事务状态
            TransactionStatus status = dataSourceTransactionManager.getTransaction(definition);
            SysUser sysUser = sysUserConverter.insertUserDTOToSysUser(insertSysUserDTO);
            try {
                sysUser.setPassword("123456");
                sysUser.setSalt(1234);
                sysUserMapper.insert(sysUser);
                this.threadBlocking(Thread.currentThread(), unFinishedThread, totalThreadCount, status, isException);
            } catch (Exception exception) {
                log.error("方法: [save] 异常: {}", exception.getMessage());
                this.errorRollback(unFinishedThread, totalThreadCount, status, isException);
            }
        });

    }

    private CompletableFuture<Void> save1(SysUserDTO.InsertSysUserDTO insertSysUserDTO, List<Thread> unFinishedThread, AtomicInteger totalThreadCount, DefaultTransactionDefinition definition, AtomicBoolean isException) {
        return CompletableFuture.runAsync(() -> {
            TransactionStatus status = dataSourceTransactionManager.getTransaction(definition);
            SysUser sysUser = sysUserConverter.insertUserDTOToSysUser(insertSysUserDTO);
            try {
                sysUser.setPassword("123456");
                sysUser.setSalt(9876);
                sysUser.setUsername(sysUser.getUsername().concat(": 子线程1"));
                sysUserMapper.insert(sysUser);
                this.threadBlocking(Thread.currentThread(), unFinishedThread, totalThreadCount, status, isException);
            } catch (Exception exception) {
                log.error("方法: [save1] 异常: {}", exception.getMessage());
                this.errorRollback(unFinishedThread, totalThreadCount, status, isException);
            }
        });
    }

    private CompletableFuture<Void> save2(SysUserDTO.InsertSysUserDTO insertSysUserDTO, List<Thread> unFinishedThread, AtomicInteger totalThreadCount, DefaultTransactionDefinition definition, AtomicBoolean isException) {
        return CompletableFuture.runAsync(() -> {
            TransactionStatus status = dataSourceTransactionManager.getTransaction(definition);
            SysUser sysUser = sysUserConverter.insertUserDTOToSysUser(insertSysUserDTO);
            try {
                sysUser.setPassword("123456");
                sysUser.setSalt(9876);
                sysUser.setUsername(sysUser.getUsername().concat(": 子线程2"));
                sysUserMapper.insert(sysUser);
                this.threadBlocking(Thread.currentThread(), unFinishedThread, totalThreadCount, status, isException);
            } catch (Exception exception) {
                log.error("方法: [save2] 异常: {}", exception.getMessage());
                this.errorRollback(unFinishedThread, totalThreadCount, status, isException);
            }
        });
    }

    /**
     * 进行线程阻塞操作
     *
     * @param thread
     * @param unFinishedThread
     * @param totalThreadCount
     * @param status
     * @param isException
     */
    private void threadBlocking(Thread thread, List<Thread> unFinishedThread, AtomicInteger totalThreadCount, TransactionStatus status, AtomicBoolean isException) {
        // 添加到没有执行结束的线程集合
        unFinishedThread.add(thread);
        // 每个线程都在悬停前开启唤醒检查
        this.notifyAllThread(unFinishedThread, totalThreadCount, false);

        if (isException.get()) {
            log.info("已存在异步任务发生回滚, 当前线程: {}", thread.getName());
            dataSourceTransactionManager.rollback(status);
        } else {
            log.info("线程: {}, 开始悬停", thread.getName());
            LockSupport.park();

            if (isException.get()) {
                log.info("线程: {}, 开始回滚", thread.getName());
                dataSourceTransactionManager.rollback(status);
            } else {
                log.info("线程: {}, 开始提交", thread.getName());
                dataSourceTransactionManager.commit(status);
            }
        }
    }

    /**
     * 程序异常, 进行回滚, 线程唤醒
     *
     * @param unFinishedThread
     * @param totalThreadCount
     * @param status
     * @param isException
     */
    private void errorRollback(List<Thread> unFinishedThread, AtomicInteger totalThreadCount, TransactionStatus status, AtomicBoolean isException) {
        // 设定线程中存在异常信息
        isException.set(Boolean.TRUE);
        // 本线程回滚
        dataSourceTransactionManager.rollback(status);
        // 发生异常, 全部线程进行唤醒
        this.notifyAllThread(unFinishedThread, totalThreadCount, true);
        log.info("异常回滚, 开始全部线程唤醒, 当前线程数量: {}", unFinishedThread.size());
    }

    /**
     * 唤醒全部悬停的线程
     *
     * @param unFinishedThread 手动悬停的线程
     * @param totalThreadCount 全部开启的线程数
     * @param isForce          是否强行操作集合中全部线程
     */
    private void notifyAllThread(List<Thread> unFinishedThread, AtomicInteger totalThreadCount, boolean isForce) {
        if (isForce || unFinishedThread.size() == totalThreadCount.get()) {
            for (Thread thread : unFinishedThread) {
                LockSupport.unpark(thread);
                log.info("线程: [{}]被唤醒", thread.getName());
            }
        }
    }
}

效果图

在这里插入图片描述

在这里插入图片描述

Chaim_chen
关注
  • 7
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
62.Spring多线程事务 能否保证事务的一致性（同时提交、同时回滚）？
weixin_43860634的博客
01-18 370
62.Spring多线程事务能否保证事务的一致性（同时提交、同时回滚）？
synchronized与（ReentrantLock）Lock的对比区别
天青色等烟雨
06-29 952
类别 synchronized Lock 存在层次 Java关键字，属于原生语法层面需要jvm实现 而Lock它是JDK 1.5之后提供的API层面的互斥锁，需要lock()和unlock()方法配合try/finally语句块来完成 锁的释放 1.以获取锁的线程执行完同步代码块，释放锁 2.线程执行发生异常，jvm会让线程释放...
CompletableFuture事务问题
weixin_37799575的博客
10-07 4501
前段时间写了关于CompletableFuture的使用博客，和。但在实际中使用的时候发现，CompletableFuture开启的线程和当前事务是脱离开的，也就是当前上下文的事务和CompletableFuture中执行的事务是两个事务，谁也不影响谁，这样就会出现业务上的错乱。例如：当前上下文执行失败，但是CompletableFuture中的执行成功了，而上下文因为失败进行了事务回滚，此时CompletableFuture中的是不会回滚的，这并不是我们想要的，所以针对这种情况进行测试说明和如何避免。
Springboot中多线程数据库操作下的事务一致性问题的解决方案
✈ 正在努力 の 寒江（StudiousTiger) ✌ 呐 ✈
11-22 5739
上述讲到了多线程之间的事务隔离（孤岛）的问题，所以多线程下实现事务一致性的问题，其实就转变成了如何解决多线程之间的事务孤岛的问题，解决事务孤岛的问题有演变成如何实现多线程下的数据库事务的统一提交与统一回滚。另一方面，因为多线程的事务一致性问题一般要求，当一个线程出现异常，那么所有的线程中的数据库写操作都需要进行回滚的，显然在。因为多线程事务的统一提交和统一回滚是在主线程中完成的，我们知道每个线程会维护器自己的事务状态与资源。实现的，所以对于多线程来说，主线程的事务管理器是无法控制子线程中的事务状态的。
多线程事务
最新发布
weixin_55229531的博客
05-25 1108
我们在工作中经常会到往数据库里插入大量数据的工作，但是既需要保证数据的一致性，又要保证程序执行的效率。因此需要在多线程中使用事务，这样既可以保证数据的一致性，又能保证程序的执行效率。但是spring自带的@Transactional注解无法满足多线程间的事务一致性，因为这几个事务执行的线程不同，无法保持数据的一致性。
多线程并发事务一致性
beihenanfei的专栏
08-30 161
多线程 事务
Spring在多线程环境下如何确保事务一致性
m0_53157173的博客
10-20 1万+
如何实现Spring在多线程环境下的事物一致性呢？还不快学起来！！！
多线程情况下保证数据一致的方法
热门推荐
rufeng的博客
04-07 1万+
多线程情况下，怎样确保对同一变量的改变出现一致性问题 使用synchronized关键字 比如：对num变量进行操作，如果没有synchronized 关键字，即使是使用volatile修饰变量，输出的值也会小于100000，因为volatile虽然能够保证可见性及顺序性，但是不能保证变量的原子性。 private static int num = ...
Spring的JPA事务管理
乌鲁木齐001号程序员
06-28 238
Demo1 - 代码实现 - PROPAGATION_REQUIRED web层调service的方法没有加事务，service中的事务传播机制为PROPAGATION_REQUIRED，故service中的方法受事务控制，数据保存失败； PROPAGATION_REQUIRED A有，B不新建事务 A没有，B新建事务 package com....
Spring多线程事务解决方案
can_meng_yun的博客
01-07 7117
对批量操作进行性能优化时会用到多线程来并行处理，从而提高运行效率。而时有业务要求保证批量操作事务的一致性，但不同线程所对应的是不同的事务，这就无法通过Spring提供的注解@Transactional来保证线程间的事务一致性。这也是Spring事务失效的一种情况。可以参考分布式2PC协议，通过编程式事务的方式，统一管理所有1线程事务的提交或回滚
Java面试题包涵基础，微服务分布式，数据库，jvm，网络，设计模式，算法，分布式锁和分布式事物等等
06-07
分布式事务处理则涉及到2PC、TCC、Saga等多种模型，确保在分布式环境下的数据一致性。 以上各点是Java开发者面试时常见的重点，对于每个知识点，都需要深入理解和实践，才能在面试中展现出扎实的技术功底。这些文档...
Java jdbc三层及事务（转账案例）
05-10
在多线程的JDBC操作中，ThreadLocal可以用来存储线程绑定的数据库连接，这样每个线程都有自己的连接，避免了线程间共享连接可能导致的竞态条件和同步问题。 转账案例中，可能遇到的关键点包括： 1. 并发控制：在高...
二十三种设计模式【PDF版】
05-30
所以很少存在简单重复的工作,加上Java 代码的精炼性和面向对象纯洁性(设计模式是 java 的灵魂),编程工作将变成一个让你时刻 体验创造快感的激动人心的过程. 为能和大家能共同探讨"设计模式",我将自己在学习中的心得...
java面试题，180多页，绝对良心制作，欢迎点评，涵盖各种知识点，排版优美，阅读舒心
08-13
【算法】什么是一致性哈希？用来解决什么问题？ 144 【性能优化】页面静态化 144 【设计模式】写一个单例(延迟加载,高性能) 144 【容器】Apache Http Server和Tomcat 区别 145 【版本控制】GIT与SVN的区别 146 【高...
软件工程的实习总结.docx
02-04
可重入函数可以在多线程环境下并发使用，但并不保证线程安全，尤其是在共享全局变量和静态变量的情况下。而不可重入函数则肯定不具备线程安全性。 在课程的后期，学习了pthread_rwlock_t类型的读写锁，包括其初始化...
多线程事务如何保证效率和原子性
BASK2312的博客
02-02 1399
在Spring开发时，遇到一个从Excel表导入数据到数据库的需求，当然最简单的方法就是先使用EasyExcel把数据读出到集合中，然后依次插入到数据库中。但如何保证效率，原子性呢？我们一步步优化方案。这里不会引入不必要的组件，而是自己模拟类似的思想。我们需要下面的方式进行执行这里我们使用和Volatile来解决这个问题。Volatile。
Spring如何在多线程下保持事务的一致性
YIYIYI
11-26 2821
Spring如何在多线程下保持事务的一致性
Spring多线程事务能否保证事务的一致性
qq_46130027的博客
10-29 289
Spring的事务信息是存在ThreadLocal中的，所以一个线程永远只能有一个事务。因此Spring的事务是无法实现事务一致性的。这里有个事务方法A，在这个方法中创建了一个线程，线程里面去调用B。那么这个时候，A和B能保证数据的一致性或者原子性吗？也就是A失败了，B是否会正常提交。B失败了, A是否会一起回滚。答案是不能保证一致性以及原子性的。可以通过编程式事务，或者通过分布式事务的思路：二阶段提交方式。
多线程的一致性怎么保证
07-29
多线程的一致性可以通过以下几种方式来保证： 1. 使用事务：在多线程环境下，可以使用事务来保证一致性。事务可以将一组操作作为一个不可分割的单元，要么全部成功提交，要么全部失败回滚。通过在多线程中使用事务，可以确保所有操作的一致性。\[1\] 2. 使用线程等待：在多线程环境下，可以使用线程等待的方式来保证一致性。可以让执行快的线程等待执行慢的线程，直到所有线程都完成后再进行统一的操作，如commit或rollback。这样可以确保所有操作都已完成再进行下一步操作，从而保证一致性。\[1\] 3. 进行多次测试：在多线程环境下，有些场景可能需要多次测试才能重现问题。通过多次运行测试，可以观察到多线程操作的一致性问题，并及时进行修复和调整。\[2\] 4. 使用异步操作：在一些特殊场景下，可以使用异步操作来保持一致性。通过将耗时较长的操作异步执行，可以将整体执行时间缩短，并保持事务的一致性。例如，在插入多个相关数据时，可以将每个插入操作异步执行，保持操作的一致性。\[3\] 综上所述，多线程的一致性可以通过使用事务、线程等待、多次测试和异步操作等方式来保证。具体的选择取决于具体的场景和需求。 #### 引用[.reference_title] - *1* *2* *3* [多线程模式下保证事物的一致性](https://blog.csdn.net/qq_38637558/article/details/128457701)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^koosearch_v1,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值