Android中使用Handler和AsyncTask进行异步操作

1.Handler

Handler相关说明：

主要接受子线程发送的数据, 并用此数据配合主线程更新UI。

解释：安卓的UI线程（即OnCreate函数创建的线程）是线程非安全的。也就是说，在UI线程中，使用sleep这样的函数会导致整个线程延迟，但是我们在安卓开发中，往往会经常遇到一些延迟比较厉害的操作，（例如通过HTTP获取数据信息）如果放在主线程中，则会影响UI界面的渲染。但是如果另外新开一个线程，则由于UI线程只能在主线程中修改，而导致无法修改主线程的UI界面。这个时候Handler就出来解决这个问题。Handler主要两大作用：

1. 提供post操作。post操作主要将Runnable对象放进主线程（UI）线程中的队列中操作。post还支持延迟操作。使用post后，Runnable是按照队列的形式逐个执行的。

2. handlerMessage操作。主要用于新开一个线程与主线程中的通信。新开的线程执行完毕后，可以通过handlerMessage给主线程发送消息，并且传递一些参数，然后主线程就可以修改UI界面了。

Handler是运行在UI主线程中的，由于不是在新的线程中使用，所以千万别做复杂的计算逻辑。

Handler提供的函数：

post类方法允许你排列一个Runnable对象到主线程队列中：

post(Runnable)

postAtTime(Runnable,long)

postDelayed(Runnable long)

sendMessage类方法, 允许你安排一个带数据的Message对象到队列中：

sendEmptyMessage(int)

sendMessage(Message)

 sendMessageAtTime(Message,long)

sendMessageDelayed(Message,long)

Handler post例子：

[java]  view plain copy print ?

1. package com.example.test.com;  
2.   
3.   
4. import android.annotation.SuppressLint;  
5. import android.app.Activity;  
6. import android.os.Bundle;  
7. import android.os.Handler;  
8. import android.os.Message;  
9. import android.util.Log;  
10. import android.view.View;  
11. import android.view.View.OnClickListener;  
12. import android.view.Window;  
13. import android.widget.Button;  
14. import android.widget.Toast;  
15.   
16. @SuppressLint("HandlerLeak")  
17. public class MainActivity extends Activity {  
18.   
19.     private Button    btn;  
20.   
21.     private MyHandler myHandler;  
22.   
23.     @Override  
24.     protected void onCreate(Bundle savedInstanceState) {  
25.         super.onCreate(savedInstanceState);  
26.         requestWindowFeature(Window.FEATURE_NO_TITLE);  
27.         setContentView(R.layout.activity_main);  
28.   
29.         //实例化一个自定义的Handler  
30.         myHandler = new MyHandler();  
31.         btn = (Button) findViewById(R.id.button1);  
32.         //图片点击的时候，启动动画效果    
33.         btn.setOnClickListener(new OnClickListener() {  
34.   
35.             @Override  
36.             public void onClick(View v) {  
37.                 Toast.makeText(getBaseContext(), "post start....",  
38.                         Toast.LENGTH_SHORT).show();  
39.                 //发送一个POST操作，将Runnable加入主线程队列  
40.                 //这个是在主线程中执行，并且延迟10秒钟延迟加载  
41.                 myHandler.postDelayed(new Runnable() {  
42.   
43.                     @Override  
44.                     public void run() {  
45.                         btn.setText("Hello Wolrd"); //修改Button文字   
46.                     }  
47.                 }, 10000);  
48.   
49.             }  
50.         });  
51.     }  
52.   
53.     /** 
54.      * 实现一个自定义的Handler 
55.      */  
56.     public class MyHandler extends Handler {  
57.   
58.         @Override  
59.         public void handleMessage(Message msg) {  
60.             Log.d("MyHandler", "handleMessage......");  
61.             super.handleMessage(msg);  
62.         }  
63.     }  
64.   
65. }  

Handler sendMessage例子：

[java]  view plain copy print ?

