2、AsyncTool框架实战使用

已于 2024-10-25 10:50:30 修改
阅读量4.3k 收藏 26
点赞数 12
分类专栏： # 并行编排AsyncTool框架源码解析 文章标签： java AsyncTool框架 AsyncTool框架原理解析 中间件
于 2022-06-12 17:04:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rongtaoup/article/details/125247148
版权

前言

本文是专栏《AsyncTool框架原理源码解析》系列的第二篇文章《AsyncTool框架实战使用》，通过编排串行、并行、阻塞等待-先串行，后并行、阻塞等待-先并行，后串行、异常、超时等多种场景进行编码调试，学习AsyncTool框架的实际应用，并初步探知其实现原理。

专栏《AsyncTool框架原理源码解析》共有 5篇 文章，由浅入深，从实战使用再到源码、原理分析，包括但不仅局限于AsyncTool框架思考和总结，最后分享下我为AsyncTool框架开源项目贡献代码。以下是《专栏目录》：

  1. 《AsyncTool框架简介和分析实现》
  2. 《AsyncTool框架实战使用》
  3. 《AsyncTool框架原理源码解析》
  4. 《AsyncTool框架的一些思考》
  5. 《AsyncTool框架竟然有缺陷？》

1、串行场景

请添加图片描述

在实战之前，先看一下Worker最小任务单元的使用。

Worker的定义如下，实现IWorker，ICallback函数式接口，并重写下面的4个方法。4个方法的说明如下：

1、begin()：Worker开始执行前，先回调begin()

2、action()：Worker中执行耗时操作的地方，比如RPC接口调用。

3、result()：action()执行完毕后，回调result方法，可以在此处处理action中的返回值。

4、defaultValue()：整个Worker执行异常，或者超时，会回调defaultValue()，Worker返回默认值。

如果没有实现ICallback，会默认执行DefaultCallback的回调方法。DefaultCallback是一个空的回调，里面没有任何逻辑。

模拟串行场景：A任务对参数+1，之后B任务对参数+2，之后C任务对参数+3。（场景没有实际业务含义，很简单）

（1）workerA：

public class WorkerA implements IWorker<Integer, Integer>, ICallback<Integer, Integer> {

    /**
     * Worker开始的时候先执行begin
     */
    @Override
    public void begin() {
        System.out.println("A - Thread:" + Thread.currentThread().getName() + "- start --" + SystemClock.now());
    }

    /**
     * Worker中耗时操作在此执行RPC/IO
     * @param object      object
     * @param allWrappers 任务包装
     * @return
     */
    @Override
    public Integer action(Integer object, Map<String, WorkerWrapper> allWrappers) {
        Integer res = object + 1;
        return res;
    }

    /**
     * action执行结果的回调
     * @param success
     * @param param
     * @param workResult
     */
    @Override
    public void result(boolean success, Integer param, WorkResult<Integer> workResult) {
        System.out.println("A - param:" + JSON.toJSONString(param));
        System.out.println("A - result:" + JSON.toJSONString(workResult));

        System.out.println("A - Thread:" + Thread.currentThread().getName() + "- end --" + SystemClock.now());
    }

    /**
     * Worker异常时的回调
     * @return
     */
    @Override
    public Integer defaultValue() {
        System.out.println("A - defaultValue");
        return 101;
    }

}

（2）workerB：

public class WorkerB implements IWorker<Integer, Integer>, ICallback<Integer, Integer> {

    /**
     * Worker开始的时候先执行begin
     */
    @Override
    public void begin() {
        System.out.println("B - Thread:" + Thread.currentThread().getName() + "- start --" + SystemClock.now());
    }

    /**
     * Worker中耗时操作在此执行RPC/IO
     * @param object      object
     * @param allWrappers 任务包装
     * @return
     */
    @Override
    public Integer action(Integer object, Map<String, WorkerWrapper> allWrappers) {
        Integer res = object + 2;
        return res;
    }

    /**
     * action执行结果的回调
     * @param success
     * @param param
     * @param workResult
     */
    @Override
    public void result(boolean success, Integer param, WorkResult<Integer> workResult) {
        System.out.println("B - param:" + JSON.toJSONString(param));
        System.out.println("B - result:" + JSON.toJSONString(workResult));

        System.out.println("B - Thread:" + Thread.currentThread().getName() + "- end --" + SystemClock.now());
    }

