【Android】Handler 知识总结：应用场景 / 使用方式 / 工作原理 / 源码分析 / 内存泄漏

🕗 发布于 2024-11-26 14:24 android

1 定义

Handler是一套 Android 消息传递机制 / 异步通信机制

2 作用

在多线程的应用场景中，将工作线程中需更新UI的操作信息传递到 UI主线程，从而实现工作线程对UI的更新处理，最终实现异步消息的处理
请添加图片描述

3 为什么要用 Handler消息传递机制

答：

多个线程并发更新UI
保证线程安全

只能在UI线程（主线程）更新UI
但实际开发过程中，存在工作线程更新UI的需要

可以通过Handler消息传递机制，解决工作线程更新UI的需求

即：工作线程需要更新UI时，通过Handler通知主线程，从而在主线程更新UI操作。

4 关键概念

Handler异步通信机制中的相关概念如下：
Handler、Message、Message Queue、Looper

5 使用方式

Handler的使用方式因 发送消息到消息队列的方式 不同而不同。共分为2种：

方式1：使用Handler.sendMessage（）
方式2：使用Handler.post（）

5.1 步骤描述

5.1.1 方式1：使用Handler.sendMessage()

在该使用方式中，又分为2种：新建Handler子类（内部类）、匿名 Handler子类

但本质相同，即继承了Handler类 & 创建了子类

/** 
  * 方式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

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

5.2 实例

主界面有一个TextView，工作线程发起修改这个TextView中的内容

布局代码：activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:gravity="center"
    tools:context="com.example.carson_ho.handler_learning.MainActivity">

    <TextView
        android:id="@+id/show"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="" />
</RelativeLayout>

5.2.1 使用 Handler.sendMessage（）

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

public class MainActivity extends AppCompatActivity {
    
    public TextView mTextView;
    public Handler mHandler;

    // 步骤1：（自定义）新创建Handler子类(继承Handler类) & 复写handleMessage（）方法
    class Mhandler extends Handler {

        // 通过复写handlerMessage() 从而确定更新UI的操作
        @Override
        public void handleMessage(Message msg) {
            // 根据不同线程发送过来的消息，执行不同的UI操作
            // 根据 Message对象的what属性 标识不同的消息
            switch (msg.what) {
                case 1:
                    mTextView.setText("执行了线程1的UI操作");
                    break;
                case 2:
                    mTextView.setText("执行了线程2的UI操作");
                    break;
            }
        }
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mTextView = (TextView) findViewById(R.id.show);

        // 步骤2：在主线程中创建Handler实例
        mHandler = new Mhandler();
       
        // 采用继承Thread类实现多线程演示
        new Thread() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                 // 步骤3：创建所需的消息对象
                 Message msg = Message.obtain();
                 msg.what = 1; // 消息标识
                 msg.obj = "A"; // 消息内存存放

                 // 步骤4：在工作线程中 通过Handler发送消息到消息队列中
                 mHandler.sendMessage(msg);
            }
        }.start();
        // 步骤5：开启工作线程（同时启动了Handler）

        // 此处用2个工作线程展示
        new Thread() {
            @Override
            public void run() {
                try {
                    Thread.sleep(6000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 通过sendMessage（）发送
                 // a. 定义要发送的消息
                 Message msg = Message.obtain();
                 msg.what = 2; //消息的标识
                 msg.obj = "B"; // 消息的存放
                 // b. 通过Handler发送消息到其绑定的消息队列
                 mHandler.sendMessage(msg);
            }
        }.start();
    }
}

方式2：匿名内部类

public class MainActivity extends AppCompatActivity {
    
    public TextView mTextView;
    public Handler mHandler;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mTextView = (TextView) findViewById(R.id.show);

        // 步骤1：在主线程中 通过匿名内部类 创建Handler类对象
        mHandler = new Handler(){
            // 通过复写handlerMessage()从而确定更新UI的操作
            @Override
            public void handleMessage(Message msg) {
                // 根据不同线程发送过来的消息，执行不同的UI操作
                switch (msg.what) {
                    case 1:
                        mTextView.setText("执行了线程1的UI操作");
                        break;
                    case 2:
                        mTextView.setText("执行了线程2的UI操作");
                        break;
                }
            }
        };
        // 采用继承Thread类实现多线程演示
        new Thread() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                 // 步骤3：创建所需的消息对象
                 Message msg = Message.obtain();
                 msg.what = 1; // 消息标识
                 msg.obj = "A"; // 消息内存存放

                 // 步骤4：在工作线程中 通过Handler发送消息到消息队列中
                 mHandler.sendMessage(msg);
            }
        }.start();
        // 步骤5：开启工作线程（同时启动了Handler）

        // 此处用2个工作线程展示
        new Thread() {
            @Override
            public void run() {
                try {
                    Thread.sleep(6000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 通过sendMessage（）发送
                 // a. 定义要发送的消息
                 Message msg = Message.obtain();
                 msg.what = 2; //消息的标识
                 msg.obj = "B"; // 消息的存放
                 // b. 通过Handler发送消息到其绑定的消息队列
                 mHandler.sendMessage(msg);
            }
        }.start();
    }
}

5.2.2 使用Handler.post()

public class MainActivity extends AppCompatActivity {
    
    public TextView mTextView;
    public Handler mHandler;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mTextView = (TextView) findViewById(R.id.show);

        // 步骤1：在主线程中创建Handler实例
        mHandler = new Handler();

        // 步骤2：在工作线程中 发送消息到消息队列中 & 指定操作UI内容
        new Thread() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 通过psot（）发送，需传入1个Runnable对象
                mHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        // 指定操作UI内容
                        mTextView.setText("执行了线程1的UI操作");
                    }

                });
            }
        }.start();
        // 步骤3：开启工作线程（同时启动了Handler）

        // 此处用2个工作线程展示
        new Thread() {
            @Override
            public void run() {
                try {
                    Thread.sleep(6000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                mHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        mTextView.setText("执行了线程2的UI操作");
                    }

                });
            }
        }.start();
    }
}

以上是关于Handler的异步消息传递机制的使用方法介绍。

6 工作原理

6.1 Handler工作流程

Handler机制的工作流程主要包括4个步骤：

异步通信准备
消息发送
消息循环
消息处理

具体如下图：
在这里插入图片描述

6.2 工作流程图

在这里插入图片描述

6.3 示意图

在这里插入图片描述

6.4 注意事项

线程（Thread）、循环器（Looper）、处理者（Handler）之间的对应关系如下：

1个线程（Thread）只能绑定 1个循环器（Looper），但可以有多个处理者（Handler）
1个循环器（Looper）可绑定多个处理者（Handler）
1个处理者（Handler）只能绑定1个循环器（Looper）

7 源码分析

7.1 Handler机制的核心类

7.1.1 类说明

Handler机制中有3个重要的类：

处理器类（Handler）
消息队列类（MessageQueue）
循环器类（Looper）

7.1.2 类图

在这里插入图片描述

7.1.3 具体介绍

在这里插入图片描述

7.2 源码分析

7.2.1 方式1：使用 Handler.sendMessage（）

使用步骤

/** 
  * 此处以 匿名内部类 的使用方式为例
  */
  // 步骤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

