Android面试题系列:

Android是一种基于Linux的自由及开放源代码的操作系统，主要使用于移动设备，如智能手机和平板电脑，由Google公司和开放手机联盟领导及开发。这里会不断收集和更新Android基础相关的面试题，目前已收集100题。

1.Android系统的架构

1. Android系统架构之应用程序
   Android会同一系列核心应用程序包一起发布，该应用程序包包括email客户端，SMS短消息程序，日历，地图，浏览器，联系人管理程序等。所有的应用程序都是使用JAVA语言编写的。
2. Android系统架构之应用程序框架
   开发人员可以完全访问核心应用程序所使用的API框架（android.jar）。该应用程序的架构设计简化了组件的重用;任何一个应用程序都可以发布它的功能块并且任何其它的应用程序都可以使用其所发布的功能块。
3. Android系统架构之系统运行库
   Android 包含一些C/C++库，这些库能被Android系统中不同的组件使用。它们通过 Android 应用程序框架为开发者提供服务。
4. Android系统架构之Linux 内核
   Android 的核心系统服务依赖于 Linux 2.6 内核，如安全性，内存管理，进程管理， 网络协议栈和驱动模型。 Linux 内核也同时作为硬件和软件栈之间的抽象层。

2.activity的生命周期

Activity生命周期方法主要有onCreate()、onStart()、onResume()、onPause()、onStop()、onDestroy()和onRestart()等7个方法。

• 启动一个A Activity，分别执行onCreate()、onStart()、onResume()方法。
• 从A Activity打开B Activity分别执行A onPause()、B onCreate()、B onStart()、B onResume()、A onStop()方法。
• 关闭B Activity，分别执行B onPause()、A onRestart()、A onStart()、A onResume()、B onStop()、B onDestroy()方法。
• 横竖屏切换A Activity，清单文件中不设置android:configChanges属性时，先销毁onPause()、onStop()、onDestroy()再重新创建onCreate()、onStart()、onResume()方法，设置orientation|screenSize（一定要同时出现）属性值时，不走生命周期方法，只会执行onConfigurationChanged()方法。
• Activity之间的切换可以看出onPause()、onStop()这两个方法比较特殊，切换的时候onPause()方法不要加入太多耗时操作否则会影响体验。

3.Fragment的生命周期

Fragment的生命周期

Fragment与Activity生命周期对比

Fragment的生命周期方法主要有onAttach()、onCreate()、onCreateView()、onActivityCreated()、onstart()、onResume()、onPause()、onStop()、onDestroyView()、onDestroy()、onDetach()等11个方法。

• 切换到该Fragment，分别执行onAttach()、onCreate()、onCreateView()、onActivityCreated()、onstart()、onResume()方法。
• 锁屏，分别执行onPause()、onStop()方法。
• 亮屏，分别执行onstart()、onResume()方法。
• 覆盖，切换到其他Fragment，分别执行onPause()、onStop()、onDestroyView()方法。
• 从其他Fragment回到之前Fragment，分别执行onCreateView()、onActivityCreated()、onstart()、onResume()方法。

4.Service生命周期

在Service的生命周期里，常用的有：

4个手动调用的方法

startService()    启动服务

stopService()    关闭服务

bindService()    绑定服务

unbindService()    解绑服务 

5个内部自动调用的方法

onCreat()            创建服务

onStartCommand()    开始服务

onDestroy()            销毁服务

onBind()            绑定服务

onUnbind()            解绑服务 

1. 手动调用startService()启动服务，自动调用内部方法：onCreate()、onStartCommand()，如果一个Service被startService()多次启动，那么onCreate()也只会调用一次。
2. 手动调用stopService()关闭服务，自动调用内部方法：onDestory()，如果一个Service被启动且被绑定，如果在没有解绑的前提下使用stopService()关闭服务是无法停止服务的。
3. 手动调用bindService()后，自动调用内部方法：onCreate()、onBind()。
4. 手动调用unbindService()后，自动调用内部方法：onUnbind()、onDestory()。
5. startService()和stopService()只能开启和关闭Service，无法操作Service，调用者退出后Service仍然存在；bindService()和unbindService()可以操作Service，调用者退出后，Service随着调用者销毁。

5.Android中动画

Android中动画分别帧动画、补间动画和属性动画（Android 3.0以后的）

帧动画

帧动画是最容易实现的一种动画，这种动画更多的依赖于完善的UI资源，他的原理就是将一张张单独的图片连贯的进行播放，从而在视觉上产生一种动画的效果；有点类似于某些软件制作gif动画的方式。在有些代码中，我们还会看到android：oneshot="false" ，这个oneshot 的含义就是动画执行一次（true）还是循环执行多次。

补间动画

补间动画又可以分为四种形式，分别是 alpha（淡入淡出），translate（位移），scale（缩放大小），rotate（旋转）。
补间动画的实现，一般会采用xml 文件的形式；代码会更容易书写和阅读，同时也更容易复用。Interpolator 主要作用是可以控制动画的变化速率 ，就是动画进行的快慢节奏。pivot 决定了当前动画执行的参考位置

    

    

    

    

    

        ...

    

 

属性动画

属性动画，顾名思义它是对于对象属性的动画。因此，所有补间动画的内容，都可以通过属性动画实现。属性动画的运行机制是通过不断地对值进行操作来实现的，而初始值和结束值之间的动画过渡就是由ValueAnimator这个类来负责计算的。它的内部使用一种时间循环的机制来计算值与值之间的动画过渡，我们只需要将初始值和结束值提供给ValueAnimator，并且告诉它动画所需运行的时长，那么ValueAnimator就会自动帮我们完成从初始值平滑地过渡到结束值这样的效果。除此之外，ValueAnimator还负责管理动画的播放次数、播放模式、以及对动画设置监听器等。

6.Android中4大组件

1. Activity：Activity是Android程序与用户交互的窗口，是Android构造块中最基本的一种，它需要为保持各界面的状态，做很多持久化的事情，妥善管理生命周期以及一些跳转逻辑。
2. BroadCast Receiver：接受一种或者多种Intent作触发事件，接受相关消息，做一些简单处理，转换成一条Notification，统一了Android的事件广播模型。
3. Content Provider：是Android提供的第三方应用数据的访问方案，可以派生Content Provider类，对外提供数据，可以像数据库一样进行选择排序，屏蔽内部数据的存储细节，向外提供统一的接口模型，大大简化上层应用，对数据的整合提 供了更方便的途径。
4. service：后台服务于Activity，封装有一个完整的功能逻辑实现，接受上层指令，完成相关的事务，定义好需要接受的Intent提供同步和异步的接口。

7.Android中常用布局

常用的布局：

FrameLayout(帧布局):所有东西依次都放在左上角，会重叠

LinearLayout(线性布局):按照水平和垂直进行数据展示

RelativeLayout(相对布局):以某一个元素为参照物，来定位的布局方式 

不常用的布局：

TableLayout(表格布局): 每一个TableLayout里面有表格行TableRow，TableRow里面可以具体定义每一个元素（Android TV上使用）

AbsoluteLayout(绝对布局):用X,Y坐标来指定元素的位置，元素多就不适用。（机顶盒上使用） 

新增布局：

PercentRelativeLayout（百分比相对布局）可以通过百分比控制控件的大小。

PercentFrameLayout（百分比帧布局）可以通过百分比控制控件的大小。 

8.消息推送的方式

• 方案1、使用极光和友盟推送。

• 方案2、使用XMPP协议（Openfire + Spark + Smack）

  • 简介：基于XML协议的通讯协议，前身是Jabber，目前已由IETF国际标准化组织完成了标准化工作。
  • 优点：协议成熟、强大、可扩展性强、目前主要应用于许多聊天系统中，且已有开源的Java版的开发实例androidpn。
    缺点：协议较复杂、冗余（基于XML）、费流量、费电，部署硬件成本高。

• 方案3、使用MQTT协议（更多信息见：mqtt.org/）

  • 简介：轻量级的、基于代理的“发布/订阅”模式的消息传输协议。
  • 优点：协议简洁、小巧、可扩展性强、省流量、省电，目前已经应用到企业领域（参考：mqtt.org/software），且…
  • 缺点：不够成熟、实现较复杂、服务端组件rsmb不开源，部署硬件成本较高。
• 方案4、使用HTTP轮循方式
  • 简介：定时向HTTP服务端接口（Web Service API）获取最新消息。
  • 优点：实现简单、可控性强，部署硬件成本低。
  • 缺点：实时性差。

