Android中可以扮演线程的角色还有很多，比如AsyncTask和IntentService，同时HandlerThread也是一种特殊的线程，尽管AsyncTask，IntentService以及HandlerThread的表现形式都有别于传统的线程，但是他们的本质仍然是传统的线程，对于AsyncTask来说，他的底层用到了线程池，对于IntentService和HandlerThread来说，他们的底层直接使用了线程

不同的形式的线程虽然都是线程，但是他们仍然具有不同的特性和使用场景。AsyncTask封装了线程池和Handler，他主要是为了方便开发者在子线程中更新UI。

HandlerThread是一种具有消息循环的线程，在他的内部可以使用Handler，IntantService是一个服务，系统对其惊醒了封装使其可以更方便的执行后台任务。IntentService内部采用了HandlerThread来执行任务，当任务执行完成之后，IntentService会自动退出。从任务执行的角度来看，IntentService的作用很像一个后台线程，但是INtentService是一种服务，他不容易被系统杀死，从而可以尽量保证任务的进行。而如果是一个后台线程，由于这个时候进程中没有活动的四大组件，那么这个进程的优先级就会非常低。会很容易被系统杀死，这就是IntentService的优点。

AsncTask:

为了简化在子线程中访问UI线程，系统提供了AsyncTask，AsyncTask经过几次修改，导致了对于不同的API版本AsyncTask具有不同的表现，尤其是在多任务的兵法执行上。 AsyncTask是一种轻量级的异步任务类，他可以在线程池中执行后台任务。并实时更新UI。从实现来说，AsyncTask封装了Thread和Handler，通过AsyncTask可以更加方便的执行后台任务以及在主线程中访问UI,但是AsyncTask并不适合做特别耗时的后台任务，对于特别耗时的任务，建议只用线程池。AsyncTask这个类的申明如下：

public abstract class AsyncTask<Params,Progress,Result>

AsyncTask提供了四个核心方法：
onPreExecute()，在主线程中执行，在异步任务执行之前，此方法会被调用，一般可以用于做一些准备工作。
doInBackground(Params...params),在线程池中执行，此方法用于执行异步任务，params参数表示异步任务的输入参数，在此方法中可以通过publishProgress方法来更新任务的进度，publishProgress方法会调用onProgressUpdate方法，另外此方法需要返回计算结果给onPostExecute方法。
onPostExecute（Result result）在主线程中执行，在异步任务执行之后，此方法会被调用，其中result参数是后台任务的返回值，即doInBackground的返回值。
除了上面四个方法，AsyncTask还提供了onCancelled()方法，他同样在主线程中执行，当异步任务被取消时，onCancelled()方法会被调用，这个时候onPostExecute则不会被调用。

