简单的聊一下Handler的原理

Handler是安卓消息体系里面很重要的一个部分，它实现了线程之间的通信，没有它，安卓将无法正常运行。

1.各部分介绍：

1.message：消息；

2.MessageQueue：消息队列；

3.Looper：消息循环器；

4.Handler：可以通过sendMessage()发送message到MessageQueue，之后通过Looper.loop() 开始循环MessageQueue不断获取消息，再将消息交给Handler，由handleMessage()处理消息。

2.原理介绍：

2.1.Handler如何和线程联系起来？

Handler通过Looper和线程联系起来，首先在创建Handler之前要先创建Looper：

public Handler(Callback callback, boolean async) {
        //检查当前的线程是否有 Looper
        mLooper = Looper.myLooper();
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread that has not called Looper.prepare()");
        }
        //Looper 持有一个 MessageQueue
        mQueue = mLooper.mQueue;
}

从上面代码可知，在创建Handler的时候，会检查是否创建了Looper，如果没有会报错。

完整例子如下：

class LooperThreadTest extends Thread {
    public Handler mHandler;
    public void run() {
        Looper.prepare();//创建Looper，同时创建消息队列
        mHandler = new Handler() {
            public void handleMessage(Message msg) {
                // process incoming messages here
            }
        };
        Looper.loop();//开始循环消息队列
    }
}

在查看Looper.prepare()：

public static void prepare() {
98        prepare(true);
99    }

private static void prepare(boolean quitAllowed) {
102        if (sThreadLocal.get() != null) {
103            throw new RuntimeException("Only one Looper may be created per thread");
104        }
105        sThreadLocal.set(new Looper(quitAllowed));//创建Looper
106    }

在sThreadLocal.set(new Looper(quitAllowed))中，因为线程中有且只有一个map，然后该线程作为key，新建的Looper对象作为值。然后线程就和Looper绑定了，就这样线程通过Looper和Handler联系起来了。

 static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();//线程是常量，是不可变，唯一的。

因为该线程是唯一的，map是唯一的，key是唯一的，再加上在Looper.prepare()中，我们可以知道当key对应的值不为空时，会报错，这就保证了值不可变。这也说明了，一个线程只能有一个Looper对象。但是一个线程可以有多个Handler。

2.2 message的获取和处理

Looper.loop()开启循环消息：

public static void loop() {
138        final Looper me = myLooper();
139        if (me == null) {
140            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
141        }
142        final MessageQueue queue = me.mQueue;//获取消息队列
143
158        //循环获取消息
159        for (;;) {
160            Message msg = queue.next(); // 可能会阻塞
161            if (msg == null) {
162                // 没有消息表示消息队列正在退出。
163                return;
164            }
165
221            //...
232            try {
                   //处理消息
193                msg.target.dispatchMessage(msg);
194                dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
195            } finally {
196                if (traceTag != 0) {
197                    Trace.traceEnd(traceTag);
198                }
199            }
                //...
233            msg.recycleUnchecked();
234        }
235    }

//Handler
public void dispatchMessage(Message msg) {
  //msg.callback 是 Runnable ，如果是 post方法则会走这个 if
  //callback拥有优先处理消息的权利
  if (msg.callback != null) {
    handleCallback(msg);
  } else {
    //callback 见【3.4】
    if (mCallback != null) {
      //利用 Callback 这个拦截机制来拦截 Handler 的消息
      if (mCallback.handleMessage(msg)) {
        return;
      }
    }
    //回调到 Handler 的 handleMessage 方法
    handleMessage(msg);
  }
}

Handler.handleMessage() 所在的线程是 Looper.loop() 方法被调用的线程，也可以说成 Looper 所在的线程，并不是创建 Handler 的线程；

2.3.Handler引起内存泄露的原因

Handler作为Activity的内部类，基于Java特性，内部类持有外部类，对Activity有一个引用，而MessageQueue消息队列持有Message消息，Message消息持有Handler，Handler持有Activity，因为MessageQueue消息队列长期存活在内存中，间接长期持有Activity，导致Activity销毁后无法回收。

解决办法：使Handler作为Activity的静态内部类，内部类持有外部类的弱引用，并及时移除所有消息。

private static class SafeHandlerTest extends Handler {
    
    //弱引用
    private WeakReference<HandlerActivity> ref;

    public SafeHandler(HandlerActivity activity) {
        this.ref = new WeakReference(activity);
    }

    @Override
    public void handleMessage(final Message msg) {
        HandlerActivity activity = ref.get();
        if (activity != null) {
            activity.handleMessage(msg);
        }
    }
}


@Override
protected void onDestroy() {
  //移除所有消息
  SafeHandlerTest.removeCallbacksAndMessages(null);
  super.onDestroy();
}

2.4.为什么主线程可以直接new Handler ？

因为在主线程中的 ActivityThread.main() 方法中，创建了Looper。

//android.app.ActivityThread
public static void main(String[] args) {
  //...
  Looper.prepareMainLooper();//主线程的Looper对象的创建。

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

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

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

2.5.主线程和子线程的Looper如何退出？

主线程的Looper不允许退出，退出意味着退出APP，子线程可以调用Looper.quit()，接着会调用MessageQueue.quit()，随后next()会返回null，然后loop()退出了。

2.6.loop()方法是死循环，为什么不会导致应用卡死？

因为当MessageQueue没有消息时，会阻塞在MessageQueue.next()方法中的nativePollOnce(ptr, nextPollTimeoutMillis)，之后主线程会释放CPU资源，陷入休眠，等有消息的时候，才会被唤醒。

2.7.创建Message的最佳方式

在安卓中被处理的Message不会被销毁，而是会被复用，节约开销，减少内存消耗。

因此可以采取Message.obtain()和handler.obtainMessage()方法，实际上内部也是Message.obtain()方法。

2.8.使用Handler.postDelay()，消息队列会有怎样变化？

首先调用这个方法，不是延迟一段时间再将消息加入消息队列，而是和队列的时间顺序排序和唤醒相结合实现的。