HandlerThread与AsyncQueryHandler源码分析

摘要：源码分析继承了，但是他提供的构造方法中却没有参数，也就是说它与其所在的当前线程的绑定。同时，创建了一个线程并开启，初始化了对象并与线程的进行绑定。类的方法如下子线程的消息发送到该方法中，然后根据消息中的操作结果执行相应的代码。

HandlerThread继承自Thread，其本质还是一个Thread子类，只不过它内部封装了一个Looper，可以进行消息轮询，实现主线程向子线程发送消息，子线程根据消息类型执行相应代码，主要是耗时操作，如访问IO、查询数据库，但不建议进行网络请求，因为子线程中的消息是串行执行，访问网络较为耗时，因此HandlerThread适合处理耗时较短的任务。

HandlerThread的内容并不多

package android.os;

public class HandlerThread extends Thread {
    int mPriority;//线程优先级
    int mTid = -1;
    Looper mLooper;

    public HandlerThread(String name) {
        super(name);
        mPriority = Process.THREAD_PRIORITY_DEFAULT;
    }
    
    public HandlerThread(String name, int priority) {
        super(name);
        mPriority = priority;
    }
    
    //初始化Looper后，在开启loop循环前进行一些准备工作
    protected void onLooperPrepared() {
    }

    @Override
    public void run() {
        mTid = Process.myTid();
        Looper.prepare();//给当前线程创建Looper
        synchronized (this) {
            mLooper = Looper.myLooper();//将当前线程的Looper传给mLooper变量
            notifyAll();
        }
        Process.setThreadPriority(mPriority);//设置线程优先级
        onLooperPrepared();
        Looper.loop();//开启消息循环
        mTid = -1;
    }

HandlerThread类中包含一个Looper对象mLooper，这个Looper对象在run方法中初始化，loop()开启后，不断的循环从MessageQueue中取出消息处理，当没有消息的时候会阻塞，有消息的到来的时候会唤醒。

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

getLooper方法返回当前线程创建的Looper对象，若调用该方法时Looper还未创建，则一直等待直到Looper创建完毕。

当HandlerThread使用完后，需要让线程内的Looper退出循环

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

HandlerThread handlerThread = new HandlerThread("subThread");
handlerThread.start();//开启子线程，同时也开启了子线程内消息循环
Looper looper = handlerThread.getLooper();//获取HandlerThread中的Looper
Handler handler = new Handler(looper){ //初始化Handler，与子线程Looper绑定
            @Override
            public void handleMessage(Message msg){
                //在子线程中执行
            }
};  

AsyncQueryHandler是一个异步查询操作帮助类，封装了HandlerThread和ContentResolver，可以方便地将耗时操作放在子线程中执行，并将执行结果回传至主线程中处理。

AsyncQueryHandler继承了Handler，但是他提供的构造方法中却没有Looper参数，也就是说它与其所在的当前线程的looper绑定。
AsyncQueryHandler构造方法：

public AsyncQueryHandler(ContentResolver cr) {
        super();//在父类构造方法中绑定了looper
        mResolver = new WeakReference(cr);
        synchronized (AsyncQueryHandler.class) {
            if (sLooper == null) {
                //创建HandlerThread，用于执行耗时的操作
                HandlerThread thread = new HandlerThread("AsyncQueryWorker");
                thread.start();

                sLooper = thread.getLooper();
            }
        }
        //创建工作线程的Handler对象
        mWorkerThreadHandler = createHandler(sLooper);
    }

    protected Handler createHandler(Looper looper) {
        return new WorkerHandler(looper);
    }

AsyncQueryHandler的构造方法中传入ContentResolver参数，然后创建一个对应的弱引用对象mResolver。
同时，创建了一个HandlerThread线程并开启，初始化了mWorkerThreadHandler对象并与HandlerThread线程的looper进行绑定。mWorkerThreadHandler是一个WorkerHandler类的对象，下面看WorkerHandler类：

protected class WorkerHandler extends Handler {
        public WorkerHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            final ContentResolver resolver = mResolver.get();
            if (resolver == null) return;

