android jni打堆栈 android堆栈常量区方法区

作为一个2年经验用了5年的android开发，最近面试受了不少打击，在这漫漫整理一些面试题，和相应的学习。

1.JVM（Android开发为什么要学这个，好吧，反正有人问这类相关的，就一起准备了）

1.方法区（也被称为永久代）用于储存类信息，final常量，静态变量，编译器编译后的代码也会有，这里又关联到一个新概念，常量池（静态常量池/运行时常量池），静态就不说了，运行时常量池一看就能做骚操作，而这里确实可以：运行期间也可能将新的常量放入池中，这种特性被开发人员利用比较多的就是String类的intern()方法。PS：卧槽，这intern方法又是什么

String s = newString("123") + newString("123");
s.intern();         
String s1 = "123123";         
System.out.println(s == s1);  
// 在jdk6和jdk7中， 这个结果还不一样？？？

在jdk6 中，intern方法将字符串复制到常量区，然后返回一个该字符串在常量区中的引用

在jdk7 中，输出true，因为jdk7中intern方法是（在常量区找不到该字符串时）将该字符串对象在堆里的引用注册到常量区，以后使用相同字面量（双引号形式）声明的字符串对象都指向该地址，也就是该字符串在堆中的地址。

意思就是s1在jdk6中，指向的是常量区的变量地址，而jdk7中指向的是堆中变量的地址，常量区实际持有的是堆中变量的引用（FFFFFK）

2.堆

存储对象实例以及数组(!!! JVM中只有一个堆) ,堆是被所有线程共享的（所以多线程操作要加锁）

堆空间分为老年代和年轻代，刚创建的对象肯定在年轻代，老不死的就放老年代，年轻代转化为老年代，还会经历Survivor区，作为Eden区和Old区的缓冲，PS：这难道就是中年区

3.栈（虚拟机栈）

Java栈中存放的是一个个的栈帧，每个栈帧对应一个被调用的方法。

栈帧中包括局部变量表(Local Variables)、操作数栈(Operand Stack)、指向当前方法所属的类的运行时常量池的引用(Reference to runtime constant pool)、方法返回地址(Return Address)和一些额外的附加信息

final int d = 1;// 常量池的引用，因为在方法执行的过程中有可能需要用到类中的常量，所以必须要有一个引用指向运行时常量
int add（int a,int b）{  
    int c = a + b + d;  // 局部变量表 + 程序中的所有计算过程都是在借助于操作数栈来完成的（a + b）也算吧
    return c; // 方法返回地址
}

我觉得就是我这样的推断吧，其实一个栈帧就是包含了一堆，方法处理必须的数据。

4.程序计数器

程序计数器是一个记录着当前线程所执行的字节码的行号指示器

说白了就是因为多线程的情况下，如果cpu使用权被其他线程抢占了，我总要记录一下自己运行到哪了，ok，就有了程序计数器。

5.本地方法栈 ？？？ 为什么又有这个栈

本地方法栈服务的对象是JVM执行的native方法，而虚拟机栈服务的是JVM执行的java方法

native方法又是啥：由于Java语言无法访问操作系统底层信息（比如：底层硬件设备等），这时候就需要借助C语言来完成了。被native修饰的方法可以被C语言重写。

。。。。说白了就是有些方法底层是C 让我想起了unsafe，实现CAS是通过native方法获取数据在内存的地址实现的

FUK：这个问题牵扯这么多知识点么

总结一下 JVM堆用于储存对象（数组也算对象把），是对所有线程共享的，有老年代和新生代，新生代中还有哥Survivor区做缓冲

栈又分为本地方法栈和虚拟机栈，存放的是栈帧，栈帧记录了有常量池的引用，操作数栈，方法返回地址，局部变量表

本地方法栈其实就是native方法，底层是用c++实现的。

2.synchronized和volatile

这块我本以为准备的很充分，结果来了个问题我懵了

Jdk对线程的优化？？？？？？？？（我直接人傻了）

