为啥要有 handle
首先 android UI 线程的类型是 ActivityThread，这可能在这里没什么用，凑凑字数吧......
android 的 UI 控件不是线程安全的， 多线程并发访问 UI 控件时可能会产生问题。
为什么不给 UI 控件加锁，一是加锁会复杂很多，二是加锁会阻塞其他访问 UI 的线程，有可能造成别的线程占用 UI 而把 UI 线程阻塞了，这就肯定会造成卡顿问题了。所以才采用了单线程更新 UI 的模式，使用 handle 来切换线程。
上面的解释是看：开发艺术探索 总结的......
handle 中几个角色：
ThreadLocal
每个线程中用来保存私有变量的容器
Looper
消息队列的管理容器，也可以叫轮询器
MessageQueue
消息队列
Message
消息本身
handle
消息发送器，和消息消费者
说下过程：
Looper.prepare();
looper 的初始化创建，looper 会创建自己，每个 Looper 对象的创建都会伴随创建一个消息队列 MessageQueue，并把自己保存在当前线程的 ThreadLocal 中，保证每个线程中 looper 的唯一性。
Looper.loop();
looper 开始一个无限循环，从内部的 MessageQueue 消息队列中循环取出数据挨个执行，消息队列没有数据了就会挂起。
message.getTarget().dispatchMessage(message);
消息最终就是这么被执行的， message.getTarget() 的返回的对象就是 handle ，所以这里由 handle 会出现内存泄露。
handler.sendMessage();
handle 发送数据，就是把自己传递给这个待处理的消息 message 中，然后添加到 MessageQueue 消息队列里面去。
Handler handler2 = new Handler(Looper.getMainLooper());
Looper里面有个静态的 looper ，就是当前进程中 UI 线程的 looper，通过这个 UI 的线程的 looper ，我们可以创建一个 handle 出来，然后添加消息到主进程中去执行。
为啥 looper 可以切换线程
looper 的都是要求我们在 Looper.prepare() looper 的初始化之后马上 Looper.loop() 让 looper 跑起来的，lopper 本身是一个无限循环，会一直在 looper 所在线程中执行，所以我们通过不同的 looper 对象，创建 handle 对象发送消失时都是把这个消息发送到了对应 looper 所以在的 MessageQueue 消息队列中去，这个消息队列自然的会在所诉的那个 looper 循环中执行，looper 在哪个线程，那么就是在哪个线程运行。所以线程切换就是这么做的。
MessageQueue 的 next() 方法内部会调用 nativePollOnce() 方法，该方法会阻塞线程。该方法的作用简单说，就是当消息队列中没消息时，阻塞掉当前执行的线程.避免过度的cpu消耗。
handle.post 干啥了
为什么特别说下 handle 的 post 方法，因为有的人面试会问，其实这个很简单，post 方法会生成一个 message 对象，然后把我们 post 方法里面的 runnable 对象存到 message 的 callback 里面去，message 在执行时，会判断有没有 callback 值，有的话直接执行消费本地信息了，没有的话才会把这个 message 交给 handle 去执行。
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;
} // 回到调用原处
对于 looper 的阻塞测试
其实看了上面对于 looper 阻塞的解释后，我被这个 Pipe 管道 hold 住了，原来用到了这么高大上的技术啊，此时我非常觉得我得做点什么才行，于是不管怎样样总得干点，干脆咱来看看这个阻塞是不是真的，我是不是有点失心疯啊...........
所以我做了个测试明确下思路：
起2个 thread 线程
thread1 里面跑一个 looper ，然后把这个 looper 抛出去，在 looper 启动之后加一个 打印循环
thread2 拿到 thread1 抛出的 looper 构建 handle 发送消息
最后看看这个在 looper 之后的打印循环有没有执行机会。
thread1
public class Thread1 extends Thread {
private Looper looper;
@Override
public void run() {
super.run();
Looper.prepare();
looper = Looper.myLooper();
Looper.loop();
int num = 1;
while (num <= 50) {
Log.d("AAA", Thread.currentThread().getName() + "_执行次数 / " + num);
num++;
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public Looper getLooper() {
return looper;
}
}
thread2
public class Thread2 extends Thread {
private Handler handler;
public void setHandler(Handler handler) {
this.handler = handler;
}
@Override
public void run() {
int num = 1;
while (num <= 3) {
try {
java.lang.Thread.sleep(1000);
if (handler != null) {
Message message = new Message();
message.what = 2;
handler.sendMessage(message);
Log.d("AAA", Thread.currentThread().getName() + "发送消息 / " + num);
}
num++;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
UI 线程启动这 2 个测试线程
Thread1 t1 = new Thread1();
Thread2 t2 = new Thread2();
t1.start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
Handler handler = new Handler(t1.getLooper()) {
int num = 0;
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
if (msg.what == 2) {
num++;
Log.d("AAA", Thread.currentThread().getName() + "接受到消息 / " + num);
}
}
};
t2.setHandler(handler);
t2.start();
}
UI 线程中中间 sleep 1秒，因为 looper 初始化需要一点时间，handle 中传入的 looper 要是 null 的话会抛异常。
测试结果
测试结果是果然 thread1 后面的打印循环是出不来的，looper 的确是阻塞了当前线程的，looper 之后的代码都是没机会执行的
首先 looper 里面的队列是无限循环的，这个循环出不去后面的代码肯定不会执行
再次 looper 的阻塞会阻塞这个无限循环，进而阻塞当前线程。
我想说这个测试有点凑字数的嫌疑，但是我的确在 looper 无限循环，阻塞，唤醒的问题上找了好多资料，折腾了好几回，非常不爽啊
ThreadLocal
ThreadLocal 是一个存储器，作用域在单个线程对象内部，多线程间是无法共享的，相当于线程对象私有的变量存储器。这个存储器只能存一个数据，那么要是想存多个数据的话，就需要多个 ThreadLocal 对象了。
threadLocal.set("BB") -- > 存数据
threadLocal.get() -- > 取数据
通过这 2 个方法就知道了吧，只能存一个数据进去
一般我们认为，你在一个类里面声明的一个对象，这个对象的作用域肯定就是你这个类的对象啊。但是注意 ThreadLocal 的特别之处在于即使你在3个线程之内，操作同一个ThreadLocal 对象里面的值，那么你会发现 3个线程所属的 ThreadLocal 里面对应的值都是不同的。
下面是一个测试，在 UI 线程启动2个 thread ，这3个线程一齐修改同一个 ThreadLocal 里面的数据
ThreadLocal threadLocal = new ThreadLocal();
threadLocal.set("AA");
Thread t1 = new Thread() {
@Override
public void run() {
super.run();
threadLocal.set("BB");
Log.d("AA", Thread.currentThread().getName() + " / ThreadLocal : value = " + threadLocal.get());
}
};
Thread t2 = new Thread() {
@Override
public void run() {
super.run();
threadLocal.set("CC");
Log.d("AA", Thread.currentThread().getName() + " / ThreadLocal : value = " + threadLocal.get());
}
};
t1.start();
t2.start();
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
Log.d("AA", Thread.currentThread().getName() + " / ThreadLocal : value = " + threadLocal.get());
}
测试结果
ThreadLocal 的使用场景并不多，基本都是用这个作用域范围，像 Looper，ActivityThread，AMS 这些。
趴趴源码实现
为啥 ThreadLocal 这么屌呢，其实也没啥，主要我们尝试看源码，就会发现很多东西其实也是很简单的，就是设计很灵活，很 Nice
looper 对象里有一个 static 的 ThreadLocal 对象，声明对象时就初始化了
static final ThreadLocal sThreadLocal = new ThreadLocal();
ThreadLocal 的 ge() 干了什么
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();
}
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
获取当前线程对象，然后从拿到线程对象里面的参数 ThreadLocalMap ，ThreadLocal 的 map 集合，然后以 ThreadLocal 对象自己为 key 获取到 value 值，也就是我们储存的数据
我们来看看这个map 里面的 Entry 的声明
static class Entry extends WeakReference> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal> k, Object v) {
super(k);
value = v;
}
}
很明显的可以看到 key 是 ThreadLocal 对象本身，value 是我们储存的值。每个 thread 对象内部都有一个 map 集合的话，通过同一个 key 我们当然会可以存不同的值进去了。
其他人的解释
ThreadLocal是一种保存变量的线程安全的类.
在多线程环境下能安全使用变量,最好的方式是在每个线程中定义一个local变量.
这样对线程中的local变量做修改就只会影响当前线程中的该变量,因此变量也就是线程安全的.
这种保证变量线程安全的思想,实际上就是ThreadLocal的实现.
Threadlocal在调用threadLocal.get方法时,会获取当前thread的threadLocalMap.
threadLocalMap是thread中的一个属性.
第一次调用ThreadLocal.get()方法时,会先判断当前线程对应的threadlocalMap是否被创建了,
如果没创建则会创建ThreadLocalMap,并把该对象赋值给thread.sThreadLocal对象.后续再获取当前thread的threadLocalMap时,就会取该赋值对象.
ThreadLocalMap就是用来保存线程中需要保存的变量的对象了.
因为threadLocalMap是赋值给当前thread的,属于thread的内部变量,
所以每个线程的threadlocalMap就都是不同的对象,也就是上面说的threadlocal是线程安全的原因了.
ThreadLocalMap内部实际上是一个Entry[],用来保存Entry对象的数组.
Entry对象是继承weakReference的,其中Entry的key为ThreadLocal对象,value为threadLocal需要保存的变量值.
调用ThreadLocal.set方法时,会向threadLocalMap中添加一个Entry对象.
调用get方法时,是通过将调用的threadLocal对象本身作为key,来遍历threadLocalMap数组.
当threadLocal等于Entry[]中的key时,则返回该Entry中的value
为什么主线程不会因为 Looper.loop() 的死循环卡死
这是个经典的问题了，我们先来看看主线程启动时干了什么
public static void main(String[] args) {
....
//创建Looper和MessageQueue对象，用于处理主线程的消息
Looper.prepareMainLooper();
//创建ActivityThread对象
ActivityThread thread = new ActivityThread();
//建立Binder通道 (创建新线程)
thread.attach(false);
Looper.loop(); //消息循环运行
throw new RuntimeException("Main thread loop unexpectedly exited");
}
核心就是给主线程添加了 looper 进去，然后启动 looper 这个队列，looper 实际是一个阻塞是死循环，简单介绍一下，有消息就处理，没有消息就会休眠，有消息就会唤醒继续处理消息，本质上是一套完整的线程通信机制
public static void loop() {
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
final MessageQueue queue = me.mQueue;
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
try {
msg.target.dispatchMessage(msg);
}
}
}
看到 loop 这个方法了没， for (;;) 就是个 while(true) 死循环，queue.next() 获取队列的消息，队列为空的时候会阻塞主线程，这里就是关键了，queue.next() 的阻塞是不会造成 ANR 的。
先说一点，为什么主线程是个死循环还要要阻塞，淡村的死循环空闲时也不阻塞，会消耗大量的 CPU 资源，这是非常不值得的操作，所以在空闲时要阻塞
java 的阻塞分两种，阻塞失去锁，阻塞不失去锁，不丢失锁的这种阻塞也叫休眠，随时可以唤醒，唤醒就能马上执行任务。wait() 是失去锁的阻塞，sleep() 就是不失去锁的阻塞也就是休眠了，只不过 loop 这里的休眠式阻塞是交给 linux 层去实现的
在添加任务到队列的时候会用 linux 的方式 nativeWake 唤醒主线程，nativeWake 是本地 C 的方法
boolean enqueueMessage(Message msg, long when) {
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}
private native static void nativeWake(long ptr);
在获取任务时先用 linux 的方式 nativePollOnce 阻塞主线程，nativePollOnce 是本地 C 的方法
Message next() {
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
.......
}
}
private native void nativePollOnce(long ptr, int timeoutMillis);
这里就涉及到Linux pipe/e****poll机制，简单说就是在主线程的MessageQueue没有消息时，便阻塞在loop的queue.next()中的nativePollOnce()方法里，详情见Android消息机制1-Handler(Java层)，此时主线程会释放CPU资源进入休眠状态，直到下个消息到达或者有事务发生，通过往pipe管道写端写入数据来唤醒主线程工作。这里采用的epoll机制，是一种IO多路复用机制，可以同时监控多个描述符，当某个描述符就绪(读或写就绪)，则立刻通知相应程序进行读或写操作，本质同步I/O，即读写是阻塞的。 所以说，主线程大多数时候都是处于休眠状态，并不会消耗大量CPU资源。
thread.attach(false)；便会创建一个Binder线程(具体是指ApplicationThread，Binder的服务端，用于接收系统服务AMS发送来的事件)，该Binder线程通过Handler将Message发送给主线程**，具体过程可查看 startService流程分析，这里不展开说，简单说Binder用于进程间通信，采用C/S架构。关于binder感兴趣的朋友，可查看
为什么Android要采用Binder作为IPC机制？ - Gityuan的回答
扫一扫
1814
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
