Handler、HandlerThread、AsyncQueryHandler三者的关系

最新推荐文章于 2020-03-16 11:13:25 发布

tianzhaohui1991

最新推荐文章于 2020-03-16 11:13:25 发布

阅读量181

点赞数

分类专栏： Android 系统知识

Android 系统知识专栏收录该内容

1 篇文章 0 订阅

订阅专栏

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

    private Runnable mRunnable = new Runnable() {

        public void run() {
            //为了方便查看，我们用Log打印出来
            Log.e(TAG, Thread.currentThread().getId() + " " +count);
            count++;
            setTitle("" +count);
            //每2秒执行一次
            mHandler.postDelayed(mRunnable, 2000);
        }

    };
    @Override
    public void onCreate(Bundle savedInstanceState) {
    Log.e(TAG, "Main id    "+Thread.currentThread().getId() + " " +count);
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        //通过Handler启动线程
        mHandler = new Handler();
        mHandler.post(mRunnable);
    }
    @Override
    protected void onDestroy() {
        //将线程与当前handler解除绑定
        //mHandler.removeCallbacks(mRunnable);
        super.onDestroy();
    }
}

这里直接通过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其实就是对消息队列以及队列处理逻辑的封装，简单说就是消息队列+消息循环。

当我们需要一个工作者线程，而不是把它当作一次性消耗品，用过即废弃的话，就可以使用它。

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

    private Runnable mRunnable = new Runnable() {

        public void run() {
            //为了方便查看，我们用Log打印出来
            Log.e(TAG, Thread.currentThread().getId() + " " +count);
            count++;
//            setTitle("" +count);
            //每2秒执行一次
            mHandler.postDelayed(mRunnable, 2000);
        }

    };
    @Override
    public void onCreate(Bundle savedInstanceState) {
    Log.e(TAG, "Main id    "+Thread.currentThread().getId() + " " +count);
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        //通过Handler启动线程
        HandlerThread handlerThread = new HandlerThread("threadone");
        handlerThread.start();
        mHandler = new Handler(handlerThread.getLooper());
        mHandler.post(mRunnable);


    }
    @Override
    protected void onDestroy() {
        //将线程与当前handler解除
        mHandler.removeCallbacks(mRunnable);
        super.onDestroy();
    }
}

这里通过HandlerThread启动一个新线程

注这里需要handlerThread.start();先启动线程才能 handlerThread.getLooper() 获取当前线程的Looper

通过HandlerThread的run方法可以发现

view plaincopy to clipboardprint?
01.public void run() {
02.        mTid = Process.myTid();
03.        Looper.prepare();
04.        synchronized (this) {
05.            mLooper = Looper.myLooper();
06.            Process.setThreadPriority(mPriority);
07.            notifyAll();
08.        }
09.        onLooperPrepared();
10.        Looper.loop();
11.        mTid = -1;
12.    }
public void run() {
        mTid = Process.myTid();
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
            Process.setThreadPriority(mPriority);
            notifyAll();
        }
        onLooperPrepared();
        Looper.loop();
        mTid = -1;
    }

这里调用了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

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

private static final String TAG = "bb";

private static Looper sLooper = null;

private static final int EVENT_ARG_WORK = 1;

private WorkerHandler mWorkerHanler ;

protected final class WorkerArgs{
  Handler handler;
}

public AsyncWorkHandler(){
  synchronized (AsyncQueryHandler.class) {
            if (sLooper == null) {
                HandlerThread thread = new HandlerThread("AsyncWorkHandler");
                thread.start();
                sLooper = thread.getLooper();
            }
        }
  mWorkerHanler = new WorkerHandler(sLooper);
}

protected class WorkerHandler extends Handler {
  public WorkerHandler(Looper looper) {
            super(looper);
        }
        @Override
        public void handleMessage(Message msg) {

        WorkerArgs args = (WorkerArgs) msg.obj;

        int info = msg.arg1;

        Log.i(TAG, "worker handler=-------------------"+info);

        Message result = args.handler.obtainMessage();

        result.arg1 = EVENT_ARG_WORK;

        result.sendToTarget();
        }

}

/**
* 需要重写的回调函数
*/
protected void onCompleteWork(){

}

public void doWork(int strInfo){

  Message msg = mWorkerHanler.obtainMessage();

  WorkerArgs workArgs = new WorkerArgs();
  workArgs.handler = this;
  msg.obj = workArgs;
  msg.arg1 = strInfo;
  mWorkerHanler.sendMessage(msg);
}

@Override
public void handleMessage(Message msg) {

  Log.i(TAG, "main handler ----------------"+msg.arg1);

  if(EVENT_ARG_WORK == msg.arg1){
   onCompleteWork();
  }
}
}

就是仿照这个类而已当然这个还需要根据实际的情况进行一些封装实际内部还是通过HandlerThread来实现

比较耗时的操作可以在WorkerHandler的方法中进行实现

那调用的方法

view plaincopy to clipboardprint?
01.AsyncWorkHandler asyncWorkHandler = new AsyncWorkHandler(){
02.            @Override
03.            protected void onCompleteWork() {
04.                Log.i("bb", "do call back methoid");
05.            }
06.        };
07.        asyncWorkHandler.doWork(321);
AsyncWorkHandler asyncWorkHandler = new AsyncWorkHandler(){
        @Override
        protected void onCompleteWork() {
          Log.i("bb", "do call back methoid");
        }
        };
        asyncWorkHandler.doWork(321);

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

我想我们做地图用来处理数据的部分可以考虑尝试一下

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/wanglong0537/archive/2011/04/06/6304239.aspx

tianzhaohui1991

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Handler、HandlerThread、AsyncQueryHandler三者的关系

首先创建工程 ThreadDemo 创建Activity一、HandlerHandler在android里负责发送和处理消息。它的主要用途有：　　1）按计划发送消息或执行某个Runnanble(使用POST方法)；　　2）从其他线程中发送来的消息放入消息队列中，避免线程冲突（常见于更新UI线程）　　默认情况下，Handler接受的是当前线程下的消息循环实例（使用H
复制链接

扫一扫

专栏目录