[关闭]
@xujun94 2016-07-28T16:01:52.000000Z 字数 6704 阅读 1293

HandlerThread源码分析

我们知道在Android系统中，我们执行完耗时操作都要另外开启子线程来执行，执行完线程以后线程会自动销毁。想象一下如果我们在项目中经常要执行耗时操作，如果经常要开启线程，接着又销毁线程，这无疑是很消耗性能的?那有什么解决方法呢？

  1. 使用线程池
  2. 使用HandlerThread

**转载请注明原博客地址： **

本篇博客主要讲解HandlerThread，关于线程池的原理，请自行了解。

本篇博客主要讲解一下问题

  1. HandlerThread的使用场景以及怎样使用HandlerThread？
  2. HandlerThread源码分析

HandlerThread的使用场景以及怎样使用HandlerThread？

使用场景

HandlerThread是Google帮我们封装好的，可以用来执行多个耗时操作，而不需要多次开启线程，里面是采用handler和Looper实现的

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.

怎样使用HandlerThread？

  1. 创建HandlerThread的实例对象
  1. HandlerThread handlerThread = new HandlerThread("myHandlerThread");

该参数表示线程的名字，可以随便选择。
2. 启动我们创建的HandlerThread线程

  1. handlerThread.start();
  1. 将我们的handlerThread与Handler绑定在一起。
    还记得是怎样将Handler与线程对象绑定在一起的吗？其实很简单，就是将线程的looper与Handler绑定在一起，代码如下：
  1. mThreadHandler = new Handler(mHandlerThread.getLooper()) {
  2.     @Override
  3.     public void handleMessage(Message msg) {
  4.         checkForUpdate();
  5.         if(isUpdate){
  6.             mThreadHandler.sendEmptyMessage(MSG_UPDATE_INFO);
  7.         }
  8.     }
  9. };

注意必须按照以上三个步骤来，下面在讲解源码的时候会分析其原因

完整测试代码如下

  1. public class MainActivity extends AppCompatActivity {
  3.     private TextView mTv;
  4.     Handler mMainHandler = new Handler();
  5.     private Handler mThreadHandler;
  6.     private static final int MSG_UPDATE_INFO = 0x100;
  7.     private HandlerThread mHandlerThread;
  8.     private boolean isUpdate=true;
  10.     @Override
  11.     protected void onCreate(Bundle savedInstanceState) {
  12.         super.onCreate(savedInstanceState);
  13.         setContentView(R.layout.activity_main);
  14.         mTv = (TextView) findViewById(R.id.tv);
  15.         initHandlerThread();
  17.     }
  19.     private void initHandlerThread() {
  20.         mHandlerThread = new HandlerThread("xujun");
  21.         mHandlerThread.start();
  22.         mThreadHandler = new Handler(mHandlerThread.getLooper()) {
  23.             @Override
  24.             public void handleMessage(Message msg) {
  25.                 checkForUpdate();
  26.                 if(isUpdate){
  27.                     mThreadHandler.sendEmptyMessage(MSG_UPDATE_INFO);
  28.                 }
  30.             }
  31.         };
  33.     }
  35.     /**
  36.      * 模拟从服务器解析数据
  37.      */
  38.     private void checkForUpdate() {
  39.         try {
  40.             //模拟耗时
  41.             Thread.sleep(1200);
  42.             mMainHandler.post(new Runnable() {
  43.                 @Override
  44.                 public void run() {
  45.                     String result = "实时更新中，当前股票行情：<font color='red'>%d</font>";
  46.                     result = String.format(result, (int) (Math.random() * 5000 + 1000));
  47.                     mTv.setText(Html.fromHtml(result));
  48.                 }
  49.             });
  51.         } catch (InterruptedException e) {
  52.             e.printStackTrace();
  53.         }
  55.     }
  57.     @Override
  58.     protected void onResume() {
  59.         isUpdate=true;
  60.         super.onResume();
  61.         mThreadHandler.sendEmptyMessage(MSG_UPDATE_INFO);
  62.     }
  64.     @Override
  65.     protected void onPause() {
  66.         super.onPause();
  67.         isUpdate=false;
  68.         mThreadHandler.removeMessages(MSG_UPDATE_INFO);
  69.     }
  71.     @Override
  72.     protected void onDestroy() {
  73.         super.onDestroy();
  74.         mHandlerThread.quit();
  75.         mMainHandler.removeCallbacksAndMessages(null);
  77.     }
  80. }

