AsyncTask

• 内部实现主要是由Executor和Handler
• 一个应用中使用的所有的AsyncTask实例会共享全局的属性，也就是说如果AsynTask中的任务是串行执行，那么应用中所有的AsyncTask都会进行排队，只有等前面的任务执行完成之后，才会接着执行下一个AsyncTask中的任务；以下摘录部分源码可以看出很多static变量，是全局共享的，不管new多少个AsyncTask

  	public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
  
      private static final int MESSAGE_POST_RESULT = 0x1;
      private static final int MESSAGE_POST_PROGRESS = 0x2;
  
      private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
      private static InternalHandler sHandler;
  
      private final WorkerRunnable<Params, Result> mWorker;
      private final FutureTask<Result> mFuture;
  
      private volatile Status mStatus = Status.PENDING;
  
      private final AtomicBoolean mCancelled = new AtomicBoolean();
      private final AtomicBoolean mTaskInvoked = new AtomicBoolean();
  
      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);
              }
          }
      }
  
      /**
       * Indicates the current status of the task. Each status will be set only once
       * during the lifetime of a task.
       */
      public enum Status {
          /**
           * Indicates that the task has not been executed yet.
           */
          PENDING,
          /**
           * Indicates that the task is running.
           */
          RUNNING,
          /**
           * Indicates that {@link AsyncTask#onPostExecute} has finished.
           */
          FINISHED,
      }
  
      private static Handler getHandler() {
          synchronized (AsyncTask.class) {
              if (sHandler == null) {
                  sHandler = new InternalHandler();
              }
              return sHandler;
          }
      }
  
      /** @hide */
      public static void setDefaultExecutor(Executor exec) {
          sDefaultExecutor = exec;
      }
  
      /**
       * Creates a new asynchronous task. This constructor must be invoked on the UI thread.
       */
      public AsyncTask() {
          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);
                  }
              }
          };
      }
  
      private void postResultIfNotInvoked(Result result) {
          final boolean wasTaskInvoked = mTaskInvoked.get();
          if (!wasTaskInvoked) {
              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;
      }
  

  　　

• 如果执行的任务需要并行执行的话，调用executeExecutor()代替execute