2018面试收集

buffer

1、接口如何保证幂等性（接口可重复调用，在调用方多次调用的情况下，接口最终得到的结果是一致的。）

查询接口本身具有幂等性
a、全局唯一id，根据业务操作生成一个全局唯一id，在执行前根据唯一id判断这个操作是否存在，如果不存在则插入，存在则进行一些其它操作
b、根据业务来订唯一标识，设置成表的唯一索引，把创建和写入放到同一个事物中，如果订单号重复则 数据库会抛出唯一约束异常，操作会回滚。
c、多版本控制
适用在更新场景中，比如更新商品名字， 在条件中带上版本号或时间戳

update goods set name=#{newName},version=#{version} where id=#{id} and version=${version}
update goods set name=#{newName},version=#{version} where id=#{id} and version<${version}

2、redis锁原理

3、hashset\treeset区别

hashset:无序，不可重复集合。只用到hashmap,key部分
treeset:根据key排序的有序集合，底层实现红黑树

4、一些集合

arraylist,linklist,map,set,queue,stack,vector

5、jdK 1.8新特性

参考：http://www.open-open.com/lib/view/open1403232177575.html
* 1、lamada表达式，使代码更简洁
* 2、接口默认方法及静态方法，可以让子类直接继承接口方法
* 3、方法引用

构造方法引用：class::new
静态方法引用：class:static_method
特殊类方法引用： class::method
实列对象方法引用： object::method
* 4、引入optional容器，避免空指针
* 5、引入stream api，引入编程式函数，对集合操作更加方便。
* 6、DATE\TIME日期处理类，对日期操作更加方便

6、什么情况会出现oom

答：（堆空间不够，对象没有被回收
代码中有死循环、启的线程太多不够用→调整代码减少创建线#程数、堆空间确实分配置太小→调整启 动参数 加大堆空间
）;
找出泄露的对象是怎么被GC ROOT引用起来，然后通过引用链来具体分析泄露的原因。
哪些对角可以作为gcroot,方法栈中的对象引用，方法区的静态属性引用对象，方法区常量引用对象
什么情况会出现栈溢出
：要么是方法调用层次过多,比如存在无限递归调用；
大量循环或死循环；全局变量是否过多；数组、List、map数据过大

7、group_concat(name)

根据key分组后，把同组的字段连接起来

8、数据库索引是用什么实现的

Btree（平衡树，非二叉树）实现参考：https://github.com/Mr-YangCheng/ForAndroidInterview/tree/master/data%20structure
b树性质：
M为树的阶数，B-树或为空树，否则满足下列条件：
1.　根结点的儿子数为[2, M]；
2.　非叶子结点最多只有M个儿子；且M>2；
3.　除根结点以外的非叶子结点的儿子数为[M/2, M]；
4.　每个结点存放至少M/2-1（取上整）和至多M-1个关键字；（至少2个关键字）
5.　非叶子结点指针个数=非叶子结点的关键字个数+1；
6.　非叶子结点的关键字：K[1], K[2], …, K[M-1]；且K[i] < K[i+1]；
7.　非叶子结点的指针：P[1], P[2], …, P[M]；其中
P[1]指向关键字 < K[1]的子树，
P[M]指向关键字 > K[M-1]的子树，
k[i-1] < P[i]指向的关键字 < K[i]；
8.　所有叶子结点位于同一层；

b+树性质：
b+是b树变体，也是一种多路搜索树，其定义基本与B树同，除了
１.　非叶子结点的子树指针与关键字个数相同；
２.　非叶子结点的子树指针P[i]，指向关键字值属于[K[i], K[i+1])的子树（B-树是开区间）；
３.　为所有叶子结点增加一个链指针；
４.　所有关键字都在叶子结点出现；

B＋树与Ｂ树的区别
1.　所有关键字都出现在叶子结点的链表中（稠密索引），且链表中的关键字恰好是有序的；
2.　不可能在非叶子结点命中；
3.　非叶子结点相当于是叶子结点的索引（稀疏索引），叶子结点相当于是存储（关键字）数据的数据层；
4.　更适合文件索引系统；
　　 B+的搜索与B-树也基本相同，区别是B+树只有达到叶子结点才命中（B-树可以在非叶子结点命中），其性能也等价于在关键字全集做一次二分查找；

