RxTask-快捷切换线程，告别处处建立handler

时间  2019-11-09
标签 rxtask 快捷 切换 线程 告别 处处 建立 handler 繁體版
原文   原文链接

RxTask,基于线程池+handler封装工具。今后告别处处建立handler，远离处处建立线程没法管理。
已迁移到Androidx

早期的版本介绍：
RxTask第一版上篇
RxTask第一版下篇
java

项目地址 个人Github 个人码云git

集成方式： implementation 'com.xujl:task:1.0.1'
github

初始化

//默认初始化，默认初始化后核心线程数为cpu核心数X4
 RxExecutor.getInstance().init();
 //自定义核心线程数量进行初始化
 RxExecutor.getInstance().init(32);
 //彻底自定义工具线程池
 RxExecutor.getInstance().init(ExecutorService);
 //关闭log输出，默认为开启
 RxExecutor.getInstance().setDebug(false);
复制代码

如何使用？

场景1

子线程任务，执行完毕结果数据返回给主线程显示
RxExecutor.getInstance()
                .executeTask(new Task<String>(){
                    @Override
                    public void run (Emitter<String> emitter) throws Exception {
                        super.run(emitter);
                        //当前为子线程
                        //模拟子线程任务
                        Thread.sleep(1000);
                        //任务结束发送数据到主线程
                        emitter.next("任务执行结果数据");
                    }

                    @Override
                    public void onNext (String data) {
                        super.onNext(data);
                        //当前为主线程
                        //显示子线程执行结果
                        textView.setText(data);
                    }
                });
复制代码

场景2

子线程任务,不关心任务结果，只关心完成时机
RxExecutor.getInstance()
                .executeTask(new Task<String>() {
                    @Override
                    public void run (Emitter<String> emitter) throws Exception {
                        super.run(emitter);
                        //当前为子线程
                        //模拟子线程任务
                        Thread.sleep(1000);
                        //任务结束
                    }

                    @Override
                    public void onFinished () {
                        super.onFinished();
                        //当前为主线程
                        // 执行主线程逻辑
                    }
                });
复制代码

场景3

单纯执行一个子线程任务,不关心任务结果，也不须要在任务结束后有任何操做
RxExecutor.getInstance()
                .executeTask(new Task<String>() {
                    @Override
                    public void run (Emitter<String> emitter) throws Exception {
                        super.run(emitter);
                        //当前为子线程
                        //模拟子线程任务
                        Thread.sleep(1000);
                        //任务结束
                    }
                });
复制代码

场景4

执行一个普通子线程而非task
RxExecutor.getInstance()
                        .executeRunnableTask(new Runnable() {
                            @Override
                            public void run () {
                                //当前为子线程
                                //模拟子线程任务
                                Thread.sleep(1000);
                                //任务结束
                            }
                        });
复制代码

场景5

执行的任务绑定生命周期，界面销毁后，再也不回调

在bindLife方法中完成绑定，生命周期结束后，onFinished和onNext将不会再回调。app

private RxLifeList mBindLife = new RxLifeList();
    private void test(){
        RxExecutor.getInstance()
                .executeTask(new Task<String>() {
                    @Override
                    public void run (Emitter<String> emitter) throws Exception {
                        super.run(emitter);
                        //当前为子线程
                        //模拟子线程任务
                        Thread.sleep(2000);
                        //任务结束
                    }

                    @Override
                    public void onNext (String data) {
                        super.onNext(data);

                    }

                    @Override
                    public void onFinished () {
                        super.onFinished();
                        //当前为主线程
                        // 执行主线程逻辑
                    }

                    @Override
                    public void bindLife (RxLife rxLife) {
                        super.bindLife(rxLife);
                        mBindLife.add(rxLife);
                    }
                });
    }
    @Override
    protected void onDestroy () {
        if (mBindLife != null) {
            mBindLife.onDestroy();
        }
        super.onDestroy();
    }
复制代码

场景6

当前处于某个子线程任务中，须要主线程中显示数据
//其余子线程中
        new Thread(new Runnable() {
            @Override
            public void run () {
                //模拟子线程任务
                Thread.sleep(1000);
                //切换回主线程进行逻辑
                RxExecutor.getInstance()
                        .executeUiTask(new Task() {
                            @Override
                            public void onlyRunUiTask () {
                                super.onlyRunUiTask();
                                //执行主线程逻辑
                            }
                        });
            }
        }).start();
