handler消息机制

时间 2020-09-21

标签 handler 消息机制繁體版

原文原文链接

MessageQueue代码：http://grepcode.com/file_/repository.grepcode.com/java/ext/com.google.android/android/5.1.1_r1/android/os/MessageQueue.java/?v=sourcejava

Handler代码：android

http://grepcode.com/file_/repository.grepcode.com/java/ext/com.google.android/android/5.1.1_r1/android/os/Handler.java/?v=sourcegit

Looper代码：github

http://grepcode.com/file_/repository.grepcode.com/java/ext/com.google.android/android/5.1.1_r1/android/os/Looper.java/?v=sourceless

为何有handler,handler的主要做用是什么？异步

首先android UI主线程不能进行大量的耗时操做，不然会产生ANR以及很差的UI体验，所以必须经过异步的方式处理耗时的操做，避免耗时的操做阻塞UI主线程。async

handler的主要做用是什么呢，主要负责多个线程之间的信息通讯，好比子线程中中耗时操做返回结果须要在UI线程进行展现，这时候就须要经过handler来将消息传递到UI线程并刷新UI内容。ide

handler的消息机制主要牵扯三方面：oop

消息发送者；
消息队列；
消息处理循环操做。

handler发消息有两种方式：post

send
1. sendEmptyMessage(int)，发送一个空的消息;
2. sendMessage(Message)，发送消息，消息中能够携带参数;
3. sendMessageAtTime(Message, long)，将来某一时间点发送消息;
4. sendMessageDelayed(Message, long)，延时Nms发送消息。
post
1. post(Runnable)，提交计划任务立刻执行;
2. postAtTime(Runnable, long)，提交计划任务在将来的时间点执行;
3. postDelayed(Runnable, long)，提交计划任务延时Nms执行。

messageQueue：消息队列，对外提供插入和删除的工做，内部存储结构为单链表结构。

messageQueue的两个主要方法：

enqueueMessage:向消息队列中插入元素；
next：从消息队列中取出元素，是个无线循环的方法，无消息，阻塞，有消息，返回消息并从消息队列中将消息移除。

looper:用来构建轮训消息队列系统。

线程默认没有looper,使用handler就必须为线程建立looper。

Looper.prepare()建立Looper;
Looper.loop()开启消息循环;
Looper.prepareMainLooper()主线程建立looper;
quit:直接退出Looper;
quitSafely:设定退出标志，已有消息处理完之后才会退出。

消息发送：post方式发送消息的方式最后调用的仍是sendMessage方式：

 public final boolean post(Runnable r)
    {
       return  sendMessageDelayed(getPostMessage(r), 0);
    }

public final boolean More ...sendMessage(Message msg)
    {
        return sendMessageDelayed(msg, 0);
    }

往下走：

 public final boolean More ...sendMessageDelayed(Message msg, long delayMillis)
    {
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
    }

最后走到这里:

public boolean More ...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);
    }

调用 enqueueMessage 在消息队列中插入一条消息，在 enqueueMessage总中，会把 msg.target 设置为当前的Handler 对象。

private boolean More ...enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
    msg.target = this;
    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    return queue.enqueueMessage(msg, uptimeMillis);
}

以下将消息插入消息队列中去。而且能够很明显看出消息队列是线性链表结构。

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("MessageQueue", 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;
}

每一个线程只能运行一个looper对象，建立 Looper 的时候，内部会建立一个消息队列MessageQueue;而且looper在线程里面必须先prepare(),再loop来对消息队列messageQueue来进行遍历循环操做。

