Handler学习

最新推荐文章于 2021-06-23 11:27:52 发布
最新推荐文章于 2021-06-23 11:27:52 发布
阅读量1.5k 收藏
点赞数 2
分类专栏： Android Android笔记 文章标签： Handler Handler原理 Handler源码 Handler学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40876113/article/details/80921623
版权

1 什么是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.
  
     There are two main uses for a Handler: (1) to schedule messages and
  runnables to be executed as some point in the future; and (2) to enqueue
  an action to be performed on a different thread than your own.

翻译下来大致如下:

Handler允许你发送和处理与线程相关的消息，runnable类型的对象。每一个Handle和一个单一的线程，线程队列对应。当你创建一个Handler，Handler是绑定到一个线程/线程队列，从那时起，它会将消息和runnable传递给该消息队列，并且执行这些消息止到他们从消息队列中走出。
Handler主要有两个用处:
1.安排消息和runnables将在未来的某个点上执行
2.在其他线程中，插入一个操作在Handler所在的线程（即用户线程间通讯）

2 Message MessageQueue Looper

谈到Handler，需要先了解下Message，MessageQueue,Looper,以及他们与Handler的关系

2.1 Message

Message，消息，用于在线程之间传递数据。Message 对象可以通过 new 关键字来获得，但为了节省资源，通常使用 Message.obtain() 方法或 Handler.obtainMessage() 方法来从消息池中获得空消息对象。下面是它的属性：

  • arg1： 用来存放 int 型数据；
  • arg2： 用来存放 int 型数据；
  • obj： 用来存放 Object 数据(即存放对象)；
  • what： 用于指定用户自定义的消息代码，便于主线程接收后，根据不同的消息代码执行不同的操作；
  • setData(Bundle)： 传送复杂的数据。

2.2 MessageQueue

MeessageQueue，消息队列，用来存放所有通过 Handler 发送的消息，这部分消息会一直存在消息队列中，等待被处理，（按照 FIFO (先进先出) 的规则执行）；一个线程中只会有一个 MessageQueue 对象。

2.3 Looper

Looper，消息泵，是每个线程中 MessageQueue 的管家，调用 Looper 的 loop() 方法后，就会进入到一个无限循环中，每当发现 MessageQueue 中存在一条消息，Looper 就会将它取出，并传递到 Handler 的 handleMessage()方法中。一个线程中只会有一个 Looper 对象。

2.4 Handler Lopper Message MessageQueue之间的关系

  • 如图，Handler 是寄信人，负责把 Message 放到 MessageQueue 里面去；Message 是信件；MessageQueue 是邮筒，先进来的信件会先被取出；Looper 是邮差，负责管理 Message(信件)，当 MessageQueue(邮筒) 里有 Message(信件) 时，就将其取出，然后交给 Handler(收信人) 处理；其中，Handler 既是寄信人，又是收信人。
    这里写图片描述
  • 一个线程中只能有一个 Looper 对象和 MessageQueue 对象，但是可以有多个 Handler 和 Message；多个 Handler 可以共享一个 Looper 和 MessageQueue，但一个 Handler 只能有一个 MessageQueue；Message 被存放在 MessageQueue 中。
  • Looper 对象用来为一个线程开启一个消息循环，从而操作 MessageQueue；
    默认情况下，Android 创建的线程没有开启消息循环，但是系统会自动为主线程创建 Looper 对象，开启消息循环；如果在子线程想要创建 Handler 对象，需要执行执行 Looper.prepare() 方法，然后创建 Handler 对象，最后执行 Looper.loop() 方法。
Looper.prepare();
    Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
        }
    }
Looper.loop();

3 Handler源码分析

Handler源码:

public class Handler {

    final Looper mLooper;
    final MessageQueue mQueue;
    final Callback mCallback;
    final boolean mAsynchronous;
    /*
     * 设置该标识为true用于检测继承Handler的非静态匿名，本地或者成员类出现内存泄漏的风险。
     * /
    private static final boolean FIND_POTENTIAL_LEAKS = false;
    private static final String TAG = "Handler";
    private static Handler MAIN_THREAD_HANDLER = null;

    /**
     *  实例化Handler的时候可以考虑使用该接口（Handler有这个类型的成员变量),避免必须继承实现Handler的抽象方法
     * 该接口的handleMessage的返回值为true表示执行完该方法后，执行Handler的handleMessage方法；否则不执行Handler的handleMessage方法
     */
    
    public interface Callback {
        public boolean handleMessage(Message msg);
    }
    
