多线程插入数据库

原创 已于 2026-01-08 18:25:09 修改 · 124 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据库

于 2026-01-08 18:22:11 首次发布

多线程插入数据库

package com.jd.adapter.processor.huarun.so;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import javax.annotation.PreDestroy;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.*;

/**
 * 华润数据批量插入助手类（基础版）
 * 实现了基本的多线程批量插入逻辑，但未处理日志TraceId透传，业务逻辑耦合在内部
 */
@Slf4j
@Component
public class HuaRunBatchInsertSimpleHelper {

    /**
     * 核心线程数
     */
    private static final int CORE_POOL_SIZE = 5;
    /**
     * 最大线程数
     */
    private static final int MAX_POOL_SIZE = 10;
    /**
     * 队列容量
     */
    private static final int QUEUE_CAPACITY = 1000;
    /**
     * 线程空闲存活时间
     */
    private static final long KEEP_ALIVE_TIME = 60L;

    /**
     * 自定义线程池
     * 使用CallerRunsPolicy拒绝策略，防止任务丢失
     */
    private final ExecutorService executorService = new ThreadPoolExecutor(
            CORE_POOL_SIZE,
            MAX_POOL_SIZE,
            KEEP_ALIVE_TIME,
            TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(QUEUE_CAPACITY),
            new ThreadFactory() {
                private int count = 0;
                @Override
                public Thread newThread(Runnable r) {
                    return new Thread(r, "huarun-batch-insert-simple-" + (++count));
                }
            },
            new ThreadPoolExecutor.CallerRunsPolicy()
    );

    /**
     * 处理批量插入
     *
     * @param dataList 数据列表
     * @param batchSize 每批次大小
     * @param <T> 数据类型
     * @return 插入结果汇总
     */
    public <T> BatchInsertResult processBatchInsert(List<T> dataList, int batchSize) {
        if (CollectionUtils.isEmpty(dataList)) {
            return new BatchInsertResult(0, 0, Collections.emptyList());
        }

        // 1. 数据切分
        List<List<T>> partitions = partition(dataList, batchSize);
        List<CompletableFuture<BatchInsertResult>> futures = new ArrayList<>();

        // 2. 提交多线程任务
        for (List<T> batch : partitions) {
            CompletableFuture<BatchInsertResult> future = CompletableFuture.supplyAsync(
                    () -> doInsert(batch), 
                    executorService
            );
            futures.add(future);
        }

        // 3. 等待所有任务完成
        CompletableFuture<Void> allFutures = CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]));
        try {
            // 设置超时时间，避免无限等待
            allFutures.get(1, TimeUnit.HOURS);
        } catch (InterruptedException e) {
            log.error("批量插入任务被中断", e);
            Thread.currentThread().interrupt();
            return new BatchInsertResult(0, dataList.size(), Collections.singletonList("Task Interrupted"));
        } catch (ExecutionException | TimeoutException e) {
            log.error("批量插入任务执行异常或超时", e);
            // 继续向下执行，收集已完成的结果
        }

        // 4. 汇总结果
        return collectResults(futures);
    }

    /**
     * 执行具体的插入逻辑
     */
    private <T> BatchInsertResult doInsert(List<T> batch) {
        int success = 0;
        int fail = 0;
        List<String> errors = new ArrayList<>();

        try {
            // ---------------------------------------------------------
            // 【伪代码】数据库插入逻辑开始
            // 注意：这里没有处理TraceId，多线程下日志链路可能会断开
            // ---------------------------------------------------------
            
            // 示例：
            // if (CollectionUtils.isEmpty(batch)) return ...;
            // yourMapper.batchInsert(batch);
            
            // 模拟逻辑：假设插入成功
            success = batch.size();
            
            // ---------------------------------------------------------
            // 【伪代码】数据库插入逻辑结束
            // ---------------------------------------------------------
        } catch (Exception e) {
            log.error("本批次插入异常, size: {}", batch.size(), e);
            fail = batch.size();
            errors.add("Batch insert failed: " + e.getMessage());
        }

        return new BatchInsertResult(success, fail, errors);
    }

    /**
     * 汇总多线程执行结果
     */
    private BatchInsertResult collectResults(List<CompletableFuture<BatchInsertResult>> futures) {
        int totalSuccess = 0;
        int totalFail = 0;
        List<String> totalErrors = new ArrayList<>();

        for (CompletableFuture<BatchInsertResult> future : futures) {
            try {
                if (future.isDone() && !future.isCompletedExceptionally()) {
                    BatchInsertResult result = future.get();
                    totalSuccess += result.getSuccessCount();
                    totalFail += result.getFailCount();
                    if (!CollectionUtils.isEmpty(result.getErrorMessages())) {
                        totalErrors.addAll(result.getErrorMessages());
                    }
                } else {
                    // 对于异常或取消的任务，统计为失败
                    totalErrors.add("Task failed or was cancelled unexpectedly");
                }
            } catch (Exception e) {
                log.error("获取子任务结果异常", e);
                totalErrors.add("Get result exception: " + e.getMessage());
            }
        }
        return new BatchInsertResult(totalSuccess, totalFail, totalErrors);
    }

    /**
     * 辅助方法：切分List
     */
    private <T> List<List<T>> partition(List<T> list, int size) {
        if (list == null) return Collections.emptyList();
        List<List<T>> partitions = new ArrayList<>();
        for (int i = 0; i < list.size(); i += size) {
            partitions.add(new ArrayList<>(list.subList(i, Math.min(i + size, list.size()))));
        }
        return partitions;
    }

    /**
     * 容器销毁时优雅关闭线程池
     */
    @PreDestroy
    public void destroy() {
        if (executorService != null && !executorService.isShutdown()) {
            executorService.shutdown();
            try {
                if (!executorService.awaitTermination(5, TimeUnit.SECONDS)) {
                    executorService.shutdownNow();
                }
            } catch (InterruptedException e) {
                executorService.shutdownNow();
            }
        }
    }

    /**
     * 批量插入结果封装
     */
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public static class BatchInsertResult {
        /**
         * 成功插入条数
         */
        private int successCount;
        /**
         * 失败条数
         */
        private int failCount;
        /**
         * 错误信息列表
         */
        private List<String> errorMessages;
    }
}

