HandlerThread使用及源码分析

HandlerThread线程其实就是一个内部创建了Looper的普通线程

HandlerThread使用：
a、建立HandlerThread线程
b、运行线程
c、获取HandlerThread线程中的Looper实例
d、经过Looper实例建立Handler实例，从而使mSubThreadHandler与该线程链接到一块儿

 myHandlerThread = new HandlerThread( "handler-thread") ; //开启一个线程

myHandlerThread.start(); //在这个线程中建立一个handler对象

handler = new Handler( myHandlerThread.getLooper() ){

　　@Override

　　public void handleMessage(Message msg) {

　　　　super.handleMessage(msg); //这个方法是运行在 handler-thread 线程中的 ，能够执行耗时操做

　　　　Log.d( "handler " , "消息： " + msg.what + " 线程： " + Thread.currentThread().getName() ) ;

　　}

};

//在主线程给handler发送消息

handler.sendEmptyMessage( 1 ) ;

 

 

 

源码分析：

package android.os;
/**
 * 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 {

    //线程优先级
    int mPriority;

　//线程id
    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() {
    }

　//线程体的实现逻辑,loop的创建
    @Override
    public void run() {
        mTid = Process.myTid();

　　//建立Looper实例
        Looper.prepare();
        synchronized (this) {

            //获取当前线程的Looper实例
            mLooper = Looper.myLooper();

            //通知外部looper已经获取到，getLooper里会等待这个通知
            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;    }    /**     * Returns the identifier of this thread. See Process.myTid().     */    public int getThreadId() {        return mTid;    }}