handler机制

希望曾经坚持的努力不会被辜负

1.handler 介绍

handler 的正常工作需要Looper 否则会报错（下面会从源码知悉报错的原因）
Handler发送消息的过程是向消息队列MessageQueue 插入了一条消息，MessageQueue 是由Looper 负责维护的MessageQueue 的next 方法返回这条消息给当前线程的Looper，Looper 收到消息后开始处理，最终消息由Looper交个Handler处理，即Handler的dispatchMessage()方法被调用，最后回调到handler的 handleMessage中进行处理

在android中，非UI线程中是不能更新UI的，如果在子线程中做UI相关操作，可能会出现程序崩溃。一般的做法是，创建一个Message对象，Handler发送该message，给handler传递主线程的Looper,将线程切回主线程就可以在Handler的handleMessage()方法中做ui相关操作
handler 主要有两个功能:
1.刷新UI，（需要用主线程的looper）
2.不刷新ui,只是处理消息

1.1 使用handler刷新UI

主线程中创建Handler，接受各线程发送来的消息进行UI操作我们使用的比较多，不做过多说明

    Handler handler = new Handler(){
                @Override
                public void handleMessage(Message msg) {
                    super.handleMessage(msg);
                    switch (msg.what){
                        case  0:
                            btn.setText("更新");
                            //ToastUtils.showShort("---handler()----");
                            LogUtils.e("----handler-----Thread.currentThread="+Thread.currentThread().getName());
                            break;
                        default:
                            break;
                    }

                }
            };  

    new Thread(new Runnable() {
     @Override public void run() {
      Message message = handler1.obtainMessage();
       message.arg1 = 1;
        handler1.sendMessage(message);
         }
      }).start();

在子线程中，创建Handler 进行UI更新，就特别需要注意,在创建handler 时要传Looper.getMainLooper(),将线程切回到主线程进行

    new Thread(new Runnable() {
            @Override
            public void run() {
             Handler handler = new Handler(Looper.getMainLooper()){
                    @Override
                    public void handleMessage(Message msg) {
                        super.handleMessage(msg);
                        switch (msg.what){
                            case  0:
                                btn.setText("更新")
                                //ToastUtils.showShort("---handler()----");
                                LogUtils.e("----handler-----Thread.currentThread="+Thread.currentThread().getName());
                                break;
                            default:
                                break;
                        }

                    }
                };
                Message message = new Message();
                message.what = 0;
                handler.sendMessage(message);
            }
        }).start();

1.2 子线程进行消息处理

子线程中只进行消息处理时，不更新UI 时
（1）初始化handler可以同上传Looper.getMainLooper()切到主线程
（2）也可以不传Looper.getMainLooper()，但是必须在子线程中新建一个Looper 对象

    new Thread(new Runnable() {
        @Override
        public void run() {
            LogUtils.e("1111-----Thread.currentThread="+Thread.currentThread().getName());
            Looper.prepare();
            Handler handler = new Handler(){
                @Override
                public void handleMessage(Message msg) {
                    super.handleMessage(msg);
                    switch (msg.what){
                        case  0:
                            LogUtils.e("22--Thread.currentThread="+Thread.currentThread().getName());
                            break;
                    }
                }
            };
            Message message = new Message();
            message.what = 0;
            handler.sendMessage(message);
            Looper.loop();
        }
    }).start();

如果子线程中创建handler 不调用Looper.prepare(),会提示运行时异常：
java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare()
查看handler源码可知

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

public static @Nullable Looper myLooper() {
      return sThreadLocal.get();
  }

sThreadLocal.get()是空的，而 Looper.prepare()就完成了这个设置操作

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

主线程为什么不需要调用Looper.prepare()? 因为在ActivityThread中会默认创建Looper对象

1.3 子线程真的不能更新UI吗

我们试着在activity,onCreate()方法中启动这个线程

new Thread(new Runnable() {
        @Override
        public void run() {
            LogUtils.e("1111-----Thread.currentThread="+Thread.currentThread().getName());
            Looper.prepare();
            Handler handler = new Handler(){
                @Override
                public void handleMessage(Message msg) {
                    super.handleMessage(msg);
                    switch (msg.what){
                        case  0:
                            btnLogin.setText("WTF");
                            //ToastUtils.showShort("---handler()----");
                            LogUtils.e("22--Thread.currentThread="+Thread.currentThread().getName());
                            break;
                    }
                }
            };
            Message message = new Message();
            message.what = 0;
            handler.sendMessage(message);
            Looper.loop();

        }
    }).start();

