Handler，Looper，Message,MessageQu

作者: 有点健忘 | 来源:发表于2018-03-16 11:58 被阅读15次

首先看下handler的源码

    public interface Callback {
        public boolean handleMessage(Message msg);
    }
    
    /**
     * Subclasses must implement this to receive messages.
     */
    public void handleMessage(Message msg) {
    }
    
    /**
     * Handle system messages here.
MessageQueue里最终调用的就是这个方法，可以看到分3种情况
     */
    public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }

MessageQueue里最终调用的就是Handler的这个dispatchMessage方法，可以看到分3种情况，首先看message有没有设置callback，完事看handler有没有设置callback，并且返回true，最后都没有的话才调用handleMessage方法。
Message是可以设置callback的，下边是初始化方法

image.png

Handler也是可以传个callback的，下图是构造方法

image.png

以前也没仔细看过，

一直以来都是直接重写handler的handleMessage来处理消息的。
如下图这种：Message自带一个runnable这种的，到时候收到消息执行的就是run的方法了。

message=Message.obtain(handler, new Runnable() {
            
            @Override
            public void run() {
                
                
            }
        });

另一种，handler构造方法里可以传一个Callback的参数的,如果这玩意返回true，就表示自己处理了，否则就继续调用Handler里的那个handleMessage方法了。

    public Handler(Callback callback) {
        this(callback, false);
    }
     public interface Callback {
        public boolean handleMessage(Message msg);
    }

Handler内部是有一个Looper的，如果handler是在主线程创建的，那么这个looper不需要处理，系统自己已经初始化了一个looper了。
如果我们在一个新的线程里用handler，那么必须给予一个looper，否则就会挂掉，如下代码：

        new Thread(new Runnable() {
            
            @Override
            public void run() {
            new Handler().post(new Runnable() {
                
                @Override
                public void run() {
                    System.err.println("myLooper=======1========"+Looper.myLooper());
                }
            });
                
            }
        }).start();

运行以后就会挂了，提示如下错误：
java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare()
原因看源码：Handler构造方法里会判断looper有没有初始化，没有它就挂了。

    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;
    }

下面是正确的写法：

        new Thread(new Runnable() {

            @Override
            public void run() {
                Looper.prepare();
                
                new Handler().post(new Runnable() {

                    @Override
                    public void run() {
                        System.err.println("myLooper=======1========" + Looper.myLooper());
                                                Looper.myLooper().quit();
                    }
                });

                Looper.loop();//这玩意是个死循环
            }
        }).start();

其中Looper.prepare(); 就是用来给当前线程创建一个Looper
Looper.loop(),用来处理messageQueue里的消息的，所以上边的runnable里的代码需要运行，这两个方法缺一不可。
稍微简单看下Looper的源码：

//构造方法
    private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
    }

//prepare方法就是new一个放到sThreadLocal里
    public static void prepare() {
        prepare(true);
    }

    private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }

//loop方法就是处理messageQueue里的message的
    /**
     * Run the message queue in this thread. Be sure to call
     * {@link #quit()} to end the loop.
     */
    public static void loop() {
        final Looper me = myLooper();
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        final MessageQueue queue = me.mQueue;

        // Make sure the identity of this thread is that of the local process,
        // and keep track of what that identity token actually is.
        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;
            }

            // 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);
            }

            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();
        }
    }

