字节跳动技术整理：进程间的通信-之-Handler机制

最新推荐文章于 2024-10-10 09:56:47 发布

2401_84903633

最新推荐文章于 2024-10-10 09:56:47 发布

阅读量859

点赞数 9

分类专栏：程序员文章标签： java jvm 算法

本文链接：https://blog.csdn.net/2401_84903633/article/details/138986449

版权

程序员专栏收录该内容

60 篇文章 0 订阅

订阅专栏

// 从而决定消息队列应处于出队消息状态 or 等待状态
int nextPollTimeoutMillis = 0;

for (;😉 {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}

// nativePollOnce方法在native层，若是nextPollTimeoutMillis为-1，此时消息队列处于等待状态　
nativePollOnce(ptr, nextPollTimeoutMillis);

synchronized (this) {

final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;

// 出队消息，即从消息队列中取出消息：按创建Message对象的时间顺序
if (msg != null) {
if (now < msg.when) {
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
// 取出了消息
mBlocked = false;
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
mMessages = msg.next;
}
msg.next = null;
if (DEBUG) Log.v(TAG, "Returning message: " + msg);
msg.markInUse();
return msg;
}
} else {

// 若消息队列中已无消息，则将nextPollTimeoutMillis参数设为-1
// 下次循环时，消息队列则处于等待状态
nextPollTimeoutMillis = -1;
}

…
}
…
}
}// 回到分析原处

/**

分析2：dispatchMessage(msg)
定义：属于处理者类（Handler）中的方法
作用：派发消息到对应的Handler实例 & 根据传入的msg作出对应的操作
*/
public void dispatchMessage(Message msg) {

// 1. 若msg.callback属性不为空，则代表使用了post（Runnable r）发送消息
// 则执行handleCallback(msg)，即回调Runnable对象里复写的run（）
// 上述结论会在讲解使用“post（Runnable r）”方式时讲解
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}

// 2. 若msg.callback属性为空，则代表使用了sendMessage（Message msg）发送消息（即此处需讨论的）
// 则执行handleMessage(msg)，即回调复写的handleMessage(msg) ->> 分析3
handleMessage(msg);

}
}

/**

分析3：handleMessage(msg)
注：该方法 = 空方法，在创建Handler实例时复写 = 自定义消息处理方式
**/
public void handleMessage(Message msg) {
… // 创建Handler实例时复写
}

总结：
（1）消息循环的操作 = 消息出队 + 分发给对应的Handler实例
（2）分发给对应的Handler的过程：根据出队消息的归属者通过dispatchMessage(msg)进行分发，最终回调复写的handleMessage(Message msg)，从而实现消息处理的操作
（3）特别注意：在进行消息分发时（dispatchMessage(msg)），会进行1次发送方式的判断：
若msg.callback属性不为空，则代表使用了post（Runnable r）发送消息，则直接回调Runnable对象里复写的run（）若msg.callback属性为空，则代表使用了sendMessage（Message msg）发送消息，则回调复写的handleMessage(msg)

步骤1：在主线程中通过匿名内部类创建Handler类对象

/**

具体使用
*/
private Handler mhandler = new Handler(){
// 通过复写handlerMessage()从而确定更新UI的操作
@Override
public void handleMessage(Message msg) {
…// 需执行的UI操作
}
};

/**

源码分析：Handler的构造方法
作用：初始化Handler对象 & 绑定线程
注：
a. Handler需绑定线程才能使用；绑定后，Handler的消息处理会在绑定的线程中执行
b. 绑定方式 = 先指定Looper对象，从而绑定了 Looper对象所绑定的线程（因为Looper对象本已绑定了对应线程）
c. 即：指定了Handler对象的 Looper对象 = 绑定到了Looper对象所在的线程
*/
public Handler() {

this(null, false);
// ->>分析1

}
/**

分析1：this(null, false) = Handler（null，false）
*/
public Handler(Callback callback, boolean async) {

…// 仅贴出关键代码

// 1. 指定Looper对象
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
“Can’t create handler inside thread that has not called Looper.prepare()”);
}
// Looper.myLooper()作用：获取当前线程的Looper对象；若线程无Looper对象则抛出异常
// 即：若线程中无创建Looper对象，则也无法创建Handler对象
// 故若需在子线程中创建Handler对象，则需先创建Looper对象
// 注：可通过Loop.getMainLooper()可以获得当前进程的主线程的Looper对象

// 2. 绑定消息队列对象（MessageQueue）
mQueue = mLooper.mQueue;
// 获取该Looper对象中保存的消息队列对象（MessageQueue）
// 至此，保证了handler对象关联上 Looper对象中MessageQueue
}

