首页手记 Android Priority Job...

Android Priority Job Queue：一个专门为Android轻松调度任务的工作队列

标签：

Android

在android中使用多线程已经是不可或缺的逻辑了，当然你可以直接使用子线程或线程子，在这里介绍的是一个专门为Android轻松调度任务的工作队列——Android Priority Job Queue

引入Android Priority Job Queue

compile 'com.birbit:android-priority-jobqueue:2.0.1'

Android Priority Job Queue官方地址：https://github.com/yigit/android-priority-jobqueue

配置JobManager

package tsou.com.simple.jobqueuetest;

import android.app.Application;
import android.util.Log;

import com.birbit.android.jobqueue.JobManager;
import com.birbit.android.jobqueue.config.Configuration;
import com.birbit.android.jobqueue.log.CustomLogger;

/**
 * Created by Administrator on 2017/12/26 0026.
 */

public class MyApplication extends Application {
    private static MyApplication instance;
    private JobManager jobManager;

    @Override
    public void onCreate() {
        super.onCreate();
        instance = this;
        // 配置JobMananger
        configureJobManager();
    }

    public static MyApplication getInstance() {
        return instance;
    }

    public JobManager getJobManager() {
        return jobManager;
    }

    /**
     * 配置JobMananger
     */
    private void configureJobManager() {
        Configuration configuration = new Configuration.Builder(this)
                //日志设置，便于用户查看任务队列的工作信息
                .customLogger(new CustomLogger() {
                    @Override
                    public boolean isDebugEnabled() {
                        return true;
                    }

                    @Override
                    public void d(String text, Object... args) {
                        Log.d("huangxiaoguo", String.format(text, args));
                    }

                    @Override
                    public void e(Throwable t, String text, Object... args) {
                        Log.e("huangxiaoguo", String.format(text, args));
                    }

                    @Override
                    public void e(String text, Object... args) {
                        Log.e("huangxiaoguo", String.format(text, args));
                    }

                    @Override
                    public void v(String text, Object... args) {
                        Log.v("huangxiaoguo", String.format(text, args));
                    }
                })
                //最少开启的线程
                .minConsumerCount(3)
                //最多开启的线程
                .maxConsumerCount(3)
                //一个Thread设置多3个任务
                .loadFactor(3)
                //设置线程在没有任务的情况下保持存活的时长，以秒为单位
                .consumerKeepAlive(120)
                .build();

        jobManager = new JobManager(configuration);
    }

}

创建Job任务

package tsou.com.simple.jobqueuetest.job;

import android.os.SystemClock;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.util.Log;

import com.birbit.android.jobqueue.Job;
import com.birbit.android.jobqueue.Params;
import com.birbit.android.jobqueue.RetryConstraint;

/**
 * Created by Administrator on 2017/12/26 0026.
 */

public class MyJob extends Job {
    private String mPriorty;

    public MyJob(String priority) {
        /**
         * 默认构造器传入的是int(priority)参数是该任务的优先级，优先级越高，越优先执行。
         *<p>
         * requireNetwork(): 设置该任务要求访问网络；
         *<p>
         * groupBy(String groupId)：设置组ID，被设置相同组ID的任务，将会按照顺序执行；
         *<p>
         * persist()：设置任务为可持久化的，持久化要求Job类为序列化的，这一点并不意外，
         * 因为一个类的内容只有序列化之后才能变成字节模式保存在硬盘上；
         * <p>
         *delayInMs(long delayMs)：设置延迟时间，ms为单位，在该时间之后再放入任务队列中。
         * <p>
         * addTags :添加标记取消任务时使用
         */
        super(new Params(Integer.parseInt(priority))
                .requireNetwork()
                .persist()
                .addTags("huangxiaoguo"));
        this.mPriorty = priority;
        Log.e("huangxiaoguo", mPriorty + "初始化");
    }

    @Override
    public void onAdded() {
        //任务加入队列并被保存在硬盘上，定义此时要处理的逻辑；
        Log.e("huangxiaoguo", mPriorty + "====>onAdded==任务加入队列");
    }

    @Override
    public void onRun() throws Throwable {
        //任务开始执执行，在此定义任务的主题逻辑，当执行完毕后，任务将被从任务队列中删除；
        Log.e("huangxiaoguo", mPriorty + "====>onRun==任务开始执行");
        SystemClock.sleep(15000);
    }

    @Override
    protected void onCancel(int cancelReason, @Nullable Throwable throwable) {
        //任务取消的时候要执行的逻辑；
        Log.e("huangxiaoguo", mPriorty + "====>onCancel==任务取消");
    }

    @Override
    protected RetryConstraint shouldReRunOnThrowable(@NonNull Throwable throwable, int runCount, int maxRunCount) {
        /**
         * 当onRun()方法中抛出异常时，就会调用该函数，
         *该函数返回Job类在执行发生异常时的应对策略，
         *是重新执行还是取消，或者是一定时间之后再尝试。
         */

        //RetryConstraint的自带策略，立刻重新尝试执行策略，
        // 直到执行成功或者尝试次数达到最大（18次）；
        // return RetryConstraint.RETRY;

        //RetryConstraint的自带策略，取消当前任务的执行；
        //return RetryConstraint.CANCEL;

        //定期延迟尝试执行任务，如果任务执行失败，
        // 下次执行的延迟时间会以指数形式增长,最大尝试次数为20次；
        return RetryConstraint.createExponentialBackoff(runCount, 10);
    }
}

开始执行队列

    private void initData() {
        jobManager = MyApplication.getInstance().getJobManager();
    }

    for (int i = 0; i < 9; i++) {
            jobManager.addJobInBackground(new MyJob(String.valueOf(i)));
         }

开始任务（一般在执行暂停任务后）

    jobManager.start();

暂停任务（一般在onStop方法中）

    jobManager.stop();

取消任务（一般在onDestroy中）

                    /**
                 * 取消任务时必须要指明tag，不然无效。当然这个tags可以多个
                 */
                jobManager.cancelJobsInBackground(null, TagConstraint.ANY, "huangxiaoguo");

清除任务队列（一般在onDestroy方法中）

                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        jobManager.clear();
                        jobManager.destroy();
                    }
                }).start();