复制代码

场景7

任务执行失败，进行重试

使用 TaskBuilder.create().setRetryMaxCount(3)传入task构造器便可实现重试功能，方法参数为最大重试次数，传入 TaskRetry.INFINITE可实现无限重试（一般不建议这么作！）。
Task默认配置为失败后不重试
任务失败后会回调onError方法并返回具体错误，若是没有配置重试，进入onError的Task将结束生命周期，再也不回调onFinished或者onNext方法。ide

RxExecutor.getInstance()
                .executeTask(new Task<String>(
                        //配置失败重试
                        TaskBuilder.create()
                                .setRetryMaxCount(3)
                ) {
                    @Override
                    public void run (Emitter<String> emitter) throws Exception {
                        super.run(emitter);
                        //当前为子线程
                        //模拟子线程任务
                        Thread.sleep(1000);
                        //任务结束
                    }

                    @Override
                    public void onError (Exception e) {
                        super.onError(e);
                        //任务出错
                    }

                    @Override
                    public void onFinished () {
                        super.onFinished();
                        //当前为主线程
                        // 执行主线程逻辑
                    }
                });
复制代码

场景8

任务组

任务组是一种比较不常见的场景，好比开启双线程分别写入两个文件到内存卡，而且两个文件完成写入后退出界面。这时候就可使用任务组概念进行工具

RxExecutor.getInstance()
                .executeTaskGroup(GroupTaskBuilder.create()
                        .setResultTask(new GroupResultTask() {

                            @Override
                            public void oneTaskComplete (Object tag, Object result) {
                                result("任务" + tag.toString() + "执行结束，数据为：" + result, R.color.task_color_4);
                            }

                            @Override
                            public void allTaskComplete (HashMap<Object, Object> resultMap) {
                                StringBuilder result = new StringBuilder();
                                for (Object o : resultMap.keySet()) {
                                    result.append(o.toString());
                                    result.append(":");
                                    result.append("" + resultMap.get(o));
                                }
                                result("组任务所有完毕，数据为：" + result.toString(), R.color.task_color_4);
                            }
                        })
                        .setGroupStrategy(GroupTaskStrategy.ALL_COMPLETE)
                        .addGroupTask(mGroupTask1)
                        .setResultTag(1)
                        .addGroupTask(mGroupTask2)
                        .setResultTag(2)
                        .addGroupTask(mGroupTask3)
                        .setResultTag(3)
                        .build());
复制代码

GroupResultTask是用来监控任务组执行结果的，每一个任务执行完毕后会回调一次oneTaskComplete，全部任务执行完毕后会回调一次allTaskComplete，两个方法的参数列表返回了单个任务执行的数据结果，经过配置的tag进行判断，固然若是你不关心执行结果数据则能够没必要调用setResultTag给每一个任务设置tag。
任务组的执行模式有三种，经过setGroupStrategy方法进行设置（使用默认模式能够不调用这个方法）：post

/** * 默认模式 * 所有完成模式，所有任务执行完毕后 * 回调结果 * 使用此模式，若是组任务配置了失败 * 重试，则最终回调会等待组任务重试成功 * 组任务配置了任务重试会阻塞结果回调时机 */
    public static final int ALL_COMPLETE = 0;
    /** * 错误退出模式 * 一个组任务发生错误则暂停其余任务 * 并再也不继续 */
    public static final int ERROR_EXIT = 1;
    /** * 错误忽略模式 * 一个任务发生的错误将会被忽略 * 其余任务正常执行，并待其余任务执行后 * 继续后续任务，使用此模式会忽略任务重试功能 * 组任务配置了任务重试不会阻塞结果回调时机 */
    public static final int ERROR_IGNORE = 2;
复制代码

须要注意的是ALL_COMPLETE和ERROR_IGNORE的阻塞区别，主要来源于子任务的重试策略对他们产生的不一样影响。

