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例子：

 package com.example.test.com;


 import android.annotation.SuppressLint;
 import android.app.Activity;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.Message;
 import android.util.Log;
 import android.view.View;
 import android.view.View.OnClickListener;
 import android.view.Window;
 import android.widget.Button;
 import android.widget.Toast;

 @SuppressLint("HandlerLeak")
 public class MainActivity extends Activity {

     private Button    btn;

     private MyHandler myHandler;

     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         requestWindowFeature(Window.FEATURE_NO_TITLE);
         setContentView(R.layout.activity_main);

         //实例化一个自定义的Handler
         myHandler = new MyHandler();
         btn = (Button) findViewById(R.id.button1);
         //图片点击的时候，启动动画效果
         btn.setOnClickListener(new OnClickListener() {

             @Override
             public void onClick(View v) {
                 Toast.makeText(getBaseContext(), "post start....",
                         Toast.LENGTH_SHORT).show();
                 //发送一个POST操作，将Runnable加入主线程队列
                 //这个是在主线程中执行，并且延迟10秒钟延迟加载
                 myHandler.postDelayed(new Runnable() {

                     @Override
                     public void run() {
                         btn.setText("Hello Wolrd"); //修改Button文字
                     }
                 }, 10000);

             }
         });
     }

     /**
      * 实现一个自定义的Handler
      */
     public class MyHandler extends Handler {

         @Override
         public void handleMessage(Message msg) {
             Log.d("MyHandler", "handleMessage......");
             super.handleMessage(msg);
         }
     }

 }

Handler sendMessage例子：

 package com.example.test.com;


 import android.annotation.SuppressLint;
 import android.app.Activity;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.Message;
 import android.util.Log;
 import android.view.View;
 import android.view.View.OnClickListener;
 import android.view.Window;
 import android.widget.Button;
 import android.widget.Toast;

 @SuppressLint("HandlerLeak")
 public class MainActivity extends Activity {

     private Button    btn;

     private MyHandler myHandler;

     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         requestWindowFeature(Window.FEATURE_NO_TITLE);
         setContentView(R.layout.activity_main);

         //实例化一个自定义的Handler
         myHandler = new MyHandler();
         btn = (Button) findViewById(R.id.button1);
         //图片点击的时候，启动动画效果
         btn.setOnClickListener(new OnClickListener() {

             @Override
             public void onClick(View v) {
                 Toast.makeText(getBaseContext(), "new Thread start....",
                         Toast.LENGTH_SHORT).show();
                 //新开一个线程,如果新线程中修改UI界面，则直接程序崩溃
                 new Thread(new Runnable() {

                     @Override
                     public void run() {
                         try {
                             Thread.sleep(10000); //线程sleep10秒
                         } catch (Exception e) {

                         }
                         Message msg = new Message();
                         Bundle bundle = new Bundle();
                         bundle.putString("val", "Hello Handler");
                         msg.setData(bundle);
                         //这边只能记录日志
                         Log.d("sendMessageDelayed", "send");
                         //线程发送一个Message消息，MyHandler类中的handleMessage
                         //会接收到数据，并且可以更新UI
                         myHandler.sendMessageDelayed(msg, 5000);
                         //myHandler.sendMessage(msg); //无延迟
                     }
                 }).start();

             }
         });
     }

     /**
      * 实现一个自定义的Handler
      */
     public class MyHandler extends Handler {

         @Override
         public void handleMessage(Message msg) {
             //接收msg
             Toast.makeText(getBaseContext(), "getMessage....",
                     Toast.LENGTH_SHORT).show();
             super.handleMessage(msg);
             Bundle bundle = msg.getData();
             //修改UI界面
             btn.setText(bundle.getString("val"));
         }
     }

 }

