【Android 开发】: AsyncTask 详解

  在Androidy应用开发中，整个架构的性能好坏很大一部分都体现在线程的操作中，所以这是Android开发中是一块很重要的内容，对于线程，多线程这一部分的基础内容，我们可以参考本博客前期中Java多线程的内容：JavaSE第九十七讲：线程与进程 在这一讲中我们主要学习Android中关于AsyncTask的学习以及相关Demo的实现。

一. 使用 AsyncTask 目的

  官网位置：Android ---> API Guides ---> Processes and Threads --->  Using AsyncTask

  异步任务允许你在用户接口上执行异步工作。它会在自己的工作线程上执行可能阻塞的操作然后将结果推送到UI主线程,而不会让你自己去处理线程的操作。(在Android3.0以上的版本中，为了使得Android UI能够更加流畅，它不允许用户在UI的主线程中访问网络，所以会强制用户开辟一个子线程，在这个线程中完成下载耗时的操作(比如从网络中下载一张图片)，此时UI的主线程与下载的子线程是存在一个异步的过程，一旦子线程中下载图片完成，就要把结果推送到UI上.)
  使用方法：继承AsyncTask类，实现 doInBackground() 回调接口，这样就运行在后台的线程池中，如果你想更新你的UI，你可以实现onPostExecute()放，它可以讲doInBackground()方法中的结果运行在 UI主线程中，所以你可以安全的更新你的UI.你可以在UI主线程中通过execute()方法来执行你的异步任务。
  如下代码片段：

二. AsyncTask 介绍

  AsyncTask其实就是一个线程操作的框架，它也是android围绕这 Thread 和 Handler来设计的。它可以直接的被一些短时间的操作使用(通常是几秒),如果你想要保持线程运行很长时间，强烈建议你使用java.util.concurrent包下的Executor, ThreadPoolExecutor 和 FutureTask 这些类来实现.
  一个异步任务是在跑在后台线程中进行计算然后把结果推送到UI主线程中的。它是由三个泛型类型和四个回调方法来实现的。

1 三个泛型类型

1)Params: 启动任务执行的输入参数，比如HTTP请求的URL。
2) Progress: 后台任务执行的百分比会发布到UI主线程中。
3) Result: 后台执行任务最终返回的结果，比如String,Integer等

【注意】如果三个泛型都没有类型，我们就用void代替，如下所所示(注意类型是Void是大写的)

 private class MyTask extends AsyncTask<Void, Void, Void> {}

2 四个回调方法

1) onPreExecute(): 在任务执行之前在UI主线程中被调用的。这个通常是用来做任务的准备，比如获得一个显示进度条的实例等。

2) doInBackground(Params...): onPreExecute()执行完成后马上被后台的进程中调用，用来处理耗时的操作，异步任务的输入参数也会传递到这里。计算得到结果会通过后面的执行方法(onPostExecute()方法)推送到UI主线程中。这个步骤还可以使用使用 publishProgress(Progress...) 来显示进度刻度。这些刻度会在UI主线程中实时显示通过onProgressUpdate(Progress...)方法.

3) onProgressUpdate(Progress...): publishProgress(Progress...)方法执行之后会被UI主线程调用，用来在UI主线程中实时显示计算刻度。

4) onPostExecute(Result): 在后台计算完成之后被UI主线程调用。doInBackground()方法返回的结果会作为它的一个参数来推送到UI主线程中。

3. AsyncTask的取消

  异步任务可以在任意时间调用cancel(boolean)来取消，调用这个方法之后会造成后续的isCancelled()方法都是返回true,取消之后在执行完doInBackground(Object[])后onCancelled(Object)方法会代替onPostExecute(Object)方法被执行。为了确保能够尽快的取消一个任务，我们应该在doInBackground(Object[])里面周期性的检查isCancelled()的返回值(例如在一个循环里面)。

4. AsyncTask的注意事项

