private Handler mHandler;
    @Override
     public void run() {
        super.run();
         Looper.prepare();
         mHandler = new Handler(){
             @Override
             public void handleMessage(Message msg) {
             }
         };
         Looper.loop();
}

mHandlerThread = new HandlerThread("mHandlerThread");//這里的mHandlerThread其實(shí)就是線程的名字
mHandlerThread.start();

mHandler = new Handler(mHandlerThread.getLooper())

@Override
protected void onDestroy() {
   //
   super.onDestroy();
   //釋放資源
   mHandlerThread.quit();
}

 public class MainActivity extends Activity {
     private HandlerThread mHandlerThread;
     private Handler mHandler;
     private boolean flag;
     //
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);
        mHandlerThread = new HandlerThread("mHandlerThread");
         mHandlerThread.start();
         mHandler = new Handler(mHandlerThread.getLooper()) {
             @Override
             public void handleMessage(Message msg) {
                 //
                 try {
                     Thread.sleep(2000);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
                 if(flag){
                     Log.i("HandlerThread", "更新："+new Random().nextInt(1000));
                 }
                 mHandler.sendEmptyMessage(1);
             }
         };
     }
     @Override
     protected void onResume() {
         //
         super.onResume();
         flag = true;
         mHandler.sendEmptyMessage(1);
     }
     @Override
     protected void onPause() {
         //
         super.onPause();
         flag = false;
     }
     @Override
     protected void onDestroy() {
         //
         super.onDestroy();
         //釋放資源
         mHandlerThread.quit();
     }
}

 public class HandlerThread extends Thread {
     int mPriority;
     int mTid = -1;
    Looper mLooper;
     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;
     }
    /**
      * Call back method that can be explicitly overridden if needed to execute some
      * setup before Looper loops.
     */
     protected void onLooperPrepared() {
     }
    @Override
    public void run() {
         mTid = Process.myTid();
         Looper.prepare();
         synchronized (this) {
            mLooper = Looper.myLooper();
             notifyAll();
         }
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
         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() {
         if (!isAlive()) {
             return null;
         }
         // 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;
     }
     public boolean quit() {
        Looper looper = getLooper();
         if (looper != null) {
             looper.quit();
             return true;
         }
         return false;
     }
     public boolean quitSafely() {
         Looper looper = getLooper();
         if (looper != null) {
             looper.quitSafely();
             return true;
         }
         return false;
     }
     /**
      * Returns the identifier of this thread. See Process.myTid().
      */
     public int getThreadId() {
         return mTid;
     }
 }