1、微信红包怎么实现。

2、海量数据分析。

3、测试职位问的线程安全和非线程安全。

4、HTTP2.0、thrift

http2.0 主要是解决 head of line blocking问题，就是请求串行等待的问题，支持多路复用
http2.0 使用了新的二进制格式传输，一个request对应一个stream分配一个stream id，每个frame可以混杂在一起，通过stream id查找到对应的request
通过设置priority可以由服务端识别处理优先级（并发请求，优先响应的问题）
header压缩
服务推送数据给客户端
http层的流量控制（window窗口概念）
ssl支持黑白名单配置
thrift 是一种基于中间描述生成代码的协议（RPC框架），静态编译，数据的编码和解析具有很好的性能【QPS > 1000】
hessian 是一种基于直接类型的协议，需要通过反射进行编译和解析【QPS < 1000 】
5、先让自我介绍。

6、分布式事务一致性。

7、nio的底层实现

NIO = IO多路复用 + IO非阻塞快速反馈
IO多路复用：提供注册连接机制，epoll只返回发出请求的连接
IO非阻塞快速反馈：发出的请求不管是否有数据流，都理解反馈，不阻塞

8、jvm基础是必问的，jvm GC原理，JVM怎么回收内存。

答：清除方法区(不使用常量、不被引用的类和类加载器)和堆栈(不使用对象)，计算出不使用的对象, 1.计数器(存在循环引用问题)2.可达性(GC Roots->局部变量表,static,final,native)
采用 标记清理,复制,标记整理等方式进行回收, 大对象/优先eden/长期存活/过半年龄/minor->old gc
搭配回收算法是：parNew + CMS(标记整理)、G1 + G1
9、Java是什么

10、API与SPI的区别

都是基于Interface接口编程，API是调用接口，SPI是实现接口
API（接口位于实现方所在的包，实现包独立）是提供给开发人员调用的接口来实现某个目的，提供给程序开发人员
SPI（接口位于调用方所在的包，实现包独立 类似于Spring IoC的概念提供热插拔）是提供框架规范，需要框架的开发人员去实现以达成某个目标，提供给框架开发人员

SPI ->
概念上更依赖调用方。
组织上位于调用方所在的包中。
实现位于独立的包中。
常见的例子是：插件模式的插件。
API ->
概念上更接近实现方。
组织上位于实现方所在的包中。
实现和接口在一个包中。

API&SPI.png

11. dubbo如何一条链接并发多个以调用。Dubbo的原理，序列化相关问题

原理：
超时优先级客户端method>客户端service>客户端全局>服务端method>服务端service>服务端全局
存在一个configServer进行provider/consumer注册监听，但是此服务down机不影响集群服务，每个provider/consumer都有本地缓存
注册中心有multicast多播，zookeeper，redis
负载均衡算法: roundrobin、random、leastActivie、constanthash(一致性hash)使相同参数请求总是发到同一提供者

序列化：

1. 使用的hessian方式进行序列化，hessian的字节比serializable小，比protobuf大，但是支持多语言，小服务体量适合使用
2. java 原生序列化的本质是 ObjectStreamClass 中的 writeNonProxy 方法. 会写入整个对象的 name 和 SerialVersionUID(如果读出的uid 和 内存中的class uid不一致会报错), 并且写下每个字段的type和name. 会加大序列化的存储空间, 同时针对 嵌套对象也会重复存储.
   通过重写 readClassDescriptor 和 writeClassDescriptor 方法, 可以简单记录元数据. 起到压缩作用. 参考 CompactedObjectInputStream 类

协议：
dubbo: 单连接，长连接，TCP，NIO（服务端线程复用），hession序列化，适合小数据量大并发(由于使用单连接，数据量大网络会成为瓶颈)，consumer要比producer多20倍才能压满千兆带宽
rmi：多连接，短连接，TCP，BIO，Serializable，适合大文件传输，consumer和producer差不多多
hessian/http：多连接，短连接，HTTP，BIO，hession序列化/表单序列化，适合提供者比消费者多
webservice：多连接，短连接，HTTP，BIO，SOAP文本序列化，适合x系统集成跨语言调用
memcached/redis

12、用过哪些中间件

rmq、redis、tair、zookeeper、memcached、eagle

13、做过工作流引擎没有

// TODO
14、以前的工作经历，自己觉得出彩的地方（钉钉）

