Android&HandlerThread分析

HandlerThread继承于Thread，所以它本质就是个Thread。与普通Thread的差别就在于，它有个Looper成员变量。这个Looper其实就是对消息队列以及队列处理逻辑的封装，简单说就是 消息队列+消息循环。

当我们需要一个工作者线程，而不是把它当作一次性消耗品，用过即废弃的话，就可以使用它。

private Handler mHandler = null;

    private HandlerThread mHandlerThread = null;
    private void sentRunnableToWorker(Runnable run){
        if (null == mHandlerThread)
        {
            mHandlerThread = new HandlerThread("WorkerThread");
            // 给工作者线程低优先级 
            mHandlerThread.setPriority(Thread.MIN_PRIORITY);
            mHandlerThread.start();
        }

        if (null == mHandler)
            mHandler = new Handler(mHandlerThread.getLooper());

        mHandler.post(run);
    }
/*AsyncQueryHandler就是基于HandlerThread封装了线程间双向通信，而HandlerThread只做了一半。*/

 

源码分析：

public class HandlerThread extends Thread{
          //线程的优先级
           private int mPriority;
          //线程的id
           private int mTid=-1;
           private Looper mLooper;
           public HandlerThread(String name){
                      super(name);
                     //设置优先级为默认线程
                     mPriority=Process.THREAD_PRIORITY_DEFAULT;
           }
           public HandlerThread(String name，int priority){
                      super(name);
                     mPriority=priority;
           }
          /*这个如果有需要的话可以继承重写，例如可以在里面声明Handler 关联此线程。*/
           protected void onLooperPrepared(){}
           //这个很熟悉吧
           public void run(){
               //得到当前线程的id
                mTid=Process.myTid;
               /*一旦调用这句代码，就在此线程中创建了Looper 对象。这就是为什么我们要在调用线程的start()方法后
               才能得到Looper 对象即 当 调用Looper.myLooper()时不为Null。*/
                Looper.prepare();
                /*同步代码块，意思就是当获得mLooper对象后，唤醒所有线程。（会在以后的例子中有所体现）*/
               synchronized(this){
                     mLooper=Looper.myLooper();
                     notifyAll();
               }
              //设置线程的优先级
               Process.setThreadPriority(mPriority);
             //调用上面的方法（需要用户重写）
              onLooperPrepared();
               //建立了消息循环
                Looper.loop();
               mTid=-1;
           }
           public Looper getLooper(){
                    //线程死了，那就只有NULL了。
                     if(!isAlive()){
                        return null;
                    }
            /*看见没，又是同步代码块，正好和上面的形成对应，就是说只要线程活着并且我的looper为NULL，那么我就让你一直等。。。*/
                   synchronized(this){
                          while(isAlive()&&mLooper==null){
                               try{
                                         wait();
                                   }catch(InterruptedException e){}
                          }
                   }
                             return mLooper;
           }
          public boolean quit(){
              Looper looper =getLooper();
               if(looper!=null){
                  //退出消息循环
                   looper.quit();
                   return true;
              }
              return false;
       }
         //返回线程ID
         public int getThreadId(){
               return mTid;
        }
}