package com.zxxthreadpool;import java.net.URL;import android.os.AsyncTask;public class DownloadFilesTask extends AsyncTask<URL, Integer, Long>{@Overrideprotected Long doInBackground(URL... urls) {// TODO Auto-generated method stubint count=urls.length;long totalSize=0;for(int i=0;i<count;i++){totalSize+=Downloader.downloadFile(urls[i]);publishProgress((int)((i/(float)count)*100));if(isCancelled())break;}return totalSize;return null;}@Overrideprotected void onProgressUpdate(Integer... progress) {// TODO Auto-generated method stubsuper.onProgressUpdate(progress);setProgressPercent(progress[0]);}@Overrideprotected void onPostExecute(Long result) {// TODO Auto-generated method stubsuper.onPostExecute(result);showDialog("Downloaded "+result+" bytes");}}

上面的代码实现了一耳光AsyncTask类，主要用于模拟文件下载过程，注意有一点，doInBackground和onProgressUpdate方法的参数中均包含...的字样，在java中...表示参数的数量补丁，他是一种数组型参数，...的概念和C语言中...的是一只的，当要执行上诉文件下载任务是，可以通过如下方式完成。

new DownloadFilesTask().execute(url1,url2,url3);

AsyncTask在具体使用的过程中也是有一些条件限制的，主要有以下几点:
AsyncTask的类必须在主线程中加载，这就意味着第一次访问AsyncTask必须发生在主线程，为什么要在主线程中加载，等下面在做分析
AsyncTask的对象必须在主线程中创建
execute方法必须在UI线程调用
不要再程序中直接调用onPostExecute，onProgressUpdate，doInBackground方法
一个AsyncTask对象只能执行一次，即只能调用一次execute方法，否则会报运行时异常
在Android1.6之前，AsyncTask是串行执行任务的，Android1.6的时候AsyncTask开始采用线程池里处理并执行任务，但是从Android3.0开始，为了避免AsyncTask所带来的并发错误，AsyncTask又采用了一个线程来串行执行任务，尽管如此，在3.0之后，我们仍可以通过AsyncTask的executeOnExecutor方法来并行的执行任务。

AsyncTask的工作原理：

为了分析AsyncTask的工作原理，我们从他的execute方法开始，execute方法又会调用executeOnExecutor方法：

public abstract class AsyncTask<Params, Progress, Result> {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 alread running.");case FINISHED:throw new IllegalStateException("Cannnot 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;}}

在上面的代码中，sDefaultExecutor实际上是一个串行的线程池，一个进程中所有的AsyncTask全部在这个串行的线程池中排队执行，这个排队执行的过程后面再分析，在executeOnExecutor方法中，AsyncTask的onPreExecute方法最先执行，然后线程池开始执行，下面分析先后蹭吃的执行过程:

package com.zxxthreadpool;import java.util.ArrayDeque;import java.util.concurrent.Executor;import android.os.AsyncTask.Status;public abstract class AsyncTask<Params, Progress, Result> {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 alread running.");case FINISHED:throw new IllegalStateException("Cannnot 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;}public static final Executor SERIAL_EXECUTOR=new SerialExecutor();private static volatile Executor sDefaultExecutor=SERIAL_EXECUTOR;private static class SerialExecutor implements Executor{final ArrayDeque<Runnable> mTasks=new ArrayDeque<Runnable>();Runnable mActive;@Overridepublic synchronized void execute(final Runnable r) {// TODO Auto-generated method stubmTasks.offer(new Runnable() {@Overridepublic void run() {// TODO Auto-generated method stubtry {r.run();} finally{scheduleNext();}}});if(mActive==null){scheduleNext();}}protected void scheduleNext() {// TODO Auto-generated method stubif((mActive=mTasks.poll())!=null){THREAD_POOL_EXECUTOR.execute(mActive);}}}}

从SerialExecutor的实现可以分析AsyncTask的排队执行的过程。首先系统会吧AsyncTask的Params参数封装为FutureTask对象，FutureTask是一个并发类，在这里他充当了Runnable的作用，接着这个FutureTask会交给SerialExecutor的execute方法处理，SerialExecutor的execute方法首先会把FutrueTask对象插入到任务队列mTasks中，如果这个时候没有正在活动的AsyncTask任务，那么就会调用SerialExecutor的scheduleNext方法来执行下一个AsyncTask任务，同时当一个AsyncTask任务执行完后AsyncTask会继续执行其他任务知道所有任务都被执行位置，这一点可以看出，默认情况下，AsyncTask是串行执行的。

AsyncTask中由两个线程池，SerialExecutor和THREAD_POOL_EXECUTOR和一个Handler(InternalHandler),其中线程池SerialExecutor用于任务的排列，而线程池THREAD_POOLEXECUTOR用于真正执行任务，InternalHandler用于将执行环境从线程池切换到主线程，其本质仍然是线程的调用。在AsyncTask的构造方法中由如下这么一段代码，由于FutureTask的run方法会调用mWorker的call方法，因此mWorker的call方法最终会在线程池中执行：

mWorker=new WorkerRunnable<Params,Rsult>(){public Result call() throws Exception{mTaskInvoked.set(true);Process.setThreadPriority(Process.THREAD_PRORITY_BACKGROUND);return postResult(doInBackground(mParams));}};

在mWorker的call方法中，首先将mTaskInoked设置为true，表示当前任务已经被调用过了，然后执行AsyncTask的doInBackground方法，接着将其返回值传递给postRsult方法，其实现如下：

private Result postResult(Result result) {Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,new AsyncTask<Result>(this, result));message.sendToTarget();return result;}

在上面代码中，postResult方法会通过sHandler发送一个MESSAGE_POST_RESULT的消息，这个sHandler的定义如下：

private static final InternalHandler sHandler=new InternalHandler();private static class InternalHandler extends Handler{@Overridepublic void handleMessage(Message msg) {// TODO Auto-generated method stubsuper.handleMessage(msg);AsyncTaskResult result=(AsyncTaskResult)msg.obj;switch (msg.what) {case MESSAGE_POST_RESULT:result.mTask.finish(result.mData[0]);break;case MESSAGE_POST_PROGESS:result.mTask.onProgressUpdate(result.mData);break;}}}

可以发现， sHandler是一个静态的Handler对象，为了能够将执行环境奇幻到主线程，这就要求sHandler这个对象必须在主线程中创建，由于静态成员会在加载类的时候进行初始化，因此这就变相要求AsyncTask的类必须在主线程中加载，否则同一个进程中的AsyncTask都将无法正常工作。 sHandler收到MESSAGE_POST_RESULT这个消息后会调用AsyncTask的finish方法，如下：

public void finish(Result result){if(isCancelled()){onCancelled(result);}else{onPostExecute(result);}mStatus=Status.FINISHED;}

AsyncTask的finish方法的逻辑比较简单，如果AsyncTask被取消执行了，那么就骁勇onCancelled方法，否者就调用onPostExecute方法，可以看到doInBackground的返回结果会传递给onPostExeute方法。到这里AsyncTask的整个工作过程就分析完毕了。
关于AsyncTask执行任务的串行还是并行：从Android3.0开始默认情况下是是串行执行的。在Android2.x上应该默认是并行的。为了让AsyncTask可以在Android3.0及以上版本上并行，可以采用AsyncTask的executeOnExecutor方法，需要注意的是这个方法是3.0新添加的方法，不能再低版本上使用，所用之前需要判断一下版本时候可行，
ok，关于AsyncTask的原理分析以及源码就先讲这么多吧。

注：本博客整理学习子《Android开发艺术探索》，以此笔记，留以后温故而知新。

Android的线程和线程池(一)

AsncTask:

AsyncTask的工作原理：

更多相关文章

随机推荐