private Looper myLooper;
private Thread thread = new Thread(new Runnable() {
  public void run() {

    Looper.prepare();
    myLooper = Looper.myLooper();
    //do something
    Looper.loop();

  }
});

private Handler handler = new Handler(myLooper){
  public void handleMessage(Message msg) {
    super.handleMessage(msg);
  }
};

handler.sendEmptyMessage(1);

/**
 * 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 {
  Looper mLooper;
}

@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;
}

/**
  * 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;
}

/**
  * Quits the handler thread's looper safely.
  * <p>
  * Causes the handler thread's looper to terminate as soon as all remaining messages
  * in the message queue that are already due to be delivered have been handled.
  * Pending delayed messages with due times in the future will not be delivered.
  * </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>
  * If the thread has not been started or has finished (that is if
  * {@link #getLooper} returns null), then false is returned.
  * Otherwise the looper is asked to quit and true is returned.
  * </p>
  *
  * @return True if the looper looper has been asked to quit or false if the
  * thread had not yet started running.
  */
public boolean quitSafely() {
    Looper looper = getLooper();
    if (looper != null) {
        looper.quitSafely();
        return true;
    }
    return false;
}

import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Message;
import android.app.Activity;
import android.util.Log;

public class MainActivity extends Activity {

    private HandlerThread myHandlerThread ;
    private Handler handler ;

    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //创建HandlerThread线程,线程名字：I'm a handlerthread
        myHandlerThread = new HandlerThread( "I'm a handlerthread");

        //开启HandlerThread线程
        myHandlerThread.start();

        //在这个线程中创建一个handler对象，并绑定myHandlerThread的looper对象
        handler = new Handler( myHandlerThread.getLooper() ){

            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                //这个方法是运行在myHandlerThread线程中的
                Log.d( "handler " , "发送的消息是： " + msg.what + "  所在线程为： " + Thread.currentThread().getName());
            }
        };

        //在主线程给handler发送消息
        handler.sendEmptyMessage( 1 ) ;

        new Thread(new Runnable() {

            public void run() {

             //在子线程给handler发送数据
             handler.sendEmptyMessage( 2 ) ;
            }
        }).start() ;

    }

    protected void onDestroy() {
        super.onDestroy();

        //退出消息循环，释放资源
        myHandlerThread.quit() ;
    }
}