Handler 源码分析 - Java 层

Handler最常见的使用场景就是下载回调,为了不影响用户体验Android不支持在主线程中进行耗时时操作,长时间的耗时操作会产生ANR异常,而下载无疑是耗时操作,所以我们会在子线程中进行下载。但,下载完毕进行UI操作却会发生异常,原来谷歌为了不让UI的操作出现冲突(线程的不可确定性),所以规定只能在子线程中进行UI操作,可这就尴尬了…即不让在主线程中进行联网操作,又不让在子线程中进行UI操作,我们如何将告诉主线程我们已经下载完毕了呢?这时就要用到Handler了.

Handler的简单使用

《Handler 源码分析 - Java 层》

test

下面是最简单的使用.

// 1.创建Handler对象, 重写方法.
mTestHandler = new TestHandler(this);

-----------------------------点击模拟下载---------------------------------
public void download(View view) {
  text.setText("开始下载...");
  new Thread(){
    @Override
    public void run() {
      // 2.创建消息对象
      Message msg = mTestHandler.obtainMessage();
      msg.obj = "下载完毕";
      msg.arg1 = 1;
      // 3.发送延时消息
      mTestHandler.sendMessageDelayed(msg, 2000);
      }
    }.start();
}
---------------------------创建一个类继承Handler--------------------------------
 // * 用软引用的方法持有Activity对象防止内存泄露
private WeakReference<MainActivity> activity ;
  public TestHandler(MainActivity activity){
    this.activity = new WeakReference<>(activity);
}

// 回调方法.
  @Override
  public void handleMessage(Message msg) {
    switch (msg.arg1){
      case 1:
        activity.get().text.setText((String) msg.obj);
      break;
    }
  }

继承Handler对象并重写handleMessage(),然后创建Handler对象,调用obtainMessagee()方法获取Message对象,将数据赋予Message,并发送出去,而发送的消息会回调给HandlerhandleMessage()方法.

在子线程中创建Handler对象.

刚才我们在主线程中创建了Handler对象,在子线程中调用HandlersendMessageDelayed()方法将Message带到主线程间完成了线程中的通信,那我们能在子线程中创建Handler吗 ? 答案是不可以。在子线程中创建Handler对象会抛出如下异常:

Can't create handler inside thread that has not called Looper.prepare()

异常说的很明白它需要调用Looper.prepare()。我们来看看源码,为什么在主线和中可以创建Handler对象呢?点击new Handler(),在两个参数的构造方法中我们发现了刚才抛出异常的代码.

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;

可以看到异常抛出的原因是因为mLooper这个对象为null,我们来看看myLooper里面做了什么?
———–可我们并没有在主线程中调用这个方法啊?那是因为该方法在ActivityThread类里调用了,我们这里暂时不看它. 继续查看Looper.myLooper()里面的内容.

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

myLooper()实现调用了ThreadLocal身上的get()方法,它返回一个Looper,既然有get()必然在一个地方set()了,于是在Looper中发现以下代码

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

ThreadLocal

我们把Looper对象存放在了ThreadLocal中,当需要Looper时也是从ThreadLocal中取的,为什么要将Looper存放在ThreadLocal中呢?下面是它的get()方法.

public T get() {
  Thread t = Thread.currentThread();
  ThreadLocalMap map = getMap(t);
  if (map != null) {
  ThreadLocalMap.Entry e = map.getEntry(this);
  if (e != null)
    return (T)e.value;
  }
  return setInitialValue();
}

ThreadLocal内部有一个Map集合,根据它所在的线程名取Looper,而ThreadLocal是在创建Looper时创建的所以LooperThreadLocal是同一线程的,而我们创建handler时会调用myLooper()方法,该方法调用get()方法时会根据handler所有线程名取Looper对象,所以我们要保证Looper.prepare()Handler在同一线程中.

现在让我们来理一下思路,首先创建Handler需要Looper,而Looper是在prepare()方法中创建的,也就是说如果我们想在子线程中创建Handler只需要在之前调用

《Handler 源码分析 - Java 层》

test