a、聚集索此：表如果不加主键就是一行一行数据，加上主键过程就是变成一个平衡树结构，整个表变成索引。主键是聚集索此。
b、非聚集索引：平时用的常规索引，也是用平衡树作为索引的数据结构。
聚集和非聚集索引区别：通过非聚集索引查到记录对应主键，再通过主键（聚集索引）查到数据。
c、覆盖索引（复合索引）：
通过非聚集索引找到记录主键，通过主键查出数据，再从数据中查找出复合索引其它字段条件数据。

二、JAVA问题总结

java 基础

1、java数据类型

2、谈一谈 “==” 跟 “equals” 的区别

答：＝＝是指对象所指地址是否是同一个，equals对较对象值是否相等

3、jvm 的性能调优（三年以上的工作经历问的比较多）最好多掌握（https://www.jianshu.com/p/c6a04c88900a）

答：java性能调优 。1、jdk工具使用：jps列出正在运行的虚拟机进程 ,jstat监视虚拟机运行状态，jmap生成堆存储快照，jstack生成当前线程快照
2、调优策略：转移到老年代对象数量降到最少；减少full gc执行时间 。
设置堆内存大小，启动大小，最大限制
设置新生代大小，不能太小，否则大量对象进入老年代
设置新生代和老年代占比

集合是个重灾区： 回答的好，基本面试官会觉得你的基础怎么样的 天平

4、arrayList LinkedList Vector 的区别 底层问的多

答：arraylist \vector是数组结构，vector是线程安全的，如果不要求线程安全尽量用arraylist ，定位比较快;linkedlist双向链，对插入删除比较快

5、红叉树数据结构考试题出的多

自平衡二叉查找树，1节点是红色或黑色2根节点是黑色3每个叶子节点都是黑色的nil节点4每个红节点的2个子节点都是黑色5从任何节点到叶子节点黑节点数相同

Set

6、hashset 跟 treeset

答：1重写对象compareTo方法2传入comparator方法，实现集合排序，这种方法比较灵活
treeset 两种实现排序的底层方法

Map 问的是最多的

7、HashMap HashTable 区别 HashMap 的底层实现原理

答：hashtable是线程安全的，hashmap就是散列表，底层是数组结构，每个数组是一个hashentry链表。当发生冲突是用冲突链解决的，直接用Key计算出hashcode定位到散列表地址加到冲突链中。如何扩容*2倍，初始大小就是2的幂次方

8、ConcurrentHashMap 的实现原理

答：jdk1.7是segment数据加hashmap实现，segment继承reenterlock自带锁功能，分段锁2次定位地址，put时 选定segment位置 ，再进行加锁（并判断是否需要扩容），只扩容对应的segment下的hashentry数组。计算size在小先2次不加锁计算如果一致返回，如果不一致再进行加锁计算。
jdk1.8直接用node数组+链表/红黑树+cas实现。首插时先初始化数组，定位的数组位置 如果没有值用cas插入，如果有值，判断是链表，链表长度是否超过8需要转到红黑树，如果是红黑数直接插入。 扩容：新建一个2倍的数组，从后向前复制，处理完的记frw 指向新数组头部
HashMap 跟 ConcurrentHashMap 底层问的偏多

9、TreeMap LinkedHashMap HashMap 的区别

答：treemap会要据Key排序，Linkedhashmap 双向链加hashmap实现，双向链记录插入顺序，hashmap无序。
treeMap，实现2种方法排序，1：treeMap中对象重写compareTo方法，2：传入一个comparable对象。

java 中的线程问题

10、synchronized 跟 volatile 区别

答：synchronized实现线程安全，保证synchronized的方法或代码段一次只有一个线程能访问。volatile主要是实现线程可见性和指命重排序，不能保证原子性。
synchronized是用moitorenter,moitorexist指令实现；volatile用内存屏障实现;内存屏障分为读屏障，写屏障。读屏障：让高速缓存中数据失败，强制从主存中读取数据；写屏障：让写入缓存中的数据强制刷入主存，让其它线程可见。除了volatile实用内存屏障外，还有final语义中也使用内存屏障，保证在final写入对其它线程可见。
内存屏障参考：https://www.jianshu.com/p/2ab5e3d7e510

