AsyncTask的使用及原理分析

使用的优点:

l  简单,快捷

l  过程可控       

使用的缺点:

l  在使用多个异步操作和并需要进行Ui变更时,就变得复杂起来。

AsyncTask定义了三种泛型类型 Params，Progress和Result。（也是可以指定为空的，如 AsyncTask <Void, Void, Void>）

一个异步加载数据最少要重写以下这两个方法：

• doInBackground(Params…) 后台执行，比较耗时的操作都可以放在这里。此方法在后台线程执行，完成任务的主要工作。在执行过程中可以调用publishProgress(Progress…)来更新任务的进度。其参数对应AsyncTask的第一个参数，publishProgress(Progress…)的参数对应AsyncTask的第二个参数，其返回值对应AsyncTask的第三个参数。
• onPostExecute(Result)  相当于Handler 处理UI的方式，在这里面可以使用在doInBackground 得到的返回结果操作UI。 此方法在主线程执行，任务执行的结果（doInBackground的返回值）作为此方法的参数。

当然了，还可以重写以下这三个方法，但不是必须的：

• onProgressUpdate(Progress…)   可以使用进度条增加用户体验度。 此方法在主线程执行，用于显示任务执行的进度。
• onPreExecute()        调用excute()方法时执行，当任务执行之前开始调用此方法。
• onCancelled()             用户调用取消（调用了cancel(true)）时，要做的操作。

使用AsyncTask类，以下是几条必须遵守的准则：

1、Task的实例必须在UI thread中创建；

2、execute方法必须在UI thread中调用；

3、不要手动的调用onPreExecute(), onPostExecute(Result)，doInBackground(Params...), onProgressUpdate(Progress...)这几个方法；

4、该task只能被执行一次，多次调用时将会出现异常；

执行的顺序是：onPreExecute()，doInBackground()，onProgressUpdate()，onPostExecute()。onCancelled()不一定会执行。

除了doInBackground是在子线程执行，其他的都是在UI线程执行的。

下面说下我们具体是怎么使用的：

第一步，创建一个异步任务的实例，并且执行，这里传入的参数对应的是AsyncTask的第一个参数：

MyTask mTask = new MyTask();  
mTask.execute(url);

private class MyTask extends AsyncTask<String, Integer, String> {
	//onPreExecute方法用于在执行后台任务前做一些UI操作  
	@Override  
	protected void onPreExecute() {
		textView.setText("start loading...");  
	}  
	  
	//doInBackground方法内部执行后台任务,不可在此方法内修改UI。这里传入的参数对应AsyncTask的第一个参数，即execute()函数传递过来的
	@Override  
	protected String doInBackground(String... params) {  
		... //做一些耗时的动作
		publishProgress(progresses); //progresses对应AsyncTask的第二个参数，同时也是要传给onProgressUpdate()的参数
		...
		return result; //返回值对应AsyncTask的第三个参数，同时也是要传给onPostExecute()的参数
	}  
	  
	//onProgressUpdate方法用于更新进度信息  
	@Override  
	protected void onProgressUpdate(Integer... progresses) {
		textView.setText("loading..." + progresses[0] + "%");  
	}  
	  
	//onPostExecute方法用于在执行完后台任务后更新UI,显示结果  
	@Override  
	protected void onPostExecute(String result) {
		textView.setText(result);  
	}  
	  
	//onCancelled方法用于在取消执行中的任务时更改UI  
	@Override  
	protected void onCancelled() {
		textView.setText("cancelled");
	}  
}

mTask.cancle(true);

public AsyncTask() {  
	mWorker = new WorkerRunnable<Params, Result>() {  
		public Result call() throws Exception {  
			mTaskInvoked.set(true);  
			Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);  
			return postResult(doInBackground(mParams));  
		}  
	};  
	mFuture = new FutureTask<Result>(mWorker) {  
		@Override  
		protected void done() {  
			...
		}  
	};  
}

public final AsyncTask<Params, Progress, Result> execute(Params... params) {  
    return executeOnExecutor(sDefaultExecutor, params);  
}

public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,  
        Params... params) {  
    ...
    mStatus = Status.RUNNING;  
    onPreExecute();  
    mWorker.mParams = params;  
    exec.execute(mFuture);  
    return this;  
}

public static final Executor SERIAL_EXECUTOR = new SerialExecutor();  
……  
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

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

void innerRun() {  
    if (!compareAndSetState(READY, RUNNING))  
        return;  
    runner = Thread.currentThread();  
    if (getState() == RUNNING) { // recheck after setting thread  
        V result;  
        try {  
            result = callable.call();  
        } catch (Throwable ex) {  
            setException(ex);  
            return;  
        }  
        set(result);  
    } else {  
        releaseShared(0); // cancel  
    }  
}

public Result call() throws Exception {  
	mTaskInvoked.set(true);  
	Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);  
	return postResult(doInBackground(mParams));  
}

private Result postResult(Result result) {  
    Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,  
            new AsyncTaskResult<Result>(this, result));  
    message.sendToTarget();  
    return result;  
}

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

protected final void publishProgress(Progress... values) {  
    if (!isCancelled()) {  
        sHandler.obtainMessage(MESSAGE_POST_PROGRESS,  
                new AsyncTaskResult<Progress>(this, values)).sendToTarget();  
    }  
}