源码分析

步骤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对象时，通过 Handler的构造方法自动关联当前线程的Looper对象 & 对应的消息队列对象（MessageQueue），从而自动绑定了实现Handler对象操作的线程

这里面隐含了一个内容，当前线程的looper对象 & 对应的消息队列对象MessageQueue是什么时候创建的呢？

步骤1前的隐式操作1：创建循环器对象（Looper） & 消息队列对象（MessageQueue）

步骤介绍
源码分析

/** 
  * 源码分析1：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();
    }

/** 
  * 源码分析2：Looper.prepareMainLooper()
  * 作用：为 主线程（UI线程） 创建1个循环器对象（Looper），同时也生成了1个消息队列对象（MessageQueue）
  * 注：该方法在主线程（UI线程）创建时自动调用，即 主线程的Looper对象自动生成，不需手动生成
  */
// 在Android应用进程启动时，会默认创建1个主线程（ActivityThread，也叫UI线程）
// 创建时，会自动调用ActivityThread的1个静态的main（）方法 = 应用程序的入口
// main（）内则会调用Looper.prepareMainLooper()为主线程生成1个Looper对象

  /** 
    * 源码分析：main（）
    **/
    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. 自动开启 消息循环 ->>下面将详细分析

    }

创建主线程时，会自动调用ActivityThread的1个静态的main（）；而main（）内则会调用Looper.prepareMainLooper()为主线程生成1个Looper对象，同时也会生成其对应的MessageQueue对象

