对象已死吗

引用计数法

很多教科书判断对象是否存活的算法是这样的：给对象中添加一个引用计数器，每当一个地方引用它时，计数器值就加1；当引用失效时，计数器值就减1；任何时刻计数器为0的对象就是不可能再被使用的。客观地说，引用计数法的实现简单，但它很难解决对象之间相互循环引用的问题，所以，主流实现中，并不使用这种方式。

可达性分析

在主流实现中，都是通过可达性分析来判定对象是否存活。这个算法的基本思路就是通过一系列称为“GC Roots”的对象作为起始点，从这些节点开始向下搜索，搜索走过的路径称为“引用链”，当一个对象到GC Roots 没有任何引用链相连时，则证明此对象是不可用的。在Java语言中，可以作为 GC Roots 的对象包括下面几种：

• 虚拟机栈（栈帧中的本地变量表）中引用的对象。
• 本地方法栈中JNI引用的对象。
• 方法区中类静态属性引用的对象。
• 方法区中常量引用的对象。

再谈引用

JDK 1.2 以前，对象只有引用和被引用两种状态，未能描述那些“食之无味，弃之可惜”的对象，我们希望描述这样一类对象：当内存还足够时，则能保留在内存之中；如果内存空间在GC后还是非常紧张，则可以抛弃这些对象。因此，JDK 1.2以后对引用的概念进行扩充，分为：

• 强引用。代码中普遍存在的，类似于 Object obj = new Object() ，只要强引用还在，垃圾收集器永远不会回收被引用的对象。

• 软引用。是用来描述一些还有用，但是并非必需的对象，在系统将要发生内存溢出的异常之前，将会把这些对象列进回收范围之中进行第二次回收，如果这次回收还没有足够的内存，才会抛出内存溢出异常。

• 弱引用。是用来描述非必需对象的，但是强度比软引用更弱一些，被弱引用关联的对象只能生存到下一次GC发生之前。当GC工作时，无论当前内存是否足够，都会回收掉只被弱引用关联的对象。

• 虚引用。是最弱的一种引用关系，不会对对象的生存时间构成影响，也无法通过虚引用获得对象实例。为对象设置虚引用的唯一目的就是能在这个对象被收集器回收时收到一个系统通知。

生存还是死亡

即使在可达性分析算法中不可达的对象，也并非“非死不可”的。要真正宣告一个对象的死亡，至少要经历两次标记过程：如果对象在可达性分析后发现没有与GC Roots 相连接的引用链，那么它会被第一次标记，并进行筛选，筛选的条件是此对象是否有必要执行 finalize() 方法，当对象没有覆写 finalize() 方法，或者 finalize() 方法已经被虚拟机调用过，则都没有必要执行；

如果对象判定有必要执行 finalize() 方法，则对象会被放入F-Queue队列中，稍后由低优先级的线程去触发 执行finalize() 方法，但不会承诺等待它运行结束。这样做的原因是防止 finalize 方法过于缓慢或者死循环。finalize() 方法是对象套多死亡命运的最后一次机会，因为稍后GC将对F-Queue中的对象进行第二次标记，如果对象要在finalize 中拯救自己————只要重新与某个引用链上的任意一个对象关联即可，那么在第二次标记的时候它将被移除出“即将回收”的集合；如果这时候对象还没逃脱，那它就会真的被回收了。

说明这一过程的示例代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

public class FinalizeEscapeGC{
    public static FinalizeEscapeGC SAVE_HOOK = null;
    
    public void isAlive(){
        System.out.println("yes,i am still alive");
    }
    
    @Override
    protected void finalize（） throws Throwable{
        super.finalize();
        System.out.println("finalize method executed");
        FinalizeEscapeGc. SAVE_HOOK = this;
    }
    
    
    public static void main(String[] args) throws Throwable{
        SAVE_HOOK = new FinalizeEscapeGC();
        
        //对象第一次成功拯救自己
        SAVE_HOOK = null;
        System.gc();
        //因为finalize方法优先级很低，所以暂停0.5秒等待它
        Thread.sleep(500);
        if(SAVE_HOOK != null){
            SAVE_HOOK.isAlive();
        }else{
            System.out.println("no,i am dead");
        }
        
        
        //下面这段代码与上面的完全相同，但是这次自救却失败了
        SAVE_HOOK = null;
        System.gc();
        //因为finalize方法优先级很低，所以暂停0.5秒等待它
        Thread.sleep(500);
        if(SAVE_HOOK != null){
            SAVE_HOOK.isAlive();
        }else{
            System.out.println("no,i am dead");
        }
    }
}

运行结果：

finalize method executed
yes,i am still alive
no,i am dead

从结果可以看出，SAVE_HOOK 对象的 finalize 方法确实被GC收集器触发过，并且收集前成功逃脱。但两段完全一样的代码，第二次却被回收了，因为finalize 方法只会被自动调用一次，因此第二次不执行了，所以自救失败。

有些教材上认为 finalize 中适合做“关闭外部资源”之类的工作，在了解以上机制之后，可以认为这完全是一种自我安慰，finalize 能做的，try-finally 或其他方法能做得更好，更及时，所以完全可以忘记这个方法存在（它也仅仅只是Java诞生时讨好C/C++程序员的一个妥协）。

垃圾收集算法

标记-清除算法

最基础的收集算法是 标记-清除(Mark-Sweep) 算法，它分为“标记”和“清除”两个阶段：首先标记出需要回收的对象，在标记完成后统一回收被标记的对象。它的主要不足有两个：一是效率问题，标记和清除效率都不高；二是清除后会产生大量不连续的内存碎片。

复制算法

为了解决效率问题，复制算法出现了。它将可用内存分为大小相等的两块，每次只使用其中一块，当这块内存用完了，就将还存活的对象复制到另一块上，然后把当前内存空间一次清理掉。这样每次都是对整个半区回收，内存分配也不会存在碎片。缺点是可用内存缩小了一半，代价太高。

现在商业虚拟机采用这种方式回收新生代。一般将内存分为较大的 Eden 和两块较小的 Survivor 空间（HotSpot中 Eden 与 Survivor大小比例为 8：1），每次使用Eden 和其中一块 Survivor，当内存回收时，将Eden和Survivor中还存活的对象一次性复制到另一块Survivor，最后清理Eden和刚才用过的Survivor空间，因此，每次只有10%的内存“被浪费”。当然这是基于统计新生代的对象生命周期都很短，差不多只有10%的对象会存活，此外，如果超出10%的存活对象，Survivor空间不够时，需要依赖老年代的空间提供担保（Survivor空间存不下的对象直接通过担保机制进入老年代），这是该分配方式能够运行下去的保障。

