安卓/Java面试笔记

进程与线程的区别？

1. 地址空间： 同一进程的所有线程共享本进程的地址空间，而不同的进程之间的地址空间是独立的。
2. 资源拥有： 同一进程的所有线程共享本进程的资源，如内存，CPU，IO等。进程之间的资源是独立的，无法共享。
3. 执行过程：每一个进程可以说就是一个可执行的应用程序，每一个独立的进程都有一个程序执行的入口，顺序执行序列。但是线程不能够独立执行，必须依存在应用程序中，由程序的多线程控制机制进行控制。
4. 健壮性： 因为同一进程的所以线程共享此线程的资源，因此当一个线程发生崩溃时，此进程也会发生崩溃。 但是各个进程之间的资源是独立的，因此当一个进程崩溃时，不会影响其他进程。因此进程比线程健壮。

线程执行开销小，但不利于资源的管理与保护。

进程的执行开销大，但可以进行资源的管理与保护。进程可以跨机器前移。

JAVA多线程的三种创建方式

在JAVA中，用Thread类代表线程，所有线程对象，都必须是Thread类或者Thread类子类的实例。每个线程的任务就是执行一段顺序执行的代码，JAVA使用线程执行体来容纳这段代码

第一种，通过继承Thread类创建线程类

通过继承Thread类来创建并启动多线程的步骤如下：

1、定义一个类继承Thread类，并重写Thread类的run()方法，run()方法的方法体就是线程要完成的任务，因此把run()称为线程的执行体；

2、创建该类的实例对象，即创建了线程对象；

3、调用线程对象的start()方法来启动线程；

第二种，通过实现Runnable接口创建线程类

这种方式创建并启动多线程的步骤如下：

1、定义一个类实现Runnable接口；

2、创建该类的实例对象obj；

3、将obj作为构造器参数传入Thread类实例对象，这个对象才是真正的线程对象；

4、调用线程对象的start()方法启动该线程；

匿名内部类的方式

适用于创建启动线程次数较少的环境，书写更加简便

//方式2:实现Runnable,Runnable作为匿名内部类

public class Demo3 {
  public static void main(String[] args) {
    //方式1：相当于继承了Thread类，作为子类重写run()实现
    new Thread() {
      public void run() {
        System.out.println("匿名内部类创建线程方式1...");
      };
    }.start();
    //方式2:实现Runnable,Runnable作为匿名内部类
    new Thread(new Runnable() {
      public void run() {
        System.out.println("匿名内部类创建线程方式2...");
      }
    } ).start();
  }
}

线程池的实现(java.util.concurrent.Executor接口)**

降低了创建线程和销毁线程时间开销和资源浪费

https://www.jb51.net/article/198304.htm#

Java线程池相关参数以及拒绝策略

线程总共有三个过程，分别是创建、使用、销毁。但是在实际使用中，服务器在创建和销毁线程上花费的时间和消耗的系统资源，甚至可能要比花在实际处理实际的用户请求的时间和资源要多的多。

线程池主要用来解决线程生命周期开销问题和资源不足问题，

由于在请求到达时线程已经存在，所以消除了创建所带来的延迟。这样，就可以立即请求服务，使应用程序响应更快。另外，通过适当的调整线程池中的线程数据可以防止出现资源不足的情况。

1. 降低资源消耗：通过重复利用已创建的线程降低线程创建和销毁造成的资源消耗。
2. 提高响应速度：当任务到达时，任务可以不需要等到线程创建就能立即执行
3. 提高线程的可管理性：线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。

1.AbortPolicy：该策略是线程池默认的策略，使用策略时，如果线程池的线程数满了，如果再有一个的任务进来，那么线程池会丢掉这个任务并且抛出RejectedExecutionException异常。

2.DiscardPolicy：这个策略和AbortPolicy的slient版本，如果线程池队列满了，再有新的任务进来，线程池则会直接丢掉这个任务并且不会有任何异常。

3.DiscardOldestPolicy：这个策略从字面上也很好理解，丢弃最老的。也就是说如果队列满了，会将最早进入队列的任务删掉腾出空间，再尝试加入队列。因为队列是队尾进，队头出，所以队头元素是最老的，因此每次都是移除对头元素后再尝试入队。

