关于android:Android-AsyncTask实现原理和使用技巧分享

为什么要用 AsyncTask

咱们写 App 都有一个准则，主线程不可能运行须要占用大量 CPU 工夫片的工作，如大量简单的浮点运算，较大的磁盘 IO 操作，网络 socket 等，这些都会导致咱们的主线程对用户的响应变得机灵，甚至 ANR，这些会使利用的用户体验变差，然而有时又确实须要执行这些耗时的工作，那么咱们通常能够应用 AsyncTask 或者 new Thread
来解决，这样把工作放入工作线程中执行，不会占用主线程的工夫片，所以主线程会及时响应用户的操作，如果应用 new Thread 来执行工作，那么如果须要中途勾销工作执行或者须要返回工作执行后果，就须要咱们本人保护很多额定的代码，而 AsyncTask 是基于 concurrent 架包提供的并发类实现的，下面的二个需要都曾经帮咱们封装了，这也是咱们抉择 AsyncTask 的起因。

怎么用 AsyncTask

咱们还是简略介绍下 AsyncTask 一些应用示例。咱们先新建一个类 DemoAsyncTask 继承 AsyncTask，因为 AsyncTask 是抽象类，其中 doInBackground 办法必须重写。

private class DemoAsyncTask extends AsyncTask<String, Void, Void> {
    @Override
    protected void onPreExecute() {super.onPreExecute();
    }

    @Override
    protected Void doInBackground(String... params) {return null;}   

    @Override
    protected void onPostExecute(Void aVoid) {super.onPostExecute(aVoid);
    }

    @Override
    protected void onProgressUpdate(Void... values) {super.onProgressUpdate(values);
    }

    @Override
    protected void onCancelled(Void aVoid) {super.onCancelled(aVoid);
    }

    @Override
    protected void onCancelled() {super.onCancelled();
    }
}

DemoAsyncTask task = new DemoAsyncTask();
task.execute("demo test AsyncTask");
//task.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR, "test");
//myTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "test");

简略剖析下
下面就是 AsyncTask 最简略的应用办法，咱们下面重写的办法中，onInBackground 办法运行在工作线程，其余的办法全副运行在主线程，另外它的运行形式 Android 提供给咱们 2 个办法，下面都列出了。

1. 第一个办法会应用默认的 Executor 执行咱们的工作, 其实也就是 SERIAL_EXECUTOR，SERIAL_EXECUTOR 咱们其实也是能够通过办法去自定义的，Android 帮咱们的默认实现是一一执行工作，也就是单线程的，对于 AsyncTask 的工作执行是单线程实现还是多线程实现还有一段很有意思的历史，较早的版本是单线程实现，从 Android2.X 开始，Google 又把它改为多线程实现，起初 Google 发现，多线程实现的话，会有很多须要保障线程平安的额定工作留给开发者，所以从 Android3.0 开始，又把默认实现改为单线程了，明天咱们演示的是 Framwork 代码版本是 21(Android5.0)。

