HandlerThread handlerThread = new HandlerThread("handlerThread");

handlerThread.start();

Handler subHandler = new Handler(handlerThread.getLooper(), new Handler.Callback() {
      @Override
      public boolean handleMessage(Message msg) {
        //實現(xiàn)自己的消息處理
        return true;
      }
    });

package com.example.handlerthread;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Message;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;
public class MainActivity extends Activity {
  private Handler mSubHandler;
  private TextView textView;
  private Button button;

  private Handler.Callback mSubCallback = new Handler.Callback() {
    //該接口的實現(xiàn)就是處理異步耗時任務(wù)的，因此該方法執(zhí)行在子線程中
    @Override
    public boolean handleMessage(Message msg) {

      switch (msg.what) {
      case 0:
        Message msg1 = new Message();
        msg1.what = 0;
        msg1.obj = java.lang.System.currentTimeMillis();
        mUIHandler.sendMessage(msg1);
        break;

      default:
        break;
      }

      return false;
    }
  };
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    textView = (TextView) findViewById(R.id.textView);
    button = (Button) findViewById(R.id.button);

    HandlerThread workHandle = new HandlerThread("workHandleThread");
    workHandle.start();
    mSubHandler = new Handler(workHandle.getLooper(), mSubCallback);

    button.setOnClickListener(new OnClickListener() {

      @Override
      public void onClick(View v) {
        //投放異步耗時任務(wù)到HandlerThread中
        mSubHandler.sendEmptyMessage(0);
      }
    });

  }
}

/**
 * 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.
 */
public class HandlerThread extends Thread {
  //線程優(yōu)先級
  int mPriority;
  //當前線程id
  int mTid = -1;
  //當前線程持有的Looper對象
  Looper mLooper;
  
  //構(gòu)造方法
  public HandlerThread(String name) {
    //調(diào)用父類默認的方法創(chuàng)建線程
    super(name);
    mPriority = Process.THREAD_PRIORITY_DEFAULT;
  }
  //帶優(yōu)先級參數(shù)的構(gòu)造方法
  public HandlerThread(String name, int priority) {
    super(name);
    mPriority = priority;
  }
...............
}

public class HandlerThread extends Thread {
 /**
   * Call back method that can be explicitly overridden if needed to execute some
   * setup before Looper loops.
   */
  protected void onLooperPrepared() {
  }

  @Override
  public void run() {
    //獲得當前線程的id
    mTid = Process.myTid();
    //準備循環(huán)條件
    Looper.prepare();
    //持有鎖機制來獲得當前線程的Looper對象
    synchronized (this) {
      mLooper = Looper.myLooper();
      //發(fā)出通知，當前線程已經(jīng)創(chuàng)建mLooper對象成功，這里主要是通知getLooper方法中的wait
      notifyAll();
    }
    //設(shè)置當前線程的優(yōu)先級
    Process.setThreadPriority(mPriority);
    //該方法實現(xiàn)體是空的，子類可以實現(xiàn)該方法，作用就是在線程循環(huán)之前做一些準備工作，當然子類也可以不實現(xiàn)。
    onLooperPrepared();
    //啟動loop
    Looper.loop();
    mTid = -1;
  }
}

/**
   * This method returns the Looper associated with this thread. If this thread not been started
   * or for any reason is isAlive() returns false, this method will return null. If this thread 
   * has been started, this method will block until the looper has been initialized. 
   * @return The looper.
   */
  public Looper getLooper() {
    //如果線程不是存活的，則直接返回null
    if (!isAlive()) {
      return null;
    }
    
    // If the thread has been started, wait until the looper has been created.
    //如果線程已經(jīng)啟動，但是Looper還未創(chuàng)建的話，就等待，知道Looper創(chuàng)建成功
    synchronized (this) {
      while (isAlive() && mLooper == null) {
        try {
          wait();
        } catch (InterruptedException e) {
        }
      }
    }
    return mLooper;
  }

 /**
   * Quits the handler thread's looper.
   * <p>
   * Causes the handler thread's looper to terminate without processing any
   * more messages in the message queue.
   * </p><p>
   * Any attempt to post messages to the queue after the looper is asked to quit will fail.
   * For example, the {@link Handler#sendMessage(Message)} method will return false.
   * </p><p class="note">
   * Using this method may be unsafe because some messages may not be delivered
   * before the looper terminates. Consider using {@link #quitSafely} instead to ensure
   * that all pending work is completed in an orderly manner.
   * </p>
   *
   * @return True if the looper looper has been asked to quit or false if the
   * thread had not yet started running.
   *
   * @see #quitSafely
   */
  public boolean quit() {
    Looper looper = getLooper();
    if (looper != null) {
      looper.quit();
      return true;
    }
    return false;
  }
//安全退出循環(huán)
 public boolean quitSafely() {
    Looper looper = getLooper();
    if (looper != null) {
      looper.quitSafely();
      return true;
    }
    return false;
  }