即主线程的Looper对象自动生成，不需手动生成；而子线程的Looper对象则需手动通过Looper.prepare()创建
在子线程若不手动创建Looper对象则无法生成Handler对象

根据Handler的作用（在主线程更新UI），故Handler实例的创建场景主要在主线程

生成Looper & MessageQueue对象后，则会自动进入消息循环：Looper.loop（），即又是另外一个隐式操作。

步骤1前的隐式操作2：消息循环
此处主要分析的是Looper类中的loop（）方法

/** 
  * 源码分析： 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() {

    ...// 仅贴出关键代码
    
    int nextPollTimeoutMillis = 0;
    // 该参数用于确定消息队列中是否还有消息
    // 从而决定消息队列应处于消息出队状态 or 等待状态（nextPollTimeoutMillis = -1）

    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) {
            // 还没到处理msg的时候，距离要处理msg还得 nextPollTimeoutMillis 秒
                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实例时复写
   }

总结：

消息循环 = 消息出队 + 分发给对应的Handler实例
分发给对应的Handler的过程：根据出队消息的归属者通过dispatchMessage(msg)进行分发，最终回调复写的handleMessage(Message msg)，从而实现消息处理的操作
特别注意：在进行消息分发时（dispatchMessage(msg)），会进行1次发送方式的判断：

若msg.callback属性不为空，则代表使用了post（Runnable r）发送消息，则直接回调Runnable对象里复写的run（）
若msg.callback属性为空，则代表使用了sendMessage（Message msg）发送消息，则回调复写的handleMessage(msg)

步骤2：创建消息对象

/** 
  * 具体使用
  */
Message msg = Message.obtain(); // 实例化消息对象
    msg.what = 1; // 消息标识
    msg.obj = "AA"; // 消息内容存放

