android Handler 机制研究学习笔记

参考博客：

        1、    http://www.cnblogs.com/youxilua/archive/2011/11/25/2263825.html 

2、   http://blog.sina.com.cn/s/blog_77c6324101016jp8.html

3、   http://blog.csdn.net/qianquanyiyan/article/details/8215887

一、Handler的定义:

    Handler主要接收子线程发送的数据, 并用此数据配合主线程更新UI，用来跟UI主线程交互用。比如可以用handler发送一个message，然后在handler的线程中来接收、处理该消息，以避免直接在UI主线程中处理事务导致影响UI主线程的其他处理工作，Android提供了Handler作为主线程和子线程的纽带；也可以将handler对象传给其他进程，以便在其他进程中通过handler给你发送事件；还可以通过handler的延时发送message，可以延时处理一些事务的处理。

通常情况下，当应用程序启动时，Android首先会开启一个主线程 (也就是UI线程) , 主线程为管理界面中的UI控件，进行事件分发。如果此时需要一个耗时的操作，例如:联网读取数据，或者读取本地较大的一个文件的时候，你不能把这些操作放在主线程中，如果你放在主线程中的话，界面会出现假死现象,如果5秒钟还没有完成的话，会收到Android系统的一个错误提示"强制关闭". 

这个时候我们需要把这些耗时的操作，放在一个子线程中,因为子线程涉及到UI更新，但是当子线程中有涉及到操作UI的操作时，就会对主线程产生危险，也就是说，更新UI只能在主线程中更新，在子线程中操作是危险的. 这个时候，Handler就出现了来解决这个复杂的问题，由于Handler运行在主线程中(UI线程中)，它与子线程可以通过Message对象来传递数据，这个时候，Handler就承担着接受子线程传过来的(子线程用sedMessage()方法传递)Message对象，(里面包含数据), 把这些消息放入主线程队列中，配合主线程进行更新UI。

 

二、Handler一些特点

        handler可以分发Message对象和Runnable对象到主线程中, 每个Handler实例,都会绑定到创建他的线程中(一般是位于主线程), 也就是说Handler对象初始化后，就默认与对它初始化的进程的消息队列绑定，因此可以利用Handler所包含的消息队列，制定一些操作的顺序。

 

三、Handler中分发消息的一些方法

        post(Runnable)

        postAtTime(Runnable,long)

        postDelayed(Runnable long)

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

        sendEmptyMessage(int)

        sendMessage(Message)

        sendMessageAtTime(Message,long)

        sendMessageDelayed(Message,long)

           sendMessage类方法, 允许你安排一个带数据的Message对象到队列中，等待更新.

 

四、应用实例：

   1，传递Message。用于接受子线程发送的数据, 并用此数据配合主线程更新UI。

          在Android中，对于UI的操作通常需要放在主线程中进行操作。如果在子线程中有关于UI的操作，那么就需要把数据消息作为一个Message对象发送到消息队列中，然后，用Handler中的handlerMessge方法处理传过来的数据信息，并操作UI。类sendMessage(Message msg)方法实现发送消息的操作。 在初始化Handler对象时重写的handleMessage方法来接收Messgae并进行相关操作。

例子：  以下为一个实例，它实现的功能为 : 通过线程修改界面Button的内容）

 注：子类需要继承Hendler类，并重写handleMessage(Message msg) 方法, 用于接受线程数据

[html]  view plain copy

