Handler和HandlerThread

Hander

Hander的主要作用有两个:

  1. 延迟处理消息。
  2. 在其他线程处理消息。

这里的消息可以理解为MessageRunnable,通过如下方法来调度消息。

方法作用
post(Runnable)将Runnable对象添加到消息队列
postAtTime(java.lang.Runnable, long)加入消息队列,在特定时间执行Runnable对象
postDelayed(Runnable, Object, long)加入消息队列,延迟执行
sendEmptyMessage(int)仅仅发送what值消息
sendMessage(Message)将Message对象加入队列
sendMessageAtTime(Message, long)同理
sendMessageDelayed(Message, long)同理

Runnable实际上是将该Runnable匿名对象排入队列,在其他线程执行该消息,这里的其他线程可以理解为MessageQueue所在的线程。

MessageQueue和Looper

MessageQueue是由Looper来创建的,通过与该Looper关联的Handler对象往里面添加消息。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public Handler(Callback callback, boolean async) {
if (FIND_POTENTIAL_LEAKS) {
final Class<? extends Handler> klass = getClass();
if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
(klass.getModifiers() & Modifier.STATIC) == 0) {
Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
klass.getCanonicalName());
}
}
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}

这是Handler的构造函数,第10行代码可以看到在里面通过Looper.myLooper()获得了Looper对象。而2到9行代码是对Handler类是否为静态内部类的检测代码,否则会提示一个警告可能会造成内存泄漏。

另外一个值得注意的是第15行的mQueue = mLooper.mQueue, 可以看到Looper会把自己的MessageQueue对象交给Handler.

Looper.java中找到静态方法myLooper,令人好奇的是sThreadLocal里面为什么可以通过get()方法获取到一个Looper对象。

1
2
3
4
5
6
7
8
9
10
11
12
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}

static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<>();

private static void prepare(boolean quitAllowed) {
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper(quitAllowed));
}

可以看到Looper.prepare()中给sThreadLocal中设置了Looper对象,如果已经存在当前线程的Looper对象则不会再次创建,而且值得注意的是不要重复调用prepare()方法,否则会抛异常。

至此,我们已经验证了Handler中获得了当前线程的Looper对象,下面我们看看Looper是怎么创建MessageQueue的。

1
2
3
4
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}

添加队列

我们来研究一下添加队列的过程。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public final boolean sendMessage(Message msg)
{
return sendMessageDelayed(msg, 0);
}

public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}

public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
MessageQueue queue = mQueue;
if (queue == null) {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
return false;
}
return enqueueMessage(queue, msg, uptimeMillis);
}

你会发现最终发送的消息是通过sendMessageAtTime发送的,上面我们已经提到过了LooperMessageQueue交给了Handler,来看看enqueueMessage方法。

1
2
3
4
5
6
7
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}

请注意第2行的msg.target=this,也就是这个target是Handler对象。

至此,我们已经将消息添加到了MessageQueue了,接下来我们来看看Looper是怎么管理队列的。

管理队列

一般创建一个Handler的过程如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class LooperThread extends Thread {
public Handler mHandler;

public void run() {
Looper.prepare();

mHandler = new Handler() {
public void handleMessage(Message msg) {
// process incoming messages here
}
};

Looper.loop();
}
}

这个Looper.loop()静态方法内有一个无限的for循环,在这个for循环中对队列数据进行了处理和分发,下面是部分代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public static void loop() {

final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
final MessageQueue queue = me.mQueue;

for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}

try {
msg.target.dispatchMessage(msg);
end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}

}

}

可以看到第17行的msg.target.dispatchMessage(msg),哈哈,上面已经提到了这里的msg.target实际上是Handler对象。

1
2
3
4
5
6
7
8
9
10
11
12
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}

至此,整个过程已经完成,你会发现这个过程其实很简单。

HandlerThread

到现在这个HandlerThread就很好理解了,它其实是是一个线程,继承自Thread类,可以说它是对Thread的一种Looper包装,它里面实现了Looper的创建。

通常情况下我们可以拿到该线程的Looper对象来创建Handler,这样Handler的消息处理就会在HandlerThread所在线程执行。

1
2
3
mSerialThread = new HandlerThread("serial-worker-thread");
mSerialThread.start();
mSerialThreadHandler = new Handler(mSerialThread.getLooper());

如果配合RxJava的线程调度就更妙了,哈哈。