/** 
  * 源码分析：Message.obtain()
  * 作用：创建消息对象
  * 注：创建Message对象可用关键字new 或 Message.obtain()
  */
  public static Message obtain() {

  // Message内部维护了1个Message池，用于Message消息对象的复用
  // 使用obtain（）则是直接从池内获取
        synchronized (sPoolSync) {
            if (sPool != null) {
            // sPool是指向链表头节点的指针，链表里存储的一个个Message，链表就是所谓的池
           // 下列代码是取出链表头结点存储的Message
                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.sendMessage（）的源码解析。总结如下：
在这里插入图片描述

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

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

/** 
  * 具体使用
  */
    private Handler mhandler = new  Handler()；
    // 与方式1的使用不同：此处无复写Handler.handleMessage()
 
/** 
  * 源码分析：Handler的构造方法
  * 作用：
  *     a. 在此之前，主线程创建时隐式创建Looper对象、MessageQueue对象
  *     b. 初始化Handler对象、绑定线程 & 进入消息循环
  * 此处的源码分析类似方式1，此处不作过多描述
  */

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

/** 
  * 具体使用
  * 需传入1个Runnable对象、复写run()从而指定UI操作
  */
mHandler.post(new Runnable() {
        @Override
        public void run() {
            ... // 需执行的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）

下面，我们重新回到步骤1前的隐式操作2：消息循环，即Looper类中的loop（）方法：
可直接看最后的handleCallback()，因为前面和方式1中sendMessage（Message msg）一样。

/** 
  * 源码分析： 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()：取出消息队列里的消息
            // 若取出的消息为空，则线程阻塞

            // 2.2 派发消息到对应的Handler
            msg.target.dispatchMessage(msg);
            // 把消息Message派发给消息对象msg的target属性
            // target属性实际是1个handler对象
            // ->>分析1

        // 3. 释放消息占据的资源
        msg.recycle();
        }
}

/** 
  * 分析1：dispatchMessage(msg)
  * 定义：属于处理者类（Handler）中的方法
  * 作用：派发消息到对应的Handler实例 & 根据传入的msg作出对应的操作
  */
  public void dispatchMessage(Message msg) {

    // 1. 若msg.callback属性不为空，则代表使用了post（Runnable r）发送消息（即此处需讨论的）
    // 则执行handleCallback(msg)，即回调Runnable对象里复写的run（）->> 分析2
        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) 
            handleMessage(msg);

        }
    }

  /** 
    * 分析2：handleCallback(msg)
    **/
    private static void handleCallback(Message message) {
        message.callback.run();
        //  Message对象的callback属性 = 传入的Runnable对象
        // 即回调Runnable对象里复写的run（）
    }

使用 Handler.post（）的工作流程：与方式1（Handler.sendMessage（））类似，区别在于：

不需外部创建消息对象，而是内部根据传入的Runnable对象封装消息对象
回调的消息处理方法是：复写Runnable对象的run（）

具体对比如下：
在这里插入图片描述
至此，关于使用 Handler.post（）的源码解析完毕

8 内存泄漏

8.1 什么是内存泄漏

内存泄漏的定义：

本该被回收的对象不能被回收而停留在堆内存中

内存泄漏出现的原因：
当一个对象已经不再被使用时，本该被回收但却因为有另外一个正在使用的对象持有它的引用从而导致它不能被回收。这就导致了内存泄漏。

8.2 Handler的内存泄漏

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

        }
}

上述例子虽可运行成功，但代码会出现严重警告：
在这里插入图片描述

警告的原因 = 该Handler类由于未设置为静态类，从而导致了内存泄露
最终的内存泄露发生在Handler类的外部类：MainActivity类

8.3 Handler为什么会出现内存泄漏

主线程的Looper对象的生命周期 = 该应用程序的生命周期
在Java中，非静态内部类 & 匿名内部类都默认持有外部类的引用

从上述示例代码可知：

上述的Handler实例的消息队列有2个分别来自线程1、2的消息（分别延迟1s、5s）
在Handler消息队列还有未处理的消息 / 正在处理消息时，消息队列中的Message持有Handler实例的引用
由于Handler = 非静态内部类 / 匿名内部类（2种使用方式），故又默认持有外部类的引用（即MainActivity实例），引用关系如下图：
上述的引用关系会一直保持，直到Handler消息队列中的所有消息被处理完毕。在Handler消息队列还有未处理的消息 / 正在处理消息时，此时若需销毁外部类MainActivity，但由于上述引用关系，垃圾回收器（GC）无法回收MainActivity，从而造成内存泄漏。如下图：

即：
当Handler消息队列还有未处理的消息 / 正在处理消息时，存在引用关系： “未被处理 / 正处理的消息 -> Handler实例 -> 外部类”
若出现 Handler的生命周期 > 外部类的生命周期时（即 Handler消息队列还有未处理的消息 / 正在处理消息而外部类需销毁时），将使得外部类无法被垃圾回收器（GC）回收，从而造成内存泄露

8.4 解决方案

从上面可看出，造成内存泄漏的原因有2个关键条件：

存在 “未被处理 / 正处理的消息 -> Handler实例 -> 外部类” 的引用关系
Handler的生命周期 > 外部类的生命周期

即 Handler消息队列还有未处理的消息 / 正在处理消息而外部类需销毁

8.4.1 解决方案1：静态内部类

原理：静态内部类不默认持有外部类的引用，从而使得 “未被处理 / 正处理的消息 -> Handler实例 -> 外部类” 的引用关系不存在。

具体方案：将Handler的子类设置成静态内部类。此外，还可使用WeakReference弱引用持有外部类，保证外部类能被回收。因为：弱引用的对象拥有短暂的生命周期，在垃圾回收器线程扫描时，一旦发现了具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存

解决代码

public class MainActivity extends AppCompatActivity {

    public static final String TAG = "carson：";//致敬卡神，永远的神！！
    private Handler showhandler;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 实例化自定义的Handler类对象->>分析1
        // 注：
            // a. 此处并无指定Looper，故自动绑定当前线程(主线程)的Looper、MessageQueue；
            // b. 定义时需传入持有的Activity实例（弱引用）
        showhandler = new FHandler(this);

        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";// 消息存放

                showhandler.sendMessage(msg);
            }
        }.start();

    }

    // 设置为：静态内部类
    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;
            }
        }
    }
}

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

原理：不仅使得 “未被处理 / 正处理的消息 -> Handler实例 -> 外部类” 的引用关系不复存在，同时使得 Handler的生命周期（即消息存在的时期）与外部类的生命周期同步

具体方案：当外部类（此处以Activity为例）结束生命周期时（此时系统会调用onDestroy（）），清除 Handler消息队列里的所有消息（调用removeCallbacksAndMessages(null)）

