Android项目之异步处理_AsyncTask

任务类：

public class MyAsyncTask<D> implements Callable<AsyncResult<D>> {
    private static SingleThreadPool singleThreadPool = new SingleThreadPool(60, TimeUnit.SECONDS, "SingleThreadPool",
            Thread.NORM_PRIORITY - 1);
    private static Handler handler = new Handler(Looper.getMainLooper());//主线程

    private AsyncResult<D> mResult = new AsyncResult<D>();//不同线程间切换时数据的载体

    /**
     * 开始执行任务
     */
    public Future<AsyncResult<D>> execute() {
        return execute(singleThreadPool);
    }

    /**
     * 开始执行任务
     */
    public Future<AsyncResult<D>> execute(SingleThreadPool executor) {
        return executor.submit(this);
    }

    /**
     * 开始执行任务
     */
    public Future<AsyncResult<D>> execute(ExecutorService executor) {
        return executor.submit(this);
    }

    public AsyncResult<D> call() throws Exception {
        runOnBackground(mResult);
        post();
        return mResult;
    }

    ;

    private void post() {
        handler.post(new Runnable() {
            @Override
            public void run() {
                runOnUIThread(mResult);
            }
        });
    }

    /**
     * 该函数在线程中执行
     */
    protected void runOnBackground(AsyncResult<D> asyncResult) {

    }

    /**
     * 该函数在UI线程中执行
     *
     * @param asyncResult {@link #runOnBackground(AsyncResult<D>)}执行后返回的结果
     */
    protected void runOnUIThread(AsyncResult<D> asyncResult) {
    }

}

线程类：

public class SingleThreadPool implements Executor {
    private ExecutorService mExecutor;

    /**
     * 单任务线程池，当线程空闲超过设定时间时会回收线程，有新的任务时再起
     *
     * @param keepAliveTime  允许线程最大空闲时间
     * @param timeUnit       线程空闲时间单位
     * @param threadName     线程池使用线程的名字，不可为空，可以为任意值，方便DDMS查看线程状态
     * @param threadPriority 线程优先级
     */
    public SingleThreadPool(int keepAliveTime, TimeUnit timeUnit, final String threadName, final int threadPriority) {
        ThreadFactory threadFactory = new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r, threadName);
                thread.setPriority(threadPriority);
                return thread;
            }
        };
        LinkedBlockingQueue<Runnable> linkedBlockingQueue = new LinkedBlockingQueue<>();
        mExecutor = new ThreadPoolExecutor(0, 1, keepAliveTime, timeUnit, linkedBlockingQueue, threadFactory);
    }

    /**
     * 单任务线程池，默认优先级为（Thread.NORM_PRIORITY - 1）。当线程空闲超过设定时间时会回收线程，有新的任务时再起
     *
     * @param keepAliveTime 允许线程最大空闲时间
     * @param timeUnit      线程空闲时间单位
     */
    public SingleThreadPool(int keepAliveTime, TimeUnit timeUnit) {
        this(keepAliveTime, timeUnit, "SingleThreadPool", Thread.NORM_PRIORITY - 1);
    }

    public SingleThreadPool() {
        this(60, TimeUnit.SECONDS);
    }

    /**
     * 填加任务到队列，如果线程池中没有线程，将创建新的线程来执行任务，先进先出执行任务
     */
    public void execute(@NonNull Runnable runnable) {
        mExecutor.execute(runnable);
    }

    public <V> Future<V> submit(Callable<V> task) {
        return mExecutor.submit(task);
    }
}