一些感悟
穷人的一次失败，为了还债可能一辈子都翻不了身，为还债一辈子送外卖。你将不再会有精力去思考和投机。穷人的失败可能断送了他所有暴富的机遇和时间，让不确定的人生瞬间确定下来，让充满无限可能的人生可能性逐渐缩小。这是赤裸裸的现实。
只有当你有足够多的资本时，允许你失误的次数才会逐渐增加。拥有足够多的资本，哪怕尝试个三番五次失败了，也不会伤你元气。所以从这个角度讲，人的机遇是随着财富的增加而增加的。这时代表面上人人机会平等，但是给穷人的机会非常有限。王思聪失败一次不过是兴趣爱好的失败，而你失败一次则是生存生活的失败。穷人，更应该不断学习和思考，因为你没有钱，知识就是你最大的财富。穷人，更应该保守，因为生活不允许你失败。
在今天记录一下我的生活。作为一个 32 岁的程序员，我很焦虑，我在一个不大不小的公司(讯飞)，干活，日子重复无聊一晃眼 7 年过去了，想辞职一想到现在的年纪，房贷，车贷，孩子，家庭真的挺无奈。现在上级还时不时“透漏”公司要优化人的消息，其实还蛮焦虑的。马上 35 岁了要是被优化了，生活真的不知道该怎么办！
重要概念
1、主线程（UI 线程、MainThread）
当应用程序第一次启动时，会同时自动开启 1 条主线程，用于处理 UI 相关的事件（如更新、操作等）
2、子线程（工作线程）
人为手动开启的线程，执行耗时操作（如网络请求、数据加载等）
3、消息（Message）
线程间通讯的数据单元（即 Handler 接受 & 处理的消息对象），用于存储需要操作的通信信息
4、消息队列（Message Queue）
一种数据结构（先进先出），存储 Handler 发送过来的消息（Message）
5、处理者（Handler）
Handler 为主线程与子线程的通信媒介，是线程消息的主要处理者。用于添加消息（Message）到消息队列（Message Queue），处理循环器（Looper）分派过来的消息（Message）
6、循环器（Looper）
消息队列（Message Queue）与处理者（Handler）的通信媒介，用于消息循环，即（1）消息获取：循环取出消息队列（Message Queue）的消息（Message）（2）消息分发：将取出的消息（Message）发送给对应的处理者（Handler）每个线程只能拥有 1 个 Looper，1 个 Looper 可绑定多个线程的 Handler，即多个线程可往 1 个 Looper 所持有的 MessageQueue 中发送消息，提供线程间通信的可能
（三）使用方式
3.1）Handler.sendMessage()
方式 1：新建 Handler 子类（内部类）
// 步骤1：自定义Handler子类（继承Handler类） & 复写handleMessage（）方法
复制代码
class mHandler extends Handler {
复制代码
// 通过复写handlerMessage() 从而确定更新UI的操作
复制代码
public void handleMessage(Message msg) {
复制代码
private Handler mhandler = new mHandler();
复制代码
Message msg = Message.obtain(); // 实例化消息对象
复制代码
msg.obj = "AA"; // 消息内容存放
复制代码
// 步骤4：在工作线程中 通过Handler发送消息到消息队列中
复制代码
// 可通过sendMessage（） / post（）
复制代码
// 多线程可采用AsyncTask、继承Thread类、实现Runnable
复制代码
mHandler.sendMessage(msg);
复制代码
// 步骤5：开启工作线程（同时启动了Handler）
复制代码
// 多线程可采用AsyncTask、继承Thread类、实现Runnable
复制代码
方式 2：匿名内部类
// 步骤1：在主线程中 通过匿名内部类 创建Handler类对象
复制代码
private Handler mhandler = new Handler(){
复制代码
// 通过复写handlerMessage()从而确定更新UI的操作
复制代码
public void handleMessage(Message msg) {
复制代码
Message msg = Message.obtain(); // 实例化消息对象
复制代码
msg.obj = "AA"; // 消息内容存放
复制代码
// 步骤3：在工作线程中 通过Handler发送消息到消息队列中
复制代码
// 多线程可采用AsyncTask、继承Thread类、实现Runnable
复制代码
mHandler.sendMessage(msg);
复制代码
// 步骤4：开启工作线程（同时启动了Handler）
复制代码
// 多线程可采用AsyncTask、继承Thread类、实现Runnable
复制代码
3.2）Handler.post()
private Handler mhandler = new mHandler();
复制代码
// 步骤2：在工作线程中 发送消息到消息队列中 & 指定操作UI内容
复制代码
mHandler.post(new Runnable() {
复制代码
// 步骤3：开启工作线程（同时启动了Handler）
复制代码
// 多线程可采用AsyncTask、继承Thread类、实现Runnable
复制代码
（四）工作原理
4.1）工作流程解析
步骤一：异步通信准备
在主线程中创建（1）循环器 对象（Looper）（2）消息队列 对象（Message Queue）（3）Handler 对象 Looper、Message Queue 均属于主线程，创建 Message Queue 后，Looper 自动进入消息循环。此时，Handler 自动绑定了主线程的 Looper、Message Queue
步骤二：消息入队
工作线程通过 Handler 发送消息（Message）到消息队列（Message Queue）中，该消息内容=工作线程对 UI 的操作
步骤三：消息循环
消息出队：Looper 循环取出消息队列（Message Queue）中的消息（Message）消息分发：Looper 将去除的消息（Message）发送给创建该消息的处理者（Handler）在消息循环过程中，若消息队列为空，则线程阻塞。
步骤四：消息处理
处理者 Handler 接受循环器 Looper 发送过来的消息（Message）处理者 Handler 根据消息（Message）进行 UI 操作
4.2）工作流程图
4.3）示意图
4.4）线程 Thread、循环器 Looper、处理者 Handler 对应关系
（1）1 个线程（Thread）只能绑定 1 个循环器（Looper），但可以有多个处理者（2）1 个循环器（Looper）可绑定多个处理者（Handler）（3）1 个处理者（Handler）只能绑定 1 个循环器（Looper）
（五）源码分析
5.1）核心类
Handler 机制包括 3 个重要类：1、处理者 Handler2、循环器 Looper3、消息队列 MessageQueue
1、类图
2、核心方法
5.2）源码分析
记录一次 Handler 使用步骤
方式 1：使用 Handler.sendMessage()
准备步骤 1：创建循环器对象 Looper&消息队列对象 MessageQueue
Looper.prepareMainLooper()为主线程（UI 线程）创建 1 个循环器对象（Looper），同时也会自动创建 1 个对应的消息队列对象（MessageQueue）该方法在主线程（UI 线程）创建时自动调用，不需手动生成。在 Android 应用进程启动时，会默认创建 1 个主线程（ActiviyThread，也叫 UI 线程），创建时，会自动调用 ActivityThread 的 1 个静态 main 方法=应用程序的入口 main()内则会调用 Looper.prepareMainLooper()为主线程生成 1 个 Looper 对象
public static void main(String[] args) {
复制代码
Looper.prepareMainLooper();
复制代码
// 1\. 为主线程创建1个Looper对象，同时生成1个消息队列对象（MessageQueue）
复制代码
// 方法逻辑类似Looper.prepare()
复制代码
// 注：prepare()：为子线程中创建1个Looper对象
复制代码
ActivityThread thread = new ActivityThread();
复制代码
// 3\. 自动开启 消息循环 ->>下面将详细分析
复制代码
Looper.prepare()为当前线程（子线程）创建 1 个循环器对象（Looper），同时也会自动创建 1 个对应的消息队列对象（MessageQueue）需要在子线程中手动调用改方法
public static final void prepare() {
复制代码
if (sThreadLocal.get() != null) {
复制代码
throw new RuntimeException("Only one Looper may be created per thread");
复制代码
// 1\. 判断sThreadLocal是否为null，否则抛出异常
复制代码
//即 Looper.prepare()方法不能被调用两次 = 1个线程中只能对应1个Looper实例
复制代码
// 注：sThreadLocal = 1个ThreadLocal对象，用于存储线程的变量
复制代码
sThreadLocal.set(new Looper(true));
复制代码
// 2\. 若为初次Looper.prepare()，则创建Looper对象 & 存放在ThreadLocal变量中
复制代码
// 注：Looper对象是存放在Thread线程里的
复制代码
private Looper(boolean quitAllowed) {
复制代码
mQueue = new MessageQueue(quitAllowed);
复制代码
// 1\. 创建1个消息队列对象（MessageQueue）
复制代码
// 即 当创建1个Looper实例时，会自动创建一个与之配对的消息队列对象（MessageQueue）
复制代码
mThread = Thread.currentThread();
复制代码
创建主线程时，会自动调用 ActivityThread 的 1 个静态的 main（）；而 main（）内则会调用 Looper.prepareMainLooper()为主线程生成 1 个 Looper 对象，同时也会生成其对应的 MessageQueue 对象，即 主线程的 Looper 对象自动生成，不需手动生成；而子线程的 Looper 对象则需手动通过 Looper.prepare()创建，在子线程若不手动创建 Looper 对象 则无法生成 Handler 对象；根据 Handler 的作用（在主线程更新 UI），故 Handler 实例的创建场景 主要在主线程生成 Looper & MessageQueue 对象后，则会自动进入消息循环：Looper.loop（）
准备步骤 2：消息循环
* 作用：消息循环，即从消息队列中获取消息、分发消息到Handler
复制代码
* b. 子线程的消息循环允许退出：调用消息队列MessageQueue的quit（）
复制代码
public static void loop() {
复制代码
final Looper me = myLooper();
复制代码
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
复制代码
// myLooper()作用：返回sThreadLocal存储的Looper实例；若me为null 则抛出异常
复制代码
// 即loop（）执行前必须执行prepare（），从而创建1个Looper实例
复制代码
final MessageQueue queue = me.mQueue;
复制代码
// 获取Looper实例中的消息队列对象（MessageQueue）
复制代码
Message msg = queue.next();
复制代码
msg.target.dispatchMessage(msg);
复制代码
// 把消息Message派发给消息对象msg的target属性
复制代码
// target属性实际是1个handler对象
复制代码
* 定义：属于消息队列类（MessageQueue）中的方法
复制代码
// 从而决定消息队列应处于出队消息状态 or 等待状态
复制代码
int nextPollTimeoutMillis = 0;
复制代码
if (nextPollTimeoutMillis != 0) {
复制代码
Binder.flushPendingCommands();
复制代码
// nativePollOnce方法在native层，若是nextPollTimeoutMillis为-1，此时消息队列处于等待状态
复制代码
nativePollOnce(ptr, nextPollTimeoutMillis);
复制代码
final long now = SystemClock.uptimeMillis();
复制代码
// 出队消息，即 从消息队列中取出消息：按创建Message对象的时间顺序
复制代码
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
复制代码
if (DEBUG) Log.v(TAG, "Returning message: " + msg);
复制代码
// 若 消息队列中已无消息，则将nextPollTimeoutMillis参数设为-1
复制代码
nextPollTimeoutMillis = -1;
复制代码
* 分析2：dispatchMessage(msg)
复制代码
* 作用：派发消息到对应的Handler实例 & 根据传入的msg作出对应的操作
复制代码
public void dispatchMessage(Message msg) {
复制代码
// 1\. 若msg.callback属性不为空，则代表使用了post（Runnable r）发送消息
复制代码
// 则执行handleCallback(msg)，即回调Runnable对象里复写的run（）
复制代码
// 上述结论会在讲解使用“post（Runnable r）”方式时讲解
复制代码
if (msg.callback != null) {
复制代码
if (mCallback.handleMessage(msg)) {
复制代码
// 2\. 若msg.callback属性为空，则代表使用了sendMessage（Message msg）发送消息（即此处需讨论的）
复制代码
// 则执行handleMessage(msg)，即回调复写的handleMessage(msg) ->> 分析3
复制代码
* 注：该方法 = 空方法，在创建Handler实例时复写 = 自定义消息处理方式
复制代码
public void handleMessage(Message msg) {
复制代码
总结：（1）消息循环的操作 = 消息出队 + 分发给对应的 Handler 实例（2）分发给对应的 Handler 的过程：根据出队消息的归属者通过 dispatchMessage(msg)进行分发，最终回调复写的 handleMessage(Message msg)，从而实现 消息处理 的操作（3）特别注意：在进行消息分发时（dispatchMessage(msg)），会进行 1 次发送方式的判断：若 msg.callback 属性不为空，则代表使用了 post（Runnable r）发送消息，则直接回调 Runnable 对象里复写的 run（）若 msg.callback 属性为空，则代表使用了 sendMessage（Message msg）发送消息，则回调复写的 handleMessage(msg)
步骤 1：在主线程中 通过匿名内部类 创建 Handler 类对象
private Handler mhandler = new Handler(){
复制代码
// 通过复写handlerMessage()从而确定更新UI的操作
复制代码
public void handleMessage(Message msg) {
复制代码
* a. Handler需绑定 线程才能使用；绑定后，Handler的消息处理会在绑定的线程中执行
复制代码
* b. 绑定方式 = 先指定Looper对象，从而绑定了 Looper对象所绑定的线程（因为Looper对象本已绑定了对应线程）
复制代码
* c. 即：指定了Handler对象的 Looper对象 = 绑定到了Looper对象所在的线程
复制代码
* 分析1：this(null, false) = Handler（null，false）
复制代码
public Handler(Callback callback, boolean async) {
复制代码
mLooper = Looper.myLooper();
复制代码
throw new RuntimeException(
复制代码
"Can't create handler inside thread that has not called Looper.prepare()");
复制代码
// Looper.myLooper()作用：获取当前线程的Looper对象；若线程无Looper对象则抛出异常
复制代码
// 即 ：若线程中无创建Looper对象，则也无法创建Handler对象
复制代码
// 故 若需在子线程中创建Handler对象，则需先创建Looper对象
复制代码
// 注：可通过Loop.getMainLooper()可以获得当前进程的主线程的Looper对象
复制代码
// 2\. 绑定消息队列对象（MessageQueue）
复制代码
// 获取该Looper对象中保存的消息队列对象（MessageQueue）
复制代码
// 至此，保证了handler对象 关联上 Looper对象中MessageQueue
复制代码
当创建 Handler 对象时，则通过 构造方法 自动关联当前线程的 Looper 对象 & 对应的消息队列对象（MessageQueue），从而 自动绑定了 实现创建 Handler 对象操作的线程总结：
步骤 2：创建消息对象
具体使用
Message msg = Message.obtain(); // 实例化消息对象
复制代码
msg.obj = "AA"; // 消息内容存放
复制代码
源码分析
/** * 源码分析：Message.obtain() * 作用：创建消息对象 * 注：创建Message对象可用关键字new 或 Message.obtain()，建议使用obtain()创建消息对象，避免每次都使用new重新分配内存。（当池内无消息对象可复用，则用关键词new创建） */ public static Message obtain() {
// Message内部维护了1个Message池，用于Message消息对象的复用 // 使用obtain（）则是直接从池内获取 synchronized (sPoolSync) { if (sPool != null) { Message m = sPool; sPool = m.next; m.next = null; m.flags = 0; // clear in-use flag sPoolSize--; return m; } // 建议：使用obtain（）”创建“消息对象，避免每次都使用new重新分配内存 } // 若池内无消息对象可复用，则还是用关键字new创建 return new Message();
}
复制代码
步骤 3：在工作线程中发送消息到消息队列
具体使用
mHandler.sendMessage(msg);
复制代码
源码分析
/** * 源码分析：mHandler.sendMessage(msg) * 定义：属于处理器类（Handler）的方法 * 作用：将消息 发送 到消息队列中（Message ->> MessageQueue） */ public final boolean sendMessage(Message msg) { return sendMessageDelayed(msg, 0); // ->>分析1 }
/** * 分析1：sendMessageDelayed(msg, 0) **/ public final boolean sendMessageDelayed(Message msg, long delayMillis) { if (delayMillis < 0) { delayMillis = 0; }
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis); // ->> 分析2 }
/** * 分析2：sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis) **/ public boolean sendMessageAtTime(Message msg, long uptimeMillis) { // 1\. 获取对应的消息队列对象（MessageQueue） MessageQueue queue = mQueue;
// 2\. 调用了enqueueMessage方法 ->>分析3 return enqueueMessage(queue, msg, uptimeMillis); }
/** * 分析3：enqueueMessage(queue, msg, uptimeMillis) **/ private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) { // 1\. 将msg.target赋值为this // 即 ：把 当前的Handler实例对象作为msg的target属性 msg.target = this; // 请回忆起上面说的Looper的loop()中消息循环时，会从消息队列中取出每个消息msg，然后执行msg.target.dispatchMessage(msg)去处理消息 // 实际上则是将该消息派发给对应的Handler实例
// 2\. 调用消息队列的enqueueMessage（） // 即：Handler发送的消息，最终是保存到消息队列->>分析4 return queue.enqueueMessage(msg, uptimeMillis）; }
/** * 分析4：queue.enqueueMessage(msg, uptimeMillis） * 定义：属于消息队列类（MessageQueue）的方法 * 作用：入队，即 将消息 根据时间 放入到消息队列中（Message ->> MessageQueue） * 采用单链表实现：提高插入消息、删除消息的效率 */ boolean enqueueMessage(Message msg, long when) {
...// 仅贴出关键代码
synchronized (this) {
msg.markInUse(); msg.when = when; Message p = mMessages; boolean needWake;
// 判断消息队列里有无消息 // a. 若无，则将当前插入的消息 作为队头 & 若此时消息队列处于等待状态，则唤醒 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;
// b. 判断消息队列里有消息，则根据 消息（Message）创建的时间 插入到队列中 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; }
// 之后，随着Looper对象的无限消息循环// 不断从消息队列中取出Handler发送的消息 & 分发到对应Handler// 最终回调Handler.handleMessage()处理消息
复制代码
总结 Handler 发送消息的本质 =将消息对象的 target 属性设置为当前 Handler 实例（将 Message 绑定到 Handler，使执行消息循环时将消息派发给对应的 Handler 实例）获取对应的消息队列对象 MessageQueue，调用 MessageQueue.enqueueMessage()，将 Handler 需发送消息入队到绑定线程的消息队列中。
之后，随着 Looper 对象的无限消息循环，不断从消息队列中取出 Handler 发送的消息 &根据 target 分发到对应 Handler，最终回调 Handler.handleMessage()处理消息
源码总结
工作流程总结
方式 2：使用 Handler.post()
步骤 1：在主线程中创建 Handler 实例
具体使用
private Handler mhandler = new Handler()； // 与方式1的使用不同：此处无复写Handler.handleMessage()
复制代码
源码分析
/** * 源码分析：Handler的构造方法 * 作用： * a. 在此之前，主线程创建时隐式创建Looper对象、MessageQueue对象 * b. 初始化Handler对象、绑定线程 & 进入消息循环 * 此处的源码分析类似方式1，此处不作过多描述 */
复制代码
步骤 2：在工作线程中 发送消息到消息队列中
具体使用
mHandler.post(new Runnable() { @Override public void run() { //传入1个Ruunable对象，复写run()从而指定UI操作 ... // 需执行的UI操作 }
});
复制代码
源码分析
/** * 源码分析：Handler.post（Runnable r） * 定义：属于处理者类（Handler）中的方法 * 作用：定义UI操作、将Runnable对象封装成消息对象 & 发送 到消息队列中（Message ->> MessageQueue） * 注： * a. 相比sendMessage()，post（）最大的不同在于，更新的UI操作可直接在重写的run（）中定义 * b. 实际上，Runnable并无创建新线程，而是发送 消息 到消息队列中 */ public final boolean post(Runnable r) { return sendMessageDelayed(getPostMessage(r), 0); // getPostMessage(r) 的源码分析->>分析1 // sendMessageDelayed（）的源码分析 ->>分析2
} /** * 分析1：getPostMessage(r) * 作用：将传入的Runable对象封装成1个消息对象 **/ 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; } // 回到调用原处
/** * 分析2：sendMessageDelayed(msg, 0) * 作用：实际上，从此处开始，则类似方式1 = 将消息入队到消息队列， * 即 最终是调用MessageQueue.enqueueMessage（） **/ public final boolean sendMessageDelayed(Message msg, long delayMillis) { if (delayMillis < 0) { delayMillis = 0; }
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis); // 请看分析3 }
/** * 分析3：sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis) **/ public boolean sendMessageAtTime(Message msg, long uptimeMillis) { // 1\. 获取对应的消息队列对象（MessageQueue） MessageQueue queue = mQueue;
// 2\. 调用了enqueueMessage方法 ->>分析3 return enqueueMessage(queue, msg, uptimeMillis); }
/** * 分析4：enqueueMessage(queue, msg, uptimeMillis) **/ private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) { // 1\. 将msg.target赋值为this // 即 ：把 当前的Handler实例对象作为msg的target属性 msg.target = this; // 请回忆起上面说的Looper的loop()中消息循环时，会从消息队列中取出每个消息msg，然后执行msg.target.dispatchMessage(msg)去处理消息 // 实际上则是将该消息派发给对应的Handler实例
// 2\. 调用消息队列的enqueueMessage（） // 即：Handler发送的消息，最终是保存到消息队列 return queue.enqueueMessage(msg, uptimeMillis）; }
// 注：实际上从分析2开始，源码 与 sendMessage（Message msg）发送方式相同消息对象的创建 = 内部 根据Runnable对象而封装发送到消息队列的逻辑 = 方式1中sendMessage（Message msg）
复制代码
源码总结
工作流程总结
Handler.sendMessage 与 Handler.post 比较
工作流程类似，区别在于 1、Handler.post 不需外部创建消息对象，而是内部根据传入的 Runnable 对象封装消息对象 2、回调的消息处理方法是：复写 Runnable 对象的 run()
（六）内存泄露
6.1）问题描述
Handler 的一般用法 = 新建 Handler 子类（内部类） 、匿名 Handler 内部类
/** * 方式1：新建Handler子类（内部类） */ public class MainActivity extends AppCompatActivity {
public static final String TAG = "carson："; private Handler showhandler;
// 主线程创建时便自动创建Looper & 对应的MessageQueue // 之后执行Loop()进入消息循环 @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main);
//1\. 实例化自定义的Handler类对象->>分析1 //注：此处并无指定Looper，故自动绑定当前线程(主线程)的Looper、MessageQueue showhandler = new FHandler();
// 2\. 启动子线程1 new Thread() { @Override public void run() { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } // a. 定义要发送的消息 Message msg = Message.obtain(); msg.what = 1;// 消息标识 msg.obj = "AA";// 消息存放 // b. 传入主线程的Handler & 向其MessageQueue发送消息 showhandler.sendMessage(msg); } }.start();
// 3\. 启动子线程2 new Thread() { @Override public void run() { try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } // a. 定义要发送的消息 Message msg = Message.obtain(); msg.what = 2;// 消息标识 msg.obj = "BB";// 消息存放 // b. 传入主线程的Handler & 向其MessageQueue发送消息 showhandler.sendMessage(msg); } }.start();
}
// 分析1：自定义Handler子类 class FHandler extends Handler {
// 通过复写handlerMessage() 从而确定更新UI的操作 @Override public void handleMessage(Message msg) { switch (msg.what) { case 1: Log.d(TAG, "收到线程1的消息"); break; case 2: Log.d(TAG, " 收到线程2的消息"); break;
} } } }
/** * 方式2：匿名Handler内部类 */ public class MainActivity extends AppCompatActivity {
public static final String TAG = "carson："; private Handler showhandler;
// 主线程创建时便自动创建Looper & 对应的MessageQueue // 之后执行Loop()进入消息循环 @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main);
//1\. 通过匿名内部类实例化的Handler类对象 //注：此处并无指定Looper，故自动绑定当前线程(主线程)的Looper、MessageQueue showhandler = new Handler(){ // 通过复写handlerMessage()从而确定更新UI的操作 @Override public void handleMessage(Message msg) { switch (msg.what) { case 1: Log.d(TAG, "收到线程1的消息"); break; case 2: Log.d(TAG, " 收到线程2的消息"); break; } } };
// 2\. 启动子线程1 new Thread() { @Override public void run() { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } // a. 定义要发送的消息 Message msg = Message.obtain(); msg.what = 1;// 消息标识 msg.obj = "AA";// 消息存放 // b. 传入主线程的Handler & 向其MessageQueue发送消息 showhandler.sendMessage(msg); } }.start();
// 3\. 启动子线程2 new Thread() { @Override public void run() { try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } // a. 定义要发送的消息 Message msg = Message.obtain(); msg.what = 2;// 消息标识 msg.obj = "BB";// 消息存放 // b. 传入主线程的Handler & 向其MessageQueue发送消息 showhandler.sendMessage(msg); } }.start();
}
复制代码
严重警告:This Handler class should be static or leaks might occur(null)警告原因=该 Handler 类由于没有设置为静态类，可能会导致内存泄露。
6.2）原因讲解
1、储备知识
主线程的 Looper 对象的生命周期 = 该应用程序的生命周期在 Java 中，非静态内部类 & 匿名内部类都默认持有 外部类的引用
2、泄露原因描述
/** * 方式1：新建Handler子类（内部类） */ public class MainActivity extends AppCompatActivity {
public static final String TAG = "carson："; private Handler showhandler;
// 主线程创建时便自动创建Looper & 对应的MessageQueue // 之后执行Loop()进入消息循环 @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main);
//1\. 实例化自定义的Handler类对象->>分析1 //注：此处并无指定Looper，故自动绑定当前线程(主线程)的Looper、MessageQueue showhandler = new FHandler();
// 2\. 启动子线程1 new Thread() { @Override public void run() { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } // a. 定义要发送的消息 Message msg = Message.obtain(); msg.what = 1;// 消息标识 msg.obj = "AA";// 消息存放 // b. 传入主线程的Handler & 向其MessageQueue发送消息 showhandler.sendMessage(msg); } }.start();
// 3\. 启动子线程2 new Thread() { @Override public void run() { try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } // a. 定义要发送的消息 Message msg = Message.obtain(); msg.what = 2;// 消息标识 msg.obj = "BB";// 消息存放 // b. 传入主线程的Handler & 向其MessageQueue发送消息 showhandler.sendMessage(msg); } }.start();
}
// 分析1：自定义Handler子类 class FHandler extends Handler {
// 通过复写handlerMessage() 从而确定更新UI的操作 @Override public void handleMessage(Message msg) { switch (msg.what) { case 1: Log.d(TAG, "收到线程1的消息"); break; case 2: Log.d(TAG, " 收到线程2的消息"); break;
} } } }
/** * 方式2：匿名Handler内部类 */ public class MainActivity extends AppCompatActivity {
public static final String TAG = "carson："; private Handler showhandler;
// 主线程创建时便自动创建Looper & 对应的MessageQueue // 之后执行Loop()进入消息循环 @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main);
//1\. 通过匿名内部类实例化的Handler类对象 //注：此处并无指定Looper，故自动绑定当前线程(主线程)的Looper、MessageQueue showhandler = new Handler(){ // 通过复写handlerMessage()从而确定更新UI的操作 @Override public void handleMessage(Message msg) { switch (msg.what) { case 1: Log.d(TAG, "收到线程1的消息"); break; case 2: Log.d(TAG, " 收到线程2的消息"); break; } } };
// 2\. 启动子线程1 new Thread() { @Override public void run() { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } // a. 定义要发送的消息 Message msg = Message.obtain(); msg.what = 1;// 消息标识 msg.obj = "AA";// 消息存放 // b. 传入主线程的Handler & 向其MessageQueue发送消息 showhandler.sendMessage(msg); } }.start();
// 3\. 启动子线程2 new Thread() { @Override public void run() { try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } // a. 定义要发送的消息 Message msg = Message.obtain(); msg.what = 2;// 消息标识 msg.obj = "BB";// 消息存放 // b. 传入主线程的Handler & 向其MessageQueue发送消息 showhandler.sendMessage(msg); } }.start();
}}
复制代码
从上述示例代码可知：上述的 Handler 实例的消息队列有 2 个分别来自线程 1、2 的消息（分别 为延迟 1s、6s）在 Handler 消息队列 还有未处理的消息 / 正在处理消息时，消息队列中的 Message 持有 Handler 实例的引用由于 Handler = 非静态内部类 / 匿名内部类（2 种使用方式），故又默认持有外部类的引用（即 MainActivity 实例），引用关系如下图
上述的引用关系会一直保持，直到 Handler 消息队列中的所有消息被处理完毕在 Handler 消息队列 还有未处理的消息 / 正在处理消息时，此时若需销毁外部类 MainActivity，但由于上述引用关系，垃圾回收器（GC）无法回收 MainActivity，从而造成内存泄漏。如下图：
3、总结
（1）当 Handler 消息队列 还有未处理的消息 / 正在处理消息时，存在引用关系： “未被处理 / 正处理的消息 -> Handler 实例 -> 外部类”（2）若出现 Handler 的生命周期 > 外部类的生命周期 时（即 Handler 消息队列 还有未处理的消息 / 正在处理消息 而 外部类需销毁时），将使得外部类无法被垃圾回收器（GC）回收，从而造成 内存泄露
6.3）解决方案
从上面可看出，造成内存泄露的原因有 2 个关键条件：1、存在“未被处理 / 正处理的消息 -> Handler 实例 -> 外部类” 的引用关系 2、Handler 的生命周期 > 外部类的生命周期
解决方案 1：静态内部类+弱引用（推荐：保证消息队列中所有消息都能执行）
（1）原理 1、将 Handler 的子类设置成 静态内部类：默认不持有外部类的引用，从而使得 “未被处理 / 正处理的消息 -> Handler 实例 -> 外部类” 的引用关系 的引用关系 不复存在。2、使用 WeakReference 弱引用持有 Activity 实例：弱引用的对象拥有短暂的生命周期。在垃圾回收器线程扫描时，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存（2）解决代码
public class MainActivity extends AppCompatActivity {
public static final String TAG = "carson："; private Handler showhandler;
// 主线程创建时便自动创建Looper & 对应的MessageQueue // 之后执行Loop()进入消息循环 @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main);
//1\. 实例化自定义的Handler类对象->>分析1 //注： // a. 此处并无指定Looper，故自动绑定当前线程(主线程)的Looper、MessageQueue； // b. 定义时需传入持有的Activity实例（弱引用） showhandler = new FHandler(this);
// 2\. 启动子线程1 new Thread() { @Override public void run() { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } // a. 定义要发送的消息 Message msg = Message.obtain(); msg.what = 1;// 消息标识 msg.obj = "AA";// 消息存放 // b. 传入主线程的Handler & 向其MessageQueue发送消息 showhandler.sendMessage(msg); } }.start();
// 3\. 启动子线程2 new Thread() { @Override public void run() { try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } // a. 定义要发送的消息 Message msg = Message.obtain(); msg.what = 2;// 消息标识 msg.obj = "BB";// 消息存放 // b. 传入主线程的Handler & 向其MessageQueue发送消息 showhandler.sendMessage(msg); } }.start();
}
// 分析1：自定义Handler子类 // 设置为：静态内部类 private static class FHandler extends Handler{
// 定义 弱引用实例 private WeakReference<Activity> reference;
// 在构造方法中传入需持有的Activity实例 public FHandler(Activity activity) { // 使用WeakReference弱引用持有Activity实例 reference = new WeakReference<Activity>(activity); }
// 通过复写handlerMessage() 从而确定更新UI的操作 @Override public void handleMessage(Message msg) { switch (msg.what) { case 1: Log.d(TAG, "收到线程1的消息"); break; case 2: Log.d(TAG, " 收到线程2的消息"); break;
} } }}
复制代码
解决方案 2：当外部类结束生命周期时，清空 Handler 内消息队列
（1）原理当 外部类（此处以 Activity 为例） 结束生命周期时（此时系统会调用 onDestroy（）），清除 Handler 消息队列里的所有消息（调用 removeCallbacksAndMessages(null)）不仅使得 “未被处理 / 正处理的消息 -> Handler 实例 -> 外部类” 的引用关系 不复存在，同时 使得 Handler 的生命周期（即 消息存在的时期） 与 外部类的生命周期 同步（2）解决代码
@Override protected void onDestroy() { super.onDestroy(); mHandler.removeCallbacksAndMessages(null); // 外部类Activity生命周期结束时，同时清空消息队列 & 结束Handler生命周期 }
复制代码
（七）线程安全
通过创建一个 Handler 子类的对象，每个 acvivity 只需一个 Handler 对象。后台进程可通过两种方式 Handler 进行通信：message 和 Runnable 对象，其结果实质都是将在 Handler 的队列中放入内容，message 是放置信息，可以传递一些参数，Handler 获取这些信息并将判度如何处理，而 Runnable 则是直接给出处理的方法。队列就是依次执行，Handler 会处理完一个消息或者执行完某个处理在进行下一步，这样不会出现多个线程同时要求进行 UI 处理而引发的混乱现象。这些队列中的内容（无论 Message 还是 Runnable）可以要求马上执行，延迟一定时间执行或者指定某个时刻执行，如果将他们放置在队列头，则表示具有最高有限级别，立即执行。这些函数包括有:sendMessage(), sendMessageAtFrontOfQueue(), sendMessageAtTime(), sendMessageDelayed()以及用于在队列中加入 Runnable 的 post(), postAtFrontOfQueue(), postAtTime(),postDelay()。
最后
为了方便有学习需要的朋友，我把资料都整理成了视频教程（实际上比预期多花了不少精力），由于篇幅有限，都放在了我的 GitHub 上，点击即可免费获取！
Androidndroid架构视频+BAT面试专题PDF+学习笔记
当程序员容易，当一个优秀的程序员是需要不断学习的，从初级程序员到高级程序员，从初级架构师到资深架构师，或者走向管理，从技术经理到技术总监，每个阶段都需要掌握不同的能力。早早确定自己的职业方向，才能在工作和能力提升中甩开同龄人。
当程序员容易，当一个优秀的程序员是需要不断学习的，从初级程序员到高级程序员，从初级架构师到资深架构师，或者走向管理，从技术经理到技术总监，每个阶段都需要掌握不同的能力。早早确定自己的职业方向，才能在工作和能力提升中甩开同龄人。
无论你现在水平怎么样一定要 持续学习 没有鸡汤，别人看起来的毫不费力，其实费了很大力，没有人能随随便便成功。
加油，共勉。
评论