具体代码

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

使用建议
为了保证Handler中消息队列中的所有消息都能被执行，此处推荐使用解决方案1解决内存泄露问题，即 静态内部类 + 弱引用的方式

原文地址：https://blog.csdn.net/qq_30885821/article/details/144027884

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：直播技术-Android基础框架（个人梳理，侵权必究）
下一篇：springboot实战(16)(Validation参数校验冲突问题、分组校验、默认分组)

基于spring boot的医院挂号就诊系统论文
第二点：设计有效的导航，这个包括每个页面上都有导航条的显示，有时也可以在页面的底部设计导航条，当用户进入具体页面时，要设计相应的位置提示，在页面中比较特殊的位置，需要设计返回链接，可以返回上个页面，也
阅读更多2024-11-28
【Unity踩坑】Unity中父对象是非均匀缩放时出现倾斜或剪切现象
本文解决了Unity中父对象是非均匀缩放时出现倾斜或剪切的问题
阅读更多2024-11-28
「Mac玩转仓颉内测版29」基础篇9 - 数组类型详解
本篇将介绍 Cangjie 中的数组类型，包括数组的定义、创建、访问、常见操作以及在数据管理中的应用，帮助开发者熟练掌握数组的使用。
阅读更多2024-11-28
创建mapreduce项目使用maven
创建mapreduce项目使用maven
阅读更多2024-11-28
Python开源项目周排行 2024年第16周
注:当前文章会不定期进行更新。标签： ERP PDF OCR。
阅读更多2024-11-28
使用EFK收集k8s日志
首先我们使用EFK收集Kubernetes集群中的日志，本次实验讲解的是在Kubernetes集群中启动一个Elasticsearch集群，如果企业内已经有了Elasticsearch集群，可以直接将
阅读更多2024-11-28
C#基础41-45
求n以内（不包括n）同时能被3和7整数的所有自然数之和的平方根s，并作为函数值返回，最后结果s输出到控制台。44.数组x中有n个数，求出奇数的个数cn1和偶数的个数cn2以及数组x下标为奇数的元素值的
阅读更多2024-11-28
JavaScript：遍历一个对象数组，获取每个对象中 mainKeyId 对应的值，并以这个值作为新属性的键名，给该对象添加一个新属性。
假设我们有一个对象数组，每个对象包含一个mainKeyId字段，以mainKeyId的值作为新的键名，并给它添加一个新的属性。
阅读更多2024-11-28
【AI系统】谷歌 TPU v4 与光路交换
TPU v4 通过采用 7nm 工艺，翻倍的 MXU 数量，以及显著增加的内存容量和带宽，实现了性能的大幅提升。特别引人注目的是 Sparse Core 的引入，它专门针对稀疏计算进行了优化，使得 T
阅读更多2024-11-28
SpringBoot文件上传之秒传、断点续传、分片上传
比如，在线教育平台上的视频资源上传，社交平台上的图片分享，以及企业内部的知识文档管理等。这些场景对文件上传的要求也各不相同，有的追求速度，有的注重稳定性，还有的需要考虑文件大小和安全性。这对于大文件上
阅读更多2024-11-28

【Android】Handler 知识总结：应用场景 / 使用方式 / 工作原理 / 源码分析 / 内存泄漏

1 定义

2 作用

3 为什么要用 Handler消息传递机制

4 关键概念

5 使用方式

5.1 步骤描述

5.1.1 方式1：使用Handler.sendMessage()

5.1.2 方式2：使用Handler.post（）

5.2 实例

5.2.1 使用 Handler.sendMessage（）

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

方式2：匿名内部类

5.2.2 使用Handler.post()

6 工作原理

6.1 Handler工作流程

6.2 工作流程图

6.3 示意图

6.4 注意事项

7 源码分析

7.1 Handler机制的核心类

7.1.1 类说明

7.1.2 类图

7.1.3 具体介绍

7.2 源码分析

7.2.1 方式1：使用 Handler.sendMessage（）

7.2.2 方式2：使用 Handler.post（）

8 内存泄漏

8.1 什么是内存泄漏

8.2 Handler的内存泄漏

8.3 Handler为什么会出现内存泄漏

8.4 解决方案

8.4.1 解决方案1：静态内部类

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

相关文章