AsyncTask详解

具体看如下分析和代码：

启动异步处理工作（下面两句代码需要在主线程里执行）：

UpdateTask  task = new UpdateTask();

task.execute(“liming”,“zhangxx”); //这里输入的参数会传给doInBackground()方法

停止异步处理工作：

if (task != null && task.getStatus() == AsyncTask.Status.RUNNING) {

  task.cancel(true);//如果Task还在运行，则先取消它

  task = null;

}

public class UpdateTask extends AsyncTask<String, Integer, String> {
	protected void onPreExecute() {
		progressBar.setMax(100);
	}

	protected String doInBackground(String... params) {
		for (int i = 0; i < 100; i++) {
			this.publishProgress(i + 1);
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			if (isCancelled())
				return null;
		}
		return "itcast";
	}

	protected void onPostExecute(String result) {
		Toast.makeText(getApplicationContext(), "结果 ：" + result, 1).show();
	}

	protected void onProgressUpdate(Integer... values) {
		progressBar.setProgress(values[0]);
	}
}

AsyncTask类的三个泛型参数：

第一个指定了doInBackground() 方法输入参数的类型；

第二个指定了onProgressUpdate()方法输入参数的类型； 

第三个指定了onPostExecute()方法输入参数的类型和doInBackground() 方法返回值的类型

这三个泛型参数的类型是根据你自己的业务需求来指定的。

onPreExecute()： 该方法在UI线程运行，当AsyncTask的execute()方法执行后，onPreExecute()会首先执行。可以在该方法中做一些准备工作，如初始化进度条的最大值。

doInBackground(Params...)： 将在onPreExecute()方法执行后马上执行，该方法运行在子线程中，负责执行耗时操作。在执行耗时操作的过程中你可以不断地调用publishProgress()方法，导致onProgressUpdate()不断地被调用。 

onProgressUpdate(Progress...)，调用publishProgress()方法，就会导致该方法被执行，该方法运行在UI线程，例如在该方法中你可以更新进度条的显示。 

onPostExecute(Result)：doInBackground()方法执行后的返回结果会传给该方法，该方法运行在UI线程，在该方法中你可以显示处理结果。

下面是我补充的一个实例：
动态的去更新UI上的一个TextView的内容，当然在实际应用开发中场景会复杂多了。

public class MainActivity extends Activity {
	private TextView tv_str;
	private myAsyncTask mAsyncTask;

	/** Called when the activity is first created. */
	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
		tv_str = (TextView) findViewById(R.id.tv_str);
		mAsyncTask = new myAsyncTask();
		mAsyncTask.execute();// 这里可以传递任意参数进去给异步任务去处理
	}

	private final class myAsyncTask extends AsyncTask<String, String, String> {
		// StringBuilder str = new StringBuilder();

		String str = "";

		@Override
		protected String doInBackground(String... params) {

			try {
				for (int i = 0; i < 100; i++) {
					Thread.sleep(200);
					str = String.valueOf(i);
					// 通知onProgressUpdate这个方法去执行，并且把参数传递过去
					this.publishProgress(i + "");
				}
				return str.toString();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}

			return null;
		}

		// 这个方法是只要this.publishProgress(str.toString());这个方法执行一次，
		//它就会执行一次，但是日志输出的时候怎么是方法的累加呢？
		@Override
		protected void onProgressUpdate(String... values) {
			super.onProgressUpdate(values);
			tv_str.setText(values[0]);
			Log.i("onProgressUpdate method", "onProgressUpdate method" + values[0]);
		}

		// 这个方法不是实时去更新UI的，而是等待doInBackground中的循环走完后再去一下子更新UI的
		@Override
		protected void onPostExecute(String result) {
			super.onPostExecute(result);
			Log.i("onPostExecute(String result)", result);
			// tv_str.setText(result);
		}
	}
}