9.android的数据存储

1. 使用SharedPreferences存储数据；它是Android提供的用来存储一些简单配置信息的一种机制，采用了XML格式将数据存储到设备中。只能在同一个包内使用，不能在不同的包之间使用。
2. 文件存储数据；文件存储方式是一种较常用的方法，在Android中读取/写入文件的方法，与Java中实现I/O的程序是完全一样的，提供了openFileInput()和openFileOutput()方法来读取设备上的文件。
3. SQLite数据库存储数据；SQLite是Android所带的一个标准的数据库，它支持SQL语句，它是一个轻量级的嵌入式数据库。
4. 使用ContentProvider存储数据；主要用于应用程序之间进行数据交换，从而能够让其他的应用保存或读取此Content Provider的各种数据类型。
5. 网络存储数据；通过网络上提供给我们的存储空间来上传(存储)和下载(获取)我们存储在网络空间中的数据信息。

10.Activity启动模式

介绍 Android 启动模式之前，先介绍两个概念task和taskAffinity

• task：翻译过来就是“任务”，是一组相互有关联的 activity 集合，可以理解为 Activity 是在 task 里面活动的。 task 存在于一个称为 back stack 的数据结构中，也就是说， task 是以栈的形式去管理 activity 的，所以也叫可以称为“任务栈”。
• taskAffinity：官方文档解释是："The task that the activity has an affinity for."，可以翻译为 activity 相关或者亲和的任务，这个参数标识了一个 Activity 所需要的任务栈的名字。默认情况下，所有Activity所需的任务栈的名字为应用的包名。 taskAffinity 属性主要和 singleTask 启动模式或者 allowTaskReparenting 属性配对使用。

4种启动模式

1. standard：标准模式，也是系统默认的启动模式。假如 activity A 启动了 activity B ， activity B 则会运行在 activity A 所在的任务栈中。而且每次启动一个 Activity ，都会重新创建新的实例，不管这个实例在任务中是否已经存在。非 Activity 类型的 context （如 ApplicationContext ）启动 standard 模式的 Activity 时会报错。非 Activity 类型的 context 并没有所谓的任务栈，由于上面第 1 点的原因所以系统会报错。此解决办法就是为待启动 Activity 指定 FLAG_ACTIVITY_NEW_TASK 标记位，这样启动的时候系统就会为它创建一个新的任务栈。这个时候待启动 Activity 其实是以 singleTask 模式启动的。
2. singleTop：栈顶复用模式。假如 activity A 启动了 activity B ，就会判断 A 所在的任务栈栈顶是否是 B 的实例。如果是，则不创建新的 activity B 实例而是直接引用这个栈顶实例，同时 onNewIntent 方法会被回调，通过该方法的参数可以取得当前请求的信息；如果不是，则创建新的 activity B 实例。
3. singleTask：栈内复用模式。在第一次启动这个 Activity 时，系统便会创建一个新的任务，并且初始化 Activity 的实例，放在新任务的底部。不过需要满足一定条件的。那就是需要设置 taskAffinity 属性。前面也说过了， taskAffinity 属性是和 singleTask 模式搭配使用的。

1. singleInstance：单实例模式。这个是 singleTask 模式的加强版，它除了具有 singleTask 模式的所有特性外，它还有一点独特的特性，那就是此模式的 Activity 只能单独地位于一个任务栈，不与其他 Activity 共存于同一个任务栈。

练习案例

视差动画 - 雅虎新闻摘要加载

效果展示

前期准备

第一步：准备好颜色数组 res => values => colors.xml

    <color name="orange">#FF9600</color>

    <color name="aqua">#02D1AC</color>

    <color name="yellow">#FFD200</color>

    <color name="bule">#00C6FF</color>

    <color name="green">#00E099</color>

    <color name="pink">#FF3891</color>



    <array name="splash_circle_colors">

        <item>@color/orange</item>

        <item>@color/aqua</item>

        <item>@color/yellow</item>

        <item>@color/bule</item>

        <item>@color/green</item>

        <item>@color/pink</item>

    </array>

自定义 View java代码编写

方法一

关键思想： 属性动画 + 计算圆心

package com.wust.mydialog;



import android.animation.ObjectAnimator;

import android.animation.ValueAnimator;

import android.content.Context;

import android.graphics.Canvas;

import android.graphics.Paint;

import android.util.AttributeSet;

import android.view.View;

import android.view.animation.LinearInterpolator;



import androidx.annotation.Nullable;





/**

 * ClassName: com.wust.mydialog.MyRotateView <br/>

 * Description: <br/>

 * date: 2021/8/7 12:13<br/>

 *

 * @author yiqi<br />

 * @QQ 1820762465

 * @微信 yiqiideallife

 * @技术交流QQ群 928023749

 */

public class MyRotateView extends View {



    //设置旋转间隔时间

    private int SPLASH_CIRCLE_ROTATE_TIME = 3000;

    //设置中心圆半径

    private float CENTER_CIRCLE_RADIUS;

    private float SMALL_CIRCLE_RADIUS;

    private float mCurrentSingle = 0f;

    private int[] mColorArray;

    private Paint mCirclePaint;

    private ValueAnimator va;



    public MyRotateView(Context context) {

        super(context);

    }



    public MyRotateView(Context context, @Nullable AttributeSet attrs) {

        super(context, attrs);

    }



    public MyRotateView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {

        super(context, attrs, defStyleAttr);

    }



    @Override

    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {

        int width = MeasureSpec.getSize(widthMeasureSpec);

        int height = MeasureSpec.getSize(heightMeasureSpec);



        //初始化参数

        initParams(width,height);



        setMeasuredDimension(width,height);

    }



    private void initParams(int w, int h) {

        //设置中心圆半径

        CENTER_CIRCLE_RADIUS = 1/4.0f * w;

        //设置小圆的半径

        SMALL_CIRCLE_RADIUS = 1/25.0f * w;

        //获取小球颜色

        mColorArray = getResources().getIntArray(R.array.splash_circle_colors);

        //初始化画笔

        mCirclePaint = new Paint();

        mCirclePaint.setDither(true);

        mCirclePaint.setAntiAlias(true);



    }



    @Override

    protected void onDraw(Canvas canvas) {

        super.onDraw(canvas);

        //绘制圆

        drawSplashCircle(canvas);

    }



    private void drawSplashCircle(Canvas canvas) {

        //设置属性动画，让小圆转起来

        //这里得注意，是个坑，你如果不判断那球就不会动 因为会陷入死循环 值动画将值设置为0 -> invalidate()重绘 -> 执行draw 又将值设为0

        if (va == null){

            va = ObjectAnimator.ofFloat(0f, 2 * (float) Math.PI);

            va.setDuration(SPLASH_CIRCLE_ROTATE_TIME);

            va.setRepeatCount(ValueAnimator.INFINITE);

            va.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {

                @Override

                public void onAnimationUpdate(ValueAnimator animation) {

                    mCurrentSingle = (float) animation.getAnimatedValue();

//                    System.out.println("mCurrentSingle ->" + mCurrentSingle);

                    invalidate();

                }

            });

            va.setInterpolator(new LinearInterpolator());

            va.start();

        }



        //计算每个小球的间隔

        double spaceAngle = Math.PI*2/mColorArray.length;



        for (int i = 0; i < mColorArray.length; i++) {

            //为 每个球 画笔 设置颜色

            mCirclePaint.setColor(mColorArray[i]);



            //利用 勾股定理 计算 小圆 中心点

            float cx = getWidth()/2 + (float) (CENTER_CIRCLE_RADIUS*Math.cos(spaceAngle*i+mCurrentSingle));

            float cy = getHeight()/2 + (float) (CENTER_CIRCLE_RADIUS*Math.sin(spaceAngle*i+mCurrentSingle));



            canvas.drawCircle(cx,cy,SMALL_CIRCLE_RADIUS,mCirclePaint);

        }

    }

}

方法二

关键思想：旋转画布法

package com.wust.mydialog;



import android.animation.ObjectAnimator;

import android.animation.ValueAnimator;

import android.content.Context;

import android.graphics.Canvas;

import android.graphics.Paint;

import android.util.AttributeSet;

import android.view.View;

import android.view.animation.LinearInterpolator;



import androidx.annotation.Nullable;





/**

 * ClassName: com.wust.mydialog.MyRotateView <br/>

 * Description: <br/>

 * date: 2021/8/7 12:13<br/>

 *

 * @author yiqi<br />

 * @QQ 1820762465

 * @微信 yiqiideallife

 * @技术交流QQ群 928023749

 */

