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

Android Handler机制的简单理解和使用

  • Handler机制
    • 1、Handler使用的引出
    • 2、背景和定义
    • 3、作用和意义
    • 4、主要参数
    • 5、工作原理及流程
      • 5.1、对应关系
    • 6、深入分析 Handler机制源码
      • 6.1、Handler机制的核心类
      • 6.2、核心方法
      • 6.3、方式1:使用 Handler.sendMessage()
        • 6.3.1、 创建Handler类对象
          • 6.3.1.1、隐式操作1:创建循环器对象& 消息队列对象
          • 6.3.1.2、隐式操作2:消息循环
        • 6.3.2、创建消息对象
        • 6.3.3、在工作线程中 发送消息到消息队列中
        • 6.3.4、总结
      • 6.4、方式2:使用Handler.post()
        • 6.4.1、在主线程中创建Handler实例
        • 6.4.2、创建消息对象
        • 6.4.3、在工作线程中 发送消息到消息队列中
        • 6.4.4、总结
        • 6.4.5、Handler.post和Handler.sendMessage的区别
      • 6.5、MessageQueue分析
        • 6.5.1、消息对象Message源码分析
        • 6.5.2、enqueueMessage是如何处理Message
      • 6.6、Looper源码分析
        • 6.6.1、Looper#构造函数原理
        • 6.6.2、Looper.myLooper()原理
        • 6.6.3、Looper.prepare()原理
        • 6.6.4、Looper.loop()原理及总结
      • 6.7、Handler机制的源码总结
    • 7、具体使用案例
      • 7.1、使用 Handler.sendMessage()
        • 7.1.1、方式1:新建Handler子类(内部类)
        • 7.1.2、方式2:匿名内部类
      • 7.2、使用 Handler.post()
  • 参考

Handler机制

1、Handler使用的引出

有这样一个需求,当打开Activity界面时,开始倒计时,倒计时结束后跳转新的界面(思维活跃的朋友可能立马想到如果打开后自动倒计时,就类似于各个APP的欢迎闪屏页面),如下图:
Android :安卓学习笔记之 Handler机制 的简单理解和使用_第1张图片
可能觉得直接开启一个包含倒序循环的子线程就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界面):
Android :安卓学习笔记之 Handler机制 的简单理解和使用_第2张图片
由此我们发现在安卓开发中,例如上面的示例,我们常常通过一个线程来完成某些操作,然后同步显示对应的视图控件UI上,通过上面的例子我们也知道了安卓中无法直接通过子线程来进行UI更新操作,对于这种情况,Android提供了一套异步消息处理机制Handler。

2、背景和定义

Android :安卓学习笔记之 Handler机制 的简单理解和使用_第3张图片
Handler一套 Android 消息传递机制,主要是子线程UI更细消息传递给主线程,从而主线程更新UI。

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

3、作用和意义

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

Android :安卓学习笔记之 Handler机制 的简单理解和使用_第4张图片

4、主要参数

Android :安卓学习笔记之 Handler机制 的简单理解和使用_第5张图片

使用Handler方式进行异步消息处理主要由MessageHandlerMessageQueueLooper四部分组成:

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

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

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

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

Android :安卓学习笔记之 Handler机制 的简单理解和使用_第6张图片

5、工作原理及流程

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

  • 1、异步通信准备
  • 2、消息发送
  • 3、消息循环
  • 4、消息处理
    Android :安卓学习笔记之 Handler机制 的简单理解和使用_第7张图片
    工作流程图:
    Android :安卓学习笔记之 Handler机制 的简单理解和使用_第8张图片

5.1、对应关系

Android :安卓学习笔记之 Handler机制 的简单理解和使用_第9张图片
线程(Thread)、循环器(Looper)、处理者(Handler)之间的对应关系如下:

  • 1个线程(Thread)只能绑定 1个循环器(Looper),但可以有多个处理者(Handler)
  • 1个循环器(Looper) 可绑定多个处理者(Handler)
  • 1个处理者(Handler) 只能绑定1个循环器(Looper)
    Android :安卓学习笔记之 Handler机制 的简单理解和使用_第10张图片

6、深入分析 Handler机制源码

Android :安卓学习笔记之 Handler机制 的简单理解和使用_第11张图片

6.1、Handler机制的核心类

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

  • 处理器 类(Handler)
  • 消息队列 类(MessageQueue)
  • 循环器 类(Looper)
    Android :安卓学习笔记之 Handler机制 的简单理解和使用_第12张图片

6.2、核心方法

Android :安卓学习笔记之 Handler机制 的简单理解和使用_第13张图片

下面的源码分析将根据 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)。
    Android :安卓学习笔记之 Handler机制 的简单理解和使用_第14张图片
