Handler “虐我千百遍，待她如初恋”

/**

• @hide

*/

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());

}

}

//创建Looper

mLooper = Looper.myLooper();

if (mLooper == null) {

throw new RuntimeException(

"Can’t create handler inside thread " + Thread.currentThread()

• " that has not called Looper.prepare()");

}

mQueue = mLooper.mQueue;

mCallback = callback;

mAsynchronous = async;

}

从上面的源码中我们看到需要一个Looper，那么可能你会问，为什么在Activity中可以直接new Handler呢？我也没有添加Looper啊？

创建Looper

创建Looper的方法就是调用了Looper.prepare()方法

不知道你有没有注意过ActivityThread.java这个类，在这个类中的main方法有这样的代码

public static void main(String[] args){

// …省略其他代码

Looper.prepareMainLooper();

ActivtyThread thread=new ActivityThread();

thread.attach(false);

//…

Looper.looper();

}

public static void prepareMainLooper(){

prepare(false); //消息队列不可以退出

synchronized(Looper.class){

if(sMianLooper!=null){

//…

}

sMainLooper=myLooper();

}

}

public static void prepare(){

prepare(true);//消息队列可以quit

}

Looper和Thread进行关联

private static void prepare(boolean quitAllowed) {

if (sThreadLocal.get() != null) { //不为空就表示当前线程已经创建了Looper

//异常提示每一个线程只能创建一个Looper

throw new RuntimeException(“Only one Looper may be created per thread”);

}

// //创建Looper并设置给sThreadLocal,确保调用get()方法的时候不为空

sThreadLocal.set(new Looper(quitAllowed));

}

perpare()有两个重载的方法，主要是看prepare(boolean quitAllowed)方法，quitAllowed用于在创建MessageQueue时标识消息队列是否可以销毁，主线程不可以被销毁

看到这里，你应该知道子线程中使用Handler的正确姿势了吧！

1. 创建一个Looper,调用Looper.prepare()方法

2. 我们可以创建一个HandlerThead,即创建一个包含Looper的对象

MessageQueue和Looper的绑定

private Looper(boolean quitAllowed){

// 创建了MessageQueue

mQueue= new MessageQueue(quitAllowed);

// 绑定当前的线程

mThread =Thread.currentThread();

}

MessageQueue的构造方法

MessageQueue(boolean quitAllowed){

//quitAllowed用于在创建MessageQueue时标识消息队列是否可以销毁，主线程不可以被销毁(false)

mQuitAllowed=quitAllowed();

mPtr=nativeInit();

}

Looper.loop()

代码就不上了，简单总结下

1.调用sThreadLocal.get()获取获取刚创建的Looper对象

2.判断Looper是否存在，如果为空就抛出异常

3.创建一个for的死循环，从消息队列不断的取消息

4.判断是否有消息，由于刚创建MessageQueue就已经开始轮询了，队列中是没有消息的，所以需要等到Handler sendMessage- euqueueMessage后才有消息

5.获取到消息后通过msg.target绑定的Handler进行消息的分发

创建Handler

创建Handler的操作可以查看上文

创建Message

可以直接使用new Message的方式创建

通常使用Message.obtain，因为obtain可以检查是否有复用的Message，可以通过复用避免过多的创建、销毁Message对象达到优化内存和性能的目的

public static Message obtain(Handler h){

//调用重载的obtain方法

Message m=obtain();

m.target =h;

return m;

}

public static Message obtain(){

synchronized(sPoolSync){//sPoolSync是一个Object对象，用来保证线程安全

if(sPool!=null){//sPool就是Handler dispatchMessage后通过recycleUnchecked回收以复用的Message

Message m= sPool;

sPool= m.next;

m.flags=0; //清除使用标记

sPoolSize–;

return m;

}

}

return new Message();

}

Message和Handler的绑定

创建Message的时候已经通过Message.obtain(Handler h)这个构造方法进行了绑定，在Handler中的enqueueMessage()方法中也绑定了，所有发送Message的方法都会调用此方法入队，所以在创建Message的时候是可以不进行绑定的

private boolean enqueueMessage(MessageQueue queue,Message msg,long uptimeMillis){

msg.target=this;//进行绑定

if(mAsynchronous){

msg.setAsynchronous(true);

}

return queue.enqueuMessage(msg,uptimeMillis);

}

Handler消息(发送/处理)

Handler发送消息的重载方法有很多

sendMessage(Message msg)

sendMessageDelayed(Message msg, long uptimeMillis)

post(Runnable r)

postDelayed(Runnable r, long uptimeMillis)

sendMessageAtTime(Message msg,long when)

sendEmptyMessage(int what)

sendEmptyMessageDelayed(int what, long uptimeMillis)

sendEmptyMessageAtTime(int what, long when)

主要是sendMessage(Message)，调用了sendMessageDelayed继续调用sendMessageAtTime,调用enqueueMessage再继续调用到MessageQueue中的enqueueMessage，将消息保存在了消息队列中，最终由Looper取出，交给Handler的dispatchMessage进行处理

