问题解答-Handler问题汇总及解答

在上篇博文我讲解了handler的源码，部分的细节由于篇幅的原因没有办法在上一篇讲解，我放在这里一起讲解。

---

问题：

1.looper是个死循环为什么不会堵住线程？

在应用的启动的main方法

public static void main(String[] args) {
        ...

        Environment.initForCurrentUser();

        EventLogger.setReporter(new EventLoggingReporter());

        final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
        TrustedCertificateStore.setDefaultUserDirectory(configDir);

        Process.setArgV0("<pre-initialized>");

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

从这里可以看出在Looper.loop()后面的那一行是程序抛出的运行异常，从异常的message可以得知，主线程的Looper不会被退出。从源码上看，这个Looper是被堵塞了，但是一旦有消息被send，那么Looper就会第一时间被唤醒并从messagequeue中取出message进行处理，正因为这种及时的机制才不会导致程序的anr。

 

2.looper handler messagequeue message 什么关系

message 传送信息的实体单位

messagequeue 是一个装有一个到多个message多的容器。

looper像当与传送带，他会把messagequeue中的message不断的传递给handler，Looper在初始化的时候会，Looper会与messagequeue进行进行绑定。

handler 用来发送message，在初始化的时候handler与looper进行绑定，最后looper会回调handler的方法。

 

3.looper handler messagequeue message的数量对应关系

loopper messagequeue 1：1

messagequeue message 1：N

loopper handler  1：N

 

4.如何回调给对应的handler

在sendmessage的时候给message设置了target（当前的handler）

 

5.如何在子线程中使用handler

需要在创建handler之前调用Looper.prepare(); 

最后使用Looper.loop()方法

 

6.obtain 创建Message 与new message的区别？

从源码看obtain创建的message先是会从缓存中获取，若能获取到将这个缓存中的message就会进初始化。如果获取不到的话，在进行new出来一个新的message。所以我们在使用的过程中最好还是使用obtain的方式获取message

 

7.handler的内存泄漏

在使用handler的过程中，handler通常会持有使用页面的对象，如果这在个过程中页面退出了，那么由于这个页面还有被持有，所以这个页面不会被gc所回收。

那么我们应该怎么做呢？

（1）把handler设置成内部静态类

内部静态类不会持有外部类的对象。

（2）使用 WeakReference 包裹外部类的对象

在内部类中需要使用对象的情况下，使用WeakReference代替原本的强应用

下面我举个简单的例子

    Handler timeHander;
	private ScheduledThreadPoolExecutor mScheduledThreadPoolExecutor;
	
	private void startRecordTime() {
        timeHander = new TimerHandler(this);
        mScheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(2);
        mScheduledThreadPoolExecutor.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                timeHander.sendEmptyMessage(TIME_TEXTVIEW_CHANGE_CODE);
            }
        }, 0, 1, TimeUnit.SECONDS);
    }
	
	private static final int TIME_TEXTVIEW_CHANGE_CODE = 1000;

    private static class TimerHandler extends Handler {
        private WeakReference<SubmitTaskActivity> mActivity;

        public TimerHandler(SubmitTaskActivity activity) {
            mActivity = new WeakReference<SubmitTaskActivity>(activity);
        }

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            if (mActivity.get() != null) {
                if (msg.what == TIME_TEXTVIEW_CHANGE_CODE) {
                    try {
                        (mActivity.get()).tv_st_now_time.setText(TimeUtil.millisToString(TimeUtil.PatternYMDHMS, new Date()));
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
	
	    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (mScheduledThreadPoolExecutor != null && !mScheduledThreadPoolExecutor.isShutdown()) {
            mScheduledThreadPoolExecutor.shutdown();
        }
    }