复制收集算法在对象存活率较高时要进行较多的复制操作，效率将会变低，更关键的是，如果不想浪费50%的空间，就需要有额外的空间进行担保，防止对象100%存活的极端情况。

标记-整理算法

根据老年代特点，有人提出另外一种标记-整理(Mark-Compact)算法，标记过程仍与“标记-清除”算法一样，但后续不是直接清理可回收对象，而是所有存活的对象都向一端移动，然后直接清理掉端边界以外的内存。标记整理算法的示意图如下：

关于怎么个移动法，书上没有说明，这里个人做个推测：

1、整个老年代的内存划分为 A 和 B 两个区域，区域 A 的大小是所有还存活对象的总大小，区域 B 大小是是剩余空间。
2、按顺序在 A 中找到第一个还存活对象，将它移动到 A 空间的最前端，接下来找第二个还存活的对象，将其移动到第一个对象的后面
3、以此类推，即使存活的对象在 B 中也一样顺序复制到A中，直至最后填满A空间，之后清除 B 空间。

分代收集算法

商业虚拟机都采用“分代收集”，根据各个年代的特点分别采用适当的收集算法：

• 在新生代中，每次垃圾收集时都会发现有大批对象死去，只有少量存活（前面提到的统计数据，大部分时候只有 10% 存活），那就选用复制算法。
• 而老年代中因对象存活率高，没有额外空间对它进行担保，就必须使用“标记-清理”或者“标记-整理”算法进行回收。

CMS 收集器

这是自己添加的这个标题，书中的结构并不是如此，因为 Android ART 虚拟机使用的也是CMS收集方式，所以这里特意抽出来理解，方便理解Android的虚拟机。 CMS (Concurrent Mark Sweep) 收集器，并发的“标记-清除”方式实现的收集器。它是一种以获取最短回收停顿时间为目标的收集器。它的整个过程分为4个步骤：

• 初始标记
• 并发标记
• 重新标记
• 并发清除

其中，初始标记、重新标记 这两个步骤仍然需要“Stop The World”，初始标记仅仅只是标记一下 GC Roots 能直接关联到的对象，速度很快；并发标记就是进行 GC Roots Tracing 的过程（根据初始标记过程中标识出来的直接关联对象，并发标记存活的对象）；重新标记阶段则是为了修正并发标记期间因用户程序继续运行而导致标记产生变动的那一部分对象的标记记录；

由于整个过程中好事最长的 并发标记 和 并发清除 过程收集器线程都可以与用户线程一起工作，所以，从总体上来讲，CMS收集器的内存回收过程是与用户线程一起并发执行的。

CMS 是优秀的收集器，但是它也有3个明显的缺点：

• CMS 收集器对 CPU 资源非常敏感。与其他并发设计的程序一样，CMS收集器对 CPU 同样敏感，它虽然不会导致用户线程停顿，但是会因为占用了一部分线程而导致应用变慢。

• CMS 无法处理浮动垃圾(Floating Garbage,个人认为简而言之就是GC过程中用户线程产生的垃圾，类比于你妈妈在打扫房间卫生的时候，你还在继续撕的纸)。

• 还有最后一个缺点，就是CMS本质还是“标记-清除”算法实现的，这种收集方式在结束后会产生大量的碎片化的空间。

内存分配与回收策略

以下是几条最普遍的内存分配规则，可以通过代码去验证这些规则：

对象优先在 Eden 上分配

大多数情况下，对象在新生代 Eden 区中分配，当 Eden 区没有足够空间时，虚拟机将发起一次 Minor GC （新生代GC）。可以采用以下方式验证：

通过 -Xms20M、-Xmx20M、-Xmn10M 三个参数限制Java 虚拟机堆大小 20MB，不可扩展，并且其中 10M 分配给新生代，剩下的 10MB 分配给老年代，-XX:SurvivorRatio=8决定新生代中 Edun 区与 一个 Survivor区的比例是 8：1，即 Eden 大小 8192K，两个 survivor 空间分别 1024K，所以新生代总共可用空间是 9216K （Eden 区 + 1个Survivor区）。
执行 testAllocation()尝试分配 3个 2M 的大小和1个 4MB 大小的对象。
代码执行完成后，可以发现 新生代Eden区被占用了 4M，而老年代被占用了 6M。
解释：分配前3个对象时，没有压力，均分配在Eden区域，当分配第4个对象时，内存已经不够了（可用空间是 9216K，而 2M*3 + 4M = 10），因此触发一次Minor GC，此时发现这3个对象都存活，并且 survivor 区间不够容纳存活的对象，因此这3个对象被直接通过担保机制提前转移到老年代中；这次GC结束后，第4个对象就可以顺利分配到Eden空间中。

新生代GC(Minor GC):发生在新生代的垃圾收集，因为Java对象大多朝生夕死，所以Minor GC非常频繁，一般回收速度也比较快
老年代GC(Major GC/Full GC)：指的是老年代的GC，对于许多收集器而言，这时候都会伴随至少一次的 Minor GC，老年代的GC一般会比 Minor GC 慢10倍以上。

大对象直接进入老年代

所谓大对象是指需要大量连续内存空间的Java对象，最典型的就是很长的字符串以及数组。当然，比大对象更糟糕的是遇到一群朝生夕死的“短命大对象”，这种应当避免。经常出现大对象容易导致内存还有不少空间就提前触发垃圾收集器以获得足够的连续空间来安置它们。

长期存活的对象进入老年代

如果对象在Eden出生并经历过第一次Minor GC 后仍然存活并且能被 Survivor 容纳的话，将被移动到Survivor 中，并且年龄设置为 1，此后，每熬过一次 Minor GC ，对象的年龄就加1，当达到某个阈值（系统一般默认 15），就会被晋升到老年代中。

动态对象年龄判定

为了更好地适应不同程序内存状况，并不总是要求对象必须达到某个年龄才进入老年代。如果 Survivor 中同龄对象达到某个阈值（一般是一半）时，大于或者等于这个年龄的对象就会移动到老年代。

空间分配担保

发生Minor GC 前，虚拟机会检查老年代最大可用的连续空间是否大于新生代所有对象总空间，如果条件成立，则 Minor GC 可以确保是安全的，如果不成立，则会判断是否允许担保失败，如果允许担保失败，则最终可能会触发一次Full GC。虽然绕了一圈还是有可能触发 Full GC，但是这种情况相对较少。