15、线程池的一些原理，锁的机制升降级（天猫、蚂蚁）

资源的池化技术是非常常见的一种使用空间缓存缓解系统瞬时压力的解决方案（线程池、连接池、对象池）
线程池的作用是避免频繁地创建和销毁线程，达到线程对象的重用
继承ThreadPoolExecutor来实现自定线程池，核心点有coreSize、maxSize、BlockingQueue、ThreadFactory、RejectedHandler、keepAliveTime

coreSize是线程池保持的最小线程数
当超过coreSize进入BlockingQueue
当BlockingQueue满了，创建线程到maxSize数量
超过maxSize执行rejectedHandler解决异常
keepAliveTime在maxCoreSize超过多长时间后，销毁

synchronized的内置锁，在JDK1.5后拆分了级别，将锁级别分为重量锁，轻量锁，偏向锁，还提供了自动识别锁消除和锁粗化的功能
锁有升级的功能，但是没有降级的功能

16、从系统层面考虑，分布式从哪些纬度考虑（天猫）

17、Hadoop底层怎么实现（天猫）

18、threadLocal，线程池，hashMap/hashTable/coccurentHashMap等（天猫）

threadLocal提供的隔离线程的副本值，每个线程内置一个tableLocals[]保存对应的threadLocal值
hashMap是非线程安全map，采用的是table数组+（链表+红黑树）进行存储，其中每个独立hash值为一个链表，先用hash值找到链表，再做val对比，扩容方式用2进制存储实现移位扩容，链表长度超过8，转为红黑树，JDK1.8 -> 采用尾插法，解决了扩容死循环和倒序问题，hashcode只用了2次扰动，不用每次都计算hashcode进行定位，采用hashcode&oldCal来判断是否需要移动位置
concurrentHashMap是线程安全map，不同点在于提供了TreeBin的读写锁，做读取时要加读锁，做变更时，针对链表头加写锁，并且扩容时加入多线程辅助扩容机制，采用步长来减少并发拷贝的冲突
hashTable // TODO

19、秒杀系统的设计

加入认证机制，减轻服务端负载，也可以有熔断
设置贡献缓存和本地缓存，每个服务器本地设置一个2倍的虚拟缓存，再设置一个真实库存的共享缓存
用户请求先扣用户机会，然后扣减本地缓存，如果本地虚拟库存不足，直接拒绝，如果有虚拟库存，再竞争贡献缓存的库存
20、虚拟机，IO相关知识点（天猫）

21、Linux的命令（天猫）

22、一个整形数组，给定一个数，在数组中找出两个数的和等于这个数，并打印出来，我写的时间复杂度高，要求O(n)。（天猫）

快排能实现O(n)

23、n个整数，找出连续的m个数加和是最大。（天猫）

// todo
24、更重视开源技术（蚂蚁金服上海）

25、数据库索引原理（蚂蚁金服网商）

索引是采用b+树来存储
MySQL分为聚簇索引和非聚簇索引
所有的数据都存储在聚簇索引的叶子节点上，聚簇索引以主键做有序的b+树
非聚簇索引存储的是索引的值，叶子节点保存的是聚簇索引的主键（因此走索引的查询实际要查询2次B+树）
B+树的好处是高度矮，能保存的值多（每个高度都是一次IO），比B-树的好处是能存储更多的数据
不支持间隔索引字段的查询

26、1000个线程同时运行，怎么防止不卡（航旅）

加入线程池，减少同时运行的线程，如果是由于http服务器，选择NIO可以降低线程数
27、并列的并发消费问题（航旅）

28、高并发量大的话怎么处理热点，数据等（蚂蚁金服）

散列数据，这里要回忆下spark如何处理大数据时热点问题
如果是业务上的，通过分库分表解决
比如订单，从业务上纵向拆分，然后进行横向扩容，比如，按照用户id的后4位中的前2位进行分库，然后根据后2位进行分表，拿到用户ID就能快速

29、如何获取一个本地服务器上可用的端口

30、流量控制相关问题（蚂蚁金服）

1. 计数器（在段时间内只允许计数器达到某个值通过，否则拒绝，段时间后，计数器清空）存在临界点问题，比如在某个时间点(1s)内爆发大量攻击请求
2. 滑动窗口
3. 漏桶 有一个固定的桶，进水的速率是不确定的，但是出水的速率是恒定的，当水满的时候是会溢出的（当请求量大时，会有大部分请求被丢弃）
4. 令牌桶 生成令牌的速度是恒定的，而请求去拿令牌是没有速度限制的（面对瞬时大流量，该算法可以在短时间内请求拿到大量令牌，而且拿令牌的过程并不是消耗很大的事情）