public class MyRotateView extends View {



    //设置旋转间隔时间

    private int SPLASH_CIRCLE_ROTATE_TIME = 3000;

    //设置中心圆半径

    private float CENTER_CIRCLE_RADIUS;

    private float SMALL_CIRCLE_RADIUS;

    private float mCurrentSingle = 0f;

    private int[] mColorArray;

    private Paint mCirclePaint;

    private ValueAnimator va;



    public MyRotateView(Context context) {

        super(context);

    }



    public MyRotateView(Context context, @Nullable AttributeSet attrs) {

        super(context, attrs);

    }



    public MyRotateView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {

        super(context, attrs, defStyleAttr);

    }



    @Override

    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {

        int width = MeasureSpec.getSize(widthMeasureSpec);

        int height = MeasureSpec.getSize(heightMeasureSpec);



        //初始化参数

        initParams(width,height);



        setMeasuredDimension(width,height);

    }



    private void initParams(int w, int h) {

        //设置中心圆半径

        CENTER_CIRCLE_RADIUS = 1/4.0f * w;

        //设置小圆的半径

        SMALL_CIRCLE_RADIUS = 1/25.0f * w;

        //获取小球颜色

        mColorArray = getResources().getIntArray(R.array.splash_circle_colors);

        //初始化画笔

        mCirclePaint = new Paint();

        mCirclePaint.setDither(true);

        mCirclePaint.setAntiAlias(true);



    }



    @Override

    protected void onDraw(Canvas canvas) {

        super.onDraw(canvas);

        //绘制圆

        drawSplashCircle(canvas);

    }



    private void drawSplashCircle(Canvas canvas) {

        //设置属性动画，让小圆转起来

        //这里得注意，是个坑，你如果不判断那球就不会动 因为会陷入死循环 值动画将值设置为0 -> invalidate()重绘 -> 执行draw 又将值设为0

        if (va == null){

//            va = ObjectAnimator.ofFloat(0f, 2 * (float) Math.PI);

            va = ObjectAnimator.ofFloat(0f, 360.0f);

            va.setDuration(SPLASH_CIRCLE_ROTATE_TIME);

            va.setRepeatCount(ValueAnimator.INFINITE);

            va.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {

                @Override

                public void onAnimationUpdate(ValueAnimator animation) {

                    mCurrentSingle = (float) animation.getAnimatedValue();

//                    System.out.println("mCurrentSingle ->" + mCurrentSingle);

                    invalidate();

                }

            });

            va.setInterpolator(new LinearInterpolator());

            va.start();

        }



        //计算每个小球的间隔

//        double spaceAngle = Math.PI*2/mColorArray.length;

        double spaceAngle = 360.0d/mColorArray.length;

        System.out.println("spaceAngle -> " + spaceAngle);



        //利用旋转画布法

        canvas.save();

        canvas.rotate(mCurrentSingle,getWidth()/2,getHeight()/2);

        for (int i = 0; i < mColorArray.length; i++) {

            canvas.rotate((float) spaceAngle,getWidth()/2,getHeight()/2);

            //为 每个球 画笔 设置颜色

            mCirclePaint.setColor(mColorArray[i]);



            //利用 勾股定理 计算 小圆 中心点

            //float cx = getWidth()/2 + (float) (CENTER_CIRCLE_RADIUS*Math.cos(spaceAngle*i+mCurrentSingle));

            //float cy = getHeight()/2 + (float) (CENTER_CIRCLE_RADIUS*Math.sin(spaceAngle*i+mCurrentSingle));



            //利用旋转画布法

            float cx = getWidth()/2 + CENTER_CIRCLE_RADIUS;

            float cy = getHeight()/2;



            canvas.drawCircle(cx,cy,SMALL_CIRCLE_RADIUS,mCirclePaint);

        }

        canvas.restore();

    }

}

易错点总结： 

1、canvas.rotate(mCurrentSingle,getWidth()/2,getHeight()/2);中 第一个参数传的是角度（360度的那种），而 Math.cos();中 参数传的是一个弧度（2π的那种）

2、canvas.rotate() 函数执行之后对后续画布上的操作都是有影响的，所以，得配合 canvas.save();和 canvas.restore();使用。因此，里面的canvas.rotate((float) spaceAngle,getWidth()/2,getHeight()/2);中spaceAngle不能乘 i 。

3、画布的旋转除了 canvas.rotate() 函数 可以实现外，还可以利用矩阵。代码如下：

//创建矩阵

private Matrix mSpaceMatrix;

//初始化旋转矩阵

mSpaceMatrix = new Matrix();

//初始化旋转矩阵

mSpaceMatrix.reset();

mSpaceMatrix.postRotate((float) spaceAngle,getWidth()/2,getHeight()/2);

//画布旋转角度

canvas.concat(mSpaceMatrix);

完整代码

package com.wust.mydialog;



import android.animation.ObjectAnimator;

import android.animation.ValueAnimator;

import android.content.Context;

import android.graphics.Canvas;

import android.graphics.Matrix;

import android.graphics.Paint;

import android.util.AttributeSet;

import android.view.View;

import android.view.animation.LinearInterpolator;



import androidx.annotation.Nullable;





/**

 * ClassName: com.wust.mydialog.MyRotateView <br/>

 * Description: <br/>

 * date: 2021/8/7 12:13<br/>

 *

 * @author yiqi<br />

 * @QQ 1820762465

 * @微信 yiqiideallife

 * @技术交流QQ群 928023749

 */

public class MyRotateView extends View {



    //设置旋转间隔时间

    private int SPLASH_CIRCLE_ROTATE_TIME = 3000;

    //设置中心圆半径

    private float CENTER_CIRCLE_RADIUS;

    private float SMALL_CIRCLE_RADIUS;

    private float mCurrentSingle = 0f;

    private int[] mColorArray;

    private Paint mCirclePaint;

    private ValueAnimator va;

    private Matrix mSpaceMatrix;



    public MyRotateView(Context context) {

        super(context);

    }



    public MyRotateView(Context context, @Nullable AttributeSet attrs) {

        super(context, attrs);

    }



    public MyRotateView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {

        super(context, attrs, defStyleAttr);

    }



    @Override

    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {

        int width = MeasureSpec.getSize(widthMeasureSpec);

        int height = MeasureSpec.getSize(heightMeasureSpec);



        //初始化参数

        initParams(width,height);



        setMeasuredDimension(width,height);

    }



    private void initParams(int w, int h) {

        //设置中心圆半径

        CENTER_CIRCLE_RADIUS = 1/4.0f * w;

        //设置小圆的半径

        SMALL_CIRCLE_RADIUS = 1/25.0f * w;

        //获取小球颜色

        mColorArray = getResources().getIntArray(R.array.splash_circle_colors);

        //初始化画笔

        mCirclePaint = new Paint();

        mCirclePaint.setDither(true);

        mCirclePaint.setAntiAlias(true);

        //初始化旋转矩阵

        mSpaceMatrix = new Matrix();

    }



    @Override

    protected void onDraw(Canvas canvas) {

        super.onDraw(canvas);

        //绘制圆

        drawSplashCircle(canvas);

    }



    private void drawSplashCircle(Canvas canvas) {

        //设置属性动画，让小圆转起来

        //这里得注意，是个坑，你如果不判断那球就不会动 因为会陷入死循环 值动画将值设置为0 -> invalidate()重绘 -> 执行draw 又将值设为0

        if (va == null){

//            va = ObjectAnimator.ofFloat(0f, 2 * (float) Math.PI);

            va = ObjectAnimator.ofFloat(0f, 360.0f);

            va.setDuration(SPLASH_CIRCLE_ROTATE_TIME);

            va.setRepeatCount(ValueAnimator.INFINITE);

            va.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {

                @Override

                public void onAnimationUpdate(ValueAnimator animation) {

                    mCurrentSingle = (float) animation.getAnimatedValue();

//                    System.out.println("mCurrentSingle ->" + mCurrentSingle);

                    invalidate();

                }

            });

            va.setInterpolator(new LinearInterpolator());

            va.start();

        }



        //计算每个小球的间隔

//        double spaceAngle = Math.PI*2/mColorArray.length;

        double spaceAngle = 360.0d/mColorArray.length;

        //初始化旋转矩阵

        mSpaceMatrix.reset();