4.CallerRunsPolicy：使用此策略，如果添加到线程池失败，那么主线程会自己去执行该任务，不会等待线程池中的线程去执行。就像是个急脾气的人，我等不到别人来做这件事就干脆自己干。

参数corePoolSize = 5，maximumPoolSize = 10，BlockingQueue阻塞队列长度为5，此时有4个任务同时进来，问：线程池会创建几条线程？

JAVA集合

1.集合和数组的区别：

2.Collection集合的方法：

3.常用集合的分类：

Collection 接口的接口 对象的集合（单列集合）
├——-List 接口：元素按进入先后有序保存，可重复
│—————-├ LinkedList 接口实现类， 链表， 插入删除， 没有同步， 线程不安全
│—————-├ ArrayList 接口实现类， 数组， 随机访问， 没有同步， 线程不安全
│—————-└ Vector 接口实现类 数组， 同步， 线程安全
│ ———————-└ Stack 是Vector类的实现类
└——-Set 接口： 仅接收一次，不可重复，并做内部排序
├—————-└HashSet 使用hash表（数组）存储元素
│————————└ LinkedHashSet 链表维护元素的插入次序
└ —————-TreeSet 底层实现为二叉树，元素排好序

Map 接口 键值对的集合 （双列集合）
├———Hashtable 接口实现类， 同步， 线程安全
├———HashMap 接口实现类 ，没有同步， 线程不安全-
│—————–├ LinkedHashMap 双向链表和哈希表实现
│—————–└ WeakHashMap
├ ——–TreeMap 红黑树对所有的key进行排序
└———IdentifyHashMap
————————————————二、List和Set集合详解：
1.list和set的区别：

2.List：
（1）ArrayList：底层数据结构是数组，查询快，增删慢，线程不安全，效率高，可以存储重复元素
（2）LinkedList 底层数据结构是链表，查询慢，增删快，线程不安全，效率高，可以存储重复元素
（3）Vector:底层数据结构是数组，查询快，增删慢，线程安全，效率低，可以存储重复元素

（4小结：

Vector为什么要用加倍扩容而不是每次增加一个固定的扩容容量？

我先了解了一下vector的扩容原理，vecctor底层是数组结构，是一段连续的数组，当集合也就是数组装满以后，如果还需要增加数据，为保证连续性，会重新申请更大的内存空间，然后将现有数据复制到新的内存空间中，再将新增数据添加到数组里面，释放原来的内存，其内存地址也相应改变，指向原vector的所有迭代器就都会失效。

为什么vector增长为原来的一倍，而arrayList增长为原来的一半？
ArrayList有两个属性，存储数据的数组elementData，和存储记录数目的size。
Vector有三个属性，存储数据的数组elementData，存储记录数目的elementCount，还有扩展数组大小的扩展因子 capacityIncrement。

对比两者结构，arrayList没有扩展因子，也就是说vector可以指定每次增长的容量，arrayList不可以指定扩展大小。

数据库事务

1. 原子性

事务是一个完整的操作。事务的各元素是不可分的（原子的）。事务中的所有元素必须作为一个整体提交或回滚。如果事务中的任何元素失败，则整个事务将失败。

以银行转账事务为例，如果该事务提交了，则这两个账户的数据将会更新。如果由于某种原因，事务在成功更新这两个账户之前终止了，则不会更新这两个账户的余额，并且会撤销对任何账户余额的修改，事务不能部分提交。

2. 一致性

当事务完成时，数据必须处于一致状态。也就是说，在事务开始之前，数据库中存储的数据处于一致状态。在正在进行的事务中. 数据可能处于不一致的状态，如数据可能有部分被修改。然而，当事务成功完成时，数据必须再次回到已知的一致状态。通过事务对数据所做的修改不能损坏数据，或者说事务不能使数据存储处于不稳定的状态。

以银行转账事务事务为例。在事务开始之前，所有账户余额的总额处于一致状态。在事务进行的过程中，一个账户余额减少了，而另一个账户余额尚未修改。因此，所有账户余额的总额处于不一致状态。事务完成以后，账户余额的总额再次恢复到一致状态。

3. 隔离性

