为啥要有 handle
首先 android UI 线程的类型是 ActivityThread，这可能在这里没什么用，凑凑字数吧......

1. android 的 UI 控件不是线程安全的， 多线程并发访问 UI 控件时可能会产生问题。
2. 为什么不给 UI 控件加锁，一是加锁会复杂很多，二是加锁会阻塞其他访问 UI 的线程，有可能造成别的线程占用 UI 而把 UI 线程阻塞了，这就肯定会造成卡顿问题了。所以才采用了单线程更新 UI 的模式，使用 handle 来切换线程。

上面的解释是看：开发艺术探索 总结的......
handle 中几个角色：

• ThreadLocal
  每个线程中用来保存私有变量的容器
• Looper
  消息队列的管理容器，也可以叫轮询器
• MessageQueue
  消息队列
• Message
  消息本身
• handle
  消息发送器，和消息消费者

说下过程：

1. Looper.prepare();
   looper 的初始化创建，looper 会创建自己，每个 Looper 对象的创建都会伴随创建一个消息队列 MessageQueue，并把自己保存在当前线程的 ThreadLocal 中，保证每个线程中 looper 的唯一性。
2. Looper.loop();
   looper 开始一个无限循环，从内部的 MessageQueue 消息队列中循环取出数据挨个执行，消息队列没有数据了就会挂起。
3. message.getTarget().dispatchMessage(message);
   消息最终就是这么被执行的， message.getTarget() 的返回的对象就是 handle ，所以这里由 handle 会出现内存泄露。
4. handler.sendMessage();
   handle 发送数据，就是把自己传递给这个待处理的消息 message 中，然后添加到 MessageQueue 消息队列里面去。
5. 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消耗。

• 关于nativePollOnce阻塞线程的解释
• next() 方法的解释来自 一句话讲清楚Android消息机制

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 = "https://www.it610.com/article/+ threadLocal.get()); } }; Thread t2 = new Thread() {@Override public void run() { super.run(); threadLocal.set("CC"); Log.d("AA", Thread.currentThread().getName() + " / ThreadLocal : value = "https://www.it610.com/article/+ threadLocal.get()); } }; t1.start(); t2.start(); try { Thread.sleep(300); } catch (InterruptedException e) { e.printStackTrace(); } Log.d("AA", Thread.currentThread().getName() + " / ThreadLocal : value = "https://www.it610.com/article/+ threadLocal.get()); }

文章图片
测试结果 ThreadLocal 的使用场景并不多，基本都是用这个作用域范围，像 Looper，ActivityThread，AMS 这些。
趴趴源码实现
为啥 ThreadLocal 这么屌呢，其实也没啥，主要我们尝试看源码，就会发现很多东西其实也是很简单的，就是设计很灵活，很 Nice

1. looper 对象里有一个 static 的 ThreadLocal 对象，声明对象时就初始化了

static final ThreadLocal sThreadLocal = new ThreadLocal();

2. 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 值，也就是我们储存的数据

3. 我们来看看这个map 里面的 Entry 的声明

static class Entry extends WeakReference> { /** The value associated with this ThreadLocal. */ Object value; Entry(ThreadLocal k, Object v) { super(k); value = https://www.it610.com/article/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是线程安全的原因了.
【android|android 多线程 — handle 学习】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的回答

推荐阅读

• 

  海门大桥
• 

  胃癌|胃癌偏爱这4类人，若你在其中，做好这5点，或许能幸免！
• 

  王者荣耀下载最新版安卓，王者荣耀助手安卓版下载
• 

  电商怎么做 粮油电商是什么意思，粮油是啥
• 

  弈星重塑啦！从围棋的对弈体验入手，天才少年的成长的关键词是：以身入局，____ 王者荣耀8月5日每日一题答案
• 

  安卓 强制前台,手机回收模式下安卓应用如何继续在后台运行?
• 

  电脑调哪几个设置可以让电脑变快速度 电脑调哪几个设置可以让电脑变快
• 

  老款5角硬币图片 「新款5元硬币」
• 

  西瓜汁放冰箱可以保存多久
• 

  qqbot源码分析,nginx源码分析
• 

  梦见抱着男孩
• 

  雨隐村曾经有几位首领 火影忍者手游10月28日每日一题答案
• 

  你看过最好看的美剧是什么？
• 

  php长数据发送 php传输数据的方式
• 

  行政处罚的种类包括人身罚行为罚财产罚和申诫罚 行政处罚的种类
• 

  mysql批量查询语句 mysql查询批量替换
• 

  六月黄吃到什么时候
• 

  小森生活游戏介绍 小森生活好玩吗
• 

  鸡丸的做法大全 鸡丸怎么做
• 

  秦时明月世界怎么转职 秦时明月世界转职业

• 放屁有这三个特征的，请注意啦！这说明你的身体毒素太多
• android第三方框架（五）ButterKnife
• 爱就是希望你好好活着
• 昨夜小楼听风
• 知识
• 死结。
• 我从来不做坏事
• 烦恼和幸福
• 关于QueryWrapper|关于QueryWrapper,实现MybatisPlus多表关联查询方式
• Android中的AES加密-下