好记性不如烂笔头，把自己会的用自己的话给记录下来，写成文章，供自己日后查阅。慢慢积累，终会有用到的那天。
基本介绍
- AsyncTask 定义 （翻译Android的官方文档）
- AsyncTask能够简单方便使用UI线程。这个类允许你在后台执行任务并且将执行后的结果在UI线程中显示出来不需要通过去开启线程和消息的方式。
- AsyncTask被设计的目的是为了成为Thread和Handler的帮助类，但是不能成为一个通用的线程框架。AsyncTask是用于短的耗时任务中（也就几秒钟的耗时任务吧！）。如果你需要去长期的在后台执行耗时任务，很强烈的推荐你去使用java.util.concurrent包下的Executor，ThreadPoolExecutor和Future这几个API。
- 一个异步任务被设计用来计算跑在后台任务的结果（一般获取任务进度来更新UI），然后将结果展示在UI线程中。一个异步任务由三个范型参数和4个方法来实现。（三个范型参数：Params，Progress，Result；4个方法：onPreExecute,doInBackground,onProgressUpdate,onPostExecute）
- AsyncTask使用基本介绍
- 各个方法的使用场景介绍
- onPreExecute() ：在UI线程中进行初始化操作，该方法的执行是在UI线程中。
- doInBackground()：执行耗时的操作任务，执行在工作线程中（开启一个新的线程）
- onProgressUpdate()：更新任务执行的进度 （主要就是更新UI，该方法如果想要执行，需要在doInBackground()中执行publishProgress()来触发刚方法的执行，这个会在源码分析部分，根据源码来说明）执行在UI线程中。
- onPostExecute：最终任务执行的结果会返回到这个方法中，也是执行在UI线程中，主要处理些结尾的操作。
- 使用AsyncTask的基本步骤
-
AsyncTask是一个抽象类，需要子类继承AsyncTask并且实现内部的抽象方法
class MyTask extends AsyncTask<Void,Integer,Void>{ @Override protected Void doInBackground(Void... voids) { ...... //执行耗时的任务操作，该方法是必须被实现的。 } } -
开启异步任务
//开启异步任务，（这个参数可以不传，这个地方不传的话，AsyncTask中第一个范型参数就可以写成Void类型了） 这段代码必须在UI线程中去执行 // new MyTask()任务实例的初始化 和 execute方法的调用都必须在UI线程中。 new MyTask().execute(params)
-
- 展示一个AsyncTask异步任务的小demo
private class MyTask extends AsyncTask<Void,Integer,Void>{ @Override protected void onPreExecute() { mTvShowLoading.setText("加载中"); } @Override protected Void doInBackground(Void... voids) { int count = 0; int length =1; int tempCount = 99; while(count < tempCount){ count += length; //将执行任务的实时结果 传入到UI线程中进行UI的更新 // 该方法的调用时为了触发onProgressUpdate(params)的方法，params[0]参数就是onProgressUpdate(Integer..values) 方法中的 values[0]的参数 publishProgress(count); try { //这个地方是为了模拟进度的效果，实际使用中，不能这么搞呀！ Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } } return null; } @Override protected void onProgressUpdate(Integer... values) { progressBar.setProgress(values[0]); mTvShowLoading.setText("loading ..."+values[0]+"%"); } @Override protected void onPostExecute(Void aVoid) { mTvShowLoading.setText("加载完毕"); } }
- 各个方法的使用场景介绍
- AsyncTask使用场景
- 执行耗时的任务，并且要实时更新主线程的UI
- 如果你仅仅执行耗时的任务，没必要使用AsyncTask。可以使用Executor FutureTask的。
- 如果是大规模的下载和数据库的更改不适合使用AsyncTask。会导致线程阻塞的。
源码分析
AsyncTask构造方法
- API == 25：
//source public AsyncTask() { //工作线程 WorkerRunnable是一个Callable接口的实现类，Callable类型接口有返回值 mWorker = new WorkerRunnable<Params, Result>() { 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; } }; //入参了mWorker参数 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); } } }; }
WorkRunnable
- 分析
//source mWorker = new WorkerRunnable<Params, Result>() { 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 { //分析1 （提交任务结果） postResult(result); } return result; } }; //分析1 private Result postResult(Result result) { @SuppressWarnings("unchecked") //getHandler()返回的就是mHandler == AsyncTask构造方法中赋值的mHandler //这段代码是构造一个Message对象 Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT, new AsyncTaskResult<Result>(this, result)); // sendToTarget方法的实现就是通过handler将消息发送出去，根据标志执行不能的逻辑代码， //也实现了从工作线程切换到Ui线程上。 message.sendToTarget(); return result; } //这是一个单利模式，来获取到InternalHanlder的实例。 //接着查看InterHandler类。 private static Handler getHandler() { synchronized (AsyncTask.class) { if (sHandler == null) { sHandler = new InternalHandler(); } return sHandler; } } //AsyncTask内部的一个Handler，主要用来发送任务更新UI的消息和任务完成的消息。 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; //发送任务更新UI的消息，来执行onProgressUpdate()方法。 case MESSAGE_POST_PROGRESS: result.mTask.onProgressUpdate(result.mData); break; } } }
FutureTask
- 分析
//source //参数中传入了上文中构造好的 WorkRunnable的对象 mFuture = new FutureTask<Result>(mWorker) { @Override protected void done() { try { //重点分析1 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); } } }; //重点分析1 private void postResultIfNotInvoked(Result result) { //获取到执行任务的标志 final boolean wasTaskInvoked = mTaskInvoked.get(); //如果任务没有得到执行，那么直接就提交任务 if (!wasTaskInvoked) { postResult(result); } }
execute
- 分析
//source //运行在主线程中 @MainThread public final AsyncTask<Params, Progress, Result> execute(Params... params) { // 此处看 executeOnExecutor() // 其中sDefaultExecutor = new SerialExecutor(); return executeOnExecutor(sDefaultExecutor, params); } // executeOnExecutor() 分析 @MainThread // 此处的exec 就是SerialExecutor public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec, Params... params) { //判断当前AsyncTask的运行状态，如果不是挂在的状态 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)"); } } //初始化AsyncTask状态为RUNNING(运行的状态) mStatus = Status.RUNNING; //主线程的UI初始化操作 onPreExecute(); //将参数添加到任务中，此处的params就是调用在主线程中调用execute(Params)传入的参数，该参数最终会进入到doInBackground()方法中。 mWorker.mParams = params; //执行任务 // 此处的exec = sDefaultExecutor = new SerialExecutor(); // SerialExecutor 是AsyncTask的一个静态内部类，实现了Execute接口，重写了Execute方法。 exec.execute(mFuture); return this; } // SerialExecutor 排队线程池,这也是AsyncTask能串行执行的关键，内部的实现就是按顺序执行任务。 //所以就达到了任务串行执行的目的。 //在上文中我们分析 execute方法的时候 我们在execute方法中调用了executeOnExecutor(sDefaultExecutor, params); // 其中的 sDefaultExecutor就是SerialExecutor的实例，所以可以看出来如果想要做并行执行任务，可以在这个executeOnExecutor()方法入参上做文章。 private static class SerialExecutor implements Executor { //此处是一个线性双向列表，用来存储所有的AsyncTask的任务 final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>(); //正在执行的任务 Runnable mActive; public synchronized void execute(final Runnable r) { //将任务添加到队列中 offer：在队列的末尾插入一个值 mTasks.offer(new Runnable() { public void run() { try { // r = mFuture // 执行了FutureTask的run方法 //查看run方法 发现内部又调用了WorkRunnable的call方法 //这时内存中的WorkRunnable中的call方法得以执行，内部就执行了doInBackground方法。 r.run(); } finally { //当前的任务执行完毕后，进行下一轮任务的执行。 //在这里也很好的体现了AsyncTask的串行执行任务的机制。 scheduleNext(); } } }); if (mActive == null) { scheduleNext(); } } protected synchronized void scheduleNext() { //取出队列头部的任务 poll：删除队列中的第一个值，并返回该值，如果不存在就返回null。 if ((mActive = mTasks.poll()) != null) { //执行取出的队列头部的任务 //就是调用了任务线程类 THREAD_POOL_EXECUTOR //接下来就是分析了 THREAD_POOL_EXECUTOR.executor // THREAD_POOL_EXECUTOR 执行线程池 THREAD_POOL_EXECUTOR.execute(mActive); } } } // THREAD_POOL_EXECUTOR 分析：执行任务的线程池 //获取到CPU核心数 private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors(); //设置线程池的核心线程数 为 2-4之间 ，也取决于cup的核数 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; //设置线程池的空闲线程存活的时间为30秒 private static final int KEEP_ALIVE_SECONDS = 30; //初始化好线程工厂类 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()); } }; // 初始化好存储任务队列。最大数量为128个 private static final BlockingQueue<Runnable> sPoolWorkQueue = new LinkedBlockingQueue<Runnable>(128); //定义一个 Executor类型的变量，名称为THREAD_POOL_EXECUTOR 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); //设置线程池的超时时间为30秒 threadPoolExecutor.allowCoreThreadTimeOut(true); THREAD_POOL_EXECUTOR = threadPoolExecutor; }
总结
- 流程总结
- AsyncTask = 两个线程池+ 一个Handler
- 这两个线程池：SerialExecutor和THREAD_POOL_EXECUTE
- Handler：就是InternalHandler，主要用来进行消息的发送，将线程从工作线程切换到UI线程上，来进行UI的更新。
- 知识点总结
-
串行还是并行？
- API 1.6 之前是串行的。
- API 1.6 - 3.0 由串行给改成并行，多任务执行。
- 但是到API 3.0 的时候 由于之前并行并发执行任务出现错误，所以给改成串行执行，直到现在最新的版本还是串行执行的。因为线程池的容量最高设定为128个，如果出现129个并行执行的话，就会出现Crash线程，导致应用程序崩溃，所以Google由串行改成并行就是画蛇添足，所以在3.0的时候改成串行了，一直保持到现在。
-
那么现在就不能并行执行任务了吗？
- 肯定能的呀！
- 下面使用AsyncTask来写一段并行执行的代码。
//example new MyTask("AsyncTask1").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,""); new MyTask("AsyncTask1").executeOnexecutor(AsyncTask.THREAD_POOL_EXECUTOR,"")； //不过注意的是 executeOnExecutor()该方法是在android3.0加入的，在低版本中是不能执行的，需要加上版本的判断，不过现在市面上应该没有android3.0 以下的手机了吧！
-
内存泄漏的那些事
内部类默认持有外部类的引用：在调用内部类的构造函数初始化内部类对象时，会默认传入外部类的引用。
-
问题发生的分析
在AsyncTask中，如果在执行耗时的异步任务的时候，当Activity结束的时候，此时AsyncTask还在后台运行着，此时AsyncTask还持有了Activity的引用，，GC就不能正常回收Activity的的引用，那么就会发生内存泄漏了！
-
内存泄漏问题的解决方式。
- 在Activity的onDestroy()方法中调用AsyncTask的onCancelled()方法。当AsyncTask中没有任务在执行的时候，GC会在合适的时候把AsyncTask所引用的Activity和AsyncTask实例给回收掉。
- 声明为静态的内部类 。
-
串行还是并行？
可能有不足或者有错误的地方，欢迎多多指教。