    /**
     * 子类必须重写该方法用于接收消息。
     */
    public void handleMessage(Message msg) {
    }
    
    /**
     * 处理消息的方法，Handler接收到的所有消息都会先被发送到这个方法中
     * 通过该方法可以比较清楚的看到handler在接收到消息以后的处理顺序
     */
    
    public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }
    
    private static void handleCallback(Message message) {
        message.callback.run();
    }
    /**
     *默认构造方法，该方法在实际使用中，用的最多。
     */
    public Handler() {
        this(null, false);
    }

    /**
     * 通过CallBack初始化
     */
    public Handler(Callback callback) {
        this(callback, false);
    }

    /**
     * 使用指定的looper初始化Handler，构造方法在不指定Looper时，默认使用当前线程的Looper
     */
    public Handler(Looper looper) {
        this(looper, null, false);
    }

    /**
     * 使用指定的looper和callback初始化Handler
     */
    public Handler(Looper looper, Callback callback) {
        this(looper, callback, false);
    }

    /**
     *该构造方法中的参数决定是否以异步方式发出消息
     * @hide
     */
    public Handler(boolean async) {
        this(null, async);
    }

    /**
     * 该构造方法中IND_POTENTIAL_LEAKS，查询是否有内存泄漏的情况，如果存在会有日志打出
     * 构造方法大多都会调用该构造方法，完成初始化
     */
    public Handler(Callback callback, boolean async) {
        if (FIND_POTENTIAL_LEAKS) {
            final Class<? extends Handler> klass = getClass();
            if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
                    (klass.getModifiers() & Modifier.STATIC) == 0) {
                Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
                    klass.getCanonicalName());
            }
        }

        mLooper = Looper.myLooper();
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

    /**
     * @hide
     */
     内部方法不对外暴露
    public Handler(Looper looper, Callback callback, boolean async) {
        mLooper = looper;
        mQueue = looper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

    /** @hide */
    @NonNull
    内部方法不对外暴露，MAIN_THREAD_HANDLER是成员变量
    public static Handler getMain() {
        if (MAIN_THREAD_HANDLER == null) {
            MAIN_THREAD_HANDLER = new Handler(Looper.getMainLooper());
        }
        return MAIN_THREAD_HANDLER;
    }

    /** @hide **/
    @NonNull
    内部方法不对外暴露
    public static Handler mainIfNull(@Nullable Handler handler) {
        return handler == null ? getMain() : handler;
    }

    /** {@hide} */
    内部方法不对外暴露，简单的字符串组合之类的操作
    public String getTraceName(Message message) {
        final StringBuilder sb = new StringBuilder();
        sb.append(getClass().getName()).append(": ");
        if (message.callback != null) {
            sb.append(message.callback.getClass().getName());
        } else {
            sb.append("#").append(message.what);
        }
        return sb.toString();
    }

    /**
     * 返回一个消息对应的特殊字符串，具体字符串怎么组合出来的可以看以下源码 
     */
    public String getMessageName(Message message) {
        if (message.callback != null) {
            return message.callback.getClass().getName();
        }
        return "0x" + Integer.toHexString(message.what);
    }

    /**
     * 以下方法均是从消息队列中获取消息的方法
     */
    public final Message obtainMessage()
    {
        return Message.obtain(this);
    }
    public final Message obtainMessage(int what)
    {
        return Message.obtain(this, what);
    }
    public final Message obtainMessage(int what, Object obj)
    {
        return Message.obtain(this, what, obj);
    }
    public final Message obtainMessage(int what, int arg1, int arg2)
    {
        return Message.obtain(this, what, arg1, arg2);
    }
    public final Message obtainMessage(int what, int arg1, int arg2, Object obj)
    {
        return Message.obtain(this, what, arg1, arg2, obj);
    }

    /**
     * 把runnable加入的消息队列中去 ，该runnable中的操作将会在Handler所在的线程中执行
     */
    public final boolean post(Runnable r)
    {
       return  sendMessageDelayed(getPostMessage(r), 0);
    }
    
   /**
     * 把runnable加入的消息队列中去 ，该runnable中的操作将会在Handler所在的线程中执行；其中参数uptimeMills指定了具体的什么时间执行该Runnable
     */
    public final boolean postAtTime(Runnable r, long uptimeMillis)
    {
        return sendMessageAtTime(getPostMessage(r), uptimeMillis);
    }
    
    /**
     * 该方法相对于postAtTime(Runnable r, long uptimeMillis)，多了一个token参数，这个参数命名有点误导的含义，其实就是message的object字段，该部分可以从getPostMessage(r, token)获知
     */
    public final boolean postAtTime(Runnable r, Object token, long uptimeMillis)
    {
        return sendMessageAtTime(getPostMessage(r, token), uptimeMillis);
    }
    
    /**
     * delayMills指定从当前时间开始以后的多少毫秒，执行r操作
     */
    public final boolean postDelayed(Runnable r, long delayMillis)
    {
        return sendMessageDelayed(getPostMessage(r), delayMillis);
    }
    
    /**
     将消息发布到实现Runnable的对象，使Runnabler在下一次迭代中执行。 runnable将在此线程上运行处理程序。此方法适用于非常特殊的情况 ,它可以轻易地使消息队列饿死，导致排序问题，或者有其他意想不到的副作用。       
     */
    public final boolean postAtFrontOfQueue(Runnable r)
    {
        return sendMessageAtFrontOfQueue(getPostMessage(r));
    }

    /**
     * timeout指定等待时间，runnable在等待指定时间以后会理解执行。不会在messageQueue中排队
     * 这种方法很危险！使用不当可能导致死锁。在持有任何锁或在重复使用时，切勿调用此方法
     */
    public final boolean runWithScissors(final Runnable r, long timeout) {
        if (r == null) {
            throw new IllegalArgumentException("runnable must not be null");
        }
        if (timeout < 0) {
            throw new IllegalArgumentException("timeout must be non-negative");
        }

        if (Looper.myLooper() == mLooper) {
            r.run();
            return true;
        }

        BlockingRunnable br = new BlockingRunnable(r);
        return br.postAndWait(this, timeout);
    }

    /**
     *移除将要进行的操作
     */
    public final void removeCallbacks(Runnable r)
    {
        mQueue.removeMessages(this, r, null);
    }
    public final void removeCallbacks(Runnable r, Object token)
    {
        mQueue.removeMessages(this, r, token);
    }

    /**
     *向消息队列发送消息
     */
    public final boolean sendMessage(Message msg)
    {
        return sendMessageDelayed(msg, 0);
    }
    public final boolean sendEmptyMessage(int what)
    {
        return sendEmptyMessageDelayed(what, 0);
    }
    public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
        Message msg = Message.obtain();
        msg.what = what;
        return sendMessageDelayed(msg, delayMillis);
    }
    public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis) {
        Message msg = Message.obtain();
        msg.what = what;
        return sendMessageAtTime(msg, uptimeMillis);
    }
    public final boolean sendMessageDelayed(Message msg, long delayMillis)
    {
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
    }
    public boolean sendMessageAtTime(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);
    }

    /**
     *立即把消息发送到消息队列，有点插队的意思，立即插到队列的最前部
     */
    public final boolean sendMessageAtFrontOfQueue(Message msg) {
        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, 0);
    }

    private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }
    //移除消息
    public final void removeMessages(int what) {
        mQueue.removeMessages(this, what, null);
    }

    public final void removeMessages(int what, Object object) {
        mQueue.removeMessages(this, what, object);
    }
    public final void removeCallbacksAndMessages(Object token) {
        mQueue.removeCallbacksAndMessages(this, token);
    }
    //检查是否包含某个消息
    public final boolean hasMessages(int what) {
        return mQueue.hasMessages(this, what, null);
    }
     public final boolean hasMessages(int what, Object object) {
        return mQueue.hasMessages(this, what, object);
    }

    //检查handler是否有message或者callback
    public final boolean hasMessagesOrCallbacks() {
        return mQueue.hasMessages(this);
    
    public final boolean hasCallbacks(Runnable r) {
        return mQueue.hasMessages(this, r, null);
    }

    //获取handler对应的looper
    public final Looper getLooper() {
        return mLooper;
    }
  
}