当创建Handler对象时，则通过构造方法自动关联当前线程的Looper对象 & 对应的消息队列对象（MessageQueue），从而自动绑定了实现创建Handler对象操作的线程
总结：
在这里插入图片描述

步骤2：创建消息对象

具体使用

Message msg = Message.obtain(); // 实例化消息对象
msg.what = 1; // 消息标识
msg.obj = “AA”; // 消息内容存放

源码分析

/**

源码分析：Message.obtain()
作用：创建消息对象
注：创建Message对象可用关键字new 或 Message.obtain()，建议使用obtain()创建消息对象，避免每次都使用new重新分配内存。（当池内无消息对象可复用，则用关键词new创建）
*/
public static Message obtain() {

// Message内部维护了1个Message池，用于Message消息对象的复用
// 使用obtain（）则是直接从池内获取
synchronized (sPoolSync) {
if (sPool != null) {
Message m = sPool;
sPool = m.next;
m.next = null;
m.flags = 0; // clear in-use flag
sPoolSize–;
return m;
}
// 建议：使用obtain（）”创建“消息对象，避免每次都使用new重新分配内存
}
// 若池内无消息对象可复用，则还是用关键字new创建
return new Message();

}

步骤3：在工作线程中发送消息到消息队列

具体使用

mHandler.sendMessage(msg);

源码分析

/**

源码分析：mHandler.sendMessage(msg)
定义：属于处理器类（Handler）的方法
作用：将消息发送到消息队列中（Message ->> MessageQueue）
*/
public final boolean sendMessage(Message msg)
{
return sendMessageDelayed(msg, 0);
// ->>分析1
}

/**

分析1：sendMessageDelayed(msg, 0)
**/
public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis < 0) {
delayMillis = 0;
}

return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
// ->> 分析2
}

/**

分析2：sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis)
**/
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
// 1. 获取对应的消息队列对象（MessageQueue）
MessageQueue queue = mQueue;

// 2. 调用了enqueueMessage方法 ->>分析3
return enqueueMessage(queue, msg, uptimeMillis);
}

/**

分析3：enqueueMessage(queue, msg, uptimeMillis)
**/
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
// 1. 将msg.target赋值为this
// 即：把当前的Handler实例对象作为msg的target属性
msg.target = this;
// 请回忆起上面说的Looper的loop()中消息循环时，会从消息队列中取出每个消息msg，然后执行msg.target.dispatchMessage(msg)去处理消息
// 实际上则是将该消息派发给对应的Handler实例

// 2. 调用消息队列的enqueueMessage（）
// 即：Handler发送的消息，最终是保存到消息队列->>分析4
return queue.enqueueMessage(msg, uptimeMillis）;
}

