AsyncTask 原理分析
2016-05-11 15:04
489 查看
一、先来看看AsyncTask的定义,以及主要的方法。
AsyncTask的定义如下:
其中这几个泛型分别表示:参数类型、进度类型、返回结果类型。
接下来看看这个类中主要的方法
ok,主要的方法介绍完了,我们切入正题,来看看它内部的实现原理。
我们知道当我们new 一个异步任务时,它首先会执行AsyncTask的构造方法,然后我们会调用他的execute(Params …) 方法并传参。所以接下来我们先看看它的构造方法,以及execute(Params…)方法。
构造方法如下:
这里我们看到:它new 了2个类 WorkerRunnable 和 FutureTask,并且将mWorker 当作参数传递给了 mFuture。我们先来看看 WorkerRunnable 的定义:
可以看到 WorkerRunnable 实际上是一个 Callable,并且他包含了 Params[] 的成员。
FutureTask、Callable 我已在前面的博客上作出了介绍,具体参考http://blog.csdn.net/a992036795/article/details/51362487
我们知道FutureTask 实现了 RunnableFuture ,而RunnableFuture 接口继承自
Runnable, Future。所以说 FutureTask 也是一个Runable对象。
好的,接下来我们来查看AsyncTask的execute(Params[] …)方法:
我们可以看到execute(Params[]…)方法又调用了 executeOnExecutor 方法。
在 executeOnExecutor()方法中我们看到:
1、他首先判断了当前任务的状态,如果不是PENDING 状态,则会抛出异常。这就告诉我们,一个异步任务实例只能执行一次。
2、将当前的状态更改为 RUNNING
3、调用onPreExecute() 方法,因为我们使用异步任务时在主线程,所以onPreExecute()方法也会发生在主线程
4、将参数传递给 mWorker。通过构造方法我们知道 mWorker是一个WorkerRunnable 对象。
5、最后调用 exec.execute(mFuture); 这里的exec 我们可以看到是一个静态的成员变量sDefaultExecutor,我们来看看它的定义。
我们稍加分析,可以看到它默认是一个顺序执行的线程池,他最终调用 THREAD_POOL_EXECUTOR.execute(mActive);
我们接着看看THREAD_POOL_EXECUTOR的定义
这里我们明显可以看到他是一个线程池了。
也就是说,我们将mFuture 向上转型为了 Runable然后传递给了这个线程池,那么我们知道,它肯定会调用 mFuture 的run方法。我们知道mFuture 是一个FutureTask 而且他在创建的时候,将mWorker(实现了 Callable)通过构造方法传递进去了,参见上文AsyncTask 构造方法。
好的,我们接下来看看 FutureTask的 构造方法,以及run方法。
这里我们看到了,他将mWorker转型为Callable,然后又在 run方法中调用 callable.call()方法。也就是数调用了 mWorker.call()方法。
我重新附上 mWorker在 AsyncTask 构造方法中的定义:
可以看到,他调用了 doInBackground(mParams) (mParams 是 execute()方法传入的)并将结果 通过 postResult(result)发送出去。
这里我们就看以看到: doInBackground(mParams) 发生在子线程。
好的接下来看 postResult(result)方法。
可以看到,他通过handler发送了一个消息,并将result 封装了成了一个AsyncTaskResult 对象 一并发送出去
这里给出AsyncTaskResult的定义
好的,我们马上来查看他的Handler
可以看到他是一个主线程的Handler
他在hanlde中调用了 result.mTask.finish(result.mData[0]); 查看AsyncTaskResult的定义我们知道,实质是调用了 AsyncTask 的finish方法。我们接着来看 AsyncTask的finish()方法
到这里我们依然清楚明了~ onPostExecute(result); 发生在主线程,并将状态置为FINISHED。
大体流程就是这样。
还有 publishProgress() 实质也是给handle发送一个消息
这里附上源码:
最红handle处理时 会走 MESSAGE_POST_PROGRESS 分支 调用哦AsyncTask的 onProgressUpdate 方法,(发生在主线程)
AsyncTask的定义如下:
public abstract class AsyncTask<Params, Progress, Result> { ...... }
其中这几个泛型分别表示:参数类型、进度类型、返回结果类型。
接下来看看这个类中主要的方法
//需要我们重写,其工作在子线程,用于执行比较耗时的操作 protected abstract Result doInBackground(Params... params); //在excute(Params ...params)被调用后立即执行,执行在UI线程,一般用来执行后台任务前对UI做一些标记。 protected void onPreExecute() { } //执行在UI线程。当后台操作结束时,此方法将会被调用,doBackground函数返回的计算结果将作为参数传递到此方法中,直接将结果显示到UI组件上 protected void onPostExecute(Result result) { } //执行UI线程,在调用publishProgress(Progress... values)来更新进度信息 protected void onProgressUpdate(Progress... values) { } //执行一个异步任务,需要我们在代码中调用 public final AsyncTask<Params, Progress, Result> execute(Params... params) { return executeOnExecutor(sDefaultExecutor, params); }
ok,主要的方法介绍完了,我们切入正题,来看看它内部的实现原理。
我们知道当我们new 一个异步任务时,它首先会执行AsyncTask的构造方法,然后我们会调用他的execute(Params …) 方法并传参。所以接下来我们先看看它的构造方法,以及execute(Params…)方法。
构造方法如下:
public 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); } } }; }
这里我们看到:它new 了2个类 WorkerRunnable 和 FutureTask,并且将mWorker 当作参数传递给了 mFuture。我们先来看看 WorkerRunnable 的定义:
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> { Params[] mParams; }
可以看到 WorkerRunnable 实际上是一个 Callable,并且他包含了 Params[] 的成员。
FutureTask、Callable 我已在前面的博客上作出了介绍,具体参考http://blog.csdn.net/a992036795/article/details/51362487
我们知道FutureTask 实现了 RunnableFuture ,而RunnableFuture 接口继承自
Runnable, Future。所以说 FutureTask 也是一个Runable对象。
好的,接下来我们来查看AsyncTask的execute(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; }
我们可以看到execute(Params[]…)方法又调用了 executeOnExecutor 方法。
在 executeOnExecutor()方法中我们看到:
1、他首先判断了当前任务的状态,如果不是PENDING 状态,则会抛出异常。这就告诉我们,一个异步任务实例只能执行一次。
2、将当前的状态更改为 RUNNING
3、调用onPreExecute() 方法,因为我们使用异步任务时在主线程,所以onPreExecute()方法也会发生在主线程
4、将参数传递给 mWorker。通过构造方法我们知道 mWorker是一个WorkerRunnable 对象。
5、最后调用 exec.execute(mFuture); 这里的exec 我们可以看到是一个静态的成员变量sDefaultExecutor,我们来看看它的定义。
private static volatile Executor sDefaultExecutor = SERIAL_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() { 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); } } }
我们稍加分析,可以看到它默认是一个顺序执行的线程池,他最终调用 THREAD_POOL_EXECUTOR.execute(mActive);
我们接着看看THREAD_POOL_EXECUTOR的定义
public static final Executor THREAD_POOL_EXECUTOR = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
这里我们明显可以看到他是一个线程池了。
也就是说,我们将mFuture 向上转型为了 Runable然后传递给了这个线程池,那么我们知道,它肯定会调用 mFuture 的run方法。我们知道mFuture 是一个FutureTask 而且他在创建的时候,将mWorker(实现了 Callable)通过构造方法传递进去了,参见上文AsyncTask 构造方法。
好的,我们接下来看看 FutureTask的 构造方法,以及run方法。
public FutureTask(Callable<V> callable) { if (callable == null) throw new NullPointerException(); this.callable = callable; this.state = NEW; // ensure visibility of callable } 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); } } finally { // runner must be non-null until state is settled to // prevent concurrent calls to run() runner = null; // state must be re-read after nulling runner to prevent // leaked interrupts int s = state; if (s >= INTERRUPTING) handlePossibleCancellationInterrupt(s); } }
这里我们看到了,他将mWorker转型为Callable,然后又在 run方法中调用 callable.call()方法。也就是数调用了 mWorker.call()方法。
我重新附上 mWorker在 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); } };
可以看到,他调用了 doInBackground(mParams) (mParams 是 execute()方法传入的)并将结果 通过 postResult(result)发送出去。
这里我们就看以看到: doInBackground(mParams) 发生在子线程。
好的接下来看 postResult(result)方法。
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 对象 一并发送出去
这里给出AsyncTaskResult的定义
private static class AsyncTaskResult<Data> { final AsyncTask mTask; final Data[] mData; AsyncTaskResult(AsyncTask task, Data... data) { mTask = task; mData = data; } }
好的,我们马上来查看他的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; } } }
可以看到他是一个主线程的Handler
他在hanlde中调用了 result.mTask.finish(result.mData[0]); 查看AsyncTaskResult的定义我们知道,实质是调用了 AsyncTask 的finish方法。我们接着来看 AsyncTask的finish()方法
private void finish(Result result) { if (isCancelled()) { onCancelled(result); } else { onPostExecute(result); } mStatus = Status.FINISHED; }
到这里我们依然清楚明了~ onPostExecute(result); 发生在主线程,并将状态置为FINISHED。
大体流程就是这样。
还有 publishProgress() 实质也是给handle发送一个消息
这里附上源码:
@WorkerThread protected final void publishProgress(Progress... values) { if (!isCancelled()) { getHandler().obtainMessage(MESSAGE_POST_PROGRESS, new AsyncTaskResult<Progress>(this, values)).sendToTarget(); } }
最红handle处理时 会走 MESSAGE_POST_PROGRESS 分支 调用哦AsyncTask的 onProgressUpdate 方法,(发生在主线程)
相关文章推荐
- 使用C++实现JNI接口需要注意的事项
- Android IPC进程间通讯机制
- Android Manifest 用法
- [转载]Activity中ConfigChanges属性的用法
- Android之获取手机上的图片和视频缩略图thumbnails
- Android之使用Http协议实现文件上传功能
- Android学习笔记(二九):嵌入浏览器
- android string.xml文件中的整型和string型代替
- i-jetty环境搭配与编译
- android之定时器AlarmManager
- android wifi 无线调试
- Android Native 绘图方法
- Android java 与 javascript互访(相互调用)的方法例子
- android 代码实现控件之间的间距
- android FragmentPagerAdapter的“标准”配置
- Android"解决"onTouch和onClick的冲突问题
- android:installLocation简析
- android searchView的关闭事件
- SourceProvider.getJniDirectories