老师讲的真棒!如何在Android-Studio下进行NDK开发,满满干货指导

2021年09月15日 阅读数:2
这篇文章主要向大家介绍老师讲的真棒!如何在Android-Studio下进行NDK开发,满满干货指导,主要内容包括基础应用、实用技巧、原理机制等方面,希望对大家有所帮助。

开头

相信大多数互联网的从业者都有着这样一个梦想:进大厂,得到丰厚的薪酬,和更优秀的人一块儿共事,在技术上得到更快的成长。git

**然而部分人其实一直都陷入了“穷忙”的困局,以为本身天天白天黑夜都在工做,高强度输出,可是却并无得到机会的眷顾。**长此以往,既不知道本身忙什么,也不知道怎么能停下来。程序员

这并非时间的过错,而是由于把解决方式过多押注在技术上,而后继续在工做上不断循环,这样的状态让你极度缺乏另外一个层面的思考。github

如何去打破这种僵局呢?不少人建议多读书,可是从哪一种类型的书开始看又该看谁的书呢?说实话,不少技术书写到最后大同小异。可是万变不离其宗,源代码以及参考手册须要多些钻研,扎根底层是程序员应有的素养。面试

如今互联网讯息如此便捷,学习资料历来不缺。硬盘里都是各类学习资源,上下班坐地铁,还要刷技术视频。可是泛看不如精看、精读。安全

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

须要的**小伙伴私信【学习】**我免费分享给你,之后的路也但愿咱们能一块儿走下去。网络

重要概念

一、主线程(UI线程、MainThread)

当应用程序第一次启动时,会同时自动开启1条主线程,用于处理UI相关的事件(如更新、操做等)数据结构

二、子线程(工做线程)

人为手动开启的线程,执行耗时操做(如网络请求、数据加载等)多线程

三、消息(Message)

线程间通信的数据单元(即Handler接受 & 处理的消息对象),用于存储须要操做的通讯信息异步

四、消息队列(Message Queue)

一种数据结构(先进先出),存储Handler发送过来的消息(Message)

五、处理者(Handler)

Handler为主线程与子线程的通讯媒介,是线程消息的主要处理者。用于添加消息(Message)到消息队列(Message Queue),处理循环器(Looper)分派过来的消息(Message)

六、循环器(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)工做流程图

老师讲的真棒!如何在Android-Studio下进行NDK开发,满满干货指导_Android

4.3)示意图

老师讲的真棒!如何在Android-Studio下进行NDK开发,满满干货指导_Android开发_02

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

(1)1个线程(Thread)只能绑定1个循环器(Looper),但能够有多个处理者
(2)1个循环器(Looper)可绑定多个处理者(Handler)
(3)1个处理者(Handler)只能绑定1个循环器(Looper)
老师讲的真棒!如何在Android-Studio下进行NDK开发,满满干货指导_Android开发_03

(五)源码分析

5.1)核心类

Handler机制包括3个重要类:一、处理者 Handler二、循环器 Looper三、消息队列 MessageQueue

一、类图

老师讲的真棒!如何在Android-Studio下进行NDK开发,满满干货指导_Android开发_04

二、核心方法

老师讲的真棒!如何在Android-Studio下进行NDK开发,满满干货指导_Android开发_05

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对象操做的线程
总结:
老师讲的真棒!如何在Android-Studio下进行NDK开发,满满干货指导_Android_06

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

源码总结

老师讲的真棒!如何在Android-Studio下进行NDK开发,满满干货指导_Android_07

老师讲的真棒!如何在Android-Studio下进行NDK开发,满满干货指导_Android_08

工做流程总结

老师讲的真棒!如何在Android-Studio下进行NDK开发,满满干货指导_Android_09

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

源码总结

老师讲的真棒!如何在Android-Studio下进行NDK开发,满满干货指导_Android_10

老师讲的真棒!如何在Android-Studio下进行NDK开发,满满干货指导_Android_11

工做流程总结

老师讲的真棒!如何在Android-Studio下进行NDK开发,满满干货指导_Android开发_12

Handler.sendMessage与Handler.post比较

工做流程相似,区别在于
一、Handler.post不需外部建立消息对象,而是内部根据传入的Runnable对象封装消息对象
二、回调的消息处理方法是:复写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)缘由讲解

一、储备知识

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

二、泄露缘由描述

   /** 
     * 方式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个分别来自线程一、2的消息(分别 为延迟1s、6s)
在Handler消息队列 还有未处理的消息 / 正在处理消息时,消息队列中的Message持有Handler实例的引用
因为Handler = 非静态内部类 / 匿名内部类(2种使用方式),故又默认持有外部类的引用(即MainActivity实例),引用关系以下图
老师讲的真棒!如何在Android-Studio下进行NDK开发,满满干货指导_Android_13

上述的引用关系会一直保持,直到Handler消息队列中的全部消息被处理完毕
在Handler消息队列 还有未处理的消息 / 正在处理消息时,此时若需销毁外部类MainActivity,但因为上述引用关系,垃圾回收器(GC)没法回收MainActivity,从而形成内存泄漏。以下图:
老师讲的真棒!如何在Android-Studio下进行NDK开发,满满干货指导_Android_14

三、总结

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

6.3)解决方案

从上面可看出,形成内存泄露的缘由有2个关键条件:
一、存在“未被处理 / 正处理的消息 -> Handler实例 -> 外部类” 的引用关系
二、Handler的生命周期 > 外部类的生命周期

解决方案1:静态内部类+弱引用(推荐:保证消息队列中全部消息都能执行)

(1)原理
一、将Handler的子类设置成 静态内部类:默认不持有外部类的引用,从而使得 “未被处理 / 正处理的消息 -> Handler实例 -> 外部类” 的引用关系 的引用关系 不复存在。
二、使用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()。

最后

做为一个有进取心的 Android 开发者,应该拥有本身的技术栈和规划很是重要,技术栈确保你有足够的市场竞争力,从而造成护城河;技术规划则能够给你一个明确的学习目标。卸载抖音、微博、斗鱼、游戏吧,作好规划,共勉!

若是你苦于没有好的时间管理方法,能够点击个人GitHub。这个是我熟悉的一个大佬的工做学习方法实践,推荐给你们

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

最后

做为一个有进取心的 Android 开发者,应该拥有本身的技术栈和规划很是重要,技术栈确保你有足够的市场竞争力,从而造成护城河;技术规划则能够给你一个明确的学习目标。卸载抖音、微博、斗鱼、游戏吧,作好规划,共勉!

若是你苦于没有好的时间管理方法,能够点击个人GitHub。这个是我熟悉的一个大佬的工做学习方法实践,推荐给你们