11、实现创建新线程的方法 3种 有返回值实现方式好处

答：直接继承thread类，实现runnable接口，实现callable接口

12、面试官喜欢问你

有没有用过线程池，有没有设计过线程池方面的代码
答：有用过线程池，对前用过jdbc线程池，用linklist实现的

13、三年以上工作经历

常见的设计模式（多说设计模式种类） 最好能说出我们的spring、 tomcat中底层的一些实现那些功能 用到哪几种设计模式（bean 的注入跟管理）
答：spring中的两大核心 依赖注入aop 跟 控制反转 ioc 需要仔细琢磨透
springmvc 跟 struts2.0 区别

14、mybatis 跟 hibernate、 jdbc 的区别 优缺点

15、springmvc 的流程 一个请求request请求， 经历了那些 ； 最好能画出 springmvc的流程图

答：1. 用户向服务器发送请求，请求被Spring 前端控制Servelt DispatcherServlet捕获；
2. DispatcherServlet对请求URL进行解析，得到请求资源标识符（URI）。然后根据该URI，调用HandlerMapping获得该Handler配置的所有相关的对象（包括Handler对象以及Handler对象对应的拦截器），最后以HandlerExecutionChain对象的形式返回；
3. DispatcherServlet 根据获得的Handler，选择一个合适的HandlerAdapter。（附注：如果成功获得HandlerAdapter后，此时将开始执行拦截器的preHandler(…)方法）
4. 提取Request中的模型数据，填充Handler入参，开始执行Handler（Controller)。
5. Handler执行完成后，向DispatcherServlet 返回一个ModelAndView对象；
6. 根据返回的ModelAndView，选择一个适合的ViewResolver（必须是已经注册到Spring容器中的ViewResolver)返回给DispatcherServlet ；
7. ViewResolver 结合Model和View，来渲染视图
8. 将渲染结果返回给客户端。

16、我们都知道spring 是单利 如果实现多利； 怎么做？

spring中问的东西 对你的面试效果权重很高；

17、applicationContext通常实现什么

bean工厂

18、spring 那些注解 需要掌握

19、spring事务管理机制

答：申明式事务管理、编程式事务管理。spring常用申明式事务管理，这代码侵入性比较小。事物几种级别
require: methodA调用方法methodB(require)，若methodA有事物，则不再启事物；或methodA没有事物则启一个事物。即当methodA或methodB任何一个方法出现异常事物都会回滚
require_new:methodB会新启一个事物，2个事物独立，不影响
suport:methodA调用methodB(suport)，如果methodA有事物，支持事物执行，如果没有事物，则直接按无事物执行

spring底层原理 需要掌握；3年以上

20、 spring aop动态代理 2种方式

JDK动态代理和CGLIB动态代理。JDK动态代理通过反射来接收被代理的类，并且要求被代理的类必须实现一个接口。JDK动态代理的核心是InvocationHandler接口和Proxy类。
如果目标类没有实现接口，那么Spring AOP会选择使用CGLIB来动态代理目标类。CGLIB（Code Generation Library），是一个代码生成的类库，可以在运行时动态的生成某个类的子类，注意，CGLIB是通过继承的方式做的动态代理，因此如果某个类被标记为final，那么它是无法使用CGLIB做动态代理的。
Jdk动态代理代码参考