            WorkerArgs args = (WorkerArgs) msg.obj;

            int token = msg.what;//可理解为消息的ID
            int event = msg.arg1;//消息类型标记

            switch (event) {
                case EVENT_ARG_QUERY:
                    Cursor cursor;
                    try {
                        cursor = resolver.query(args.uri, args.projection,
                                args.selection, args.selectionArgs,
                                args.orderBy);
                        // Calling getCount() causes the cursor window to be filled,
                        // which will make the first access on the main thread a lot faster.
                        if (cursor != null) {
                            cursor.getCount();
                        }
                    } catch (Exception e) {
                        Log.w(TAG, "Exception thrown during handling EVENT_ARG_QUERY", e);
                        cursor = null;
                    }

                    args.result = cursor;
                    break;

                case EVENT_ARG_INSERT:
                    args.result = resolver.insert(args.uri, args.values);
                    break;

                case EVENT_ARG_UPDATE:
                    args.result = resolver.update(args.uri, args.values, args.selection,
                            args.selectionArgs);
                    break;

                case EVENT_ARG_DELETE:
                    args.result = resolver.delete(args.uri, args.selection, args.selectionArgs);
                    break;
            }

            // passing the original token value back to the caller
            // on top of the event values in arg1.
            Message reply = args.handler.obtainMessage(token);
            reply.obj = args;
            reply.arg1 = msg.arg1;

            if (localLOGV) {
                Log.d(TAG, "WorkerHandler.handleMsg: msg.arg1=" + msg.arg1
                        + ", reply.what=" + reply.what);
            }

            reply.sendToTarget();
        }
    }

WorkerHandler类是AsyncQueryhandler的内部类，继承了Handler，它的构造函数中传入looper作为参数，与之绑定。由上可知，实例化的WorkerHandler对象是mWorkerThreadHandler，它与HandlerThread的looper绑定，因此其handleMessage方法会在子线程中执行，处理耗时的操作

在handleMessage方法中，首先获取到mResolver对象，然后从消息中获取到WorkerArgs对象、event和token。

event：消息类型，AsyncQueryhandler中定义了四种消息类型，分别对应增删查改的四种操作

    private static final int EVENT_ARG_QUERY = 1;
    private static final int EVENT_ARG_INSERT = 2;
    private static final int EVENT_ARG_UPDATE = 3;
    private static final int EVENT_ARG_DELETE = 4;

token: 我理解为消息的ID，比如查询操作可能有很多次，每次都是发送不同的消息，因此要标识其ID，这在AsyncQueryhandler暴露的增删查改方法中也需要作为参数传入。当要取消某个操作时，执行cancelOperation方法，传入的参数就是token

public final void cancelOperation(int token) {
        mWorkerThreadHandler.removeMessages(token);
    }

WorkerArgs：静态内部类，封装了查询操作的各种参数，定义如下

protected static final class WorkerArgs {
        public Uri uri;
        public Handler handler;
        public String[] projection;
        public String selection;
        public String[] selectionArgs;
        public String orderBy;
        public Object result;
        public Object cookie;
        public ContentValues values;
    }

然后判断消息类型，跟据消息类型，进行相应的操作，以查询为例：

case EVENT_ARG_QUERY:
                    Cursor cursor;
                    try {
                        cursor = resolver.query(args.uri, args.projection,
                                args.selection, args.selectionArgs,
                                args.orderBy);
    
                        if (cursor != null) {
                            cursor.getCount();
                        }
                    } catch (Exception e) {
                        Log.w(TAG, "Exception thrown during handling EVENT_ARG_QUERY", e);
                        cursor = null;
                    }
                    args.result = cursor;
                    break;

就是基本的查询操作，将查询的结果保存在args.result，最后：

Message reply = args.handler.obtainMessage(token);
            reply.obj = args;
            reply.arg1 = msg.arg1;

            reply.sendToTarget();