31、数据库TPS是多少，是否进行测试过（天猫）

32、缓存击穿有哪些方案解决（天猫）

1. HTTP浏览器缓存
2. CDN
3. 服务器缓存（本地缓存、分布式缓存）

在击穿时，线程保存旧缓存数据在本地，并且标记有线程正在读取数据库，其余请求击穿时，判断是否线程正在请求，有则获取旧缓存数据

1. 预估流量
2. 降级
3. 限流（token，请求队列化，计数器）

1. 雪崩，说明服务器已经出现问题，无法反馈，用户反映往往是再刷一下，加快服务器奔溃，需要采用断路器，快速失败
2. 队列机制在处理时进行判断是否是无效值，如果已经过期了，直接丢弃

33、Java怎么挖取回收器相关原理（财富）

34、Java的集合都有哪些，都有什么特点（信息平台）

ArrayList 是数组集合，支持随机存取，变更慢，读取块，非线程安全
LinkedList 是链表集合，支持顺序存取，变更慢，读取慢，非线程安全
BlockingQueue 是阻塞队列，继承自AQS架构，实现线程安全的消费生产者
35、分布式锁，redis缓存，spring aop，系统架构图，MySQL的特性（信息平台）

36、场景，同时给10万个人发工资，怎么样设计并发方案，能确保在1分钟内全部发完 打个比方会提出类似的场景（信息平台）

1、java事件机制包括哪三个部分？分别介绍。

1. 事件源
2. 事件（EventObject）
3. 事件监听器（EvenListener）

• 事件队列（event queue）：接收事件的入口，存储待处理事件
• 分发器（event mediator）：将不同的事件分发到不同的业务逻辑单元
• 事件通道（event channel）：分发器与处理器之间的联系渠道
• 事件处理器（event processor）：实现业务逻辑，处理完成后会发出事件，触发下一步操作

2、为什么要使用线程池？

每次请求都要不断的创建和销毁线程，一个线程的生命周期是
T1创建线程，T2执行线程，T3销毁线程

3、线程池有什么作用？

如果T1+T3>T2就可以使用线程池技术
池技术，可以减少 创建/销毁 线程的资源损耗，用空间换时间
避免无休止的创建线程，对线程数量进行管理，防止导致资源泄漏

4、说说几种常见的线程池及使用场景

1. FixedThreadPool 固定线程池 重负载的服务器，合理使用资源，需要限制线程数
2. SingleThreadPool 单例线程池 串行执行任务，需要线程且方便使用
3. CachedThreadPool 无限制线程池 消费者与生产者直接连接，没有缓存，没有最大线程个数限制，适合短期大量小任务，轻负载服务器
4. ScheduledThreadPool 定时调度线程池，提供按照速率/延迟执行的调度执行策略，适合执行多线程执行周期性任务

web容器 每次用户的请求都是一个独立的无状态的线程，而用户体量远远大于服务器能创建的线程个数，这时候就需要线程池来复用这些线程，缩短重复创建销毁线程，同时限制线程创建的个数
消费者 应用动的时候会启动固定的n个线程，来专门监听生产队列

5、线程池都有哪几种工作队列？

1. ArrayBlockingQueue -> 有限制队列
2. LinkedBlockingQueue -> 无限制队列
3. SynchronousQueue -> 连通隧道队列
4. DelayedWorkQueue -> 延迟工作队列
5. PriorityBlockingQueue -> 权限队列
6. ForwardBlockingQueue -> ???

6、怎么理解无界队列和有界队列？

无界队列是没有设置队列的大小，但实际上队列还是有界的，只是Integer.MAX_VALUE最大值上线，读写分成两把lock，可以分开控制速率
有界队列是设置了队列的大小，共享一把全局lock，size计算更精确

7、线程池中的几种重要的参数及流程说明。

略

8、什么是反射机制？

程序在运行时能够动态的获取自身的信息
通过指定类的全名，就可以动态加载对象和查看所有方法和属性

9、说说反射机制的作用。

1. 增加程序的灵活性，避免将程序写死到代码里
2. 可以运行时获取对象的所有属性和方法，进行代理和运行时修改数据
3. 开发各种通用框架