运行时数据区域

根据《Java虚拟机规范(java SE 7)》规定，Java 虚拟机所管理的内存将会包括以下几个运行时数据区域：

程序计数器

程序计数器可以看做是当前线程执行的字节码的行号指示器，它是线程私有的。在虚拟机概念模型里（具体虚拟机可能有更高效实现），字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令，分支、循环、跳转、异常处理、线程恢复等功能都需要依赖程序计数器来完成。如果线程在执行Java方法，计数器记录的是正在执行的虚拟机字节码指令的地址；如果正在执行Native方法，这个计数器值为Undefined。此内存区域是Java虚拟机规范中唯一一个没有规定任何 OutOfMemoryError情况的区域。

Java虚拟机栈

Java虚拟机栈也是线程私有的。它描述的是Java方法执行的内存模型：每个方法在执行的同时都会创建一个栈帧(Stack Frame)用于存储局部变量表、操作数栈、动态链接、方法出口等信息，一个方法从调用至完成，就对应一个栈帧在虚拟机栈中入栈到出栈的过程。这个区域被规定了两种异常状况：如果线程请求的栈深度大于虚拟机允许的深度，就抛出 StackOverflowError异常；如果该区域可以动态扩展，则在扩展时无法申请到足够内存，就会抛出OutOfMemoryError异常。

本地方法栈

本地方法栈与虚拟机栈类似，区别只不过是虚拟机栈为执行Java方法(即字节码)服务，而本地方法栈为Native方法服务，同样，本地方法栈也可能抛出StackOverflowError异常以及OutOfMemoryError异常.

Java堆

Java堆是被所有线程共享的一块内存，虚拟机启动时创建。虚拟机规范描述是，所有对象的实例以及数组都要在堆上分配(当然，不同虚拟机实现不同)。如果堆中没有内存完成实例分配，并且堆也无法再扩展时，将会抛出OutOfMemoryError异常。

方法区

与Java堆一样，方法区也是各个线程共享的内存区域。它用于存储已经被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。当方法区无法满足内存分配需要时，将抛出OutOfMemoryError异常。

提到方法区，不得不提运行时常量池，它是方法区的一个部分。Class 文件中除了有类的版本、字段、方法、接口等描述信息外，还有一项信息是信息常量池，用于存放编译期生成的各种字面量和符号引用（一般来说，翻译出来的直接引用也会存储在运行时常量池中）。

直接内存

直接内存(Direct Memory)不是虚拟机运行时数据区的一部分，也不是Java虚拟机规范中定义的内存区域。在Java 1.4中新加入了NIO（New Input/Output）类，它可以使用Native函数直接分配堆外内存，然后通过一个存储在Java堆中的DirectBuffer对象作为这块内存额引用进行操作，这样能在一些场景中显著提高性能，因为它避免在 Java 堆和 Native 堆中来回复制数据。当然，该区域空间在动态扩展时也可能出现OutOfMemoryError异常。

HotSpot 虚拟机对象探秘

对象的创建

虚拟机遇到一条new指令时，首先检查这个指令的参数是否能在常量池中定位到类的符号引用，并检查这个符号引用代表的类是否已经被加载、解析和初始化过，如果没有，则必须限制性相应的类加载过程。类加载完成后，便可完全确定对象所需的内存大小，接下来为新生的对象真正分配内存。

对象的内存布局

对象在内存中存储的布局可以分为3块区域：对象头(Header)、实例数据(Instance Data)、和对齐填充(Padding)。

对象的访问定位

建立对象是为了使用对象，我们的Java程序需要通过栈上的refrence数据来操作堆上的具体对象。目前主流的访问方式有使用句柄和直接指针，其中前者通过句柄池间接指向堆中的对象，后者直接指向堆中的对象。

实战

OutOfMemoryError异常

Java虚拟机规范中，除了程序计数器之外，其他区域都可能发生 OutOfMemoryError异常。

JAVA堆溢出

Java堆用于存储实例对象，只要不断地创建对象，并且保证GC root 到对象之间有可达路径来避免垃圾回收，那么就能产生OutOfMemoryError异常。

虚拟机栈和本地方法栈溢出

虚拟机栈和本地方法栈理论上分配不到足够的内存同样会报 OutOfMemoryError异常，但是一般情况下，首先会出现StackOverflowError，OutOfMemoryError很难出现。

方法区和运行时常量池溢出

由于运行时常量池是方法区的一个部分，因此这两个区域的溢出测试放在一起进行。在此之前我们先了解下String.intern()方法：

String.intern()是一个Native方法，它的作用是，如果字符串常量池中已经包含一个等于此String对象的字符串，则返回代表池中这个字符串的String对象；否则，将此String对象包含的字符串添加到常量池中，并返回此String对象的引用。

在JDK1.6及以前，通过设置永久代区域的大小可以间接限制方法区大小，但是从JDK 1.7以后就“去永久代”了，因此以下代码只在JDK 1.6 ，并且设置了 MaxPermSize 时有效：

1
2
3
4
5
6
7
8

public static void main(String[] args){
    //使用List保持常量池的引用，避免full gc 回收常量池
    List<String> list = new ArrayList<String>();
    int i = 0;
    while(true){
        list.add(String.valueOf(i++).intern());
    }
}

同样的原因，还可以引申一个更有意思的影响，如下代码：

1
2
3
4
5
6
7

public static void main(String[] args){
    String str1 = new StringBuilder("计算机").append（“软件”）.toString();
    Systemt.out.println(str1.intern() == str1);
    
    String str2 = new StringBuilder("ja").append("va").toString();
    Systemt.out.println(str2.intern() == str2);
}

这段代码在JDK 1.6 中运行，会得到两个false（intern 方法会把首次遇到的字符串实例复制到永久代中，而StringBuilder创建的字符串实例在Java堆上，所以必然不是同一个引用）；而在JDK 1.7 中会得到一个true（intern 实现不会再复制实例，只是在常量池中记录首次出现的实例引用，因此，intern返回的引用和由StringBuilder创建的字符串实例是同一个实例）一个false（“java”字符串在执行StringBuilder.toString()之前已经出现过，字符串常量池中已经有它的引用了，不符合首次出现，而“计算机软件”这个字符串则是首次出现的—这个解释没看懂，需要再次理解）。

本机直接内存溢出

直接或者间接地使用NIO，就可能出现本机直接内存溢出。虽然使用DirectByteBuffer分配内存也会抛出内存溢出异常，但是抛出异常时并没有真正向操作系统申请分配内存，而是通过计算得知内存无法分配。因此可以通过以下代码手动抛出异常，真正抛出异常的地方是unsafe.allocateMemory()。

