安卓软件开发！你所不知道的Android原生开发的现状，附超全教程文档

前言：

笔者出生在江西一个偏远的山村。虽然出生时已经不是那个温饱都是问题的年代，但是也谈不上有个幸福的童年。家里很穷。幼儿园并没有读，因为家里觉得花那个钱没有必要，小学才开始学拼音字母。我的童年，就是和我的姐姐弟弟在山中的梯田里放牛，抓泥鳅，割鱼草。

大学上的是北大青鸟，一个成人培训机构，没有学历。在深圳打拼了6年了，一直在一些小公司打转。年初疫情突然爆发，市场经济进入寒冬，我也被公司裁员了。

这也让我意识到，本身学历就不高，如果还不发奋让自己的技术更上一个层次的话，肯定是没有未来可言的。幸而有朋友在阿里任职，给了我一个内推的机会。所以，疫情在家的这段时间，我决定逼自己一把，开始着手准备阿里的面试。终于在五一节前拿到了P5的offer。下面是我的面试经验分享。

重要概念

1、主线程（UI线程、MainThread）

当应用程序第一次启动时，会同时自动开启1条主线程，用于处理UI相关的事件（如更新、操作等）

2、子线程（工作线程）

人为手动开启的线程，执行耗时操作（如网络请求、数据加载等）

3、消息（Message）

线程间通讯的数据单元（即Handler接受 & 处理的消息对象），用于存储需要操作的通信信息

4、消息队列（Message Queue）

一种数据结构（先进先出），存储Handler发送过来的消息（Message）

5、处理者（Handler）

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

6、循环器（Looper）

消息队列（Message Queue）与处理者（Handler）的通信媒介，用于消息循环，即
（1）消息获取：循环取出消息队列（Message Queue）的消息（Message）
（2）消息分发：将取出的消息（Message）发送给对应的处理者（Handler）
每个线程只能拥有1个Looper，1个Looper可绑定多个线程的Handler，即多个线程可往1个Looper所持有的MessageQueue中发送消息，提供线程间通信的可能

（三）使用方式

3.1）Handler.sendMessage()

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

  // 步骤1：自定义Handler子类（继承Handler类） & 复写handleMessage（）方法
    class mHandler extends Handler {

        // 通过复写handlerMessage() 从而确定更新UI的操作
        @Override
        public void handleMessage(Message msg) {
         ...// 需执行的UI操作

        }
    }

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

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

    // 步骤4：在工作线程中 通过Handler发送消息到消息队列中
    // 可通过sendMessage（） / post（）
    // 多线程可采用AsyncTask、继承Thread类、实现Runnable
        mHandler.sendMessage(msg);

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

方式2：匿名内部类

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

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

  // 步骤3：在工作线程中 通过Handler发送消息到消息队列中
  // 多线程可采用AsyncTask、继承Thread类、实现Runnable
   mHandler.sendMessage(msg);

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

3.2）Handler.post()

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

    // 步骤2：在工作线程中 发送消息到消息队列中 & 指定操作UI内容
    // 需传入1个Runnable对象
    mHandler.post(new Runnable() {
            @Override
            public void run() {
                ... // 需执行的UI操作 
            }

    });

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

（四）工作原理

4.1）工作流程解析

步骤一：异步通信准备

在主线程中创建
（1）循环器 对象（Looper）
（2）消息队列 对象（Message Queue）
（3）Handler对象
Looper、Message Queue均属于主线程，创建Message Queue后，Looper自动进入消息循环。此时，Handler自动绑定了主线程的Looper、Message Queue

步骤二：消息入队

工作线程通过Handler发送消息（Message）到消息队列（Message Queue）中，该消息内容=工作线程对UI的操作

步骤三：消息循环

消息出队：Looper循环取出消息队列（Message Queue）中的消息（Message）
消息分发：Looper将去除的消息（Message）发送给创建该消息的处理者（Handler）
在消息循环过程中，若消息队列为空，则线程阻塞。

步骤四：消息处理

处理者Handler接受循环器Looper发送过来的消息（Message）
处理者Handler根据消息（Message）进行UI操作

4.2）工作流程图

4.3）示意图

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

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

（五）源码分析

5.1）核心类

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

1、类图

2、核心方法

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
  *