Android AsyncTask实现机制详细介绍及实例代码

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;
  }

 public interface executor {
    void execute(runnable command);
  }

 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);
      }
    }
  }

 /**
   * an {@link executor} that can be used to execute tasks in parallel.
   */
  public static final executor thread_pool_executor
      = new threadpoolexecutor(core_pool_size, maximum_pool_size, keep_alive,
          timeunit.seconds, spoolworkqueue, sthreadfactory);

  /**
   * an {@link executor} that executes tasks one at a time in serial
   * order. this serialization is global to a particular process.
   */
  public static final executor serial_executor = new serialexecutor();

  private static internalhandler shandler;

  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 result postresult(result result) {
    @suppresswarnings("unchecked")
    message message = gethandler().obtainmessage(message_post_result,
        new asynctaskresult<result>(this, result));
    message.sendtotarget();
    return result;
  }

 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);
    }
    mstatus = status.finished;
  }

 /**
   * runs on the ui thread after {@link #publishprogress} is invoked.
   * the specified values are the values passed to {@link #publishprogress}.
   *
   * @param values the values indicating progress.
   *
   * @see #publishprogress
   * @see #doinbackground
   */
  @suppresswarnings({"unuseddeclaration"})
  protected void onprogressupdate(progress... values) {
  }

 /**
   * override this method to perform a computation on a background thread. the
   * specified parameters are the parameters passed to {@link #execute}
   * by the caller of this task.
   *
   * this method can call {@link #publishprogress} to publish updates
   * on the ui thread.
   *
   * @param params the parameters of the task.
   *
   * @return a result, defined by the subclass of this task.
   *
   * @see #onpreexecute()
   * @see #onpostexecute
   * @see #publishprogress
   */
  protected abstract result doinbackground(params... params);

 protected final void publishprogress(progress... values) {
    if (!iscancelled()) {
      gethandler().obtainmessage(message_post_progress,
          new asynctaskresult<progress>(this, values)).sendtotarget();
    }
  }

  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;
      }
    }
  }