2. 同时也提供了多线程实现的接口，即咱们下面写的最初一行代码 `
AsyncTask.THREAD_POOL_EXECUTOR。

public final AsyncTask<Params, Progress, Result> execute(Params… params) {
return executeOnExecutor(sDefaultExecutor, params);
}
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

其实置信大家平时工作学习中常常应用 AsyncTask，咱们间接去看 AsyncTask 类源码（插一句题外话，平时大家也能够把本人工作学习中的心得体会总结一下，记下来~~）public abstract class AsyncTask<Params, Progress, Result> {....}

AsyncTask 抽象类，有三个泛型参数类型，第一个是你须要传递进来的参数类型，第二个是工作实现进度的类型个别是 Integer，第三个是工作实现后果的返回类型，有时这些参数不是全副须要，不须要的设为 Void 即可，另外 Result 只有一个，但 Params 能够有多个。咱们能够看到 AsyncTask 的默认结构器初始化了二个对象，mWorker 和 mFuture。private final WorkerRunnable<Params, Result> mWorker;
private final FutureTask<Result> mFuture;
    mWorker = new WorkerRunnable<Params, Result>() {public Result call() throws Exception {mTaskInvoked.set(true);

            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
            //noinspection unchecked
            return postResult(doInBackground(mParams));
        }
    };

    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 occured while executing doInBackground()",
                        e.getCause());
            } catch (CancellationException e) {postResultIfNotInvoked(null);
            }
        }
    };

mWoker 实现了 Callback 接口，Callback 接口是 JDK1.5 退出的高级并发架包外面的一个接口，它能够有一个泛型返回值。public interface Callable<V> {
/**
 * 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 实现了 RunnableFuture 接口，RunnableFuture 接口是 JDK 提供的，看名称就晓得它继承了 Runnable 和 Future 接口，mFuture 是 FutureTask 的一个实例，能够间接被 Executor 类实例 execute。咱们来持续看 AsyncTask 的 execute 办法。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 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()办法，此时还在主线程(严格来说是调用 AsyncTask 执行的线程)，而后 exec.execute(mFuture)，把工作交给 exec 解决，execute mFuture 其实就是 invoke mWoker，而后调用 postResult(doInBackground(mParams))，此时曾经运行在工作线程池，不会阻塞主线程。而后给 mHandler 发送 MESSAGE_POST_RESULT 音讯，而后调用 finish 办法，如果 isCancelled，回调 onCancelled，否则回调 onPostExecute。private Result postResult(Result result) {@SuppressWarnings("unchecked")
    Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
            new AsyncTaskResult<Result>(this, result));
    message.sendToTarget();
    return result;
}
private static final InternalHandler sHandler = new InternalHandler();
private static class InternalHandler extends Handler {@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);
    }
    mStatus = Status.FINISHED;
}

当初其实咱们曾经把 AsyncTask 整个执行工作的过程走完了，其中裸露给咱们的那几个回调办法也都走到了。当初咱们回过头来看，AsyncTask 其实只是对 JDK 1.5 提供的高级并发个性，concurrent 架包做的一个封装，不便开发者来解决异步工作，当然外面还有很多细节解决的办法值得大家学习，如工作执行进度的反馈，工作执行原子性的保障等，这些留给大家本人学习了。应用 AsyncTask 一点小技巧
咱们以一个实例来阐明，“点击按钮开始下载 QQAndroid 安装包，而后显示一个对话框来反馈下载进度”。咱们先初始化一个对话框，因为要显示进度，咱们用 Github 下面一个可能显示百分比的进度条 NumberProgressbar，启动工作的按钮咱们应用 * circlebutton*，一个有酷炫动画的按钮，Github 下面有很多十分好的开源我的项目，当然炫酷的控件是其中一部分了，前面有机会，会去学习一些比拟风行的控件它们的实现原理，明天就暂且拿来主义了~~。1. 先初始化进度条提醒对话框。builder = new AlertDialog.Builder(MainActivity.this);
    LayoutInflater inflater = LayoutInflater.from(MainActivity.this);
    mDialogView = inflater.inflate(R.layout.progress_dialog_layout, null);
    mNumberProgressBar = (NumberProgressBar)mDialogView.findViewById(R.id.number_progress_bar);
    builder.setView(mDialogView);
    mDialog = builder.create();

*   2. 设置按钮点击事件。findViewById(R.id.circle_btn).setOnClickListener(new View.OnClickListener(){
    @Override
    public void onClick(View v) {dismissDialog();
    mNumberProgressBar.setProgress(0);
    myTask = new MyAsyncTask();
    myTask.execute(qqDownloadUrl);
    }
    });
3.DownloadAsyncTask 实现，有点长。private class DownloadAsyncTask extends AsyncTask<String , Integer, String> {

  @Override
  protected void onPreExecute() {super.onPreExecute();
      mDialog.show();}

  @Override
  protected void onPostExecute(String aVoid) {super.onPostExecute(aVoid);
      dismissDialog();}

  @Override
  protected void onProgressUpdate(Integer... values) {super.onProgressUpdate(values);

      mNumberProgressBar.setProgress(values[0]);
  }

  @Override
  protected void onCancelled(String aVoid) {super.onCancelled(aVoid);
      dismissDialog();}

  @Override
  protected void onCancelled() {super.onCancelled();
      dismissDialog();}

  @Override
  protected String doInBackground(String... params) {String urlStr = params[0];
      FileOutputStream output = null;
      try {URL url = new URL(urlStr);
          HttpURLConnection connection = (HttpURLConnection)url.openConnection();
          String qqApkFile = "qqApkFile";
          File file = new File(Environment.getExternalStorageDirectory() + "/" + qqApkFile);
          if (file.exists()) {file.delete();
          }
          file.createNewFile();
          InputStream input = connection.getInputStream();
          output = new FileOutputStream(file);
          int total = connection.getContentLength();
          if (total <= 0) {return null;}
          int plus = 0;
          int totalRead = 0;
          byte[] buffer = new byte[4*1024];
          while((plus = input.read(buffer)) != -1){output.write(buffer);
              totalRead += plus;
              publishProgress(totalRead * 100 / total);
              if (isCancelled()) {break;}
          }
          output.flush();} catch (MalformedURLException e) {e.printStackTrace();
          if (output != null) {
              try {output.close();
              } catch (IOException e2) {e2.printStackTrace();
              }
          }
      } catch (IOException e) {e.printStackTrace();
          if (output != null) {
              try {output.close();
              } catch (IOException e2) {e2.printStackTrace();
              }
          }
      } finally {if (output != null) {
              try {output.close();
              } catch (IOException e) {e.printStackTrace();
              }
          }
      }
      return null;
  }

```

}
这样一个简略的下载文件文件就根本实现了，到目前为止谈不上技巧，然而当初咱们有一个问题，就是如果咱们的 Activity 正在后盾执行一个工作，可能耗时较长，那用户可能会点击返回退出 Activity 或者退出 App，那么后台任务不会立刻退出，如果 AsyncTask 外部有 Activity 中成员变量的援用，还会造成 Activity 的回收延时，造成一段时间内的内存泄露，所以咱们须要加上上面的第四步解决。

• 4.onPause 中判断利用是否要退出，从而决定是否勾销 AsyncTask 执行。

  @Override
  protected void onPause() {super.onPause();
  if (myTask != null && isFinishing()) {myTask.cancel(false);
  }
  }

这样咱们的异步工作就会在 Activity 退出时，也随之勾销工作执行，顺利被零碎销毁回收，第四步很多时候会被脱漏，而且个别也不会有什么致命的问题，然而一旦出问题了，就很难排查，所以遵循编码标准还是有必要的。
小结
AsyncTask 的根本实现原理咱们曾经分明了，同时咱们也介绍了一个应用 AsyncTask 要留神的一个小技巧，心愿大家读完能有所播种

欢送大家一起交换探讨哈！