handler 与message的一些理解

观点一：

Android 对进程的重要性评级的时候，选取它最高的级别。另外，当被另外的一个进程依赖的时候，某个进程的级别可能会增高。一个为其他进程服务的进程永远不会比被服务的进程重要级低。因为服务进程比后台activity进程重要级高，因此一个要进行耗时工作的activity最好启动一个service来做这个工作，而不是开启一个子进程――特别是这个操作需要的时间比activity存在的时间还要长的时候。例如，在后台播放音乐，向网上上传摄像头拍到的图片，使用service可以使进程最少获取到“服务进程”级别的重要级，而不用考虑activity目前是什么状态。broadcast receivers做费时的工作的时候，也应该启用一个服务而不是开一个线程。

观点二：

在开发Android应用时必须遵守单线程模型的原则： Android UI操作并不是线程安全的，并且这些操作必须在UI线程中执行。

观点三：

为了避免拖住GUI，一些较费时的对象应该交给独立的线程去执行。如果幕后的线程来执行UI对象，Android就会发出错误讯息 CalledFromWrongThreadException。

观点四：Handler

  handler可以分发Message对象和Runnable对象到主线程中。

每个Handler实例,都会绑定到创建他的线程中(一般是位于主线程),
        它有两个作用: (1):  安排消息或Runnable 在某个主线程中某个地方执行, (2)安排一个动作在不同的线程中执行

观点五： Message Queue

    Message Queue消息队列，用来存放通过Handler发布的消息，按照先进先出执行。
    每个message queue都会有一个对应的Handler。Handler会向message queue通过两种方法发送消息：sendMessage或post。这两种消息都会插在message queue队尾并按先进先出执行。但通过这两种方法发送的消息执行的方式略有不同：通过sendMessage发送的是一个message对象,会被Handler的handleMessage()函数处理；而通过post方法发送的是一个runnable对象，则会自己执行。
 

观点六： Looper是每条线程里的Message Queue的管家。

Android没有Global的Message Queue，而Android会自动替主线程(UI线程)建立Message Queue，但在子线程里并没有建立Message Queue。所以调用Looper.getMainLooper()得到的主线程的Looper不为NULL，但调用Looper.myLooper()得到当前线程的Looper就有可能为NULL。

    对于子线程使用Looper，API Doc提供了正确的使用方法：

  1. class LooperThread extends Thread { 
  2.     public Handler mHandler; 
  3.  
  4.     public void run() { 
  5.         Looper.prepare(); //创建本线程的Looper并创建一个MessageQueue
  6.  
  7.         mHandler = new Handler() { 
  8.             public void handleMessage(Message msg) { 
  9.                 // process incoming messages here 
  10.             } 
  11.         }; 
  12.    
  13.         Looper.loop(); //开始运行Looper,监听Message Queue 
  14.     } 
  15. } 

主要转自http://android.blog.51cto.com/268543/343823/

一个异步加载listview的例子，用2种方法：

在网上有很多文章讲述主线程和其他子线程如何交互，传送信息，最终谁来执行处理信息之类的，个人理解是最简单的方法——判断Handler对象里面的Looper对象是属于哪条线程的，则由该线程来执行！
    1. 当Handler对象的构造函数的参数为空，则为当前所在线程的Looper；
    2. Looper.getMainLooper()得到的是主线程的Looper对象，Looper.myLooper()得到的是当前线程的Looper对象。

