子线程中:new Handler需要做哪些准备?消息队列中无消息的时候,Looper的处理方案是什么?

为什么主线程可以new Handler?

在ActivityThread.java里有一个main()函数,它是Android每一个应用最早执行的函数。

    public static void main(String[] args) {

        .....

        Looper.prepareMainLooper();

        ActivityThread thread = new ActivityThread();
        thread.attach(false);

        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }

        if (false) {
            Looper.myLooper().setMessageLogging(new
                    LogPrinter(Log.DEBUG, "ActivityThread"));
        }

        // End of event ActivityThreadMain.
        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
        Looper.loop();

        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

它先prepare的,看这个prepare干了些什么事情?

    public static void prepareMainLooper() {
        prepare(false);
        synchronized (Looper.class) {
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            sMainLooper = myLooper();
        }
    }

prepare是初始化,初始化了一个Looper。

然后又接着调用的Looper.loop()函数,这个loop()函数其实就是执行了那个for循环,它不断的调用next()函数,通过调用next()函数去轮询我们的MessageQueue。

如果不调用prepare(),Looper没有被初始化;如果不调用loop(),Looper的机制滚动不起来。所以,所有的执行必须先prepare(),然后再loop()。

回到问题,为什么主线程不需要做这些操作呢?

因为主线程一启动的时候,在main()函数中,由系统已经帮我们完成了,我们主线程中的所有代码,全都运行在这两个函数(prepare() 和 loop())之间。

 

在子线程中new Handler需要做哪些准备?

在上一题 为什么主线程可以new Handler?中其实已经解答,所有的线程都必须要prepare()和loop(),如果子线程中想要进行Handler操作,就必须在子线程中执行prepare() 和 loop()。

 

子线程中维护的Looper,消息队列无消息的时候的处理方案是什么?

我们先来创建一个子线程,然后子线程中创建了一个Looper,并且发送了一个消息,消息处理完了,看一下会发生什么样的事情。

    Handler threadHandler;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        new Thread(new Runnable() {
            @Override
            public void run() {
                if (threadHandler == null){
                    Looper.prepare();
                    threadHandler = new Handler(){
                        @Override
                        public void handleMessage(Message msg) {
                            super.handleMessage(msg);
                            Log.e("seas","handle Message");
                        }
                    };
                    Log.e("seas","Looper loop() UP");
                    Looper.loop();
                    Log.e("seas","Looper loop() DOWN");
                }
            }
        }).start();

    }

    public void click(View view){
        Log.e("seas","click");
        threadHandler.sendMessage(threadHandler.obtainMessage());

    }

我运行之后,再点击执行click方法,就出现了如下的log。

如果这个子线程结束,那么他应该是有调用到 Log.e("seas","Looper loop() DOWN"); 这个语句才对,但是它并没有,这就意味着这个Looper一直处于一个阻塞状态。

也就是说它一直卡在了这个地方:

        for (;;) {
            Message msg = queue.next(); // might block

            .....
        }

所以它就一直在等待,这个子线程也已经干不了其他的事情了,其实也被卡死了。

子线程中维护的Looper,消息队列无消息的时候的处理方案是什么?有什么用?

在Handler机制里面有一个Looper,在Looper机制里面有一个函数,叫做quitSafely()和quit()函数,这两个函数是调用的MessageQueue的quit()。

    /**
     * Quits the looper.
     * 

* Causes the {@link #loop} method to terminate without processing any * more messages in the message queue. *

* Any attempt to post messages to the queue after the looper is asked to quit will fail. * For example, the {@link Handler#sendMessage(Message)} method will return false. *

* Using this method may be unsafe because some messages may not be delivered * before the looper terminates. Consider using {@link #quitSafely} instead to ensure * that all pending work is completed in an orderly manner. *

* * @see #quitSafely */ public void quit() { mQueue.quit(false); } /** * Quits the looper safely. *

* Causes the {@link #loop} method to terminate as soon as all remaining messages * in the message queue that are already due to be delivered have been handled. * However pending delayed messages with due times in the future will not be * delivered before the loop terminates. *

* Any attempt to post messages to the queue after the looper is asked to quit will fail. * For example, the {@link Handler#sendMessage(Message)} method will return false. *

*/ public void quitSafely() { mQueue.quit(true); }

再进入到MessageQueue的quit()函数。

    void quit(boolean safe) {
        if (!mQuitAllowed) {
            throw new IllegalStateException("Main thread not allowed to quit.");
        }

        synchronized (this) {
            if (mQuitting) {
                return;
            }
            mQuitting = true;

            if (safe) {
                removeAllFutureMessagesLocked();
            } else {
                removeAllMessagesLocked();
            }

            // We can assume mPtr != 0 because mQuitting was previously false.
            nativeWake(mPtr);
        }
    }

它会remove消息,把消息队列中的全部消息给干掉。

把消息全部干掉,也就释放了内存

    private void removeAllFutureMessagesLocked() {
        final long now = SystemClock.uptimeMillis();
        Message p = mMessages;
        if (p != null) {
            if (p.when > now) {
                removeAllMessagesLocked();
            } else {
                Message n;
                for (;;) {
                    n = p.next;
                    if (n == null) {
                        return;
                    }
                    if (n.when > now) {
                        break;
                    }
                    p = n;
                }
                p.next = null;
                do {
                    p = n;
                    n = p.next;
                    p.recycleUnchecked();
                } while (n != null);
            }
        }
    }

而在quit()函数的最后一行,有一个nativeWake()函数。

            // We can assume mPtr != 0 because mQuitting was previously false.
            nativeWake(mPtr);

这个函数的调用,就会叫醒等待的地方,醒来之后,就接着往下执行。

            //native的方法,在没有消息的时候回阻塞管道读取端,只有nativePollOnce返回之后才能往下执行
            //阻塞操作,等待nextPollTimeoutMillis时长
            nativePollOnce(ptr, nextPollTimeoutMillis);

往下执行后,发现 Message msg = mMessages; 是空的,然后就执行了这个,就接着往下走。

                if (msg != null) {

                   ......

                } else {
                    // No more messages.
                	//没有消息,nextPollTimeoutMillis复位
                    nextPollTimeoutMillis = -1;
                }

然后又调用了这个方法,并且return了null。

                // Process the quit message now that all pending messages have been handled.
                //如果消息队列正在处于退出状态返回null,调用dispose();释放该消息队列
                if (mQuitting) {
                    dispose();
                    return null;
                }

所以说,这个时候Looper就结束了(跳出了死循环),则达成了第二个作用:释放线程

 

如果我在刚才的例子上加入退出操作。

    public void stopclick(View view){
        Log.e("seas","click");
        threadHandler.getLooper().quit();

    }

打印如下:

这个线程就真正的执行了,否则这个线程就一直在等待。

如果在子线程中创建了一个Handler,那么就必须做三个操作:

1. prepare();

2. loop();

3. quit();

 

主线程中能否调用quit()方法?

是不能的。它会抛出一个异常,让程序挂掉。

    void quit(boolean safe) {
        if (!mQuitAllowed) {
            throw new IllegalStateException("Main thread not allowed to quit.");
        }
        ......
    }

 

你可能感兴趣的:(Android)