1
2
3
4
5
6
7
8
9
10
11

//以下代码能够抛出异常的前提是，设置虚拟机参数 -XX: MaxDirectMemorySize 的值

private static final int _1MB = 1024 * 1024;
public static void main(String[] args) throws Exception{
	Field unsafeField = Unsafe.class.getDeclaredFields()[0];
	unsafeField.setAccessible(true);
	Unsafe unsafe = (Unsafe) unsafeField.get(null);
	while (true){
		unsafe.allocateMemory(_1MB);
	}
}

704、二分查找，给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1

参考链接：LeetCode

进程间通信的经典实现

共享内存

共享内存的工作流程：

1. 创建共享区。进程1从内存中申请一块内存作为共享区域，并且将该区域与某个Key绑定
2. 映射共享区。创建共享区之后，需要将其映射到进程1的空间中才能操作。
3. 访问共享区。进程2利用第一步得到的Key，访问到共享区，之后将这块内存映射到进程2的空间中。
4. 进程间通信。各进程实现了对共享内存的映射后，便可以利用该区域进行信息交换。（注意：整个内存过程都没有实现同步机制，需要进程间自己实现）

管道

• 进程A和B分立管道两端，进行数据传输通信
• 管道是单向的，如果进程既要“读”也要“写”，就需要两根管道这点很像水管的特性
• 管道同时具有“读取”(read end)端和“写入”(write end)端，比如进程A从 write end 写入，进程 B 就可以从 read end 端读取到数据
• 管道容量有限制，当pipe满了后，写操作将阻塞；反之，pipe空了之后，读操作将会阻塞
• 普通的管道是匿名的，这种匿名的管道只适合有斧子关系的进程通信，如果要实现没有任何关系的管道间的通信，就需要命名管道(Named pipe)

UNIX DOMAIN SOCKET

• 简称UDS,也可以说是IPC Socket，与普通的Socket不一样，专门针对单机进程间通信提出来的。
• 大家熟知的 Network Socket 是以 TCP/IP 协议栈作为基础的，需要分包、重组 等一系列操作，而 UDS 因为是本机内的“安全可靠操作”，实现机制上并不依赖于这些协议。
• Android 中使用最多的一种IPC就是Binder，其次就是 UDS 。

RPC（REMOTE PROCEDURE CALLS）

RPC 涉及通信双方通常运行于两台不同的机器中。

同步机制的经典实现

###信号量（SEMAPHORE）

信号量与PV原语是分不开的，也是最为广泛的互斥方法之一，主要包括以下几个元素：

• Semaphore S（信号量，用于指示共享资源的可用数量）
• Operation P （可以减小S计数）
• Operation V （可以增加S计数）

P执行：S = S -1，此时判断若 S>=0 ，说明资源此时允许访问，开始操作共享资源；否则，加入等待队列，待别人释放资源后唤醒。
V执行：S=S+1，如果此时S>0，说明当前没有希望访问资源的等待者；否则，唤醒等待队列中的相关对象。
其中，PV源于都属于原子操作，意味着他们执行过程是不允许被中断的。

互斥体（MUTEX）

Mutex 是 Mutual Exclusion 的缩写，释义为 互斥体。如果资源允许多个对象同时访问，成为 Counting Semaphores；而如果只允许取值0或1（lock/unlocked）的Semaphore，则叫做 Binary Semaphore。Binary Semaphore 与Mutex有相同性质，Mutex通常是对某一排他资源的共享控制——要么这个资源被占用（locked），要么是可以访问的（unlocked）。

管程（MONITOR）

针对信号量机制的程序易读性较差，并且信号量管理分散在各个参与对象中，很难维护等缺点，管程被提出来了。管程是可以被多个进程/线程安全访问的对象或者模块，管程中的方法在同一时刻只允许一个范文这使用它们（方法受 mutual exclusion 保护的）。

操作系统内存基础

操作系统中任何操作都与内存息息相关，内存管理的底层原理主要注意几个核心：

• 虚拟内存

内存总是“不够大”的，随着应用的增加，总会填满，虚拟内存为运行更多的程序提供了可能，其基本思想是：1.将硬盘上一部分空间作为内存的扩展；2.出现资源不足时，按照一定算法挑出优先级较低的数据块移动到第1步划出的空间；3.需要用到硬盘中的数据块时，系统将产生“缺页”，之后把硬盘中的数据交换回内存中。

• 内存分配与回收

分配、native层回收，java层回收

• 内存保护

内存分页或者分段式管理。进程的逻辑地址不是直接对应物理地址的，因此没办法访问它范围外的内存空间。

顺带一提，mmap函数（Memory Map）正如其名，可以将某个设备或者文件映射到应用进程的内存空间中，这样访问这块内存就相当于对设备/文件进行读写；可见，理论上mmap可以用于进程间通信，即通过映射同一块物理内存来共享内存，这种方式因为减少了复制次数，在一定程度上提高了进程间通信效率。

Android 匿名共享内存（Ashmem）

Ashmem 全称 Anony Shared Memory，是Android 特有的内存共享机制，它可以将指定的物理内存分别映射到各个进程的地址空间，从而便捷地实现进程间的内存共享。Ashmem 是一个 misc 设备，其实现依托于 /dev/ashmem 。

根据技术栈可能的提问

1、聊聊 java 中 static 关键字

1
2
3

class StaticTest{
    static int i = 47;
}

2、Kotlin 相关

3、有自定义view的经验，那如何理解 MeasureSpec？

4、聊聊 Android 中事件分发机制？

5、如何处理手势冲突？

以上内容参考自一骑绝尘 和 前行的乌龟

6、如何优化App性能？

引申-adb shell dumpsys meminfo com.esun.ui 中各数据含义

以上内容参考自简书上的博客

7、引申-ArrayMap的原理、SparseArray原理

以上内容可以参考这个链接

8、描述http 三次握手？为什么3次，2次或者4次不行？

以上内容有部分是参考知乎中的内容

9、延伸-http 使用80端口，如果客户端一个tcp/ip在连接，那么就无法建立其他tcp/ip连接，因为80端口在占用？

10、描述4次挥手，3次行不行？为什么？

11、了解哪些设计模式？写个单例模式？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

//线程安全的单例模式代码
public class Singleton{
    //注意 volatitle 关键字
    private static volatitle Singleton instance = null;
    
    //构造函数私有
    private Singleton(){
    }
    