运行以上测试代码，将可以看到如下效果图

HandlerThread源码分析

** 官方源代码如下，是基于sdk23的，可以看到，只有一百多行代码而已**

  1. public class HandlerThread extends Thread {
  2.     int mPriority;
  3.     int mTid = -1;
  4.     Looper mLooper;
  6.     public HandlerThread(String name) {
  7.         super(name);
  8.         mPriority = Process.THREAD_PRIORITY_DEFAULT;
  9.     }
  12.     public HandlerThread(String name, int priority) {
  13.         super(name);
  14.         mPriority = priority;
  15.     }
  17.     /**
  18.      * Call back method that can be explicitly overridden if needed to execute some
  19.      * setup before Looper loops.
  20.      */
  21.     protected void onLooperPrepared() {
  22.     }
  24.     @Override
  25.     public void run() {
  26.         mTid = Process.myTid();
  27.         Looper.prepare();
  28.         //持有锁机制来获得当前线程的Looper对象
  29.         synchronized (this) {
  30.             mLooper = Looper.myLooper();
  31.             //发出通知，当前线程已经创建mLooper对象成功，这里主要是通知getLooper方法中的wait
  32.             notifyAll();
  33.         }
  34.         //设置线程的优先级别
  35.         Process.setThreadPriority(mPriority);
  36.         //这里默认是空方法的实现，我们可以重写这个方法来做一些线程开始之前的准备，方便扩展
  37.         onLooperPrepared();
  38.         Looper.loop();
  39.         mTid = -1;
  40.     }
  43.     public Looper getLooper() {
  44.         if (!isAlive()) {
  45.             return null;
  46.         }
  48.         // 直到线程创建完Looper之后才能获得Looper对象，Looper未创建成功，阻塞
  49.         synchronized (this) {
  50.             while (isAlive() && mLooper == null) {
  51.                 try {
  52.                     wait();
  53.                 } catch (InterruptedException e) {
  54.                 }
  55.             }
  56.         }
  57.         return mLooper;
  58.     }
  60.     public boolean quit() {
  61.         Looper looper = getLooper();
  62.         if (looper != null) {
  63.             looper.quit();
  64.             return true;
  65.         }
  66.         return false;
  67.     }
  70.     public boolean quitSafely() {
  71.         Looper looper = getLooper();
  72.         if (looper != null) {
  73.             looper.quitSafely();
  74.             return true;
  75.         }
  76.         return false;
  77.     }
  79.     /**
  80.      * Returns the identifier of this thread. See Process.myTid().
  81.      */
  82.     public int getThreadId() {
  83.         return mTid;
  84.     }
  85. }

1）首先我们先来看一下它的构造方法

  1.     public HandlerThread(String name) {
  2.         super(name);
  3.         mPriority = Process.THREAD_PRIORITY_DEFAULT;
  4.     }
  7.     public HandlerThread(String name, int priority) {
  8.         super(name);
  9.         mPriority = priority;
  10.     }

有两个构造方法，一个参数的和两个参数的，name代表当前线程的名称，priority为线程的优先级别

2）接着我们来看一下run（）方法，在run方法里面我们可以看到我们会初始化一个Looper，并设置线程的优先级别

  1. public void run() {
  2.     mTid = Process.myTid();
  3.     Looper.prepare();
  4.     //持有锁机制来获得当前线程的Looper对象
  5.     synchronized (this) {
  6.         mLooper = Looper.myLooper();
  7.         //发出通知，当前线程已经创建mLooper对象成功，这里主要是通知getLooper方法中的wait
  8.         notifyAll();
  9.     }
  10.     //设置线程的优先级别
  11.     Process.setThreadPriority(mPriority);
  12.     //这里默认是空方法的实现，我们可以重写这个方法来做一些线程开始之前的准备，方便扩展
  13.     onLooperPrepared();
  14.     Looper.loop();
  15.     mTid = -1;
  16. }
  1. mHandlerThread.start();
  2. mThreadHandler = new Handler(mHandlerThread.getLooper()) {
  3.     @Override
  4.     public void handleMessage(Message msg) {
  5.         checkForUpdate();
  6.         if(isUpdate){
  7.             mThreadHandler.sendEmptyMessage(MSG_UPDATE_INFO);
  8.         }
  9.     }
  10. };
  1. public Looper getLooper() {
  2.     if (!isAlive()) {
  3.         return null;
  4.     }
  6.     // 直到线程创建完Looper之后才能获得Looper对象，Looper未创建成功，阻塞
  7.     synchronized (this) {
  8.         while (isAlive() && mLooper == null) {
  9.             try {
  10.                 wait();
  11.             } catch (InterruptedException e) {
  13.             }
  14.         }
  15.     }
  16.     return mLooper;
  17. }

