扒一扒面试必问的Handler

时间  2020-03-14
标签 面试 handler 栏目 快乐工作 繁體版
原文   原文链接

0.前言

Handler做为Android代码编写以及面试时常常遇到的内容，有必要花个时间整理一下，毕竟写过的东西印象会更加深入。html

1.什么是Handler?

1.1 定义

源码里面捞出来的内容，英文不难看懂。主要就是说每一个Handler会和每一个线程以及线程对应的消息队列相绑定。以后消息就可经过Handler在线程之间传递。android

A Handler allows you to send and process {@link Message} and Runnable objects associated with a thread's {@link MessageQueue}. Each Handler instance is associated with a single thread and that thread's message queue.  When you create a new Handler, it is bound to the thread ，message queue of the thread that is creating it -- from that point on,
 it will deliver messages and runnables to that message queue and execute them as they come out of the message queue.
  <p>There are two main uses for a Handler:
  (1) to schedule messages and runnables to be executed at some point in the future; and 
  (2) to enqueue an action to be performed on a different thread than your own.
复制代码

1.2 Handler的做用

Handler 的做用主要为两个：git

  1. 让程序在将来的某个时间点去执行一些事情
  2. 事件跨线程传递执行（最主要的使用就是子线程让主线程去作一些刷新的事情）

1.3 Handler的基本用法

1.在将来某个时刻去执行runnable中的事件面试

handler.post(runnable,delayMillis);
复制代码

2.不一样消息间传递事件bash

android.os.Handler handler = new Handler(){
  @Override
  public void handleMessage(final Message msg) {
    //这里接受并处理消息
  }
};
//发送消息
handler.sendMessage(message);
复制代码

2.Handler基本原理

2.1 Handler原理相关的类

  • Handler
  • Looper
  • MessageQueue
  • Messagre

2.2 Handler原理概述

首先放一张Handler消息处理的原理图less

handler原理图.jpeg
根据图一步步梳理Handler实现机制

2.3 Handler工做流程

2.3.1 建立Handler

首先第一步是建立Handler,Handler的构造函数主要有以下几个 异步

Hanlder构造函数

其中的参数以下async

  • boolean asyncide

    async 该参数肯定用Handler发送的消息是否要设置成异步消息，若是为ture设置为异步消息，异步消息可和同步阻塞一块儿配合使用，典型的例子是界面的定时刷新。函数

  • Callback callback

    设置了该参数，那么Handler在dispatchMessage回调时会优先调用callback中的代码，若返回为true,则再也不执行handleMessage的回调

/**
     * Handle system messages here.
     */
    public void dispatchMessage(@NonNull Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }
复制代码

  • Looper looper

    设置该Hanlder对应的Looper参数，对于每一个Handler,都有一个对应的Looper,每一个Looper有其对应的MessageQueue。若是没有显式的设置Handler的Looper,那么Handler默认会取该线程对应的Looper赋给该Handler。

2.3.2 Handler发送消息

Handler发送消息主要调用的是sendMessage方法。

sendMessage(@NonNull Message msg)
复制代码

发送消息的方法有许多不一样的名称和参数。可是，你从源码一步步看最后都会指向以下的这段代码

public boolean sendMessageAtTime(@NonNull Message msg, long uptimeMillis) {
        MessageQueue queue = mQueue;
        if (queue == null) {
            RuntimeException e = new RuntimeException(
                    this + " sendMessageAtTime() called with no mQueue");
            Log.w("Looper", e.getMessage(), e);
            return false;
        }
        return enqueueMessage(queue, msg, uptimeMillis);
    }
复制代码

看这段代码咱们会发现，其主要的操做就是调用压队列的方法。传入的参数是队列，消息以及对应的事件

2.3.3 MessageQueue压入消息

该方法首先是对Message 实例进行各类参数的设置，最主要的就是target参数，该参数用于肯定消息从MessageQueue中取出后去调用哪一个Handler的dispatchMessage，从而进行消息的处理。

private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
            long uptimeMillis) {
        msg.target = this;
        msg.workSourceUid = ThreadLocalWorkSource.getUid();

        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }
复制代码

设置完参数，Handler的enqueueMessage就会去调用MessageQueue的enqueueMessage方法，代码以下