继续分析looper这个玩意，大家一直说他是死循环，虽然我也看到了for(;;)可我更看到了if (msg == null)

    public static void loop() {
        final Looper me = myLooper();
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        final MessageQueue queue = me.mQueue;

        // Make sure the identity of this thread is that of the local process,
        // and keep track of what that identity token actually is.
        Binder.clearCallingIdentity();
        final long ident = Binder.clearCallingIdentity();

        for (;;) {
            Message msg = queue.next(); // might block
            if (msg == null) {//我第一眼看到是这里，我想，我不给你设置message你不就return？might block这个提示我完全没当回事
                // No message indicates that the message queue is quitting.
                return;
            }

            // 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);
            }

            msg.target.dispatchMessage(msg);

今天跑去看了下 queue.next();这个方法,原来这个next也是个死循环，我靠，非得有一个message它才返回，所以就解释了为啥上边的msg基本不可能为空，当然了，在looper调用quit方法的时候，也会把MessageQueue里的mQuitting改为真，next里的死循环就会返回null了，上边pool方法里是死循环也就一起结束了。

 Message next() {
        // Return here if the message loop has already quit and been disposed.
        // This can happen if the application tries to restart a looper after quit
        // which is not supported.
        final long ptr = mPtr;
        if (ptr == 0) {
            return null;
        }

        int pendingIdleHandlerCount = -1; // -1 only during first iteration
        int nextPollTimeoutMillis = 0;
        for (;;) {
            if (nextPollTimeoutMillis != 0) {
                Binder.flushPendingCommands();
            }

            nativePollOnce(ptr, nextPollTimeoutMillis);

            synchronized (this) {
                // Try to retrieve the next message.  Return if found.
                final long now = SystemClock.uptimeMillis();
                Message prevMsg = null;
                Message msg = mMessages;
                if (msg != null && msg.target == null) {//不为空
                    // Stalled by a barrier.  Find the next asynchronous message in the queue.
                    do {
                        prevMsg = msg;
                        msg = msg.next;
                    } while (msg != null && !msg.isAsynchronous());
                }
                if (msg != null) {//不为空，为空啥也没干，继续循环
                    if (now < msg.when) {
                        // Next message is not ready.  Set a timeout to wake up when it is ready.
                        nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                    } else {
                        // Got a message.
                        mBlocked = false;
                        if (prevMsg != null) {
                            prevMsg.next = msg.next;
                        } else {
                            mMessages = msg.next;
                        }
                        msg.next = null;
                        if (DEBUG) Log.v(TAG, "Returning message: " + msg);
                        msg.markInUse();
                        return msg;
                    }
                } else {
                    // No more messages.
                    nextPollTimeoutMillis = -1;
                }

                // Process the quit message now that all pending messages have been handled.
                if (mQuitting) {//looper调用quit方法，也会调用messageQueue里的quit方法，把这个值改成true的。
                    dispose(); 
                    return null;
                }

最后总结一下：

//如下是一个新开的线程里的方法片段
Looper.prepare();
                
                new Handler().postDelayed(new Runnable() {

                    @Override
                    public void run() {
                        
                         Looper looper=Looper.myLooper();
                        if(looper!=null) {
                            looper.quit();
                        }
                    }
                },3333);

                Looper.loop();

我们可以看到3步走

1 Looper.prepare(); 初始化Looper

2 Handler post 一个Runnable，其实就是往MessageQueue里添加一个新的Message

3 开始loop循环从MessageQueue里取Message

其实还有个第4步，就是调用quit方法退出。如果不调用quit方法，Looper.loop();后边再写代码就不会执行了。loop是个死循环。

实际中的应用

如果要new一个非主线程的looper，我们一般是如下做法

        val handlerThread=HandlerThread("aa")
        handlerThread.start()
        val handler=Handler(handlerThread.looper)
//        handler.sendEmptyMessage(1)
        handlerThread.quit()

handlerthread 调用start的时候会初始化一个looper的。完事quit的时候会调用looper的quit
看下HandlerThread的run方法

    public void run() {
        mTid = Process.myTid();
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
            notifyAll();
        }
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        Looper.loop();
        mTid = -1;
    }

quit方法

    public boolean quit() {
        Looper looper = getLooper();
        if (looper != null) {
            looper.quit();
            return true;
        }
        return false;
    }

关系总结

首先Handler需要一个Looper【Looper里包含一个Messagequeue】
Handler和Message之间最后都是通过messagequeue.enqueueMessage(msg, uptimeMillis)把message放到messagequeue里。
完事looper在执行loop方法以后会有个循环获取messagequeue里的消息，通过next（）方法，而
messagequeue.next(）方法是个block的，有数据就返回，没数据就阻塞。所以looper的loop方法也就一直在阻塞的，要退出需要调用quit方法

其他一些东西

我们的activity是有一个ActivityThread的东西的。
百度搜索：Android 主线程looper
看这里：http://blog.csdn.net/u013435893/article/details/50903082
为撒死循环不会挂掉：https://www.zhihu.com/question/34652589

打印下一般的activity启动了几个线程

int count = Thread.activeCount();
                Thread[] threads=new Thread[count];
                Thread.enumerate(threads);
                for(Thread thread:threads) {
                    System.err.println("==="+thread.toString());
                }
03-15 04:25:31.061: W/System.err(16637): ===Thread[Binder_4,5,main]
03-15 04:25:31.061: W/System.err(16637): ===Thread[Binder_3,5,main]
03-15 04:25:31.061: W/System.err(16637): ===Thread[RenderThread,5,main]
03-15 04:25:31.061: W/System.err(16637): ===Thread[Binder_2,5,main]
03-15 04:25:31.061: W/System.err(16637): ===Thread[Binder_1,5,main]
03-15 04:25:31.061: W/System.err(16637): ===Thread[main,5,main]

可能是经常new一个Thread出来里边都带一个Runnable的构造方法，所以啊，今天执行下面的代码

        new Runnable() {
            
            @Override
            public void run() {
                System.err.println("Runnable=======2========" + Looper.myLooper());
            }
        }.run();

我还想着是个新线程，其实还是主线程。哎，thread和runnable天天黏在一起，害的我把他俩当一回事了。

Handler，Looper，Message,MessageQu

1 Looper.prepare(); 初始化Looper

2 Handler post 一个Runnable，其实就是往MessageQueue里添加一个新的Message

3 开始loop循环从MessageQueue里取Message

实际中的应用

关系总结

其他一些东西

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读