AsyncTask封装了Thread和Handler，是一种轻量级的异步任务类。
参数
class MyAsyncTask extends AsyncTask
Params：执行execute时需要传入的参数，可以是Void。
Progress：更新进度时用到的类型。
Result：任务执行完成后返回的结果类型。
核心方法
doInBackground：异步执行后台线程需要完成的任务。
onPreExecute：执行后台耗时操作前被调用，通常进行初始化操作。
onPostExecute：doInBackground执行完成后调用的方法。
onProgressUpdate：doInBackground中调用publishProgress会执行该方法，用于更新进度。
onCancelled：异步任务被取消时执行该方法。
doInBackground在线程池中执行，其余方法均在主线程中执行，可以直接更新UI。
基本用法
class MyAsyncTask extends AsyncTask {
@Override
protected void onPreExecute() {
super.onPreExecute();
progressBar.setMax(100);
bt_start.setText("开始下载");
}
@Override
protected String doInBackground(String... strings) {
for (int i = 0; i < 101; i++) {
if (isCancelled()) {
break;
}
publishProgress(i);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
return null;
}
@Override
protected void onProgressUpdate(Integer... values) {
super.onProgressUpdate(values);
if (isCancelled()) {
return;
}
progressBar.setProgress(values[0]);
}
@Override
protected void onPostExecute(String s) {
super.onPostExecute(s);
bt_start.setText("下载完成");
}
@Override
protected void onCancelled() {
super.onCancelled();
}
}
启动方式
myAsyncTask = new MyAsyncTask();
myAsyncTask.execute("downLoadUrl");
从Android3.0开始，默认情况下AsyncTask是串行执行的，要想并行执行，可以尝试下面方法
myAsyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"downLoadUrl");
源码初探
@MainThread
public final AsyncTask execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
@MainThread
public 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;
}
当执行execute方法时，可以看到调用了executeOnExecutor，并加入了默认的sDefaultExecutor。也可以看到，当重复执行时就会抛出异常。
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
Executor是一个接口，百度翻译是执行者，就是用来执行提交的任务的。
所以不管调用AsyncTask.execute(Params),
还是调用AsyncTask.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR,Params),
效果是一样的，用的都是默认的Executor，即sDefaultExecutor。
public static final Executor SERIAL_EXECUTOR = new 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);
}
}
}
ArrayDeque采用循环数组实现，mTasks为要执行的任务队列，从SerialExecutor可以看出，当调用AsyncTask.execute(Params)或者调用AsyncTask.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR,Params),并不是立即执行任务，而是通过mTasks.offer方法向队尾插入了执行任务，只有当scheduleNext方法取到它时，才会通过THREAD_POOL_EXECUTOR执行，mTasks.poll为获取并删除队首任务，所以通过这两种方法执行的都是串行任务。
等等
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);
threadPoolExecutor.allowCoreThreadTimeOut(true);
THREAD_POOL_EXECUTOR = threadPoolExecutor;
}
ThreadPoolExecutor是一个线程池，用来执行提交的任务，所以当参数设置为THREAD_POOL_EXECUTOR时，没有一系列的添加队列操作，而是在executeOnExecutor方法中直接执行，所以这种方法执行任务是并行的。
注意事项
AsyncTask对象必须在主线程创建，execute方法也必须在主线程调用，且execute只能调用一次。
取消任务
myAsyncTask.cancel(true);
调用cancel方法取消任务是否可以有效的取消当前任务？cancel掉当前任务后，此时新建AsyncTask对象并执行，发现会有短暂的停顿后才会执行新建的任务，因为cancel只是改变了任务的状态，并没有真正的停止任务，cancel掉的任务在队列中执行完成后才会执行新创建的任务。所以，要在doInBackground中进行isCancelled判断，如果为true，则直接跳出，避免资源、时间的浪费。
最后
有什么解释不对还望各位大神指正