进阶版 

package com.jd.adapter.processor.huarun.so;

import com.jd.adapter.util.ThreadLogUtil;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import javax.annotation.PreDestroy;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.*;
import java.util.function.Consumer;

/**
 * 华润数据批量插入助手类（进阶版）
 * 负责多线程批量处理数据入库，并处理跨线程日志链路追踪，支持自定义业务逻辑回调
 * @author liuyongchao32
 * @date 2026/1/8
 */
@Slf4j
@Component
public class HuaRunBatchInsertHelper {

    /**
     * 核心线程数
     */
    private static final int CORE_POOL_SIZE = 5;
    /**
     * 最大线程数
     */
    private static final int MAX_POOL_SIZE = 10;
    /**
     * 队列容量
     */
    private static final int QUEUE_CAPACITY = 1000;
    /**
     * 线程空闲存活时间
     */
    private static final long KEEP_ALIVE_TIME = 60L;

    /**
     * 自定义线程池
     * 使用CallerRunsPolicy拒绝策略，防止任务丢失
     */
    private final ExecutorService executorService = new ThreadPoolExecutor(
            CORE_POOL_SIZE,
            MAX_POOL_SIZE,
            KEEP_ALIVE_TIME,
            TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(QUEUE_CAPACITY),
            new ThreadFactory() {
                private int count = 0;
                @Override
                public Thread newThread(Runnable r) {
                    return new Thread(r, "huarun-batch-insert-" + (++count));
                }
            },
            new ThreadPoolExecutor.CallerRunsPolicy()
    );

