AsyncTask
AsyncTask封装了线程池和Handler，它主要是为了方便开发者在子线程中更新UI。AsyncTask是一种轻量级的异步任务类，它可以在线程池中执行后台任务，然后把执行的进度和最终结果返回给主线程并在主线程中更新UI。
概述
AsyncTask是一个抽象的泛型类，提供了三个泛型参数Params、Progress和Result，他们的含义如下：
- Params：表示参数的类型，启动任务输入的参数，例如HTTP请求的URL
- Progress：表示后台任务的执行进度的类型，即后台任务执行的百分比
- Result ：后台执行任务最终返回的结果类型
AsyncTask的声明如下：
public abstract class AsyncTask<Params,Progress,Result>
AsyncTask还提供了四个核心方法需要我们重写：
- （1）onPreExecute(), 该方法在主线程中执行，将在execute(Params…
params)被调用后执行，一般用来做一些UI的准备工作，如在界面上显示一个进度条。 - （2）doInBackground(Params…params),
抽象方法，必须实现，该方法在线程池中执行，用于执行异步任务，将在onPreExecute方法执行后执行。其参数是一个可变类型，表示异步任务的输入参数，在该方法中还可通过publishProgress(Progress…
values)来更新实时的任务进度，而publishProgress方法则会调用onProgressUpdate方法。此外doInBackground方法会将计算的返回结果传递给onPostExecute方法。 - （3）onProgressUpdate(Progress…),在主线程中执行，该方法在publishProgress(Progress…
values)方法被调用后执行，一般用于更新UI进度，如更新进度条的当前进度。 - （4）onPostExecute(Result), 在主线程中执行，在doInBackground 执行完成后，onPostExecute
方法将被UI线程调用，doInBackground
方法的返回值将作为此方法的参数传递到UI线程中，并执行一些UI相关的操作，如更新UI视图。
上面这几个方法，onPreExecute先执行，接着是doInBackground，最后才是onPostExecute。此外AsyncTask还提供了onCancelled()方法，它同样在主线程中执行，当异步任务被取消时，onCancelled()方法会被调用，在这个时候onPostExecute则不会调用。
案例分析（案例引自坛友）
AsyncTask不需要传入具体参数，那么泛型参数可以用Void来代替，接下来我们可以自定义一个类继承自AsyncTask：
DownLoadAsyncTask.java
import android.content.Context;
import android.os.AsyncTask;
import android.os.Environment;
import android.os.PowerManager;
import android.widget.Toast;
import com.zejian.handlerlooper.util.LogUtils;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
/**
* Created by zejian
* Time 16/9/4.
* Description:
*/
public class DownLoadAsyncTask extends AsyncTask<String, Integer, String> {
private PowerManager.WakeLock mWakeLock;
private int ValueProgress=100;
private Context context;
public DownLoadAsyncTask(Context context){
this.context=context;
}
/**
* sync method which download file
* @param params
* @return
*/
@Override
protected String doInBackground(String... params) {
InputStream input = null;
OutputStream output = null;
HttpURLConnection connection = null;
try {
URL url = new URL(params[0]);
connection = (HttpURLConnection) url.openConnection();
connection.connect();
// expect HTTP 200 OK, so we don't mistakenly save error report
// instead of the file
if (connection.getResponseCode() != HttpURLConnection.HTTP_OK) {
return "Server returned HTTP " + connection.getResponseCode()
+ " " + connection.getResponseMessage();
}
// this will be useful to display download percentage
// might be -1: server did not report the length
int fileLength = connection.getContentLength();
// download the file
input = connection.getInputStream();
//create output
output = new FileOutputStream(getSDCardDir());
byte data[] = new byte[4096];
long total = 0;
int count;
while ((count = input.read(data)) != -1) {
// allow canceling with back button
if (isCancelled()) {
input.close();
return null;
}
total += count;
// publishing the progress....
if (fileLength > 0) // only if total length is known
publishProgress((int) (total * 100 / fileLength));
//
Thread.sleep(100);
output.write(data, 0, count);
}
} catch (Exception e) {
return e.toString();
} finally {
try {
if (output != null)
output.close();
if (input != null)
input.close();
} catch (IOException ignored) {
}
if (connection != null)
connection.disconnect();
}
return null;
}
@Override
protected void onPreExecute() {
super.onPreExecute();
// take CPU lock to prevent CPU from going off if the user
// presses the power button during download
PowerManager pm = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,
getClass().getName());
mWakeLock.acquire();
//Display progressBar
// progressBar.setVisibility(View.VISIBLE);
}
@Override
protected void onPostExecute(String values) {
super.onPostExecute(values);
mWakeLock.release();
if (values != null)
LogUtils.e("Download error: "+values);
else {
Toast.makeText(context, "File downloaded", Toast.LENGTH_SHORT).show();
}
}
/**
* set progressBar
* @param values
*/
@Override
protected void onProgressUpdate(Integer... values) {
super.onProgressUpdate(values);
// progressBar.setmProgress(values[0]);
//update progressBar
if(updateUI!=null){
updateUI.UpdateProgressBar(values[0]);
}
}
/**
* get SD card path
* @return
*/
public File getSDCardDir(){
if(Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())){
// 创建一个文件夹对象，赋值为外部存储器的目录
String dirName = Environment.getExternalStorageDirectory()+"/MyDownload/";
File f = new File(dirName);
if(!f.exists()){
f.mkdir();
}
File downloadFile=new File(f,"new.jpg");
return downloadFile;
}
else{
LogUtils.e("NO SD Card!");
return null;
}
}
public UpdateUI updateUI;
public interface UpdateUI{
void UpdateProgressBar(Integer values);
}
public void setUpdateUIInterface(UpdateUI updateUI){
this.updateUI=updateUI;
}
}简单说明一下代码，在onPreExecute方法中，可以做了一些准备工作，如显示进度圈，这里为了演示方便，进度圈在常态下就是显示的，同时，我们还锁定了CPU，防止下载中断，而在doInBackground方法中，通过HttpURLConnection对象去下载图片，然后再通过int fileLength =connection.getContentLength();代码获取整个下载图片的大小并使用publishProgress((int) (total * 100 / fileLength));更新进度，进而调用onProgressUpdate方法更新进度条。最后在onPostExecute方法中释放CPU锁，并通知是否下载成功。
接着看一下布局文件的实现：
activity_download.xml：
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:customView="http://schemas.android.com/apk/res-auto"
android:layout_width="match_parent"
android:layout_height="match_parent">
<com.zejian.handlerlooper.util.LoadProgressBarWithNum
android:id="@+id/progressbar"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
customView:progress_radius="100dp"
android:layout_centerInParent="true"
customView:progress_strokeWidth="40dp"
customView:progress_text_size="35sp"
customView:progress_text_visibility="visible"
customView:progress_value="0"
/>
<Button
android:id="@+id/downloadBtn"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="start download"
android:layout_centerHorizontal="true"
android:layout_below="@id/progressbar"
android:layout_marginTop="40dp"
/>
</RelativeLayout>我们也可以采用安卓系统自带的ProgressBar来实现~
最后就是Activity的实现了：
AsyncTaskActivity.java：
import android.Manifest;
import android.app.Activity;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.support.v4.app.ActivityCompat;
import android.support.v4.content.ContextCompat;
import android.view.View;
import android.widget.Button;
import com.zejian.handlerlooper.util.LoadProgressBarWithNum;
import com.zejian.handlerlooper.util.LogUtils;
/**
* Created by zejian
* Time 16/9/4.
* Description:AsynTaskActivity
*/
public class AsynTaskActivity extends Activity implements DownLoadAsyncTask.UpdateUI {
private static int WRITE_EXTERNAL_STORAGE_REQUEST_CODE=0x11;
private static String DOWNLOAD_FILE_JPG_URL="http://img2.3lian.com/2014/f6/173/d/51.jpg";
private LoadProgressBarWithNum progressBar;
private Button downloadBtn;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_download);
progressBar= (LoadProgressBarWithNum) findViewById(R.id.progressbar);
downloadBtn= (Button) findViewById(R.id.downloadBtn);
//create DownLoadAsyncTask
final DownLoadAsyncTask downLoadAsyncTask= new DownLoadAsyncTask(AsynTaskActivity.this);
//set Interface
downLoadAsyncTask.setUpdateUIInterface(this);
//start download
downloadBtn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
//execute
downLoadAsyncTask.execute(DOWNLOAD_FILE_JPG_URL);
}
});
//android 6.0 权限申请
if (ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)
!= PackageManager.PERMISSION_GRANTED) {
//android 6.0 API 必须申请WRITE_EXTERNAL_STORAGE权限
ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},
WRITE_EXTERNAL_STORAGE_REQUEST_CODE);
}
}
@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
doNext(requestCode,grantResults);
}
private void doNext(int requestCode, int[] grantResults) {
if (requestCode == WRITE_EXTERNAL_STORAGE_REQUEST_CODE) {
if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
// Permission Granted
LogUtils.e("Permission Granted");
} else {
// Permission Denied
LogUtils.e("Permission Denied");
}
}
}
/**
* update progressBar
* @param values
*/
@Override
public void UpdateProgressBar(Integer values) {
progressBar.setmProgress(values);;
}
}在AsynTaskActivity中实现了更新UI的接口DownLoadAsyncTask.UpdateUI，用于更新主线程的progressBar的进度，由于使用的测试版本是android6.0，涉及到外部SD卡读取权限的申请，所以在代码中对SD卡权限进行了特殊处理（这点不深究，不明白可以google一下），LoadProgressBarWithNum是一个自定义的进度条控件。ok~，最后看看我们的运行结果：
AsyncTask工作原理完全解析
从上面案例的”downLoadAsyncTask.execute(DOWNLOAD_FILE_JPG_URL);”开始，系统帮我们做了什么呢？从代码可以知道，入口是execute(Params… params)方法，我们可以通过查源码来一步步解析AsyncTask的工作原理.
@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}实际上是调用了executeOnExecutor(Executor exec, Params… params)，那么我们再来看看executeOnExecutor(Executor exec, Params… 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;
}Executor是执行者的意思，在传入该参数时，我们应该了解这个参数是怎么定义的：
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();
//串行线程池类，实现Executor接口
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() { //插入一个Runnble任务
public void run() {
try {
r.run();
} finally {
scheduleNext();
}
}
});
//判断是否有Runnable在执行,没有就调用scheduleNext方法
if (mActive == null) {
scheduleNext();
}
}
protected synchronized void scheduleNext() {
//从任务队列mTasks中取出任务并放到THREAD_POOL_EXECUTOR线程池中执行.
//由此也可见任务是串行进行的。
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
} 从源码可以看出，ArrayDeque是一个存放任务队列的容器（mTasks），任务Runnable传递进来后交给SerialExecutor的execute方法处理，SerialExecutor会把任务Runnable插入到任务队列mTasks尾部，接着会判断是否有Runnable在执行,没有就调用scheduleNext方法去执行下一个任务，接着交给THREAD_POOL_EXECUTOR线程池中执行，由此可见SerialExecutor并不是真正的线程执行者，它只是是保证传递进来的任务Runnable（实例是一个FutureTask）串行执行，而真正执行任务的是THREAD_POOL_EXECUTOR线程池，当然该逻辑也体现AsyncTask内部的任务是默认串行进行的。顺便看一下THREAD_POOL_EXECUTOR线程池的声明：
//CUP核数
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;
//非核心线程的存活时间1s
private static final int KEEP_ALIVE = 1;
//线程工厂类
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 BlockingQueue<Runnable> sPoolWorkQueue =
new LinkedBlockingQueue<Runnable>(128);
/**
* 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);executeOnExecutor(Executor exec, Params… params)这个方法做了什么呢？执行任务前先会去判断当前AsyncTask的状态，如果处于RUNNING和FINISHED状态就不可再执行，直接抛出异常，只有处于Status.PENDING时，AsyncTask才会去执行。然后onPreExecute()被执行的，该方法可以用于线程开始前做一些准备工作。接着会把我们传递进来的参数赋值给 mWorker.mParams ，并执行开始执行mFuture任务，那么mWorker和mFuture到底是什么？先看看mWorker即WorkerRunnable的声明源码：
//抽象类
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
Params[] mParams;
}WorkerRunnable抽象类实现了Callable接口，因此WorkerRunnable本质上也算一个Callable对象，其内部还封装了一个mParams的数组参数，因此我们在外部执行execute方法时传递的可变参数最终会赋值给WorkerRunnable的内部数组mParams，这些参数最后会传递给doInBackground方法处理，这时我们发现doInBackground方法也是在WorkerRunnable的call方法中被调用的，看看其源码如下：
public AsyncTask() {
//创建WorkerRunnable mWorker，本质上就是一个实现了Callable接口对象
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
//设置标志
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//执行doInBackground，并传递mParams参数
Result result = doInBackground(mParams);
Binder.flushPendingCommands();
//执行完成调用postResult方法更新结果
return postResult(result);
}
};
//把mWorker（即Callable实现类）封装成FutureTask实例
//最终执行结果也就封装在FutureTask中
mFuture = new FutureTask<Result>(mWorker) {
//任务执行完成后被调用
@Override
protected void done() {
try {
//如果还没更新结果通知就执行postResultIfNotInvoked
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);
}
}
};
}可以看到在初始化AsyncTask时，不仅创建了mWorker（本质实现了Callable接口的实例类）而且也创建了FutureTask对象，并把mWorker对象封装在FutureTask对象中，最后FutureTask对象将在executeOnExecutor方法中通过线程池去执行。给出下图协助理解：
FutrueTask是什么？来看一下它的定义：
public class FutureTask<V> implements RunnableFuture<V> {接着往下看：
public interface RunnableFuture<V> extends Runnable, Future<V> {
/**
* Sets this Future to the result of its computation
* unless it has been cancelled.
*/
void run();
}继续：
public interface Future<V> {
//取消任务
boolean cancel(boolean mayInterruptIfRunning);
//如果任务完成前被取消，则返回true。
boolean isCancelled();
//如果任务执行结束，无论是正常结束或是中途取消还是发生异常，都返回true。
boolean isDone();
//获取异步执行的结果，如果没有结果可用，此方法会阻塞直到异步计算完成。
V get() throws InterruptedException, ExecutionException;
// 获取异步执行结果，如果没有结果可用，此方法会阻塞，但是会有时间限制，
//如果阻塞时间超过设定的timeout时间，该方法将返回null。
V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
}再骚微分散一下，看看前面的WorkerRunnable对象作为FutureTask的参数传入，看看FutureTask的构造方法：
public FutureTask(Callable<V> callable) {
}
public FutureTask(Runnable runnable, V result) {
} 既然workerRunnable是个Callable接口，那么Callable接口又是什么呢？
public interface Callable<V> {
V call() throws Exception;
} 其实就是有返回值的Runnalbe接口而已。
好了，接下来往下看，AsynTask在初始化时会创建mWorker实例对象和FutureTask实例对象，mWorker是一个实现了Callable线程接口并封装了传递参数的实例对象，然后mWorker实例会被封装成FutureTask实例中。在AsynTask创建后，我们调用execute方法去执行异步线程，其内部又直接调用了executeOnExecutor方法，并传递了线程池exec对象和执行参数，该方法内部通过线程池exec对象去执行mFuture实例，这时mWorker内部的call方法将被执行并调用doInBackground方法，最终通过postResult去通知更新结果。关于postResult方法,其源码如下：
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}显然是通过Handler去执行结果更新的，在执行结果成返回后，会把result封装到一个AsyncTaskResult对象中，最后把MESSAGE_POST_RESULT标示和AsyncTaskResult存放到Message中并发送给Handler去处理，这里我们先看看AsyncTaskResult的源码：
private static class AsyncTaskResult<Data> {
final AsyncTask mTask;
final Data[] mData;
AsyncTaskResult(AsyncTask task, Data... data) {
mTask = task;
mData = data;
}
}显然AsyncTaskResult封装了执行结果的数组以及AsyncTask本身，这个没什么好说的，接着看看AsyncTaskResult被发送到handler后如何处理的:
private static class InternalHandler extends Handler {
public InternalHandler() {
//获取主线程的Looper传递给当前Handler，这也是为什么AsyncTask只能在主线程创建并执行的原因
super(Looper.getMainLooper());
}
@SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
@Override
public void handleMessage(Message msg) {
//获取AsyncTaskResult
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:
//执行onProgressUpdate方法，自己实现。
result.mTask.onProgressUpdate(result.mData);
break;
}
}
} 从Handler的源码分析可知，该handler绑定的线程为主线线程，这也就是为什么AsyncTask必须在主线程创建并执行的原因了。接着通过handler发送过来的不同标志去决定执行那种结果，如果标示为MESSAGE_POST_RESULT则执行AsyncTask的finish方法并传递执行结果给该方法，finish方法源码如下：
private void finish(Result result) {
if (isCancelled()) {//判断任务是否被取消
onCancelled(result);
} else {//执行onPostExecute(result)并传递result结果
onPostExecute(result);
}
//更改AsyncTask的状态为已完成
mStatus = Status.FINISHED;
}该方法先判断任务是否被取消，如果没有被取消则去执行onPostExecute(result)方法，外部通过onPostExecute方法去更新相关信息，如UI，消息通知等。最后更改AsyncTask的状态为已完成。到此AsyncTask的全部流程执行完。
这里还有另一种标志MESSAGE_POST_PROGRESS，该标志是我们在doInBackground方法中调用publishProgress方法时发出的，该方法原型如下：
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
//发送MESSAGE_POST_PROGRESS，通知更新进度条
getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
} ok~，AsyncTask的整体流程基本分析完，最后来个总结吧：当我们调用execute(Params… params)方法后，其内部直接调用executeOnExecutor方法，接着onPreExecute()被调用方法，执行异步任务的WorkerRunnable对象(实质为Callable对象)最终被封装成FutureTask实例，FutureTask实例将由线程池sExecutor执行去执行，这个过程中doInBackground(Params… params)将被调用（在WorkerRunnable对象的call方法中被调用），如果我们覆写的doInBackground(Params… params)方法中调用了publishProgress(Progress… values)方法，则通过InternalHandler实例sHandler发送一条MESSAGE_POST_PROGRESS消息，更新进度，sHandler处理消息时onProgressUpdate(Progress… values)方法将被调用；最后如果FutureTask任务执行成功并返回结果，则通过postResult方法发送一条MESSAGE_POST_RESULT的消息去执行AsyncTask的finish方法，在finish方法内部onPostExecute(Result result)方法被调用，在onPostExecute方法中我们可以更新UI或者释放资源等。这既是AsyncTask内部的工作流程，可以说是Callable+FutureTask+Executor+Handler内部封装。结尾我们献上一张执行流程，协助大家理解整个流程：
扫一扫
1301
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