//代理类实现ProxyHandler,重写invoke方法(代理方法)
public class ProxyHandler implements InvocationHandler{
    // 真实业务对象
    private Object target;
    public ProxyHandler(Class clazz){
        try {
          this.target = clazz.newInstance();
        } catch (InstantiationException | IllegalAccessException ex) {
          LOG.error("Create proxy for {} failed", clazz.getName());
        }
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 增强逻辑
        System.out.println("PROXY : " + proxy.getClass().getName());
        // 反射调用，目标方法
        Object result = method.invoke(target, args);
        // 增强逻辑
        System.out.println(method.getName() + " : " + result);
        return result;
    }
}
public class JDKDynamicProxyClient {
  public static void main(String[] args) {
    InvocationHandler handler = new ProxyHandler(ConcreteSubject.class);
    ISubject proxy =
        (ISubject) Proxy.newProxyInstance(JDKDynamicProxyClient.class.getClassLoader(),
            new Class[] {ISubject.class}, handler);
    proxy.action();
  }
}

21、java IO 跟NIO的区别 我面试过程没有遇到过，可以相应的了解

答：io是面向流的，我们需要每次从流中读取一个或多个字符，直到读完所有字符。nio是面向缓冲的，会把数据读到缓冲区，然后地缓存区中的数据处理；io是阻塞io，nio是非阻塞；nio存在一个选择器，它充许多个通道注册到一个选择器上，然后用一个线程监视这些通道，若这些通道中有一个可以开始读写，则开始对相应的通道进行读写。而在等待某通道变为可读/写期间，请求对通道进行读写操作的线程可以去干别的事情。

22、java8的新特性 需要掌握

• 引用lamda表达式，使代码更加简洁
• 接口默认方法及静态方法，可以让子类直接继承，或重写方法
• 方法引用
• 引入steam api，方便操作集合，引入函数式编程
• 引入optional容器，避免空指针
• 引入date/time类，更好的日期操作

23、mysql的存储过程

sql 语句

24、分页问的特别多； mysql orcle也要知道

sql底层些东西 最好了解

25、一般面试官会问你 简单的介绍下 redis

对redis的很熟悉面试官 基本会问这些

26、redis的存储策略

redis是Key-valued存储系统，为了保证效率，缓存在内存中，同时也会周期性的把数据更新到磁盘或追加到文件，以保证数据持久化。

27、redis的集合数据类型 （需要很熟）

string,hash,set,sort set,list

28、redis的容灾机制

部署哨兵：1、从机岩机，redis从库重启后自动加到主从架构中，自动完成数据同步2、主机岩机，断开redis主从关系，将从库提升成主库，重启原主库并将其设置成从库，完成数据同步。

redis的有个map 数据类型 key 是否可以是任意类型 还有它的长度有无限制

29、redis在业务上 可以实现那些功能 不单单是 作为非关系型数据库的作用 还有其他作用；可以响应 的去了解

作为分布式锁，setnx命令实现，当key不存时set成功能返回true,Key已经存在set失败返回false。用cas实现

redis的基本操作命令 设置过期时间 expir等

redis 问的频率很高； 需要多了解

电商方面问题(由于我写了电商项目)

dubbo+zookeeper(zookeeper最少三台因为它有投票机制) 面试官当时问我这个电商项目用到几台

zookeeper ；都是奇数；最少3台

dubbo + zookeeper的底层能掌握多少； 就看你自己了
答：zk选举算法1service投票2接收投票信息3处理投票信息：投票过时清空投票箱（将接收到的投票和自己比较（服务器编号，数据编号），先比较数据编号大的，如果一样则再选服务器编号大的）更新推荐人，广播推荐人4统计投票信息（比较如果投票信息过半，则选出leader，否则继续接收选举信息）5选举出Leader节点
zk选举参考：
http://codemacro.com/2014/10/19/zk-fastleaderelection/

单点登入

session共享

js跨域问题

静态缓存的问题； 你们项目是怎么很好的解决静态资源缓存问题

solr全文检索问到过一次

两点一线 得需要知道是什么

cookie 跟 session的区别

cookie 的值 在网页中的请求头 请求体 还是 在哪儿

nginx 问的不多 我们了解足够应付过去（nginx这个东西实在是太优秀了）

运维方面上的就是 linux一些操作命令 设置权限等

并发工具包：

java.util.concurrent 下面几个常用的

下面就是聊一聊你简历上；那些项目上的基础知识点；自己把握分寸

30、生产者消费者

public class BlockingQueueTest {

    private int size = 20;    
    private ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<>(size); 

