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

末蓝、 2021-09-28 00:08 421阅读 0赞

从我们学习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();  
            }  
          
        }

![Center][]

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

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

1.  `Message`消息，理解为线程间通讯的数据单元。例如后台线程在处理数据完毕后需要更新UI，则可发送一条包含更新信息的Message给UI线程。
2.  `Message Queue`消息队列，用来存放通过Handler发布的消息，按照先进先出执行。
3.  `Handler`Handler是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的原理是什么 ##

![Center 1][]

### 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

[Center]: /images/20210923/3058cf840317473b87416f4ba7b8b06d.png
[Center 1]: /images/20210923/5969d3da701c429684832c37ac1c0b5d.png