1) AsyncTask 类必须在UI主线程中被加载,这点在 Android4.1 上已经帮我们自动完成
2) 任务类的实例(即new出一个继承AsyncTask类，作为匿名内部类的实例)必须在UI主线程中创建.
3) execute(Params...) 必须在UI主线程中被调用.
4) 不要手动的去调用 onPreExecute(), onPostExecute(Result), doInBackground(Params...),  onProgressUpdate(Progress...)这些方法.
5) 任务只能被执行一次(如果有第二次执行会抛出一个异常)

三、 程序Demo

1. Manifest.xml文件中添加网络授权

[html] view plaincopy

1. <uses-permission android:name="android.permission.INTERNET"/>  

2. 布局文件，主要是定义一个Button和ImageView,这里就不贴出来,读者可以自己下载源码查看

3. MainActivity.java

[java] view plaincopy

1. package com.android.asynctasktest;  
2.   
3. import java.io.IOException;  
4.   
5. import org.apache.http.HttpEntity;  
6. import org.apache.http.HttpResponse;  
7. import org.apache.http.client.ClientProtocolException;  
8. import org.apache.http.client.HttpClient;  
9. import org.apache.http.client.methods.HttpGet;  
10. import org.apache.http.impl.client.DefaultHttpClient;  
11. import org.apache.http.util.EntityUtils;  
12.   
13. import android.os.AsyncTask;  
14. import android.os.Bundle;  
15. import android.app.Activity;  
16. import android.app.ProgressDialog;  
17. import android.graphics.Bitmap;  
18. import android.graphics.BitmapFactory;  
19. import android.view.Menu;  
20. import android.view.View;  
21. import android.widget.Button;  
22. import android.widget.ImageView;  
23.   
24. /** 
25.  * 使用异步任务从服务器上下载网络图片 
26.  * @author AHuier 
27.  * 
28.  */  
29. public class MainActivity extends Activity {  
30.   
31.     private Button btn;  
32.     private ImageView img;  
33.     private String imgPath = "http://f.hiphotos.baidu.com/image/w%3D2048/sign=05793c21bba1cd1105b675208d2ac9fc/43a7d933c895d14350ee3c3272f082025aaf0703.jpg";  
34.     private ProgressDialog dialog;  
35.       
36.     @Override  
37.     protected void onCreate(Bundle savedInstanceState) {  
38.         super.onCreate(savedInstanceState);  
39.         setContentView(R.layout.activity_main);  
40.         initComponent();  
41.         dialog = new ProgressDialog(this);  
42.         dialog.setTitle("提示信息");  
43.         dialog.setMessage("正在下载,请稍后...");  
44.         btn.setOnClickListener(new View.OnClickListener() {  
45.               
46.             @Override  
47.             public void onClick(View v) {  
48.                 // 执行异步任务的操作,这个必须写在UI主线程中,由UI主线程去操作  
49.                 new MyTask().execute(imgPath);  
50.             }  
51.         });  
52.     }  
53.   
54.     /** 
55.      * 使用异步任务的规则： 
56.      * 1. 声明一个类继承AsyncTask, 指定好三个泛型的参数 
57.      * 2. 第一个参数：启动任务执行的输入参数，比如HTTP请求的URL 
58.      *    第二个参数：后台任务执行的百分比会发布到UI主线程中 
59.      *    第三个参数：后台执行任务最终返回的结果，比如String,Integer等 
60.      * 3. 小技巧 
61.      *    这边写异步任务的时候先指定后三个参数在去实现对应的方法，这样Eclipse会自动生成与我们参数类型相匹配的返回类型的方法。 
62.      * @author AHuier 
63.      * 
64.      */  
65.     public class MyTask extends AsyncTask<String, Void, Bitmap>{  
66.   
67.         // 任务执行之前的准备工作  
68.         @Override  
69.         protected void onPreExecute() {  
70.             // TODO Auto-generated method stub  
71.             super.onPreExecute();  
72.             dialog.show();  
73.         }  
74.           
75.         // 完成耗时操作，将结果推送到onPostExecute()方法中  
76.         // String... params ： 表示可以传递多个String类型的参数，我们只取一个所以用params[0]  
77.         @Override  
78.         protected Bitmap doInBackground(String... params) {  
79.             // TODO Auto-generated method stub  
80.             // 使用网络链接类 HttpClient 类完成对网络数据的提取  
81.             HttpClient httpClient = new DefaultHttpClient();  
82.             HttpGet httpGet = new HttpGet(params[0]);  
83.             Bitmap bitmap = null;  
84.             try {  
85.                 HttpResponse httpResponse = httpClient.execute(httpGet);  
86.                 if(httpResponse.getStatusLine().getStatusCode() == 200){  
87.                     HttpEntity httpEntity = httpResponse.getEntity(); // 取出Http协议实体  
88.                     byte[] data = EntityUtils.toByteArray(httpEntity); //转换成字节数组  
89.                     // 字节数组转换成Bitmap对象  
90.                     bitmap = BitmapFactory.decodeByteArray(data, 0, data.length);  
91.                 }  
92.             } catch (ClientProtocolException e) {  
93.                 // TODO Auto-generated catch block  
94.                 e.printStackTrace();  
95.             } catch (IOException e) {  
96.                 // TODO Auto-generated catch block  
97.                 e.printStackTrace();  
98.             }  
99.             // 返回bitmap对象,最终会作为参数到onPostExecute()方法中，用这个方法将其推送到UI主线程中。  
100.             return bitmap;  
101.         }  
102.   
103.         @Override  
104.         protected void onProgressUpdate(Void... values) {  
105.             // TODO Auto-generated method stub  
106.             super.onProgressUpdate(values);  
107.         }  
108.           
109.         // 更新UI线程  
110.         @Override  
111.         protected void onPostExecute(Bitmap result) {  
112.             // TODO Auto-generated method stub  
113.             super.onPostExecute(result);  
114.             img.setImageBitmap(result);  
115.             dialog.dismiss();  
116.         }  
117.     }  
118.       
119.     @Override  
120.     public boolean onCreateOptionsMenu(Menu menu) {  
121.         // Inflate the menu; this adds items to the action bar if it is present.  
122.         getMenuInflater().inflate(R.menu.main, menu);  
123.         return true;  
124.     }  
125.       
126.     private void initComponent(){  
127.         btn = (Button)findViewById(R.id.button1);  
128.         img = (ImageView)findViewById(R.id.imageView1);  
129.     }  
130.   
131. }  