    public static void main(String[] args)  { 
            BlockingQueueTest test = new BlockingQueueTest();        
            Producer producer = test.new Producer();        Consumer consumer = test.new Consumer();                   producer.start();        
            consumer.start();    
    }

    class Consumer extends Thread{

        @Override        
        public void run() {             
            while(true){                
                try {                    
                    //从阻塞队列中取出一个元素
                    queue.take();                    
                    System.out.println("队列剩余" + queue.size() + "个元素");                
                } catch (InterruptedException e) {                                  
                }            
            }        
        }    
    } 

    class Producer extends Thread{                  

        @Override
        public void run() {            
            while (true) {                
                try {                    
                    //向阻塞队列中插入一个元素    
                    queue.put(1);                    
                    System.out.println("队列剩余空间：" + (size - queue.size()));                
                } catch (InterruptedException e) {                              
                }            
            }        
        }    
    }
}

31、事物传播属性

require:默认，事物方法a调用事物方法b,事物方法b发现自己运行在事物中则不起事物，如果没有事物则起一个事物执行。
require_new：事物方法a调用事物方法b，事物b发现自己运行在事物中也会新启一个事物来运行，2个事物方法相互独立，不影响。
suport：事物方法a调用事物方法b,事物a开启一个事物，事物b不再开启，方法b完全依赖外层事物

32、数据隔离级别

• 
  
• 脏读:事务b读到了事物a未提交的数据
• 不可重复读:在同一个事务内的查询都是事务开始时刻不一致的,二次查询的数据不一样
• 可重复读:在同一个事务内的查询都是事务开始时刻不致的,二次查询的数据一样
• 幻读:解决了不可重复读问题,但会造成幻读,在事物b中二次查到数据库没有记录a,但插入时报出主键a冲突,就是因为幻读.因为在事物b开始时数据没有被插入,后来事物a插入记录a,事物b再次插入时就会出错.
  

其它数据库默认事物隔离级别是读不提交,mysql默认是可重复读

32、堆排序

参考：http://bubkoo.com/2014/01/14/sort-algorithm/heap-sort/

给出如下堆，将其变成大堆过程

32、快速排序

给出原始数组

选择第一个数72为基数，i=0,j=9。先从a[j]开始比较将小于72的数放到a[i]，i=i+1,然后再从a[i]开始找大于72数放到a[j],直到i>j 第一次块排结束。
第一次快排，详情：

33、tcp分层

1、物理层层:定义主机之间信号传输0，1；
2、数据链层：对0，1分组表达一个完整的信号，用由以太网协议规定，同时以太网包含mac地址；
3、网络层：用mac协议直接发送数据包，效率太低。网络层就是区分哪些mac地址属于同一个子网，如果是同一子网则用广播方式发送，否则用路由方式发送。
网络地址帮助我们确定计算机所在的子网络，MAC地址则将数据包送到该子网络中的目标网卡。因此，从逻辑上可以推断，必定是先处理网络地址，然后再处理MAC地址。用ARP协议从Ip地址得到mac地址
4、传输层：建立端口到端口通信，网络层主要是主机到主机。
需要在数据包中加入端口，就需要新的协议，udp,tcp
5、应用层：就是规定应用程序的数据格式。

以太网标头：本机mac地址和接收方Mac
Ip标关：本机ip和接收方ip
tcp/udp标头:本机端口和接收方端口

tcp3次握手，4次分手；

参考：https://github.com/jawil/blog/issues/14
tcp 3次握手：

为什么要3次握手，三次握手是为了解决“网络中存在延迟的重复分组”的问题。
场景：主机A发送连接请求主机B，由于网络原因消息滞留。主机B在很长时间后收到这个失效的消息，误以为主机A是请求连接，回复确认报文。但主机A不会回复。此时主机B没有收到回复，也就不会建立连接，也不会一直等待。所以需要3次握手解决上述问题。
tcp4次分手：

为什么4次分手：
主机A主请求断开后，只说明A没有数据发送了，此时B还可以发送数据。
主机B回复可以断开，响应A的请求。
主机B请求断开，主机B也没有数据发送了。
主机A回复，我也没数据接收了,可以断开。