运行后发现也没有出现崩溃现象，难道我们就可以下结论子线程也可以更新UI 了么

其实不然

我们试着在更新UI前让子线程休眠200ms ,发现出现崩溃了，或者我们把这段代码放在Button 的点击事件中去处理，也会发生崩溃！崩溃日志是这样的：

android.view.ViewRootImpl$CalledFromWrongThreadException: Only the original thread that created a
view hierarchy can touch its views.
    at android.view.ViewRootImpl.checkThread(ViewRootImpl.java:7583)
    at android.view.ViewRootImpl.requestLayout(ViewRootImpl.java:1298)

那我们就要从这段崩溃日志中找原因，跟踪源码，我们发现ViewRootImpl类中会有一个checkThread()方法来判断当前访问UI的线程是不是主线程，因为mThread这个主线程是在app程序启动时就初始化的

void checkThread() {
    if (mThread != Thread.currentThread()) {
        throw new CalledFromWrongThreadException(
                "Only the original thread that created a view hierarchy can touch its views.");
    }
}

其中 mThread 是创建 ViewRootImpl 的线程，而ViewRootImpl是在主线程中创建的，所以，我们习惯地称它为主线程，mThread和当前代码运行的线程来做了个等式运算，相同就出错，也就是说，并不是子线程不能刷新UI，准确来说，是发送进行 UI 刷新消息的消息，因为真正的底层刷新也不是当前 APP 的主线程。而是限制了，如果当ViewRootImpl是由子线程创造的，那么就可以在该子线程中发送更新UI的消息，自然地就能更新了，那么为什么限制呢?

这背后是线程同步的开销问题。显然两个线程同时绘制屏幕，屏幕会显示一些意想不到的图像，所以两个线程不能同时去更新Ui。需要互斥，比如锁。结果就是同一时刻只有一个线程可以做ui。那么当两个线程互斥几率较大时，或者互斥的代码很复杂，选择其中一个长期持有其他发消息就是典型的解决方案。所以普遍的要求ui只能单线程操作

在ActivityThread中，我们找到handleResumeActivity方法，跟进这个方法我们会发现 activity就是在这里面调用onResume()生命周期的，这方法之后，有一个makeVisible()方法;

r.activity.mVisibleFromServer = true;
mNumVisibleActivities++;
    if (r.activity.mVisibleFromClient) {
        r.activity.makeVisible();
}

跟进去，我们发现，这里是activity 让view显示的地方

void makeVisible() {
 if (!mWindowAdded) {
  ViewManager wm = getWindowManager();
   wm.addView(mDecor, getWindow().getAttributes());
    mWindowAdded = true;
     }
      mDecor.setVisibility(View.VISIBLE);
       }

往WindowManager中添加DecorView，那现在应该关注的就是WindowManager的addView方法了。而WindowManager是一个接口来的，
我们应该找到WindowManager的实现类才行，而WindowManager的实现类是WindowManagerImpl，找到了WindowManagerImpl的addView方法，
如下：

@Override 
public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
    applyDefaultToken(params);
    mGlobal.addView(view, params, mDisplay, mParentWindow);
    }

里面调用了WindowManagerGlobal的addView方法，那现在就锁定WindowManagerGlobal的addView方法
我们发现

public void addView(View view, ViewGroup.LayoutParams params,
    Display display, Window parentWindow) {
    ...
    root = new ViewRootImpl(view.getContext(), display);
    view.setLayoutParams(wparams); mViews.add(view);
    mRoots.add(root); mParams.add(wparams);
    ...
    }

ViewRootImpl是在WindowManagerGlobal的addView方法中创建的。
所以我们可以总结一下，我们在onCreate()或者onResume()中使用子线程更新UI时，由于viewRootImpl 还未创建完成，所以并没有报错，我们延时200ms 后，ViewRootImpl已经创建了，可以执行checkThread方法检查当前线程。
所以，系统考虑资源调度及线程开销上，通过viewRootImpl线程判断的方式来让UI线程（长期持有发送消息进行UI更新操作的线程）来进行UI更新操作。