10、反射机制会不会有性能问题？

对性能有影响
使用反射基本上是一种解释操作
这类操作总是慢于只直接执行(大概100倍)相同的操作
许多应用中更严重的一个缺点是使用反射会模糊程序内部实际要发生的事情
解决方案：

1. 关闭校验 .setAccessible(true);
2. 缓存反射出来的metadata至redis
3. 使用asm字节码生成的方式实现了更为高效的反射机制，不依赖Java本身的反射机制

11、你怎么理解http协议？

数据包在网络中的传输
HTTP 是一个由请求和响应组成的一种应用层协议

12、说说http协议的工作流程

13、http有哪些请求提交方式？

14、http中的200,302,403,404,500,503都代表什么状态？

200 OK
302 重定向
403 服务器识别了并且主动拒绝
404 没有找到请求资源
500 服务器未知错误
503 服务器当前无法处理请求

15、http get和post有什么区别？

16、你怎么理解cookie和session，有哪些不同点？

17、什么是web缓存？有什么优点？

18、什么是https，说说https的工作原理？

19、什么是http代理服务器，有什么用？

20、什么是虚拟主机及实现原理？

虚拟机是一种抽象化的计算机，通过在实际的计算机上仿真模拟各种计算机功能来实现的
一台服务器上可以提供多个虚拟主机，共享物理服务器的带宽，cpu可以锁定core，内存可以固定划分，存储可以以目录形式划分

21、什么是Java虚拟机，为什么要使用？

Java虚拟机有自己完善的硬体架构，如处理器、堆栈、寄存器(Java虚拟机没有、使用栈来存储)等，还具有相应的指令系统。Java虚拟机屏蔽了与具体操作系统平台相关的信息，使得Java程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在多种平台上不加修改地运行，实现跨平台性

Java虚拟机规范定义了一个抽象的——而非实际的——机器或处理器。这个规范描述了一个指令集，一组寄存器，一个堆栈，一个“垃圾堆”，和一个方法区。一旦一个Java虚拟机在给定的平台上运行，任何Java程序（编译之后的程序，称作字节码）都能在这个平台上运行。Java虚拟机（JVM）可以以一次一条指令的方式来解释字节码（把它映射到实际的处理器指令），或者字节码也可以由实际处理器中称作just-in-time的编译器进行进一步的编译。

22、说说Java虚拟机的生命周期及体系结构

执行一个java程序，就运行一个Java虚拟机。
通过一个main()函数开始 -> 运行 -> 直到没有普通线程运行（非daemon线程）终止程序
daemon线程 使用者之一是GC垃圾回收线程

体系结构：

1. 通过类加载系统加载.class数据
2. 存储到运行数据区中
3. 通过执行引擎执行装载类中的指令

23、说一说Java内存区域。

运行数据区 -> 内存区域

独享：
`程序计数器`、`虚拟方法栈`、`本地方法栈`
共享：
`堆`、`方法区（常量池）`

24、什么是分布式系统？

25、分布式系统你会考虑哪些方面？

26、讲一讲TCP协议的三次握手和四次挥手流程

三次握手 双方都能明确自己和对方的收、发能力是正常的
四次挥手
由于TCP连接是全双工的，因此每个方向都必须单独进行关闭

27、为什么TCP建立连接协议是三次握手，而关闭连接却是四次握手呢？为什么不能用两次握手进行连接？

3次握手完成两个重要的功能，既要双方做好发送数据的准备工作(双方都知道彼此已准备好)，也要允许双方就初始序列号进行协商，这个序列号在握手过程中被发送和确认
因为服务端的LISTEN状态下的SOCKET当收到SYN报文的连接请求后，它可以把ACK和SYN(ACK起应答作用，而SYN起同步作用)放在一个报文里来发送，通过序号(ISN)来按序组装报文
关闭连接时，当收到对方的FIN报文通知时，它仅仅表示对方没有数据发送给你了；但未必你所有的数据都全部发送给对方了，所以你可能未必会马上会关闭SOCKET,也即你可能还需要发送一些数据给对方之后，再发送FIN报文给对方来表示你同意现在可以关闭连接了，所以它这里的ACK报文和FIN报文多数情况下都是分开发送的。（服务端和客户端都需要发送一次FIN对应的都要一次ACK）

28、为什么TCP TIME_WAIT状态还需要等2MSL后才能返回到CLOSED状态？