        mSpaceMatrix.postRotate((float) spaceAngle,getWidth()/2,getHeight()/2);





        //利用旋转画布法

        canvas.save();

        canvas.rotate(mCurrentSingle,getWidth()/2,getHeight()/2);

        for (int i = 0; i < mColorArray.length; i++) {

//            canvas.rotate((float) spaceAngle,getWidth()/2,getHeight()/2);

//        System.out.println("spaceAngle -> " + spaceAngle);

            canvas.concat(mSpaceMatrix);

            //为 每个球 画笔 设置颜色

            mCirclePaint.setColor(mColorArray[i]);



            //利用 勾股定理 计算 小圆 中心点

            //float cx = getWidth()/2 + (float) (CENTER_CIRCLE_RADIUS*Math.cos(spaceAngle*i+mCurrentSingle));

            //float cy = getHeight()/2 + (float) (CENTER_CIRCLE_RADIUS*Math.sin(spaceAngle*i+mCurrentSingle));



            //利用旋转画布法

            float cx = getWidth()/2 + CENTER_CIRCLE_RADIUS;

            float cy = getHeight()/2;



            canvas.drawCircle(cx,cy,SMALL_CIRCLE_RADIUS,mCirclePaint);

        }

        canvas.restore();

    }

}

注意事项：

1、canvas.concat(mSpaceMatrix);对画布的操作也会对后面进行影响

2、Android中Matrix的set、pre、post的区别

说set、pre、post的区别之前，先说说Matrix。

Matrix包含一个3 X 3的矩阵，专门用于图像变换匹配。

Matrix提供了四种操作：

• translate(平移)


• rotate(旋转)


• scale(缩放)


• skew(倾斜)

也就是说这4种操作都是对这个3 X 3的矩阵设值来达到变换的效果。

Matrix没有结构体，它必须被初始化，通过reset或set方法。

OK，Matrix介绍完了，我们来看看set、pre、post的区别。

pre是在队列最前面插入，post是在队列最后面追加，而set先清空队列在添加（这也是上文提到的“Matrix没有结构体，它必须被初始化，通过reset或set方法”的原因）。

下面通过一些例子具体说明：

1. matrix.preScale(2f,1f);    


2. matrix.preTranslate(5f, 0f);   


3. matrix.postScale(0.2f, 1f);    


4. matrix.postTranslate(0.5f, 0f);  

执行顺序：translate(5, 0) -> scale(2f, 1f) -> scale(0.2f, 1f) -> translate(0.5f, 0f)

1. matrix.postTranslate(2f, 0f);   


2. matrix.preScale(0.2f, 1f);     


3. matrix.setScale(1f, 1f);   


4. matrix.postScale(5f, 1f);   


5. matrix.preTranslate(0.5f, 0f);   

执行顺序：translate(0.5f, 0f) -> scale(1f, 1f) ->  scale(5f, 1)

志在巅峰的攀登者，不会陶醉在沿途的某个脚印之中，在码农的世界里，优美的应用体验，来源于程序员对细节的处理以及自我要求的境界，年轻人也是忙忙碌碌的码农中一员，每天、每周，都会留下一些脚印，就是这些创作的内容，有一种执着，就是不知为什么，如果你迷茫，不妨来瞅瞅码农的轨迹。

在 Flutter 中 ，AnimatedList 、ListView 、SliverListView 、SliverAnimatedList 用来显示列表数据样式，一般情况下 使用 ListView 就可实现大部分业务需求，AnimatedList 的特点是可以在插入数据与移除数据的时候添加动画效果

本文章实现的效果是

AnimatedList 简述

  const AnimatedList({

    Key? key,

    required this.itemBuilder,

    this.initialItemCount = 0,

    this.scrollDirection = Axis.vertical,

    this.reverse = false,

    this.controller,

    this.primary,

    this.physics,

    this.shrinkWrap = false,

    this.padding,

    this.clipBehavior = Clip.hardEdge,

  })

• itemBuilder 子 Item UI布局构建


• initialItemCount 列表显示的条目 个数


• scrollDirection 滑动方向


• reverse scrollDirection 为 Axis.vertical 时，如果 reverse 为ture ，那么列表内容会自动滑动到底部


• controller 滑动控制器


• physics 滑动效果控制 ，BouncingScrollPhysics 是列表滑动 iOS 的回弹效果；AlwaysScrollableScrollPhysics 是 列表滑动 Android 的水波纹回弹效果；ClampingScrollPhysics 普通的滑动效果；


• shrinkWrap 为true的时候 AnimatedList 会包裹所有的子Item

本实例 Demo

首先是我初始化了点数据‘

  List<String> _list = [];



  GlobalKey<AnimatedListState> _globalKey = new GlobalKey();



  @override

  void initState() {

    super.initState();

    for (int i = 0; i < 10; i++) {

      _list.add("早起的年轻人 $i");

    }

  }

然后就是 AnimatedList 的使用如下：

  AnimatedList buildAnimatedList() {

    return AnimatedList(

      //关键key

      key: _globalKey,

      //列表个数

      initialItemCount: _list.length,

      //每个子Item

      itemBuilder:

          (BuildContext context, int index, Animation<double> animation) {

        return buildSizeTransition(animation, index);

      },

    );

  }

然后列表中的每个 Item 的 UI 布局构建如下

 SizeTransition buildSizeTransition(Animation<double> animation, int index) {

    //来个动画

    return SizeTransition(

      //动画构建

      sizeFactor: animation,

      //子UI

      child: SizedBox(

        height: 80.0,

        child: Card(

          color: Colors.primaries[index % Colors.primaries.length],

          child: Center(

            child: Text(

              'Item $index ${_list[index]}',

            ),

          ),

        ),

      ),

    );

  }

然后我们插入一条数据

//插入源数据

   _list.insert(0, "插入数据 ${DateTime.now()}");

   //插入动画效果

   _globalKey.currentState.insertItem(

     0,//插入的位置 

     duration: Duration(milliseconds: 400),

   );

 },

然后移除一条数据

 //移除源数据

 _list.removeAt(0);

 //移除动画效果

 _globalKey.currentState.removeItem(

   0,

   (BuildContext context, Animation<double> animation) {

     return buildSizeTransition(animation, 0);

   },

 );

前言

        起因：项目使用的一直是multidex:1.0.3版本就想着版本低了要不要升级一下。惊喜就这么来了。

65536

        当你的应用及其引用的库超过 65,536 个方法时，你会遇到构建错误，表明你的应用已达到 Android 构建架构的限制：

trouble writing output:

Too many field references: 131000; max is 65536.

You may try using --multi-dex option.

        旧版本的构建系统报告了不同的错误，这表明存在相同的问题：

Conversion to Dalvik format failed:

Unable to execute dex: method ID not in [0, 0xffff]: 65536

        这两种错误情况都显示一个共同的数字：65536。这个数字表示单个 Dalvik 可执行文件 (DEX) 字节码文件中的代码可以调用的引用总数。本问介绍了如何通过启用称为multidex的应用程序配置来克服此限制，该配置允许你的应用程序构建和读取多个 DEX 文件。

关于 64K 参考限制

        Android 应用 APK 文件包含 Dalvik 可执行文件 DEX 文件形式的可执行字节码文件，其中包含用于运行应用的编译代码。Dalvik Executable 规范将单个 DEX 文件中可以引用的方法总数限制为 65,536，包括 Android 框架方法、库方法和你自己代码中的方法。在计算机科学的上下文中，术语Kilo, K表示 1024（或 2^10）。由于 65,536 等于 64 X 1024，因此此限制称为64K 参考限制。

解决64K限制

对 Android 5.0 及更高版本的 Multidex 支持

        Android 5.0（API 级别 21）及更高版本使用称为 ART 的运行时，该运行时本机支持从 APK 文件加载多个 DEX 文件。 ART 在应用安装时执行预编译，它会扫描 classesN.dex 文件并将它们编译成单个 .oat 文件以供 Android 设备执行。 因此，如果你的 minSdkVersion 为 21 或更高，则默认启用 multidex，并且你不需要 multidex 库。

注意： 当使用 Android Studio 运行你的应用程序时，构建会针对你部署到的目标设备进行优化。 这包括在目标设备运行 Android 5.0 及更高版本时启用 multidex。 由于此优化仅在使用 Android Studio 部署应用程序时应用，因此你可能仍需要为 multidex 配置发布版本以避免 64K 限制。

        看到没，这里最好的解决办法就是设置minSdkVersion设置为 21 或更高。这样网上的一些什么

