Android 异步任务队列实现

前段时间看过一篇文章，里面初略提到异步任务链式调用。

异步任务有AsyncTask，和Handler + Thread等等多种实现，链式调用如RxJava等。

于是一时心急如焚，弄了个简单的，给后来人提供思路：

想在activity中这么写代码：

new TaskManager()
.next(runnable)
.next(runnable,CHILD_THREAD)
.next(runnable,MAIN_THREAD)
.execute();

这么来看，TaskManager类中需要有next方法，调用后还需返回当前对象：

/**
     * add runnable, default run in child thread
     *
     * @param task
     * @return
     */
    public TaskManager next(Runnable task) {
        return next(task, ThreadType.CHILD_THREAD);
    }

    public TaskManager next(Runnable task, ThreadType type) {
        Message message = new Message();
        message.task = task;
        message.type = type;
        queue.add(message);
        return this;
    }

得有消息队列，线程池来创建任务线程，主线程任务就由handler来执行

    //异步任务队列
    private LinkedList<Message> queue;
    private Handler handler;

    private boolean isStop;//是否停止

    private ExecutorService pool;

构造函数中需要初始化这些对象：

public TaskManager() {
        handler = new Handler(Looper.getMainLooper());
        queue = new LinkedList<Message>();
        pool = Executors.newSingleThreadExecutor();
    }

调用execute执行方法时，循环获取消息队列中的任务，根据其类型决定是用子线程执行还是handler执行：

/**
     * execute all runnable
     */
    public void execute() {
        if(isInvalid){
        	throw new IllegalStateException("This object cannot repeated use,please renew");
        }
        isInvalid = true;//标记用过了
        while (!isStop) {
            Message message = queue.pollFirst();
            if (message == null)//返回null，消息队列为null了，结束循环
                break;
            if (message.type == ThreadType.CHILD_THREAD)
                pool.execute(message.task);
            else
                handler.post(message.task);
        }
        clear();
    }

以上就是大概思路。下面贴出完成代码：

调用处：

new TaskManager().next(new Runnable() {
            @Override
            public void run() {
                Log.v("消息A",Thread.currentThread().getName());
            }
        }).next(new Runnable() {
            @Override
            public void run() {
                Log.v("消息B",Thread.currentThread().getName());
            }
        }).next(new Runnable() {
            @Override
            public void run() {
                Log.v("消息C",Thread.currentThread().getName());
            }
        }, TaskManager.ThreadType.MAIN_THREAD)
	.execute();

TaskManager类完整代码：

/**
 * @DateTime: 2016-07-13 14:10
 * @Author: duke
 * @Deacription: 异步任务链
 */
public class TaskManager {
    //异步任务队列
    private LinkedList<Message> queue;
    private Handler handler;

    private boolean isStop;//是否停止

    private ExecutorService pool;

    private boolean isInvalid = false;//是否无效，标记当前实例只能用一次

    public TaskManager() {
        handler = new Handler(Looper.getMainLooper());
        queue = new LinkedList<Message>();
        pool = Executors.newSingleThreadExecutor();
    }

    /**
     * add runnable, default run in child thread
     *
     * @param task
     * @return
     */
    public TaskManager next(Runnable task) {
        return next(task, ThreadType.CHILD_THREAD);
    }

    public TaskManager next(Runnable task, ThreadType type) {
        Message message = new Message();
        message.task = task;
        message.type = type;
        queue.add(message);
        return this;
    }

    /**
     * execute all runnable
     */
    public void execute() {
        if(isInvalid){
        	throw new IllegalStateException("This object cannot repeated use,please renew");
        }
        isInvalid = true;//标记用过了
        while (!isStop) {
            Message message = queue.pollFirst();
            if (message == null)//返回null，消息队列为null了，结束循环
                break;
            if (message.type == ThreadType.CHILD_THREAD)
                pool.execute(message.task);
            else
                handler.post(message.task);
        }
        clear();
    }

    /**
     * stop task
     */
    public void clear() {
        isStop = true;
        pool.shutdownNow();
        pool = null;
        handler.removeCallbacksAndMessages(null);
        handler = null;
    }

    public static enum ThreadType {
        CHILD_THREAD, MAIN_THREAD
    }

    public class Message {
        Runnable task;
        ThreadType type;
    }
}