1. package com.example.test.com;  
2.   
3.   
4. import android.annotation.SuppressLint;  
5. import android.app.Activity;  
6. import android.os.Bundle;  
7. import android.os.Handler;  
8. import android.os.Message;  
9. import android.util.Log;  
10. import android.view.View;  
11. import android.view.View.OnClickListener;  
12. import android.view.Window;  
13. import android.widget.Button;  
14. import android.widget.Toast;  
15.   
16. @SuppressLint("HandlerLeak")  
17. public class MainActivity extends Activity {  
18.   
19.     private Button    btn;  
20.   
21.     private MyHandler myHandler;  
22.   
23.     @Override  
24.     protected void onCreate(Bundle savedInstanceState) {  
25.         super.onCreate(savedInstanceState);  
26.         requestWindowFeature(Window.FEATURE_NO_TITLE);  
27.         setContentView(R.layout.activity_main);  
28.   
29.         //实例化一个自定义的Handler  
30.         myHandler = new MyHandler();  
31.         btn = (Button) findViewById(R.id.button1);  
32.         //图片点击的时候，启动动画效果    
33.         btn.setOnClickListener(new OnClickListener() {  
34.   
35.             @Override  
36.             public void onClick(View v) {  
37.                 Toast.makeText(getBaseContext(), "new Thread start....",  
38.                         Toast.LENGTH_SHORT).show();  
39.                 //新开一个线程,如果新线程中修改UI界面，则直接程序崩溃  
40.                 new Thread(new Runnable() {  
41.   
42.                     @Override  
43.                     public void run() {  
44.                         try {  
45.                             Thread.sleep(10000); //线程sleep10秒  
46.                         } catch (Exception e) {  
47.   
48.                         }  
49.                         Message msg = new Message();  
50.                         Bundle bundle = new Bundle();  
51.                         bundle.putString("val", "Hello Handler");  
52.                         msg.setData(bundle);  
53.                         //这边只能记录日志  
54.                         Log.d("sendMessageDelayed", "send");  
55.                         //线程发送一个Message消息，MyHandler类中的handleMessage  
56.                         //会接收到数据，并且可以更新UI  
57.                         myHandler.sendMessageDelayed(msg, 5000);  
58.                         //myHandler.sendMessage(msg); //无延迟  
59.                     }  
60.                 }).start();  
61.   
62.             }  
63.         });  
64.     }  
65.   
66.     /** 
67.      * 实现一个自定义的Handler 
68.      */  
69.     public class MyHandler extends Handler {  
70.   
71.         @Override  
72.         public void handleMessage(Message msg) {  
73.             //接收msg  
74.             Toast.makeText(getBaseContext(), "getMessage....",  
75.                     Toast.LENGTH_SHORT).show();  
76.             super.handleMessage(msg);  
77.             Bundle bundle = msg.getData();  
78.             //修改UI界面  
79.             btn.setText(bundle.getString("val"));  
80.         }  
81.     }  
82.   
83. }  

公用的xml：

[html]  view plain copy print ?

1. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"  
2.     xmlns:tools="http://schemas.android.com/tools"  
3.     android:layout_width="match_parent"  
4.     android:layout_height="match_parent"  
5.     android:paddingBottom="@dimen/activity_vertical_margin"  
6.     android:paddingLeft="@dimen/activity_horizontal_margin"  
7.     android:paddingRight="@dimen/activity_horizontal_margin"  
8.     android:paddingTop="@dimen/activity_vertical_margin"  
9.     tools:context=".MainActivity" >  
10.   
11.     <!-- button -->  
12.   
13.     <Button  
14.         android:id="@+id/button1"  
15.         android:layout_width="wrap_content"  
16.         android:layout_height="wrap_content"  
17.         android:layout_alignParentLeft="true"  
18.         android:layout_alignParentTop="true"  
19.         android:layout_marginLeft="70dp"  
20.         android:layout_marginTop="116dp"  
21.         android:text="Button" />  
22.   
23. </RelativeLayout>  

2.AsyncTask

在开发Android应用时必须遵守单线程模型的原则： Android UI操作并不是线程安全的并且这些操作必须在UI线程中执行。在单线程模型中始终要记住两条法则： 
1. 不要阻塞UI线程 
2. 确保只在UI线程中访问Android UI工具包 
      当一个程序第一次启动时，Android会同时启动一个对应的主线程(Main Thread)，主线程主要负责处理与UI相关的事件，如：用户的按键事件，用户接触屏幕的事件以及屏幕绘图事件，并把相关的事件分发到对应的组件进行处理。所以主线程通常又被叫做UI线程。 
      比如说从网上获取一个网页，在一个TextView中将其源代码显示出来，这种涉及到网络操作的程序一般都是需要开一个线程完成网络访问，但是在获得页面源码后，是不能直接在网络操作线程中调用TextView.setText()的.因为其他线程中是不能直接访问主UI线程成员 。