现在来看一个例子，模拟从网络获取数据，加载到ListView的过程：

  1. public class ListProgressDemo extends ListActivity { 
  2.  
  3.     @Override 
  4.     public void onCreate(Bundle savedInstanceState) { 
  5.         super.onCreate(savedInstanceState); 
  6.         setContentView(R.layout.listprogress); 
  7.  
  8.         ((Button) findViewById(R.id.load_Handler)).setOnClickListener(new View.OnClickListener(){ 
  9.  
  10.             @Override 
  11.             public void onClick(View view) { 
  12.                 data = null; 
  13.                 data = new ArrayList<String>(); 
  14.  
  15.                 adapter = null; 
  16.  
  17.                 showDialog(PROGRESS_DIALOG); 
  18.                 new ProgressThread(handler, data).start(); 
  19.             } 
  20.         }); 
  21.     } 
  22.  
  23.     @Override 
  24.     protected Dialog onCreateDialog(int id) { 
  25.         switch(id) { 
  26.         case PROGRESS_DIALOG: 
  27.                  return ProgressDialog.show(this, "",  
  28.                    "Loading. Please wait...", true); 
  29.  
  30.         default: return null; 
  31.         } 
  32.     } 
  33.  
  34.     private class ProgressThread extends Thread { 
  35.  
  36.         private Handler handler; 
  37.         private ArrayList<String> data; 
  38.  
  39.         public ProgressThread(Handler handler, ArrayList<String> data) { 
  40.             this.handler = handler; 
  41.             this.data = data; 
  42.         } 
  43.  
  44.         @Override 
  45.         public void run() { 
  46.             for (int i=0; i<8; i++) { 
  47.                 data.add("ListItem"); //后台数据处理
  48.                 try { 
  49.                     Thread.sleep(100); 
  50.                 }catch(InterruptedException e) { 
  51.                      
  52.                     Message msg = handler.obtainMessage(); 
  53.                     Bundle b = new Bundle(); 
  54.                     b.putInt("state", STATE_ERROR); 
  55.                     msg.setData(b); 
  56.                     handler.sendMessage(msg);  
  57.                      
  58.                 } 
  59.             } 
  60.             Message msg = handler.obtainMessage(); 
  61.             Bundle b = new Bundle(); 
  62.             b.putInt("state", STATE_FINISH); 
  63.             msg.setData(b); 
  64.             handler.sendMessage(msg); 
  65.         } 
  66.          
  67.     } 
  68.  
  69.     // 此处甚至可以不需要设置Looper，因为Handler默认就使用当前线程的Looper
  70.     private final Handler handler = new Handler(Looper.getMainLooper()) {
  71.  
  72.         public void handleMessage(Message msg) { // 处理Message，更新ListView
  73.             int state = msg.getData().getInt("state"); 
  74.             switch(state){ 
  75.                 case STATE_FINISH: 
  76.                     dismissDialog(PROGRESS_DIALOG); 
  77.                     Toast.makeText(getApplicationContext(), 
  78.                             "加载完成!", 
  79.                             Toast.LENGTH_LONG) 
  80.                          .show(); 
  81.  
  82.                     adapter = new ArrayAdapter<String>(getApplicationContext(), 
  83.                             android.R.layout.simple_list_item_1, 
  84.                             data ); 
  85.                              
  86.                     setListAdapter(adapter); 
  87.  
  88.                     break; 
  89.  
  90.                 case STATE_ERROR: 
  91.                    dismissDialog(PROGRESS_DIALOG); 
  92.                    Toast.makeText(getApplicationContext(), 
  93.                            "处理过程发生错误!", 
  94.                            Toast.LENGTH_LONG) 
  95.                         .show(); 
  96.  
  97.                    adapter = new ArrayAdapter<String>(getApplicationContext(), 
  98.                            android.R.layout.simple_list_item_1, 
  99.                            data ); 
  100.                             
  101.                       setListAdapter(adapter); 
  102.  
  103.                       break; 
  104.  
  105.                default: 
  106.  
  107.             } 
  108.         } 
  109.     }; 
  110.  
  111.  
  112.     private ArrayAdapter<String> adapter; 
  113.     private ArrayList<String> data; 
  114.  
  115.     private static final int PROGRESS_DIALOG = 1; 
  116.     private static final int STATE_FINISH = 1; 
  117.     private static final int STATE_ERROR = -1; 
  118. } 

这个例子，我自己写完后觉得还是有点乱，要稍微整理才能看明白线程间交互的过程以及数据的前后变化。随后了解到AsyncTask类，相应修改后就很容易明白了！

 

2.3 AsyncTask