• multidex你遇到的坑




• multidex与你不得不说的秘密




• multidex原理及实现就和你没得关系了，当然你想了解也可以。

        Android SDK 为 21 或更高的问题解决了，那Android SDK 低于 21 的呢。咱接着往下看喽。

Android 5.0 之前的 Multidex 支持

为你的应用程序配置 multidex

        如果你的 minSdkVersion 设置为 21 或更高，则默认启用 multidex，你不需要 multidex 库。

        但是，如果你的 minSdkVersion 设置为 20 或更低，那么你必须使用 multidex 库并对你的应用项目进行以下修改：

1.修改模块级 build.gradle 文件以启用 multidex 并添加 multidex 库作为依赖项，如下所示：

• 使用AndroidX

android {

    defaultConfig {

        ...

        minSdkVersion 15 

        targetSdkVersion 30

        multiDexEnabled true

    }

    ...

}



dependencies {

    implementation "androidx.multidex:multidex:2.0.1"

}

• 不使用AndroidX(已弃用)

android {

    defaultConfig {

        ...

        minSdkVersion 15 

        targetSdkVersion 30

        multiDexEnabled true

    }

    ...

}



dependencies {

    implementation 'com.android.support:multidex:1.0.3'

}

2.根据你是否覆盖 Application 类，执行以下操作之一：

• 如果你不覆盖 Application 类，请编辑你的清单文件以在 < application > 标记中设置 android:name，如下所示：

<?xml version="1.0" encoding="utf-8"?>

<manifest xmlns:android="http://schemas.android.com/apk/res/android"

    package="com.scc.demo">

    <application

            android:name="androidx.multidex.MultiDexApplication" >

        ...

    </application>

</manifest>

• 如果你确实覆盖了 Application 类，请将其更改为扩展 MultiDexApplication(非必须)，如下所示：

public class MyApplication extends MultiDexApplication { ... }

• 或者，如果你确实覆盖了 Application 类但无法更改基类，那么你可以覆盖 attachBaseContext() 方法和 callMultiDex.install(this) 以启用 multidex：

public class MyApp extends Application {

  @Override

  protected void attachBaseContext(Context base) {

     super.attachBaseContext(base);

     MultiDex.install(this);

  }

}

 

注意： 在 MultiDex.install() 完成之前，不要通过反射或 JNI 执行 MultiDex.install() 或任何其他代码。 Multidex 跟踪不会跟随这些调用，导致 ClassNotFoundException 或由于 DEX 文件之间的类分区错误而导致验证错误。

        现在，当你构建应用程序时，Android 构建工具会根据需要构建一个主要的 DEX 文件 (classes.dex) 和支持的 DEX 文件（classes2.dex、classes3.dex 等）。构建系统然后将所有 DEX 文件打包到你的 APK 中。

        在运行时，multidex API 使用特殊的类加载器来搜索所有可用的 DEX 文件以查找你的方法（而不是仅在主 classes.dex 文件中搜索）。

multidex 库的限制

        multidex 库有一些已知的限制，当你将其合并到应用程序构建配置中时，你应该注意并测试这些限制：

• 在启动期间将 DEX 文件安装到设备的数据分区上很复杂，如果辅助 DEX 文件很大，可能会导致应用程序无响应 (ANR) 错误。为避免此问题，请启用代码收缩以最小化 DEX 文件的大小并删除未使用的代码部分。




• 在 Android 5.0（API 级别 21）之前的版本上运行时，使用 multidex 不足以解决 linearalloc 限制（问题 78035）。此限制在 Android 4.0（API 级别 14）中有所增加，但这并没有完全解决。在低于 Android 4.0 的版本上，你可能会在达到 DEX 索引限制之前达到线性分配限制。因此，如果你的目标 API 级别低于 14，请在平台的这些版本上进行彻底测试*，因为你的应用程序可能在启动时或加载特定类组时出现问题。

        代码缩减可以减少或可能消除这些问题。

在主 DEX 文件中声明所需的类

        如果你收到 java.lang.NoClassDefFoundError，那么你必须通过在构建类型中使用 multiDexKeepFile 或 multiDexKeepProguard 属性声明它们，根据主 DEX 文件中的要求手动指定这些附加类。 如果某个类在 multiDexKeepFile 或 multiDexKeepProguard 文件中匹配，则该类将添加到主 DEX 文件中。

multiDexKeepFile 属性

        你在multiDexKeepFile其中指定的文件应每行包含一个类，格式为com/example/MyClass.class. 例如，你可以创建一个如下所示的文件multidex-config.txt：

com/scc/MyClass.class

com/scc/MyOtherClass.class

        然后，你可以为构建类型声明该文件，如下所示：

android {

    buildTypes {

        release {

            multiDexKeepFile file('multidex-config.txt')

            ...

        }

    }

}

 

注意： Gradle 读取相对于build.gradle文件的路径，因此如果multidex-config.txt与build.gradle文件位于同一目录中，则上述示例有效。

multiDexKeepProguard 属性

        该multiDexKeepProguard文件使用与 Proguard 相同的格式，并支持整个 Proguard 语法。

        你在multiDexKeepProguard其中指定的文件应包含 -keep 任何有效 ProGuard 语法中的选项。例如， -keep com.scc.MyClass.class。你可以创建一个名为的文件 multidex-config.pro，如下所示：

-keep class com.scc.MyClass

-keep class com.scc.MyClassToo

        如果要指定包中的所有类，文件如下所示：

-keep class com.scc.** { *; } // com.scc 包中的所有类 

        然后，你可以为构建类型声明该文件，如下所示：

android {

    buildTypes {

        release {

            multiDexKeepProguard file('multidex-config.pro')

            ...

        }

    }

}

在开发版本中优化 multidex

        为了减少更长的增量构建时间，使用 pre-dexing在构建之间重用 multidex 输出。Pre-dexing 依赖于仅在 Android 5.0（API 级别 21）及更高版本上可用的 ART 格式。如果你使用的是 Android Studio 2.3 及更高版本，则在将你的应用程序部署到运行 Android 5.0（API 级别 21）或更高版本的设备时，IDE 会自动使用此功能。

 

注意： 适用于 Gradle 3.0.0及更高版本的Android 插件包括进一步改进以优化构建速度，例如按类进行 dexing（以便仅对你修改的类进行重新索引）。一般来说，为了获得最佳的开发体验，你应该始终升级到 最新版本的 Android Studio和 Android 插件。

        但是，如果你从命令行运行 Gradle 构建，则需要将 minSdkVersion 设置为 21 或更高以启用 pre-dexing。保留生产版本设置的一个有用策略是使用产品风格创建两个版本的应用程序 ：开发风格和发布风格，具有不同的值minSdkVersion，如下所示。

android {

    defaultConfig {

        ...

        multiDexEnabled true

        //最低 API 级别。 

        minSdkVersion 15

    }

    productFlavors {

        dev {

            //(API 级别 21)或更高 .

            minSdkVersion 21

        }

        prod {

            // 如果你已经为生产版本配置了 defaultConfig 块

            // 你的应用程序，你可以将此块留空，Gradle 会使用其中的配置

            // 代替 defaultConfig 块。 你仍然需要包括这种味道。

            // 否则，所有变体都使用“dev”配置。 

        }

    }

    buildTypes {

        release {

            minifyEnabled true

            proguardFiles getDefaultProguardFile('proguard-android.txt'),

                                                 'proguard-rules.pro'

        }

    }

}

dependencies {

    implementation "androidx.multidex:multidex:2.0.1"

}

避免 64K 限制

        在配置应用以启用 64K 或更多方法引用之前，你应该采取措施减少应用代码调用的引用总数，包括应用代码定义的方法或包含的库。以下策略可以帮助你避免达到 DEX 参考限制：

• 检查你的应用程序的直接和传递依赖项 - 确保你在应用程序中包含的任何大型库依赖项的使用方式都超过添加到应用程序的代码量。一个常见的反模式是包含一个非常大的库，因为一些实用方法是有用的。减少你的应用程序代码依赖性通常可以帮助你避免 DEX 引用限制。




• 使用 R8 删除未使用的代码 -启用代码收缩以运行 R8 以用于你的发布版本。启用收缩可确保你不会随 APK 一起发送未使用的代码。

        使用这些技术可能会帮助你避免在应用中启用 multidex，同时还可以减少 APK 的整体大小。

以上就是本文的全部内容，希望对大家学习Android multidex有所帮助和启发。

