深入学习理解 Handler HandlerThread AsyncQueryHandler 三者的关系

首先创建工程 ThreadDemo 创建Activity
一、Handler
Handler在android里负责发送和处理消息。它的主要用途有：
　　1）按计划发送消息或执行某个Runnanble(使用POST方法)；
　　2）从其他线程中发送来的消息放入消息队列中，避免线程冲突（常见于更新UI线程）
　　 默认情况下，Handler接受的是当前线程下的消息循环实例（使用Handler(Looper looper)、Handler(Looper  looper, Handler.Callback callback) 可以指定线程），同时一个消息队列可以被当前线程中的多个对象进行分发、处理（在UI线程中，系统已经有一个Activity来处理了，你可以再起若干个 Handler来处理）。在实例化Handler的时候，Looper可以是任意线程的，只要有Handler的指针，任何线程也都可以 sendMessage。Handler对于Message的处理不是并发的。一个Looper 只有处理完一条Message才会读取下一条，所以消息的处理是阻塞形式的（handleMessage()方法里不应该有耗时操作，可以将耗时操作放在 其他线程执行，操作完后发送Message（通过sendMessges方法）,然后由handleMessage()更新UI）。

1. view plaincopy to clipboardprint?
   
2. package com.debby.threaddemo;  
   
3. import android.app.Activity;  
   
4. import android.content.AsyncQueryHandler;  
   
5. import android.os.Bundle;  
   
6. import android.os.Handler;  
   
7. import android.os.HandlerThread;  
   
8. import android.util.Log;  
   
9. public class ThreadDemo extends Activity {  
   
10.     private static final String TAG = "bb";    
    
11.     private int count = 0;    
    
12.     private Handler mHandler ;    
    
13.         
    
14.     private Runnable mRunnable = new Runnable() {    
    
15.             
    
16.         public void run() {    
    
17.             //为了方便 查看，我们用Log打印出来    
    
18.             Log.e(TAG, Thread.currentThread().getId() + " " +count);    
    
19.             count++;    
    
20.             setTitle("" +count);    
    
21.             //每2秒执行一次    
    
22.             mHandler.postDelayed(mRunnable, 2000);    
    
23.         }    
    
24.             
    
25.     };    
    
26.     @Override    
    
27.     public void onCreate(Bundle savedInstanceState) {    
    
28.         Log.e(TAG, "Main id    "+Thread.currentThread().getId() + " " +count);    
    
29.         super.onCreate(savedInstanceState);    
    
30.         setContentView(R.layout.main);     
    
31.         //通过Handler启动线程    
    
32.         mHandler =  new Handler();  
    
33.         mHandler.post(mRunnable);    
    
34.     }    
    
35.     @Override    
    
36.     protected void onDestroy() {    
    
37.         //将线程与当前handler解除绑定  
    
38.         //mHandler.removeCallbacks(mRunnable);    
    
39.         super.onDestroy();    
    
40.     }    
    
41. }  

复制代码

这里直接通过Handler启动一个线程
执行测试后可以发现 setTitle("" +count);   该行代码可以执行 并可以不断改变UI

由于android是单线程模型 所以可见个线程就是运行在UI主线程当中的 通过两次打印的Log也可以看出是同一个线程

也就是说mHandler.post(mRunnable);  执行了run()方法 并没有执行Thread的start()方法开启一个新的线程
所以这种方式不适合比较耗时的操作 会堵塞主线程 UI message队列
另外 mHandler.removeCallbacks(mRunnable);   该行代码如果注释掉会发现即使退出该Acitivity也会继续执行线程的run()
方法 所以这里需要注意

二、 HandlerThread
HandlerThread继承于Thread，所以它本质就是个Thread。与普通Thread的差别就在于，它有个Looper成员变量。这个Looper其实就是对消息队列以及队列处理逻辑的封装，简单说就是 消息队列+消息循环。
当我们需要一个工作者线程，而不是把它当作一次性消耗品，用过即废弃的话，就可以使用它。

1. view plaincopy to clipboardprint?
   