(MSL)是任何报文段被丢弃前在网络内的最长时间，2MSL也就是这个时间的2倍

1. 为了保证A发送的最有一个ACK报文段能够到达B。这个ACK报文段有可能丢失，因而使处在LAST-ACK状态的B收不到对已发送的FIN和ACK 报文段的确认。B会超时重传这个FIN和ACK报文段，而A就能在2MSL时间内收到这个重传的ACK+FIN报文段。接着A重传一次确认。
2. 就是防止上面提到的已失效的连接请求报文段出现在本连接中，A在发送完最有一个ACK报文段后，再经过2MSL，就可以使本连接持续的时间内所产生的所有报文段都从网络中消失。

TIME_WAIT状态所带来的影响：
--> 当某个连接的一端处于TIME_WAIT状态时，该连接将不能再被使用。事实上，对于我们比较有现实意义的是，这个端口将不能再被使用。某个端口处于TIME_WAIT状态(其实应该是这个连接)时，这意味着这个TCP连接并没有断开(完全断开)，那么，如果你bind这个端口，就会失败。对于服务器而言，如果服务器突然crash掉了，那么它将无法再2MSL内重新启动，因为bind会失败。解决这个问题的一个方法就是设置socket的SO_REUSEADDR选项。这个选项意味着你可以重用一个地址，当设置了SO_REUSEADDR选项时，它可以在2MSL内启动并listen成功

29、什么是DoS、DDoS、DRDoS攻击？如何防御？

30、描述一下Java异常层次结构。

31、什么是检查异常，不受检查异常，运行时异常？并分别举例说明。

32、finally块一定会执行吗？

1. 在 try {} finally{} 之前return了，不会执行
2. 在try {} finally{} 之间执行了System.exit(0); 不会执行
3. return i;后 finally {i++;} 不会改变返回的值，因为return 会拷贝一份副本作为返回值
   33、正常情况下，当在try块或catch块中遇到return语句时，finally语句块在方法返回之前还是之后被执行？

34、try、catch、finally语句块的执行顺序。

try -> catch -> finally -> return

35、Java虚拟机中，数据类型可以分为哪几类？

1. 原始类型
   1.1 数值型 - int/float/double/long/char/byte/short
   1.2 布尔型 - boolean
   1.3 returnAddress
2. 引用类型
   reference

36、怎么理解栈、堆？堆中存什么？栈中存什么？

1. 栈内存存储的是局部变量，而堆内存存储的是实体
2. 栈内存的更新速度要快于堆内存，因为局部变量的生命周期很短
3. 栈内存存放的变量生命周期一旦结束就立即会被释放，而堆内存存放的实体会被垃圾回收机制不定时的回收

37、为什么要把堆和栈区分出来呢？栈中不是也可以存储数据吗？

问题很棒~

栈是运行时的单位，而堆是存储的单位。
- 栈解决程序的运行问题，即程序如何执行，或者说如何处理数据
- 堆解决的是数据存储的问题，即数据怎么放、放在哪儿。

在Java中一个线程就会相应有一个线程栈与之对应，因为不同的线程执行逻辑有所不同，因此需要一个独立的线程栈
堆则是所有线程共享的

栈因为是运行单位，因此里面存储的信息都是跟当前线程（或程序）相关信息的
- 包括局部变量、程序运行状态、方法返回值等等
堆只负责存储对象信息。

1. 软件设计角度，栈代表了处理逻辑，堆代表了数据存储
2. 堆中的内容可以被多个栈共享。一方面提供了一种有效的数据交互方式（如内存共享），另一方面，节省内存空间
3. 栈因为运行时的需要（如保存系统运行的上下文），需要进行址段的划分。由于栈只能向上增长，因此会限制住栈存储内容的能力。而堆不同，堆中的对象可以根据需要动态增长。因此，堆与栈的分离，使得动态增长成为可能，相应栈中只需要记录堆中的一个地址即可。
4. 堆和栈的完美结合就是面向对象的一个实例

38、在Java中，什么是是栈的起始点，同是也是程序的起始点？

main函数就是栈的起始点，也是程序的起始点

39、为什么不把基本类型放堆中呢？