/** 
  * 源码分析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实例时复写
   } 

总结:

  • 消息循环的操作 = 消息出队 + 分发给对应的Handler实例
  • 分发给对应的Handler的过程:根据出队消息的归属者通过dispatchMessage(msg)进行分发,最终回调复写的handleMessage(Message msg),从而实现 消息处理 的操作
  • 特别注意:在进行消息分发时(dispatchMessage(msg)),会进行1次发送方式的判断:
    • 1、若msg.callback属性不为空,则代表使用了post(Runnable r)发送消息,则直接回调Runnable对象里复写的run()
    • 2、若msg.callback属性为空,则代表使用了sendMessage(Message msg)发送消息,则回调复写的handleMessage(msg)

图表总结如下:

Android :安卓学习笔记之 Handler机制 的简单理解和使用_第15张图片

6.3.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) {
                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();

    }

6.3.3、在工作线程中 发送消息到消息队列中

多线程的实现方式:AsyncTask、继承Thread类、实现Runnable

/** 
  * 具体使用
  */

    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属性(即本身实例对象) & 将消息入队到绑定线程的消息队列中。具体如下:

在这里插入图片描述

6.3.4、总结

Android :安卓学习笔记之 Handler机制 的简单理解和使用_第16张图片
Android :安卓学习笔记之 Handler机制 的简单理解和使用_第17张图片

6.4、方式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.sendMessage()工作原理相同、源码分析类似,下面将主要讲解不同之处

6.4.1、在主线程中创建Handler实例

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

6.4.2、创建消息对象

消息对象的创建 = 内部 根据Runnable对象而封装

参考下一节(6.4.3)

6.4.3、在工作线程中 发送消息到消息队列中

/** 
 * 具体使用
 * 需传入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()方法

/** 
  * 源码分析: 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()的工作流程与Handler.sendMessage()类似,区别在于:

  • 不需外部创建消息对象,而是内部根据传入的Runnable对象 封装消息对象
  • 回调的消息处理方法是:复写Runnable对象的run()

6.4.4、总结

关于使用 Handler.post()的源码解析完毕,总结如下:
Android :安卓学习笔记之 Handler机制 的简单理解和使用_第18张图片

6.4.5、Handler.post和Handler.sendMessage的区别

Android :安卓学习笔记之 Handler机制 的简单理解和使用_第19张图片

6.5、MessageQueue分析

首先来看看构造函数

MessageQueue(boolean quitAllowed) {
    mQuitAllowed = quitAllowed;
    mPtr = nativeInit();
}

构造函数之上定义了很多native方法

 private native static long nativeInit();
    private native static void nativeDestroy(long ptr);// 阻塞
    private native static void nativeWake(long ptr); // 唤醒
    private native static boolean nativeIsPolling(long ptr);
    private native static void nativeSetFileDescriptorEvents(long ptr, int fd, int events);

native之上定义了几类数据结构,Message、ArrayList、SparseArray、数组

 Message mMessages; // 头结点
    private final ArrayList<IdleHandler> mIdleHandlers = new ArrayList<IdleHandler>();
    private SparseArray<FileDescriptorRecord> mFileDescriptorRecords;
    private IdleHandler[] mPendingIdleHandlers;

6.5.1、消息对象Message源码分析

Message有如下公有属性,供程序员调用:

public int what;//消息标示,
public int arg1; //简单int类型数据
public int arg2;//简单int类型数据
public Object obj;//简单Object类型数据
public Messenger replyTo;//跨进程信使
public int sendingUid = -1;//Messenger消息标示

Message有如下私有属性,用途如下:

/*package*/ static final int FLAG_IN_USE = 1 << 0;//正在使用中
/*package*/ static final int FLAG_ASYNCHRONOUS = 1 << 1;//消息同步标识
/*package*/ static final int FLAGS_TO_CLEAR_ON_COPY_FROM = FLAG_IN_USE;//
/*package*/ int flags;//消息执行标识
/*package*/ long when;//执行时间
/*package*/ Bundle data;//装载的数据
/*package*/ Handler target;//目标载体
/*package*/ Runnable callback;//任务线程
/*package*/ Message next;//消息链表,下一个消息

private static final Object sPoolSync = new Object();//锁对象
private static Message sPool;//消息池
private static int sPoolSize = 0;//消息池大小
private static final int MAX_POOL_SIZE = 50;//消息池最大消息数常量
private static boolean gCheckRecycle = true;//循环检查

Message的源码,我们可以得出如下结论,Message是一种链表结构,每个Message持有以下信息:

  • 1、用于传递的数据,如what、arg1、arg2、obj
  • 2、用于执行当前Message的Handler
  • 3、用于执行当前Message的回调接口CallBack、子线程Runnable
  • 4、当前Message的属性,如延时时间、执行标识、Bundle数据,下一个Message引用。这种结构构成了链表。