ios 利用RunLoop的原理去监控卡顿

typedef CF_OPTIONS(CFOptionFlags, CFRunLoopActivity) {



    kCFRunLoopEntry , // 进入 loop



    kCFRunLoopBeforeTimers , // 触发 Timer 回调



    kCFRunLoopBeforeSources , // 触发 Source0 回调



    kCFRunLoopBeforeWaiting , // 等待 mach_port 消息



    kCFRunLoopAfterWaiting ), // 接收 mach_port 消息



    kCFRunLoopExit , // 退出 loop



    kCFRunLoopAllActivities  // loop 所有状态改变



}

//

//  SMLagMonitor.h

//

//  Created by DaiMing on 16/3/28.

//



#import <Foundation/Foundation.h>



@interface SMLagMonitor : NSObject



+ (instancetype)shareInstance;



- (void)beginMonitor; //开始监视卡顿

- (void)endMonitor;   //停止监视卡顿



@end

//

//  SMLagMonitor.m

//

//  Created by DaiMing on 16/3/28.

//



#import "SMLagMonitor.h"

#import "SMCallStack.h"

#import "SMCPUMonitor.h"



@interface SMLagMonitor() {

    int timeoutCount;

    CFRunLoopObserverRef runLoopObserver;

    @public

    dispatch_semaphore_t dispatchSemaphore;

    CFRunLoopActivity runLoopActivity;

}

@property (nonatomic, strong) NSTimer *cpuMonitorTimer;

@end



@implementation SMLagMonitor



#pragma mark - Interface

+ (instancetype)shareInstance {

    static id instance = nil;

    static dispatch_once_t dispatchOnce;

    dispatch_once(&dispatchOnce, ^{

        instance = [[self alloc] init];

    });

    return instance;

}



- (void)beginMonitor {

    //监测 CPU 消耗

    self.cpuMonitorTimer = [NSTimer scheduledTimerWithTimeInterval:3

                                                             target:self

                                                           selector:@selector(updateCPUInfo)

                                                           userInfo:nil

                                                            repeats:YES];

    //监测卡顿

    if (runLoopObserver) {

        return;

    }

    dispatchSemaphore = dispatch_semaphore_create(0); //Dispatch Semaphore保证同步

    //创建一个观察者

    CFRunLoopObserverContext context = {0,(__bridge void*)self,NULL,NULL};

    runLoopObserver = CFRunLoopObserverCreate(kCFAllocatorDefault,

                                              kCFRunLoopAllActivities,

                                              YES,

                                              0,

                                              &runLoopObserverCallBack,

                                              &context);

    //将观察者添加到主线程runloop的common模式下的观察中

    CFRunLoopAddObserver(CFRunLoopGetMain(), runLoopObserver, kCFRunLoopCommonModes);

    

    //创建子线程监控

    dispatch_async(dispatch_get_global_queue(0, 0), ^{

        //子线程开启一个持续的loop用来进行监控

        while (YES) {

            long semaphoreWait = dispatch_semaphore_wait(dispatchSemaphore, dispatch_time(DISPATCH_TIME_NOW, 20*NSEC_PER_MSEC));

            if (semaphoreWait != 0) {

                if (!runLoopObserver) {

                    timeoutCount = 0;

                    dispatchSemaphore = 0;

                    runLoopActivity = 0;

                    return;

                }

                //两个runloop的状态，BeforeSources和AfterWaiting这两个状态区间时间能够检测到是否卡顿

                if (runLoopActivity == kCFRunLoopBeforeSources || runLoopActivity == kCFRunLoopAfterWaiting) {

                    // 将堆栈信息上报服务器的代码放到这里

                    //出现三次出结果

//                    if (++timeoutCount < 3) {

//                        continue;

//                    }

                    NSLog(@"monitor trigger");

                    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{

//                        [SMCallStack callStackWithType:SMCallStackTypeAll];

                    });

                } //end activity

            }// end semaphore wait

            timeoutCount = 0;

        }// end while

    });

    

}



- (void)endMonitor {

    [self.cpuMonitorTimer invalidate];

    if (!runLoopObserver) {

        return;

    }

    CFRunLoopRemoveObserver(CFRunLoopGetMain(), runLoopObserver, kCFRunLoopCommonModes);

    CFRelease(runLoopObserver);

    runLoopObserver = NULL;

}



#pragma mark - Private



static void runLoopObserverCallBack(CFRunLoopObserverRef observer, CFRunLoopActivity activity, void *info){

    SMLagMonitor *lagMonitor = (__bridge SMLagMonitor*)info;

    lagMonitor->runLoopActivity = activity;

    

    dispatch_semaphore_t semaphore = lagMonitor->dispatchSemaphore;

    dispatch_semaphore_signal(semaphore);

}





- (void)updateCPUInfo {

    thread_act_array_t threads;

    mach_msg_type_number_t threadCount = 0;

    const task_t thisTask = mach_task_self();

    kern_return_t kr = task_threads(thisTask, &threads, &threadCount);

    if (kr != KERN_SUCCESS) {

        return;

    }

    for (int i = 0; i < threadCount; i++) {

        thread_info_data_t threadInfo;

        thread_basic_info_t threadBaseInfo;

        mach_msg_type_number_t threadInfoCount = THREAD_INFO_MAX;

        if (thread_info((thread_act_t)threads[i], THREAD_BASIC_INFO, (thread_info_t)threadInfo, &threadInfoCount) == KERN_SUCCESS) {

            threadBaseInfo = (thread_basic_info_t)threadInfo;

            if (!(threadBaseInfo->flags & TH_FLAGS_IDLE)) {

                integer_t cpuUsage = threadBaseInfo->cpu_usage / 10;

                if (cpuUsage > 70) {

                    //cup 消耗大于 70 时打印和记录堆栈

                    NSString *reStr = smStackOfThread(threads[i]);

                    //记录数据库中

//                    [[[SMLagDB shareInstance] increaseWithStackString:reStr] subscribeNext:^(id x) {}];

                    NSLog(@"CPU useage overload thread stack：\n%@",reStr);

                }

            }

        }

    }

}



@end

[[SMLagMonitor shareInstance] beginMonitor];

实例化讲解RunLoop

之前看过很多有关RunLoop的文章，其中要么是主要介绍RunLoop的基本概念，要么是主要讲解RunLoop的底层原理，很少用真正的实例来讲解RunLoop的，这其中有大部分原因是由于大家在项目中很少能用到RunLoop吧。基于这种原因，本文中将用很少的篇幅来对基础内容做以介绍，然后主要利用实例来加深大家对RunLoop的理解,本文中的代码已经上传GitHub,大家可以下载查看，有问题欢迎Issue我。本文主要分为如下几个部分:

• RunLoop的基础知识
• 初识RunLoop，如何让RunLoop进驻线程
• 深入理解Perform Selector
• 一直"活着"的后台线程
• 深入理解NSTimer
• 让两个后台线程有依赖性的一种方式
• NSURLConnetction的内部实现
• AFNetWorking中是如何使用RunLoop的?
• 其它:利用GCD实现定时器功能
• 延伸阅读

一、RunLoop的基本概念:

什么是RunLoop？提到RunLoop，我们一般都会提到线程，这是为什么呢？先来看下官方对RunLoop的定义:RunLoop系统中和线程相关的基础架构的组成部分(和线程相关)，一个RunLoop是一个事件处理环，系统利用这个事件处理环来安排事务，协调输入的各种事件。RunLoop的目的是让你的线程在有工作的时候忙碌，没有工作的时候休眠(和线程相关)。可能这样说你还不是特别清楚RunLoop究竟是用来做什么的，打个比方来说明:我们把线程比作一辆跑车，把这辆跑车的主人比作RunLoop，那么在没有'主人'的时候，这个跑车的生命是直线型的，其启动，运行完之后就会废弃(没有人对其进行控制，'撞坏'被收回)，当有了RunLoop这个主人之后，‘线程’这辆跑车的生命就有了保障，这个时候，跑车的生命是环形的，并且在主人有比赛任务的时候就会被RunLoop这个主人所唤醒,在没有任务的时候可以休眠(在IOS中，开启线程是很消耗性能的，开启主线程要消耗1M内存，开启一个后台线程需要消耗512k内存，我们应当在线程没有任务的时候休眠，来释放所占用的资源，以便CPU进行更加高效的工作)，这样可以增加跑车的效率,也就是说RunLoop是为线程所服务的。这个例子有点不是很贴切，线程和RunLoop之间是以键值对的形式一一对应的，其中key是thread，value是runLoop(这点可以从苹果公开的源码中看出来)，其实RunLoop是管理线程的一种机制，这种机制不仅在IOS上有，在Node.js中的EventLoop，Android中的Looper，都有类似的模式。刚才所说的比赛任务就是唤醒跑车这个线程的一个source;RunLoop Mode就是，一系列输入的source,timer以及observer，RunLoop Mode包含以下几种: NSDefaultRunLoopMode,NSEventTrackingRunLoopMode,UIInitializationRunLoopMode,NSRunLoopCommonModes,NSConnectionReplyMode,NSModalPanelRunLoopMode,至于这些mode各自的含义，读者可自己查询，网上不乏这类资源;

