AsyncTask是android提供的轻量级的异步类,可以直接继承AsyncTask类,在类中实现异步操作,并提供接口反馈当前异步执行的程度(可以通过接口实现UI进度更新),最后反馈执行的结果给UI主线程，且其是串行执行的，下面从源码上分析他是如何做的
class DownloadTask extends AsyncTask<Integer, Void, String> {
@Override
//后台任务执行前准备工作，主线程中
protected void onPreExecute() {
super.onPreExecute();
}
@Override
//后台任务
protected String doInBackground(Integer... params) {
return null;
}
@Override
//更新进度，主线程中
protected void onProgressUpdate(Void... values) {
super.onProgressUpdate(values);
}
@Override
//返回执行结果，主线程中
protected void onPostExecute(String s) {
super.onPostExecute(s);
}
}
new DownloadTask().execute(3);
new DownloadTask().execute(4);以上是AsyncTask的基本使用方法，首先新建一个继承自AsyncTask的类，其中三个参数Integer, Void, String分别代表传进的参数，更新进度的参数以及返回给你的参数，之后就可以新建对象并调用execute方法，不过请注意，一个AsyncTask对象只能调用一次execute方法，否则会报错，下面我们看看execute做了什么
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Params... params) {
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();
mWorker.mParams = params;
exec.execute(mFuture);
return this;
}最终会调用executeOnExecutor方法，我们可以看到调用了该方法后，mStatus 会变成Status.RUNNING，而在Status.RUNNING的状态下如果再次调用该方法则会抛出异常，这解释了为什么对象只能调用一次execute方法
接着看主要流程，onPreExecute，后台操作之前的准备工作，在主线程中执行，很清晰，那么很明显关键代码就在下面两行
mWorker.mParams = params;
exec.execute(mFuture);三个变量mWorker，mFuture和exec，我们来看看都是什么玩意
mWorker，mFuture都在AsyncTask的构造方法中定义
public AsyncTask() {
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Result result = null;
try {
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
result = doInBackground(mParams);
Binder.flushPendingCommands();
} catch (Throwable tr) {
mCancelled.set(true);
throw tr;
} finally {
postResult(result);
}
return result;
}
};
mFuture = new FutureTask<Result>(mWorker) {
@Override
protected void done() {
try {
postResultIfNotInvoked(get());
} catch (InterruptedException e) {
android.util.Log.w(LOG_TAG, e);
} catch (ExecutionException e) {
throw new RuntimeException("An error occurred while executing doInBackground()",
e.getCause());
} catch (CancellationException e) {
postResultIfNotInvoked(null);
}
}
};
}mWorker中就是定义了一个call方法，不过仔细看看里面有我们熟悉的方法doInBackground,而参数就是我们执行的传递的参数，所以后台执行的代码应该就是在这里被调用
而mWorker又是mFuture构造函数的参数，首先明确下mFuture是一个Runnable，接着看mFuture的构造函数
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW; // ensure visibility of callable
}没什么，就是简单的赋值，而Runnable肯定是要看看他的run方法
public void run() {
if (state != NEW ||
!U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
result = c.call();
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
setException(ex);
}
if (ran)
set(result);
}
}
......
}callable就是我们的mWorker，他在这里被调用了call方法，所以我们的doInBackground方法被放在了一个Runnable的run方法中
mWorker最后还有一个方法为postResult(result)，result就是doInBackground返回的结果
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}利用Handler发送消息至主线程，我们看看Handler
private static class InternalHandler extends Handler {
public InternalHandler() {
super(Looper.getMainLooper());
}
@SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
@Override
public void handleMessage(Message msg) {
AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
switch (msg.what) {
case MESSAGE_POST_RESULT:
// There is only one result
result.mTask.finish(result.mData[0]);
break;
case MESSAGE_POST_PROGRESS:
result.mTask.onProgressUpdate(result.mData);
break;
}
}
}可以看到接收到消息后，AsyncTask会调用finish方法
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}如果任务没有被取消，则会回调onPostExecute方法
之前重写的四个方法还少了一个，也就是onProgressUpdate，如果需要使用的话，我们需要在doInBackground方法中调用publishProgress（Progress）方法
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}可以看到他也是通过Handler实现消息传递
通过上面我们可以知道，如果要执行任务的话可以直接开个线程，把mFuture当做参数传进去就完事了，但是这样的话任务就不会是串行执行的，而且每次执行一个任务都要新开线程也明显浪费资源，我们看看AsyncTask是如何处理的
这需要我们来分析最后一个变量exec
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();他是一个静态变量，意味着所有AsyncTask对象共享同一个，他还是一个线程池，来看具体实现
private static class SerialExecutor implements Executor {
final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
Runnable mActive;
public synchronized void execute(final Runnable r) {
mTasks.offer(new Runnable() {
public void run() {
try {
r.run();
} finally {
scheduleNext();
}
}
});
if (mActive == null) {
scheduleNext();
}
}
protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}首先声明下，那个final Runnable r就是我们的mFuture
可以看到新建了一个Runnable对象，然后把这个对象放进了队列中，这个Runnable对象的run方法干了两件事
r.run()：就是mFuture的run方法，包含具体的工作，也就是我们的后台任务，回调什么的
scheduleNext()：安排下一个任务
exec的具体逻辑是这样的，如果是首个任务，则先将任务封装并添加到队列中，接着判断mActive == null，很明显是true，所以会执行scheduleNext()方法，也就是会取出刚才添加进去的Runnable并执行；而此时再添加任务时，因为mActive 不为空，是正在执行的任务对象，所以只会将任务添加到队列中，不会调用scheduleNext()方法。等到正在执行的任务完成时，他会再次从队列中取任务并执行。这样子任务就按照顺序排队等待执行
最后让我们看看THREAD_POOL_EXECUTOR
/**
* An {@link Executor} that can be used to execute tasks in parallel.
*/
public static final Executor THREAD_POOL_EXECUTOR;
static {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
sPoolWorkQueue, sThreadFactory);
threadPoolExecutor.allowCoreThreadTimeOut(true);
THREAD_POOL_EXECUTOR = threadPoolExecutor;
}就是一个线程池，这个是真正干活的，我们的任务就是在这里执行的
总的说我们的AsyncTask类中有两个静态线程池变量，其中THREAD_POOL_EXECUTOR 是具体执行业务逻辑的，exec是用来对任务排队，让任务串行执行的
如果想让任务并行执行也简单，我们可以自己新建一个线程池对象，接着调用executeOnExecutor(Executor exec,
Params… params) 方法
int CPU_COUNT = Runtime.getRuntime().availableProcessors();
int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
int KEEP_ALIVE_SECONDS = 30;
BlockingQueue<Runnable> sPoolWorkQueue = new LinkedBlockingQueue<Runnable>(128);
ThreadFactory sThreadFactory = new ThreadFactory() {
private final AtomicInteger mCount = new AtomicInteger(1);
public Thread newThread(Runnable r) {
return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
}
};
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
sPoolWorkQueue, sThreadFactory);
new DownloadTask().executeOnExecutor(threadPoolExecutor, 2);
new DownloadTask().executeOnExecutor(threadPoolExecutor, 3);
new DownloadTask().executeOnExecutor(threadPoolExecutor, 4);这样AsyncTask就会用我们线程池并行执行任务，而不会使用他自身的两个线程池来工作
扫一扫
245
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