1. public class MyHandlerActivity extends Activity {  
2.     Button button;  
3.     MyHandler myHandler;  
4.   
5.     protected void onCreate(Bundle savedInstanceState) {  
6.         super.onCreate(savedInstanceState);  
7.         setContentView(R.layout.handlertest);  
8.   
9.         button = (Button) findViewById(R.id.button);  
10.         myHandler = new MyHandler();  
11.         // 当创建一个新的Handler实例时, 它会绑定到当前线程和消息的队列中,开始分发数据  
12.         // Handler有两个作用, (1) : 定时执行Message和Runnalbe 对象  
13.         // (2): 让一个动作,在不同的线程中执行.  
14.   
15.         // 它安排消息,用以下方法  
16.         // post(Runnable)  
17.         // postAtTime(Runnable,long)  
18.         // postDelayed(Runnable,long)  
19.         // sendEmptyMessage(int)  
20.         // sendMessage(Message);  
21.         // sendMessageAtTime(Message,long)  
22.         // sendMessageDelayed(Message,long)  
23.         
24.         // 以上方法以 post开头的允许你处理Runnable对象  
25.         //sendMessage()允许你处理Message对象(Message里可以包含数据,)  
26.   
27.         MyThread m = new MyThread();  
28.         new Thread(m).start();  
29.     }  
30.   
31.     /**  
32.     * 接受消息,处理消息 ,此Handler会与当前主线程一块运行  
33.     * */  
34.   
35.     class MyHandler extends Handler {  
36.         public MyHandler() {  
37.         }  
38.   
39.         public MyHandler(Looper L) {  
40.             super(L);  
41.         }  
42.   
43.         // 子类必须重写此方法,接受数据  
44.         @Override  
45.         public void handleMessage(Message msg) {  
46.             // TODO Auto-generated method stub  
47.             Log.d("MyHandler", "handleMessage......");  
48.             super.handleMessage(msg);  
49.             // 此处可以更新UI  
50.             Bundle b = msg.getData();  
51.             String color = b.getString("color");  
52.             MyHandlerActivity.this.button.append(color);  
53.   
54.         }  
55.     }  
56.   
57.     class MyThread implements Runnable {  
58.         public void run() {  
59.   
60.             try {  
61.                 Thread.sleep(10000);  
62.             } catch (InterruptedException e) {  
63.                 // TODO Auto-generated catch block  
64.                 e.printStackTrace();  
65.             }  
66.   
67.             Log.d("thread.......", "mThread........");  
68.             Message msg = new Message();  
69.             Bundle b = new Bundle();// 存放数据  
70.             b.putString("color", "我的");  
71.             msg.setData(b);  
72.   
73.             MyHandlerActivity.this.myHandler.sendMessage(msg); // 向Handler发送消息,更新UI  
74.   
75.         }  
76.     }  
77.   
78. }  

  

在《解密Google Android》一书中，发现了这样一个启动线程的模型。利用该模型，我们可以把一些耗时的操作放到doStuff方法中去执行，同时在updateUIHere方法中进行更新UI界面的操作，就可以完成一个线程所需要的功能。其他的说明写在注释部分了。

[html]  view plain copy

1. Handler myHandler = new Handler() {  
2.     public void handleMessage(Message msg) {  
3.         updateUIHere();  
4.     }  
5. }  
6.   
7. new Thread() {  
8.     public void run() {  
9.         doStuff();         // 执行耗时操作  
10.         Message msg = myHandler.obtainMessage();  
11.         Bundle b = new Bundle();  
12.         b.putString("key", "value");  
13.         m.setData(b);    // 向消息中添加数据  
14.         myHandler.sendMessage(m);    // 向Handler发送消息，更新UI  
15.     }  
16. }.start();  

  2，传递Runnable对象。用于通过Handler绑定的消息队列，安排不同操作的执行顺序。

Handler对象在进行初始化的时候，会默认的自动绑定消息队列。利用类post方法，可以将Runnable对象发送到消息队列中，按照队列的机制按顺序执行不同的Runnable对象中的run方法。

另外，Android的CPU分配的最小单元是线程，Handler一般是在某个线程里创建的，因而Handler和Thread就是相互绑定的，一一对应。而Runnable是一个接口，Thread是Runnable的子类。所以说，他俩都算一个进程。

                                                                                                                                                                       

例子：