对数据进行修改的所有并发事务是彼此隔离的，这表明事务必须是独立的，它不应以任何方式依赖于或影响其他事务。修改数据的事务可以在另一个使用相同数据的事务开始之前访问这些数据，或者在另一个使用相同数据的事务结束之后访问这些数据。

另外，当事务修改数据时，如果任何其他进程正在同时使用相同的数据，则直到该事务成功提交之后，对数据的修改才能生效。张三和李四之间的转账与王五和赵二之间的转账，永远是相互独立的。

4. 持久性

事务的持久性指不管系统是否发生了故障，事务处理的结果都是永久的。

一个事务成功完成之后，它对数据库所作的改变是永久性的，即使系统出现故障也是如此。也就是说，一旦事务被提交，事务对数据所做的任何变动都会被永久地保留在数据库中。

1）脏读

指一个事务读取到另一个事务未提交的数据。

2）不可重复读

指一个事务对同一行数据重复读取两次，但得到的结果不同。

3）虚读/幻读

指一个事务执行两次查询，但第二次查询的结果包含了第一次查询中未出现的数据。

4）丢失更新

指两个事务同时更新一行数据，后提交（或撤销）的事务将之前事务提交的数据覆盖了

1）Read Uncommitted（读未提交）

一个事务在执行过程中，既可以访问其他事务未提交的新插入的数据，又可以访问未提交的修改数据。如果一个事务已经开始写数据，则另外一个事务不允许同时进行写操作，但允许其他事务读此行数据。此隔离级别可防止丢失更新。

2）Read Committed（读已提交）

一个事务在执行过程中，既可以访问其他事务成功提交的新插入的数据，又可以访问成功修改的数据。读取数据的事务允许其他事务继续访问该行数据，但是未提交的写事务将会禁止其他事务访问该行。此隔离级别可有效防止脏读。

3）Repeatable Read（可重复读取）

一个事务在执行过程中，可以访问其他事务成功提交的新插入的数据，但不可以访问成功修改的数据。读取数据的事务将会禁止写事务（但允许读事务），写事务则禁止任何其他事务。此隔离级别可有效防止不可重复读和脏读。

4）Serializable（可串行化）

提供严格的事务隔离。它要求事务序列化执行，事务只能一个接着一个地执行，不能并发执行。此隔离级别可有效防止脏读、不可重复读和幻读。但这个级别可能导致大量的超时现象和锁竞争，在实际应用中很少使用。

b+树和b树区别，为什么不用avl树

平衡二叉树的缺点就是：（1）维护平衡过程的成本代价很高，因为每次删除一个节点或者增加一个节点的话，需要一次或者多次的左旋，右旋等去维护“平衡”状态，（2）然后是查询的效率不稳定，还是会有看运气的成分在里面，（3）然后是如果节点很多的话，那么这个AVL树的高度还是会很高的，那么查询效率还是会很低，
————————————————

B Tree（多路平衡查找树）

1. 首先你也得知道B Tree的基本概念：所有的叶子节点的高度都是一样，这个保证了每次查询数据的时候都是稳定的查询效率，不会因为运气的影响
2. 然后B Tree中其实每个非叶子节点内的小节点内其实都是一个二元组[key, data]
3. 然后是B Tree查询的效率不够稳定，他有可能在第一个节点中就查到了数据，并且返回
4. 他的键值其实都是分布在整棵树上的节点上的任何一个节点

B+ Tree（多路平衡查找树）

1. 首先你要知道什么B+ Tree，其实他是专门为磁盘或者其他的直接存取辅助设备设计的一种平衡查找树，在B树中，所有的节点都是按照键值的大小顺序存放在同一层的叶子节点上，由各叶子节点的指针连接。

每一个非叶子节点的内节点中都没有date这个概念了，都变成了key，因为他的date都放在了叶子节点上，这样的一个最大的好处就利用了局部性原理（当一个数据被用到时，其附近的数据也通常会马上被使用）与磁盘预读的特性（磁盘往往不是严格按需读取，而是每次都会预读

1. B+Tree中因为数据都在叶子节点，所以每次查询的时间复杂度是固定的，因为稳定性保证了
2. 而且叶子节点之间都是链表的结构，所以B+ Tree也是可以支持范围查询的，而B树每个节点 key 和 data 在一起，则无法区间查找。