android提供了几种在其他线程中访问UI线程的方法。 
Activity.runOnUiThread( Runnable ) 
View.post( Runnable ) 
View.postDelayed( Runnable, long ) 
Hanlder 
这些类或方法同样会使你的代码很复杂很难理解。然而当你需要实现一些很复杂的操作并需要频繁地更新UI时这会变得更糟糕。 

     为了解决这个问题，Android 1.5提供了一个工具类：AsyncTask，它使创建需要与用户界面交互的长时间运行的任务变得更简单。相对来说AsyncTask更轻量级一些，适用于简单的异步处理，不需要借助线程和Handler即可实现。 
AsyncTask是抽象类.AsyncTask定义了三种泛型类型 Params，Progress和Result。 
　　Params 启动任务执行的输入参数，比如HTTP请求的URL。 
　　Progress 后台任务执行的百分比。 
　　Result 后台执行任务最终返回的结果，比如String。 

     AsyncTask的执行分为四个步骤，每一步都对应一个回调方法，这些方法不应该由应用程序调用，开发者需要做的就是实现这些方法。 
　　1) 子类化AsyncTask 
　　2) 实现AsyncTask中定义的下面一个或几个方法 
　　   onPreExecute(), 该方法将在执行实际的后台操作前被UI thread调用。可以在该方法中做一些准备工作，如在界面上显示一个进度条。 
　　  doInBackground(Params...), 将在onPreExecute 方法执行后马上执行，该方法运行在后台线程中。这里将主要负责执行那些很耗时的后台计算工作。可以调用 publishProgress方法来更新实时的任务进度。该方法是抽象方法，子类必须实现。 
　　  onProgressUpdate(Progress...),在publishProgress方法被调用后，UI thread将调用这个方法从而在界面上展示任务的进展情况，例如通过一个进度条进行展示。 
　　  onPostExecute(Result), 在doInBackground 执行完成后，onPostExecute 方法将被UI thread调用，后台的计算结果将通过该方法传递到UI thread. 

为了正确的使用AsyncTask类，以下是几条必须遵守的准则： 
　　1) Task的实例必须在UI thread中创建 
　　2) execute方法必须在UI thread中调用 
　　3) 不要手动的调用onPreExecute(), onPostExecute(Result)，doInBackground(Params...), onProgressUpdate(Progress...)这几个方法
　　4) 该task只能被执行一次，否则多次调用时将会出现异常 
      doInBackground方法和onPostExecute的参数必须对应，这两个参数在AsyncTask声明的泛型参数列表中指定，第一个为doInBackground接受的参数，第二个为显示进度的参数，第第三个为doInBackground返回和onPostExecute传入的参数。

从网上获取一个网页，在一个TextView中将其源代码显示出来 

[java]  view plain copy print ?