2. public class ThreadDemo extends Activity {  
   
3.     private static final String TAG = "bb";    
   
4.     private int count = 0;    
   
5.     private Handler mHandler ;    
   
6.         
   
7.     private Runnable mRunnable = new Runnable() {    
   
8.             
   
9.         public void run() {    
   
10.             //为了方便 查看，我们用Log打印出来    
    
11.             Log.e(TAG, Thread.currentThread().getId() + " " +count);    
    
12.             count++;    
    
13. //            setTitle("" +count);    
    
14.             //每2秒执行一次    
    
15.             mHandler.postDelayed(mRunnable, 2000);    
    
16.         }    
    
17.             
    
18.     };    
    
19.     @Override    
    
20.     public void onCreate(Bundle savedInstanceState) {    
    
21.         Log.e(TAG, "Main id    "+Thread.currentThread().getId() + " " +count);    
    
22.         super.onCreate(savedInstanceState);    
    
23.         setContentView(R.layout.main);     
    
24.         //通过Handler启动线程    
    
25.         HandlerThread handlerThread = new HandlerThread("threadone");  
    
26.         handlerThread.start();  
    
27.         mHandler =  new Handler(handlerThread.getLooper());  
    
28.         mHandler.post(mRunnable);    
    
29.           
    
30.           
    
31.     }    
    
32.     @Override    
    
33.     protected void onDestroy() {    
    
34.         //将线程与当前handler解除  
    
35.         mHandler.removeCallbacks(mRunnable);    
    
36.         super.onDestroy();    
    
37.     }    
    
38. }  

复制代码

这里通过HandlerThread启动一个新线程
注这里需要handlerThread.start();先启动线程 才能 handlerThread.getLooper() 获取当前线程的Looper
通过HandlerThread的run方法可以发现

1. view plaincopy to clipboardprint?
   
2. public void run() {  
   
3.         mTid = Process.myTid();  
   
4.         Looper.prepare();  
   
5.         synchronized (this) {  
   
6.             mLooper = Looper.myLooper();  
   
7.             Process.setThreadPriority(mPriority);  
   
8.             notifyAll();  
   
9.         }  
   
10.         onLooperPrepared();  
    
11.         Looper.loop();  
    
12.         mTid = -1;  
    
13.     }  

复制代码

这里调用了Looper.prepare(); 初始化了Looper
通过执行可以发现 setTitle("" +count);  在这里调用会出现异常  
还有通过打印的日志
 
都可以发现 这里启动的是一个新线程 虽然不能直接操作UI 但可以通过Message发送消息来进行操作
这样可以处理一些比较耗时操作
三、AsyncQueryHandler
这个类继承了Handler 实现了 ContentProvider处理相关的一些操作的异步方式
与其说这个类提供给我们一个处理ContentProvider的方法 我觉得这更给我们提供了一个处理异步的方案
若我们不用AsyncQueryHandler，直接在UI 线程调用ContentResolve去操作数据库比如查询，若你的数据库的数据很少还好，若很多，就会出现ANR了。一般解决ANR,就是开 thread去解决。让UI线程知道何时查询完毕，可以更新UI将查询的结果表现出来
首先分析一下 AsyncQueryHandler 这个类
他的基本策略如下：
　　1. 当你实例化一个AsyncQueryHandler类时（包括其子类...），它会单件构造一个线程WorkerHandler，这个线程里面会构建一个消息循环。
　　2. 获得该消息循环的指针，用它做参数实例化另一个Handler类，该类为内部类。至此，就有了两个线程，各自有一个Handler来处理消息。
　　3. 当调用onXXX的时候，在XXX函数内部会将请求封装成一个内部的参数类，将其作为消息的参数，将此消息发送至另一个线程。
　　4. 在该线程的Handler中，接受该消息，并分析传入的参数，用初始化时传入的ContentResolver进行XXX操作，并返回Cursor或其他返回值。
　　5. 构造一个消息，将上述返回值以及其他相关内容绑定在该消息上，发送回主线程。
　　6. 主线程默认的AsyncQueryHandler类的handleMessage方法（可自定义，但由于都是内部类，基本没有意义...）会分析该消息，并转发给对应的onXXXComplete方法。
　　7. 用户重写的onXXXComplete方法开始工作。
通过上面的HandlerThread的用法可以看到我们启动新线程进行操作的代码是很冗余很繁琐的 把更多对Handler的操作暴露出来了
这样是很不利于维护和复用的（虽然有时候没有必要 这不显得比较NB嘛）
那通过这个类我们只需要实例化的时候传入ContentResolver 并实现自己的回调方法onXXXComplete 最后调用你需要的操作就可以
确实代码简洁了 想知道怎么回事去反编译android的代码去吧
那我觉得如果有什么非ContentProvider操作，却需要异步多线程执行的话，模拟一套，是个不错的选择
这里我做了个demo

