Handler
Android只能在UI线程(主线程)更新UI显示,一般情况在子线程做耗时操作，我们平时通过Handler消息机制让线程之间进行通信。它有三个构造函数:
| 构造函数 | 描述 |
|---|---|
| Handler() | 无参构造函数 |
| Handler(CallBack mCallBack) | 带回调的构造函数 |
| Handler(Runnable runnable) | 带任务的构造函数 |
其中Handler的内部运行机制如下图所示：
Handler创建
创建Handler要区分两种情况，在子线程创建Handler和在主线程创建Handler，它们有部分区别。
子线程创建
如果直接在子线程创建Handler会导致崩溃，是因为子线程创建Handler必须先调用looper.prepare()
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.prepare()，我们看看Handler构造函数，无参的构造其实都调用带callBack的构造函数：
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;
}
可以看出在第10行调用了Looper.myLooper()，如果looper不存在则抛出异常。我们继续查看Looper.myLooper()中的代码：
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
方法非常简单，就是在ThreadLocal中拿到Looper实例，其中ThreadLocal是线程副本，保证不同线程都有一份独立的数据。其中，给sThreadLocal设置Looper的地方在于Looper.prepare()方法中：
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));
}
这里就是判断ThreadLocal中是否存在Looper，不存在则直接创建一个。这样就解决为什么创建Handler需要调用Looper.prepare()方法。而且每个线程只能存在一个Looper实例。
主线程创建
在主线程创建Handler可以直接创建，不需要调用Looper.prepare()方法：
Handler mHandler = new Handler(){
@Override
public void handleMessage(Message msg) {
}
};
主线程创建Handler不需要调用Looper.prepare()方法是因为系统已经自动调用Looper.prepare()方法，我们看下ActivityThread(程序主线程)中的main()方法：
public static void main(String[] args) {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
SamplingProfilerIntegration.start();
CloseGuard.setEnabled(false);
Environment.initForCurrentUser();
EventLogger.setReporter(new EventLoggingReporter());
final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
TrustedCertificateStore.setDefaultUserDirectory(configDir);
Process.setArgV0("<pre-initialized>");
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
// End of event ActivityThreadMain.
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
可以看到在第11行调用了Looper.prepareMainLooper()方法，该方法又调用了myPrepare()方法，我们在Looper中查看该方法的源码：
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
总结:子线程创建Handler实例必须先调用Looper.prepare()才能正常创建,而主线程中创建Handler则不需要。
消息传递
当我们创建Message后，可以通过setData、args参数以及obj参数等当时为消息携带数据或对象，再借助Handler将消息发送出去即可
new Thread(new Runnable() {
@Override
public void run() {
Message message = new Message();
message.arg1 = 1;
Bundle bundle = new Bundle();
bundle.putString("data", "data");
message.setData(bundle);
handler.sendMessage(message);
}
}).start();
Handler提供很多发送消息的方法，其中除了sendMessageAtFrontOfQueue()方法外，其他发送消息的方法最终都会调用sedMesageAtTime()方法
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);
}
它所携带的两个参数都会传递到MessageQueue的enqueueMessage(..)方法中，MessageQueue是一个先进先出的消息队列，它在Looper构造函数中创建：
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
因此一个Looper对应一个MessageQueue，那么MessageQueue中的enqueueMessage()就是入队方法。其中sendMessageAtFrontOfQueue()也调用enqueueMessage()来让消息入队，只是时间为0而已。然而出队操作是通过Looper.looper()来进行操作。
public static void loop() {
final Looper me = myLooper();
.....
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
return;
}
......
msg.recycleUnchecked();
}
}
每当有一个消息出队，就将它传递到msg.target的dispatchMessage()方法中,而msg.target就是Handler。
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
dispatchMessage会根据不同的传递消息的方式进行判断，其中msg.callback是Runnable的实例。
Android中除了Handler可以发送消息外，还有其他的方式，主要方式如下所示：
Handler中的post()方法发送消息
View中的post()方法发送消息
Activity的runOnUiThread()发送消息
View中的post()方法其实就是调用Handler的post()方法，而Activity的runOnUIThread()方法则是先判断线程如果当前线程不是主线程，就调用Handler的post()方法，否则直接调用Runnable对象的run()方法。
Handler原理
Handler是支撑整个Android系统运行的基础，本质上Android系统都是由事件驱动的。而处理事件的核心就在于Handler。
关于Handler、Looper、MessageQueue和Message的概述如下：
Handler 消息机制中作为一个对外暴露的工具，其内部包含了一个 Looper 。负责Message的发送及处理。
Looper 作为消息循环的核心，其内部包含了一个消息队列 MessageQueue，用于记录所有待处理的消息。（线程切换在这里完成）
MessageQueue 则作为一个消息队列，则包含了一系列链接在一起的Message（内部是单链表）
Message 则是消息体，内部又包含了一个目标处理器target，这个target正是最终处理它的Handler
Handler的使用
Handler的使用非常简单，一般分为在主线程创建Handler和在子线程创建Handler两种方式。
一般是在主线程中实现一个Handler，然后在子线程中使用它。
public class MainActivity extends AppCompatActivity {
private Handler handler = new MyHandler();
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
new Thread(){
@Override
public void run() {
handler.sendEmptyMessageDelayed(1, 1000);
}
};
}
// 自定义一个Handler
class MyHandler extends Handler {
@Override
public void handleMessage(@NonNull Message msg) {
Log.i("MainActivity", "主线程：handleMessage：" + msg.what);
}
}
}
或者有时候需要在子线程中创建运行在主线程中的Handler
public class MainActivity extends AppCompatActivity {
private Handler handler = null;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
new Thread(){
@Override
public void run() {
Looper.prepare();
handler = new MyHandler();
handler.sendEmptyMessageDelayed(1, 1000);
Looper.loop();
}
};
}
// 自定义一个Handler
class MyHandler extends Handler {
@Override
public void handleMessage(@NonNull Message msg) {
Log.i("MainActivity", "主线程：handleMessage：" + msg.what);
}
}
}
Handler
Handler可以用来发送消息，我们这里从sendMessage()方法开始，源码如下所示：
public final boolean sendMessage(@NonNull Message msg) {
return sendMessageDelayed(msg, 0);
}
调用了sendMessageDelayed方法：
public final boolean sendMessageDelayed(@NonNull Message msg, long delayMillis) {
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
继而调用sendMessagAtTime方法：
public boolean sendMessageAtTime(@NonNull 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);
}
在这里赋值MessageQueue并且将它作为参数传递给enqueueMessage()方法，其方法的调用顺序如下：
可以看到无论如何，最后都会走到enqueueMessage()方法中。接下来看看enqueueMessage()方法：
private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg, long uptimeMillis) {
msg.target = this;
msg.workSourceUid = ThreadLocalWorkSource.getUid();
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
enqueueMessage()方法一共做了两件事情，一个是给Message赋值，一个是调用传进来的这个MessageQueue的enqueueMessage()方法。
target表示的就是当前的Handler，也就是说每个发出去的Message都持有把它发出去的Handler的引用。
MessageQueue
Handler这个mQueue就是上文我们提到过的MessageQueue对象，它是一个单链表（一种链式存取的数据结构）。
我们在sendMessageAtTime()方法中对MessageQueue进行赋值，并且当做参数传递给Handler的enqueueMessage()方法。
public boolean sendMessageAtTime(@NonNull Message msg, long uptimeMillis) {
// 对MessageQueue进行赋值，mQueue来源于构造方法
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);
}
其实MessageQueue是在构造方法中进行赋值的，接下来我们看看构造方法的源码：
public Handler(@Nullable 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 " + Thread.currentThread()
+ " that has not called Looper.prepare()");
}
// 对MessageQueue进行赋值，来自于Looper
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
这里我们可以看到，MessageQueue的实例创建应该在Looper中，这里先不研究Looper，继续探索MessageQueue。
最后发送消息都调用的是MessageQueue的queue.enqueueMessage(msg, uptimeMillis)方法。
boolean enqueueMessage(Message msg, long when) {
if (msg.target == null) {
throw new IllegalArgumentException("Message must have a target.");
}
synchronized (this) {
if (msg.isInUse()) {
throw new IllegalStateException(msg + " This message is already in use.");
}
if (mQuitting) {
IllegalStateException e = new IllegalStateException(
msg.target + " sending message to a Handler on a dead thread");
Log.w(TAG, e.getMessage(), e);
msg.recycle();
return false;
}
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;
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;
}
主要分为三个步骤，可以参看代码标注：
mMessages 是队列的第一消息，获取到它判断消息队列是不是空的，是则将当前的消息放到队列头部。
如果当前消息不需要延时，或当前消息的执行时间比头部消息早，也是放到队列头部。
如果不是以上情况，说明当前队列不为空，并且队列的头部消息执行时间比当前消息早，需要将它插入到队列的中间位置。
我们也许会产生疑问，如何判断这个位置呢？其实依旧是通过消息被执行的时间。
通过遍历整个队列，当队列中的某个消息的执行时间比当前消息晚时，将消息插到这个消息的前面。
Looper
我们再来看看Handler的构造方法，如下所示：
public Handler(@Nullable 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()");
}
// 对MessageQueue进行赋值，来自于Looper
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
可以看到在这里通过mLooper = Looper.myLooper()代码赋值了Looper的实例，它作为消息循环的核心，不断的从MessageQueue中取出消息进行分发。
我们再来看看Lopper的myLooper()方法，源码如下：
/**
* Return the Looper object associated with the current thread. Returns
* null if the calling thread is not associated with a Looper.
*/
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
可以看到这个sThreadLocal是一个ThreadLocal类，并且它的泛型是Looper对象。
ThreadLocal提供了线程的局部变量，每个线程都可以通过set()和get()来对这个局部变量进行操作，但不会和其他线程的局部变量进行冲突，实现了线程的数据隔离。
我们看到源码中有个注释：除非您已调用prepare()，否则sThreadLocal.get()将返回null。接下来看看prepare()方法：
public static void prepare() {
prepare(true);
}
private static void prepare(boolean quitAllowed) {
// 如果sThreadLocal有值，就抛异常，没有值才会塞进去一个值。
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper(quitAllowed));
}
prepare方法必须调用但也只能调用一次，不调用没有值，抛异常，调用多次也还抛异常。
在构造Handler之前，必须调用Looper的prepare()方法创建Looper。
接下来看看sThreadLocal.set(new Looper(quitAllowed))方法的源码：
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
set方法首先获取到了当前的线程，然后获取一个map。这个map是以键值对形式存储内容的。
如果不为空就塞进去值，如果获取的map为空，就创建一个map。这里面的key是当前的线程，这里面的value就是Looper。（线程绑定）
接下来我们去看看Lopper的构造方法，源码如下所示：
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
可以看到在Looper的构造方法中创建了MessageQueue对象。
由于prepare()方法只能调用一次，所以只会创建一个Looper对象，所以：
一个线程中只会创建一个Looper对象，而一个Looper对象也只会创建一个MessageQueue对象。
最后，主线程创建Handler没有调用prepare()方法，那么Looper是从哪里来的？
其实主线程的Looper是在ActivityThread类中main()方法中创建的，接下来我们看看这个main()方法：
public static void main(String[] args) {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
Process.setArgV0("<pre-initialized>");
// 就是这里调用了prepare方法
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false, startSeq);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
if (false) {
Looper.myLooper().setMessageLogging(new LogPrinter(Log.DEBUG, "ActivityThread"));
}
// End of event ActivityThreadMain.
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
// 就是这里给主线程创建了Looper
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
接下来我们看看Looper的prepareMainLooper方法：
public static void prepareMainLooper() {
//设置不允许退出的Looper
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
prepare(false)创建了Looper并且把它和当前线程一起塞进map中的。
Looper要分发消息并不知道具体发送消息的时间，只能开启死循环不断从MessageQueue中获取消息，所以Looper.loop()方法就是开启了死循环：
public static void loop() {
// 拿到当前线程的Looper
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
// ......
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
// ......
msg.recycleUnchecked();
}
}
在循环中Looper不停的取出消息，拿到Message对象以后，会去调用Message的target字段的dispatchMessage方法，其中target就是发送消息的Handler。
可以再来看看dispatchMessage方法，源码如下所示：
public void dispatchMessage(@NonNull Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
可以看到在回调中调用了handleMessage(msg)方法。
通过Handler发送消息时，消息会回到Handler初始化的线程，而不一定是主线程，所以Handler其实是借助共享变量来进行线程切换的。
- Looper和ANR
其实整个Android就是在一个Looper的loop循环的，整个Android的一切都是以Handler机制进行的，即只要有代码执行都是通过Handler来执行的，而所谓ANR便是Looper.loop()没有得到及时处理，一旦没有消息，Linux的epoll机制则会通过管道写文件描述符的方式来对主线程进行唤醒与沉睡，Android里调用了linux层的代码实现在适当时会睡眠主线程