Android中的Handler的机制与用法详解

从我们学习android开始,几乎每天都在和handler打交道.有了它,我们在子线程中处理好了耗时的操作,可以利用它来更新UI.它为我们在线程间的通信提供了很大的方便,而今天博客就来详细的介绍一下Handler的消息循环机制,一步一步的了解其中的奥妙.

1.了解概念

1.1简单实例

    public class DemoAct extends AppCompatActivity {  
      
        private Handler h = new Handler() {  
            @Override  
            public void handleMessage(Message msg) {  
                Toast.makeText(DemoAct.this, "收到啦", Toast.LENGTH_LONG).show();  
            }  
        };  
      
        @Override  
        protected void onCreate(Bundle savedInstanceState) {  
            super.onCreate(savedInstanceState);  
            setContentView(R.layout.act_demo);  
        }  
      
        /** 
         * 按钮的点击事件 
         * 
         * @param view 
         */  
        public void clickView(View view) {  
            new Thread(){  
                @Override  
                public void run() {  
                    h.sendEmptyMessage(0);  
                }  
            }.start();  
        }  
      
    }  

很多Android初学者对Android 中的Handler不是很明白，其实Google参考了Windows的消息处理机制，在Android系统中实现了一套类似的消息处理机制。

在下面介绍Handler机制前，首先得了解以下几个概念：

1. Message消息，理解为线程间通讯的数据单元。例如后台线程在处理数据完毕后需要更新UI，则可发送一条包含更新信息的Message给UI线程。
2. Message Queue消息队列，用来存放通过Handler发布的消息，按照先进先出执行。
3. HandlerHandler是Message的主要处理者，负责将Message添加到消息队列以及对消息队列中的Message进行处理。
4. Looper循环器，扮演Message Queue和Handler之间桥梁的角色，循环取出Message Queue里面的Message，并交付给相应的Handler进行处理。
5. 线程UI thread 通常就是main thread，而Android启动程序时会替它建立一个Message Queue。每一个线程里可含有一个Looper对象以及一个MessageQueue数据结构。在你的应用程序里，可以定义Handler的子类别来接收Looper所送出的消息。

2.什么是handler

1. Handler 是 Android 给我们提供来更新 UI 的一套机制，也是一套消息处理的机制，我们可以发送消息，也可以通过它来处理消息，Handler 在我们的 framework 中是非常常见的。
2. Android 在设计的时候，就封装了一套消息创建、传递、处理机制，如果不遵循这样的机制就没有办法更新 UI 信息，就会抛出异常信息。

3.如何使用handler

3.1 传递message

用于接受子线程发送的数据，并用此数据配合主线程更新 UI。有以下方法：

post(Ruannable);
postAtTime(Runnable, long);
postDelayed(Runnable long);

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

3.2 传递Runnable对象

用于通过 Handler 绑定的消息队列，安排不同操作的执行顺序，主要有以下方法：

sendEmptyMessage(int);
sendMessage(Message);
sendMessageAtTime(Message, long);
sendMessageDelayed(Message, long);

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

1. 使用 Handler 在子线程中向 UI 线程发送一个消息进行 UI 的更新
2. 创建一个 Message,Message msg = new Message(); msg.arg1 = 88;
3. handler.sendMessage(msg); msg.obj = xxx;可以传递一个对象
4. 当然不一定要用 new 一个 Message，也可以复用系统的 message 对象Message msg = handler.obtainMessage();

3.3传递callback对象

Callback 用于截获 handler 发送的消息，如果返回 true 就截获成功不会向下传递了。

public Handler mHandler = new Handler(new Handler.Callback() {
    @Override
    public boolean handleMessage(Message msg) {
        // TODO Auto-generated method stub
        Toast.makeText(getApplicationContext(), "HandleMessage 1", Toast.LENGTH_SHORT).show();
        return true;
    }
}) {
    public void handleMessage(Message msg) {
        // TODO Auto-generated method stub
        Toast.makeText(getApplicationContext(), "handleMessage 1", Toast.LENGTH_SHORT).show();
    };
}

上面的示例中，第一个有返回值的 handlerMessage 方法是 Callback 的回调，如果返回true，则不执行下面的 handlerMessage 方法，从而达到拦截 handler 发送的消息的目的，如果返回 false，则会继续执行 handlerMessage 方法。