1. view plaincopy to clipboardprint?
   
2. public class AsyncWorkHandler extends Handler{  
   
3.       
   
4.     private static final String TAG = "bb";  
   
5.       
   
6.     private static Looper sLooper = null;  
   
7.       
   
8.     private static final int EVENT_ARG_WORK = 1;  
   
9.       
   
10.     private WorkerHandler mWorkerHanler ;  
    
11.       
    
12.     protected final class WorkerArgs{  
    
13.         Handler handler;  
    
14.     }  
    
15.       
    
16.     public AsyncWorkHandler(){  
    
17.         synchronized (AsyncQueryHandler.class) {  
    
18.             if (sLooper == null) {  
    
19.                 HandlerThread thread = new HandlerThread("AsyncWorkHandler");  
    
20.                 thread.start();  
    
21.                 sLooper = thread.getLooper();  
    
22.             }  
    
23.         }  
    
24.         mWorkerHanler = new WorkerHandler(sLooper);  
    
25.     }  
    
26.       
    
27.     protected class WorkerHandler extends Handler {  
    
28.         public WorkerHandler(Looper looper) {  
    
29.             super(looper);  
    
30.         }  
    
31.         @Override  
    
32.         public void handleMessage(Message msg) {  
    
33.               
    
34.             WorkerArgs args = (WorkerArgs) msg.obj;  
    
35.               
    
36.             int info = msg.arg1;  
    
37.               
    
38.             Log.i(TAG, "worker handler=-------------------"+info);  
    
39.               
    
40.             Message result = args.handler.obtainMessage();  
    
41.               
    
42.             result.arg1 = EVENT_ARG_WORK;  
    
43.               
    
44.             result.sendToTarget();  
    
45.         }  
    
46.           
    
47.     }  
    
48.       
    
49.     /** 
    
50.      * 需要重写的回调函数 
    
51.      */  
    
52.     protected void onCompleteWork(){  
    
53.           
    
54.     }  
    
55.       
    
56.     public void doWork(int strInfo){  
    
57.           
    
58.         Message msg = mWorkerHanler.obtainMessage();  
    
59.           
    
60.         WorkerArgs workArgs = new WorkerArgs();  
    
61.         workArgs.handler = this;  
    
62.         msg.obj = workArgs;  
    
63.         msg.arg1 = strInfo;  
    
64.         mWorkerHanler.sendMessage(msg);  
    
65.     }  
    
66.       
    
67.     @Override  
    
68.     public void handleMessage(Message msg) {  
    
69.           
    
70.         Log.i(TAG, "main handler ----------------"+msg.arg1);  
    
71.           
    
72.         if(EVENT_ARG_WORK == msg.arg1){  
    
73.             onCompleteWork();  
    
74.         }  
    
75.     }  
    
76. }  

复制代码

就是仿照这个类而已 当然这个还需要根据实际的情况进行一些封装 实际内部还是通过HandlerThread来实现
比较耗时的操作可以在WorkerHandler的 方法中进行实现
那调用的方法

1. view plaincopy to clipboardprint?
   
2. AsyncWorkHandler asyncWorkHandler = new AsyncWorkHandler(){  
   
3.             @Override  
   
4.             protected void onCompleteWork() {  
   
5.                 Log.i("bb", "do call back methoid");  
   
6.             }  
   
7.         };  
   
8.         asyncWorkHandler.doWork(321);  

复制代码

比较简单点了  这个可以用在一个项目中比较经常会用到的地方