33、spring bean对象生命周期

33、一致性Hash算法

参考：http://blog.csdn.net/u010558660/article/details/52767218
一致性哈希算法是分布式系统中常用的算法。比如，一个分布式的存储系统，要将数据存储到具体的节点上，
如果采用普通的hash方法，将数据映射到具体的节点上，如key%N，key是数据的key，N是机器节点数，
如果有一个机器加入或退出这个集群，则所有的数据映射都无效了。

一致性哈希算法解决了普通余数Hash算法伸缩性差的问题，可以保证在上线、下线服务器的情况下尽量有多的请求命中原来路由到的服务器。
一、一致hash算法
1、原理：
* （1）环形Hash空间
照常用的hash算法来将对应的key哈希到一个具有2^32次方个桶的空间中，即0~(2^32)-1的数字空间中。
现在我们可以将这些数字头尾相连，想象成一个闭合的环形。如下图

* （2）把数据通过一定的hash算法处理后映射到环上
现在我们将object1、object2、object3、object4四个对象通过特定的Hash函数计算出对应的key值，然后散列到Hash环上。如下图：
Hash(object1) = key1；
Hash(object2) = key2；
Hash(object3) = key3；
Hash(object4) = key4；

* （3）将机器通过hash算法映射到环上
在采用一致性哈希算法的分布式集群中将新的机器加入，其原理是通过使用与对象存储一样的Hash算法将机器也映射到环中
（一般情况下对机器的hash计算是采用机器的IP或者机器唯一的别名作为输入值），然后以顺时针的方向计算，将所有对象存储到离自己最近的机器中。
Hash(NODE1) = KEY1;
Hash(NODE2) = KEY2;
Hash(NODE3) = KEY3;

2、机器的删除与添加
普通hash求余算法最为不妥的地方就是在有机器的添加或者删除之后会造成大量的对象存储位置失效。下面来分析一下一致性哈希算法是如何处理的。

(1)节点（机器）的删除
以上面的分布为例，如果NODE2出现故障被删除了，那么按照顺时针迁移的方法，object3将会被迁移到NODE3中，这样仅仅是object3的映射位置发生了变化，其它的对象没有任何的改动。如下图：

(2)节点（机器）的添加
如果往集群中添加一个新的节点NODE4，通过对应的哈希算法得到KEY4，并映射到环中，如下图：

通过按顺时针迁移的规则，那么object2被迁移到了NODE4中，其它对象还保持着原有的存储位置。
通过对节点的添加和删除的分析，一致性哈希算法在保持了单调性的同时，还是数据的迁移达到了最小，这样的算法对分布式集群来说是非常合适的，避免了大量数据迁移，减小了服务器的的压力。

原链连：
链接：https://www.nowcoder.com/discuss/28229?type=2&order=

基础知识考察：

1、模块化的好处

2、Http协议

答：基于tcp/ip应用层协议，是超文本传输协议，是从www服务器传送超文本到本地浏览器的传送协议。
http请求消息包含4部份：
* 1、请求行：用来说明请求类型,要访问的资源以及所使用的HTTP版本.
* 2、请求头：用来说明服务器要使用的附加信息
* 3、空行：请求头后面必须是空行
* 4、请求数据：请求主体，可添加任意其他数据。
http响应消息4部分：
* 状态行：http协议版本号、状态码、状态消息
* 消息报头：说明客户端使用的附加信息
* 空行
* 响应文：服务端返回客户端的文本信息

一个http请求完整过程

域名解析 –> 发起TCP的3次握手 –> 建立TCP连接后发起http请求 –> 服务器响应http请求，浏览器得到html代码 –> 浏览器解析html代码，并请求html代码中的资源（如js、css、图片等） –> 浏览器对页面进行渲染呈现给用户

3、hashmap和concurrenthashmap区别及两者的优缺点

4、对MySQL的了解，和oracle的区别

5、对设计模式的看法和认知

设计模式的目的是为了代码的复用、容易理解和保证代码的可靠性。最终要达成的效果是：可扩展性、可修改性、可替换性。

6、有哪些设计模式