4.handler原理

4.1Android为何设计只能通过handler来更新UI

最根本的目的就是解决多线程并发的问题，假设在一个 Activity 当中，有多个线程去更新 UI，并且对更新的 UI 的操作进行枷锁处理的话又会产生什么样的问题呢? 那就是性能下降，Handler 通过消息队列，保证了消息处理的先后有序。

鉴于以上问题的考虑，Android 给我们提供了一套更新 UI 的机制，我们只要使用一套机制就好，所有的更新 UI 的操作都是在主线程中轮询处理。

4.2 handler的原理是什么

4.2.1 MessageQueue和Looper的介绍

在Android中,一个线程可以对应一个Looper对象,不能有多个,为什么说可以呢,Looper作为一个消息的循环器,在一个线程中可以使用它也可以不使用它,所以一个线程中可以有一个Looper对象不能有多个.

说到了消息的循环器,就必须掰扯掰扯所谓的消息队列MessageQueue.每一个Looper对象里面都会维护一个消息队列MessageQueue,它用来存放消息(Message),在MessageQueue中,存放的消息按照FIFO(先进先出)原则执行

1. Handler 封装了消息的发送(主要包括消息发送给谁) Looper:
   • 内部包含一个消息队列也就是 MessageQueue，所有 Handler 发送的消息都走向这个队列。
   • Looper.loop()方法，就是一个 for 死循环，不断的从 MessageQueue 取消息，如果有消息就处理消息，没有消息就阻塞。
2. MessageQueue，就是一个消息队列，可以添加消息，处理消息。
3. Handler 也不难，比较简单，在构造 Handler 时候内部会跟 Looper 进行关联，通过 Looper.myLooper() 获取到 Looper，找到 Looper 也就找到了 MessageQueue。在 Handler 中发送消息，其实是向 MessageQueue 队列中发送消息。

5.handler与子线程

5.1自定义与线程相关的handler

class MyThread extends Thread {
    public Handler handler;
    @Override
    public void run() {
        Looper.prepare(); //new 一个Looper对象
        handler = new Handler() { //拿到当前线程的 Looper 对象
            @Override
            public void handlerMessage(Message msg) {
                // TODO Auto-generated method stub
                System.out.println("current thread:" + Thread.currentThread());
            }
        };
        Looper.loop();//开始死循环处理消息
    };
}

一般 UI 主线程中不要执行一些耗时的操作，这样就可以通过子线程消息来处理耗时操作。

5.2 HandlerThread是什么

HandlerThread 继承于 Thread，所以它本质就是个 Thread。与普通的 Thread 的差别就在于，它有个 Looper 成员变量。这个 Looper 其实就是对消息队列以及队列处理逻辑的封装，简单来说就是消息队列+消息循环。

当我们需要一个工作线程，而不是把它当作一次性消耗品，用过即废的话，就可以使用它。

private Handler mHandler = null;
private HandlerThread mHandlerThread = null;

private void sendRunnableToWorker(Ruannable run) {
    if (null == mHandlerThread) {
        mHandlerThread = new HandlerThread("WorkerThread");
        // 给工作者线程低优先级
        mHandlerThread.setPriority(Thread.MIN_PRIORITY);
        mHandlerThread.start();
    }
    if (null == mHandler) {
        mHandler = new Handler(mHandlerThread.getLooper());
    }
    mHandler.post(run);
}

6.主线程与子线程的信息交互

//创建主线程的Handler
private Handler mHandler = new Handler() {
    public void handleMessage(Message msg) {
        Message mssage = new Message();
        System.out.println("main Handler");
        //向子线程发送消息
        threadHandler.sendMessageDelayed(message, 1000);
    };
};
//创建子线程的 handler
private Handler threadHandler;

@Override
protected void onCreate(Bundle saveInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);

    HandlerThread thread = new HandlerThread("handlerThread");
    //创建子线程的 handler
    threadHandler = new Handler(thread.getLooper()) {
        public void handlerMessage(Message msg) {
            Message message = new Message();
            //向主线程发送消息
            mHandler.sendMessageDelayed(message, 1000);
        };
    };
}

7.Android中更新UI的四种方式

1. runOnUiThread
2. handler 的 post
3. handler 的 sendMessage
4. View 自身的 post