占用的空间一般是1~8个字节——需要空间比较少，而且因为是基本类型，所以不会出现动态增长的情况——长度固定，因此栈中存储就够了，如果把他存在堆中是没有什么意义的（还会浪费空间，后面说明）。可以这么说，基本类型和对象的引用都是存放在栈中，而且都是几个字节的一个数，因此在程序运行时，他们的处理方式是统一的。但是基本类型、对象引用和对象本身就有所区别了，因为一个是栈中的数据一个是堆中的数据。最常见的一个问题就是，Java中参数传递时的问题。

40、Java中的参数传递是传值呢？还是传引用？

要说明这个问题，先要明确两点：

     1. 不要试图与C进行类比，Java中没有指针的概念

     2. 程序运行永远都是在栈中进行的，因而参数传递时，只存在传递基本类型和对象引用的问题。不会直接传对象本身。

明确以上两点后。Java在方法调用传递参数时，因为没有指针，所以它都是进行传值调用（这点可以参考C的传值调用）。因此，很多书里面都说Java是进行传值调用，这点没有问题，而且也简化的C中复杂性。

但是传引用的错觉是如何造成的呢？在运行栈中，基本类型和引用的处理是一样的，都是传值，所以，如果是传引用的方法调用，也同时可以理解为“传引用值”的传值调用，即引用的处理跟基本类型是完全一样的。但是当进入被调用方法时，被传递的这个引用的值，被程序解释（或者查找）到堆中的对象，这个时候才对应到真正的对象。如果此时进行修改，修改的是引用对应的对象，而不是引用本身，即：修改的是堆中的数据。所以这个修改是可以保持的了。

对象，从某种意义上说，是由基本类型组成的。可以把一个对象看作为一棵树，对象的属性如果还是对象，则还是一颗树（即非叶子节点），基本类型则为树的叶子节点。程序参数传递时，被传递的值本身都是不能进行修改的，但是，如果这个值是一个非叶子节点（即一个对象引用），则可以修改这个节点下面的所有内容。
堆和栈中，栈是程序运行最根本的东西。程序运行可以没有堆，但是不能没有栈。而堆是为栈进行数据存储服务，说白了堆就是一块共享的内存。不过，正是因为堆和栈的分离的思想，才使得Java的垃圾回收成为可能。

 Java中，栈的大小通过-Xss来设置，当栈中存储数据比较多时，需要适当调大这个值，否则会出现java.lang.StackOverflowError异常。常见的出现这个异常的是无法返回的递归，因为此时栈中保存的信息都是方法返回的记录点。

41、Java中有没有指针的概念？

java中没有指针的概念，reference引用就是指针的概念

42、Java中，栈的大小通过什么参数来设置？

43、一个空Object对象的占多大空间？

44、对象引用类型分为哪几类？

45、讲一讲垃圾回收算法

通过可达性分析算法，从GcRoots标记所有存活的对象
标记-清除算法，清除其余未存活对象
复制算法 ，将存储空间分为2分，存储对象只是用其中一份，在做垃圾回收的时候，将存活的对象拷贝到另外一份
标记-整理算法，清除其余未存活对象，整理存活的对象到存储空间头/尾
分代 使用了复制算法，但是没有浪费一半内存，而是每代都有存活的对象，根据eden/s1/s2/old再使用不同的算法进行处理

46、如何解决内存碎片的问题？

1. 使用整理技术，每次回收完垃圾后，进行一次整理
2. 使用分代技术，每次垃圾回收完，把存活的对象拷贝到下一级存储空间，然后清除这一级的空间

47、如何解决同时存在的对象创建和对象回收问题？

48、讲一讲内存分代及生命周期。

内存分为4代，比例是8：1：1

eden: 绝大多数对象都在这里消亡，频繁的miniotr gc
s1:
s2:
old: full gc会导致STW

49、什么情况下触发垃圾回收？

每次切换区的时候，都会执行一次minor gc

• 如果有限次minor gc还没有回收此对象，进入s1，进入s2，进入old，old会触发full gc（每次gc都会增加一次对象的年龄作为计数器）
• 如果存在连续内存的大对象，会直接进入old区，以免无意义的重复拷贝
• 如果s区内有一半以上对象存活时间相等，进入old区
• s区往old区迁移的时候会判断是否空间足够，否则会full gc（还有一个冗余位设置，如果设置为true还有30%的空间，再判断后是否full gc）

50、如何选择合适的垃圾收集算法？

ParNew(young) + CMS(old)
G1(young) + G1(old)
年轻代需要快速回收，且空间足够大，不能有大量碎片，ParNew采用复制算法
老年代都是大对象长期存活的，适用CMS采用标记-清理算法，但是可能由于没有连续空间导致频繁full gc，可以在有限次gc后执行一次标记-整理