public static void loop() {
        final Looper me = myLooper();
        //若是looper对象是空的，就提示必须在当前线程经过looper.prepare()来进行建立
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        //若是looper不为null,就取出消息队列
        final MessageQueue queue = me.mQueue;

        Binder.clearCallingIdentity();
        final long ident = Binder.clearCallingIdentity();
        //遍历消息队列
        for (;;) {
            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                //没有消息中断操做，跳出循环
                return;
            }

            //----------------队列不为null的操做----------------
            // This must be in a local variable, in case a UI event sets the logger
            Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to " + msg.target + " " +
                        msg.callback + ": " + msg.what);
            }
            //----------------队列不为null，分发数据出去---------------- msg.target.dispatchMessage(msg); if (logging != null) {
                logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
            }

            // Make sure that during the course of dispatching the
            // identity of the thread wasn't corrupted.
            final long newIdent = Binder.clearCallingIdentity();
            if (ident != newIdent) {
                Log.wtf(TAG, "Thread identity changed from 0x"
                        + Long.toHexString(ident) + " to 0x"
                        + Long.toHexString(newIdent) + " while dispatching to "
                        + msg.target.getClass().getName() + " "
                        + msg.callback + " what=" + msg.what);
            }

            msg.recycleUnchecked();
        }
    }

循环遍历并分发消息出去msg.target.dispatchMessage(msg)，切换到建立handler所使用的looper中执行，也就是说将逻辑切换到主线程去：

/**
     * Handle system messages here.
     *首先，若是消息的 callback 不是空，便调用 handleCallback 处理。不然判断 Handler 的 mCallback 是否为空，不为空则调用它的 handleMessage方法。若是仍然为空，才调用 Handler 自身的 handleMessage，也就是咱们建立 Handler 时重写的方法 */
public void dispatchMessage(Message msg) {
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        //回调handler的handleMessage(msg)方法，从而接收数据  handleMessage(msg);
    }
}

额，先写到这，明天继续更新。

hander的相关问题的延伸：

handler在实际开发中常见的问题就是内存泄漏的问题了：

常见的写法：

 private Handler   handler    = new Handler() { public void handleMessage(android.os.Message msg) { switch (msg.what) {
                case UPDATE_TEXTVIEW:
                    updateTextView();
                    break;

                default:
                    break;
            }
        }
    };

1，在Java中，非静态的内部类和匿名内部类都会隐式地持有其外部类的引用，静态的内部类不会持有外部类的引用，经过将类声明为静态的，解决持有外部类引用的问题；

2，android主线程有looper,looper处理MessageQueue消息队列数据的进进出出，Message添加到消息队列中的时候Message(排队的Message)会持有当前Handler引用,处理消息，并在ui界面上进行结果展现或者toast()或者dialog对话框弹出，就会产生MessageQueue 到 Message 到 Handler 到 Activity的引用链。

为了解决静态内部类没法操做外部类的内容，将activity做为弱引用引入，这样就就能够避免引用的问题，有能够对外部类的方法进行调用。

那么如何解决呢？

private Handler   handler    = new MyHandler( BackPasswordActivity.this );

    private class MyHandler extends Handler {
        private WeakReference<Activity> mActivity;


        public MyHandler(BackPasswordActivity activity) {
            mActivity = new WeakReference<Activity>( activity );
        }


        @Override public void handleMessage(Message msg) {
            super.handleMessage( msg );
            MainActivity activity = (MainActivity) mActivity.get();
            if (activity != null) updateTextView();
        }
    }

还有一种解决方式：WeakHandler

开源库地址：https://github.com/badoo/android-weak-handler

实际项目中使用:

1,引入：compile 'com.badoo.mobile:android-weak-handler:1.1'，固然也能够代码引入，就一个类；

2，代码中的使用：

声明以及在主线程中接收消息，注意和咱们的handler的写法的不一样：

 WeakHandler myHandler = new WeakHandler(new Handler.Callback() { @Override public boolean handleMessage(Message msg) { switch (msg.what) {
                    case 1:
                        //UI操做
                        if (!StringUtil.isEmpty(tradeNo)) {
                            rechargeStatus();
                        }
                        break;
                    default:
                        break;
                }
                return false;
            }
        });

发送消息：

    Message message = new Message();
    message.what = 1;
    myHandler.sendMessage(message);  //发送message