    /**
     * Worker异常时的回调
     * @return
     */
    @Override
    public Integer defaultValue() {
        System.out.println("B - defaultValue");
        return 102;
    }
}

（3）WorkerC：

public class WorkerC implements IWorker<Integer, Integer>, ICallback<Integer, Integer> {

    /**
     * Worker开始的时候先执行begin
     */
    @Override
    public void begin() {
        System.out.println("C - Thread:" + Thread.currentThread().getName() + "- start --" + SystemClock.now());
    }

    /**
     * Worker中耗时操作在此执行RPC/IO
     * @param object      object
     * @param allWrappers 任务包装
     * @return
     */
    @Override
    public Integer action(Integer object, Map<String, WorkerWrapper> allWrappers) {
        Integer res = object + 3;
        return res;
    }

    /**
     * action执行结果的回调
     * @param success
     * @param param
     * @param workResult
     */
    @Override
    public void result(boolean success, Integer param, WorkResult<Integer> workResult) {
        System.out.println("C - param:" + JSON.toJSONString(param));
        System.out.println("C - result:" + JSON.toJSONString(workResult));

        System.out.println("C - Thread:" + Thread.currentThread().getName() + "- end --" + SystemClock.now());
    }

    /**
     * Worker异常时的回调
     * @return
     */
    @Override
    public Integer defaultValue() {
        System.out.println("C - defaultValue");
        return 103;
    }
}

（4） 编排WorkerWrapper包装类：

上面Worker创建好之后，使用WorkerWrapper对Worker进行包装以及编排，WorkerWrapper是AsyncTool组件的最小可执行任务单元。

C是最后一步，它没有next。B的next是C，A的next是B。编排顺序就是：C <- B <- A

public class Test {