1.  public class HandlerActivity extends Activity {   2.        3.      //声明两个按钮控件   4.      private Button startButton = null;   5.      private Button endButton = null;   6.      @Override  7.      public void onCreate(Bundle savedInstanceState) {   8.          super.onCreate(savedInstanceState);   9.          setContentView(R.layout.main);   10.         //根据控件的ID得到代表控件的对象，并为这两个按钮设置相应的监听器   11.         startButton = (Button)findViewById(R.id.startButton);   12.         startButton.setOnClickListener(new StartButtonListener());   13.         endButton = (Button)findViewById(R.id.endButton);   14.         endButton.setOnClickListener(new EndButtonListener());   15.            16.     }   17.     class StartButtonListener implements OnClickListener{   18.   19.         @Override  20.         public void onClick(View v) {   21.             //调用Handler的post方法，将要执行的线程对象添加到队列当中   22.             handler.post(updateThread);   23.         }   24.            25.     }   26.        27.     class EndButtonListener implements OnClickListener{   28.   29.         @Override  30.         public void onClick(View v) {   31.             handler.removeCallbacks(updateThread);   32.         }   33.            34.     }   35.     //创建一个Handler对象   36.     Handler handler  = new Handler();   37.     //将要执行的操作写在线程对象的run方法当中   38.     Runnable updateThread =  new Runnable(){   39.   40.         @Override  41.         public void run() {   42.             System.out.println("UpdateThread");   43.             //在run方法内部，执行postDelayed或者是post方法   44.             handler.postDelayed(updateThread, 3000);   45.         }   46.            47.     };   48. }

    程序的运行结果就是每隔3秒钟，就会在控制台打印一行UpdateTread。这是因为实现了Runnable接口的updateThread对象进入了空的消息队列即被立即执行run方法，而在run方法的内部，又在3000ms之后将其再次发送进入消息队列中。

  3， Handler和多线程

    post方法虽然发送的是一个实现了Runnable接口的类对象，但是它并非创建了一个新线程，而是执行了该对象中的run方法。也就是说，整个run中的操作和主线程处于同一个线程。

    这样对于那些简单的操作，似乎并不会影响。但是对于耗时较长的操作，就会出现“假死”。为了解决这个问题，就需要使得handler绑定到一个新开启线程的消息队列上，在这个处于另外线程的上的消息队列中处理传过来的Runnable对象和消息。 

1.  public class HandlerTest2 extends Activity {   2.    3.      @Override  4.      protected void onCreate(Bundle savedInstanceState) {   5.          // TODO Auto-generated method stub   6.      super.onCreate(savedInstanceState);   7.      setContentView(R.layout.main);   8.      //打印了当前线程的ID   9.      System.out.println("Activity-->" + Thread.currentThread().getId());   10.     //生成一个HandlerThread对象   11.     HandlerThread handlerThread = new HandlerThread("handler_thread");   12.     //在使用HandlerThread的getLooper()方法之前，必须先调用该类的start()，同时开启一个新线程;   13.     handlerThread.start(); 14.     //将由HandlerThread获取的Looper传递给Handler对象，即由处于另外线程的Looper代替handler初始化时默认绑定的消息队列来处理消息。   15.      // HandlerThread顾名思义就是可以处理消息循环的线程，它是一个拥有Looper的线程 16. ，可以处理消息循环；  其实与其说Handler和一个线程绑定，倒不如说Handler和Looper是 17. 一一对应的。 18.     MyHandler myHandler = new MyHandler(handlerThread.getLooper());   19.     Message msg = myHandler.obtainMessage();   20.     //将msg发送到目标对象，所谓的目标对象，就是生成该msg对象的handler对象   21.     Bundle b = new Bundle();   22.     b.putInt("age", 20);   23.     b.putString("name", "Jhon");   24.     msg.setData(b);   25.     msg.sendToTarget();  //将msg发送到myHandler 26.     }   27.        28.     //定义类 29.     class MyHandler extends Handler{   30.     public MyHandler(){   31.                32.     }   33.      34.     public MyHandler(Looper looper){   35.         super(looper);   36.     }   37.     @Override  38.     public void handleMessage(Message msg) {   39.         Bundle b = msg.getData();   40.         int age = b.getInt("age");   41.         String name = b.getString("name");   42.         System.out.println("age is " + age + ", name is" + name);   43.         System.out.println("Handler--->" + Thread.currentThread().getId());   44.         System.out.println("handlerMessage");   45.         }   46.     }   47. }

    这样，当使用sendMessage方法传递消息或者使用post方法传递Runnable对象时，就会把它们传递到与handler对象绑定的处于另外一个线程的消息队列中，它们将在另外的消息队列中被处理。而主线程还会在发送操作完成时候继续进行，不会影响当前的操作。

这里需要注意，这里用到的多线程并非由Runnable对象开启的，而是ThreadHandler对象开启的。Runnable对象只是作为一个封装了操作的对象被传递，并未产生新线程。

另外再强调一遍，在UI线程（主线程）中：

    mHandler=new Handler();

    mHandler.post(new Runnable(){

    void run(){

       //执行代码..

     }

    });

    这个线程其实是在UI线程之内运行的，并没有新建线程。

 

    常见的新建线程的方法是：

    Thread thread = new Thread();

    thread.start();

 

    HandlerThread thread = new HandlerThread("string");

    thread.start();

 

注：Message结构体类型

作为handler接受的对象,我们有必要知道Message这个数据类型是个怎样的数据类型

从官方文档中我们可以知道message 关于数据的字段

public int what
public int arg1
public int arg2
public Object obj

从上面的表格可以看出,message 提供了一个对象来存储对象,而且,还提供了三个int字段用来存储少量int类型

当然,除了以上三个Message 自有的字段外,我们还可以通过setData(Bundle b),来存储一个Bundle对象,来存储更丰富的数据类型,例如,图片等等.

在初始化我们的message的时候就可以为我们的Message默认字段赋值,注意赋值顺序!!!

1 2 3 4 5 6 7 8 9

Message msg = obtainMessage(); // 设置我们what 字段的初值，注意顺序！！！ Message msg = mHandler.obtainMessage(int what);   // 下面同理 Message msg = mHandler.obtainMessage(int what,Object object); Message msg = mHandler.obtainMessage(int what,int arg1,int arg2); Message msg = mHandler.obtainMessage(int what,int arg1,int arg2, Object obj );