Android(安卓)源码解析-AsyncTask
我们都知道Android 的子线程中是不能更新UI 的(当然也不是绝对的,在初始化的某个时机是可以的,稍后会根据源码进行分析为什么可以,期待吧),如果想要在子线程里进行UI操作,就需要借助Android的异步消息处理机制。为了更方便的在子线程中更新UI元素,Android从1.5版本后引入了AsyncTask类,AsyncTask从本质上讲,是对ThreadPool和handler的封装,本文首先介AsyncTask的基本用法,然后解析AsynTask的成员变量,然后分析AsyncTask的整个调用流程以及AsyncTask存在的问题。本文分析的是Android API 25 中的源码。
AsyncTask 基本用法
public abstract class AsyncTask {}
从源码来看 AsyncTask 是一个抽象类,必须继承后才可以使用,继承时需要传三个泛型参数 Params, Progress, Result, 用途如下:
1、 Params
执行时的参数,在后台任务中使用。
2、Progress
用于界面上显示当前的进度,Progress作为进度单位。
3、Result
当任务执行完毕后,如果需要对结果进行返回,则使用这里指定的泛型作为返回值类型。
AsyncTask 中需要重写的方法,
@MainThreadprotected void onPreExecute() {}
这个方法会在后台任务开始执行之间调用,用于进行一些界面上的初始化操作,比如显示进度条。
protected abstract Result doInBackground(Params... params);
方法内的所有代码在子线程中运行,可以处理所有的耗时任务。任务一旦完成就可以通过return语句来将任务的执行结果进行返回,在这个方法中是不可以进行UI操作的,如果需要更新UI元素,可以调用publishProgress(Progress…)方法。
protected void onProgressUpdate(Progress... values) {}
当在后台任务中调用了publishProgress(Progress…)方法后,这个方法就很快会被调用,方法中携带的参数就是在后台任务中传递过来的。在这个方法中可以对UI进行操作
protected void onPostExecute(Result result) {}
当后台任务执行完毕并通过return语句进行返回时,这个方法就很快会被调用。
模拟一个下载任务 代码如下:
public class MainActivity extends AppCompatActivity { SeekBar progressBar; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); progressBar = (SeekBar) findViewById(R.id.seek_bar); } @Override protected void onResume() { super.onResume(); new DownloadTask().execute(); } private class DownloadTask extends AsyncTask<Void, Integer, Boolean> { @Override protected void onPreExecute() { super.onPreExecute(); } @Override protected Boolean doInBackground(Void... params) { try { int percent = 0; while (true) { publishProgress(percent); if (percent++ > 100) { break; } Thread.sleep(50); } } catch (Exception e) { e.printStackTrace(); return false; } return true; } @Override protected void onProgressUpdate(Integer... values) { progressBar.setProgress(values[0]); super.onProgressUpdate(values); } @Override protected void onPostExecute(Boolean aBoolean) { if (aBoolean) { Toast.makeText(MainActivity.this, "Download finished", Toast.LENGTH_LONG).show(); } else { Toast.makeText(MainActivity.this, "Download Error", Toast.LENGTH_LONG).show(); } } }}
上面的代码模拟了一个下载任务,在doInBackground()方法中去执行具体的下载逻辑,在onProgressUpdate()方法中显示当前的下载进度,在onPostExecute()方法中来提示任务的执行结果。AsyncTask的启动是通过new DownloadTask().execute() 启动的。
AsyncTask 中成员变量的解析
线程池 THREAD_POOL_EXECUTOR
// CPU 核数private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();// We want at least 2 threads and at most 4 threads in the core pool,// preferring to have 1 less than the CPU count to avoid saturating// the CPU with background work//核心线程池,最少2个 最大4个private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));// 最大线程数private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;// 非核心线程数闲置时的超时时长private static final int KEEP_ALIVE_SECONDS = 30;//线程工厂,为线程池提供创建新线程的功能只有一个方法newThread(),具体实现就是创建一个thread并返回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()); }}; //线程池中的任务队列,通过线程池的execute方法提交的Runnable对象会存储在这个参数中,此处LinkedBlockingQueue是一个单向链表实现的阻塞队列private static final BlockingQueue sPoolWorkQueue = new LinkedBlockingQueue(128);/** * An {@link Executor} that can be used to execute tasks in parallel. */public static final Executor THREAD_POOL_EXECUTOR;static { //使用以上参数创建的线程池 ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor( CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory); threadPoolExecutor.allowCoreThreadTimeOut(true); THREAD_POOL_EXECUTOR = threadPoolExecutor;}
sDefaultExecutor (特别强调:串行)
private static class SerialExecutor implements Executor { // 双端队列 final ArrayDeque mTasks = new ArrayDeque(); 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); } }}
这里实现了一个串行的exectuor,这里的实现很巧妙, 每次调用execute()方式都必然会调用scheduleNext(),
使得mTasks中的所有Runnable对象依次执行.
还有一点需要注意的是:
这里的execute()方法的作用只是用于给任务排队,真正执行任务的是THREAD_POOL_EXECUTOR.
然后看一下成员变量的声明:
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
SERIAL_EXECUTOR 唯一的作用是把SerialExecutor对象传递给sDefaultExecutor。
为什么这里要这样使用呢?
我觉得原因在于下面这个隐藏方法:
/** @hide */public static void setDefaultExecutor(Executor exec) { sDefaultExecutor = exec;}
也就是说AsyncTask中有一个sDefaultExecutor的默认实现,但是还提供了一个隐藏方法,可以对其进行修改.
sHandler
首先先看一个内部类的实现,这个内部类是用来包装执行结果的,其中封装了一个AsyncTask实例和某种类型的数据集.
@SuppressWarnings({"RawUseOfParameterizedType"})private static class AsyncTaskResult { final AsyncTask mTask; final Data[] mData; AsyncTaskResult(AsyncTask task, Data... data) { mTask = task; mData = data; }}
InternalHandler的具体实现
private static InternalHandler sHandler;private static final int MESSAGE_POST_RESULT = 0x1;private static final int MESSAGE_POST_PROGRESS = 0x2;// 单例模式private static Handler getHandler() { synchronized (AsyncTask.class) { if (sHandler == null) { sHandler = new InternalHandler(); } return sHandler; }}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; } }}private void finish(Result result) { if (isCancelled()) { onCancelled(result); //这个同样需要用户来实现 } else { onPostExecute(result); //这个就是我们自定义AsyncTask时需要实现的onPostExecute() } mStatus = Status.FINISHED; //任务执行完成的状态}
onProgressUpdate,onPostExecute,onCancelled这三个回调方法会在这里集中处理,结合AsyncTask的使用方法,我们可以得出以下结论:
在doInBackground()执行过程中或者结束后,会由该handler发送消息到主线程,调用相关回调方法,可以认为,handler是AsyncTask整个工作流程的倒数第二站.
AsyncTask的源码解析
首先分析的是AsyncTask 的构造函数
/** * Creates a new asynchronous task. This constructor must be invoked on the UI thread. */public AsyncTask() { mWorker = new WorkerRunnable() { public Result call() throws Exception { mTaskInvoked.set(true); //设置mTask已经被调用过 Result result = null; try { Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); //noinspection unchecked result = doInBackground(mParams); //调用doInBackground()!!!!!!!! Binder.flushPendingCommands(); } catch (Throwable tr) { mCancelled.set(true); throw tr; } finally { postResult(result); } return result; } }; //将mWorker作为参数创建FutureTask实例 //在mFuture实例中,将会调用mWorker做后台任务,完成后调用done方法 mFuture = new FutureTask(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和mFuture,并在初始化mFuture的时候将mWorker作为参数传入。mWorker是一个Callable对象,mFuture是一个FutureTask对象,这两个变量会暂时保存在内存中,稍后才会用到它们。
mWorker&FutureTask
private final WorkerRunnable mWorker;private final FutureTask mFuture;private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> { Params[] mParams;}
Callable
WorkRunnable实现了Callble接口,Callable与Runnable的功能大致相似,不同的是Callable是一个泛型接口,它有一个泛型参数V,该接口中只有一个call()方法,该方法返回类型为V的值.
Callable可以简单理解为有返回值的Runnable.
@FunctionalInterfacepublic interface Callable { /** * Computes a result, or throws an exception if unable to do so. * * @return computed result * @throws Exception if unable to compute a result */ V call() throws Exception;}
FutureTask
FutureTask实现了 RunnableFuture接口,而RunnableFuture继承Runnable, Future
Future提供了对Runnable或者Callable任务的执行结果进行取消,查询是否完成,获取结果的操作,FutureTask是它的实现类
public interface Future { boolean cancel(boolean mayInterruptIfRunning); boolean isCancelled(); boolean isDone(); V get() throws InterruptedException, ExecutionException; V get(long timeout, TimeUnit unit)throws InterruptedException, ExecutionException, TimeoutException;}
下面是FutureTask的一个构造函数,在AsyncTask的构造函数中会使用其创建一个FutureTask实例、
public FutureTask(Callable callable) { if (callable == null) throw new NullPointerException(); this.callable = callable; this.state = NEW; // ensure visibility of callable}
分析完了构造函数,然后分析如何启动某一个任务, 调用该任务的execute()方法, 我们看看 execute()方法的源码 ,如下所示:
@MainThreadpublic final AsyncTask<Params, Progress, Result> execute(Params... params) { return executeOnExecutor(sDefaultExecutor, params);}
只有一行代码, 只是调用了executeOnExecutor()方法, 我们接着进 这个方法看看
@MainThreadpublic final AsyncTask 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()方法,因此证明了onPreExecute()方法会第一个得到执行。什么地方调用doInBackground()方法呢?我们看到调用了Executor的execute()方法,并将前面初始化的mFuture对象传了进去,那么这个Executor对象又是什么呢?查看上面的execute()方法,原来是传入了一个sDefaultExecutor变量,接着找一下这个sDefaultExecutor变量是在哪里定义的,源码如下所示:
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
可以看到,这里先new出了一个SERIAL_EXECUTOR常量,然后将这个值赋给sDefaultExecutor这个常量,也就是说明,刚才在executeOnExecutor()方法中调用的execute()方法,其实也就是调用的SerialExecutor类中的execute()方法。SerialExecutor的源码了,如下所示:
private static class SerialExecutor implements Executor { final ArrayDeque mTasks = new ArrayDeque(); 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); } }}
SerialExecutor类中也有一个execute()方法,run 方法中的逻辑都是运行在子线程, 方法中有个Runnalbe 参数 r, r.run() 执行的就是FutureTask类的run()方法, 代码如下
public void run() { if (state != NEW || !U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread())) return; try { Callable 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); }}
可以看到,改方法中调用了c.all(),那么这个callable对象是什么呢?其实就是在初始化mFuture对象时传入的mWorker对象了,此时调用的call()方法,也就是一开始在AsyncTask的构造函数中指定的,代码如下所示:
mWorker = new WorkerRunnable() { public Result call() throws Exception { mTaskInvoked.set(true); Result result = null; try { Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); //noinspection unchecked result = doInBackground(mParams); Binder.flushPendingCommands(); } catch (Throwable tr) { mCancelled.set(true); throw tr; } finally { postResult(result); } return result; }};
该方法中找到了doInBackground()方法的调用处,该方法是在子线程中运行的, 所以这也就是为什么我们可以在doInBackground()方法中去处理耗时的逻辑。接着将doInBackground()方法返回的result传递给了postResult()方法,这个方法的源码如下所示:
private Result postResult(Result result) { @SuppressWarnings("unchecked") Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT, new AsyncTaskResult(this, result)); message.sendToTarget(); return result;}
这里使用sHandler对象发出了一条消息。这个sHandler对象是InternalHandler类的一个实例,那么稍后这条消息在InternalHandler的handleMessage()方法中被处理。InternalHandler的源码如下所示:
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; } }}
handleMessage 中对消息类型进行了判断,如果这是一条MESSAGE_POST_RESULT消息,会执行finish()方法,如果是一条MESSAGE_POST_PROGRESS消息,就会去执行onProgressUpdate()方法。
因为InternalHandler 是一个静态类它不会持有外部类的引用,也不能调用外部类的方法, 因此在发消息的时候传入了 msg.obj 即 AsyncTaskResult,
AsyncTaskResult 中有一个属性 mTask 就是 AsyncTask 本身因此就可以调用外部方法
finish() 方法的源码如下
private void finish(Result result) { if (isCancelled()) { onCancelled(result); } else { onPostExecute(result); } mStatus = Status.FINISHED;}
如果当前任务被取消掉了,就会调用onCancelled()方法,如果没有被取消,则调用onPostExecute()方法,这样当前任务的执行就全部结束了。
InternalHandler的handleMessage()方法里,还有一种MESSAGE_POST_PROGRESS的消息类型,这种消息是用于当前进度的,查看publishProgress()方法的源码,如下所示:
@WorkerThreadprotected final void publishProgress(Progress... values) { if (!isCancelled()) { getHandler().obtainMessage(MESSAGE_POST_PROGRESS, new AsyncTaskResult
到这里源码已经分析完了。
AsyncTask的各种坑
1、在Activity中定义AsyncTask导致内存泄漏
由于AsyncTask是Activity的内部类,所以会持有外部的一个引用,如果Activity已经退出,但是AsyncTask还没有执行完毕,那么Activity就无法释放导致内存泄漏。对于这个问题我们可以把AsyncTask定义为静态内部类并且采用弱引用。
2、各版本对AsyncTask的实现不一样
对于这个问题,可以自己扩展一下AsyncTask在其内部也对版本做出判断,对于不同版本做一些不同的处理。
3、不能及时取消任务
以4.4版本双核手机为例,如果用户在A界面发起5个任务,由于使用SerialExecutor来执行任务,那么任务将一个一个顺序执行,由于第一个任务执行时间过长,其他任务只能在队列中等待,导致阻塞,所以可以考虑把执行时间较短的任务优先加入。如果在第一个任务执行过程中,用户跳转到了B界面,而A界面发起的任务已经没有必要执行,所以我们要在Activity的生命周期结束的时候取消掉任务。如果任务没取消掉,B界面又发起新的任务,就会导致B界面的所有请求阻塞。如果有需要我们可以直接使用executeOnExecutor方法,然后直接使用THREAD_POOL_EXECUTOR线程池来执行,这样可以3个线程同时执行,并且在doInBackground方法中判断任务是否被取消,这样可以提高效率。
4、曾经缺陷
以前对于缺陷的答案可能是:AsyncTask在并发执行多个任务时发生异常。其实还是存在的,在3.0以前的系统中还是会以支持多线程并发的方式执行,128,阻塞队列可以存放10个;也就是同时执行138个任务是没有问题的;而超过138会马上出现java.util.concurrent.RejectedExecutionException;
而在在3.0以上包括3.0的系统中会为单线程执行;
更多相关文章
- 浅谈Java中Collections.sort对List排序的两种方法
- Python list sort方法的具体使用
- python list.sort()根据多个关键字排序的方法实现
- android:绘图
- Android(安卓)App开发基础篇—四大组件之Activity简介
- android的消息处理机制(图+源码分析)——Looper,Handler,Message
- Android(安卓)之 zygote 与进程创建
- Android输入法原理和疑云
- android的消息处理机制(图+源码分析)——Looper,Handler,Message