public void dispatchMessage(Message msg){

if(msg.callback!=null){ //callback在message的构造方法中初始化或者使用 handler.post（Runnable）时候才不为空

handlercallback(msg);

}else{

if(mCallback!=null){ //mCallback是一个Callback对象,通过无参的构造方法创建出来的Handler，该属性为null时不会进入到此判断

if(mCallback.handleMessage(msg)){

return ;

}

}

handleMessage(msg);

}

}

private static void handleMessage(Message msg){

msg.callback.run();

}

从dispatchMessage方法，我们知道message中callback是一个Runnable对象，如果callback不为空，则直接调用callback的run方法，否则判断mCallback是否为空，mCallback在Handler构造方法中初始化，在主线程中直接通过无参的构造方法new出来的为null,所以会执行后面的handlemessage方法

在handlemessage中可以拿到Message对象，根据不同的需求进行处理，到此Handler算是结束了

Handler小结

handler.sendMessage发送消息到消息队列MessageQueue，然后Looper通过loop()函数轮询MessageQueue中的Message，当Message到了可执行的时候开始执行，执行后就会调用message绑定的Handler进行处理

再探Handler

从设计思想看Handler

子线程发送消息，主线程处理消息，构成了线程模型中的经典问题: 生产者-消费者模式（内存共享）

生产者-消费者模式：主要让生产者和消费在同一时间段内共用同一个存储空间，生产者往存储空间中添加数据，消费者从存储空间中取出数据

这样做的好处是什么？

可以保证数据生产消费的顺序(MessageQueue先进先出)不管是生产者（子线程）还是消费者（主线程）都只依赖缓冲区(Handler),不会相互持有，没有任何耦合

MessageQueue

简单的说：

MessageQueue是一个消息队列，Handler将Message发送到消息队列中，消息队列会按照一定的规则取出要执行的Message

• 成员变量

// True if the message queue can be quit.

//用于标示消息队列是否可以被关闭，主线程的消息队列不可关闭

private final boolean mQuitAllowed;

@SuppressWarnings(“unused”)

// 该变量用于保存native代码中的MessageQueue的指针

private long mPtr; // used by native code

//在MessageQueue中，所有的Message是以链表的形式组织在一起的，该变量保存了链表的第一个元素，也可以说它就是链表的本身

Message mMessages;

//当Handler线程处于空闲状态的时候(MessageQueue没有其他Message时)，可以利用它来处理一些事物，该变量就是用于保存这些空闲时候要处理的事务

private final ArrayList mIdleHandlers = new ArrayList();

// 注册FileDescriptor以及感兴趣的Events，例如文件输入、输出和错误，设置回调函数，最后

// 调用nativeSetFileDescriptorEvent注册到C++层中，

// 当产生相应事件时，由C++层调用Java的DispathEvents，激活相应的回调函数

private SparseArray mFileDescriptorRecords;

// 用于保存将要被执行的IdleHandler

private IdleHandler[] mPendingIdleHandlers;

//标示MessageQueue是否正在关闭。

private boolean mQuitting;

// Indicates whether next() is blocked waiting in pollOnce() with a non-zero timeout.

// 标示 MessageQueue是否阻塞

private boolean mBlocked;

// The next barrier token.

// Barriers are indicated by messages with a null target whose arg1 field carries the token.

// 在MessageQueue里面有一个概念叫做障栅，它用于拦截同步的Message，阻止这些消息被执行，

// 只有异步Message才会放行。障栅本身也是一个Message，只是它的target为null并且arg1用于区分不同的障栅，

// 所以该变量就是用于不断累加生成不同的障栅。

private int mNextBarrierToken;

• 数据是有序的吗？

你这不是废话吗？肯定有序啊，来来来，看源码

boolean enqueueMessage(Message msg, long when) {

// …

synchronized (this) {

// …

msg.markInUse();

msg.when = when;

Message p = mMessages;

boolean needWake;

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;

for (;😉 {

prev = p;

p = p.next;

// 一致循环，直到找到尾巴(p == null)

// 或者这个 message 的 when 小于我们当前这个 message 的 when

if (p == null || when < p.when) {

break;

}

if (needWake && p.isAsynchronous()) {

needWake = false;

}

}

msg.next = p; // invariant: p == prev.next

prev.next = msg;

}

}

return true;

}

Queue 都是有序的，Set 才是无序的，它的排序的依据是通过when字段，表示一个相对时间，该值是由 MessageQueue#enqueueMessage(Message, Long) 方法设置的

• when是怎么来的？

Message#when 是一个时间，用于表示 Message 期望被分发的时间，该值是 SystemClock#uptimeMillis() 与 delayMillis 之和

public final boolean sendMessageDelayed(Message msg, long delayMillis)

{

if (delayMillis < 0) {

delayMillis = 0;

}

return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);

}

既然是时间，为什么不直接用System.currentTimeMillis() ???

return sendMessageAtTime(msg, System.currentTimeMillis()+ delayMillis);

为什么不用呢？首先我们先了解下这两者的区别

SystemClock.uptimeMillis() 是一个表示当前时间的一个相对时间，它代表的是 自系统启动开始从0开始的到调用该方法时相差的毫秒数