```
public void run() {
   Looper.prepare();
   mTestHandler = new Handler(){
    @Override
    public void handleMessage(Message msg) {
      Log.d("MainActivity", Thread.currentThread().getName());
    }
  };
  mTestHandler.sendMessage(mTestHandler.obtainMessage());
}

MesageQuene

可是问题又来了,虽然没有抛出异常,handleMessage()方法却一直接收不到消息.既然是收不到消息,那我们来看看Handler内部是怎么发送消息的吧,我们继续查看sendMessage()方法.

// 这里我们看到了前面的发送延时消息方法,延时+当时时间 并调用下一方法
sendMessage(msg) -> sendMessageDelayed(msg, 0)
    -> sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis)

----------------------------------------------------------------------
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
  MessageQueue queue = mQueue;
  if (queue == null) {
     ...
    return false;
  }
  return enqueueMessage(queue, msg, uptimeMillis);
}

----------------------------------------------------------------------
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
  msg.target = this; // this = handler; 把消息与handler进行绑定.
  if (mAsynchronous) {
    msg.setAsynchronous(true);
  }
  return queue.enqueueMessage(msg, uptimeMillis);
}

最后调用了MesageQueneenqueueMessage()方法,即入队列,那MesageQuene对象是在什么时候创建的呢?是在创建Looper对象时创建的。

private Looper(boolean quitAllowed) {
   mQueue = new MessageQueue(quitAllowed);
   mThread = Thread.currentThread();
}

继续来看MesageQueneenqueueMessage()方法.

...
Message prev;
for (;;) {
  prev = p;
  p = p.next;
  if (p == null || when < p.when) {
    break;
  }
  if (needWake && p.isAsynchronous()) {
    needWake = false;
  }
}
msg.next = p; // invariant: p == prev.next
prev.next = msg;
...

enqueueMessage()就是入队列的意思,Message 是单链表结构,它持有下一个Message 对象的引用,因为MesageQuene中可能存有多个未处理的消息,所以需要判断MesageQuene中有多少消息,若有多个则将当前消息放置在最后,可以看成集合的add方法.

Looper

sendMessage()方法只是将消息加入消息队列中,那消息是如何取出并发给handler的呢?我们来看下Looper.loop()

...
for (;;) {
  Message msg = queue.next(); // might block
...
  try {
    msg.target.dispatchMessage(msg);
  } finally {
    if (traceTag != 0) {
    Trace.traceEnd(traceTag);
  }
}
...

这里的target就是handler(在handler的enqueueMessage()方法里,我们将消息与handler进行了绑定),所以调用了handler身上的dispatchMessage()方法,而该方法最终又调用了handleMessage()方法,并将消息传递进去.

public void dispatchMessage(Message msg) {
  if (msg.callback != null) {
    handleCallback(msg);
  } else {
    if (mCallback != null) {
      if (mCallback.handleMessage(msg)) {
        return;
      }
    }
    handleMessage(msg);
  }
}

上面就是handler发送消息的大致流程最后我们总结一下.
总结:创建Handler对象时会调用Looper.prepare()方法,该方法会用从ThreadLocal对象中取出looper, 所以如果ThreadLocal中没有先存Looper或不在同一线程中则取不到对象,Handler就会抛出异常.

  • 问题1.:主线程在哪里调用了prepare()方法的?见底部代码.

用handler发送消息方法时,会调用到MesageQuene的方法, 而mQuene是在创建Looper对象时创建的, Looper对象是在调用prepare()方法时创建的, 也就是说mQuene与Looper是在同一线程.

我们发送消息时会将所发送的消息加入消息队列,而后调用Looper.loop()方法才能将消息取出并传送给handler,如果不调用Looper.loop()则消息无法取出

  • 问题2:为什么在主线中创建可以接收消息?见底部代码.

最后在子线程中创建handler那handleMessage是在哪个线程回调的呢?
这个问题在上面就已经说了,handleMessage在loop()方法调用,而loop()与Looper是在同一线程,也就是说最终会在子线程回调.那如何让回调在主线程呢?调用prepareMainLooper()方法,而不是prepare()就可让回调在主线程中运行.
下面代码很好回答了第1和第2问题.

public static final void main(String[] args) {
....
// 1.主线程创建Looper 
Looper.prepareMainLooper();
if (sMainThreadHandler == null) {
  sMainThreadHandler = new Handler();
}

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

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

Looper.loop();
...
    原文作者:java集合源码分析
    原文地址: https://juejin.im/entry/58aacf3c570c35006bc0186c
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