AsyncTask版：
  1. ((Button) findViewById(R.id.load_AsyncTask)).setOnClickListener(new View.OnClickListener(){ 
  2.  
  3.     @Override 
  4.     public void onClick(View view) { 
  5.         data = null; 
  6.         data = new ArrayList<String>(); 
  7.  
  8.         adapter = null; 
  9.  
  10.         //显示ProgressDialog放到AsyncTask.onPreExecute()里 
  11.         //showDialog(PROGRESS_DIALOG); 
  12.         new ProgressTask().execute(data); 
  13.     } 
  14. }); 
  15.  
  16. private class ProgressTask extends AsyncTask<ArrayList<String>, Void, Integer> { 
  17.  
  18. /* 该方法将在执行实际的后台操作前被UI thread调用。可以在该方法中做一些准备工作，如在界面上显示一个进度条。*/ 
  19. @Override 
  20. protected void onPreExecute() { 
  21.     // 先显示ProgressDialog
  22.     showDialog(PROGRESS_DIALOG); 
  23. } 
  24.  
  25. /* 执行那些很耗时的后台计算工作。可以调用publishProgress方法来更新实时的任务进度。 */ 
  26. @Override 
  27. protected Integer doInBackground=\'#\'" /span>
  28.     ArrayList<String> data = datas[0]; 
  29.     for (int i=0; i<8; i++) { 
  30.         data.add("ListItem"); 
  31.     } 
  32.     return STATE_FINISH; 
  33. } 
  34.  
  35. /* 在doInBackground 执行完成后，onPostExecute 方法将被UI thread调用， 
  36.  * 后台的计算结果将通过该方法传递到UI thread. 
  37.  */ 
  38. @Override 
  39. protected void onPostExecute(Integer result) { 
  40.     int state = result.intValue(); 
  41.     switch(state){ 
  42.     case STATE_FINISH: 
  43.         dismissDialog(PROGRESS_DIALOG); 
  44.         Toast.makeText(getApplicationContext(), 
  45.                 "加载完成!", 
  46.                 Toast.LENGTH_LONG) 
  47.              .show(); 
  48.  
  49.         adapter = new ArrayAdapter<String>(getApplicationContext(), 
  50.                 android.R.layout.simple_list_item_1, 
  51.                 data ); 
  52.                  
  53.         setListAdapter(adapter); 
  54.  
  55.         break; 
  56.          
  57.     case STATE_ERROR: 
  58.        dismissDialog(PROGRESS_DIALOG); 
  59.        Toast.makeText(getApplicationContext(), 
  60.                "处理过程发生错误!", 
  61.                Toast.LENGTH_LONG) 
  62.             .show();
  63.  
  64.        adapter = new ArrayAdapter<String>(getApplicationContext(), 
  65.                android.R.layout.simple_list_item_1, 
  66.                data );
  67.  
  68.           setListAdapter(adapter);
  69.  
  70.           break;
  71.  
  72.    default:
  73.  
  74.    }
  75. }

    Android另外提供了一个工具类：AsyncTask。它使得UI thread的使用变得异常简单。它使创建需要与用户界面交互的长时间运行的任务变得更简单，不需要借助线程和Handler即可实现。

    1)  子类化AsyncTask
    2)  实现AsyncTask中定义的下面一个或几个方法
         onPreExecute() 开始执行前的准备工作；
         doInBackground=\'#\'" ) 开始执行后台处理，可以调用publishProgress方法来更新实时的任务进度；
         onProgressUpdate(Progress...)  在publishProgress方法被调用后，UI thread将调用这个方法从而在界面上展示任务的进展情况，例如通过一个进度条进行展示。
         onPostExecute(Result) 执行完成后的操作，传送结果给UI 线程。
 
         这4个方法都不能手动调用。而且除了doInBackground=\'#\'" /div>
        1) AsyncTask的实例必须在UI thread中创建；
        2) AsyncTask.execute方法必须在UI thread中调用；
        
    同时要注意：该task只能被执行一次，否则多次调用时将会出现异常。而且是不能手动停止的，这一点要注意，看是否符合你的需求！
 
    在使用过程中，发现AsyncTask的构造函数的参数设置需要看明白：AsyncTask<Params, Progress, Result>
    Params对应doInBackground=\'#\'" AsyncTask().execute(Params... params)，就是传进来的Params数据，你可以execute(data)来传送一个数据，或者execute(data1, data2, data3)这样多个数据。
    Progress对应onProgressUpdate(Progress...)的参数类型；
    Result对应onPostExecute(Result)的参数类型。
    当以上的参数类型都不需要指明某个时，则使用Void，注意不是void。不明白的可以参考上面的例子，或者API Doc里面的例子。
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/linxiaojiang/p/3036924.html