System.currentTimeMillis() 代表的是从 1970-01-01 00:00:00 到当前时间的毫秒数,我们可以通过修改系统时间达到修改该值的目的，所以该值是不可靠的值

看完解释，一目了然了吧！

在上面的成员变量中，看到了IdleHandler这个东东，虽然用的少，但也简单的了解下吧

IdleHandler

IdleHandler在处理业务逻辑方面和Handler一样，不过它只会在线程空闲的时候才执行业务逻辑的处理，这些业务经常是哪些不是很紧要或者不可预期的，比如GC

从源码上来看，我们发现这货就是一个接口而已,内部就一个带返回值的方法boolean queueIdle()，在使用的时候只需要实现该接口并加入到MessageQueue中就可以了

public static interface IdleHandler {

boolean queueIdle();

}

• 使用

MessageQueue messageQueue = Looper.myQueue();

messageQueue.addIdleHandler(new MessageQueue.IdleHandler() {

@Override

public boolean queueIdle() {

// do something.

return false;

}

});

public void addIdleHandler(@NonNull IdleHandler handler) {

//非空判断

if (handler == null) {

throw new NullPointerException(“Can’t add a null IdleHandler”);

}

//加一个同步锁

synchronized (this) {

//调用mIdleHandlers.add(handler)添加

mIdleHandlers.add(handler);

}

}

/**

*从消息队列中移除一个之前添加的IdleHandler。如果该IdleHandler不存在，则什么也不做

*/

public void removeIdleHandler(@NonNull IdleHandler handler) {

synchronized (this) {

mIdleHandlers.remove(handler);

}

}

ThreadLocal（核心成员）

我们知道Handler利用了内存共享的原理，那么ThreadLocal就是最大的功臣

ThreadLocal设计的初衷是提供线程内部的局部变量，在本地线程内随时随地可取，隔离其他线程

• 类图

• 结构图

• set操作

public void set(T value) {

//先拿到保存键值对的ThreadLocalMap对象实例map

Thread t = Thread.currentThread();

ThreadLocalMap map = getMap(t);

//

if (map != null)

map.set(this, value);

else

//如果map为空(即第一次调用的时候map值为null),去创建一个ThreadLocalMap对象并赋值给map，并把键值对保存在map

createMap(t, value);

}

getMap实现非常直接，就是直接返回Thread对象的threadLocal字段

ThreadLocalMap getMap(Thread t) {

return t.threadLocals;

}

//Thread.java

ThreadLocal.ThreadLocalMap threadLocals = null;

void createMap(Thread t, T firstValue) {

t.threadLocals = new ThreadLocalMap(this, firstValue);

}

简单的说每个线程引用的ThreadLocal副本值都是保存在当前Thread对象里面的。存储结构为ThreadLocalMap类型，ThreadLocalMap保存的类型为ThreadLocal，值为副本值

• get操作

public T get() {

Thread t = Thread.currentThread();

ThreadLocalMap map = getMap(t);

if (map != null) {

ThreadLocalMap.Entry e = map.getEntry(this);

if (e != null)

return (T)e.value;

}

return setInitialValue();

}

private T setInitialValue() {

T value = initialValue();

Thread t = Thread.currentThread();

ThreadLocalMap map = getMap(t);

if (map != null)

map.set(this, value);

else

createMap(t, value);

return value;

}

和set方法原理一样，拿到当前线程Thread对象实例中保存的ThreadLocalMap对象map，然后从map中读取键为this(即ThreadLocal类实例)对应的值

从上面的图中我们发现 ThreadLocal内部有一个ThreadLocalMap对象，该Map对象里面维护了一个弱引用的Entry实体类

• ThreadLocalMap(内部类)

从源码中的文档上我们得知：

ThreadLocalMap是一个适用于维护线程本地值的自定义哈希映射(hash map)，没有任何操作可以让它超出ThreadLocal这个类的范围。该类是私有的，允许在Thread类中声明字段。为了更好的帮助处理常使用的，hash表条目使用了WeakReferences的键。但是，由于不实用引用队列，所以，只有在表空间不足的情况下，才会保留已经删除的条目

• 存储结构

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

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

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

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）

实战系列

话不多说，Android实战系列集合都已经系统分类好，由于文章篇幅问题没法过多展示

《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》，点击传送门即可获取！

但是，由于不实用引用队列，所以，只有在表空间不足的情况下，才会保留已经删除的条目

• 存储结构

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

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

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

[外链图片转存中…(img-frGmZiEh-1711859734157)]

[外链图片转存中…(img-YuTDmxda-1711859734157)]

[外链图片转存中…(img-8WTvjiL1-1711859734157)]

[外链图片转存中…(img-NQhPIDsG-1711859734158)]

[外链图片转存中…(img-uystkI5P-1711859734158)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）

实战系列

话不多说，Android实战系列集合都已经系统分类好，由于文章篇幅问题没法过多展示

[外链图片转存中…(img-EyKmlrrM-1711859734158)]
[外链图片转存中…(img-HOWsaLpN-1711859734158)]

《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》，点击传送门即可获取！