    public static Singleton getInstance(){
        if (instance == null){
            synchronized(Singleton.class){
                if (instance == null){
                    instance = new Singleton();
                }
            }
        }
        
        return instance;
    }
    
}

以下针对项目可能的提问

12、了解多线程使用，聊聊锁可以分为哪些种类

具体可以参考以前写的这篇博客

13、引申-聊聊 HandlerThread

1
2
3
4
5
6
7
8
9
10
11
12
13

@Override
    public void run() {
        mTid = Process.myTid();
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
            notifyAll();
        }
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        Looper.loop();
        mTid = -1;
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public Looper getLooper() {
        if (!isAlive()) {
            return null;
        }
        
        // If the thread has been started, wait until the looper has been created.
        synchronized (this) {
            while (isAlive() && mLooper == null) {
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }
        }
        return mLooper;
    }

1
2
3
4
5
6
7
8

public boolean quit() {
    Looper looper = getLooper();
    if (looper != null) {
        looper.quit();
        return true;
    }
    return false;
}

14、延伸-IntentService

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

public abstract class IntentService extends Service {
    private final class ServiceHandler extends Handler {
        public ServiceHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            onHandleIntent((Intent)msg.obj);
            stopSelf(msg.arg1);
        }
    }
    
    @Override
    public void onCreate() {
        super.onCreate();
        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
        thread.start();

        mServiceLooper = thread.getLooper();
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }

    @Override
    public void onStart(@Nullable Intent intent, int startId) {
        Message msg = mServiceHandler.obtainMessage();
        msg.arg1 = startId;
        msg.obj = intent;
        mServiceHandler.sendMessage(msg);
    }
}

以上内容参考俗人浮生 的博客，以及 IntentService 官方源码

15、volatile 关键字有了解吗？

如果还不太了解，可以参考以前写的这篇读书笔记、还可以参考这篇文章，讲得很透彻

16、什么是大接口？

17、怎么防止劫持？

https的ip直连会碰到一些问题，具体可以参考别人的博客

18、一般走查哪些代码？

19、如何文档归档

20、聊聊这个内部sdk的设计？

21、最有成就感的项目？最棘手的问题？

22、引申-如何重新设计网络框架？

23、引申-安全做了哪些努力

24、讲一讲你看过的第三方框架的源码？

25、逛哪些论坛？

26、平时关注什么技术？

27、有什么想问我的

冒泡排序算法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

    private static void bubbleSort1(int[] ints) {
    int len = ints.length;
    boolean flag = true;
    while (flag) {
        flag = false;
        for (int i = 1; i < len; i++) {
            if (ints[i - 1] > ints[i]) {
                int temp = ints[i];
                ints[i] = ints[i-1];
                ints[i-1] = temp;
                flag = true;
            }
        }
        len -- ;
    }
}

选择排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public static void selectSort(int[] a){
    for (int i = 0; i< a.length - 1; i++){
    
        int index = i;//当前趟最小的数所在index
        
        for (int j=i+1; j < a.length; j++){
            if (a[j] < a[index]){
                index = j;
            }
        }
        
        if (index != i){
            int temp = a[i];
            a[i] = a[index];
            a[index] = temp;
        }
    }
}

插入排序

1
2
3
4
5
6
7
8
9
10
11

public void doInsertSort(){
    for(int index = 1; index<length; index++){//外层向右的index，即作为比较对象的数据的index
        int temp = array[index];//用作比较的数据
        int leftindex = index-1;
        while(leftindex>=0 && array[leftindex]>temp){//当比到最左边或者遇到比temp小的数据时，结束循环
            array[leftindex+1] = array[leftindex];
            leftindex--;
        }
        array[leftindex+1] = temp;//把temp放到空位上
    }
}

shell排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

/**
 * 思路：三层循环
 * 第一层循环：控制增量-增量随着程序的进行依次递减一半
 * 第二层循环：遍历数组
 * 第三层循环：比较元素，交换元素。
 * 这里需要注意的是：比较的两个元素和交换的两个元素是不同的。
 */
public static shellSort(int[] data) {
    for (int div = data.length/2; div>0; div/=2) {
        for (int j = div; j < data.length; j++) {
            int temp = data[j];
            for (int k=j; k>=div && temp<data[k-div] ; k-=div) {
                data[k] = data[k-div];
            }
            data[k] = temp;
        }
    }
}

快速排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

public static void quickSort(int[] arr,int low,int high){
    int i,j,temp,t;
    if(low>high){
        return;
    }
    i=low;
    j=high;
    //temp就是基准位
    temp = arr[low];
 
    while (i<j) {
        //先看右边，依次往左递减
        while (temp<=arr[j]&&i<j) {
            j--;
        }
        //再看左边，依次往右递增
        while (temp>=arr[i]&&i<j) {
            i++;
        }
        //如果满足条件则交换
        if (i<j) {
            t = arr[j];
            arr[j] = arr[i];
            arr[i] = t;
        }
 
    }
    //最后将基准为与i和j相等位置的数字交换
     arr[low] = arr[i];
     arr[i] = temp;
    //递归调用左半数组
    quickSort(arr, low, j-1);
    //递归调用右半数组
    quickSort(arr, j+1, high);
}

堆排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

private static void heapSort(int[] arr){
    int arrLen = arr.length;
    int temp;
    
    //建立大顶堆
    for (int i = arrLen/2 -1;i>=0;i--){
        //从第一个非叶子结点(在 arrLen/2 -1 处)从下至上，从右至左调整结构
        adjustHeap(arr,i,arrLen);

    }

    for (int j = arrLen -1;j >= 0;j--){
        //将堆顶元素与末尾元素进行交换
        temp = arr[0];
        arr[0] = arr[j];
        arr[j] = temp;
        
        //重新对堆进行调整
        adjustHeap(arr,0,j);
    }
}

private static void adjustHeap(int[] arr,int start,int end){
    //先取出当前元素i
    int temp = arr[start];

    for (int k = 2*start + 1;k < end;k = 2*k + 1){//从i结点的左子结点(2i+1处)开始
        if (k + 1 < end && arr[k] < arr[k + 1]){//如果左子结点小于右子结点，k指向右子结点
            k ++;
        }
        
        //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换）
        if (arr[k] > temp) {
            arr[start] = arr[k];
            start = k;
        }else {
            break;
        }
    }

    //将temp值放到最终的位置
    arr[start] = temp;
} 

归并排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

    //非递归算法实现二路归并排序，length代表数组长度，即数组最大下标是 legth - 1
