当前位置：首页 > article >正文

android移动开发基础案例教程答案，渣本毕业两年经验，文末有彩蛋

article 2025/8/25 7:00:43

开篇

说一下我大概的情况。渣本毕业，工作已经有快3年了，从高中就开始玩小破站。无论是学习还是日常放松都是在b站。大学主学的软件技术专业，所以，入职bilibili是我大学时期给自己定的小目标。

在学校，专业学的算中上的水平，课本知识和老师讲的东西基本消化的八九不离十，也自己动手写过属于自己APP，参与过一些社团协会共同开发的项目。

刚毕业时候，b站也有校招，满腔热血的参加了，准备了好久，结果还是没有被录用。当时，挺失落的吧，但是也并没有放弃我进B站工作的梦想。

7月份的时候一位学长知道我非常想进bilibili，特意告诉我B站有内推名额，问我要不要来试一下，我一口直接答应，然后把手里的工作辞掉了，破釜沉舟一把，宅家里半个月复习。将学校所学知识点，以及工作3年的积累经验都系统的归纳整理了起来。再过一篇，然后就是刷面经，面试场景练习等等等。

世间所有的付出终是有回报的，努力的耕耘，也没有被辜负。从离职到入职，一个月时间，顺利的入职了哔哩哔哩，也是要感谢网友们提供的宝贵经验，所以整理了一下，把我的面经整理一下也分享出来给大家。