1. package test.list;  
2. import java.io.ByteArrayOutputStream;  
3. import java.io.InputStream;  
4. import java.util.ArrayList;  
5.   
6. import org.apache.http.HttpEntity;  
7. import org.apache.http.HttpResponse;  
8. import org.apache.http.client.HttpClient;  
9. import org.apache.http.client.methods.HttpGet;  
10. import org.apache.http.impl.client.DefaultHttpClient;  
11.   
12. import android.app.Activity;  
13. import android.app.ProgressDialog;  
14. import android.content.Context;  
15. import android.content.DialogInterface;  
16. import android.os.AsyncTask;  
17. import android.os.Bundle;  
18. import android.os.Handler;  
19. import android.os.Message;  
20. import android.view.View;  
21. import android.widget.Button;  
22. import android.widget.EditText;  
23. import android.widget.TextView;  
24.   
25. public class NetworkActivity extends Activity{  
26.     private TextView message;  
27.     private Button open;  
28.     private EditText url;  
29.   
30.     @Override  
31.     public void onCreate(Bundle savedInstanceState) {  
32.        super.onCreate(savedInstanceState);  
33.        setContentView(R.layout.network);  
34.        message= (TextView) findViewById(R.id.message);  
35.        url= (EditText) findViewById(R.id.url);  
36.        open= (Button) findViewById(R.id.open);  
37.        open.setOnClickListener(new View.OnClickListener() {  
38.            public void onClick(View arg0) {  
39.               connect();  
40.            }  
41.        });  
42.   
43.     }  
44.   
45.     private void connect() {  
46.         PageTask task = new PageTask(this);  
47.         task.execute(url.getText().toString());  
48.     }  
49.   
50.   
51.     class PageTask extends AsyncTask<String, Integer, String> {  
52.         // 可变长的输入参数，与AsyncTask.exucute()对应  
53.         ProgressDialog pdialog;  
54.         public PageTask(Context context){  
55.             pdialog = new ProgressDialog(context, 0);     
56.             pdialog.setButton("cancel", new DialogInterface.OnClickListener() {  
57.              public void onClick(DialogInterface dialog, int i) {  
58.               dialog.cancel();  
59.              }  
60.             });  
61.             pdialog.setOnCancelListener(new DialogInterface.OnCancelListener() {  
62.              public void onCancel(DialogInterface dialog) {  
63.               finish();  
64.              }  
65.             });  
66.             pdialog.setCancelable(true);  
67.             pdialog.setMax(100);  
68.             pdialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);  
69.             pdialog.show();  
70.   
71.   
72.         }  
73.         @Override  
74.         protected String doInBackground(String... params) {  
75.   
76.             try{  
77.   
78.                HttpClient client = new DefaultHttpClient();  
79.                // params[0]代表连接的url  
80.                HttpGet get = new HttpGet(params[0]);  
81.                HttpResponse response = client.execute(get);  
82.                HttpEntity entity = response.getEntity();  
83.                long length = entity.getContentLength();  
84.                InputStream is = entity.getContent();  
85.                String s = null;  
86.                if(is != null) {  
87.                    ByteArrayOutputStream baos = new ByteArrayOutputStream();  
88.   
89.                    byte[] buf = new byte[128];  
90.   
91.                    int ch = -1;  
92.   
93.                    int count = 0;  
94.   
95.                    while((ch = is.read(buf)) != -1) {  
96.   
97.                       baos.write(buf, 0, ch);  
98.   
99.                       count += ch;  
100.   
101.                       if(length > 0) {  
102.                           // 如果知道响应的长度，调用publishProgress（）更新进度  
103.                           publishProgress((int) ((count / (float) length) * 100));  
104.                       }  
105.   
106.                       // 让线程休眠100ms  
107.                       Thread.sleep(100);  
108.                    }  
109.                    s = new String(baos.toByteArray());              }  
110.                // 返回结果  
111.                return s;  
112.             } catch(Exception e) {  
113.                e.printStackTrace();  
114.   
115.             }  
116.   
117.             return null;  
118.   
119.         }  
120.   
121.         @Override  
122.         protected void onCancelled() {  
123.             super.onCancelled();  
124.         }  
125.   
126.         @Override  
127.         protected void onPostExecute(String result) {  
128.             // 返回HTML页面的内容  
129.             message.setText(result);  
130.             pdialog.dismiss();   
131.         }  
132.   
133.         @Override  
134.         protected void onPreExecute() {  
135.             // 任务启动，可以在这里显示一个对话框，这里简单处理  
136.             message.setText(R.string.task_started);  
137.         }  
138.   
139.         @Override  
140.         protected void onProgressUpdate(Integer... values) {  
141.             // 更新进度  
142.               System.out.println(""+values[0]);  
143.               message.setText(""+values[0]);  
144.               pdialog.setProgress(values[0]);  
145.         }  
146.   
147.      }  
148.   
149. }  

3.动态加载分页实例

在android开发中，经常需要使用数据分页，比如要实现一个新闻列表的显示，或者博文列表的显示，不可能第一次加载就展示出全部，这就需要使用分页的方法来加载数据，在android中Handler经常用来在耗时的工作中，它接收子线程发送的数据，并使用数据配合更新UI,AsyncTask是在一个线程中执行耗时操作然后把结果传给UI线程，不需要你亲自去管理线程和句柄。
一、使用Handler+线程方法1、基础知识Handler在android系统中，主要负责发送和接收消息，它的用途主要有以下两种：
（1）按照计划来处理一个消息（sendMessage(Message)方法）或者执行某个runnable实例（post(Runnable)方法）（2）把其他的线程对象放入消息队列中，避免线程冲突。
   消息的发送通过post(Runnable), postAtTime(Runnable, long), postDelayed(Runnable, long), sendEmptyMessage(int),sendMessage(Message), sendMessageAtTime(Message, long)和 sendMessageDelayed(Message, long) 方法完成。对于postXXX方法通过Runnable对象给消息队列，并在消息队列到达后被调用。对于sendMessageXXX方法，则传递一个包含message对象，该对象可以被Handler类的handlerMessage（Message）方法处理。