网页输入网址后到显示的全过程

1、在浏览器地址栏输⼊URL

2、浏览器查看缓存，如果请求资源在缓存中并且新鲜，跳转到转码步骤

如果资源未缓存，发起新请求

如果已缓存，检验是否⾜够新鲜，⾜够新鲜直接提供给客户端，否则与服务器进⾏验证。

检验新鲜通常有两个HTTP头进⾏控制 Expires 和 Cache-Control：

HTTP1.0提供 Expires，值为⼀个绝对时间表示缓存新鲜⽇期
HTTP1.1增加了Cache-Control: max-age=time，值为以秒为单位的最⼤新鲜时间
3、浏览器解析URL获取协议，主机，端⼝，path

4、浏览器组装⼀个HTTP（GET）请求报⽂

5、浏览器获取主机 ip 地址，过程如下：

浏览器缓存

本机缓存

hosts⽂件

路由器缓存

ISP DNS缓存

DNS递归查询（可能存在负载均衡导致每次IP不⼀样）

6、打开⼀个socket与⽬标IP地址，端⼝建⽴TCP链接，三次握⼿如下：

客户端发送⼀个TCP的SYN=1，Seq=X的包到服务器端口

服务器发回SYN=1， ACK=X+1， Seq=Y的响应包

客户端发送ACK=Y+1， Seq=Z

7、TCP链接建⽴后发送HTTP请求

8、服务器接受请求并解析，将请求转发到服务程序，如虚拟主机使⽤HTTP Host头部判断请求的服务程序

9、服务器检查HTTP请求头是否包含缓存验证信息，如果验证缓存新鲜，返回304等对应状态码

10、处理程序读取完整请求并准备HTTP响应，可能需要查询数据库等操作

11、服务器将响应报⽂通过TCP连接发送回浏览器

12、浏览器接收HTTP响应，然后根据情况选择关闭TCP连接或者保留重⽤，关闭TCP连接的四次握⼿如下：

主动⽅发送Fin=1， Ack=Z， Seq= X报⽂

被动⽅发送ACK=X+1， Seq=Z报⽂

被动⽅发送Fin=1， ACK=X， Seq=Y报⽂

主动⽅发送ACK=Y， Seq=X报⽂

13、浏览器检查响应状态吗：是否为1XX，3XX， 4XX， 5XX，这些情况处理与2XX不同

14、如果资源可缓存，进行缓存

15、对响应进行解码（例如gzip压缩）

16、根据资源类型决定如何处理（假设资源为HTML⽂档）

17、解析HTML⽂档，构件DOM树，下载资源，构造CSSOM树，执⾏js脚本，这些操作没有严 格的先后顺序，以下分别解释：

16、构建DOM树：

Tokenizing：根据HTML规范将字符流解析为标记

Lexing：词法分析将标记转换为对象并定义属性和规则

DOM construction：根据HTML标记关系将对象组成DOM树

17、解析过程中遇到图⽚、样式表、js⽂件，启动下载

18、构建CSSOM树：

Tokenizing：字符流转换为标记流

Node：根据标记创建节点

CSSOM：节点创建CSSOM树

19、根据DOM树和CSSOM树构建渲染树 :

从DOM树的根节点遍历所有可⻅节点，不可⻅节点包括：

script , meta 这样本身 不可⻅的标签。
被css隐藏的节点，如 display: none
对每⼀个可⻅节点，找到恰当的CSSOM规则并应⽤

发布可视节点的内容和计算样式

20、js解析如下：

浏览器创建Document对象并解析HTML，将解析到的元素和⽂本节点添加到⽂档中，此时document.readystate为loading

HTML解析器遇到没有async和defer的script时，将他们添加到⽂档中，然后执⾏⾏内 或外部脚本。这些脚本会同步执⾏，并且在脚本下载和执⾏时解析器会暂停。这样就可以⽤document.write()把⽂本插⼊到输⼊流中。同步脚本经常简单定义函数和注册事件处理程序，他们可以遍历和操作script和他们之前的⽂档内容

当解析器遇到设置了async属性的script时，开始下载脚本并继续解析⽂档。脚本会在它 下载完成后尽快执⾏，但是解析器不会停下来等它下载。异步脚本禁止使⽤ document.write()，它们可以访问⾃⼰script和之前的⽂档元素