若是你的任务组中，有一个是必要的（必须完成，不完成会影响后续逻辑），其余是非必要的（顺便执行的任务，不关心是否成功），该怎么办？
不用担忧，RxTask能够在组策略下配置单个任务的策略，好比下面的示例，任务1和3为非核心逻辑，2为核心逻辑，那么只须要以下配置便可保证任务1和3失败后对最后的任务组完成回调不产生影响。
ui

RxExecutor.getInstance()
                .executeTaskGroup(GroupTaskBuilder.create()
                        .setResultTask(new GroupResultTask() {

                            @Override
                            public void oneTaskComplete (Object tag, Object result) {
                                result("任务" + tag.toString() + "执行结束，数据为：" + result, R.color.task_color_4);
                            }

                            @Override
                            public void allTaskComplete (HashMap<Object, Object> resultMap) {
                                StringBuilder result = new StringBuilder();
                                for (Object o : resultMap.keySet()) {
                                    result.append(o.toString());
                                    result.append(":");
                                    result.append("" + resultMap.get(o));
                                }
                                result("组任务所有完毕，数据为：" + result.toString(), R.color.task_color_4);
                            }
                        })
                        .setGroupStrategy(GroupTaskStrategy.ALL_COMPLETE)
                        //非核心业务，能够容许失败
                        .addGroupTask(mGroupTask1)
                        .setStrategy(GroupTaskStrategy.ERROR_IGNORE)
                        .setResultTag(1)
                        //核心业务，必须成功才进行下一步
                        .addGroupTask(mGroupTask2)
                        .setResultTag(2)
                        //非核心业务，能够容许失败
                        .addGroupTask(mGroupTask3)
                        .setStrategy(GroupTaskStrategy.ERROR_IGNORE)
                        .setResultTag(3)
                        .build());
复制代码

使用单任务策略须要注意如下几点
首先，单任务的执行策略仅在任务组策略为GroupTaskStrategy.ALL_COMPLETE时才有效。
其次，任务组策略为GroupTaskStrategy.ALL_COMPLETE且没有配置单任务策略时，须要当心任务阻塞的处理，由于在此模式下，任何一个子任务执行失败都会形成你的后续逻辑执行不到，因此须要考虑每一个任务失败时的处理逻辑。子任务出错参考前面Task任务出错时的状况。
最后，在activity中使用任务组时请务必绑定生命周期，以避免出现内存泄漏问题。spa

场景9

多种类型数据结果

一个子线程任务过程当中可能产生不一样结果或者多个结果，那么能够采用下面的写法（注意使用 emitter.objNext发射数据，用onObjNext接收数据），此方法能够用来控制多种类型或者多个步骤的子线程任务，每种类型或者步骤识别使用code来进行线程

RxExecutor.getInstance()
                .executeTask(new Task<Object>() {
                    @Override
                    public void run (Emitter<Object> emitter) throws Exception {
                        super.run(emitter);
                        Thread.sleep(1000);
                        //执行结果数据类型1
                        emitter.objNext("数据1", 1);
                        Thread.sleep(1000);
                        //执行结果数据类型2
                        emitter.objNext(222, 2);
                        Thread.sleep(1000);
                        //执行结果数据类型3
                        emitter.objNext(new Bundle(), 3);
                    }

                    @Override
                    public void onObjNext (int code, Object obj) {
                        super.onObjNext(code, obj);
                        switch (code) {
                            case 1:
                                //处理数据类型1
                                break;
                            case 2:
                                //处理数据类型2
                                break;
                            case 3:
                                //处理数据类型3
                                break;
                            default:

                                break;

                        }
                    }
                });
复制代码

场景10

经常使用子任务封装

如下三种类型均支持绑定生命周期，绑定生命周期后，生命周期结束，将再也不回调

倒计时
RxExecutor.getInstance()
                .executeTask(new RxHelper.CountDownTask(60*1000,1000) {
                    @Override
                    public void count (long time) {
                        
                    }
                });
复制代码
延时任务
RxExecutor.getInstance()
                .executeTask(new RxHelper.DelayTask(60*1000) {

                    @Override
                    public void timeOver () {
                        
                    }
                });
复制代码
循环任务

-1表示无限循环

RxExecutor.getInstance()
                .executeTask(new RxHelper.RecycleTask(1000,-1) {
                    @Override
                    public void count (int count) {
                        
                    }
                });
复制代码
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程