二、初识RunLoop，如何让RunLoop进驻线程

我们在主线程中添加如下代码:

while (1) {
    NSLog(@"while begin");
    // the thread be blocked here
    NSRunLoop *runLoop = [NSRunLoop currentRunLoop];
    [runLoop runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];
    // this will not be executed
    NSLog(@"while end");
    
}

这个时候我们可以看到主线程在执行完[runLoop runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];之后被阻塞而没有执行下面的NSLog(@"while end");同时，我们利用GCD，将这段代码放到一个后台线程中:

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
  
    while (1) {
        
        NSLog(@"while begin");
        NSRunLoop *subRunLoop = [NSRunLoop currentRunLoop];
        [subRunLoop runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];
        NSLog(@"while end");
    }
    
    
});

这个时候我们发现这个while循环会一直在执行；这是为什么呢?我们先将这两个RunLoop分别打印出来:

主线程的RunLoop

由于这个日志比较长，我就只截取了上面的一部分。
我们再看我们新建的子线程中的RunLoop,打印出来之后:

backGroundThreadRunLoop.png

从中可以看出来：我们新建的线程中:

sources0 = (null),
sources1 = (null),
observers = (null),
timers = (null),

我们看到虽然有Mode，但是我们没有给它soures,observer,timer，其实Mode中的这些source,observer,timer，统称为这个Mode的item，如果一个Mode中一个item都没有，则这个RunLoop会直接退出，不进入循环(其实线程之所以可以一直存在就是由于RunLoop将其带入了这个循环中)。下面我们为这个RunLoop添加个source:

     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
  
        while (1) {
        
        NSPort *macPort = [NSPort port];
        NSLog(@"while begin");
        NSRunLoop *subRunLoop = [NSRunLoop currentRunLoop];
        [subRunLoop addPort:macPort forMode:NSDefaultRunLoopMode];
        [subRunLoop runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];
        NSLog(@"while end");
        NSLog(@"%@",subRunLoop);
        
    }    
    
});

这样我们可以看到能够实现了和主线程中相同的效果，线程在这个地方暂停了，为什么呢？我们明天让RunLoop在distantFuture之前都一直run的啊？相信大家已经猜出出来了。这个时候线程被RunLoop带到‘坑’里去了，这个‘坑’就是一个循环，在循环中这个线程可以在没有任务的时候休眠，在有任务的时候被唤醒；当然我们只用一个while(1)也可以让这个线程一直存在，但是这个线程会一直在唤醒状态，及时它没有任务也一直处于运转状态，这对于CPU来说是非常不高效的。
小结:我们的RunLoop要想工作，必须要让它存在一个Item(source,observer或者timer)，主线程之所以能够一直存在，并且随时准备被唤醒就是应为系统为其添加了很多Item

三、深入理解Perform Selector

我们先在主线程中使用下performselector:

- (void)tryPerformSelectorOnMianThread{
 
[self performSelector:@selector(mainThreadMethod) withObject:nil]; }
 
- (void)mainThreadMethod{
 
NSLog(@"execute %s",__func__);
 
// print: execute -[ViewController mainThreadMethod]
}

这样我们在ViewDidLoad中调用tryPerformSelectorOnMianThread,就会立即执行，并且输出:print: execute -[ViewController mainThreadMethod];
和上面的例子一样，我们使用GCD,让这个方法在后台线程中执行

 - (void)tryPerformSelectorOnBackGroundThread{
 
 dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
 
[self performSelector:@selector(backGroundThread) onThread:[NSThread currentThread] withObject:nil waitUntilDone:NO];
 
});
}
- (void)backGroundThread{
 
NSLog(@"%u",[NSThread isMainThread]);
 
NSLog(@"execute %s",__FUNCTION__);
 
}

同样的，我们调用tryPerformSelectorOnBackGroundThread这个方法，我们会发现，下面的backGroundThread不会被调用，这是什么原因呢？
这是因为，在调用performSelector:onThread: withObject: waitUntilDone的时候，系统会给我们创建一个Timer的source，加到对应的RunLoop上去，然而这个时候我们没有RunLoop,如果我们加上RunLoop:

 - (void)tryPerformSelectorOnBackGroundThread{
 
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
 
[self performSelector:@selector(backGroundThread) onThread:[NSThread currentThread] withObject:nil waitUntilDone:NO];
 
NSRunLoop *runLoop = [NSRunLoop currentRunLoop];
[runLoop run];
 
});
}

这时就会发现我们的方法正常被调用了。那么为什么主线程中的perfom selector却能够正常调用呢？通过上面的例子相信你已经猜到了，主线程的RunLoop是一直存在的，所以我们在主线程中执行的时候，无需再添加RunLoop。从Apple的文档中我们也可以得到验证：

Each request to perform a selector is queued on the target thread’s run loop and the requests are then processed sequentially in the order in which they were received. 每个执行perform selector的请求都以队列的形式被放到目标线程的run loop中。然后目标线程会根据进入run loop的顺序来一一执行。

小结:当perform selector在后台线程中执行的时候，这个线程必须有一个开启的runLoop

四、一直"活着"的后台线程

现在有这样一个需求，每点击一下屏幕，让子线程做一个任务,然后大家一般会想到这样的方式:

@interface ViewController ()
 
@property(nonatomic,strong) NSThread *myThread;
 
@end
 
@implementation ViewController
 
 - (void)alwaysLiveBackGoundThread{
 
NSThread *thread = [[NSThread alloc]initWithTarget:self selector:@selector(myThreadRun) object:@"etund"];
self.myThread = thread;
[self.myThread start];
 
}
- (void)myThreadRun{
 
NSLog(@"my thread run");
    
}
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
 
    NSLog(@"%@",self.myThread);
    [self performSelector:@selector(doBackGroundThreadWork) onThread:self.myThread withObject:nil waitUntilDone:NO];
}
- (void)doBackGroundThreadWork{
 
    NSLog(@"do some work %s",__FUNCTION__);
    
}
@end

这个方法中，我们利用一个强引用来获取了后台线程中的thread,然后在点击屏幕的时候，在这个线程上执行doBackGroundThreadWork这个方法，此时我们可以看到，在touchesBegin方法中，self.myThread是存在的，但是这是为是什么呢？这就要从线程的五大状态来说明了:新建状态、就绪状态、运行状态、阻塞状态、死亡状态，这个时候尽管内存中还有线程，但是这个线程在执行完任务之后已经死亡了，经过上面的论述，我们应该怎样处理呢？我们可以给这个线程的RunLoop添加一个source，那么这个线程就会检测这个source等待执行，而不至于死亡(有工作的强烈愿望而不死亡):

 - (void)myThreadRun{
 
 [[NSRunLoop currentRunLoop] addPort:[[NSPort alloc] init] forMode:NSDefaultRunLoopMode]; 
 [[NSRunLoop currentRunLoop] run]
 
  NSLog(@"my thread run");
    
}

这个时候再次点击屏幕，我们就会发现，后台线程中执行的任务可以正常进行了。
小结:正常情况下，后台线程执行完任务之后就处于死亡状态，我们要避免这种情况的发生可以利用RunLoop，并且给它一个Source这样来保证线程依旧还在

五、深入理解NSTimer

我们平时使用NSTimer，一般是在主线程中的，代码大多如下:

 - (void)tryTimerOnMainThread{
 
NSTimer *myTimer = [NSTimer scheduledTimerWithTimeInterval:0.5 target:self       
    selector:@selector(timerAction) userInfo:nil repeats:YES];
    
[myTimer fire];
 
}
 
- (void)timerAction{
 
NSLog(@"timer action");
 
}