boolean enqueueMessage(Message msg, long when) {
        if (msg.target == null) {
            throw new IllegalArgumentException("Message must have a target.");
        }
        if (msg.isInUse()) {
            throw new IllegalStateException(msg + " This message is already in use.");
        }

        synchronized (this) {
            if (mQuitting) {
                IllegalStateException e = new IllegalStateException(
                        msg.target + " sending message to a Handler on a dead thread");
                Log.w(TAG, e.getMessage(), e);
                msg.recycle();
                return false;
            }

            msg.markInUse();
            msg.when = when;
            Message p = mMessages;
            boolean needWake;
            if (p == null || when == 0 || when < p.when) {
                // New head, wake up the event queue if blocked.
                msg.next = p;
                mMessages = msg;
                needWake = mBlocked;
            } else {
                // Inserted within the middle of the queue.  Usually we don't have to wake // up the event queue unless there is a barrier at the head of the queue // and the message is the earliest asynchronous message in the queue. needWake = mBlocked && p.target == null && msg.isAsynchronous(); Message prev; for (;;) { prev = p; p = p.next; if (p == null || when < p.when) { break; } if (needWake && p.isAsynchronous()) { needWake = false; } } msg.next = p; // invariant: p == prev.next prev.next = msg; } // We can assume mPtr != 0 because mQuitting is false. if (needWake) { nativeWake(mPtr); } } return true; } 复制代码

从代码中咱们能发现，消息队列主要是经过链表的形式进行的存储。这段代码的所处理的事情就是根据Message中的when参数从列表中来找到须要插入的点，并把Message进行参入。

2.3.4 Looper取出消息

Looper取出消息主要是调用了Looper类的loop方法，该方法里面有一个for(;;）循环，不停的从MessageQueue中取出消息。

for (;;) 
    {
        Message msg = queue.next();
        ……
    }
复制代码
2.3.5 Handler处理消息

当消息取出之后，即会调用

msg.target.dispatchMessage(msg);
 
复制代码

来处理消息，这个target即时开始enqueMessage时塞入的Handler。

从Handler中咱们能够看到，这dispatchMessage(Message msg)方法。

public void dispatchMessage(@NonNull Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }
复制代码

其中handleMessage(msg)就是咱们自定义Handler时的回调，这样消息就走完了整个流程。

3.Handler延伸

3.1 Q Handler 为何会致使内存泄漏，该如何处理这个内存泄漏问题？

A: Handler的普通用法以下：

Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
           
        }
    };
复制代码

因为Handler是经过匿名内部类的方式实现的，因此其会对外部类有引用（一般为Activity），这就会引发内存泄漏。

一般的解决以下

把Handler定义成静态内部类，如Handler中须要对外部类的参数有引用，那么可使用弱引用，示例代码以下

private static class MyHandler extends Handler{
        //持有弱引用HandlerActivity,GC回收时会被回收掉.
        private final WeakReference<HandlerActivity> mActivty;
        public MyHandler(HandlerActivity activity){
            mActivty =new WeakReference<HandlerActivity>(activity);
        }
        @Override
        public void handleMessage(Message msg) {
            HandlerActivity activity=mActivty.get();
            super.handleMessage(msg);
            if(activity!=null){
                //执行业务逻辑
            }
        }
    }
复制代码

3.2 Q Handler类中有个Callback的接口，请问这个接口有什么用？

A: 这个的设计主要是为了解决Handler内存泄漏的问题。

可参考以下代码：

Handler handler = new Handler(new Handler.Callback(

@Override

public boolean handleMessage(Message msg) {

if (msg.what ==1){

textView.setText("Hello!");

return true;

    }

return false;

));

复制代码

该接口的调用主要出如今dispatchMessage中，今后处的代码可知道，若是mCallback变量没有定义，变量为空，会走Handler系统的方法hadlerMessage（Message msg）,而若是mCallback变量定义了，那么其会运行到mCallback

public void dispatchMessage(@NonNull Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }
复制代码

3.3 Q Handler中的普通消息，异步消息和消息屏障是什么关系？有什么做用？

MessageQueue中的Message一共有三种类型，即普通消息，异步消息和消息屏障。区别是消息屏障它的target为null。而普通消息和异步消息是经过setAsynchronous为true来进行区分的。

在设置消息屏障后，异步消息具备优先处理的权利。界面的定时刷新就是用的这个机制

3.4 Q Message的target是何时注入的？

捞取Handler的源码发现以下这段

private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
            long uptimeMillis) {
        msg.target = this;
        msg.workSourceUid = ThreadLocalWorkSource.getUid();

        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }

复制代码

即哪一个Handler把Message存入的消息队列，最后回调的就是这个Handler对应的dispatchMessage 方法。

3.5 Q Looper会不停的从消息队列中取消息吗？

不会，若MessageQueue中消息已经取完或者消息要在以后的某个事件才会促发，则会调用native方法 nativePollOnce(long ptr, int timeoutMillis)，使主线程处于等待状态。当调用了往消息队列塞入消息时，则会调用nativeWake(long ptr)方法唤醒主线程，因此尽管，loop方法中有个for死循环，可是这不会致使Looper不停从消息队列取数据。可参考Android 中 MessageQueue 的 nativePollOnce这篇文章

3.6 Q Handler的post(Runnable r) 方法是如何实现Runnable中事件的执行的？

post方法从本质上来讲也是用的Message消息传递的流程。

public final boolean post(@NonNull Runnable r) {
       return  sendMessageDelayed(getPostMessage(r), 0);
    }
复制代码
private static Message getPostMessage(Runnable r) {
        Message m = Message.obtain();
        m.callback = r;
        return m;
    }
复制代码

从以下两端代码可看出其是对runnable进行了封装，把runnable塞进了Message中。而当Handler得到消息后，其会取出msg.callback参数，而后运行里面的runnable方法。

3.7 Q 平时代码编写中如何得到Message对象比较好？

用Message.obtain()获取比较好，避免了gc致使的性能消耗。

3.8 Q IdleHandler是什么，有什么做用？

IdleHandler是在主线程消息队列空闲时，会被取出执行的对象。可在一些页面优化的情景下使用。 可参考我以前写的一篇文章 IdleHandler，页面启动优化神器

4.参考资料

  1. Android Handler那些事儿，消息屏障？IdelHandler?ANR?
  2. Android 中 MessageQueue 的 nativePollOnce
  3. IdleHandler，页面启动优化神器
  4. 理解Android ANR的触发原理
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程