AsyncTask

1.AsyncTask是什么

AsyncTask,是android提供的轻量级的异步类,可以直接继承AsyncTask,在类中实现异步操作,并提供接口反馈当前异步执行的程度(可以通过接口实现UI进度更新),最后反馈执行的结果给UI主线程.

AsyncTask是Android提供的一个助手类，它对Thread和Handler进行了封装，方便我们使用。Android之所以提供AsyncTask这个类，就是为了方便我们在后台线程中执行操作，然后将结果发送给主线程，从而在主线程中进行UI更新等操作。在使用AsyncTask时，我们无需关注Thread和Handler，AsyncTask内部会对其进行管理，这样我们就只需要关注于我们的业务逻辑即可。

2.AsyncTask怎么用

在Android中实现异步任务机制有两种方式，Handler和AsyncTask。

Handler模式需要为每一个任务创建一个新的线程，任务完成后通过Handler实例向UI线程发送消息，完成界面的更新，这种方式对于整个过程的控制比较精细，但也是有缺点的，例如代码相对臃肿，在多个任务同时执行时，不易对线程进行精确的控制。关于Handler的相关知识，前面也有所介绍，不清楚的朋友们可以参照一下。

为了简化操作，Android1.5提供了工具类android.os.AsyncTask，它使创建异步任务变得更加简单，不再需要编写任务线程和Handler实例即可完成相同的任务。

先来看看AsyncTask的定义：

[java]  view plain  copy

1. public abstract class AsyncTask<Params, Progress, Result> {    

三种泛型类型分别代表“启动任务执行的输入参数”、“后台任务执行的进度”、“后台计算结果的类型”。在特定场合下，并不是所有类型都被使用，如果没有被使用，可以用java.lang.Void类型代替。

一个异步任务的执行一般包括以下几个步骤：

1.execute(Params... params)，执行一个异步任务，需要我们在代码中调用此方法，触发异步任务的执行。

2.onPreExecute()，在execute(Params... params)被调用后立即执行，一般用来在执行后台任务前对UI做一些标记。

3.doInBackground(Params... params)，在onPreExecute()完成后立即执行，用于执行较为费时的操作，此方法将接收输入参数和返回计算结果。在执行过程中可以调用publishProgress(Progress... values)来更新进度信息。

4.onProgressUpdate(Progress... values)，在调用publishProgress(Progress... values)时，此方法被执行，直接将进度信息更新到UI组件上。

5.onPostExecute(Result result)，当后台操作结束时，此方法将会被调用，计算结果将做为参数传递到此方法中，直接将结果显示到UI组件上。

在使用的时候，有几点需要格外注意：

1.异步任务的实例必须在UI线程中创建。

2.execute(Params... params)方法必须在UI线程中调用。

3.不要手动调用onPreExecute()，doInBackground(Params... params)，onProgressUpdate(Progress... values)，onPostExecute(Result result)这几个方法。

4.不能在doInBackground(Params... params)中更改UI组件的信息。

5.一个任务实例只能执行一次，如果执行第二次将会抛出异常。

（以上内容转自：http://blog.csdn.net/liuhe688/article/details/6532519）

为了对该方法有更为深入的认识，下面以一个例子来说明。

该例子要实现的是进度条倒计时的功能。时长30s，随着时间的减少，进度条逐渐缩短，同时文本框中的剩余时间也相对应减少。

[java]  view plain  copy

1. import android.os.AsyncTask;  
2. import android.widget.ProgressBar;  
3. import android.widget.TextView;  
4.   
5. class TestAsyncTask extends AsyncTask<String, Integer, String>    
6. {    
7.     FullscreenActivity activity;    
8.     TextView textView;  
9.     ProgressBar bar;  
10.   
11.     public TestAsyncTask(FullscreenActivity activity, TextView textView, ProgressBar bar ) {  
12.         this.activity = activity;  
13.         this.textView = textView;  
14.         this.bar = bar;  
15.     }  
16.     //TestAsyncTask被后台线程执行后，被UI线程被调用，一般用于初始化界面控件，如进度条    
17.     @Override   
18.     protected void onPreExecute() {    
19.         // TODO Auto-generated method stub    
20.         super.onPreExecute();    
21.     }    
22.   
23.     //doInBackground执行完后由UI线程调用，用于更新界面操作    
24.     @Override   
25.     protected void onPostExecute(String result) {    
26.         // TODO Auto-generated method stub    
27.           
28.           
29.         //textView.setText(result);    
30.         super.onPostExecute(result);    
31.     }    
32.   
33.     //在PreExcute执行后被启动AysncTask的后台线程调用，将结果返回给UI线程    
34.     @Override   
35.     protected String doInBackground(String... params) {    
36.         // TODO Auto-generated method stub    
37.         bar.setMax(300);  
38.         int i = 30;  
39.         while(true)  
40.         {  
41.             publishProgress((int)i);  
42.             if(i == 0 ) break;  
43.             try {  
44.                 Thread.sleep(1000);  
45.             } catch (InterruptedException e) {  
46.                 // TODO Auto-generated catch block  
47.                 e.printStackTrace();  
48.             }  
49.             i--;  
50.               
51.         }  
52.         return null;    
53.     }  
54.     @Override  
55.     protected void onProgressUpdate(Integer... values) {  
56.         // TODO Auto-generated method stub  
57.         bar.setProgress(values[0]*10);    
58.         textView.setText("" + values[0] + " s");    
59.           
60.         super.onProgressUpdate(values);  
61.     }    
62.       
63.          
64. }    

在UI线程中：

[java]  view plain  copy

1. new TestAsyncTask(FullscreenActivity.this, textView, bar).execute("");  

3.需要实现的几个方法分别是什么、有什么用

AsyncTask有四个重要的回调方法，分别是：onPreExecute、doInBackground, onProgressUpdate 和 onPostExecute。

AsyncTask的执行分为四个步骤，每一步都对应一个回调方法，开发者需要实现这些方法。

　   1) 继承AsyncTask
　   2) 实现AsyncTask中定义的下面一个或几个方法
       * onPreExecute(), 该方法将在执行实际的后台操作前被UI 线程调用。可以在该方法中做一些准备工作，如在界面上显示一个进度条，或者一些控件的实例化，这个方法可以不用实现。
       * doInBackground(Params...), 将在onPreExecute 方法执行后马上执行，该方法运行在后台线程中。这里将主要负责执行那些很耗时的后台处理工作。可以调用 publishProgress方法来更新实时的任务进度。该方法是抽象方法，子类必须实现。
      * onProgressUpdate(Progress...),在publishProgress方法被调用后，UI 线程将调用这个方法从而在界面上展示任务的进展情况，例如通过一个进度条进行展示。
      * onPostExecute(Result), 在doInBackground 执行完成后，onPostExecute 方法将被UI 线程调用，后台的计算结果将通过该方法传递到UI 线程，并且在界面上展示给用户.

      * onCancelled(),在用户取消线程操作的时候调用。在主线程中调用onCancelled()的时候调用。

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

    　　1) Task的实例必须在UI 线程中创建

    　　2) execute方法必须在UI 线程中调用

    　　3) 不要手动的调用onPreExecute(), onPostExecute(Result)，doInBackground(Params...), onProgressUpdate(Progress...)这几个方法，需要在UI线程中实例化这个task来调用。

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

      doInBackground方法和onPostExecute的参数必须对应，这两个参数在AsyncTask声明的泛型参数列表中指定，第一个为doInBackground接受的参数，第二个为显示进度的参数，第第三个为doInBackground返回和onPostExecute传入的参数。

