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