AsyncTask简介
1. AsyncTask提供了一种恰当的简单的跟UI Thread交互的方式。2. 它不需要通过操控Threads或Handler就可以将后台操作以及其结果展示在UI Thread上。
3. AsyncTask是围绕Thread和Handler被设计出的一个Helper类，它不构成一般的线程框架。
4. AsyncTasks使用在短时间操作(最多几秒钟)上是非常理想的。
5. 如果你需要保持一个长时间操作，强烈建议还是使用java.util.concurrent包中的类，比如Executor、ThreadPollExecutor和FutureTask。
如何定义一个Asynchronous Task
1. 需要在后台进行计算2. 结果要被public到UI Thread上。
定义Asynchronous Task的三个元素
1. Params 参数2. Progress 进度
3. Result 结果
定义Asynchronous Task的4个步骤
1. onPreExecute2. doInBackground
3. onProgressUpdate
4. onPostExecute
范例
1. 类的实现
private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {
protected Long doInBackground(URL... urls) {
int count = urls.length;
long totalSize = 0;
for (int i = 0; i < count; i++) {
totalSize += Downloader.downloadFile(urls[i]);
publishProgress((int) ((i / (float) count) * 100));
// Escape early if cancel() is called
if (isCancelled()) break;
}
return totalSize;
}
protected void onProgressUpdate(Integer... progress) {
setProgressPercent(progress[0]);
}
protected void onPostExecute(Long result) {
showDialog("Downloaded " + result + " bytes");
}
}2. 执行
new DownloadFilesTask().execute(url1, url2, url3);3. 取消Task
Async Task可以通过cancel(boolean)在任何时间cancel.在cancel之后，isCancelled()返回的函数会变成true。在cancel函数被调用后，onCancelled(Object)会替代onPostExecute(Object)在doInBackground(Object[])之后被调用，
注.如果要尽快确定task被cancelled,要周期性的不断在doInBackground(Object[])检查isCancelled(),
可以在里头内置一个 循环，不断的查询。
4. 使用规则
1. AsyncTask类必须在UI线程中被实例化。2. AsyncTask必须在UI线程中被创建。
3. execute(Params...) 必须在UI线程中被调用
4. 不要手动的调用onPreExecute(), onPostExecute(Result)，doInBackground(Params...), onProgressUpdate(Progress...)这几个方法；
5. task只能被执行一次，否则多次调用时将会出现异常；
Memory可观察性
AsynTask保证所有回调调用不用加synchronized也是线程安全的。1. Set member fields in the constructor or onPreExecute(), and refer to them in doInBackground(Params...).
2. Set member fields in doInBackground(Params...), and refer to them in onProgressUpdate(Progress...) and onPostExecute(Result).
顺序执行，演变史
1. 在刚被Google引入使用时，AsyncTasks会被线性的在单一线程里头执行。2. 从Android 2.0DONUT开始, AsyncTasks改进到在线程池中，并允许多线程并发执行
3. 从Andriod 3.0HONEYCOMB开始, tasks在单一线程中执行以避免因并发Exception导致一般的应用错误
4. 如果你一定要并发执行，可以通过executeOnExecutor(java.util.concurrent.Executor, Object[])函数，在THREAD_POOL_EXECUTOR中执行(线程池).
源码解析
1. 先说下有几个需要实现的
protected abstract Result doInBackground(Params... params);
protected void onPreExecute() {
}
@SuppressWarnings({"UnusedDeclaration"})
protected void onPostExecute(Result result) {
}
@SuppressWarnings({"UnusedDeclaration"})
protected void onProgressUpdate(Progress... values) {
}2. 先看结构体
public AsyncTask() {
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
return postResult(doInBackground(mParams));
}
};
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 occured while executing doInBackground()",
e.getCause());
} catch (CancellationException e) {
postResultIfNotInvoked(null);
}
}
};
}3. 再看如何execute
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
public static void execute(Runnable runnable) {
sDefaultExecutor.execute(runnable);
}直接运行runnable，mDefaultExecutor也会直接执行一个runnable。
看下sDefaultExecutor
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR; /**
* An {@link Executor} that executes tasks one at a time in serial
* order. This serialization is global to a particular process.
*/
public static final Executor SERIAL_EXECUTOR = new SerialExecutor(); 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);
}
}
} private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
private static final int KEEP_ALIVE = 1;
/**
* An {@link Executor} that can be used to execute tasks in parallel.
*/
public static final Executor THREAD_POOL_EXECUTOR
= new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);这里的配置方案倒是挺符合惯例的。要注意之类KEEP_ALIVE = 1.单线程运行。
sDefaultExecutor是个线性Executor。先将Task加载进ArrayDeque，再一个个poll出来，用THREAD_POOL_EXECUTOR执行。
4. 回到之前的execute流程。看executeOnExecutor
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;
}mStatus有三个状态
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,
}设置好mStatus的状态之后，会调用abstract onPreExecute().并调整mWorker的mParams；然后才在executor中执行mFuture，开始真正的运算。
5. 回头再看下mWorker的实例化
在executor调用execute(mFuture)之后，就会调用。doInBackground protected abstract Result doInBackground(Params... params);6. 那publishProgress什么时候调用呢？
在doInBackground的函数实现的时候，可以调用publishProgress及时更新状态。progress的进度需要手动实现。protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}
private static class InternalHandler extends Handler {
...
@Override
public void handleMessage(Message msg) {
AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
switch (msg.what) {
....
case MESSAGE_POST_PROGRESS:
result.mTask.onProgressUpdate(result.mData);
break;
}
}
}7. 再看mWorker的实例化。在doInBackground完成之后，会postResult
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
@SuppressWarnings({"RawUseOfParameterizedType"})
private static class AsyncTaskResult<Data> {
final AsyncTask mTask;
final Data[] mData;
AsyncTaskResult(AsyncTask task, Data... data) {
mTask = task;
mData = data;
}
}
private static class InternalHandler extends Handler {
...
@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;
....
}
}
} private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}小结，至此AsyncTask的execute流程就完结。
8. 中止Task
public final boolean cancel(boolean mayInterruptIfRunning) {
mCancelled.set(true);
return mFuture.cancel(mayInterruptIfRunning);
}继续跟，看下mCancelled是如何使用的？
public final boolean isCancelled() {
return mCancelled.get();
} protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
} private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}按照finish的逻辑，onCancelled就会被顺利调用
至此，cancel的流程就完成。
结束
AsyncTask，其实就是个利用ThreadPoolExecutor。Future。Handler实现的可以更新。在5个使用规则的前提下，AsyncTask就可以顺利更新UI。
换言之,AsyncTask如果你不用View的更新.理论上是可以在分线程上用.可以从中了解AsyncTask的设计理念.
755
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