后面我想了想，其实只是这个问题太过于广泛。包括ConcurrentHashMap的锁从最开始的Segment（可重入锁）+ 分段锁 到 后面的CAS + synchronized 数据结构从segment + hashentry 数组+ 链表 改进到 数组+链表+红黑树 ， 也许这就是一种优化的体现吧。

本来我准备的是volatile (可见性，不保证原子性，有序性) -----> 为什么不保证原子性(因为可以对volatile变量进行++操作) -----> 解决方法 -------> CAS(compare and set) atomicinteger -------> CAS 会引发什么问题 解决方案 / unsafe类了解过么 -------> ABA 问题，unsafe中的方法是native方法

3.handler机制

为啥都喜欢问这个，就每次都背一遍，Looper， message， messageQueue， handler

Looper.prepare(); //这里就可以聊到looper了，looper是个好东西啊（等会再说）
Looper.loop(); // 这里其实是个死循环，不停从队列中取出message 然后msg.target.dispatchMessage(msg);
//这里出现了target

 private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        msg.target = this;  // 服了，在发送消息的时候target其实就是handler自己
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }



handler构造方法看一眼
public Handler(Callback callback, boolean async) {
        mLooper = Looper.myLooper();
        if (mLooper == null) {  // 校验looper
            throw new RuntimeException(
                "Can't create handler inside thread that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue; // 卧槽 队列原来是looper里的
        mCallback = callback;
        mAsynchronous = async;
    }

Looper这里先停一下，下面会聊到sendMessage了

中间又涉及到sendMessageDelayed( )和sendMessageAtTime( ) 这里就会有

问题2： 如何延迟执行

其实还可以用sleep(), 和定时器，还有个专门倒计时的类，我当时还说了可以用Rxjava

最后总结一下

private Handler mhandler = new  Handler(){  // 1. handler构造方法会绑定messageQueue
                @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); //2.sendmessage 其实就是最后就是MessageQueue的enqueueMessage（）
  3.线程类会执行完耗时操作，调用looper.loop() 开始无限循环 从链表中取出message,调用他们的handleMessage方法

4.锁

居然还碰到了这类问题，面试了5家，第一次出现这类问题

之前其实准备了一些：比如公平锁，非公平锁，乐观锁，悲观锁，可重入锁，自旋锁

问题：乐观锁和悲观锁区别

悲观锁就直接锁住就完事了，读锁（共享锁），写锁（排他锁）

乐观锁 举例CAS（Compare and set）

公平锁和非公平锁，就是一个插队问题

这里可以提到两个java常用的锁，ReentrantLock和synchronized

这里说下区别和相同点吧：

两者都是可重入锁

synchronized 依赖于 JVM，而 ReentrantLock 依赖于 API

使用方法： synchronized 可以对方法，类，对象直接使用，效果分别是锁方法是锁对象this，锁静态方法是锁所有调用此方法的线程，锁对象是锁以对象为锁的代码块。ReentrantLock则直接需要 lock() 和 unlock() 方法配合 try/finally 语句块来完成

ReentrantLock 增加了一些高级功能。主要有三点：① 等待可中断；② 可实现公平锁；③ 可实现选择性通知（锁可以绑定多个条件）

拓展掉头发系列： synchronized实现方法

要从java对象头说起，由于懒得复制粘贴，简单总结一下就是很多锁信息都会包含在对象头中，想了解对象头自行百度，Synchronized通常被称为重量级锁，但是1.6之后对其进行优化，新增了轻量级锁和偏向锁。

Synchronized用的就是monitor

监视器锁(monitor)是依赖于底层的操作系统的Mutex Lock来实现的，而操作系统实现线程之间的切换时需要从用户态转换内核态

偏向锁的核心思想是，如果一个线程获得了锁，那么锁就进入偏向模式，此时Mark Word 的结构也变为偏向锁结构，当这个线程再次请求锁时，无需再做任何同步操作，即获取锁的过程，这样就省去了大量有关锁申请的操作

与偏向锁的区别是，引入偏向锁是假设同一个锁都是由同一线程多次获得，而轻量级锁是假设同一个锁是由n个线程交替获得；相同点是都是假设不存在多线程竞争

5.数据结构的多线程问题

整明白CAS和各类锁之后，这里就很easy了

问： ArrayList是否线程安全，HashMap呢，HashSet实现？ HashTable？

ArrayList肯定不安全啊不然为啥会有Vetor

通过Collections.synchronizedList() 可以给list加锁 （HashMap同理）

接下来就是基于写时复制的CopyonWriteList （如何实现的） 用的ReentrantLock

写入的时候同时copy一份副本，最后返回的是副本

后面就是ConcurrentHashMap了 之前提到的Segment+HashEntry 以及改进后的CAS+synchronizedList 包括数据结构的改善 ，引入红黑树

HashSet底层基于HashMap 所以hashset也不安全 HashTable是锁方法，所以效率低，建议使用ConcurrentHashMap了

Android特有的SparseArray（知识点无非是稀疏矩阵的储存可以减少空间的消耗）但是二分查找要比HashMap慢一点。

6.Android程序启动流程相关

Looper什么时候产生？（Zygote创建新进程时就产生了）

这就要从Linux系统启动开始说起了，BootLoader是在操作系统内核运行之前运行，以便为最终调用操作系统内核准备好正确的环境（像普通电脑的bios？）

Zygote（受精卵 这个很形象 受精卵会进行fork，生成各种各样的进程）进程的启动，然后SystemServer就启动了，接着著名的AMS（Activity Manager Service）也会启动

照理每个Android app进程中默认一个进程里面只有一个线程，就是著名的主线程，通过Looper.loop()来进行任务的处理。

下面就是网上总结的一个Android app启动的流程

1.Click Event

2.Launcher进程（整个App启动流程的起点，负责接收用户点击屏幕事件，它其实就是一个Activity）

3.BInder IPC 跨进程通信告诉AMS，startActivity(); （这里涉及到的Binder IPC下面继续探讨）

4.分两种情况，1）进程未被创建，则通过Zygote fork一个新的进程 2）进程已经被创建，则直接LAUNCH_ACTIVITY

Binder 机制

网络上很多问题就是Android跨进程通讯方法有哪几种？（标准答案是：activity之间的数据通讯 ， content provider， broadcast ，service）这不就是四大组件么

这里就要从linux的IPC开始说起了 ：linux常用的管道，socket，甚至是内存共享，都不太适用于android

因为有几个重要的缺点，1：安全性，安全校验的数据只能包含在消息体里面，容易被伪造。

2：传统的IPC有两次数据复制的过程，而使用binder只会有一次

3：内存共享对安全性的保护也不够

binder 机制到底是个啥 ？

说白了就是为了跨进程通讯，又不必inux用户态和内核态之间频繁切换，采用C/S通信方式，的一种IPC（Inter-Process Communication）进程间通讯。

binder 拷贝为什么只有一次？

这里就要聊到mmap()了，而聊mmap()之前又要说到linux里的copy_from_user()和copy_to_user()，linux两个进程间交互，一般是用户甲copy_from_user()拷贝到内核空间，然后再用copy_to_user()拷贝到另一个用户空间，而mmap通过地址映射，很好的解决了多次拷贝的问题。

mmap到底做了啥？

mmap实现文件磁盘地址和进程虚拟地址空间中一段虚拟地址的一一对映关系，当用户想写数据时，将需要写入的数据直接copy到对应的mmap地址，若mmap地址未对应物理内存，则产生缺页异常，由内核处理。若已对应，则直接copy到对应的物理内存，由操作系统调用，将脏页回写到磁盘（通常是异步的），进程可以直接访问mmap的数据(page cache)。

binder的具体实现

AIDL(android interface definition language)对Binder的使用进行了封装，可以让开发者方便的进行方法的远程调用。Intent是最高一层的抽象，方便开发者进行常用的跨进程调用。

7.Android事件传递机制

从应用层角度和底层角度分析：

应用层：

从大方向，当用户点击屏幕后， 从与用户交互的Activity开始，到PhoneWindows，再到DecorView，接着ViewGroup，最后才是开发人员定义的控件。