Android AsyncTask内部原理
@(Android)
[toc]
小笔记
基本使用
/**
* 在主线程中调用，可以做一些初始化的操作，但是不要在这里做耗时操作
*/
@Override
protected void onPreExecute() {
super.onPreExecute();
}
/**
* 在子线程中调用,耗时操作全部在这里完成。
* 如果需要更新进度可以调用 publishProgress(Progress... values)
*/
@Override
protected Object doInBackground(Object[] params) {
return null;
}
/**
* 在主线程中调用,显示子线程进度的回调函数
* @param values
*/
@Override
protected void onProgressUpdate(Object[] values) {
super.onProgressUpdate(values);
}
/**
* 在主线程中调用，传入的传输是在doInBackground中返回的值
* @param o
*/
@Override
protected void onPostExecute(Object o) {
super.onPostExecute(o);
}
/**
* AsyncTask被取消的时候会回调
* 参数是从哪里传过来的呢。后面有解释
*/
@Override
protected void onCancelled(Object o) {
super.onCancelled(o);
System.out.println(o instanceof Bitmap);
if (o instanceof Bitmap) {
image_view.setImageBitmap((Bitmap) o);
}
}
/**
* AsyncTask被取消的时候会回调
*/
@Override
protected void onCancelled() {
super.onCancelled();
System.out.println("MyAsyncTask ========== onCancelled");
}
了解了基本的使用方法之后，简单的实现一个加载图片的方法吧
package com.example.wen.asynctask;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.AsyncTask;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.widget.ImageView;
import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
public class MainActivity extends AppCompatActivity {
private ImageView image_view;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
image_view = (ImageView) findViewById(R.id.image_view);
new MyAsyncTask().execute();
}
class MyAsyncTask extends AsyncTask {
/**
* 在主线程中调用，可以做一些初始化的操作，但是不要在这里做耗时操作
*/
@Override
protected void onPreExecute() {
super.onPreExecute();
}
/**
* 在子线程中调用,耗时操作全部在这里完成。
* 如果需要更新进度可以调用 publishProgress(Progress... values)
*/
@Override
protected Object doInBackground(Object[] params) {
Bitmap bitmap = null;
try {
URL url = new URL("https://www.baidu.com/img/bd_logo1.png");
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
bitmap = BitmapFactory.decodeStream(connection.getInputStream());
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return bitmap;
}
/**
* 在主线程中调用，传入的传输是在doInBackground中返回的值
* @param o
*/
@Override
protected void onPostExecute(Object o) {
super.onPostExecute(o);
if (o instanceof Bitmap) {
image_view.setImageBitmap((Bitmap) o);
}
}
/**
* 在主线程中调用,显示子线程进度的回调函数
* @param values
*/
@Override
protected void onProgressUpdate(Object[] values) {
super.onProgressUpdate(values);
}
/**
* AsyncTask被取消的时候会回调
*/
@Override
protected void onCancelled(Object o) {
super.onCancelled(o);
System.out.println(o instanceof Bitmap);
if (o instanceof Bitmap) {
image_view.setImageBitmap((Bitmap) o);
}
}
/**
* AsyncTask被取消的时候会回调
*/
@Override
protected void onCancelled() {
super.onCancelled();
System.out.println("MyAsyncTask ========== onCancelled");
}
}
}
内部实现原理
- 在主线程中调用
execute(Params... params)方法或者是指定的线程池的executeOnExecutor(Executor exec,Params... params)
@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
@MainThread
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;
}
从上面的代码中看到两点：
-
onPreExecute()方法在主线程中调用的 - 另外，在执行
exec.execute(mFuture);的时候，会先判断mStatus的状态。所以每一个AsyncTask对象都只能调用execute()方法一次。看一下mStatues的定义：
private volatile Status mStatus = Status.PENDING;
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是用volatile关键字修饰的。volatile的作用是保证操作的可见性，即修改之后其他能马上读取修改后的值。详情看Java 并发编程。
那为什么需要用一个volatile关键字修饰呢。现在有这么一个场景，一个AsyncTask对象已经快执行完后台任务了，准备修改状态Statue.FINISH，但是这个时候，主线程保留了这个AsyncTask对象，并且调用了execute()方法，这个时候就会导致一个AsyncTask被调用了两次。
而一个AsyncTask不允许执行两次的原因是考虑到了线程安全的问题，如果一个对象被执行了两次，那么就需要考虑自己定义的成员变量的线程安全的问题了。所以直接在new一个出来比执行两次的方式更加方便。
当判断是第一次调用的时候，后面就会调用到exec.execute(mFuture);方法。线程池中的exec.execute()需要一个Runnable的对象，所以让我们看看mFuture的定义吧：
private final FutureTask<Result> mFuture;
我们发现他是一个FutureTask对象。FutrueTask对象需要实现一个方法：
/**
* Protected method invoked when this task transitions to state
* {@code isDone} (whether normally or via cancellation). The
* default implementation does nothing. Subclasses may override
* this method to invoke completion callbacks or perform
* bookkeeping. Note that you can query status inside the
* implementation of this method to determine whether this task
* has been cancelled.
*/
protected void done() { }
并且在FutureTask的构造方法中，需要传一个Callable对象，那么Callable又是一个什么东西呢。简单来说，Callable是一个有返回值的Runnable。所以FutureTask在后台运行的代码就是Callable中的call()的方法。具体来看看在AsyncTask源码中是怎么实现的：
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
Result result = doInBackground(mParams);
Binder.flushPendingCommands();
return postResult(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是一个实现了Callable的类，并且用一个变量保存了在执行AsyncTask时传入的参数
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
Params[] mParams;
}
上面的代码的大概意思就是在一个子线程中调用了我们实现的doInBackground()方法。在FutureTask中的done()方法中有一个get()方法，作用就是获取doInBackground()返回的数据。然后将返回的数据传到postResult方法中：
private Result postResult(Result result) {
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
在这里可以看到AsyncTask的内部是通过Handler来实现的。这里还有一个AsyncTaskResult：
private static class AsyncTaskResult<Data> {
final AsyncTask mTask;
final Data[] mData;
AsyncTaskResult(AsyncTask task, Data... data) {
mTask = task;
mData = data;
}
}
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
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;
}
}
}
因为在finish()方法中需要判断Task是否被取消，而Status是对象内部的成员变量，所以需要保留一个AsyncTask对象和在子线程中返回的数据。
当执行完finish()方法之后，基本AsyncTask的内部原理都讲完了。耶！！