重要概念

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的操作@Overridepublic void handleMessage(Message msg) {...// 需执行的UI操作}}// 步骤2：在主线程中创建Handler实例private Handler mhandler = new mHandler();// 步骤3：创建所需的消息对象Message msg = Message.obtain(); // 实例化消息对象msg.what = 1; // 消息标识msg.obj = "AA"; // 消息内容存放// 步骤4：在工作线程中 通过Handler发送消息到消息队列中// 可通过sendMessage（） / post（）// 多线程可采用AsyncTask、继承Thread类、实现RunnablemHandler.sendMessage(msg);// 步骤5：开启工作线程（同时启动了Handler）// 多线程可采用AsyncTask、继承Thread类、实现Runnable

方式2：匿名内部类

 // 步骤1：在主线程中 通过匿名内部类 创建Handler类对象private Handler mhandler = new  Handler(){// 通过复写handlerMessage()从而确定更新UI的操作@Overridepublic void handleMessage(Message msg) {...// 需执行的UI操作}};// 步骤2：创建消息对象Message msg = Message.obtain(); // 实例化消息对象msg.what = 1; // 消息标识msg.obj = "AA"; // 消息内容存放// 步骤3：在工作线程中 通过Handler发送消息到消息队列中// 多线程可采用AsyncTask、继承Thread类、实现RunnablemHandler.sendMessage(msg);// 步骤4：开启工作线程（同时启动了Handler）// 多线程可采用AsyncTask、继承Thread类、实现Runnable

3.2）Handler.post()

// 步骤1：在主线程中创建Handler实例private Handler mhandler = new mHandler();// 步骤2：在工作线程中 发送消息到消息队列中 & 指定操作UI内容// 需传入1个Runnable对象mHandler.post(new Runnable() {@Overridepublic void run() {... // 需执行的UI操作 }});// 步骤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(); // 2\. 创建主线程Looper.loop(); // 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线程里的// 源码分析Looper的构造方法->>分析a}/** * 分析a：Looper的构造方法**/private Looper(boolean quitAllowed) {mQueue = new MessageQueue(quitAllowed);// 1\. 创建1个消息队列对象（MessageQueue）// 即 当创建1个Looper实例时，会自动创建一个与之配对的消息队列对象（MessageQueue）mRun = true;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：消息循环

/** * 源码分析： Looper.loop()* 作用：消息循环，即从消息队列中获取消息、分发消息到Handler* 特别注意：*       a. 主线程的消息循环不允许退出，即无限循环*       b. 子线程的消息循环允许退出：调用消息队列MessageQueue的quit（）*/public static void loop() {...// 仅贴出关键代码// 1\. 获取当前Looper的消息队列final Looper me = myLooper();if (me == null) {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）// 2\. 消息循环（通过for循环）for (;;) {// 2.1 从消息队列中取出消息Message msg = queue.next(); if (msg == null) {return;}// next()：取出消息队列里的消息// 若取出的消息为空，则线程阻塞// ->> 分析1 // 2.2 派发消息到对应的Handlermsg.target.dispatchMessage(msg);// 把消息Message派发给消息对象msg的target属性// target属性实际是1个handler对象// ->>分析2// 3\. 释放消息占据的资源msg.recycle();}
}/** * 分析1：queue.next()* 定义：属于消息队列类（MessageQueue）中的方法* 作用：出队消息，即从 消息队列中 移出该消息*/Message next() {...// 仅贴出关键代码// 该参数用于确定消息队列中是否还有消息// 从而决定消息队列应处于出队消息状态 or 等待状态int nextPollTimeoutMillis = 0;for (;;) {if (nextPollTimeoutMillis != 0) {Binder.flushPendingCommands();}// nativePollOnce方法在native层，若是nextPollTimeoutMillis为-1，此时消息队列处于等待状态　nativePollOnce(ptr, nextPollTimeoutMillis);synchronized (this) {final long now = SystemClock.uptimeMillis();Message prevMsg = null;Message msg = mMessages;// 出队消息，即 从消息队列中取出消息：按创建Message对象的时间顺序if (msg != null) {if (now < msg.when) {nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);} else {// 取出了消息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 {// 若 消息队列中已无消息，则将nextPollTimeoutMillis参数设为-1// 下次循环时，消息队列则处于等待状态nextPollTimeoutMillis = -1;}......}.....}
}// 回到分析原处/** * 分析2：dispatchMessage(msg)* 定义：属于处理者类（Handler）中的方法* 作用：派发消息到对应的Handler实例 & 根据传入的msg作出对应的操作*/public void dispatchMessage(Message msg) {// 1\. 若msg.callback属性不为空，则代表使用了post（Runnable r）发送消息// 则执行handleCallback(msg)，即回调Runnable对象里复写的run（）// 上述结论会在讲解使用“post（Runnable r）”方式时讲解if (msg.callback != null) {handleCallback(msg);} else {if (mCallback != null) {if (mCallback.handleMessage(msg)) {return;}}// 2\. 若msg.callback属性为空，则代表使用了sendMessage（Message msg）发送消息（即此处需讨论的）// 则执行handleMessage(msg)，即回调复写的handleMessage(msg) ->> 分析3handleMessage(msg);}}/** * 分析3：handleMessage(msg)* 注：该方法 = 空方法，在创建Handler实例时复写 = 自定义消息处理方式**/public void handleMessage(Message msg) {  ... // 创建Handler实例时复写}

总结：
（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的操作@Overridepublic void handleMessage(Message msg) {...// 需执行的UI操作}};/** * 源码分析：Handler的构造方法* 作用：初始化Handler对象 & 绑定线程* 注：*   a. Handler需绑定 线程才能使用；绑定后，Handler的消息处理会在绑定的线程中执行*   b. 绑定方式 = 先指定Looper对象，从而绑定了 Looper对象所绑定的线程（因为Looper对象本已绑定了对应线程）*   c. 即：指定了Handler对象的 Looper对象 = 绑定到了Looper对象所在的线程*/public Handler() {this(null, false);// ->>分析1}
/** * 分析1：this(null, false) = Handler（null，false）*/public Handler(Callback callback, boolean async) {...// 仅贴出关键代码// 1\. 指定Looper对象mLooper = Looper.myLooper();if (mLooper == null) {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）mQueue = mLooper.mQueue;// 获取该Looper对象中保存的消息队列对象（MessageQueue）// 至此，保证了handler对象 关联上 Looper对象中MessageQueue}

当创建Handler对象时，则通过构造方法自动关联当前线程的Looper对象 & 对应的消息队列对象（MessageQueue），从而自动绑定了实现创建Handler对象操作的线程
总结：
在这里插入图片描述

步骤2：创建消息对象

具体使用

    Message msg = Message.obtain(); // 实例化消息对象msg.what = 1; // 消息标识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 flagsPoolSize--;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方法 ->>分析3return 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发送的消息，最终是保存到消息队列->>分析4return 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() {@Overridepublic 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方法 ->>分析3return 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()进入消息循环@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);//1\. 实例化自定义的Handler类对象->>分析1//注：此处并无指定Looper，故自动绑定当前线程(主线程)的Looper、MessageQueueshowhandler = new FHandler();// 2\. 启动子线程1new Thread() {@Overridepublic 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\. 启动子线程2new Thread() {@Overridepublic 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的操作@Overridepublic 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()进入消息循环@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);//1\. 通过匿名内部类实例化的Handler类对象//注：此处并无指定Looper，故自动绑定当前线程(主线程)的Looper、MessageQueueshowhandler = new  Handler(){// 通过复写handlerMessage()从而确定更新UI的操作@Overridepublic void handleMessage(Message msg) {switch (msg.what) {case 1:Log.d(TAG, "收到线程1的消息");break;case 2:Log.d(TAG, " 收到线程2的消息");break;}}};// 2\. 启动子线程1new Thread() {@Overridepublic 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\. 启动子线程2new Thread() {@Overridepublic 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()进入消息循环@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);//1\. 实例化自定义的Handler类对象->>分析1//注：此处并无指定Looper，故自动绑定当前线程(主线程)的Looper、MessageQueueshowhandler = new FHandler();// 2\. 启动子线程1new Thread() {@Overridepublic 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\. 启动子线程2new Thread() {@Overridepublic 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的操作@Overridepublic 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()进入消息循环@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);//1\. 通过匿名内部类实例化的Handler类对象//注：此处并无指定Looper，故自动绑定当前线程(主线程)的Looper、MessageQueueshowhandler = new  Handler(){// 通过复写handlerMessage()从而确定更新UI的操作@Overridepublic void handleMessage(Message msg) {switch (msg.what) {case 1:Log.d(TAG, "收到线程1的消息");break;case 2:Log.d(TAG, " 收到线程2的消息");break;}}};// 2\. 启动子线程1new Thread() {@Overridepublic 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\. 启动子线程2new Thread() {@Overridepublic 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()进入消息循环@Overrideprotected 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\. 启动子线程1new Thread() {@Overridepublic 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\. 启动子线程2new Thread() {@Overridepublic 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的操作@Overridepublic 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）解决代码

@Overrideprotected 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()。

文末

我总结了一些Android核心知识点，以及一些最新的大厂面试题、知识脑图和视频资料解析。

需要的**小伙伴私信【学习】**我免费分享给你，以后的路也希望我们能一起走下去。（谢谢大家一直以来的支持，需要的自己领取）

扫码添加好友也可以领取哦！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VL7GlsLe-1629340493010)(C:\Users\朱鸿\AppData\Roaming\Typora\typora-user-images\image-20210818144558785.png)]

330页PDF Android学习核心笔记（内含8大板块）

Android学习的系统对应视频

Android进阶的系统对应学习资料

Android BAT大厂面试题（有解析）

消息存在的时期）与外部类的生命周期同步
（2）解决代码

@Overrideprotected void onDestroy() {super.onDestroy();mHandler.removeCallbacksAndMessages(null);// 外部类Activity生命周期结束时，同时清空消息队列 & 结束Handler生命周期}

（七）线程安全

文末

我总结了一些Android核心知识点，以及一些最新的大厂面试题、知识脑图和视频资料解析。

需要的**小伙伴私信【学习】**我免费分享给你，以后的路也希望我们能一起走下去。（谢谢大家一直以来的支持，需要的自己领取）

扫码添加好友也可以领取哦！

[外链图片转存中…(img-VL7GlsLe-1629340493010)]

330页PDF Android学习核心笔记（内含8大板块）

[外链图片转存中…(img-ZLUoXM7T-1629340493011)]

[外链图片转存中…(img-5uFYJhd9-1629340493011)]

Android学习的系统对应视频

[外链图片转存中…(img-XHrMdDn6-1629340493012)]

Android进阶的系统对应学习资料

[外链图片转存中…(img-8DXASAYN-1629340493013)]

Android BAT大厂面试题（有解析）

查看全文

http://www.lryc.cn/news/2418127.html

图片预览参考网址

【Socket】Java Socket编程基础及深入讲解

数字人解决方案——3D数字人从捕捉到建模与合成方法解析

设备管理器里一片空白没有东西解决方法

闪讯无线助手-Android端闪讯破解路由器拨号实现原理

fedora18装一些软件及配置

2024亲测可用最新PHP仿猪八戒任务威客网整站源码/在线接任务网站源码

360浏览器插件360抢票王火车票刷票技巧

为什么南派三叔要封笔？

数据库常见面试题（附答案）

F3arRa1n发布V4.2.1，完整绕过支持iOS14.5.1修复通知

NVIDIA官方中文版GPU编程指南v2.20（转载自GZeasy）

一盒两用！——破解电信IPTV机顶盒为普通安卓机顶盒

佳易王头疗养发护发馆会员管理系统试用版操作教程

Web服务器配置——搭建自己的web服务器，要求可以进行局域网内部的DNS地址解析。

哈大客运专线起终点为现大连站五年左右建成通车

使用阿里云轻量级服务器配置socket代理实现局域网远程访问

x264源代码简单分析：编码器主干部分-2

生物药剂学与药物动力学习题1-15章

PDF转WORD工具破解版

TweenMax学习笔记整理

试图共享文件夹时出现错误,没有启动服务器服务,此时尚未创建共享资源,试图共享时出现错误,没有启动服务器服务,此时尚未创建共享资源...

ENOENT raw.githubusercontent.com pngquant failed to build

MVVM大比拼之avalon.js源码精析

用JSmooth转换可执行jar包为exe文件

java示波器程序_Verilog实现示波器

jsp代码实例第51课

《唐山大地震》高清下载，迅雷下载，在线观看！

推广网站的十八个秘籍

linux 报错: Address already in use的解决方法

开篇

重要概念

1、主线程（UI线程、MainThread）

2、子线程（工作线程）

3、消息（Message）

4、消息队列（Message Queue）

5、处理者（Handler）

6、循环器（Looper）

（三）使用方式

3.1）Handler.sendMessage()

方式1：新建Handler子类（内部类）

方式2：匿名内部类

3.2）Handler.post()

（四）工作原理

4.1）工作流程解析

步骤一：异步通信准备

步骤二：消息入队

步骤三：消息循环

步骤四：消息处理

4.2）工作流程图

4.3）示意图

4.4）线程Thread、循环器Looper、处理者Handler对应关系

（五）源码分析

5.1）核心类

1、类图

2、核心方法

5.2）源码分析

方式1：使用Handler.sendMessage()

准备步骤1：创建循环器对象Looper&消息队列对象MessageQueue

准备步骤2：消息循环

步骤1：在主线程中 通过匿名内部类 创建Handler类对象

步骤2：创建消息对象

步骤3：在工作线程中发送消息到消息队列

源码总结

工作流程总结

方式2：使用 Handler.post()

步骤1：在主线程中创建Handler实例

步骤2：在工作线程中 发送消息到消息队列中

源码总结

工作流程总结

Handler.sendMessage与Handler.post比较

（六）内存泄露

6.1）问题描述

6.2）原因讲解

1、储备知识

2、泄露原因描述

3、总结

6.3）解决方案

解决方案1：静态内部类+弱引用（推荐：保证消息队列中所有消息都能执行）

解决方案2：当外部类结束生命周期时，清空Handler内消息队列

（七）线程安全

文末

扫码添加好友也可以领取哦！

（七）线程安全

文末

扫码添加好友也可以领取哦！

相关文章：

步骤1：在主线程中通过匿名内部类创建Handler类对象

步骤2：在工作线程中发送消息到消息队列中