void mergeSort(int List[],int length){
    int size = 1;
    int low;
    int mid;
    int high;
    //size 是标记当前各个归并序列的high-low，从1，2，4，8，……，2*size
    while(size <= length - 1){
        //从第一个元素开始扫描，low代表第一个分割的序列的第一个元素
        low = 0;
        //当前的归并算法结束的条件
        while(low + size <= length - 1){
            //mid代表第一个分割的序列的最后一个元素
            mid = low + size - 1;
            //high 代表第二个分割的序列的最后一个元素
            high = mid + size;
            //判断一下：如果第二个序列个数不足size个
            if(high > length - 1){
                //调整 high 为最后一个元素的下标即可
                high = length - 1;
            }
            //调用归并函数，进行分割的序列的分段排序
            merge(List, low, mid, high);
            //打印出每次归并的区间
            cout << "low:" << low << " mid:" << mid << " high:" << high << endl;
            //下一次归并时第一序列的第一个元素位置
            low = high + 1;
        }// end of while
        //范围扩大一倍，二路归并的过程
        size *= 2;
    }
}

总结

上述排序，稳定的排序有：冒泡、插入、合并 ，不稳定排序：选择、shell、快排、堆排

二叉树遍历

先序遍历

1
2
3
4
5
6
7
8
9
10
11