6.5.2、enqueueMessage是如何处理Message

Android :安卓学习笔记之 Handler机制 的简单理解和使用_第20张图片

  • 图中 1处会判断如果 Message 中的 target 没有被设置,则直接抛出异常;
  • 图中2和 3 处会按照 Message 的时间 when 来有序得插入 MessageQueue 中,可以看出 MessageQueue实际上是一个链表维护的有序队列,只不过是按照 Message 的执行时间来排序

看到这里,思路似乎终止了,我们跟随Handler、MessQueue的脚步,只看到了Message被插入到MessageQueue的私有队列中。那我们产生的Message什么时候会背消费呢?

接下来我们看看Looper吧!

6.6、Looper源码分析

在任何线程要开启Loop,都要用Looper.prepare()+Looper.looper()的方式。

  • 以APP主进程为例,APP进程启动入口的main方法,也是通过这种方式开启loop的。与子线程细微不同的是,主线程开启looper用的是prepareMainLooper

6.6.1、Looper#构造函数原理

private Looper(boolean quitAllowed) {
    mQueue = new MessageQueue(quitAllowed);
    mThread = Thread.currentThread();
}

Looper构造函数做了两件事情,初始化消息队列MessageQueue对象,记录当前线程信息。

6.6.2、Looper.myLooper()原理

/**
 * Return the Looper object associated with the current thread.  Returns
 * null if the calling thread is not associated with a Looper.
 */
public static @Nullable Looper myLooper() {
    return sThreadLocal.get();
}

可以看到myLooper是从threadLocal中取出Looper对象。在Looper类中定义了如下变量sThreadLocalmQueuesMainLoopermThread

// sThreadLocal.get() will return null unless you've called prepare().
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
private static Looper sMainLooper;  // guarded by Looper.class

final MessageQueue mQueue;
final Thread mThread;

6.6.3、Looper.prepare()原理

private static void prepare(boolean quitAllowed) {
    if (sThreadLocal.get() != null) {
        throw new RuntimeException("Only one Looper may be created per thread");
    }
    sThreadLocal.set(new Looper(quitAllowed));
}

prepare就是 new 出一个 Looper。核心之处在于将 new 出的 Looper 设置到了线程本地变量 sThreadLocal 中。也就是说创建的 Looper 与当前线程发生了绑定。

Looper#prepareMainLooper原理

public static void prepareMainLooper() {
    prepare(false);
    synchronized (Looper.class) {
        if (sMainLooper != null) {
            throw new IllegalStateException("The main Looper has already been prepared.");
        }
        sMainLooper = myLooper();
    }
}

prepareMainLooper只有在APP进程启动的时候有用,并不推荐开发者调用这个函数。

6.6.4、Looper.loop()原理及总结

Android :安卓学习笔记之 Handler机制 的简单理解和使用_第21张图片

  • 1、 取出Looper对象
  • 2 、校验当前线程是否持有Looper,是否启动而来Looper.prepare
  • 3、从Looper中取出对应的MessageQueue主线程Looper就取出主线程的MessageQueue,子线程就取出子线程MessageQueue
  • 4 、从MessageQueue中取出Message
  • 5、Message.target属性,即handler,调用Message绑定好的handler.dispatchMessage,处理消息。

也就是说,Message最终交由与Message绑定的Handler处理。Looper只是负责无限循环+从MessageQueue中读取

6.7、Handler机制的源码总结

Android :安卓学习笔记之 Handler机制 的简单理解和使用_第22张图片
Android :安卓学习笔记之 Handler机制 的简单理解和使用_第23张图片
Android :安卓学习笔记之 Handler机制 的简单理解和使用_第24张图片

7、具体使用案例

1个简单 “更新UI操作” 的案例,主布局文件相同 = 1个用于展示的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>

7.1、使用 Handler.sendMessage()

7.1.1、方式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();

    }
}

实验结果:
Android :安卓学习笔记之 Handler机制 的简单理解和使用_第25张图片

7.1.2、方式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();

    }

}

实验结果
Android :安卓学习笔记之 Handler机制 的简单理解和使用_第26张图片

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

    }

}

实验结果:
Android :安卓学习笔记之 Handler机制 的简单理解和使用_第27张图片

参考

1、Android异步通信:这是一份 全面、详细的Handler机制学习攻略
2、Handler介绍
3、Android百问百答-《那些年被问过的Handler原理》
4、ANDROID中HANDLER使用浅析
5、都 2021 年了,还有人在研究 Handler?
6、Android异步通信:详解 Handler 内存泄露的原因

你可能感兴趣的:(Android,android,java,Handler机制)