51、JVM中最大堆大小有没有限制？

52、堆大小通过什么参数设置？

53、JVM有哪三种垃圾回收器？

54、吞吐量优先选择什么垃圾回收器？响应时间优先呢？

55、如何进行JVM调优？有哪些方法？

56、如何理解内存泄漏问题？有哪些情况会导致内存泄露？如何解决？

57、从分布式系统部署角度考虑，分哪几层？

58、如何解决业务层的数据访问问题？

59、为了解决数据库服务器的负担，如何做数据库的分布？

60、什么是著名的拜占庭将军问题？

61、为什么说TCP/IP协议是不可靠的？

62、讲讲CAP理念

Consistent（一致性）
Available（可用性）
Partition tolerance（分布性容忍性）
P是必须保证的，C和A选其一
选C的强一致性可用性很低互联网公司不能接受
一般会选A，然后实现最终一致性
这时候引入BASE[基本可用，阮状态，最终一致性]

63、怎么理解强一致性、单调一致性和最终一致性？

强一致性：更新过的数据能被后续的访问都能看到
弱一致性：能容忍后续的部分或者全部访问不到
顺序一致性：任何一次读都能读到某个数据的最近一次写的数据，系统的所有进程的顺序一致
最终一致性：经过一段时间后要求能访问到更新后的数据

64、分布式系统设计你会考虑哪些策略？

65、最常见的数据分布方式是什么？

66、谈一谈一致性哈希算法。

67、paxos是什么？

68、什么是Lease机制？

69、如何理解选主算法？

70、OSI有哪七层模型？TCP/IP是哪四层模型

OSI七层

应用层->表示层->会话层->传输层->网络层->数据链路层->物理层

TCP/IP四层

应用层->传输(TCP)层->网络(IP)层->物理链路层

层次定义.png

1. spring/spring-bean 生命周期

spring只对singleton单例对象管理生命周期
spring实例化方式：setter，constructor，factory
scope：singleton，prototype，request，session，global-session
spring生命周期：define，init-method，invoke，destroy-method
spring-bean生命周期：

1. 实例化 2. 填充属性(DI) 3. 设置bean name
4. 设置 beanFactory/applicationContext
5. init-method 前/后置 BeanPostProcessor-before/after
6. bean初始化完成
7. DisposableBean-destroy
8. destroy

只有无状态的Bean才可以在多线程环境下共享，在Spring中，绝大部分Bean都可以声明为singleton作用域。就是因为Spring对一些Bean(如RequestContextHolder、TransactionSynchronizationManager、LocaleContextHolder等)中非线程安全状态采用ThreadLocal进行处理，让它们也成为线程安全的状态，因为有状态的Bean就可以在多线程中共享了

2. spring aop/ioc/di

IoC控制反转是一种框架的概念
DI依赖注入是具体的实现
AOP弥补了面向对象编程（OOP）的不足，通过Aspect切面的方式，JoinPoint连接点和Advise通知（around/before/afterReturn/afterThrow/afterFinally）来进行Weaving织入，Spring通过动态代理(jdkProxy，gclib)将代理对象加强

BeanFactory：采取延迟加载，第一次getBean时才会初始化Bean
ApplicationContext：加载配置文件时初始化Bean，可以进行国际化处理、事件传递和bean自动装配以及各种不同应用层的Context实现

3. 一致性hash

一致性哈希将整个哈希值空间组织成一个虚拟的圆环，如假设某哈希函数H的值空间为0-2^32-1

4. hibernate 缓存

事务进行控制
一级缓存（session）：
随着session.close释放
持久化对象有三个状态（瞬时态[无OID]、持久态[有OID有session]、托管态[有OID无session]）
Map<缓存，快照>
flush时会对比缓存和快照是否一致，不一致会提交更新
FlushMode.ALWAYS AUTO(默认) COMMIT MANUAL NEVER
二级缓存（sessionFactory）

5. 索引原理

INNODB UPDATE的原理，行级锁的前提条件是建立索引，行级锁并不是直接锁记录，而是锁索引后再锁主键

聚集索引叶子节点存放的是行数据本身
非聚集索引叶子节点存放的是聚集索引的值
非聚集索引的查找[通常情况下]至少要经过两次B+树的遍历

6. MVCC