1
2
3
4
5
6
7
8

Observable.create(new ObservableOnSubscribe<RecvCommand>() {
@Override
public void subscribe(ObservableEmitter<RecvCommand> emitter) throws Exception {

//TODO Somethings
}
}).subscribeOn(AndroidSchedulers.from(mSerialThread.getLooper()));

简单的说HandlerThread可以方便我们快速创建一个处理消息队列的线程,我们可以获取它的Looper对象来给相关Handler,相对应的Handler就可以给该线程发送消息。

最后我们看看HandlerThread的run()方法吧,看到这个代码是不是什么都不用说了,哈哈。

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

评论

Ajax Android AndroidStudio Animation Anroid Studio AppBarLayout Babel Banner Buffer Bulma ByteBuffer C++ C11 C89 C99 CDN CMYK COM1 COM2 CSS Camera Raw, 直方图 Chrome ContentProvider CoordinatorLayout C语言 DML DOM Dagger Dagger2 Darktable Demo Document DownloadManage ES2015 ESLint Element Error Exception Extensions File FileProvider Flow Fresco GCC Git GitHub GitLab Gradle Groovy HTML5 Handler HandlerThread Hexo Hybrid I/O IDEA IO ImageMagick IntelliJ Intellij Interpolator JCenter JNI JS Java JavaScript JsBridge Kotlin Lab Lambda Lifecycle Lint Linux Looper MQTT MVC MVP Maven MessageQueue Modbus Momentum MySQL NDK NIO NexT Next Nodejs ObjectAnimator Oracle VM Permission PhotoShop Physics Python RGB RS-232 RTU Remote-SSH Retrofit Runnable RxAndroid RxJava SE0 SSH Spring SpringBoot Statubar Task Theme Thread Tkinter UI UIKit UML VM virtualBox VS Code VUE ValueAnimator ViewPropertyAnimator Vue Web Web前端 Workbench api apk bookmark by关键字 compileOnly css c语言 databases demo hexo hotfix html iOS icarus implementation init jQuery javascript launchModel logo merge mvp offset photos pug query rxjava2 scss servlet shell svg tkinter tomcat transition unicode utf-8 vector virtual box vscode 七牛 下载 中介者模式 串口 临潼石榴 主题 书签 事件 享元模式 仓库 代理模式 位运算 依赖注入 修改,tables 光和色 内存 内核 内部分享 函数 函数式编程 分支 分析 创建 删除 动画 单例模式 压缩图片 发布 可空性 合并 同向性 后期 启动模式 命令 命令模式 响应式 响应式编程 图层 图床 图片压缩 图片处理 图片轮播 地球 域名 基础 增加 备忘录模式 外观模式 多线程 大爆炸 天气APP 太白山 头文件 奇点 字符串 字符集 存储引擎 宇宙 宏定义 实践 属性 属性动画 岐山擀面皮 岐山肉臊子 岐山香醋 工具 工厂模式 年终总结 开发技巧 异常 弱引用 恒星 打包 技巧 指针 插件 摄影 操作系统 攻略 故事 数据库 数据类型 数组 文件 新功能 旅行 旋转木马 时序图 时空 时间简史 曲线 杂谈 权限 枚举 架构 查询 标准库 标签选择器 样式 核心 框架 案例 桥接模式 检测工具 模块化 模板引擎 模板方法模式 油泼辣子 泛型 洛川苹果 浅色状态栏 源码 源码分析 瀑布流 热修复 版本 版本控制 状态栏 状态模式 生活 留言板 相册 相对论 眉县猕猴桃 知识点 码云 磁盘 科学 笔记 策略模式 类图 系统,发行版, GNU 索引 组件 组合模式 结构 结构体 编码 网易云信 网格布局 网站广播 网站通知 网络 美化 联合 膨胀的宇宙 自定义 自定义View 自定义插件 蒙版 虚拟 虚拟机 补码 补齐 表单 表达式 装饰模式 西安 观察者模式 规范 视图 视频 解耦器模式 设计 设计原则 设计模式 访问者模式 语法 责任链模式 贪吃蛇 转换 软件工程 软引用 运算符 迭代子模式 适配器模式 选择器 通信 通道 配置 链表 锐化 错误 键盘 闭包 降噪 陕西地方特产 面向对象 项目优化 项目构建 黑洞
Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×