2、主要代码public class HandlerDemo extends Activity implements OnScrollListener {

    private ListView mListView;
    LinearLayout loadingLayout;
    private Thread mThread;
    private ListViewAdapter adapter;

    private int startIndex = 1;// 从第1条开始
    private int size = 10;// 每次下载十条数据
    private List<News> newsList;
    List<Map<String, String>> data ;

    /*
   * 设置布局显示属性
   */
    private LayoutParams mLayoutParams = new LayoutParams(
            LinearLayout.LayoutParams.WRAP_CONTENT,
            LinearLayout.LayoutParams.WRAP_CONTENT);

    private LayoutParams ffLayoutParams = new LayoutParams(
            LinearLayout.LayoutParams.FILL_PARENT,
            LinearLayout.LayoutParams.FILL_PARENT);

    private ProgressBar progressBar;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
      // TODO Auto-generated method stub
      super.onCreate(savedInstanceState);
      setContentView(R.layout.news_main);
      data=new ArrayList<Map<String, String>>();
      addView();
    }

    private void addView() {
      if (startIndex == 1) {
            newsList = new ArrayList<News>();
            newsList = getNewsList();
      }
      getdata(newsList);
      LinearLayout layout = new LinearLayout(this);
      layout.setOrientation(LinearLayout.HORIZONTAL);
      progressBar = new ProgressBar(this);
      layout.addView(progressBar, mLayoutParams);
      TextView textView = new TextView(this);
      textView.setText("加载中...");
      textView.setGravity(Gravity.CENTER_VERTICAL);
      layout.addView(textView, ffLayoutParams);
      layout.setGravity(Gravity.CENTER);
      loadingLayout = new LinearLayout(this);
      loadingLayout.addView(layout, mLayoutParams);
      loadingLayout.setGravity(Gravity.CENTER);

      // 得到一个ListView用来显示条目
      mListView = (ListView) findViewById(R.id.listView);
      mListView.addFooterView(loadingLayout);
      adapter = new ListViewAdapter();
      mListView.setAdapter(adapter);
      mListView.setOnScrollListener(this);
      mListView.setTextFilterEnabled(true);
    }

    @Override
    public void onScroll(AbsListView view, int firstVisibleItem,
            int visibleItemCount, int totalItemCount) {
      // TODO Auto-generated method stub
      if (firstVisibleItem + visibleItemCount == totalItemCount) {
            if (mThread == null || !mThread.isAlive()) {
                mThread = new Thread() {

                  @Override
                  public void run() {
                        newsList = new ArrayList<News>();
                        newsList = getNewsList();
                        getdata(newsList);
                        Message msg = new Message();
                        msg.what = 1;
                        handler.sendMessage(msg);
                  }
                };
                mThread.run();
            }
      }
    }
   
    Handler handler = new Handler() {

      @Override
      public void handleMessage(Message msg) {
            // TODO Auto-generated method stub
            if (msg.what == 1) {
                startIndex = startIndex + size;
                Log.v("startindex", startIndex + "");
                mListView.removeFooterView(loadingLayout);
                mThread.stop();
                adapter.count += size;
                adapter.notifyDataSetChanged();
                return;
            }
      }
    };

    class ListViewAdapter extends BaseAdapter {
      int count = 10;

      @Override
      public int getCount() {
            // TODO Auto-generated method stub
            return count;
      }

      @Override
      public Object getItem(int position) {
            // TODO Auto-generated method stub
            return position;
      }

      @Override
      public long getItemId(int position) {
            // TODO Auto-generated method stub
            return position;
      }
         
      @Override
      public View getView(int position, View convertView, ViewGroup parent) {
            // TODO Auto-generated method stub
            convertView = LayoutInflater.from(getApplicationContext()).inflate(
                  R.layout.news_item, null);
            TextView textView = (TextView) convertView
                  .findViewById(R.id.textNewsTitle);
            textView.setText((data.get(position)).get("title"));
            return convertView;
      }
    }

    @Override
    public void onScrollStateChanged(AbsListView view, int scrollState) {
      // TODO Auto-generated method stub

    }

    private List<Map<String, String>> getdata(List<News> list) {

      if (list == null)
            return null;
      for (News news : list) {
            Map<String, String> map = new HashMap<String, String>();
            map.put("title", news.getTitle());
            data.add(map);
      }
      return data;
    }

    /*
   * 获取网络数据 注：我是访问本机的一个新闻服务，使用asp.net技术来实现的，等一段时间我打算写一个系列来总结次项目
   * 这个是项目是一个基于android的资讯播报软件
   */
    private List<News> getNewsList() {
      String path = "http://10.0.2.2/getNewsList.aspx";
      String xmlStr = "<?xml version='1.0' encoding='utf-8'?><source><categoryIds>1,3,7</categoryIds><startIndex>"
                + startIndex
                + "</startIndex><detail>2</detail><count>"
                + size
                + "</count></source>";
      NewsConnector newsConnector = new NewsConnector();
      List<News> list = new ArrayList<News>();
      list = newsConnector.getNewsList(path, xmlStr);
      return list;
    }
}3、小结ListView使用Handler+线程方式来动态加载数据的步骤如下：1.先初始化页面（如：加载第一页数据）2.在接收某个事件的消息之后（以上代码是onScroll事件），启动线程（线程完成下载数据，并发送消息给handler）3.handler接收到消息后更新界面，显示数据。
二、使用AsyncTask方法1、基础知识AsyncTask也是android提供的一个为了不能阻塞主线程的一个类，AsyncTask定义了三种泛型类型Params、Progress和Result，Params启动任务执行输入参数，比如http请求的url和参数，Progress后台执行任务的百分比，后台执行最终返回的结果。AsyncTask的执行分为四个步骤，每一步都对应都对应一个回调方法，开发者需要实现一个或者几个方法，在任务的执行过程中，这些方法会自动调用。onPreExecute()，在执行后台耗时操作前被调用，可以在执行此方法中做一些ui操作，比如显示一个进度条等 
doInBackground(Params...),这个方法在执行onPreExecute()后执行，这个方法完成耗时工作，比如下载等。 
onProgressUpdate(Progress...),UI线程通过此方法获取任务的完成的情况，比如完成的任务的百分比。 
onPostExecute(Result)，这个方法在耗时工作完成后被调用。UI线程调用此方法获取结果。注意：在使用AsyncTask类，有几条准则需要遵守(1)、Task的实例必须在UI线程中创建(2)、execute方法必须在UI线程中调用(3)、不要手动调用以上四个方法(4)、这个任务只执行一次（如果执行第二次将会抛出异常）2、主要代码@Override
    public void onScroll(AbsListView arg0, int arg1, int arg2, int arg3) {
      // TODO Auto-generated method stub
      if(arg1+arg2==arg3)
      {
            if(!isloading)
            {
                new myAsyncTask().execute(null);
            }
            else
            {
                mListView.removeFooterView(loadingLayout);
            }
      }
    }

    @Override
    public void onScrollStateChanged(AbsListView arg0, int arg1) {
      // TODO Auto-generated method stub
         
    }
   
    private class myAsyncTask extends AsyncTask<Void, Void, Void>
    {

      @Override
      protected Void doInBackground(Void... params) {
            // TODO Auto-generated method stub
             
            newsList = new ArrayList<News>();
            newsList = getNewsList();
            getdata(newsList);
            return null;
             
      }

      @Override
      protected void onPostExecute(Void result) {
            // TODO Auto-generated method stub
            super.onPostExecute(result);
            adapter.count+=size;
            adapter.notifyDataSetChanged();
            startIndex+=size;
            isloading=false;
      }

      @Override
      protected void onPreExecute() {
            // TODO Auto-generated method stub
            super.onPreExecute();
            isloading=true;
      }
         
    }注：以上仅是和使用Handler+线程方法不同的代码,建议了解详细代码3、小结ListView使用AsyncTask方法动态加载数据的方法如下：1.和handler一样初始化页面（如：加载第一页)2.在接收某个事件的消息之后（以上代码是onScroll事件），创建一个新的异步任务，并开始执行3.耗时工作完成后，开始更新UI
三、总结使用Handler+线程和使用AsyncTask方法进行ListView动态加载的比较   Handler+线程方式：在使用Handler方式时，它涉及Handler、Thread、Message、Looper四个对象，在执行的流程如下：主线程启动一个Thread，这个Thread执行耗时操作，耗时操作完成后，生成一个Message，Looper读取Message并传递给Hander，Handler接收Message并更新响应的UI。因为Looper在一个message处理完，才会读下一条，如果发生多个Message就会形成一个消息队列，所以它对多个后台操作比较清晰，明朗。但对于单个message来讲显得代码比较多，过于复杂。AsyncTask方式：AsyncTask继承自Object，是android提供的轻量级的异步类。并提供了一个方法来获取任务的执行进度（可以根据它来更新UI），最后会把结果返回在主线程。这个方式的比较简单，而且可以清楚的看到耗时任务执行的进度。但是对于多个异步操作同时进行，并更新UI变得比较复杂。
附件上截图