/**

分析4：queue.enqueueMessage(msg, uptimeMillis）
定义：属于消息队列类（MessageQueue）的方法
作用：入队，即将消息根据时间放入到消息队列中（Message ->> MessageQueue）
采用单链表实现：提高插入消息、删除消息的效率
*/
boolean enqueueMessage(Message msg, long when) {

…// 仅贴出关键代码

synchronized (this) {

msg.markInUse();
msg.when = when;
Message p = mMessages;
boolean needWake;

// 判断消息队列里有无消息
// a. 若无，则将当前插入的消息作为队头 & 若此时消息队列处于等待状态，则唤醒
if (p == null || when == 0 || when < p.when) {
msg.next = p;
mMessages = msg;
needWake = mBlocked;
} else {
needWake = mBlocked && p.target == null && msg.isAsynchronous();
Message prev;

// b. 判断消息队列里有消息，则根据消息（Message）创建的时间插入到队列中
for (;😉 {
prev = p;
p = p.next;
if (p == null || when < p.when) {
break;
}
if (needWake && p.isAsynchronous()) {
needWake = false;
}
}

msg.next = p;
prev.next = msg;
}

if (needWake) {
nativeWake(mPtr);
}
}
return true;
}

// 之后，随着Looper对象的无限消息循环
// 不断从消息队列中取出Handler发送的消息 & 分发到对应Handler
// 最终回调Handler.handleMessage()处理消息

总结
Handler发送消息的本质 =
将消息对象的target属性设置为当前Handler实例（将Message绑定到Handler，使执行消息循环时将消息派发给对应的Handler实例）
获取对应的消息队列对象MessageQueue，调用MessageQueue.enqueueMessage()，将Handler需发送消息入队到绑定线程的消息队列中。

之后，随着Looper对象的无限消息循环，不断从消息队列中取出Handler发送的消息&根据target分发到对应Handler，最终回调Handler.handleMessage()处理消息

源码总结

在这里插入图片描述

工作流程总结

在这里插入图片描述

方式2：使用 Handler.post()

步骤1：在主线程中创建Handler实例

具体使用

private Handler mhandler = new Handler()；
// 与方式1的使用不同：此处无复写Handler.handleMessage()

源码分析

/**

源码分析：Handler的构造方法
作用：

a. 在此之前，主线程创建时隐式创建Looper对象、MessageQueue对象

b. 初始化Handler对象、绑定线程 & 进入消息循环

此处的源码分析类似方式1，此处不作过多描述
*/

步骤2：在工作线程中发送消息到消息队列中

具体使用

mHandler.post(new Runnable() {
@Override
public void run() {
//传入1个Ruunable对象，复写run()从而指定UI操作
… // 需执行的UI操作
}

});

源码分析

/**

源码分析：Handler.post（Runnable r）
定义：属于处理者类（Handler）中的方法
作用：定义UI操作、将Runnable对象封装成消息对象 & 发送到消息队列中（Message ->> MessageQueue）
注：
a. 相比sendMessage()，post（）最大的不同在于，更新的UI操作可直接在重写的run（）中定义
b. 实际上，Runnable并无创建新线程，而是发送消息到消息队列中
*/
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage®, 0);
// getPostMessage® 的源码分析->>分析1
// sendMessageDelayed（）的源码分析 ->>分析2

}
/**

分析1：getPostMessage®
作用：将传入的Runable对象封装成1个消息对象
**/
private static Message getPostMessage(Runnable r) {
// 1. 创建1个消息对象（Message）
Message m = Message.obtain();
// 注：创建Message对象可用关键字new 或 Message.obtain()
// 建议：使用Message.obtain()创建，
// 原因：因为Message内部维护了1个Message池，用于Message的复用，使用obtain（）直接从池内获取，从而避免使用new重新分配内存

// 2. 将 Runable对象赋值给消息对象（message）的callback属性
m.callback = r;

// 3. 返回该消息对象
return m;
} // 回到调用原处

/**

分析2：sendMessageDelayed(msg, 0)
作用：实际上，从此处开始，则类似方式1 = 将消息入队到消息队列，
即最终是调用MessageQueue.enqueueMessage（）
**/
public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis < 0) {
delayMillis = 0;
}

return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
// 请看分析3
}

/**

分析3：sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis)
**/
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
// 1. 获取对应的消息队列对象（MessageQueue）
MessageQueue queue = mQueue;

// 2. 调用了enqueueMessage方法 ->>分析3
return enqueueMessage(queue, msg, uptimeMillis);
}

/**

分析4：enqueueMessage(queue, msg, uptimeMillis)
**/
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
// 1. 将msg.target赋值为this
// 即：把当前的Handler实例对象作为msg的target属性
msg.target = this;
// 请回忆起上面说的Looper的loop()中消息循环时，会从消息队列中取出每个消息msg，然后执行msg.target.dispatchMessage(msg)去处理消息
// 实际上则是将该消息派发给对应的Handler实例

// 2. 调用消息队列的enqueueMessage（）
// 即：Handler发送的消息，最终是保存到消息队列
return queue.enqueueMessage(msg, uptimeMillis）;
}

// 注：实际上从分析2开始，源码与 sendMessage（Message msg）发送方式相同
消息对象的创建 = 内部根据Runnable对象而封装
发送到消息队列的逻辑 = 方式1中sendMessage（Message msg）

源码总结

在这里插入图片描述

工作流程总结

在这里插入图片描述

Handler.sendMessage与Handler.post比较

工作流程类似，区别在于
1、Handler.post不需外部创建消息对象，而是内部根据传入的Runnable对象封装消息对象
2、回调的消息处理方法是：复写Runnable对象的run()

（六）内存泄露

6.1）问题描述

Handler的一般用法 = 新建Handler子类（内部类）、匿名Handler内部类

/**

方式1：新建Handler子类（内部类）
*/
public class MainActivity extends AppCompatActivity {

public static final String TAG = “carson：”;
private Handler showhandler;

// 主线程创建时便自动创建Looper & 对应的MessageQueue
// 之后执行Loop()进入消息循环
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

//1. 实例化自定义的Handler类对象->>分析1
//注：此处并无指定Looper，故自动绑定当前线程(主线程)的Looper、MessageQueue
showhandler = new FHandler();

// 2. 启动子线程1
new Thread() {
@Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// a. 定义要发送的消息
Message msg = Message.obtain();
msg.what = 1;// 消息标识
msg.obj = “AA”;// 消息存放
// b. 传入主线程的Handler & 向其MessageQueue发送消息
showhandler.sendMessage(msg);
}
}.start();