7、如何实现分布式缓存

8、多线程如何避免死锁

参考：https://www.ibm.com/developerworks/cn/java/j-lo-deadlock/index.html
死锁：2个或多个线程互相等待对方已持有的资源
死锁条件：互斥条件（一个资源只能被一个线程所用）；请求与保持（一个进程因请求资源而阻塞时，对已获得的资源保持不放。）；不剥夺条件（进程已获得的资源，在未使用完之前，不能强行剥夺）；循环等待条件（若干进程之间形成一种头尾相接的循环等待资源关系。）
破坏上面的任何一个条件死锁解除
避免死锁：有序的请求资源；一次性分配置给线程所有资源（消耗资源较大，场景不可用）；

9、关于树的算法题-二叉树的锯齿形层次遍历：http://www.lintcode.com/zh-cn/problem/binary-tree-zigzag-level-order-traversal/

10、Java的垃圾回收机制

参考：
http://blog.csdn.net/justloveyou_/article/details/71216049
gc主要是java堆进回收，堆分成新生代和老年代。新生代回收算法主要是用复制算法，新生代分成eden 、2块servious区。当eden和其中一块servious区写满时，就会触发gc 进行一次垃圾回收，具体回收算法，将还存活的eden\servious区的对象复制到另一块servious区上，再去清除。
老年代主要用标记清除算法
判断对象是否可回收：引用计数算法&可达性分析
可达性分析：判断gc root是否还有任何引用链
可作为gc root:虚拟机栈(栈帧中的局部变量表)中引用的对象;方法区中类静态属性引用的对象；方法区中常量引用的对象；本地方法栈中Native方法引用的对象；
分代收集算法：新生代对象存活率低，就采用复制算法；老年代存活率高，就用标记清除算法或者标记整理算法

框架

1、zk集群为什么总用基数个
参考：https://www.jianshu.com/p/35c09d6a02a0
为了以最大容错服务器的个数下，节省资源。
zookeeper容错是指：当宕掉几个zookeeper服务器之后，剩下的个数必须大于宕掉的个数，也就是剩下的服务数必须大于n/2，zookeeper才可以继续使用，无论奇偶数都可以选举leader。
5台机器最多宕掉2台，还可以继续使用，因为剩下3台大于5/2。说为什么最好为奇数个，是在以最大容错服务器个数的条件下，会节省资源，比如，最大容错为2的情况下，对应的zookeeper服务数，奇数为5，而偶数为6，也就是6个zookeeper服务的情况下最多能宕掉2个服务，所以从节约资源的角度看，没必要部署6（偶数）个zookeeper服务。
2、dubbo有点和缺点
服务化优点：
应用按业务拆分成服务
各个服务可独立部署
服务可被多个应用共享
服务之间可以通信
服务化面临的挑战：
- 服务越来越多，配置管理复杂
- 服务间依赖关系复杂
- 服务之间的负载均衡
- 服务的拓展
- 服务监控
- 服务降级
- 服务鉴权
- 服务上线与下线
- 服务文档

要想实现服务化，服务治理是关键：dubbo就是一个带有服务治理功能的RPC框架。
dubbo服务治理优势
- 注册中心只负责注册查找，不负责请求转发，压力小
- 注册中心宕机影响消费者，消费者本地缓存服务地址列表
- 注册中心对等集群，宕掉一台自动切换到另外 一台
- 服务提供者无状态，可动态部署，注册中心负责推送
- 统计无压力，本地内存中累计次数，每分钟发送注册中心
- 消费者调用服务者，自动软负载均衡
- 通过服务中心可追踪依赖关系
- 监控中心为扩容和降级提供依据
- 可启用acl机制进行鉴权
- 与Spring整合，接入简单松耦合
- 多种序列化协议支持
dubbo的不足
- 消费者仍需要依赖配置中心
- 消费者仍需要依赖jar包配置provider
- 提供者文档管理功能缺失
- 无统一入口
- 不支持OAuth2.0
- 内部鉴权不方便管理
- 无外部应用鉴权
- 接口基本裸奔，无法直接对外暴露服务
- IT治理不方便