Java中的线程回顾
在操作系统的概念里，进程是具有一定独立功能的程序、它是系统进行资源分配和调度的一个独立单位。
在Java的虚拟机中，进程拥有自己独立的虚拟地址空间（准确的说是方法区和堆内存）。
而线程则是CPU调度的基本单元,它没有自己独立的虚拟地址空间，它依附于进程的虚拟地址空间。在Java虚拟机中，线程拥有的不过是PC计数器和方法栈而已。
在Android系统中，进程之间的通信称为IPC，它主要由Binder完成，线程之间由于共享地址空间，各线程都可以对对象进行操作，因此线程间的通信机制更为简单，由轻便的Handler和Looper完成。
线程独有数据
由于同一个进程的线程共享资源，因此，如何保证数据在某线程的私有性变为极为重要，忽略这点会造成著名的多线程同步问题。在Java中，线程被封装为Thread类，一种很常见的思维是维护一个共有的哈希表，然后将线程的私有变量存储起来，当线程需要取用数据时，从哈希表中读取私有数据。
val threadData = ConcurrentHashMap<Thread,Any>()
但是如果这样的话，程序员就需要自己在程序中维护这么一个表，且不说自己能不能记住到底存储了什么，光是表的维护就已经很麻烦了，而且表的更新特别耗费资源。因此，比较好的方法是将数据存储封装在Thread这个类的内部，由于每一个线程都是一个Thread对象，它们需要这个值的时候直接读取其内部的值即可。Android采用了ThreadLocal这个类，实现了在指定线程中存储数据的功能。
首先我们来看一下ThreadLocal类怎么使用:
fun test()
{
val localAge = ThreadLocal<Int>() // 申请一个Int类型的线程私有变量
localAge.set(10) //主线程中修改值
Log.d(Thread.currentThread().toString(),localAge.get().toString()+"-> $localAge")
Thread({
localAge.set(12345) //其他线程中修改值
Log.d(Thread.currentThread().toString(),localAge.get().toString()+"-> $localAge")
}, "Thread#2").start()
Thread({
localAge.set(18) //其他线程中修改值
Log.d(Thread.currentThread().toString(),localAge.get().toString()+"-> $localAge")
},"Thread#3").start()
localAge.set(-33) //主线程中第二次修改值
Log.d(Thread.currentThread().toString(),localAge.get().toString()+"-> $localAge")
}
输出结果:
01-09 21:33:50.274 11935-11935/cn.suiseiseki.www.androidstudy D/Thread[main,5,main]: 10-> java.lang.ThreadLocal@4368aaa8
01-09 21:33:50.274 11935-11950/cn.suiseiseki.www.androidstudy D/Thread[Thread#2,5,main]: 12345-> java.lang.ThreadLocal@4368aaa8
01-09 21:33:50.279 11935-11935/cn.suiseiseki.www.androidstudy D/Thread[main,5,main]: -33-> java.lang.ThreadLocal@4368aaa8
01-09 21:33:50.279 11935-11951/cn.suiseiseki.www.androidstudy D/Thread[Thread#3,5,main]: 18-> java.lang.ThreadLocal@4368aaa8
可以看到，在不同线程中访问同一个Thread对象，其获取的值不一样，这就是ThreadLocal的奇妙之处
下面我们分析一下ThreadLocal的主要方法:
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
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();
}
其实代码已经很明显了，就是通过不同的Thread对象获取其Thread内部维护的ThreadLocalMap,然后查询是否有这个参数，如果有就返回这个参数的值，如果没有则返回null.对于set方法来说，首先查找线程是否创建了ThreadLocalMap，如果没有则创建之，然后就是正常的map操作了
如果你感兴趣的话，可以再深入了解一下ThreadLocalMap这个类，它内部采用弱引用维护了一个哈希表，这里不再详细介绍。
总之，现在我们已经知道，多个线程之间确实可以互不干扰地存储和修改某些数据，这是线程间通信的基础。
MessageQueue：消息队列
Android中的线程间通信涉及到四个组件:Handler,Looper,Message,MessageQueue
MessageQueue称为消息队列，得力于上文所述的ThreadLocal类，现在每一个线程可以拥有自己的MessageQueue了。MessageQueue通过一个单链表来维护一个消息队列，因为单链表在插入和删除过程中有性能优势。作为一个队列，它自然有两个方法，用于入队（插队）的enqueueMessage方法和出队的next方法
boolean enqueueMessage(Message msg, long when) {
if (msg.target == null) {
throw new IllegalArgumentException("Message must have a target.");
}
if (msg.isInUse()) {
throw new IllegalStateException(msg + " This message is already in use.");
}
synchronized (this) {
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) {
// New head, wake up the event queue if blocked.
msg.next = p;
mMessages = msg;
needWake = mBlocked;
} else {
// Inserted within the middle of the queue. Usually we don't have to wake
// up the event queue unless there is a barrier at the head of the queue
// and the message is the earliest asynchronous message in the queue.
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; // invariant: p == prev.next
prev.next = msg;
}
// We can assume mPtr != 0 because mQuitting is false.
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}
可以看到，enqueueMessage方法先检查Message的合法性，然后再根据Message的when属性将Message插入单链表中。
Message next() {
// Return here if the message loop has already quit and been disposed.
// This can happen if the application tries to restart a looper after quit
// which is not supported.
final long ptr = mPtr;
if (ptr == 0) {
return null;
}
int pendingIdleHandlerCount = -1; // -1 only during first iteration
int nextPollTimeoutMillis = 0;
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
// Try to retrieve the next message. Return if found.
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;
if (msg != null && msg.target == null) {
// Stalled by a barrier. Find the next asynchronous message in the queue.
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
}
if (msg != null) {
if (now < msg.when) {
// Next message is not ready. Set a timeout to wake up when it is ready.
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
// Got a message.
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 {
// No more messages.
nextPollTimeoutMillis = -1;
}
// Process the quit message now that all pending messages have been handled.
if (mQuitting) {
dispose();
return null;
}
// If first time idle, then get the number of idlers to run.
// Idle handles only run if the queue is empty or if the first message
// in the queue (possibly a barrier) is due to be handled in the future.
if (pendingIdleHandlerCount < 0
&& (mMessages == null || now < mMessages.when)) {
pendingIdleHandlerCount = mIdleHandlers.size();
}
if (pendingIdleHandlerCount <= 0) {
// No idle handlers to run. Loop and wait some more.
mBlocked = true;
continue;
}
if (mPendingIdleHandlers == null) {
mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
}
mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
}
// Run the idle handlers.
// We only ever reach this code block during the first iteration.
for (int i = 0; i < pendingIdleHandlerCount; i++) {
final IdleHandler idler = mPendingIdleHandlers[i];
mPendingIdleHandlers[i] = null; // release the reference to the handler
boolean keep = false;
try {
keep = idler.queueIdle();
} catch (Throwable t) {
Log.wtf(TAG, "IdleHandler threw exception", t);
}
if (!keep) {
synchronized (this) {
mIdleHandlers.remove(idler);
}
}
}
// Reset the idle handler count to 0 so we do not run them again.
pendingIdleHandlerCount = 0;
// While calling an idle handler, a new message could have been delivered
// so go back and look again for a pending message without waiting.
nextPollTimeoutMillis = 0;
}
}
next方法是一个无限循环的方法，如果MessageQueue队列中没有消息，此方法会堵塞，直到新的消息到来位置，它会将消息取出，然后再链表中删除它。
Looper:MessageQueue的使用者
有了消息队列之后，我们还需要一个使用消息队列的对象:Looper。从Looper的名字可以看出，它代表某种循环的意思。为了让某个线程能不断地处理消息(Message),我们就需要为线程创建Looper:
Thread(
{
Looper.prepare()
val handler = Handler()
Looper.loop()
}
).start()
注意这里需要调用Looper的静态方法。当然，我们也可以随时停止Looper，在线程中调用quit或者quitSatety即可:
Looper.myLooper().quit()
Looper.myLooper().quitSafely()
可以看到，Looper的主要方法都是静态方法，便于我们在线程的任意位置调用它们
Looper内部最重要的方法就是loop()方法，它是一个死循环，跳出循环的唯一方式是其MessageQueue的next返回了null（正常情况下应该是被堵塞的）。当Looper调用quit或者quitSafely时，它会通知消息队列退出，使其返回null值。
如果MessageQueue的next返回了Message消息，它会将这个消息交给Handler去处理。
Handler：消息的发送与处理者
Handler的工作就是发送消息和处理消息,它主要通过两个方法：sendMessage和post(runnable)去发送消息
它们的底层过程就是向消息队列中插入一条消息，通过Looper接收后又交给了它自己的dispatchMessage方法去处理:
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
首先，它会检查消息本身的callback是否为空（这适用于post方法发送的runnable对象消息），如果不为空则由这个runnable对象接管执行。
如果为空，再检查本Handler自身的mCallback是否为空，如果不为空则由这个对象代为处理。
如果mCallback也为空，则在自身的handleMessage方法中执行了，这是常规操作，自己在Handler的子类中实现这个方法即可
Handler还有一个很方便的构造方法，传入一个指定Looper来构造Looper:
public Handler(Looper looper) {
this(looper, null, false);
}
比如 val handler = Handler(Looper.getMainLooper())，快速在其他线程中获取主线程的handler
