android 自己实现 AsyncTask

自从Java 1.5开始，就提供了Callable和Future，通过它们可以在任务执行完毕之后得到任务执行结果

这里先介绍Callable,Future以及FutureTask的使用，因为AsyncTask里面需要使用FutureTask，这里给出一篇参考文章：Java并发编程：Callable、Future和FutureTask点击打开链接。

下面是我自己实现的，其中很多参考了 源码，主要实现了其主要逻辑，细节可以直接参考源码。其实现的核心是一个Handler主要是为了在UI线程中来执行onPostExecute(Result result)以及onProgressUpdate(Progress... progress)，一个Executor是用来执行WorkRunnable也就是在doInBackgroud(Param...
prarames)中执行的部分，而在doInBackground执行完之后，因为我们使用了FutureTask<Result>,因此可以通过重载其done()函数，该函数是在FutureTask执行完毕之后才会被调用，因此在其中可以通过mFutureTask.get()函数，获取该task执行的结果，也就是onPostExecute(Result result)需要的result，将其通过sendToTarget发送给Handler在UI线程中执行

package com.example.renlei.myapplication.handler;

import android.os.AsyncTask;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.support.annotation.MainThread;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.FutureTask;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
* Created by  renlei
* DATE: 16/7/29
* Time: 15:33
*/
public abstract class MyAsyncTask<Params, Progress, Result> {
/**
* 含有的成员变量
*/
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();//
private static final int CORE_COUNT = CPU_COUNT + 1;
private static final int MAX_COUNT = CPU_COUNT * 2 + 1;
private static final int POST_EXECUTE = 0x00001;
private static final int PUBLISH_PROGRSS = 0x00002;
private final WorkRunnable<Params, Result> mWork;
private final FutureTask<Result> mFutureTask;
private static final int KEEP_ALIVE = 1;
private static final BlockingQueue<Runnable> sPoolWorkQueue =
new LinkedBlockingQueue<Runnable>(128);

private static final ThreadFactory sThreadFactory = new ThreadFactory() {
private final AtomicInteger mCount = new AtomicInteger(1);

public Thread newThread(Runnable r) {
return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
}
};
private static final Executor mExecutor = new ThreadPoolExecutor(CORE_COUNT, MAX_COUNT, KEEP_ALIVE,
TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

private static InnerUIHandler mUIHandler;

private static Handler getHandler() {
synchronized (AsyncTask.class) {
if (mUIHandler == null) {
mUIHandler = new InnerUIHandler();
}
return mUIHandler;
}
}

/**
* 构造函数
*/
public MyAsyncTask() {

/**
* 构造函数中初始化
*/
mWork = new WorkRunnable<Params, Result>() {
@Override
public Result call() throws Exception {
Result result = doInBackground(paramses);
return result;
}
};
mFutureTask = new FutureTask<Result>(mWork) {
@Override
protected void done() {/// 线程执行完成之后会执行该函数
super.done();
try {
postResult(get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
};
}

/**
* 用来获取futuretask执行完成的结果
*
* @return
* @throws InterruptedException
* @throws ExecutionException
*/
public final Result get() throws InterruptedException, ExecutionException {
return mFutureTask.get();
}

private void postResult(Result result) {
getHandler().obtainMessage(POST_EXECUTE, new AsyncTaskResult<Result>(this, result)).sendToTarget();
}

/**
* 可以回调的一些函数
*/
@MainThread
protected void onPreExecute() {
}

protected abstract Result doInBackground(Params... params);

@MainThread
protected void onPostExecute(Result result) {
}

@MainThread
protected void onCancelled() {
}

@MainThread
protected void onProgressUpdate(Progress... progress) {
}

private static class InnerUIHandler extends Handler {

public InnerUIHandler() {
super(Looper.getMainLooper());//给handle一个Looper
}

@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what) {
case POST_EXECUTE:
AsyncTaskResult result = (AsyncTaskResult) msg.obj;
result.myAsyncTask.postResult(result.mData);
break;
case PUBLISH_PROGRSS:
AsyncTaskResult result2 = (AsyncTaskResult) msg.obj;
result2.myAsyncTask.onProgressUpdate(result2.mData);
break;
}

}
}

public final void publishProgress(Progress... progress) {
getHandler().obtainMessage(PUBLISH_PROGRSS,
new AsyncTaskResult<Progress>(this, progress)).sendToTarget();
}

/**
* Indicates the current status of the task. Each status will be set only once
* during the lifetime of a task.
*/
public enum Status {
/**
* Indicates that the task has not been executed yet.
*/
PENDING,
/**
* Indicates that the task is running.
*/
RUNNING,
/**
* Indicates that {@link AsyncTask#onPostExecute} has finished.
*/
FINISHED,
}

private volatile Status mStatus = Status.PENDING;

public final MyAsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(mExecutor, params);
}

public final MyAsyncTask<Params, Progress, Result> executeOnExecutor(Executor executor, Params... paramses) {
if (mStatus != Status.PENDING) {
switch (mStatus) {
case RUNNING:
throw new IllegalStateException("Cannot execute task:"
+ " the task is already running.");
case FINISHED:
throw new IllegalStateException("Cannot execute task:"
+ " the task has already been executed "
+ "(a task can be executed only once)");
}
}

mStatus = Status.RUNNING;
onPreExecute();
mWork.paramses = paramses;
executor.execute(mFutureTask);
return this;
}

private static abstract class WorkRunnable<Params, Result> implements Callable<Result> {
Params[] paramses;
}

private static class AsyncTaskResult<Data> {
MyAsyncTask myAsyncTask;
Data[] mData;

public AsyncTaskResult(MyAsyncTask myAsyncTask, Data... mData) {
this.myAsyncTask = myAsyncTask;
this.mData = mData;
}
}

}

另外推荐一篇写AsyncTask的文章 http://www.jianshu.com/p/dad0ecb5461e