没有意向锁：做法是遍历表A的所有行级锁，看是否有X锁。
有意向锁：做法判断一下表A（意向锁是表锁）是否有IX就可以了。就可以判断表A此时有没有在写的事务

MVCC (Multiversion Concurrency Control)，对数据库的任何修改的提交都不会直接覆盖之前的数据，而是产生一个新的版本与老版本共存(快照)，使得读取时可以完全不加锁。不再单纯的使用行锁来进行数据库的并发控制，取而代之的是把数据库的行锁与行的多个版本结合起来，只需要很小的开销,就可以实现非锁定读，从而大大提高数据库系统的并发性能

InnoDB的MVCC,是通过在每行记录后面保存两个隐藏的列来实现的,这两个列，分别保存了这个行的创建时间，一个保存的是行的删除时间。这里存储的并不是实际的时间值,而是系统版本号(可以理解为事务的ID)，没开始一个新的事务，系统版本号就会自动递增，事务开始时刻的系统版本号会作为事务的ID

7. NIO/IO

NIO
非阻塞、面向缓冲区、有选择器
线程通常将非阻塞IO的空闲时间用于在其它通道上执行IO操作，所以一个单独的线程(选择器)现在可以管理多个输入和输出通道（channel）

NIO可让您只使用一个（或几个）单线程管理多个通道（网络连接或文件），但付出的代价是解析数据可能会比从一个阻塞流中读取数据更复杂

优势：大量连接，发送数据小
IO
阻塞、面向流
优势：少量连接，发送数据大

8. JPA(hibernate)/MyBatis

JPA(hibernate)：
使用注解@EnableJpaRepositories指定EntityManager和PlatformTransactionManager以及scan的目录范围
支持Criteria
MyBatis：
使用mybatis-spring融合spring，@Bean初始化SqlSessionFactoryBean对象，指定DataSource，mapper.xml地址，mybatis-config.xml以及aliasesPackage，在config里面可以配置插件，比如PageableHelper来简化分页查询
一级缓存：
Mybatis首先去缓存中查询结果集，如果没有则查询数据库，如果有则从缓存取出返回结果集就不走数据库。Mybatis内部存储缓存使用一个HashMap，key为hashCode+sqlId+Sql语句。value为从查询出来映射生成的java对象
二级缓存：
Mybatis的二级缓存即查询缓存，它的作用域是一个mapper的namespace，即在同一个namespace中查询sql可以从缓存中获取数据。二级缓存是可以跨SqlSession的

9. 事务

编程式：
重复代码多
声明式：
灵活

10. 扩容

StringBuffer，默认16，每次扩容一倍（如果一倍还不够直接扩容到目标大小）
HashMap，默认2^4=16，默认负载因子0.75，当容量达到四分之三进行再散列（扩容），扩容一倍
ArrayList，首先容量扩大为原来的1.5倍，判断是否足够，不够扩大为需要的大小，再判断是否超过上限（使用Integer.MAX_VALUE）
Vector，每次扩容是翻倍

11. dubbo/webservice

自带负载均衡，服务治理
客户端超时>服务端超时
客户端重试>服务端重试

12. tair/redis

redis：
使用一致性hash解决扩容和定位问题
支持存储大/小对象
支持多集群，但是读写分离
支持分组并发更新
tair：
使用一致性hash解决扩容和定位问题
支持小对象
支持多集群
不支持分组并发更新

13. QPS/RT/threadNum

RT: 响应时间(单位ms)
QPS（最大吞吐能力）: 每秒请求量(单位是s)
ThreadNum: 并发数(并发数就是线程数)
PV：访问量即Page View, 即页面浏览量或点击量，用户每次刷新即被计算一次（单台服务器每天PV计算公式1：每天总PV = QPS * 3600 * 6）
UV：独立访客即Unique Visitor,访问您网站的一台电脑客户端为一个访客。00:00-24:00内相同的客户端只被计算一次

QPS = 并发数 / 平均响应时间
QPS = threadNum / RT
请求耗时 = 用户请求数(requests) / QPS

公式：( 总PV数 * 80% ) / ( 每天秒数 * 20% ) = 峰值时间每秒请求数(QPS)

每天300w PV 的在单台机器上，这台机器需要多少QPS？
答：( 3000000 * 0.8 ) / (86400 * 0.2 ) = 139 (QPS)
如果一台机器的QPS是58，需要几台机器来支持？
答：139 / 58 = 3