当⽂档完成解析，document.readState变成interactive

所有defer脚本会按照在⽂档出现的顺序执⾏，延迟脚本能访问完整⽂档树，禁止使⽤ document.write()

浏览器在Document对象上触发DOMContentLoaded事件

此时⽂档完全解析完成，浏览器可能还在等待如图⽚等内容加载，等这些内容完成载⼊ 并且所有异步脚本完成载⼊和执⾏，document.readState变为complete，window触发 load事件

21、显示⻚⾯（HTML解析过程中会逐步显示⻚⾯）
7212575

JVM运行时区域由哪几部分组成

线程共享区域：

Java堆：

（1）Java堆是java虚拟机所管理的内存中最大的一块；

（2）被所有线程共享区域，在虚拟机启动时创建，唯一目的存放对象实例；

（3）堆区是gc的主要区域，通常情况下分为两个区块年轻代和年老代。更细一点年轻代又分为Eden区最要放新创建对象，From survivor 和 To survivor 保存gc后幸存下的对象，默认情况下各自占比 8:1:1。 进一步划分的目的是为了更还的内存回收或者更快的内存分配；

（4）会有异常OutOfMemoneyError；

方法区：

（1）被所有线程共享区域，用于存放已被虚拟机加载的类信息，常量，静态变量等数据。被Java虚拟机描述为堆的一个逻辑部分。习惯是也叫它永久代（仅仅是因为HotSpot虚拟机选择把GC分代收集扩展至方法区）；

（2）垃圾回收很少光顾这个区域，不过也是需要回收的，主要针对常量池回收，类型卸载。

（3）会有异常OutOfMemoneyError；

线程私有区域：

程序计数器：

（1）当前线程所执行的字节码指令的行号指示器，如分支、跳转、循环、异常处理、线程恢复都依赖程序计数器实现；

（2）Java多线程是通过线程轮流切换并分配CPU时间片来执行的，为了线程切换后能恢复到正确的位置，所以每个线程都有一个单独的程序计数器，所以程序计数器是私有的；

（3）Jvm没有规定OutOfMemory的区块；

Java虚拟机栈：

（1）为执行Java方法服务‘

（2）当线程创建的时候，为线程分配一块内存区域，在线程执行的过程中，每个方法的执行都会创建一个栈帧，用于存放局部变量表、操作栈、
动态链接，方法出口等。每个方法从被调用，直到被执行完。对应着一个栈帧在虚拟机中从入栈到出栈的过程；

（3）会有两种异常StackOverFlowError和 OutOfMemoneyError。当线程请求栈深度大于虚拟机所允许的深度就会抛出StackOverFlowError错误；虚拟机栈动态扩展，当扩展无法申请到足够的内存空间时候，抛出OutOfMemoneyError；

（4）它是线程私有的，生命周期与线程相同；

本地方法栈：

（1）与java虚拟机栈所发挥的作用非常相似，它们之间的区别在于java虚拟机栈执行java方法服务的，本地方法栈是执行本地方法服务的

gc垃圾回收，回收哪些区域

https://blog.csdn.net/sj15814963053/article/details/109562162

JVM GC只回收堆区和方法区内的对象。而栈区的数据，在超出作用域后会被JVM自动释放掉，所以其不在JVM GC的管理范围内。

判断对象可以回收的方法

引用计数法

给对象中添加一个引用计数器，每当有一个地方引用它时，计数器值就加1；当引用失效时，计数器值就减1；任何时刻计数器为0的对象就是不可能再被使用的。

它的优点是简单、高效，但是缺点也是异常明显：这个方法无法解决对象循环引用的问题

可达分析算法

基于引用计数法无法回收循环应用，我们就有了一种新的方法。

可达分析算法，或叫根搜索算法，在主流的JVM中，都是使用的这种方法来判断对象是否存活的。这个算法的思路很简单，它把内存中的每一个对象都看作一个结点，然后定义了一些可以作为根结点的对象，我们称之为GC Roots。如果一个对象中有另一个对象的引用，那么就认这个对象有一条指向另一个对象的边。
————————————————