注意：这里将带有操作结果的args对象封装入一个message中，这个message的handler是args中保存的handler，然后将这个消息发送出去。

那么，WorkerHandler类中handleMessage方法的消息从何处发来的？reply这个消息又将发向哪里？

handleMessage方法中的消息是主线程执行操作时发送的，这里以查询为例，在AsyncQueryHandler类中：

public void startQuery(int token, Object cookie, Uri uri,
            String[] projection, String selection, String[] selectionArgs,
            String orderBy) {
        // Use the token as what so cancelOperations works properly
        Message msg = mWorkerThreadHandler.obtainMessage(token);//获取一个消息
        msg.arg1 = EVENT_ARG_QUERY;

        WorkerArgs args = new WorkerArgs();
        args.handler = this;//指向AsyncQueryHandler对象
        args.uri = uri;
        args.projection = projection;
        args.selection = selection;
        args.selectionArgs = selectionArgs;
        args.orderBy = orderBy;
        args.cookie = cookie;
        msg.obj = args;

        mWorkerThreadHandler.sendMessage(msg);
    }

这里开启异步查询操作，首先获取一个消息，这个消息将携带查询操作所需的各种参数，这些参数被封装在WorkerArgs中，这个消息将被发送到工作线程（子线程）中的MessageQueue，等待被执行，因此，子线程HandlerThread将会接收到这个消息，所以该消息的handler对象为mWorkerThreadHandler。

注意，在构造args对象后，args.handler = this 将args对象的handler指向了AsyncQueryHandler对象，因此，在WorkerHandler的handleMessage方法中：

Message reply = args.handler.obtainMessage(token);
            reply.obj = args;
            reply.arg1 = msg.arg1;

            reply.sendToTarget();

这个reply消息将会发送到AsyncQueryHandler对象的handleMessage方法中，也就是将查询结果发送到主线程中的handleMessage方法中。
AsyncQueryHandler类的handleMessage方法如下：

@Override
    public void handleMessage(Message msg) {
        WorkerArgs args = (WorkerArgs) msg.obj;

        if (localLOGV) {
            Log.d(TAG, "AsyncQueryHandler.handleMessage: msg.what=" + msg.what
                    + ", msg.arg1=" + msg.arg1);
        }

        int token = msg.what;
        int event = msg.arg1;

        // pass token back to caller on each callback.
        switch (event) {
            case EVENT_ARG_QUERY:
                onQueryComplete(token, args.cookie, (Cursor) args.result);
                break;

            case EVENT_ARG_INSERT:
                onInsertComplete(token, args.cookie, (Uri) args.result);
                break;

            case EVENT_ARG_UPDATE:
                onUpdateComplete(token, args.cookie, (Integer) args.result);
                break;

            case EVENT_ARG_DELETE:
                onDeleteComplete(token, args.cookie, (Integer) args.result);
                break;
        }
    }
}

子线程的消息发送到该handleMessage方法中，然后根据消息中的操作结果执行相应的代码。这样整个异步查询流程就完成了。

QueryHandler handler = new QueryHandler(getContentResolver());//创建异步查询对象
//开启查询，传入查询参数
handler.startQuery(token, cookie, uri, projection, selection, selectionArgs, String orderBy)

//自定义AsyncQueryHandler类
private final class QueryHandler extends AsyncQueryHandler{

        public QueryHandler(ContentResolver cr) {
            super(cr);
            //do something
        }
        
        //查询完毕后将结果后回传至此方法
        @Override
        protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
            //do something
        }
    }

AsyncQueryHandler是一个Handler，其内部还有一个Handler类WorkerHandler

AsyncQueryHandler：与创建它的线程（调用线程）的looper绑定
AsyncQueryHandler.handleMessage：处理子线程发来的消息，消息携带操作结果

WorkerHandler：与HandlerThread线程（工作线程）的looper绑定
AsyncQueryHandler.handleMessage：接收主线程发送的增删查改消息，并执行，将结果消息发送至主线程。