void pre(BTreeNode treeNode){

    if(treeNode != null){
        //显示节点数据
        showNodeValue(treeNode);
        //先序遍历左子树
        pre(treeNode.left);
        //先序遍历右子树
        pre(treeNode.right)
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

//非递归，手算的思想，先变访问边找，找到最左下方的，然后向上再向访问右边的
public static void iterativePreOrder(TreeNode p) {
    if (p == null) return;
    Stack<TreeNode> stack = new Stack<TreeNode>();
    while (!stack.empty() || p != null) {
        while (p != null) {
            visit(p);
            stack.push(p);
            p = p.left;
        }
        p = stack.pop();
        p = p.right;
    }
}

//栈的思想，按层次倒着进栈，利用后进先出解决顺序问题
public static void iterativePreOrder_2(TreeNode p) {
    if (p == null) return;
    Stack<TreeNode> stack = new Stack<TreeNode>();
    stack.push(p);
    while (!stack.empty()) {
        p = stack.pop();
        visit(p);
        if (p.right != null) stack.push(p.right);
        if (p.left != null) stack.push(p.left);
    }
}

中序遍历

1
2
3
4
5
6
7
8
9
10

public static void middle(BTreeNode treeNode){
    if(treeNode != null){
        //中序遍历左子树
        middle(treeNode.left);
        //显示节点数据
        showNodeValue(treeNode);
        //中序遍历右子树
        middle(treeNode.right);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

public static void iterativeInOrder(TreeNode p) {
    if (p == null) return;
    Stack<TreeNode> stack = new Stack<TreeNode>();
    while (!stack.empty() || p != null) {
        while (p != null) {
            stack.push(p);
            p = p.left;
        }
        p = stack.pop();
        visit(p);
        p = p.right;
    }
}

后序遍历

1
2
3
4
5
6
7
8
9
10
11

public static void behind(BTreeNode treeNode){
    if(treeNode != null){
        //后序遍历左子树
        behind(treeNode.left);
        //后序遍历右子树
        behind(treeNode.right);
        //显示节点数据
        showNodeValue(treeNode);
        
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

//双栈法，易于理解
public static void iterativePostOrder_3(TreeNode p) {
    if (p == null) return;
    Stack<TreeNode> stack = new Stack<TreeNode>();
    Stack<TreeNode> result = new Stack<TreeNode>();
    while (!stack.empty() || p != null) {
        while (p != null) {
            stack.push(p);
            result.push(p);
            p = p.right;
        }
        if (!stack.empty()) p = stack.pop().left;
    }
    while (!result.empty()) {
        p = result.pop();
        visit(p);
    }
}

层次遍历

1
2
3
4
5
6
7
8
9
10
11

public static void iterativeLevelOrder(TreeNode p) {
    if (p == null) return;
    LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
    queue.offer(p);
    while (!queue.isEmpty()) {
        p = queue.poll();
        if (p.left != null) queue.offer(p.left);
        if (p.right != null) queue.offer(p.right);
        visit(p);
    }
}

以上内容可以参考这篇博客

扑克洗牌算法

打乱一个已有顺序有多种实现方式，但是要高效地实现，还需要斟酌，以下是目前能想到的最有的解决方案：

1
2
3
4
5
6
7
8
9
10
11

//生成一副牌
Card[52] oneCard = generateOneCard;

//顺序与 随机位置交换
Random r = new Random();
for (int i = 0; i < oneCard.size(); i ++){
    int j = r.nextInt(52);
    Card tempCard = oneCard[i];
    oneCard[i] = onCard[j];
    onCard[j] = tempCard;
}

判断链表中是否有环

快慢指针法：创建两个指针1和2同时指向这个链表的头节点，然后两个指针分别向后移动，其中指针1每次向后移动一个节点，指针2每次向后移动两个节点，每移动一次就比较两个指针指向的节点是否相同，如果相同说明出链表有环；如果不同，则继续循环，直到有环结束或者到达尾部结束。

原理：两个人在环形跑道上同一位置开始跑，一人速度快，一人速度慢，如此持续跑一段时间，速度快的那个肯定会从速度慢的身后再次追上以及超越，这中间必然有个交汇点。如果是跑直线的话，到终点就结束了，不会再碰面。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

//判断是否有环
public static <T> boolean isLoopList(ListNode<T> head){
    ListNode<T> slowPointer, fastPointer;

    //使用快慢指针，慢指针每次向前一步，快指针每次两步
    slowPointer = fastPointer = head;
    while(fastPointer != null && fastPointer.next != null){
        slowPointer = slowPointer.next;
        fastPointer = fastPointer.next.next;

        //两指针相遇则有环
        if(slowPointer == fastPointer){
            return true;
        }
    }
    return false;
}

引申：如何判断环的入口

我们假定链表头到环入口的距离是len，环入口到slow和fast交汇点的距离为x，环的长度为R。slow和fast第一次交汇时，设slow走的长度为：d = len + x，而fast走的长度为：2d = len + nR + x，(n >= 1)，从而我们可以得知：2len + 2x = len + nR + x，即len = nR - x，(n >= 1)。所以，要找出环入口，也要两个指针，一个指针A指向相遇时候的节点，一个指针B指向链表头，两个指针每次都走一步，A指针在遍历过程中可能多次(n >= 1)经过环入口节点，但当B指针第一次达到入口节点时，A指针此时必然也指向入口节点。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

//判断是否有环，有环就返回入口
public static <T> ListNode<T> findEntranceInLoopList(ListNode<T> head){
    ListNode<T> slowPointer, fastPointer;

    //使用快慢指针，慢指针每次向前一步，快指针每次两步
    boolean isLoop = false;
    slowPointer = fastPointer = head;
    while(fastPointer != null && fastPointer.next != null){
        slowPointer = slowPointer.next;
        fastPointer = fastPointer.next.next;

        //两指针相遇则有环
        if(slowPointer == fastPointer){
            isLoop = true;
            break;
        }
    }

    //一个指针从链表头开始，一个从相遇点开始，每次一步，再次相遇的点即是入口节点
    if(isLoop){
        slowPointer = head;
        while(fastPointer != null && fastPointer.next != null){
            //两指针相遇的点即是入口节点
            if(slowPointer == fastPointer){
                return slowPointer;
            }

            slowPointer = slowPointer.next;
            fastPointer = fastPointer.next;
        }
    }
    return null;
}

再引申，两个单链表是否相交

两个没有环的链表在某一节点相交，那么在这个节点之后的所有结点都是两个链表所共有的。如果它们相交，则最后一个结点一定是共有的，因此问题转化为：两个链表最后一个结点是否相同（时间复杂度为O(len1+len2)）。要找出相交的第一个结点，可以首先获得两个链表的长度，然后获得两个链表长度差值 K，之后长的链表指向第K个结点，短的链表从头开始，每次向后移动一个结点，再比较当前结点是否相等，第一次相等的那个结点点就是相交节点。

代码略

1、给100盏灯编号 1~100，开始时所有灯都是关着的
第1次：把所有编号是1的倍数的灯的开关状态改变一次；
第2次：把所有编号是2的倍数的灯的开关状态改变一次；
第3次，把所有编号是3的倍数的灯的开关状态改变一次；
…
第100次，把所有编号是100的倍数的灯的开关状态改变一次；
问：最后开着的灯的编号是哪些？

分析：最开始灯是灭的，因此只有经过奇数次开关状态改变，灯才会是亮的。从题意可知一个数字有多少约数就会状态改变多少次，因此这道题可以转换为：1~100数字中约数个数是奇数的有哪些。并且我们知道约数是成对出现的，如8的约数：（1，8）、（2，4），因此如果要出现约数的个数是奇数个，除非它是个平方数，如36的约数：（1，36）、（2，18）、（3，12）、（4，9）、（6），因此，这题又可以转换为1~100数字中的平方数有哪些，这操作。。。。666吧，这就是分析问题的乐趣吧

2、烧一根不均匀的绳子，从头烧到尾总共需要1小时，现在有若干条这样的绳子，问如何用烧绳子的方法来计时1小时15分钟呢

从题目知道，绳子不均匀，不能根据燃烧半根来计量半小时。但是还可以推断，从两头烧，只要半小时。因此可以使用3根绳子来计时：1）第1根绳子点燃两端，第2根绳子点燃一端，第三根绳子先不点燃； 2）第1根绳子烧完计时30分钟，接着第2根绳子另一端也点燃 3）第2根绳子烧完计时15分钟，此时已经计时45分钟了，剩下的半小时只需要将第3条绳子两端点燃就能计算出。

3、有12个外观一样的小球，但有一个与其他小球重量略微不同，用手感觉不出来，用一个天平，能称3次就能找到那个小球吗

把小球编号 112，然后分为3组（想想为什么是3组）：14分为A组，58分为B组，912分为C组。首先A组和B组称量比较：
1、天平平衡。则目标小球在C组。将C分为两组：9、10、11分为一组C1，12分为一组C2，再从B中随意拿出3个球分组为B1，C1和B1比较：
1）若平衡，则12号球就是目标球。
2）若不平衡，则目标球在C1内，并且根据天平倾斜，可以判断目标球比普通球重还是轻（若是天平显示B1重，则目标球比较轻；反之目标球比较重），此时随意取 C1 中的2个球放在天平上即可知道结果（如果平衡，则目标球是另一个，如果不平衡，根据轻重可知目标球）。
2、天平不平衡。则目标球在A或者B中。
1）若A > B,取（1，2，3，5）为一组X,(4,9,10,11)为一组Y，（6，7，8）为一组Z，比较X和Y，若X>Y，可知不同小球在1，2，3中，且目标球重于普通球，此时再将编号 1，2，3 任取2个放上天平即可知道目标球。若X<Y,则说明4号是目标球；若X=Y，则目标球在Z中（6，7，8），并且目标球轻于普通球，此时只需要将编号 其中任意两个球放上天平即可找出目标球。
2）若 A < B，同样按照上述分为X、Y、Z三组，同理，若X<Y，则目标球在1，2，3中，且目标球轻于普通球，此时再将编号 1，2，3 任取2个放上天平即可知道目标球；若X>Y,说明4号为目标球，若X=Y，则目标球在Z中（6，7，8），并且目标球重于普通球，此时再将编号 6，7，8 任取2个放上天平即可知道目标球。

3、一笔画出经过9个点的4条直线

主要是要突破点，不要局限于点上，不说了，直接上图：
9点4线

4、有1块钱1瓶的契税，喝完后2个空瓶换一瓶汽水，问有20块钱，可以喝几瓶汽水？

总共40瓶（不要浪费最后那个空瓶，找老板借1个，凑2瓶子再喝一瓶，最后这空瓶还给老板。。。）

5、时针分针秒针重合的次数

只有2次，一次是 00:00:00 一次是 12：00：00

假设排列100个球，两个人轮流一拿球装入口袋，能拿到第100个球为胜，条件是每次拿球至少拿1个，最多拿5个，加入你是最先拿球的人，你该拿几个，以后怎么保证拿到最后一个球？

怎样保证拿到最后一个球呢？最简单的方法是最后剩下6个，并且轮到对方来拿，这样无论对方拿几个，都能保证自己拿到最后一个。
（1）首先，要控制每一轮拿出的个数，但是对方拿的个数是不受控制的，假设对方拿n个，自己就拿6-n个（为什么是控制总数是6个，是因为对手最多拿5个，自己最少能拿1个，和值就是6，自己不能把和值控制得更低；而对手至少拿1个，自己最多拿5个，同样自己不能把和值控制得更高。因此只有6才是一个可控的值）。
（2）其次，假设第一次拿x个球，以后每次自己和对方拿的和是6，最多可以拿到15轮（除去第一轮的x个，最后留这肯定少于10个了），还剩 10-x个，为了达到之前定的目标最后留6个，所以x应该是4.
（3）总结而言就是第一次拿4个，以后每次对方拿了n个后，自己拿 6-n 个。

如何确定用户异地登陆。

Android 事件分发机制

当我们点击屏幕时，事件最先传递给Activity ，在 Activity 的dispatchTouchEvent() 回调中，默认首先调用 getWindow().superDispatchTouchEvent(ev) 将事件交给window 处理，如果window 返回true之后，则直接return true。在 getWindow().superDispatchTouchEvent(ev) 调用的时候，我们能发现事件一步步传递：

1、PhoneWindow.superDispatchTouchEvent
2、DecorView.dispatchTouchEvent()
3、ViewGroup. dispatchTouchEvent()

代码可以参考（Carson的）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

/**  * 源码分析：Activity.dispatchTouchEvent（）  */ 
  public boolean dispatchTouchEvent(MotionEvent ev) {

    // 仅贴出核心代码

    // ->>分析1
    if (getWindow().superDispatchTouchEvent(ev)) {

        return true;
        // 若getWindow().superDispatchTouchEvent(ev)的返回true
        // 则Activity.dispatchTouchEvent（）就返回true，则方法结束。即 ：该点击事件停止往下传递 & 事件传递过程结束
        // 否则：继续往下调用Activity.onTouchEvent

    }
    // ->>分析3
    return onTouchEvent(ev);
  }

/**  * 分析1：getWindow().superDispatchTouchEvent(ev)  * 说明：  *     a. getWindow() = 获取Window类的对象  *     b. Window类是抽象类，其唯一实现类 = PhoneWindow类  *     c. Window类的superDispatchTouchEvent() = 1个抽象方法，由子类PhoneWindow类实现  */
  @Override
  public boolean superDispatchTouchEvent(MotionEvent event) {

      return mDecor.superDispatchTouchEvent(event);
      // mDecor = 顶层View（DecorView）的实例对象
      // ->> 分析2
  }

/**  * 分析2：mDecor.superDispatchTouchEvent(event)  * 定义：属于顶层View（DecorView）  * 说明：  *     a. DecorView类是PhoneWindow类的一个内部类  *     b. DecorView继承自FrameLayout，是所有界面的父类  *     c. FrameLayout是ViewGroup的子类，故DecorView的间接父类 = ViewGroup  */
  public boolean superDispatchTouchEvent(MotionEvent event) {

      return super.dispatchTouchEvent(event);
      // 调用父类的方法 = ViewGroup的dispatchTouchEvent()
      // 即将事件传递到ViewGroup去处理，详细请看后续章节分析的ViewGroup的事件分发机制

  }
  // 回到最初的分析2入口处

/**  * 分析3：Activity.onTouchEvent()  * 调用场景：当一个点击事件未被Activity下任何一个View接收/处理时，就会调用该方法  */
  public boolean onTouchEvent(MotionEvent event) {

        // ->> 分析5
        if (mWindow.shouldCloseOnTouch(this, event)) {
            finish();
            return true;
        }

        return false;
        // 即 只有在点击事件在Window边界外才会返回true，一般情况都返回false，分析完毕
    }

/**  * 分析4：mWindow.shouldCloseOnTouch(this, event)  * 作用：主要是对于处理边界外点击事件的判断：是否是DOWN事件，event的坐标是否在边界内等  */
  public boolean shouldCloseOnTouch(Context context, MotionEvent event) {

  if (mCloseOnTouchOutside && event.getAction() == MotionEvent.ACTION_DOWN
          && isOutOfBounds(context, event) && peekDecorView() != null) {

        // 返回true：说明事件在边界外，即 消费事件
        return true;
    }

    // 返回false：在边界内，即未消费（默认）
    return false;
  } 

之后，就进入了ViewGroup的事件分发流程。用一张图(这张图转载自Carson_Ho)来描绘下整体的过程：

接下来主要关注的是 Android 中 ViewGroup 事件分发机制。它总体来说可以用几张图说明白，相比在代码中打印Log，这种方式更容易理解和记住。

针对 ACTION_DOWN 事件

只针对 ACTION_DOWN 事件时，事件的完整流向是一个U形图，如下图所示：

如果没有中断事件，可能看起来更直观一些，Activity、ViewGroup、View的层次更加清晰：

针对 ACTION_MOVE 和 ACTION_UP

上面讲解的都是针对ACTION_DOWN的事件传递，ACTION_MOVE和ACTION_UP在传递的过程中并不是和ACTION_DOWN 一样，你在执行ACTION_DOWN的时候返回了false，后面一系列其它的action就不会再得到执行了。简单的说，就是当dispatchTouchEvent在进行事件分发的时候，只有前一个事件（如ACTION_DOWN）返回true，才会收到ACTION_MOVE和ACTION_UP的事件。

ViewGroup1 的dispatchTouchEvent 中返回true消费事件

红色的箭头代表ACTION_DOWN 事件的流向，蓝色的箭头代表ACTION_MOVE 和 ACTION_UP 事件的流向：

ViewGroup2 的dispatchTouchEvent 中返回true消费事件

在View 的dispatchTouchEvent 返回true消费事件,就不画图了，效果和在ViewGroup2 的dispatchTouchEvent return true的差不多，同样的收到ACTION_DOWN 的dispatchTouchEvent函数都能收到 ACTION_MOVE和ACTION_UP。

在View 的onTouchEvent 中返回true消费事件

在ViewGroup 2 的onTouchEvent 中返回true消费事件

在ViewGroup 1 的onTouchEvent 中返回true消费事件

在View的dispatchTouchEvent 中返回false并且ViewGroup 1 的onTouchEvent 返回true消费事件

在View的dispatchTouchEvent 中返回false并且Activity 的onTouchEvent 返回true消费事件

经过这么多图能得出以下规律：

ACTION_DOWN事件在哪个控件消费了（return true）， 那么ACTION_MOVE和ACTION_UP就会从上往下（通过dispatchTouchEvent）做事件分发往下传，就只会传到这个控件，不会继续往下传，如果ACTION_DOWN事件是在dispatchTouchEvent消费，那么事件到此为止停止传递，如果ACTION_DOWN事件是在onTouchEvent消费的，那么会把ACTION_MOVE或ACTION_UP事件传给该控件的onTouchEvent处理并结束传递。

以上文章参考自 Kelin ,这里图片形式贴出来仅仅只是个人做的笔记，方便记忆。