4.什么是泛型参数

Params 启动任务执行的输入参数，比如HTTP请求的URL。
Progress 后台任务执行的百分比。
Result 后台执行任务最终返回的结果，比如String。

5.什么是长度可变的参数列表

Java类型后面三个点(String…)，是从Java 5开始，Java语言对方法参数支持一种新写法，叫可变长度参数列表，其语法就是类型后跟…，表示此处接受的参数为0到多个Object类型的对象，或者是一个Object[]。

 public class test {
        public static void main(String[] args) {
            testVarchar("xy", "xy2", "xy3");
            testVarchar(new String[]{"xy", "xy2", "xy3"});
        }

        public static void testVarchar(String... strings) {
            for (int i = 0; i < strings.length; i++) {
                System.out.print(strings[i]);
            }
            System.out.print("\n");
        }
    }

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13

输出结果：

xyxy2xy3
xyxy2xy3

6.案例解析——倒计时Demo

布局文件soeasy：

 

?

1 2 3

<linearlayout android:layout_height= "match_parent" android:layout_width= "match_parent" android:orientation= "vertical" xmlns:android= "https://schemas.android.com/apk/res/android" xmlns:tools= "https://schemas.android.com/tools" >        <textview android:id= "@+id/tv" android:layout_gravity= "center_horizontal" android:layout_height= "32dp" android:layout_width= "wrap_content" android:textsize= "18sp" ><button android:layout_height= "wrap_content" android:layout_width= "match_parent" android:onclick= "start" android:text= "开始任务" ></button></textview></linearlayout>

接着活动代码：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64

package com.example.asynctask;   import android.app.Activity; import android.os.AsyncTask; import android.os.Bundle; import android.os.SystemClock; import android.view.View; import android.widget.TextView;   public class MainActivity extends Activity {        private TextView tv;        @Override      protected void onCreate(Bundle savedInstanceState) {          super .onCreate(savedInstanceState);          setContentView(R.layout.activity_main);          tv = (TextView) findViewById(R.id.tv);      }        public void start(View v) {          //@1:对应的参数是：1、doInBackground回调中的传入的参数类型；2、执行任务的参数类型          //@2:进度参数，与进度有关。onProgressUpdate的参数类型          //@3：1、doInBackground的返回值类型；2、执行结果onPostExecute传入的参数类型          new AsyncTask<integer, integer= "" >() {                            @Override              protected void onPreExecute() {                  // 准备执行前调用，用于界面初始化操作                                }                            @Override              protected Integer doInBackground(Integer... params) {                  // 子线程，耗时操作                  int start = params[ 0 ];                  int end = params[ 1 ];                                    int result = 0 ;                  for ( int i = end; i >= start; i--) {                      SystemClock.sleep( 20 );                      result = i;                      publishProgress(result); //把进度推出去，推给onProgressUpdate参数位置                  }                  return result;              }                            @Override              protected void onProgressUpdate(Integer[] values) {                  //主线程执行的回调，可更新进度。values为doInBackground调用publishProgress时候推过来的参数。这里每次推一个。因此数组长度就是0                  int progress = values[ 0 ];                  tv.setText(progress+ "" );              };                            @Override              protected void onPostExecute(Integer result) {                  // 执行完成的回调,即获得数据后的回调                  tv.setText(result+ "" );              }                        }.execute( 0 , 100 );      } } </integer,>

对于AsyncTask的详细分析，请关注《 Android 进阶》专栏介绍。上面的代码注释也很清晰，运行看看效果：