    /**
     * 处理批量插入，支持自定义业务逻辑
     *
     * @param dataList 数据列表
     * @param batchSize 每批次大小
     * @param batchConsumer 具体的批量插入业务逻辑
     * @param <T> 数据类型
     * @return 插入结果汇总
     */
    public <T> BatchInsertResult processBatchInsert(List<T> dataList, int batchSize, Consumer<List<T>> batchConsumer) {
        if (CollectionUtils.isEmpty(dataList)) {
            return new BatchInsertResult(0, 0, Collections.emptyList());
        }

        // 获取主线程的traceId
        String parentTraceId = ThreadLogUtil.getTid();

        // 1. 数据切分
        List<List<T>> partitions = partition(dataList, batchSize);
        List<CompletableFuture<BatchInsertResult>> futures = new ArrayList<>();

        // 2. 提交多线程任务
        for (List<T> batch : partitions) {
            CompletableFuture<BatchInsertResult> future = CompletableFuture.supplyAsync(
                    () -> {
                        // 子线程设置traceId，保证日志链路完整
                        ThreadLogUtil.requestStart(parentTraceId);
                        try {
                            return doInsert(batch, batchConsumer);
                        } finally {
                            // 清理ThreadLocal，防止内存泄漏或污染复用线程
                            ThreadLogUtil.requestEnd();
                        }
                    },
                    executorService
            );
            futures.add(future);
        }

        // 3. 等待所有任务完成
        CompletableFuture<Void> allFutures = CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]));
        try {
            // 设置超时时间，避免无限等待，可根据实际业务调整
            allFutures.get(2, TimeUnit.HOURS);
        } catch (InterruptedException e) {
            log.error("批量插入任务被中断", e);
            Thread.currentThread().interrupt();
            return new BatchInsertResult(0, dataList.size(), Collections.singletonList("Task Interrupted: " + e.getMessage()));
        } catch (ExecutionException | TimeoutException e) {
            log.error("批量插入任务执行异常或超时", e);
            // 这里不抛出异常，尝试收集已完成的结果，未完成的会在collectResults中标记
        }

        // 4. 汇总结果
        return collectResults(futures);
    }

    /**
     * 执行具体的插入逻辑
     */
    private <T> BatchInsertResult doInsert(List<T> batch, Consumer<List<T>> batchConsumer) {
        int success = 0;
        int fail = 0;
        List<String> errors = new ArrayList<>();

        try {
            // 执行传入的业务逻辑
            batchConsumer.accept(batch);
            success = batch.size();
        } catch (Exception e) {
            log.error("本批次插入异常, size: {}", batch.size(), e);
            fail = batch.size();
            errors.add("Batch insert failed: " + e.getMessage());
        }

        return new BatchInsertResult(success, fail, errors);
    }

    /**
     * 汇总多线程执行结果
     */
    private BatchInsertResult collectResults(List<CompletableFuture<BatchInsertResult>> futures) {
        int totalSuccess = 0;
        int totalFail = 0;
        List<String> totalErrors = new ArrayList<>();

        for (CompletableFuture<BatchInsertResult> future : futures) {
            try {
                // 只统计正常完成的任务，异常或超时的任务无法获取结果
                if (future.isDone() && !future.isCompletedExceptionally() && !future.isCancelled()) {
                    BatchInsertResult result = future.get(); // 此时get应立即返回
                    totalSuccess += result.getSuccessCount();
                    totalFail += result.getFailCount();
                    if (!CollectionUtils.isEmpty(result.getErrorMessages())) {
                        totalErrors.addAll(result.getErrorMessages());
                    }
                } else {
                    // 对于未完成（超时）或异常的任务，记录错误
                    totalErrors.add("Task failed, timed out or was cancelled");
                    // 注意：这里无法准确统计失败条数，因为不知道该future对应多少数据（除非在Future中携带元数据）
                    // 实际生产中可以考虑让Future返回更丰富的结果包含原始批次大小
                }
            } catch (Exception e) {
                log.error("获取子任务结果异常", e);
                totalErrors.add("Get result exception: " + e.getMessage());
            }
        }
        return new BatchInsertResult(totalSuccess, totalFail, totalErrors);
    }

    /**
     * 辅助方法：切分List
     */
    private <T> List<List<T>> partition(List<T> list, int size) {
        if (list == null) return Collections.emptyList();
        List<List<T>> partitions = new ArrayList<>();
        for (int i = 0; i < list.size(); i += size) {
            partitions.add(new ArrayList<>(list.subList(i, Math.min(i + size, list.size()))));
        }
        return partitions;
    }

    /**
     * 容器销毁时优雅关闭线程池
     */
    @PreDestroy
    public void destroy() {
        if (executorService != null && !executorService.isShutdown()) {
            executorService.shutdown();
            try {
                if (!executorService.awaitTermination(5, TimeUnit.SECONDS)) {
                    executorService.shutdownNow();
                }
            } catch (InterruptedException e) {
                executorService.shutdownNow();
            }
        }
    }

    /**
     * 批量插入结果封装
     */
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public static class BatchInsertResult {
        /**
         * 成功插入条数
         */
        private int successCount;
        /**
         * 失败条数
         */
        private int failCount;
        /**
         * 错误信息列表
         */
        private List<String> errorMessages;
    }
}

