欢迎转载，转载请注明出处：https://blog.csdn.net/dmk877/article/details/141690289
在阅读本篇博客之前建议先阅读此篇 Android Handler消息机制完全解析(一)
在看Looper源码之前必须要理解ThreadLocal，ThreadLocal在Handler消息机制中起到了至关重要的作用，面试中也经常会被问到，所以我们先来了解下ThreadLocal，通过本篇博客你将学到
①ThreadLocal的作用以及原理
②Looper方法的源码
③Handler的dispatchMessage消息分发流程
④几个常见的面试题
1.ThreadLocal的作用
ThreadLocal主要有以下作用
(1)线程隔离:每个线程都可以独立的改变自己的副本，而不会影响其它线程的副本
(2)减少同步:由于每个线程操作的是属于自己的数据副本，因此可以避免使用同步机制(synchronized或Lock)来保护共享数据，从而提高性能
(3)简化编程：在某些情况下，使用 ThreadLocal 可以使代码更加简洁，因为它允许开发者以单线程的方式来编写多线程代码。
看到这你可能有点懵，看段代码你就会理解
static ThreadLocal<String> localVar = new ThreadLocal<String>();
public static void main(String[] args) {
localVar.set("main");
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("thread1 localVar:" + localVar.get());
localVar.set("thread1");
System.out.println("thread1 localVar: " + localVar.get());
}
});
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("thread2 localVar:" + localVar.get());
localVar.set("thread2");
System.out.println("thread2 localVar: " + localVar.get());
}
});
thread1.start();
thread2.start();
System.out.println(localVar.get());
}
输出
main
thread1 localVar:null
thread2 localVar:null
thread1 localVar: thread1
thread2 localVar: thread2
上述代码中在主线程中声明了一个ThreadLocal变量，然后分别在主线程和两个子线程中set值并取出进行打印，你会发现ThreadLocal变量在主线程中设置值后在子线程thread1和thread1中get获取时是null,main、thread1、thread2对localVar 的操作互不影响，对，这就是线程隔离，实现的原理就是每个线程中都会保存一个ThreadLocal的副本，每次在子线程中修改只是修改了当前线程对应的ThreadLocal对象，对其它线程没有影响。那么问题来了，它是怎么做到的呢？
2.ThreadLocal源码解析
在详细查看源码前，先来看下实现原理图，大概了解之后再看源码事半功倍
从图中可以看到每一个Thread都会持有一个ThreadLocalMap对象，这个ThreadLocalMap内部持有一个Entry类型的数组，Entry类型有key和value键值对其中key就是ThreadLocal对象，value就是每个线程需要隔离的变量。这样就实现了数据与线程的隔离，每个线程有自己独立的数据。另外需要说明的是一个ThreadLocal实例，在一个线程中只能存储一类数据，线程中的ThreadLocalMap是一个数组结构它可以存储多个ThreadLocal对象。有点懵？没关系，接下来我们看源码，源码结合上图相信你能很好的理解其中的奥妙。
首先从ThreadLocal的set方法开始
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
public class Thread implements Runnable {
......
/* ThreadLocal values pertaining to this thread. This map is maintained
* by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;
......
}
在ThreadLocal的set方法中首先获取当前的线程对象t，然后以t为参数调用getMap方法，getMap返回的其实就是当前线程对应的threadLocals，它是声明在Thread类中的ThreadLocal.ThreadLocalMap对象，ThreadLocalMap是ThreadLocal的静态内部类
static class ThreadLocalMap {
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
private static final int INITIAL_CAPACITY = 16;
private Entry[] table;
private void set(ThreadLocal<?> key, Object value) {
......
tab[i] = new Entry(key, value);
......
}
}
可以看到ThreadLocalMap中有一个Entry类型的数组，ThreadLocalMap的set方法的参数key就是ThreadLocal类型的参数，value就是我们要保存的数据
如下图所示
这就是set的大致流程，还是比较清晰的。接下来看看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) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();
}
同样也是先获取当前所在线程t，然后以t为参数调用getMap方法获取与当前线程对应的ThreadLocalMap对象，然后调用map.getEntry(this)在set的时候说过，ThreadLocalMap.Entry中key是ThreadLocalMap对象，value就是我们要保存的值，这里也是将this传入然后拿到当前ThreadLocal对象中保存的值然后返回。到这里大家应该能很清楚的知道ThreadLocal是怎么实现线程隔离的了。其实就是每个线程独有一个ThreadLocalMap对象，当我们set值时会先获取当前的线程，然后得到当前线程的ThreadLocalMap对象，然后将我们要保存的数据存放到ThreadLocalMap中的Entry数组中，get值也是先获取ThreadLocalMap对象，然后根据key(当前的ThreadLocal对象)获取到我们保存的数据。
ok，了解ThreadLocal对Looper的源码会有很大的帮助，接下来我们就来分析下Handler机制中的Looper
3.Looper源码分析
Looper是Handler的核心组成部分之一，它是一个消息循环器，负责管理消息队列，每个线程都可以创建自己的Looper主线程默认就会创建一个Looper，Looper通过Looper.prepare()进行初始化，然后调用Looper.loop()开启消息循环，接下来我们看下Looper的核心代码
public final class Looper {
......
// 保存当前线程的Looper对象,注意这个ThreadLocal对象保存是一个Looper对象，每个线程的Looper是独立的
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal();
// 主线程Looper
private static Looper sMainLooper;
// 当前线程的MessageQueue对象
final MessageQueue mQueue;
// 创建Looper的线程
final Thread mThread;
......
public static Looper myLooper() {
// 返回当前线程的looper
return (Looper)sThreadLocal.get();
}
public static void prepare() {
prepare(true);
}
private static void prepare(boolean quitAllowed) {
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
} else {
sThreadLocal.set(new Looper(quitAllowed));
}
}
......
}
- myLooper方法
首先看myLooper方法其实就是获取当前线程的looper对象，它是保存在ThreadLocal对象中的从刚才对ThreadLocal的讲解这一点应该很好理解。
- prepare方法
prepare方法会调用prepare(boolean)方法，在prepare(quitAllowed)方法中会判断looper是否为空，如果不为空则会抛异常Only one Looper may be created per thread，这也是面试中经常被问到的，这也就是说一个线程只能创建一个Looper对象，否则会抛异常。
再看下Looper的构造方法
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
因为在Looper的prepare方法中会往ThreadLocal对象中set Looper对象即调用sThreadLocal.set(new Looper(quitAllowed))，而MessageQueue又是在Looper的构造函数中创建的因此一个线程只有一个Looper对象，同时也只有一个MessageQueue对象。
还有一个重要方法loop
public static void loop() {
final Looper me = myLooper();
......
final MessageQueue queue = me.mQueue;
for (;;) {
// 不停的从MessageQueue中取消息，当没消息时可能会阻塞
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
msg.target.dispatchMessage(msg);
// 将消息进行回收放到消息池中，以便后续使用
msg.recycleUnchecked();
}
}
为了更好的阅读我删除很多代码，只留下了最核心的代码，从loop的源码中可以看到调用loop方法后会开启一个死循环，这就相当于我们给传送带通电，此时它就获得了动力，在这个死循环里会不停的调用MessageQueue的next方法向MessageQueue中取消息，取到消息之后就会调用msg.target.dispatchMessage方法
4. Handler dispatchMessage消息分发流程
在上一篇中我们说到在MessageQueue的enqueueMessage方法中会将当前的handler赋值给msg.target因此这里的msg.target就是Handler对象，那我们来看下源码就看下Handler的dispatchMessage方法的源码
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (this.mCallback != null && this.mCallback.handleMessage(msg)) {
return;
}
this.handleMessage(msg);
}
}
private static void handleCallback(Message message) {
message.callback.run();
}
考点来了，在上一篇文章的开头，我列举了几个大厂的面试题其中就有
Handler的callback存在但返回true,handleMessage是否会执行？看到这个问题是不是有点懵？没关系带着这个问题分析完dispatchMessage这个方法之后你就会非常清晰，这里面有两个callback一个是msg.callback一个是this.mCallback我们一个一个来看首先来看
- msg.callbak
这个callback是从哪里来的呢？在上一篇文章中也提到Handler发送消息有两种方法一种是调用handler.send，一种是调用handler.post，再看下Handler的post方法的源码如下
public final boolean post(Runnable r) {
return this.sendMessageDelayed(getPostMessage(r), 0L);
}
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
可以看到在调用Handler的post方法时它传递的参数是一个Runnable对象，并且将这个Runnable对象转化为Messgage对象后调用send方法发出去，在转化的过程中有一个赋值m.callback=r即将当前的Runnable对象赋值个Message的callback，这就是msg.callback，也就是说只有调用handler.post方法时msg.callback才不为空。
- this.mCallback
this.mCallback很明显是Handler的变量，它是怎么来的呢？它是通过new Handler时传递过来的，如下所示
public Handler(Looper looper, Handler.Callback callback, boolean async) {
this.mLooper = looper;
this.mQueue = looper.mQueue;
this.mCallback = callback;
this.mAsynchronous = async;
}
public interface Callback {
boolean handleMessage(Message var1);
}
注意区分Handler.callback.handleMessage和this.handleMessage
- this.handleMessage(msg)
这个就是我们重写的Handler的handleMessage方法
理清楚这些，再来个实例你肯定就会非常清楚,看个实例代码
mHandler = new Handler(getMainLooper(), new Handler.Callback() {
@Override
public boolean handleMessage(@NonNull Message msg) {
Log.d(TAG, "Handler.Callback handleMessage is called");
return true;
}
}) {
@Override
public void handleMessage(@NonNull Message msg) {
Log.d(TAG, "Handler handleMessage is called");
super.handleMessage(msg);
}
};
handlerPost.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
mHandler.post(new Runnable() {
@Override
public void run() {
Log.d(TAG, "handler post onClick,send post msg");
}
});
}
});
handlerSend.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Log.d(TAG, "handler send onClick,send msg");
Message msg = Message.obtain();
mHandler.sendMessage(msg);
}
});
可以看到在new Handler的时候传递了Handler.callback参数并且返回true，并且重写了Handler的handleMessage方法然后定义了两个按钮一个用来调用Handler的post方法，一个用来调用Handler的send方法,点击handlerPost打印结果
MainActivity: handler post onClick,send post msg
分析：根据Handler的dispatchMessage如果msg.callack!=null则直接调用handleCallback(msg)方法，handleCallback方法其实就是调用msg.callback.run()，此时就会执行hander.post(runnable)中的runnable任务，因此就是只打印了handler post onClick,send post msg。
点击handlerSend打印结果
MainActivity: handler send onClick,send msg
MainActivity: Handler.Callback handleMessage is called
这个就有点说法了,再看下dispatchMessage的代码
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (this.mCallback != null && this.mCallback.handleMessage(msg)) {
return;
}
this.handleMessage(msg);
}
}
首先第一个if不满足，send方法发送的消息msg.callback==null，进入else,因为我们在new Handler的时候传递了Handler.callback回调，所以this.callback!=null成立，而我们传递的回调中Handler.callback返回true因此执行this.mCallback.handleMessage它也返回了true，两个条件成立因此直接return,this.handleMessage不会执行到，在上述代码中做下修改把Handler.callback的返回值改为false打印结果是啥呢？大家可以自己尝试下。
因此Handler的callback存在但返回true,handleMessage是否会执行？的回答是不会执行。另外此处还涉及到一个面试题
面试题：Handler的post和send方法的区别，相信到此你也能回答出来，主要从发送和分发来回答
（1）post一类的方法发送的是Runnable对象，但是最后还是会被封装成Message对象，将Runnable对象赋值给Message对象中的callback字段，然后交由sendMessageAtTime()方法发送出去。
在处理消息时，会在dispatchMessage()方法里首先被handleCallback(msg)方法执行，实际上就是执行Message对象里面的Runnable对象的run方法。
（2）sendMessage一类方法发送的消息直接是Message对象，处理消息时，在dispatchMessage里优先级会低于handleCallback(msg)方法，是通过自己重写的handleMessage(msg)方法执行。
5. 子线程中如何正确创建Handler
好，到这里Handler相关的几个对象Handler、MessageQueue、Looper就介绍的差不多了，到这里可能有些同学还是心存疑惑，到底这个Handler机制是从哪里触发的？这里涉及到App的启动流程后面有时间的话会写一篇博客，在这里你只要知道，当我们的手指点击手机上的应用图标时，系统会创建一个ActivityThread负责管理所有Activity的线程，它负责处理Activity的生命周期、事件分发、消息处理等工作，在ActivityThread的main方法源码如下
public static void main(String[] args) {
......
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false, startSeq);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
// 开启死循环，不停的取消息
Looper.loop();
}
也就是说当我们手指点击应用图标应用启动的时候，系统会执行ActivityThread的main方法而在main方法中会调用
Looper.prepareMainLooper()和Looper.loop()
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
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的ThreadLocal对象并调用loop方法开启循环从MessageQueue中取消息，这样整个流程就通了，因为loop是一个死循环，所以当我们使用handler发送一条消息时，在loop方法中会把此消息取出，并调用Handler的dispatchMessage方法将此消息分发出去，执行对应的方法。注意这只针对主线程，在子线程中我们要手动调用Looper.prepare和Looper.loop，如下所示先把Looper.prepare注释掉运行看下下效果
new Thread(new Runnable() {
@Override
public void run() {
// Looper.prepare();
mHandler = new Handler(){
@Override
public void handleMessage(@NonNull Message msg) {
super.handleMessage(msg);
Log.d(TAG, "mHandler handleMessage is called:" + Thread.currentThread().getName());
}
};
mHandler.sendMessage(Message.obtain());
Looper.loop();
}
}).start();
这个报错是不是很常见，很多人都知道调用下Looper.prepare就行了，为什么会报这个错呢？这是因为new Handler的时候会判断当前Handler所在的线程的Looper是否为空？如果为空就抛异常，所以在子线程中不调用Looper.prepare()直接new Handler就会抛异常，源码如下
public Handler(@Nullable Callback callback, boolean async) {
......
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;
}
看到没异常就是从这里抛出来的。
这篇就写到这里了，总结下：
(1) Handler是怎么进行线程间通讯的，原理是什么？
Handler之所以能够进行线程间通讯原理就是，线程间内存共享，在Handler机制中共享的就是MessageQueue，首先new Handler的这个线程中的Looper(ThreadLocal使得Looper被当前线程独有)、MessageQueue是与当前线程绑定的，其它的线程拿到这个Handler的引用发送消息时，会将此消息插入到这个MessageQueue中，从而就实现了两个不同线程间的通讯。就是说现在有两个线程A和B，在B中创建了Handler，此时Looper、MessageQueue都在线程B中，在线程A中拿到Handler的引用发送消息时这条消息就会被插入到线程B的MessageQueue中，这样就完成了从线程A到线程B的通讯。这一块建议大家好好理一下。
public Handler handler;
Thread A = new Thread(new Runnable() {
@Override
public void run() {
// handler在线程B中初始化,此消息会插入到线程B中的MessageQueue中
handler.sendMessage(Message.obtain());
}
});
Thread B = new Thread(new Runnable() {
@Override
public void run() {
Looper.prepare();
handler = new Handler(){
@Override
public void handleMessage(@NonNull Message msg) {
super.handleMessage(msg);
Log.d(TAG, "receive message");
}
};
Looper.loop();
}
});
B.start();
Thread.sleep(1000);
A.start();
(2)一个线程只有一个Looper并且只有一个MessageQueue
(3)对Handler的dispatchMessge方法的流程要掌握清晰
如果本篇对你有帮助欢迎点赞留言，若发现文中的错误欢迎批评指正，大家一起进步。