未完待续 后续还会对Looper的代码进行解读

Hale王
关注
专栏目录
获取主线程的handler
INX的博客
03-30 9611
    通常我们封装框架的时候需要回调主线很多时候是传个handler进来，或者用rxjava、eventbus等跨线程交换数据的方式。    如果通过handler的形式切换线程就需要获取到主线程的handler，这时候以前都是通过在activity中创建实例后传进来，但是这样子不太美观，所以应然而生在其他地方获取到主线程的handler是尤为重要。   具体代码如下：private Handl...
handler 学习总结
tingyalove的专栏
05-13 651
这几天学习的内容做些总结。
Handler学习（一）- 使用
kk的博客
07-23 313
handler使用： 1）若在Activity主线程中直接用handler - handler和looper在主线程 handler和looper均在主线程，这里可以不需要自己调looper,因为activity的ActivityThread中已经创建并调了loop，而且由于handler一般是用来更新主线程UI的，所以需要保证消息分发来自同一个线程，否则界面更新处理来自多个looper发送的消息会出现布局混乱，而加锁等线程同步会让更新变的更慢还可能出现死锁，得不偿失。 ActivityTh.
android_handler学习笔记
01-23
Handler在android里负责发送和处理消息。它的主要用途有(或者是干什么的)： 　1）执行计划任务，按计划（定时）发送消息或执行某个Runnanble(使用POST方法)； 　2）线程间通信，把从其他线程中发送来的消息放入消息...
Android:Handler学习实例1
10-11
Android中Handler的学习实例，在本示例中，在主线程外开启子线程（使用匿名内部类Runnable），使用Handler中的Message传递消息（高效），操作一个ProgressBar的进度。适合初学者学习和了解Handler以及ProgressBar的...
Android:Handler学习实例2（HandlerThread、Bundle传递参数）
10-12
HandlerThread handlerThread = new HandlerThread("handler_thread"); //在使用HandlerThread的getLooper()方法之前，必须先调用该类的start()方法，否则获得的值为空值； handlerThread.start(); //创建...
android handler学习文档（多个）
05-17
本学习文档集包含了12个深入解析`Handler`的资料，旨在帮助开发者全面理解并熟练运用`Handler`来解决线程间的通信问题。 1. **Android消息循环系统** Android的消息循环系统由`Looper`、`MessageQueue`和`Handler`...
Handler学习（一）
飞梦
09-16 564
android为了优化性能，采用的并非线程安全操作，这意味着如果多线程并发操作UI可能出现安全问题，为解决此问起，android规定只能使UI线程操作activity的UI组件。 当一个activity启动时，启动一个主线程，主线程主要负责UI的相关操作！例如： 布局文件： <RelativeLayout xmlns:android="http://schemas.android.com/a
Handler学习笔记
hejiyanghjy的博客
09-28 297
Handler相关知识梳理1、为什么要使用Handler？因为Android系统只能在主线更新UI，而我们的数据操作经常是由子线程来完成的。为什么子线程不能更新UI？因为如果多线程操作UI会导致UI处于不可预知的状态；那可不可以用加锁的方式来解决这个问题呢？加锁会让访问UI的逻辑变得很复杂，而且会降低访问效率。 2、Handler消息机制原理在程序中，我们一般的做法是调用Handler.SendMe
handler机制学习总结
weixin_44630656的博客
06-23 330
handler机制学习总结一、Handler介绍二、Handler的使用三、源码分析3.1 创建循环器对象（Looper） & 消息队列对象（MessageQueue）3.2 创建消息对象3.3 发送消息3.4 取出处理消息 一、Handler介绍 Handler的作用 在多线程的应用场景中，将工作线程中需更新UI的操作信息 传递到 UI主线程，从而实现 工作线程对UI的更新处理，最终实现异步消息的处理 Looper、MessageQueue、Message、Handler的关系
Handler学习小结
王温暖的博客
03-17 256
  写在前面的总结：  Handler其实可以作为一个宏观的消息传递机制来看，平时我们在主线程中实例化一个handler，并重写handleMessage方法，在子线程中完成耗时操作，并拿着主线程中初始化的handler来发送消息给主线程，告诉主线程：你可以更新UI啦。这就是一个完整的消息传递流程。这个流程其实也就是最常用的子线程拿着主线程的handler发送消息给主线程，这个handler就像是...
关于Handler学习的一些自我小结
XL
03-02 253
Handler在Android实现异步扮演了一个很重要的角色，所以记录下学习之后的一些小结。
Handler原理学习简记
我的博客
11-08 172
1.Handler looper MessageQueue 的关系和作用： ①Handler 负责消息的发送 和 处理的。 ②looper是负责 接收 handler传送过来的消息，以及 回传给handler自己 ③MessageQueue 是存储消息的容器 2.重点函数解说: looper的looper方法 里面是有一个死循环，死循环里面的是如下处理： looper从消息队列里取出一个...
Android知识点：Handler
qq_30207527的博客
11-19 196
一、什么是Handler Handler是种消息的传递机制，通过发送Message和处理Meesage和Runnable对象，来关联对应线程的Looper和MessageQueue实现线程消息传递。常用于子线程向主线程发送消息更新ui。当然也有其他用处。   二、Handler的使用 1、sendMessage（Message msg） 2、post (Runnable runnable...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值