Android_HandlerThread 源码梳理

前言

Android 多线程还有HandleThread,看名字就可以能感觉到得到，会是handler和Thread的综合使用。那到底是怎么样的呢，现在就跟随Android的源码来看看他的工作原理是什么样的。

我们先看看他的类注解：先看看官方对他的介绍：【 Handy class for starting a new thread that has a looper. The looper can then be used to create handler classes. Note that start() must still be called.】简单的翻译就是这是一个很方便启动一个拥有looper的的类，这个Looper在这以后是用来创建handler类的，注意：thread的start()方法一定要被调用。

理解HandleThread

看到介绍可能觉得HandleThread有点厉害，有looper还能创建handler。我们抱着这样的心情去看HandleThread比较难受，所以，我们要换一下思路，这个HandleThread就是个Thread，这个Thread执行工作任务，我们通过handler给这个Thread安排工作。【从使用角度就相当于我们自己起一个工作线程，然后在线程中自己prepareLooper一样。只不过HandleThread已经把这些做好了，还封装了优先级设置，安全退出等一些辅助功能，让我们开发人员使用起来更加方便】

handler我们知道可以用来线程间通信，之前在Handler工作流程梳理里面分析过【具体在本篇就不细说】，我们这里要知道，Handler可以把Message发送到MessageQueue中，通过Looper.loop()循环将Message取出并分派到到相应的Handler去处理。同一个线程中只有一个MessageQueue和Looper, Message的处理是串行的。当有Thread使用了Handler，那么通过Handler给Thread安排任务也是串行执行的，就是一个执行完才执行下一个，所以这个HandleThread不适多耗时任务，这样任务的执行相互收影响比较严重。对于任务量小，使用频繁的任务来说就比较友好，可以使用一个线程来实现线程池的效果，节省了资源。

源码分析

看了上面的理解描述后，我们就可以猜到HandleThread代码逻辑应该不复杂，代码量也不会很大。事实就是这样，加上注解，HandleThread的代码在160多行。

/frameworks/base/core/java/android/os/HandlerThread.java

public class HandlerThread extends Thread {int mPriority;int mTid = -1;Looper mLooper;private @Nullable Handler mHandler;public HandlerThread(String name) {super(name);mPriority = Process.THREAD_PRIORITY_DEFAULT;}/*** Constructs a HandlerThread.* @param name* @param priority The priority to run the thread at. The value supplied must be from* {@link android.os.Process} and not from java.lang.Thread.*/public HandlerThread(String name, int priority) {super(name);mPriority = priority;}...
}

HandleThread继承自Thread，首先我们就看到了该有的Looper对象，然后从它的构造函数看，可以设置线程优先级和给线程命名。在使用时如果不设置优先级，会默认设置为Process.THREAD_PRIORITY_DEFAULT；

HandleThread主要的逻辑就在run()方法里面

1.run()

@Override
public void run() {mTid = Process.myTid();Looper.prepare();synchronized (this) {mLooper = Looper.myLooper();notifyAll();}Process.setThreadPriority(mPriority);onLooperPrepared();Looper.loop();mTid = -1;
}

在run()里。Looper.prepare()来初始化当前线程的一个Looper。然后拿到一个looper对象赋值给mLooper，呃呃呃。这里为啥要notifyAll(),在Java中wait()和notify/notifyAll是一起使用的，主要用在多线程中，，用在这里又是为什么？我们在HandleThread搜索一下wait()果然有：

1.2 getLooper()

public Looper getLooper() {...// If the thread has been started, wait until the looper has been created.synchronized (this) {while (isAlive() && mLooper == null) {try {wait();} catch (InterruptedException e) {}}}return mLooper;
}

在getLooper（）方法里，当looper还没有创建时间，需要当前线程保持wait,这是为什么呢？我估计是当线程启动，在没有获取到looper之前，当前线程是空闲的，也没任务做,就先释放资源，让其他线程先执行run()方法来获取Looper对象，然后将looper赋值给mLooper,【当我看到这里时是很疑惑的，这个在文章后面来介绍】；