什么对象可以当作GC Roots？

虚拟机栈中的引用对象

我们在程序中正常创建一个对象时，对象会在堆上开辟一块内存空间，同时会将这块空间的地址作为引用保存到虚拟机栈中，如果对象生命周期结束了，那么引用就会从虚拟机栈中出栈，因此如果在虚拟机栈中有引用，就说明这个对象还是有用的，这种对象可以作为GC Roots。

全局的静态的对象

也就是使用了static关键字定义了的对象，这种对象的引用保存在共有的方法区中，因为虚拟机栈是线程私有的，如果保存在栈里，就不叫全局了，很显然，这种对象是要作为GC Roots的。

常量引用

就是使用了static final关键字，由于这种引用初始化之后不会修改，所以方法区常量池里的引用的对象也作为GC Roots。

本地方法栈中JNI引用的对象

有时候单纯的java代码不能满足我们的需求，就可能需要调用C或C++代码（java本身就是用C和C++写的嘛），因此会使用native方法，JVM内存中专门有一块本地方法栈，用来保存这些对象的引用，所以本地方法栈中引用的对象也会被作为GC Roots。

垃圾回收算法

标记清除算法

复制算法

标记压缩算法

volatile和synchronized的区别

volatile本质是在告诉jvm当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取； synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。
volatile仅能使用在变量级别；synchronized则可以使用在变量、方法、和类级别的
volatile仅能实现变量的修改可见性，不能保证原子性；而synchronized则可以保证变量的修改可见性和原子性
volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞。
volatile标记的变量不会被编译器优化；synchronized标记的变量可以被编译器优化

ReenTrantLock可重入锁（和synchronized的区别）

从名字上理解，ReenTrantLock的字面意思就是再进入的锁，其实synchronized关键字所使用的锁也是可重入的，两者关于这个的区别不大。两者都是同一个线程没进入一次，锁的计数器都自增1，所以要等到锁的计数器下降为0时才能释放锁。

ReenTrantLock独有的能力：

1. ReenTrantLock可以指定是公平锁还是非公平锁。而synchronized只能是非公平锁。所谓的公平锁就是先等待的线程先获得锁。
2. ReenTrantLock提供了一个Condition（条件）类，用来实现分组唤醒需要唤醒的线程们，而不是像synchronized要么随机唤醒一个线程要么唤醒全部线程。
3. ReenTrantLock提供了一种能够中断等待锁的线程的机制，通过lock.lockInterruptibly()来实现这个机制。

ReenTrantLock实现的原理：

在网上看到相关的源码分析，本来这块应该是本文的核心，但是感觉比较复杂就不一一详解了，简单来说，ReenTrantLock的实现是一种自旋锁，通过循环调用CAS操作来实现加锁。它的性能比较好也是因为避免了使线程进入内核态的阻塞状态。想尽办法避免线程进入内核的阻塞状态是我们去分析和理解锁设计的关键钥匙。
ils/65441415

接口与抽象类的区别

相同点

（1）都不能被实例化 （2）接口的实现类或抽象类的子类都只有实现了接口或抽象类中的方法后才能实例化。

不同点

（1）接口只有定义，不能有方法的实现，java 1.8中可以定义default方法体，而抽象类可以有定义与实现，方法可在抽象类中实现。

（2）实现接口的关键字为implements，继承抽象类的关键字为extends。一个类可以实现多个接口，但一个类只能继承一个抽象类。所以，使用接口可以间接地实现多重继承。

（3）接口强调特定功能的实现，而抽象类强调所属关系。

（4）接口成员变量默认为public static final，必须赋初值，不能被修改；其所有的成员方法都是public、abstract的。抽象类中成员变量默认default，可在子类中被重新定义，也可被重新赋值；抽象方法被abstract修饰，不能被private、static、synchronized和native等修饰，必须以分号结尾，不带花括号。

【算法】如何判断链表有环

方法一、穷举遍历

O(N*N)。而此算法没有创建额外存储空间，空间复杂度可以简单地理解成为O(1)

方法二、哈希表缓存

O(N)。而算法的空间复杂度还是D+S-1，可以简单地理解成O(N)。

方法三、快慢指针

