Android Handler使用

Posted 2023-05-05

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Android Handler使用相关的知识，希望对你有一定的参考价值。

参考技术A 在日常开发中，都避免不了进行网络请求，并更新View，由于android中主线程不可以进行耗时操作，所以我们的网络请求只能放在子线程中，又由于在子线程中不能更新UI，所以我们就需要使用Handler切换到主线程并更新UI。

在介绍Handler使用之前，我们先了解以下两个问题。

1、为什么主线程不能进行耗时操作？
因为如果在主线程进行耗时操作，容易出现ANR，Application Not Responding，即应用无响应，当在一定的时间内，app无法响应时就会出现ANR，并弹出一个对话框提示应用无响应，所以我们应该避免在主线程中进行耗时操作，当我们应用出现ANR时，会在
/data/anr/目录中生成traces.txt，我们可以通过这个文件查找错误信息。

2、为什么子线程中不能更新UI？
这是因为在子线程中更新UI不是线程安全的，在Android源码ViewRootImpl的checkThread方法中也对UI做了验证。

基于这两个问题，我们可以使用Handler来解决，接下来介绍Handler的基本使用。

首先创建Handler

接下来发送消息。

这个时候在handlerMessage方法中即可收到消息，获取Message中的数据，并更新UI了。是不是很简单。

Android ：安卓学习笔记之 Handler机制的简单理解和使用

Handler机制

1、Handler使用的引出

有这样一个需求，当打开Activity界面时，开始倒计时，倒计时结束后跳转新的界面（思维活跃的朋友可能立马想到如果打开后自动倒计时，就类似于各个APP的欢迎闪屏页面），如下图：

可能觉得直接开启一个包含倒序循环的子线程就ok了，具体实现如下：
activity_main

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/activity_main2"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context="com.mly.panhouye.handlerdemo.Main2Activity">
    <TextView
        android:gravity="center"
        android:textSize="30sp"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:text="NO DATA"
        android:id="@+id/tv"/>
</LinearLayout>

MainActivity.java

public class Main2Activity extends AppCompatActivity 
    TextView tv;
    @Override
    protected void onCreate(Bundle savedInstanceState) 
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        tv = (TextView) findViewById(R.id.tv);
        new Thread(new Runnable() 
            @Override
            public void run() 
                for (int i=5;i>0;i--)
                    tv.setText(String.valueOf(i));
                    try 
                        Thread.sleep(1000);
                     catch (InterruptedException e) 
                        e.printStackTrace();
                    
                
                //计时结束后跳转到其他界面
                startActivity(new Intent(MainActivity.this,MainActivity1.class));
                //添加finish方法在任务栈中销毁倒计时界面，使新开界面在回退时直接退出而不是再次返回该界面
                finish();
            
        ).start();

但当点进入界面时，会发现程序奔溃了，logcat中错误日志如下（只有UI线程可以更改UI界面）：

由此我们发现在安卓开发中，例如上面的示例，我们常常通过一个线程来完成某些操作，然后同步显示对应的视图控件UI上，通过上面的例子我们也知道了安卓中无法直接通过子线程来进行UI更新操作，对于这种情况，Android提供了一套异步消息处理机制Handler。

2、背景和定义

Handler一套 Android 消息传递机制,主要是子线程UI更细消息传递给主线程，从而主线程更新UI。

Android 主线程的UI，只能主线程更新。如果多个线程都能更新，势必要「加锁」，还不如采用「单线程消息队列机制」
主线程内部维护一个循环。没有消息时候，这个循环是阻塞的。新来消息(或者阻塞timeout)时会唤醒，接着处理新到来消息。

3、作用和意义

在多线程的应用场景中，将工作线程中需更新UI的操作信息传递到 UI主线程，从而实现工作线程对UI的更新处理，最终实现异步消息的处理
多个线程并发更新UI的同时保证线程安全

4、主要参数

使用Handler方式进行异步消息处理主要由Message，Handler，MessageQueue，Looper四部分组成：

（1）Message，线程之间传递的消息，用于不同线程之间的数据交互。Message中的what字段用来标记区分多个消息，arg1、arg2 字段用来传递int类型的数据，obj可以传递任意类型的字段。

（2）Handler，用于发送和处理消息。其中的sendMessage()用来发送消息，handleMessage()用于消息处理，进行相应的UI操作。

（3）MessageQueue，消息队列（先进先出），用于存放Handler发送的消息，一个线程只有一个消息队列。

（4）Looper，可以理解为消息队列的管理者，当发现MessageQueue中存在消息，Looper就会将消息传递到handleMessage()方法中，同样，一个线程只有一个Looper。

5、工作原理及流程

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

1、异步通信准备
2、消息发送
3、消息循环
4、消息处理

工作流程图：

5.1、对应关系

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

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

6、深入分析 Handler机制源码

6.1、Handler机制的核心类

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

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

6.2、核心方法

下面的源码分析将根据 Handler的使用步骤进行

Handler使用方式因发送消息到消息队列的方式不同而不同，共分为2种：使用Handler.sendMessage（）、使用Handler.post（）

6.3、方式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

6.3.1、创建Handler类对象

步骤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对象操作的线程

那么，当前线程的Looper对象 & 对应的消息队列对象（MessageQueue）是什么时候创建的呢？

在上述使用步骤中，并无创建Looper对象 & 对应的消息队列对象（MessageQueue）这1步
。

6.3.1.1、隐式操作1：创建循环器对象& 消息队列对象

创建Looper对象主要通过方法：Looper.prepareMainLooper()、Looper.prepare();
创建消息队列对象(MessageQueue)方法：创建Looper对象时则会自动创建，即：创建循环器对象(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. 自动开启 消息循环 ->>下面将详细分析

总结：

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

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

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

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

6.3.1.2、隐式操作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() 

        ...// 仅贴出关键代码

        // 该参数用于确定消息队列中是否还有消息
        // 从而决定消息队列应处于出队消息状态 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实例时复写