在这里插入图片描述

list分组多线程插入数据库
BKKBjams的博客
11-28 1539
创建多线程 public static void createThreadPoolBatch() { List<String> lists = formatList(); ExecutorService executorService = new ThreadPoolComponent().getFullIOExecutorService(5, 60L, TimeUnit.SECONDS, new LinkedBlockingDeque<>(80).
调用分页接口使用多线程插入数据库
weixin_41963652的博客
04-01 1300
调用分页接口使用多线程插入数据库 public Object insert() throws Exception { Map mapResult = restTemplate.getForObject("http://127.0.0.1:8088/msg", Map.class); //返回类型 // {"currentPage":1,"tota...
java使用多线程插入数据库
热门推荐
chenpe32cp的博客
03-21 2万+
经过测试，单核机器上效果不好，甚至不如单线程效率高。多核CPU效果提升较为明显。参考博客：http://sky-xin.iteye.com/blog/2305973JdbcUtils.javapackage com.inserttestdata; import java.io.BufferedReader; import java.io.File; import java.io.FileInpu...
java 多线程 插入数据库_小弟请教一个多线程并发向数据库插入数据的问题
weixin_29628479的博客
02-21 695
该楼层疑似违规已被系统折叠隐藏此楼查看此楼String insertMapRecorderStr = "insert into map (zoom_level,tile_column,tile_row,tile_id) values(?,?,?,?)";String insertImageRecorderStr = "insert into images (tile_id,tile_data,t...
多线程访问数据库插入数据
qq_38349413的博客
06-08 4700
数据量大，插入数据库耗时长，多线程插入数据，springBoot+线程池+mybatisPlus
多线程批量插入数据库
殇之何伤的博客
09-30 4770
背景 目前有12万数据需要打入到mysql数据库 准备 开发环境 ：Java、JdbcTemplate、ThreadPoolTaskExecutor（线程池） 数据库：MySql 代码： 1、配置线程池 import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.schedu
java 多线程插入数据_Java多线程向数据库写入数据
weixin_33481663的博客
02-20 2182
任务: 从sqlserver中将一个表A(约16W条数据)导到mysql中对应的一个表B中。思路：分段获取A表中的数据后，用多个线程同时向B表中写入。关键代码//将数据库中的数据条数分段public void division(){//获取要导入的总的数据条数String sql3="SELECT count(*) FROM [CMD].[dbo].[mycopy1]";try {pss=co...
多线程往数据库添加数据
qq_42094745的博客
01-08 1733
一、多线程写法： /** * @author liangyongpeng * @create 2022/1/7 9:44 */ @Slf4j public class RunnableImpCrmOutsideUtil implements Runnable { private final CrmCustOutsideMapper outsideMapper; private List<CrmCustOutside> results = new ArrayList&
利用多线程将大数据插入数据库
weixin_45933454的博客
08-03 3488
利用多线程将大数据插入数据库
JAVA多线程实现数据库之间的数据互导、连接池、及多表插入数据库功能
03-20
本主题聚焦于如何利用多线程实现在不同数据库间的数据互导，以及结合连接池技术来优化数据库操作，并实现多表插入功能。我们将深入探讨以下几个核心知识点： 1. **Java多线程**： - **线程创建**：Java提供了多种...
怎么优化慢SQL
chenxuefeng_accp的专栏
01-06 718
摘要：本文系统介绍了MySQL慢SQL优化方法论，涵盖慢SQL定位、常见问题分析及优化策略。通过开启慢查询日志和使用EXPLAIN分析执行计划，可快速识别性能瓶颈。优化措施包括：合理设计索引（避免失效）、解决排序和临时表问题、优化JOIN查询、处理大分页性能问题等。高级优化手段涉及SQL重写、读写分离、分库分表和缓存技术。这些方法不仅适用于InnoDB引擎，部分也适用于其他关系型数据库，是提升数据库性能的实用指南。
AI应用（5）- RAG知识库理解
小糖豆
01-07 943
知识库其实是自己建立的库，并不是让模型记住，而是把文档变成可以检索的库，模型在这个过程中只是读证据，综合多端证据，按照规则输出而已。
基于学科知识图谱的智能搜索平台研究与构建
专业代码设计
01-09 396
本论文针对传统搜索引擎的不足，提出基于学科知识图谱的智能搜索平台。平台通过构建知识图谱，实现学术资源的精准索引与高效检索。实验证明，相比传统搜索，本平台在准确性、速度和满意度上均有显著优势，为学科知识检索提供新方案，具重要理论和应用价值。
HTML:SQLite本地网页查看
aimersong69的博客
01-06 322
本文介绍了一个基于Web的SQLite本地查看器工具，无需安装即可在浏览器中查看SQLite数据库。该工具采用HTML5技术实现，支持拖拽上传.db/.sqlite文件，提供表结构浏览、数据查询、自定义SQL执行和数据导出为CSV等功能。通过sql.js库实现前端SQL解析，保证数据在本地处理，避免云端传输的安全风险。界面采用现代化设计，包含响应式布局、表格展示和交互式操作，适合开发人员快速查看和分析SQLite数据库内容。
MySQL 架构与SQL执行全流程深度解析
最新发布
alonewolf_99的博客
01-10 582
MySQL学习路线与SQL执行机制解析 摘要：本文系统介绍了MySQL学习路径，分为基础、进阶和集群架构三个层次。重点剖析了SQL查询和更新语句的执行流程，包括连接器、分析器、优化器等核心模块。特别讲解了redolog和binlog的协作机制，以及通过两阶段提交保证数据一致性的原理。针对Java开发者，强调了连接池使用、事务控制和数据恢复等实践要点。文章通过"粉板记账"等生动比喻，帮助读者深入理解MySQL的底层运行机制和优化思路。
金仓数据库安全防护体系解析：从技术原理到落地实践
稻草人
01-10 3780
摘要 金仓数据库KingbaseES构建了覆盖全链条的安全防护体系，通过"三权分立"架构实现权限分离，支持多维度身份认证（包括国密算法），采用RBAC角色模型与强制访问控制（MAC）实现精细权限管控。其安全特性包括：系统初始化自动划分管理员权限边界，支持口令全生命周期管理，提供Kerberos/LDAP/SSL等多种强认证方式，并通过安全标记实现高敏感数据的刚性防护。该体系既满足国家信息安全标准，又能灵活适配不同安全等级场景需求，为企业数据库安全提供从技术落地到运维的完整解决方案。
LightRAG应用二-[文档Postgres数据库存储]
HarryChenj的专栏
01-09 545
LightRAG系统使用PostgreSQL数据库进行文档向量存储与管理
达梦数据库索引删除操作小记
吕呵呵的博客
01-06 361
摘要：达梦数据库(DM8)中删除系统自动生成的索引(如INDEX33557221)时，因该索引关联主键/唯一约束而被系统阻止。解决方案应先查询ALL_CONSTRAINTS表确定关联约束，通过删除约束(ALTER TABLE...DROP CONSTRAINT)间接删除索引。核心原则是约束(逻辑)与索引(物理)的绑定关系，系统索引作为约束的实现载体不应直接操作。操作流程需依次检查约束类型、业务影响和依赖关系，最终通过约束管理实现索引变更。（149字）
多线程插入数据库问题
09-18
多线程插入数据库时存在的问题及解决办法如下： ### 数据一致性问题 多线程同时插入数据可能会导致数据重复、数据冲突等一致性问题。例如，多个线程同时插入具有唯一约束的数据，就可能违反唯一约束条件。 解决办法：可以使用数据库的事务机制，将多个插入操作包裹在一个事务中，确保数据的一致性。另外，在代码层面可以添加同步机制，如使用锁来保证同一时间只有一个线程进行关键数据的插入操作。 ### 数据库连接池耗尽问题 如果线程数量过多，可能会导致数据库连接池中的连接被耗尽，从而使后续的插入操作无法获取连接而失败。 解决办法：合理配置线程池和数据库连接池的大小。根据数据库的性能和服务器的资源情况，设置合适的线程数和连接数。如引用[2]中配置线程池时，设置核心线程数、最大线程数和队列大小，避免线程数量过度增长。 ### 性能瓶颈问题 虽然多线程插入理论上可以提高插入性能，但如果数据库本身存在性能瓶颈，如磁盘I/O慢、索引过多等，多线程插入可能无法达到预期的效果，甚至会因为线程上下文切换开销过大而降低性能。 解决办法：对数据库进行性能优化，如优化数据库表结构、减少不必要的索引、使用批量插入语句等。同时，根据数据库的性能测试结果，调整线程池的参数。 ### 锁竞争问题 如果在多线程插入过程中使用了锁机制，可能会导致线程之间的锁竞争，从而降低并发性能。 解决办法：尽量减少锁的粒度，只在必要的代码段使用锁。可以使用更细粒度的锁，如使用分段锁或乐观锁来替代粗粒度的锁。 ### 代码示例 以下是综合引用内容，使用线程池进行多线程插入数据库的示例： ```java import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.scheduling.annotation.EnableAsync; import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor; import java.util.List; import java.util.concurrent.CountDownLatch; import java.util.concurrent.Executor; import java.util.concurrent.ThreadPoolExecutor; import org.slf4j.Logger; import org.slf4j.LoggerFactory; // 线程池配置 @Configuration @EnableAsync class ExecutorConfig { @Bean public Executor asyncServiceExecutor() { ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); executor.setCorePoolSize(5); executor.setMaxPoolSize(10); executor.setQueueCapacity(400); executor.setThreadNamePrefix("thread-"); executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); executor.initialize(); return executor; } } // 插入数据的任务类 class ImportData implements Runnable { private static final Logger log = LoggerFactory.getLogger(ImportData.class); private List<OnlineConfirmExportVO> list; private CountDownLatch latch; private Integer i; private Integer agencyAgreementType; public ImportData(List<OnlineConfirmExportVO> list, CountDownLatch latch, Integer i, Integer agencyAgreementType) { this.list = list; this.latch = latch; this.i = i; this.agencyAgreementType = agencyAgreementType; } @Override public void run() { log.info("线程" + i + "开始执行，数据条数：" + list.size()); String errorImport = "导入模板不正确"; try { // 这里添加实际的插入数据库操作 log.info("线程" + i + "执行结束，数据条数：" + list.size()); } catch (Exception e) { log.error("Catch OnlineConfirm import Exception:", e); } finally { latch.countDown(); } } } class OnlineConfirmExportVO { // 类的具体实现 } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值