总结：在获得mLooper对象的时候存在一个同步的问题，只有当线程创建成功并且Looper对象也创建成功之后才能获得mLooper的值。这里等待方法wait和run方法中的notifyAll方法共同完成同步问题。

3)接着我们来看一下quit方法和quitSafe方法

  1. //调用这个方法退出Looper消息循环，及退出线程
  2. public boolean quit() {
  3.     Looper looper = getLooper();
  4.     if (looper != null) {
  5.         looper.quit();
  6.         return true;
  7.     }
  8.     return false;
  9. }
  11. //调用这个方法安全地退出线程
  12. @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2)
  13. public boolean quitSafely() {
  14.     Looper looper = getLooper();
  15.     if (looper != null) {
  16.         looper.quitSafely();
  17.         return true;
  18.     }
  19.     return false;
  20. }

跟踪这两个方法容易知道只两个方法最终都会调用MessageQueue的queue（boolean safe）方法

  1. void quit(boolean safe) {
  2.     if (!mQuitAllowed) {
  3.         throw new IllegalStateException("Main thread not allowed to quit.");
  4.     }
  6.     synchronized (this) {
  7.         if (mQuitting) {
  8.             return;
  9.         }
  10.         mQuitting = true;
  11.         //安全退出调用这个方法
  12.         if (safe) {
  13.             removeAllFutureMessagesLocked();
  14.         } else {//不安全退出调用这个方法
  15.             removeAllMessagesLocked();
  16.         }
  18.         // We can assume mPtr != 0 because mQuitting was previously false.
  19.         nativeWake(mPtr);
  20.     }
  21. }

不安全的会调用removeAllMessagesLocked();这个方法，我们来看这个方法是怎样处理的，其实就是遍历Message链表，移除所有信息的回调，并重置为null

  1. private void removeAllMessagesLocked() {
  2.     Message p = mMessages;
  3.     while (p != null) {
  4.         Message n = p.next;
  5.         p.recycleUnchecked();
  6.         p = n;
  7.     }
  8.     mMessages = null;
  9. }

安全地会调用removeAllFutureMessagesLocked();这个方法，它会根据Message.when这个属性，判断我们当前消息队列是否正在处理消息，没有正在处理消息的话，直接移除所有回调，正在处理的话，等待该消息处理处理完毕再退出该循环。因此说quitSafe（）是安全的，而quit（）方法是不安全的，因为quit方法不管是否正在处理消息，直接移除所有回调。

  1. private void removeAllFutureMessagesLocked() {
  2.     final long now = SystemClock.uptimeMillis();
  3.     Message p = mMessages;
  5.     if (p != null) {
  6.         //判断当前队列中的消息是否正在处理这个消息，》没有的话，直接移除所有回调
  7.         if (p.when > now) {
  8.             removeAllMessagesLocked();
  9.         } else {//正在处理的话，等待该消息处理处理完毕再退出该循环
  10.             Message n;
  11.             for (;;) {
  12.                 n = p.next;
  13.                 if (n == null) {
  14.                     return;
  15.                 }
  16.                 if (n.when > now) {
  17.                     break;
  18.                 }
  19.                 p = n;
  20.             }
  21.             p.next = null;
  22.             do {
  23.                 p = n;
  24.                 n = p.next;
  25.                 p.recycleUnchecked();
  26.             } while (n != null);
  27.         }
  28.     }
  29. }

到此HandlerThread源码分析为止

  1. 关于IntentService的，可以参考我的这一篇博客IntentService使用及源码分析
  2. 关于Handler消息机制的，可以参考郭林大神的这篇博客Android异步消息处理机制完全解析，带你从源码的角度彻底理解

题外话

最近在准备校招，比较忙，不过个人整理了一些常见的算法题目，有空的话我会把它分享出来，一起加油，Come on!

**简书博客博客地址： **

**转载请注明原博客地址： **

例子源码下载地址：

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注