自学编程找工作！我阿里P7了解到的Android面试的一些小内幕！面试心得体会

简介

Jetpack是一套库、工具和指南，可以帮助开发者更轻松地编写优质应用。这些组件可以帮助开发者遵循最佳做法、让开发者摆脱编写样板代码的工作并简化复杂任务，以便开发者将精力集中放在所需的代码上

重要概念

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的操作
@Override
public 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类、实现Runnable
mHandler.sendMessage(msg);

// 步骤5：开启工作线程（同时启动了Handler）
// 多线程可采用AsyncTask、继承Thread类、实现Runnable

方式2：匿名内部类

// 步骤1：在主线程中通过匿名内部类创建Handler类对象
private Handler mhandler = new Handler(){
// 通过复写handlerMessage()从而确定更新UI的操作
@Override
public void handleMessage(Message msg) {
...// 需执行的UI操作
}
};

// 步骤2：创建消息对象
Message msg = Message.obtain(); // 实例化消息对象
msg.what = 1; // 消息标识
msg.obj = "AA"; // 消息内容存放

// 步骤3：在工作线程中通过Handler发送消息到消息队列中
// 多线程可采用AsyncTask、继承Thread类、实现Runnable
mHandler.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() {
@Override
public 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）工作流程图

自学编程找工作！我阿里P7了解到的Android面试的一些小内幕！面试心得体会

4.3）示意图

自学编程找工作！我阿里P7了解到的Android面试的一些小内幕！面试心得体会

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

（1）1个线程（Thread）只能绑定1个循环器（Looper），但可以有多个处理者（2）1个循环器（Looper）可绑定多个处理者（Handler）（3）1个处理者（Handler）只能绑定1个循环器（Looper）自学编程找工作！我阿里P7了解到的Android面试的一些小内幕！面试心得体会

（五）源码分析

5.1）核心类

Handler机制包括3个重要类：1、处理者 Handler2、循环器 Looper3、消息队列 MessageQueue

1、类图

自学编程找工作！我阿里P7了解到的Android面试的一些小内幕！面试心得体会

2、核心方法

自学编程找工作！我阿里P7了解到的Android面试的一些小内幕！面试心得体会

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 派发消息到对应的Handler
msg.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) ->> 分析3
handleMessage(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的操作
@Override
public 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对象操作的线程总结：自学编程找工作！我阿里P7了解到的Android面试的一些小内幕！面试心得体会

步骤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 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()处理消息

源码总结

自学编程找工作！我阿里P7了解到的Android面试的一些小内幕！面试心得体会

工作流程总结

自学编程找工作！我阿里P7了解到的Android面试的一些小内幕！面试心得体会

方式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）

源码总结

自学编程找工作！我阿里P7了解到的Android面试的一些小内幕！面试心得体会

工作流程总结

自学编程找工作！我阿里P7了解到的Android面试的一些小内幕！面试心得体会

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实例），引用关系如下图自学编程找工作！我阿里P7了解到的Android面试的一些小内幕！面试心得体会

上述的引用关系会一直保持，直到Handler消息队列中的所有消息被处理完毕在Handler消息队列还有未处理的消息 / 正在处理消息时，此时若需销毁外部类MainActivity，但由于上述引用关系，垃圾回收器（GC）无法回收MainActivity，从而造成内存泄漏。如下图：自学编程找工作！我阿里P7了解到的Android面试的一些小内幕！面试心得体会

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