为O（N）。除了两个指针以外，没有使用任何额外存储空间，所以空间复杂度是O（1）。

**方法四、Set集合大小变化

O（N），空间复杂度上因为需要额外等数量的存储空间，所以空间复杂度是O（n）。

Android常用存储：

Android平台进行数据存储的五大方式,分别如下:

• 1 使用SharedPreferences存储数据
• 2 文件存储数据
• 3 SQLite数据库存储数据
• 4 使用ContentProvider存储数据
• 5 网络存储数据

线程安全三大特性 1.原子性 2.可见性 3.有序性

synchronized同步代码块 可以实现 原子性，可见性，有序性 volatile 可以实现 可见性，有序性

①原子性 指定代码块是原子操作。

②可见性 修改共享变量时，立即同步到主存中，并使该修改对其他线程可见

③有序性 禁止读取共享变量后的代码、修改共享变量前的代码重排序。

五种进程优先级：

系统当然要保证用户体验，所以重要等级的划分原则就是要首先满足用户当前的需求：用户正在使用的当然不能关闭，而用户暂时不需要的，相对的就没那么重要了。

1.Foreground process 前台进程：也就是用户正在进行操作的进程。这样的进程优先级（优先保留）最高，最不容易销毁，因为它表现在屏幕上，直接同用户进行交互，所以只有当内存资源极度紧张等一些其他极端情况才会关闭，表现为“闪退”。我用的第一台 Android 手机运行内存（RAM）只有 290M，多任务时经常内存不足导致程序“闪退”。这手机我竟然用了两年，现在想想都佩服我自己hhhh。

不只是界面交互，如果应用程序中的服务（service）组件正在进行一些操作或者广播接收者（BroadcastReceiver）在执行接收广播的操作（onReceive）时，该进程仍被视为前台进程。

2.Visible process 可视进程：顾名思义，就是仍然在屏幕上有显示，但用户不再能直接与它交互的程序。比如当在应用中打开下滑菜单时（有些下滑菜单是透明的），用户能“看得到”，但是“摸不着”。优先级仅次于前台进程。

3.Service process 服务进程：该进程中开启了一个服务（通过startService方法）。注意这里强调的是服务的“开启”，区别于第一类中的“服务正在执行一些操作”。大多数音乐软件都是通过这种方法来保留其播放音乐的进程。

4.Background process 后台进程：当你按下 HOME 键或 BACK 键时，手机退回主界面，此时应用程序不再可见，转入后台运行。如果如果不满足前几类的条件，这个进程就会被判定为后台进程。

5.Empty process 空进程：A process that doesn’t hold any active application components.没有任何组件在运行，包括活动界面（Activity）。事实上用户已经不再需要这个进程了，但出于 Android 系统“尽可能保留进程”的原则，这样的进程出现后不会被立即销毁。保留进程的唯一理由，就是为了下次开启这个应用时能快一些。其实现在的手机硬件性能足够好，这样的缓存对于用户体验的提升效果不怎么明显。这样的进程最不重要，将首先被销毁。

单例模式的实现

Singleton 模式通常有两种实现形式。

第 1 种：懒汉式单例

该模式的特点是类加载时没有生成单例，只有当第一次调用 getlnstance 方法时才去创建这个单例。代码如下：

public class LazySingleton {
    private static volatile LazySingleton instance = null;    //保证 instance 在所有线程中同步

    private LazySingleton() {
    }    //private 避免类在外部被实例化

    public static synchronized LazySingleton getInstance() {
        //getInstance 方法前加同步
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

注意：如果编写的是多线程程序，则不要删除上例代码中的关键字 volatile 和 synchronized，否则将存在线程非安全的问题。如果不删除这两个关键字就能保证线程安全，但是每次访问时都要同步，会影响性能，且消耗更多的资源，这是懒汉式单例的缺点。

第 2 种：饿汉式单例

该模式的特点是类一旦加载就创建一个单例，保证在调用 getInstance 方法之前单例已经存在了。

public class HungrySingleton {
    private static final HungrySingleton instance = new HungrySingleton();

    private HungrySingleton() {
    }

    public static HungrySingleton getInstance() {
        return instance;
    }
}

饿汉式单例在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以是线程安全的，可以直接用于多线程而不会出现问题。