公用的xml：

 <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools"
     android:layout_width="match_parent"
     android:layout_height="match_parent"
     android:paddingBottom="@dimen/activity_vertical_margin"
     android:paddingLeft="@dimen/activity_horizontal_margin"
     android:paddingRight="@dimen/activity_horizontal_margin"
     android:paddingTop="@dimen/activity_vertical_margin"
     tools:context=".MainActivity" >



     <Button
         android:id="@+id/button1"
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         android:layout_alignParentLeft="true"
         android:layout_alignParentTop="true"
         android:layout_marginLeft="70dp"
         android:layout_marginTop="116dp"
         android:text="Button" />

 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中将其源代码显示出来 

 package test.list;
 import java.io.ByteArrayOutputStream;
 import java.io.InputStream;
 import java.util.ArrayList;

 import org.apache.http.HttpEntity;
 import org.apache.http.HttpResponse;
 import org.apache.http.client.HttpClient;
 import org.apache.http.client.methods.HttpGet;
 import org.apache.http.impl.client.DefaultHttpClient;

 import android.app.Activity;
 import android.app.ProgressDialog;
 import android.content.Context;
 import android.content.DialogInterface;
 import android.os.AsyncTask;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.Message;
 import android.view.View;
 import android.widget.Button;
 import android.widget.EditText;
 import android.widget.TextView;

 public class NetworkActivity extends Activity{
     private TextView message;
     private Button open;
     private EditText url;

     @Override
     public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.network);
        message= (TextView) findViewById(R.id.message);
        url= (EditText) findViewById(R.id.url);
        open= (Button) findViewById(R.id.open);
        open.setOnClickListener(new View.OnClickListener() {
            public void onClick(View arg0) {
               connect();
            }
        });

     }

     private void connect() {
         PageTask task = new PageTask(this);
         task.execute(url.getText().toString());
     }


     class PageTask extends AsyncTask {
         // 可变长的输入参数，与AsyncTask.exucute()对应
         ProgressDialog pdialog;
         public PageTask(Context context){
             pdialog = new ProgressDialog(context, 0);
             pdialog.setButton("cancel", new DialogInterface.OnClickListener() {
              public void onClick(DialogInterface dialog, int i) {
               dialog.cancel();
              }
             });
             pdialog.setOnCancelListener(new DialogInterface.OnCancelListener() {
              public void onCancel(DialogInterface dialog) {
               finish();
              }
             });
             pdialog.setCancelable(true);
             pdialog.setMax(100);
             pdialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
             pdialog.show();


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

             try{

                HttpClient client = new DefaultHttpClient();
                // params[0]代表连接的url
                HttpGet get = new HttpGet(params[0]);
                HttpResponse response = client.execute(get);
                HttpEntity entity = response.getEntity();
                long length = entity.getContentLength();
                InputStream is = entity.getContent();
                String s = null;
                if(is != null) {
                    ByteArrayOutputStream baos = new ByteArrayOutputStream();

                    byte[] buf = new byte[128];

                    int ch = -1;

                    int count = 0;

                    while((ch = is.read(buf)) != -1) {

                       baos.write(buf, 0, ch);

                       count += ch;

                       if(length > 0) {
                           // 如果知道响应的长度，调用publishProgress（）更新进度
                           publishProgress((int) ((count / (float) length) * 100));
                       }

                       // 让线程休眠100ms
                       Thread.sleep(100);
                    }
                    s = new String(baos.toByteArray());              }
                // 返回结果
                return s;
             } catch(Exception e) {
                e.printStackTrace();

             }

             return null;

         }

         @Override
         protected void onCancelled() {
             super.onCancelled();
         }

         @Override
         protected void onPostExecute(String result) {
             // 返回HTML页面的内容
             message.setText(result);
             pdialog.dismiss();
         }

         @Override
         protected void onPreExecute() {
             // 任务启动，可以在这里显示一个对话框，这里简单处理
             message.setText(R.string.task_started);
         }

         @Override
         protected void onProgressUpdate(Integer... values) {
             // 更新进度
               System.out.println(""+values[0]);
               message.setText(""+values[0]);
               pdialog.setProgress(values[0]);
         }

      }

 }

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 newsList;
    List> 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>();
      addView();
    }

    private void addView() {
      if (startIndex == 1) {
            newsList = new ArrayList();
            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();
                        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> getdata(List list) {

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

    /*
   * 获取网络数据 注：我是访问本机的一个新闻服务，使用asp.net技术来实现的，等一段时间我打算写一个系列来总结次项目
   * 这个是项目是一个基于android的资讯播报软件
   */
    private List getNewsList() {
      String path = "http://10.0.2.2/getNewsList.aspx";
      String xmlStr = "1,3,7"
                + startIndex
                + "2"
                + size
                + "";
      NewsConnector newsConnector = new NewsConnector();
      List list = new ArrayList();
      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
    {

      @Override
      protected Void doInBackground(Void... params) {
            // TODO Auto-generated method stub
             
            newsList = new ArrayList();
            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变得比较复杂。
附件上截图