4. 程序执行结果

   点击Button从网络中下载图片

   

四、使用带有刻度的进度条来完善上述功能

  在上一讲中我们实现了点击按钮在不阻塞UI主线程的情况下从网络中获取一张图片，并且显示出来。我们主要的操作是使用延时框，这一讲我们讲一下如何使用异步任务给它添加一下带有下载进度的刻度条。

1. 修改上面 MainActivity.java 中 onCreate()方法：

[java] view plaincopy

1. @Override  
2. protected void onCreate(Bundle savedInstanceState) {  
3.     super.onCreate(savedInstanceState);  
4.     setContentView(R.layout.activity_main);  
5.     initComponent();  
6.     dialog = new ProgressDialog(this);  
7.     dialog.setTitle("提示信息");  
8.     dialog.setMessage("正在下载,请稍后...");  
9.     // 设置进度条对话框的样式  
10.     dialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);  
11.     btn.setOnClickListener(new View.OnClickListener() {  
12.           
13.         @Override  
14.         public void onClick(View v) {  
15.             // 执行异步任务的操作,这个必须写在UI主线程中,由UI主线程去操作  
16.             new MyTask().execute(imgPath);  
17.         }  
18.     });  
19. }  

[java] view plaincopy

1. <span style="font-family:Courier New;"> </span>   public class MyTask extends AsyncTask<String, Integer, Bitmap>{  
2.   
3.         // 任务执行之前的准备工作  
4.         @Override  
5.         protected void onPreExecute() {  
6.             // TODO Auto-generated method stub  
7.             super.onPreExecute();  
8.             dialog.show();  
9.         }  
10.           
11.         // 完成耗时操作，将结果推送到onPostExecute()方法中  
12.         // String... params ： 表示可以传递多个String类型的参数，我们只取一个所以用params[0]  
13.         @Override  
14.         protected Bitmap doInBackground(String... params) {  
15.             // 完成图片的下载功能  
16.             Bitmap bitmap = null;  
17.             ByteArrayOutputStream outputStream = new ByteArrayOutputStream();  
18.             InputStream inputStream = null;  
19.             try {  
20.                 HttpClient httpClient = new DefaultHttpClient();  
21.                 HttpGet httpGet = new HttpGet(params[0]);  
22.                 HttpResponse httpResponse = httpClient.execute(httpGet);  
23.                 if(200 == httpResponse.getStatusLine().getStatusCode()){  
24.                     inputStream = httpResponse.getEntity().getContent();  
25.                     // 先要获得文件的总长度  
26.                     long file_length = httpResponse.getEntity().getContentLength();  
27.                     // 每次读取字节的长度  
28.                     int len = 0;  
29.                     // 读取字节长度的总和  
30.                     int total_length = 0;  
31.                     byte[] data = new byte[1024];  
32.                     while(-1 != (len = inputStream.read(data))){  
33.                         total_length += len; //每次下载的长度进行叠加  
34.                         /* 
35.                          * 计算机每次下载完的部分占全部文件长度的百分比。  
36.                          * 计算公式如下：(int)((i/(float)count) * 100)  
37.                          * 得到的结果就是它的刻度值了 
38.                          */  
39.                         int value = (int)((total_length / (float)file_length) * 100);  
40.                         // 使用 publishProgress(value)方法把刻度发布出去，它会发布到 onProgressUpdate()方法中  
41.                         publishProgress(value);  
42.                         outputStream.write(data, 0, len);  
43.                     }  
44.                     // outputStream 有一个特性，它可以将流里面的数据转换成一个字节数组,通过字节数据我们可以转换成Bitmap图像  
45.                     byte[] result = outputStream.toByteArray();  
46.                     // 将字节数组流转换成Bitmap的图片格式  
47.                     bitmap = BitmapFactory.decodeByteArray(result, 0, result.length);    
48.                 }  
49.             } catch (Exception e) {  
50.                 // TODO: handle exception  
51.             } finally{  
52.                 // outputStream 是特殊的流，它作用在内存中可以不用关闭，这一点我们之前有讲过.  
53.                 if(inputStream != null){  
54.                     try {  
55.                         inputStream.close();  
56.                     } catch (IOException e) {  
57.                         // TODO Auto-generated catch block  
58.                         e.printStackTrace();  
59.                     }  
60.                 }  
61.             }  
62.             return bitmap;  
63.         }  
64.   
65.         @Override  
66.         protected void onProgressUpdate(Integer... values) {  
67.             // TODO Auto-generated method stub  
68.             super.onProgressUpdate(values);  
69.             dialog.setProgress(values[0]);  
70.         }  
71.           
72.         // 更新UI线程  
73.         @Override  
74.         protected void onPostExecute(Bitmap result) {  
75.             // TODO Auto-generated method stub  
76.             super.onPostExecute(result);  
77.             img.setImageBitmap(result);  
78.             dialog.dismiss();  
79.         }  
80.     }  

2. 程序执行结果如下所示：

   

【备注】：使用异步任务的好处是用户不需要再去开启线程，去做一些线程里面方法的顺序操作。而 AsyncTask 其实就是一个线程框架，它已经为我们封装好了。

程序Demo源码：http://download.csdn.net/my 

[2013.11.27更新]-------------------------------------------------

1. 查看上述两种通过Http协议获取网络数据的方式。

1) 通过输入流来转换成byte[] 然后在利用字节数组流转换成Bitmap. 这也是比较笨的方式,如上述中的第二个Demo。

2) 直接通过 org.apache.http.util.EntityUtils方式获得byte[]然后转换成字节数组流,如上诉第一个Demo

[java] view plaincopy

1. HttpEntity httpEntity = httpResponse.getEntity(); // 取出Http协议实体  
2. byte[] data = EntityUtils.toByteArray(httpEntity); //转换成字节数组  

这一点读者可以注意一下。