再回到run()方法中；获mLooper赋值后，随后调用notifyAll()，【此时其他线程的getLooper()方法也会被唤醒，就可以利用looper去创建handler。然后再handleMessage()中实现处理任务的业务代码】；然后接下里就主要是进入loop循环了。这就之前分析handler看到的线程最后的状态是一毛一样，那就是随后线程都会进入到loop循环中。

以上就是HandleThread的主要原理了。

----------------------------------------------------------华丽丽的分割线--------------------------------------------------------------------------

疑惑

现在要来说说我在分析那个mlooper被赋值时遇到的疑惑，还记得我们在Handler工作流程梳理事看到Looper.getLooper()最后是从ThreadLoacl中取出的，在Android_ThreadLoacl原理一篇中，我们知道threadLocal保存的变量是与线程相关联的，所以不同线程get到的Looper是不一样的。

疑点来了啊，注意听。假如线程A运行到HandleThread的getLooper()方法，如果此时mlooper为空。那么线程A就会wait,阻塞在这里;那么后来线程B运行到HandleThread的run()方法，从线程B中获取到线程B的looper，然后赋值给mLooper;之后线程A就可以被唤醒，返回mLooper；那么这时候线程A返回的looper其实是在线程B中创建的looper，我就很乱了，，，不应该looper和线程相关的吗？在这里怎么可以这么玩？

反正我是很乱的，问了同事也还没问个明白。有一点肯定的，源码中这么玩肯定是没错的，我需要一个可以让自己信服的理由。

既然没问道直接的答案，按我自己试试，然后，我写了个demo，在主线程中获取主线程的MainLooper，然后在子线程创建Handler时直接传入MainLooper。最后发现，子线程是可以使用主线程的looper。恩恩，终于，用事实说明了，多线是可以公用looper的。好了，HandleThread中的疑惑解决了；

接下来，我就有了新疑惑，我需要继续搞明白，为什么多线程可以共用looper。这和我之前的理解不一样，我之前的理解是线程中的looper和线程相关，当前线程只能使用当前线程的Looper。

解惑

答案还是得要在源码里面找，经过观察发现HandleThread和我们一般的在子线程中创建Handler的方式是不同的；

子线程中直接我们一般是这样的：

/ * * <pre>*  class LooperThread extends Thread {*      public Handler mHandler;**      public void run() {*          Looper.prepare();**          mHandler = new Handler() {*              public void handleMessage(Message msg) {*                  // process incoming messages here*              }*          };**          Looper.loop();*      }*  }</pre>* /

使用HandelrThread时是这样的

private HandlerThread mMyhandleThread = new HandlerThread("MyHandleThread");
Handler mHandler;
mMyhandleThread.start();
mHandler = new Handler(mMyhandleThread.getLooper()) {@Overridepublic void handleMessage(Message msg) {// TODO}
};

我感觉问题还是在Handler上。那我们就去看看Handler 的构造函数：

/frameworks/base/core/java/android/os/Handler.java

// 1.我们一般手动在子线程就是这样创建Handler的
public Handler() {this(null, false);
}
...
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 " + Thread.currentThread()+ " that has not called Looper.prepare()");}mQueue = mLooper.mQueue;mCallback = callback;mAsynchronous = async;
}
//------------------------华丽丽的分割线------------------------// 2.我们一般使用HandlerThread时是这样创建Handler的
public Handler(Looper looper) {this(looper, null, false);
}
...
public Handler(Looper looper, Callback callback, boolean async) {mLooper = looper;mQueue = looper.mQueue;mCallback = callback;mAsynchronous = async;
}

通过对不同方式创建Handler时调用的构造方法，我们发现，handler的如果在构造函数中指定了Looper，就直接使用传进来的looper对象，如果在构造事没有传入looper对象，则此时就需要使用本线程自己的looper；至于messageQueue只是和Looper相关，MessageQueue和handler并没有直接联系。

结论

所以我们得出结论，多线程可以使用同一个Looper,相应的也就是使用了相同的MessageQueue。