// 3. 启动子线程2
new Thread() {
@Override
public void run() {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// a. 定义要发送的消息
Message msg = Message.obtain();
msg.what = 2;// 消息标识
msg.obj = “BB”;// 消息存放
// b. 传入主线程的Handler & 向其MessageQueue发送消息
showhandler.sendMessage(msg);
}
}.start();

}

// 分析1：自定义Handler子类
class FHandler extends Handler {

// 通过复写handlerMessage() 从而确定更新UI的操作
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case 1:
Log.d(TAG, “收到线程1的消息”);
break;
case 2:
Log.d(TAG, " 收到线程2的消息");
break;

}
}
}
}

/**

方式2：匿名Handler内部类
*/
public class MainActivity extends AppCompatActivity {

public static final String TAG = “carson：”;
private Handler showhandler;

//1. 通过匿名内部类实例化的Handler类对象
//注：此处并无指定Looper，故自动绑定当前线程(主线程)的Looper、MessageQueue
showhandler = new Handler(){
// 通过复写handlerMessage()从而确定更新UI的操作
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case 1:
Log.d(TAG, “收到线程1的消息”);
break;
case 2:
Log.d(TAG, " 收到线程2的消息");
break;
}
}
};

}

严重警告:This Handler class should be static or leaks might occur(null)
警告原因=该Handler类由于没有设置为静态类，可能会导致内存泄露。

6.2）原因讲解

1、储备知识

主线程的Looper对象的生命周期 = 该应用程序的生命周期
在Java中，非静态内部类 & 匿名内部类都默认持有外部类的引用

2、泄露原因描述

/**

方式1：新建Handler子类（内部类）
*/
public class MainActivity extends AppCompatActivity {

public static final String TAG = “carson：”;
private Handler showhandler;

//1. 实例化自定义的Handler类对象->>分析1
//注：此处并无指定Looper，故自动绑定当前线程(主线程)的Looper、MessageQueue
showhandler = new FHandler();

}

// 分析1：自定义Handler子类
class FHandler extends Handler {

}
}
}
}

/**

方式2：匿名Handler内部类
*/
public class MainActivity extends AppCompatActivity {

public static final String TAG = “carson：”;
private Handler showhandler;

}
}

从上述示例代码可知：
上述的Handler实例的消息队列有2个分别来自线程1、2的消息（分别为延迟1s、6s）
在Handler消息队列还有未处理的消息 / 正在处理消息时，消息队列中的Message持有Handler实例的引用
由于Handler = 非静态内部类 / 匿名内部类（2种使用方式），故又默认持有外部类的引用（即MainActivity实例），引用关系如下图
在这里插入图片描述

上述的引用关系会一直保持，直到Handler消息队列中的所有消息被处理完毕
在Handler消息队列还有未处理的消息 / 正在处理消息时，此时若需销毁外部类MainActivity，但由于上述引用关系，垃圾回收器（GC）无法回收MainActivity，从而造成内存泄漏。如下图：
在这里插入图片描述

3、总结

（1）当Handler消息队列还有未处理的消息 / 正在处理消息时，存在引用关系： “未被处理 / 正处理的消息 -> Handler实例 -> 外部类”
（2）若出现 Handler的生命周期 > 外部类的生命周期时（即 Handler消息队列还有未处理的消息 / 正在处理消息而外部类需销毁时），将使得外部类无法被垃圾回收器（GC）回收，从而造成内存泄露

6.3）解决方案

从上面可看出，造成内存泄露的原因有2个关键条件：
1、存在“未被处理 / 正处理的消息 -> Handler实例 -> 外部类” 的引用关系
2、Handler的生命周期 > 外部类的生命周期

解决方案1：静态内部类+弱引用（推荐：保证消息队列中所有消息都能执行）

（1）原理
1、将Handler的子类设置成静态内部类：默认不持有外部类的引用，从而使得 “未被处理 / 正处理的消息 -> Handler实例 -> 外部类” 的引用关系的引用关系不复存在。
2、使用WeakReference弱引用持有Activity实例：弱引用的对象拥有短暂的生命周期。在垃圾回收器线程扫描时，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存
（2）解决代码

public class MainActivity extends AppCompatActivity {

public static final String TAG = “carson：”;
private Handler showhandler;

//1. 实例化自定义的Handler类对象->>分析1
//注：
// a. 此处并无指定Looper，故自动绑定当前线程(主线程)的Looper、MessageQueue；
// b. 定义时需传入持有的Activity实例（弱引用）
showhandler = new FHandler(this);

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此我收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点！不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
Thread() {
@Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// a. 定义要发送的消息
Message msg = Message.obtain();