这个时候代码按照我们预定的结果运行，如果我们把这个Tiemr放到后台线程中呢?

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
   
    NSTimer *myTimer = [NSTimer scheduledTimerWithTimeInterval:0.5 target:self selector:@selector(timerAction) userInfo:nil repeats:YES];
 
    [myTimer fire];
    
});

这个时候我们会发现，这个timer只执行了一次，就停止了。这是为什么呢？通过上面的讲解，想必你已经知道了，NSTimer,只有注册到RunLoop之后才会生效，这个注册是由系统自动给我们完成的,既然需要注册到RunLoop,那么我们就需要有一个RunLoop,我们在后台线程中加入如下的代码:

    NSRunLoop *runLoop = [NSRunLoop currentRunLoop];
    [runLoop run];

这样我们就会发现程序正常运行了。在Timer注册到RunLoop之后，RunLoop会为其重复的时间点注册好事件，比如1：10，1：20，1：30这几个时间点。有时候我们会在这个线程中执行一个耗时操作，这个时候RunLoop为了节省资源，并不会在非常准确的时间点回调这个Timer，这就造成了误差(Timer有个冗余度属性叫做tolerance,它标明了当前点到后，容许有多少最大误差)，可以在执行一段循环之后调用一个耗时操作，很容易看到timer会有很大的误差，这说明在线程很闲的时候使用NSTiemr是比较傲你准确的，当线程很忙碌时候会有较大的误差。系统还有一个CADisplayLink,也可以实现定时效果，它是一个和屏幕的刷新率一样的定时器。如果在两次屏幕刷新之间执行一个耗时的任务，那其中就会有一个帧被跳过去，造成界面卡顿。另外GCD也可以实现定时器的效果，由于其和RunLoop没有关联，所以有时候使用它会更加的准确，这在最后会给予说明。

六、让两个后台线程有依赖性的一种方式

给两个后台线程添加依赖可能有很多的方式，这里说明一种利用RunLoop实现的方式。原理很简单，我们先让一个线程工作，当工作完成之后唤醒另外的一线程,通过上面对RunLoop的说明，相信大家很容易能够理解这些代码:

- (void)runLoopAddDependance{
 
self.runLoopThreadDidFinishFlag = NO;
NSLog(@"Start a New Run Loop Thread");
NSThread *runLoopThread = [[NSThread alloc] initWithTarget:self selector:@selector(handleRunLoopThreadTask) object:nil];
[runLoopThread start];
 
NSLog(@"Exit handleRunLoopThreadButtonTouchUpInside");
dispatch_async(dispatch_get_global_queue(0, 0), ^{
    
    
    while (!_runLoopThreadDidFinishFlag) {
        
        self.myThread = [NSThread currentThread];
        NSLog(@"Begin RunLoop");
        NSRunLoop *runLoop = [NSRunLoop currentRunLoop];
        NSPort *myPort = [NSPort port];
        [runLoop addPort:myPort forMode:NSDefaultRunLoopMode];
        [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];
        NSLog(@"End RunLoop");
        [self.myThread cancel];
        self.myThread = nil;
        
    }
});
 
 }
- (void)handleRunLoopThreadTask
{
NSLog(@"Enter Run Loop Thread");
for (NSInteger i = 0; i < 5; i ++) {
    NSLog(@"In Run Loop Thread, count = %ld", i);
    sleep(1);
}
#if 0
// 错误示范
_runLoopThreadDidFinishFlag = YES;
// 这个时候并不能执行线程完成之后的任务，因为Run Loop所在的线程并不知道runLoopThreadDidFinishFlag被重新赋值。Run Loop这个时候没有被任务事件源唤醒。
// 正确的做法是使用 "selector"方法唤醒Run Loop。 即如下:
#endif
NSLog(@"Exit Normal Thread");
[self performSelector:@selector(tryOnMyThread) onThread:self.myThread withObject:nil waitUntilDone:NO];
 
// NSLog(@"Exit Run Loop Thread");
}

七、NSURLConnection的执行过程

在使用NSURLConnection时，我们会传入一个Delegate,当我们调用了[connection start]之后，这个Delegate会不停的收到事件的回调。实际上，start这个函数的内部会获取CurrentRunloop，然后在其中的DefaultMode中添加4个source。如下图所示，CFMultiplexerSource是负责各种Delegate回调的，CFHTTPCookieStorage是处理各种Cookie的。如下图所示:

NSURLConnection的执行过程

从中可以看出，当开始网络传输是，我们可以看到NSURLConnection创建了两个新的线程:com.apple.NSURLConnectionLoader和com.apple.CFSocket.private。其中CFSocket是处理底层socket链接的。NSURLConnectionLoader这个线程内部会使用RunLoop来接收底层socket的事件，并通过之前添加的source，来通知(唤醒)上层的Delegate。这样我们就可以理解我们平时封装网络请求时候常见的下面逻辑了:

    while (!_isEndRequest)
{
    NSLog(@"entered run loop");
    [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];
}
 
NSLog(@"main finished，task be removed");
 
- (void)connectionDidFinishLoading:(NSURLConnection *)connection
 {
 
  _isEndRequest = YES;
 
 } 

这里我们就可以解决下面这些疑问了:

1. 为什么这个While循环不停的执行，还需要使用一个RunLoop? 程序执行一个while循环是不会耗费很大性能的，我们这里的目的是想让子线程在有任务的时候处理任务，没有任务的时候休眠，来节约CPU的开支。
2. 如果没有为RunLoop添加item,那么它就会立即退出，这里的item呢? 其实系统已经给我们默认添加了4个source了。
3. 既然[[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];让线程在这里停下来，那么为什么这个循环会持续的执行呢？因为这个一直在处理任务，并且接受系统对这个Delegate的回调，也就是这个回调唤醒了这个线程，让它在这里循环。

八、AFNetWorking中是如何使用RunLoop的?

在AFN中AFURLConnectionOperation是基于NSURLConnection构建的，其希望能够在后台线程来接收Delegate的回调。
为此AFN创建了一个线程,然后在里面开启了一个RunLoop，然后添加item

+ (void)networkRequestThreadEntryPoint:(id)__unused object {
@autoreleasepool {
    [[NSThread currentThread] setName:@"AFNetworking"];
    NSRunLoop *runLoop = [NSRunLoop currentRunLoop];
    [runLoop addPort:[NSMachPort port] forMode:NSDefaultRunLoopMode];
    [runLoop run];
}
 
}
 
+ (NSThread *)networkRequestThread {
    static NSThread *_networkRequestThread = nil;
    static dispatch_once_t oncePredicate;
    dispatch_once(&oncePredicate, ^{ 
        _networkRequestThread = [[NSThread alloc] initWithTarget:self selector:@selector(networkRequestThreadEntryPoint:) object:nil];
        [_networkRequestThread start];
    });
    return _networkRequestThread;
}

这里这个NSMachPort的作用和上文中的一样，就是让线程不至于在很快死亡，然后RunLoop不至于退出(如果要使用这个MachPort的话，调用者需要持有这个NSMachPort，然后在外部线程通过这个port发送信息到这个loop内部,它这里没有这么做)。然后和上面的做法相似，在需要后台执行这个任务的时候，会通过调用:[NSObject performSelector:onThread:..]来将这个任务扔给后台线程的RunLoop中来执行。

- (void)start {
[self.lock lock];
if ([self isCancelled]) {
    [self performSelector:@selector(cancelConnection) onThread:[[self class] networkRequestThread] withObject:nil waitUntilDone:NO modes:[self.runLoopModes allObjects]];
} else if ([self isReady]) {
    self.state = AFOperationExecutingState;
    [self performSelector:@selector(operationDidStart) onThread:[[self class] networkRequestThread] withObject:nil waitUntilDone:NO modes:[self.runLoopModes allObjects]];
}
[self.lock unlock];
}

GCD定时器的实现

 - (void)gcdTimer{
 
// get the queue
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
 
// creat timer
self.timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
// config the timer (starting time，interval)
// set begining time
dispatch_time_t start = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1.0 * NSEC_PER_SEC));
// set the interval
uint64_t interver = (uint64_t)(1.0 * NSEC_PER_SEC);
 
dispatch_source_set_timer(self.timer, start, interver, 0.0);
 
dispatch_source_set_event_handler(self.timer, ^{
    
    // the tarsk needed to be processed async
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        
        for (int i = 0; i < 100000; i++) {
            
            NSLog(@"gcdTimer");
            
            
        }
        
    });
 
    
});
 
dispatch_resume(self.timer);
 

链接：https://www.jianshu.com/p/536184bfd163