    public static void main(String[] args) {
        //引入Worker工作单元
        WorkerA workerA = new WorkerA();
        WorkerB workerB = new WorkerB();
        WorkerC workerC = new WorkerC();

        //包装Worker，编排串行顺序：C <- B <- A
        //C是最后一步，它没有next
        WorkerWrapper wrapperC = new WorkerWrapper.Builder<Integer, Integer>()
                .id("workerC")
                .worker(workerC)
                .callback(workerC)
                .param(3)//3+3
                .build();
        //B的next是C
        WorkerWrapper wrapperB = new WorkerWrapper.Builder<Integer, Integer>()
                .id("workerB")
                .worker(workerB)
                .callback(workerB)
                .param(2)//2+2
                .next(wrapperC)
                .build();
        //A的next是B
        WorkerWrapper wrapperA = new WorkerWrapper.Builder<Integer, Integer>()
                .id("workerA")
                .worker(workerA)
                .callback(workerA)
                .param(1)//1+1
                .next(wrapperB)
                .build();
        try {
            //Action
            Async.beginWork(1000, wrapperA);
        } catch (ExecutionException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

（5）通过执行器类Async的beginWork方法提交任务执行。

  1. Timeout：全组任务超时时间设定，如果Worker任务超时，则Worker结果使用defaultValue()默认值。
  2. ExecutorService executorService：自定义线程池，不自定义的话，就走默认的COMMON_POOL。默认的线程池是不定长线程池。
  3. WorkerWrapper… workerWrapper：起始任务，可以是多个。注意不要提交中间节点的任务，只需要提交起始任务即可，编排的后续任务会自动执行。
//默认不定长线程池
private static final ThreadPoolExecutor COMMON_POOL = (ThreadPoolExecutor) Executors.newCachedThreadPool();

Async.beginWork(long timeout, ExecutorService executorService, WorkerWrapper... workerWrapper)

（6）上面只是一种写法，如果觉得这种写法反人类，也可以使用depend方式编排：

//A没有depend
WorkerWrapper wrapperA = new WorkerWrapper.Builder<Integer, Integer>()
        .id("workerA")
        .worker(workerA)
        .callback(workerA)
        .param(1)
        .build();

//B的depend是A
WorkerWrapper wrapperB = new WorkerWrapper.Builder<Integer, Integer>()
        .id("workerB")
        .worker(workerB)
        .callback(workerB)
        .param(2)
        .depend(wrapperA)
        .build();

//C的depend是B
WorkerWrapper wrapperC = new WorkerWrapper.Builder<Integer, Integer>()
        .id("workerC")
        .worker(workerC)
        .callback(workerC)
        .param(3)
        .depend(wrapperB)
        .build();
//begin
Async.beginWork(1000, wrapperA);

运行结果：A：1+1=2；B：2+2=4；C：3+3=6

请添加图片描述

2、并行场景

请添加图片描述

场景模拟：基于串行场景，。A任务对参数+1，B任务对参数+2，C任务对参数+3。并行执行。

WorkerWrapper并行编排：A\B\C都没有next和depend， 3个WorkerWrapper一起begin。Async.beginWork(1000, wrapperA, wrapperB, wrapperC);

public class Test {

    public static void main(String[] args) {
        //引入Worker工作单元
        WorkerA workerA = new WorkerA();
        WorkerB workerB = new WorkerB();
        WorkerC workerC = new WorkerC();

        /**
         * 包装Worker，编排并行顺序
         */

        //A
        WorkerWrapper wrapperA = new WorkerWrapper.Builder<Integer, Integer>()
                .id("workerA")
                .worker(workerA)
                .callback(workerA)
                .param(1)//1+1
                .build();
        //B
        WorkerWrapper wrapperB = new WorkerWrapper.Builder<Integer, Integer>()
                .id("workerB")
                .worker(workerB)
                .callback(workerB)
                .param(2)//2+2
                .build();
        //C
        WorkerWrapper wrapperC = new WorkerWrapper.Builder<Integer, Integer>()
                .id("workerC")
                .worker(workerC)
                .callback(workerC)
                .param(3)//3+3
                .build();
        try {
            //3个WorkerWrapper一起begin
            Async.beginWork(1000, wrapperA, wrapperB, wrapperC);
        } catch (ExecutionException | InterruptedException e) {
            e.printStackTrace();
        }

    }
}

执行结果：ABC分别使用不同的线程并行执行。A：1+1=2；B：2+2=4；C：3+3=6

请添加图片描述

3、阻塞等待 - 先串行，后并行

请添加图片描述

阻塞等待 - 先串行，后并行场景模拟：A先执行，对参数+1；A执行完毕之后，B\C同时并行执行，B任务基于A的返回值+2，C任务基于A的返回值+3

（1）next写法：

public static void nextWork() {
    //引入Worker工作单元
    WorkerA workerA = new WorkerA();
    WorkerB workerB = new WorkerB();
    WorkerC workerC = new WorkerC();

    //C是最后一步，它没有next
    WorkerWrapper wrapperC = new WorkerWrapper.Builder<Integer, Integer>()
            .id("workerC")
            .worker(workerC)
            .callback(workerC)
            .param(null)//没有参数，根据A的返回值+3
            .build();
    //B是最后一步，它没有next
    WorkerWrapper wrapperB = new WorkerWrapper.Builder<Integer, Integer>()
            .id("workerB")
            .worker(workerB)
            .callback(workerB)
            .param(null)//没有参数，根据A的返回值+2
            .build();
    //A的next是B、C
    WorkerWrapper wrapperA = new WorkerWrapper.Builder<Integer, Integer>()
            .id("workerA")
            .worker(workerA)
            .callback(workerA)
            .param(1)//1+1
      			//next是B、C
            .next(wrapperB, wrapperC)
            .build();


    try {
        //Action
        Async.beginWork(1000, wrapperA);
    } catch (ExecutionException | InterruptedException e) {
        e.printStackTrace();
    }
}

（2）depend写法：

//A没有depend，就是开始
WorkerWrapper wrapperA = new WorkerWrapper.Builder<Integer, Integer>()
        .id("workerA")
        .worker(workerA)
        .callback(workerA)
        .param(1)
        .build();

//C depend A
WorkerWrapper wrapperC = new WorkerWrapper.Builder<Integer, Integer>()
        .id("workerC")
        .worker(workerC)
        .callback(workerC)
        .param(null)
        .depend(wrapperA)
        .build();
//B depend A
WorkerWrapper wrapperB = new WorkerWrapper.Builder<Integer, Integer>()
        .id("workerB")
        .worker(workerB)
        .callback(workerB)
        .param(null)
        .depend(wrapperA)
        .build();

执行结果：A：1+1 = 2；B：2+2 =4；C：3+2 = 5

请添加图片描述

4、阻塞等待 - 先并行，后串行

请添加图片描述

场景模拟：阻塞等待 - 先并行，后串行。

B\C并行执行。B对参数+2，C对参数+3，B\C全部执行完后，A = B返回值+C返回值。

注意：需要B和C同时begin。Async.beginWork(4000, wrapperB, wrapperC);

（1）next写法：

public static void nextWork() {

    //引入Worker工作单元
    WorkerA workerA = new WorkerA();
    WorkerB workerB = new WorkerB();
    WorkerC workerC = new WorkerC();

    //A是最后一步，没有next
    WorkerWrapper wrapperA = new WorkerWrapper.Builder<Integer, Integer>()
            .id("workerA")
            .worker(workerA)
            .callback(workerA)
            .param(null)//参数是null，A = B + C
            .build();

    //C next A
    WorkerWrapper wrapperC = new WorkerWrapper.Builder<Integer, Integer>()
            .id("workerC")
            .worker(workerC)
            .callback(workerC)
            .param(3)//3+3 = 6
            .next(wrapperA)
            .build();
    //B next A
    WorkerWrapper wrapperB = new WorkerWrapper.Builder<Integer, Integer>()
            .id("workerB")
            .worker(workerB)
            .callback(workerB)
            .param(2)//2+2 = 4
            .next(wrapperA)
            .build();

    try {new SynchronousQueue<Runnable>();
        //Action
        Async.beginWork(4000, wrapperB, wrapperC);
    } catch (ExecutionException | InterruptedException e) {
        e.printStackTrace();
    }
}

（2）depend写法：

//C没有depend，是起始节点
WorkerWrapper wrapperC = new WorkerWrapper.Builder<Integer, Integer>()
        .id("workerC")
        .worker(workerC)
        .callback(workerC)
        .param(3)//3+3 = 6
        .build();
//B没有depend，是起始节点
WorkerWrapper wrapperB = new WorkerWrapper.Builder<Integer, Integer>()
        .id("workerB")
        .worker(workerB)
        .callback(workerB)
        .param(2)//2+2 = 4
        .build();

//A depend B,C
WorkerWrapper wrapperA = new WorkerWrapper.Builder<Integer, Integer>()
        .id("workerA")
        .worker(workerA)
        .callback(workerA)
        .param(null)//参数是null，A = B + C
        .depend(wrapperB, wrapperC)
        .build();

执行结果：B：2+2=4；C：3+3 = 6；A = B+C = 10

请添加图片描述

5、异常、超时回调场景

这2种场景，可以基于以上场景微调，即可debug调试。

//超时时间，线程池，初始Wrapper，多个
Async.beginWork(long timeout, ExecutorService executorService, WorkerWrapper... workerWrapper)
  1. 基于全组设定的timeout，如果超时了，则worker中的返回值使用defaultValue()
  2. 如果当前Worker任务异常了，则当前任务使用defaultValue()，并且depend当前任务的，也FastFail，返回defaultValue()

🎉 如果喜欢这篇文章，请不要吝啬你的赞👍👍👍哦，创作不易，感谢！

请添加图片描述

涛声依旧叭
关注
专栏目录
1、AsyncTool框架简介和分析实现
真正的大师，永远怀着一颗学徒的❤
06-12 8601
本文是专栏《AsyncTool框架原理源码解析》系列的第一篇文章《AsyncTool框架简介和分析实现》，以解决实际问题为出发点，以需求分析和设计实现为实践，带你一步一步分析如何设计一款和类似的多线程并行、串行、阻塞、依赖、回调的并行框架。专栏《AsyncTool框架原理源码解析》共有 5篇 文章，由浅入深，从实战使用再到源码、原理分析，包括但不仅局限于思考和总结，最后分享下我为开源项目贡献代码。以下是《专栏目录》：它是由京东零售开源的项目，作者是天涯泪小武。该框架目前正在 京东App后台 接受苛刻、高并发
asyncTool并行框架-其他
06-12
asyncTool是一个可以解决任意的多线程并行、串行、阻塞、依赖、回调的并行框架，可以任意组合各线程的执行顺序，带全链路执行结果回调。多线程编排一站式解决方案。来自于京东主App后台。 asyncTool特点： 1、解决任意的多线程并行、串行、阻塞、依赖、回调的并发框架，可以任意组合各线程的执行顺序，带全链路回调和超时控制。 2、其中的A、B、C分别是一个最小执行单元（worker），可以是一段耗时代码、一次Rpc调用等，不局限于你做什么。 3、该框架可以将这些worker，按照你想要的各种执行顺序，加以组合编排。最终得到结果。 4、并且，该框架 为每一个worker都提供了执行结果的回调和执行失败后自定义默认值 。譬如A执行完毕后，A的监听器会收到回调，带着A的执行结果（成功、超时、异常）。 5、根据你的需求，将各个执行单元组合完毕后，开始在主线程执行并阻塞，直到最后一个执行完毕。并且 可以设置全组的超时时间 。 6、该框架支持后面的执行单元以前面的执行单元的结果为自己的入参 。譬如你的执行单元B的入参是ResultA，ResultA就是A的执行结果，那也可以支持。在编排时，就可以预先设定B或C的入参为A的result，即便此时A尚未开始执行。当A执行完毕后，自然会把结果传递到B的入参去。
支持线程编排的并行框架AsyncTool
最新发布
qq_73210658的博客
09-15 1578
AsyncTool是一款京东零售开源的支持编排、异步回调的框架，代码量少但功能强大。我会以一个初学者的角度进行介绍，快来一起学习吧！
微服务并行计算框架asyncTool使用说明
jetty_welcome的博客
04-26 3316
一、为什么要使用并行计算框架 1 复杂的微服务系统间调用 经常会有这样的调用场景：app（或web前端）调用后台的一个接口，该接口接到该请求后，需要调用其他多个微服务来获取数据，最终汇总一个最终结果返回给用户。 譬如用户请求“我的订单”，后台在收到请求后，就需要去调用用户详情rpc、商品详情rpc、库存rpc、优惠券rpc等等很多个服务。有些服务是可以并行去请求的，但有些服务是依赖于某个服务的返回值的（如查库存、优惠券，就依赖于商品详情回复到达后才能去请求）。 2 工作流式的任务编排 譬如在数据清洗领域，经
asyncTool 使用指南
gitblog_00740的博客
08-22 366
asyncTool 使用指南 asyncTool京东的一款并发框架项目地址:https://gitcode.com/gh_mirrors/as/asyncTool 本教程旨在帮助您快速理解和上手 asyncTool 这一开源项目，通过讲解其目录结构、启动文件以及配置文件，使您能够顺利进行开发或集成。该项目位于 GitHub，以下内容基于该仓库的最新版本。 1. 项目目录结构及介绍 asyncTo...
【并行编程框架】AsyncTool
weixin_44783506的博客
02-06 1246
自定义线程任务A、B、C，实现IWorker，ICallback函数式接口，并重写下面的4个方法。begin()：Worker开始执行前，先回调begin()action()：Worker中执行耗时操作的地方，比如RPC接口调用。result()：action()执行完毕后，回调result方法，可以在此处处理action中的返回值。defaultValue()：整个Worker执行异常，或者超时，会回调defaultValue()，Worker返回默认值。
研究一款 Java 线程编排并行框架-asyncTool
uzong
03-24 2122
如果有复杂场景，可以参考这个框架，但一定要熟知这个框架的特性，比如超时快速失败等场景是否接受；我要执行 TaskC，则先执行 TaskA 和 TaskB，然后才能执行 TaskC，最后再执行 TaskD。“解决任意的多线程并行、串行、阻塞、依赖、回调的并行框架，可以任意组合各线程的执行顺序，带全链路执行结果回调。因此，不管从 TaskC 作为入口，还是 TaskD 作为入口，它的执行结果都是一致的。最后，如果有后续的任务依赖于当前任务的完成，WorkerWrapper 将触发下一个任务的执行。
asyncTool并行框架 v1.4.zip
03-18
asyncTool并行框架v1.4是一个用于提升程序执行效率的工具，主要针对多线程和异步编程的场景。这个框架可能包含了丰富的类库和API，帮助开发者更有效地利用现代计算机的多核处理器资源，从而实现并发任务的高效执行。...
asyncTool并行框架 v1.0-源码.zip
02-26
"asyncTool并行框架 v1.0-源码.zip"是一个包含并行处理框架源代码的压缩文件，专为开发者提供学习和理解异步编程设计的资源。在深入探讨这个框架之前，首先需要理解什么是异步编程。异步编程是一种编程范式，它允许...
【Java分享客栈】一文搞定京东零售开源的AsyncTool，彻底解决异步编排问题。.doc
07-12
使用AsyncTool非常简单，主要分为两步： 1. 引入AsyncTool 可以通过maven引入AsyncTool，但不推荐使用这种方式，因为可能会导致依赖下载不下来。推荐的方式是直接下载源码，核心代码放到java目录里面，测试代码放...
京东零售多线程并行框架 - AsyncTool
.
01-02 5325
文章目录京东零售多线程并行框架 - AsyncTool一、基本入门1 首发案例（并发执行）第一步：获取源码第二步：构建任务类第三步：执行总结2 案例二：获取上一个任务的执行结果作为自身的入参3 案例三：如果上一个任务出现了异常4 案例四：完全异步玩法一玩法二二、源码解析持续更新中万事如意，阖家安康 京东零售多线程并行框架 - AsyncTool 文章目录 QuickStart.md · 京东零售/asyncTool - Gitee.com / / 在平常工作中经常会习惯使用传统的
AsyncTask的简单例子
03-23
AsyncTask的一个小例子，详情请见： http://blog.csdn.net/woaieillen/article/details/7372293
asynctools：用于Nim语言的各种异步工具
02-03
asynctools：用于Nim语言的各种异步工具
asyncTool并行框架v1.0源码包学习指南
压缩包子文件的文件名称列表中包含一个单独的文件名：“内容来自存起来软件站***.txt”，这可能是一个说明文件，用来进一步解释asyncTool并行框架的使用方法、功能特点、授权信息或是其他相关信息。该文件的命名方式...
asyncTool 开源项目教程
gitblog_00319的博客
08-22 627
asyncTool 开源项目教程 asyncTool京东的一款并发框架项目地址:https://gitcode.com/gh_mirrors/as/asyncTool 项目介绍 asyncTool 是一个用于异步编程的开源工具库，旨在简化异步任务的管理和调度。该项目提供了丰富的API，支持多种异步模式，包括但不限于任务队列、定时任务和并发控制。asyncTool 的设计理念是提供一个高效、易用的...
AsyncTask学习与实战
Android 小萌新的博客
05-23 809
前言 Android 系统默认会在主线程（UI 线程）执行任务，但是如果有耗时程序就会阻塞 UI 线程，导致页面卡顿。这时候我们通常会将耗时任务放在独立的线程，然后通过 Handler 等线程间通信机制完成 UI 的刷新。很多时候我们也许只是想执行一个简单的任务，为此写一套 Handler 线程通信就会显得比较复杂，不用担心，Android 系统为我们提供了一个专门用于执行异步任务的工具——AsyncTask 在Android的android.os.AsyncTask的类前注释（2021-05），对Asyn
异步编程生产实践
小海子的博客
11-06 590
介绍异步编程的实现，并对CompletableFuture做简单介绍。
【Java核心能力】京东并行框架asyncTool如何针对高并发场景进行优化？
qq_45260619的博客
03-10 1458
由于最近在整理并发相关的内容，整理了 CompletableFuture、CAS、线程池这些方面的内容，但是通过理论知识我们只是学会了：怎么去用？应该怎么去用？ 但是并没有学习别人如何去用，没有实际场景的示范，恰巧看到了 tianyaleixiaowu 作者开源出来的 asyncTool 并行框架 ，并且已经在 京东App后台接受苛刻、高并发、海量用户等复杂场景业务的检验测试 所以这篇文章就以这个并行框架为例，来说一下如何在高并发场景中保证比较好的性能，即如何通过 CompletableFuture、C
工具类NetUtil
yedaiyang的博客
11-01 244
import android.graphics.Bitmap; import android.graphics.BitmapFactory; import android.util.Log; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

涛声依旧叭

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

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

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

打赏作者

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

抵扣说明：

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

余额充值