资料来源：https://www.bilibili.com/video/BV1M54y1H7Dp?p=15&spm_id_from=pageDriver
https://www.yuque.com/renyong-jmovm/ds/svgzsk

一、阿里一面

1、ArrayList和LinkedList区别

⾸先他们的底层数据结构不同，ArrayList底层是基于数组实现的，LinkedList底层是基于链表实现的
由于底层数据结构不同，他们所适⽤的场景也不同，ArrayList更适合随机查找，LinkedList更适合删除和添加，查询、添加、删除的时间复杂度不同
另外ArrayList和LinkedList都实现了List接⼝，但是LinkedList还额外实现了Deque接⼝，所以LinkedList还可以当做队列来使⽤

2、HashMap的Put方法
先说HashMap的Put⽅法的大体流程：
根据Key通过哈希算法与与运算得出数组下标
如果数组下标位置元素为空，则将key和value封装为Entry对象（JDK1.7中是Entry对象，JDK1.8中是 Node对象）并放⼊该位置
如果数组下标位置元素不为空，则要分情况讨论

如果是JDK1.7，则先判断是否需要扩容，如果要扩容就进⾏扩容，如果不⽤扩容就⽣成Entry对象，并使⽤头插法添加到当前位置的链表中
如果是JDK1.8，则会先判断当前位置上的Node的类型，看是红⿊树Node，还是链表Node
- 如果是红⿊树Node，则将key和value封装为⼀个红⿊树节点并添加到红⿊树中去，在这个过程中会判断红⿊树中是否存在当前key，如果存在则更新value
- 如果此位置上的Node对象是链表节点，则将key和value封装为⼀个链表Node并通过尾插法插⼊到链表的最后位置去，因为是尾插法，所以需要遍历链表，在遍历链表的过程中会判断是否存在当前key，如果存在则更新value，当遍历完链表后，将新链表Node插⼊到链表中，插⼊到链表后，会看当前链表的节点个数，如果⼤于等于8，那么则会将该链表转成红⿊树
- 将key和value封装为Node插⼊到链表或红⿊树中后，再判断是否需要进⾏扩容，如果需要就扩容，如果不需要就结束PUT方法
  3、ThreadLocal

ThreadLocal是Java中所提供的线程本地存储机制，可以利⽤该机制将数据缓存在某个线程内部，该线程可以在任意时刻、任意⽅法中获取缓存的数据
ThreadLocal底层是通过ThreadLocalMap来实现的，每个Thread对象（注意不是ThreadLocal对象）中都存在⼀个ThreadLocalMap，Map的key为ThreadLocal对象，Map的value为需要缓存的值
如果在线程池中使⽤ThreadLocal会造成内存泄漏，因为当ThreadLocal对象使⽤完之后，应该要把设置的key、value，也就是Entry对象进⾏回收，但线程池中的线程不会回收，⽽线程对象是通过强引⽤指向ThreadLocalMap，ThreadLocalMap也是通过强引⽤指向Entry对象，线程不被回收，Entry对象也就不会被回收，从⽽出现内存泄漏，解决办法是，在使⽤了ThreadLocal对象之后，⼿动调⽤ThreadLocal的remove⽅法，⼿动清楚Entry对象
ThreadLocal经典的应⽤场景就是连接管理（⼀个线程持有⼀个连接，该连接对象可以在不同的⽅法之间进⾏传递，线程之间不共享同⼀个连接）

4、JVM中哪些是共享区，哪些可以作为gc root
堆区和⽅法区是所有线程共享的，栈、本地⽅法栈、程序计数器是每个线程独有的

什么是GC Root，JVM在进⾏垃圾回收时，需要找到“垃圾”对象，也就是没有被引⽤的对象，但是直接找“垃圾”对象是⽐较耗时的，所以反过来，先找“⾮垃圾”对象，也就是正常对象，那么就需要从某些“根”开始去找，根据这些“根”的引⽤路径找到正常对象，⽽这些“根”有⼀个特征，就是它只会引⽤其他对象，⽽不会被其他对象引⽤

例如：栈中的本地变量、⽅法区中的静态变量、本地⽅法栈中的变量、正在运⾏的线程等可以作为GC Root。

5、项目如何排查JVM问题

5.1 对于还在正常运行的系统：

可以使⽤jmap来查看JVM中各个区域的使⽤情况
可以通过jstack来查看线程的运⾏情况，比如哪些线程阻塞、是否出现了死锁
可以通过jstat命令来查看垃圾回收的情况，特别是full gc，如果发现full gc⽐较频繁，那么就得进⾏调优了
通过各个命令的结果，或者jvisualvm等⼯具来进⾏分析
⾸先，初步猜测频繁发送full gc的原因，如果频繁发⽣full gc但是又⼀直没有出现内存溢出，那么表示 full gc实际上是回收了很多对象了，所以这些对象最好能在young gc过程中就直接回收掉，避免这些对象进⼊到⽼年代，对于这种情况，就要考虑这些存活时间不长的对象是不是比较大，导致年轻代放不下，直接进⼊到了⽼年代，尝试加大年轻代的大小，如果改完之后，full gc减少，则证明修改有效
同时，还可以找到占⽤CPU最多的线程，定位到具体的⽅法，优化这个⽅法的执⾏，看是否能避免某些对象的创建，从而节省内存

5.2 对于已经发生了OOM的系统：

⼀般⽣产系统中都会设置当系统发⽣了OOM时，⽣成当时的dump⽂件

（-XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/usr/local/base）

我们可以利⽤jsisualvm等⼯具来分析dump⽂件
根据dump⽂件找到异常的实例对象，和异常的线程（占⽤CPU⾼），定位到具体的代码
然后再进⾏详细的分析和调试

总之，调优不是⼀蹴⽽就的，需要分析、推理、实践、总结、再分析，最终定位到具体的问题

6、如何查看线程死锁

可以通过jstack命令来进⾏查看，jstack命令中会显示发⽣了死锁的线程
或者两个线程去操作数据库时，数据库发⽣了死锁，这是可以查询数据库的死锁情况 ```sql 1、查询是否锁表 show OPEN TABLES where In_use > 0;

2、查询进程 show processlist;

3、查看正在锁的事务 SELECT * FROM INFORMATION_SCHEMA.INNODB_LOCKS;

4、查看等待锁的事务 SELECT * FROM INFORMATION_SCHEMA.INNODB_LOCK_WAITS;

<a name="h6gHw"></a>
## 7、线程之间如何进行通讯的
1. 线程之间可以通过共享内存或基于网络来进行通信
1. 如果是通过共享内存来进⾏通信，则需要考虑并发问题，什么时候阻塞，什么时候唤醒
1. 像Java中的wait()、notify()就是阻塞和唤醒
1. 通过网络就比较简单了，通过网络连接将通信数据发送给对方，当然也要考虑到并发问题，处理⽅式就是加锁等⽅式
<a name="pGpbU"></a>
## 8、介绍Spring，读过源码介绍一下大致流程
1. Spring是⼀个快速开发框架，Spring帮助程序员来管理对象
1. Spring的源码实现的是⾮常优秀的，设计模式的应⽤、并发安全的实现、⾯向接⼝的设计等
1. 在创建Spring容器，也就是启动Spring时：
   - ⾸先会进⾏扫描，扫描得到所有的BeanDefinition对象，并存在⼀个Map中
   - 然后筛选出非懒加载的单例BeanDefinition进⾏创建Bean，对于多例Bean不需要在启动过程中去进⾏创建，对于多例Bean会在每次获取Bean时利⽤BeanDefinition去创建
   - 利⽤BeanDefinition创建Bean就是Bean的创建⽣命周期，这期间包括了合并BeanDefinition、推断构造⽅法、实例化、属性填充、初始化前、初始化、初始化后等步骤，其中AOP就是发⽣在初始化后这⼀步骤中
4. 单例Bean创建完了之后，Spring会发布⼀个容器启动事件
4. Spring启动结束
4. 在源码中会更复杂，⽐如源码中会提供⼀些模板⽅法，让子类来实现，比如源码中还涉及到⼀些 BeanFactoryPostProcessor和BeanPostProcessor的注册，Spring的扫描就是通过BenaFactoryPostProcessor来实现的，依赖注⼊就是通过BeanPostProcessor来实现的
4. 在Spring启动过程中还会去处理@Import等注解
![](https://cdn.nlark.com/yuque/0/2021/png/365147/1622965863563-ce71fb30-d01f-4829-93a8-a94d784ccc2c.png?x-oss-process=image%2Fwatermark%2Ctype_d3F5LW1pY3JvaGVp%2Csize_151%2Ctext_5Zu-54G15a2m6Zmi5ZGo55Gc%2Ccolor_FFFFFF%2Cshadow_50%2Ct_80%2Cg_se%2Cx_10%2Cy_10#crop=0&crop=0&crop=1&crop=1&from=url&id=FiBwd&margin=%5Bobject%20Object%5D&originHeight=4940&originWidth=5311&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=)
<a name="VUCJS"></a>
## 9、Spring的事务机制
1. Spring事务底层是基于数据库事务和AOP机制的
1. ⾸先对于使⽤了@Transactional注解的Bean，Spring会创建⼀个代理对象作为Bean
1. 当调⽤代理对象的⽅法时，会先判断该⽅法上是否加了@Transactional注解
1. 如果加了，那么则利⽤事务管理器创建⼀个数据库连接
1. 并且修改数据库连接的autocommit属性为false，禁⽌此连接的⾃动提交，这是实现Spring事务⾮常重要的⼀步
1. 然后执⾏当前⽅法，⽅法中会执⾏sql
1. 执⾏完当前⽅法后，如果没有出现异常就直接提交事务
1. 如果出现了异常，并且这个异常是需要回滚的就会回滚事务，否则仍然提交事务
1. Spring事务的隔离级别对应的就是数据库的隔离级别
1. Spring事务的传播机制是Spring事务⾃⼰实现的，也是Spring事务中最复杂的
1. Spring事务的传播机制是基于数据库连接来做的，⼀个数据库连接⼀个事务，如果传播机制配置为需要新开⼀个事务，那么实际上就是先建⽴⼀个数据库连接，在此新数据库连接上执⾏sql
![](https://cdn.nlark.com/yuque/0/2021/png/365147/1622966825505-41961ccc-19e0-4f70-8182-e6e3337eb3af.png?x-oss-process=image%2Fwatermark%2Ctype_d3F5LW1pY3JvaGVp%2Csize_223%2Ctext_5Zu-54G15a2m6Zmi5ZGo55Gc%2Ccolor_FFFFFF%2Cshadow_50%2Ct_80%2Cg_se%2Cx_10%2Cy_10#crop=0&crop=0&crop=1&crop=1&from=url&id=xBw9H&margin=%5Bobject%20Object%5D&originHeight=2680&originWidth=7826&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=)
<a name="YBfDs"></a>
## 10、@Transactional失效的场景
因为Spring事务是基于代理来实现的，所以某个加了@Transactional的⽅法只有被**代理对象调用时**，那么这个注解才会⽣效，所以如果是**被代理对象来调⽤这个方法**，那么@Transactional是不会⽣效的
同时如果某个⽅法是private的，那么@Transactional也会失效，因为底层cglib是基于父子类来实现的，子类是不能重载⽗类的private⽅法的，所以⽆法很好的利⽤代理，也会导致@Transactianal失效
<a name="uWnKo"></a>
## 11、Dubbo是如何做系统交互的
Dubbo底层是通过RPC来完成服务和服务之间的调⽤的，Dubbo⽀持很多协议，比如默认的dubbo协议，⽐如http协议、⽐如rest等都是⽀持的，他们的底层所使⽤的技术是不太⼀样的，比如dubbo协议底层使⽤的是netty，也可以使⽤mina，http协议底层使⽤的tomcat或jetty。<br />服务消费者在调⽤某个服务时，会将当前所调⽤的服务接口信息、当前⽅法信息、执⾏方法所传⼊的⼊参信息等组装为⼀个Invocation对象，然后不同的协议通过不同的数据组织⽅式和传输⽅式将这个对象传送给服务提供者，提供者接收到这个对象后，找到对应的服务实现，利⽤反射执⾏对应的⽅法，得到⽅法结果后再通过网络响应给服务消费者。<br />当然，Dubbo在这个调⽤过程中还做很多其他的设计，比如服务容错、负载均衡、Filter机制、动态路由机制等等，让Dubbo能处理更多企业中的需求。<br />![](https://cdn.nlark.com/yuque/0/2021/png/365147/1623128186999-7bc7f5d9-3ec2-48dd-9fe4-fac868d20380.png?x-oss-process=image%2Fwatermark%2Ctype_d3F5LW1pY3JvaGVp%2Csize_96%2Ctext_5Zu-54G15a2m6Zmi5ZGo55Gc%2Ccolor_FFFFFF%2Cshadow_50%2Ct_80%2Cg_se%2Cx_10%2Cy_10#crop=0&crop=0&crop=1&crop=1&from=url&id=AZ4wL&margin=%5Bobject%20Object%5D&originHeight=2944&originWidth=3372&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=)
<a name="sdm10"></a>
## 12、Dubbo的负载均衡策略
Dubbo⽬前⽀持：
   1. 平衡加权轮询算法
   1. 加权随机算法
   1. ⼀致性哈希算法
   1. 最小活跃数算法
[https://www.yuque.com/renyong-jmovm/kb/gwu187](https://www.yuque.com/renyong-jmovm/kb/gwu187)
<a name="o2bFW"></a>
## 13、介绍熟悉的框架源码
这个问题⽐较⼴泛，你即可以说：HashMap、线程池等JDK⾃带的源码，也可以说Mybatis、Spring Boot、Spring Cloud、消息队列等开发框架或中间件的源码
<a name="lcuHd"></a>
# 二、阿里二面
<a name="rlsZD"></a>
## 1、Jdk1.7到Jdk1.8 HashMap发生了什么变化（底层）
   1. 1.7中底层是**数组+链表**，1.8中底层是**数组+链表+红⿊树**，加红⿊树的⽬的是提⾼HashMap插⼊和查询整体效率
   1. 1.7中链表插⼊使⽤的是**头插法**，1.8中链表插⼊使⽤的是**尾插法**，因为1.8中插⼊key和value时需要判断链表元素个数，所以需要遍历链表统计链表元素个数，所以正好就直接使⽤尾插法
   1. 1.7中哈希算法⽐较复杂，存在各种右移与异或运算，1.8中进⾏了简化，因为复杂的哈希算法的⽬的就 是提⾼散列性，来提供HashMap的整体效率，而1.8中新增了红⿊树，所以可以适当的简化哈希算法，节省CPU资源
<a name="lNcJX"></a>
## 2、Jdk1.7到Jdk1.8 java虚拟机发生了什么变化
1.7中存在永久代，1.8中没有永久代，替换它的是元空间，元空间所占的内存不是在虚拟机内部，⽽是本地内存空间，这么做的原因是，不管是永久代还是元空间，他们都是⽅法区的具体实现，之所以元空间所占的内存改成本地内存，官⽅的说法是为了和JRockit统⼀，不过额外还有⼀些原因，⽐如⽅法区所存储的类信息通常是⽐较难确定的，所以对于⽅法区的⼤⼩是⽐较难指定的，太⼩了容易出现⽅法区溢出，太⼤了⼜会占⽤了太多虚拟机的内存空间，⽽转移到本地内存后则不会影响虚拟机所占⽤的内存
<a name="LB3IA"></a>
## 3、如何实现AOP，项⽬哪些地方用到了AOP
利⽤动态代理技术来实现AOP，⽐如JDK动态代理或Cglib动态代理，利⽤动态代理技术，可以针对某个类 ⽣成代理对象，当调⽤代理对象的某个⽅法时，可以任意控制该⽅法的执⾏，⽐如可以先打印执⾏时间，再执⾏该⽅法，并且该⽅法执⾏完成后，再次打印执⾏时间。<br />项⽬中，⽐如事务、权限控制、⽅法执⾏时⻓⽇志都是通过AOP技术来实现的，凡是需要对某些⽅法做统 ⼀处理的都可以⽤AOP来实现，利⽤AOP可以做到业务⽆侵⼊<br />![](https://cdn.nlark.com/yuque/0/2021/png/365147/1623130985455-4c9944dc-a0f7-4a46-93a9-42ae50676421.png?x-oss-process=image%2Fwatermark%2Ctype_d3F5LW1pY3JvaGVp%2Csize_124%2Ctext_5Zu-54G15a2m6Zmi5ZGo55Gc%2Ccolor_FFFFFF%2Cshadow_50%2Ct_80%2Cg_se%2Cx_10%2Cy_10#crop=0&crop=0&crop=1&crop=1&from=url&id=RuAaI&margin=%5Bobject%20Object%5D&originHeight=2470&originWidth=4364&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=)
<a name="k5xba"></a>
## 4、Spring中后置处理器的作用
Spring中的后置处理器分为BeanFactory后置处理器和Bean后置处理器，它们是Spring底层源码架构设计中⾮常重要的⼀种机制，同时开发者也可以利⽤这两种后置处理器来进⾏扩展。BeanFactory后置处理器表示针对BeanFactory的处理器，Spring启动过程中，会先创建出BeanFactory实例，然后利⽤BeanFactory处理器来加⼯BeanFactory，⽐如Spring的扫描就是基于BeanFactory后置处理器来实现的，⽽Bean后置处理器也类似，Spring在创建⼀个Bean的过程中，⾸先会实例化得到⼀个对象，然后再利⽤Bean后置处理器来对该实例对象进⾏加⼯，⽐如我们常说的依赖注⼊就是基于⼀个Bean后置处理器来实现的，通过该Bean后置处理器来给实例对象中加了@Autowired注解的属性⾃动赋值，还⽐如我们常说的AOP，也是利⽤⼀个Bean后置处理器来实现的，基于原实例对象，判断是否需要进⾏AOP，如果需要，那么就基于原实例对象进⾏动态代理，生成⼀个代理对象。<br />![](https://cdn.nlark.com/yuque/0/2021/png/365147/1623131296541-f476845c-b5f8-478f-8ad1-deefbedd766a.png?x-oss-process=image%2Fwatermark%2Ctype_d3F5LW1pY3JvaGVp%2Csize_121%2Ctext_5Zu-54G15a2m6Zmi5ZGo55Gc%2Ccolor_FFFFFF%2Cshadow_50%2Ct_80%2Cg_se%2Cx_10%2Cy_10#crop=0&crop=0&crop=1&crop=1&from=url&id=a4EiE&margin=%5Bobject%20Object%5D&originHeight=3693&originWidth=4237&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=)
<a name="i8IHi"></a>
## 5、常用的SpringBoot注解及其实现
1. @SpringBootApplication注解：这个注解标识了⼀个SpringBoot⼯程，它实际上是另外三个注解的组 合，这三个注解是：
   - @SpringBootConfiguration：这个注解实际就是⼀个@Configuration，表示启动类也是⼀个配置类
   - @EnableAutoConfiguration：向Spring容器中导⼊了⼀个Selector，⽤来加载ClassPath下 SpringFactories中所定义的⾃动配置类，将这些⾃动加载为配置Bean
   - @ComponentScan：标识扫描路径，因为默认是没有配置实际扫描路径，所以SpringBoot扫描的 路径是启动类所在的当前⽬录
2. @Bean注解：⽤来定义Bean，类似于XML中的<bean>标签，Spring在启动时，会对加了@Bean注解 的⽅法进⾏解析，将⽅法的名字做为beanName，并通过执⾏⽅法得到bean对象
2. @Controller、@Service、@ResponseBody、@Autowired都可以说
<a name="MBE82"></a>
## 6、分布式锁实现
分布式锁所要解决的问题的本质是：能够对分布在多台机器中的线程对共享资源的互斥访问。在这个原理 上可以有很多的实现⽅式：
   1. 基于Mysql，分布式环境中的线程连接同⼀个数据库，利⽤数据库中的⾏锁来达到互斥访问，但是 Mysql的加锁和释放锁的性能会⽐较低，不适合真正的实际⽣产环境
   1. 基于Zookeeper，Zookeeper中的数据是存在内存的，所以相对于Mysql性能上是适合实际环境的， 并 且基于Zookeeper的顺序节点、临时节点、Watch机制能⾮常好的来实现的分布式锁
   1. 基于Redis，Redis中的数据也是在内存，基于Redis的消费订阅功能、数据超时时间，lua脚本等功能，也能很好的实现的分布式锁
<a name="OVqhi"></a>
## 7、Redis的数据结构及使用场景
Redis的数据结构有：
   1. 字符串：可以⽤来做最简单的数据缓存，可以缓存某个简单的字符串，也可以缓存某个json格式的字符串，Redis分布式锁的实现就利⽤了这种数据结构，还包括可以实现计数器、Session共享、分布式ID
   1. 哈希表：可以⽤来存储⼀些key-value对，更适合⽤来存储对象
   1. 列表：Redis的列表通过命令的组合，既可以当做栈，也可以当做队列来使⽤，可以⽤来缓存类似微信 公众号、微博等消息流数据
   1. 集合：和列表类似，也可以存储多个元素，但是不能重复，集合可以进⾏交集、并集、差集操作，从⽽可以实现类似，我和某⼈共同关注的⼈、朋友圈点赞等功能
   1. 有序集合：集合是⽆序的，有序集合可以设置顺序，可以⽤来实现排⾏榜功能
<a name="ppr1M"></a>
## 8、Redis集群策略
Redis提供了三种集群策略：
1. 主从模式：这种模式比较简单，主库可以读写，并且会和从库进⾏数据同步，这种模式下，客户端直接连主库或某个从库，但是但主库或从库宕机后，客户端需要⼿动修改IP，另外，这种模式也⽐较难进⾏扩容，整个集群所能存储的数据受到某台机器的内存容量，所以不可能⽀持特⼤数据量
1. 哨兵模式：这种模式在主从的基础上新增了哨兵节点，但主库节点宕机后，哨兵会发现主库节点宕机，然后在从库中选择⼀个库作为进的主库，另外哨兵也可以做集群，从⽽可以保证但某⼀个哨兵节点宕机 后，还有其他哨兵节点可以继续⼯作，这种模式可以⽐较好的保证Redis集群的⾼可⽤，但是仍然不能很好的解决Redis的容量上限问题。
1. Cluster模式：Cluster模式是⽤得⽐较多的模式，它⽀持多主多从，这种模式会按照key进⾏槽位的分配，可以使得不同的key分散到不同的主节点上，利⽤这种模式可以使得整个集群⽀持更⼤的数据容量，同时每个主节点可以拥有⾃⼰的多个从节点，如果该主节点宕机，会从它的从节点中选举⼀个新的主节点。
对于这三种模式，如果Redis要存的数据量不⼤，可以选择哨兵模式，如果Redis要存的数据量⼤，并且需要持续的扩容，那么选择Cluster模式。
<a name="cb3UF"></a>
## 9、Mysql数据库中索引失效的场景
   1. 没有符合最左前缀原则
   1. 字段进⾏了隐式数据类型转化
   1. ⾛索引没有全表扫描效率⾼
[https://www.bilibili.com/video/BV1W64y1u761?from=search&seid=6062298215110905390](https://www.bilibili.com/video/BV1W64y1u761?from=search&seid=6062298215110905390)
<a name="x0WYI"></a>
## 10、Innodb是如何实现事务的
Innodb通过Buffer Pool，LogBuffer，Redo Log，Undo Log来实现事务，以⼀ 个update语句为例：
   1. Innodb在收到⼀个update语句后，会先根据条件找到数据所在的⻚，并将该⻚缓存在Buffer Pool中
   1. 执⾏update语句，修改Buffer Pool中的数据，也就是内存中的数据
   1. 针对update语句⽣成⼀个RedoLog对象，并存⼊LogBuffer中
   1. 针对update语句⽣成undolog⽇志，⽤于事务回滚
   1. 如果事务提交，那么则把RedoLog对象进⾏持久化，后续还有其他机制将Buffer Pool中所修改的数据 ⻚持久化到磁盘中
   1. 如果事务回滚，则利⽤undolog⽇志进⾏回滚
<a name="FTNxp"></a>
## 11、聊聊你最有成就感的项目
1. 项⽬是做什么的<br />2. ⽤了什么技术<br />3. 你在项⽬中担任的职位<br />4. 收获了什么
<a name="iH0rn"></a>
## 12、自己最有挑战的项目、难点
1. 使⽤什么技术解决了什么项⽬难点<br />2. 使⽤什么技术优化了什么项⽬功能<br />3. 使⽤什么技术节省了多少成本
<a name="xbEOf"></a>
# 三、京东一面
<a name="RmHzj"></a>
## 1、遇到过哪些设计模式
在学习⼀些框架或中间件的底层源码的时候遇到过⼀些设计模式：
   1. 代理模式：Mybatis中⽤到JDK动态代理来⽣成Mapper的代理对象，在执⾏代理对象的⽅法时会去执⾏SQL，Spring中AOP、包括@Configuration注解的底层实现也都⽤到了代理模式
   1. 责任链模式：Tomcat中的Pipeline实现，以及Dubbo中的Filter机制都使⽤了责任链模式
   1. ⼯⼚模式：Spring中的BeanFactory就是⼀种⼯⼚模式的实现
   1. 适配器模式：Spring中的Bean销毁的⽣命周期中⽤到了适配器模式，用来适配各种Bean销毁逻辑的执行方式
   1. 外观模式：Tomcat中的Request和RequestFacade之间体现的就是外观模式
   1. 模板⽅法模式：Spring中的refresh⽅法中就提供了给⼦类继承重写的⽅法，就⽤到了模板⽅法模式
<a name="xkU9D"></a>
## 2、Java死锁如何避免
造成死锁的几个原因：
   1. ⼀个资源每次只能被⼀个线程使⽤
   1. ⼀个线程在阻塞等待某个资源时，不释放已占有资源
   1. ⼀个线程已经获得的资源，在未使⽤完之前，不能被强⾏剥夺
   1. 若⼲线程形成头尾相接的循环等待资源关系
这是造成死锁必须要达到的4个条件，如果要避免死锁，只需要不满⾜其中某⼀个条件即可。而其中前3个 条件是作为锁要符合的条件，所以要避免死锁就需要打破第4个条件，不出现循环等待锁的关系。
在开发过程中：
   1. 要注意加锁顺序，保证每个线程按同样的顺序进⾏加锁
   1. 要注意加锁时限，可以针对所设置⼀个超时时间
   1. 要注意死锁检查，这是⼀种预防机制，确保在第⼀时间发现死锁并进⾏解决
<a name="MbDev"></a>
## 3、深拷贝和浅拷贝
深拷贝和浅拷⻉就是指对象的拷贝，⼀个对象中存在两种类型的属性，⼀种是基本数据类型，⼀种是实例对象的引用
   1. 浅拷贝是指，只会拷贝基本数据类型的值，以及实例对象的引⽤地址，并不会复制⼀份引⽤地址所指向的对象，也就是浅拷⻉出来的对象，内部的类属性指向的是同⼀个对象
   1. 深拷贝是指，既会拷贝基本数据类型的值，也会针对实例对象的引⽤地址所指向的对象进⾏复制，深拷⻉出来的对象，内部的属性指向的不是同⼀个对象
<a name="zdJmn"></a>
## 4、如果你提交任务时，线程池队列已满，这时会发生什么
   1. 如果使⽤的⽆界队列，那么可以继续提交任务时没关系的
   1. 如果使⽤的有界队列，提交任务时，如果队列满了，如果核⼼线程数没有达到上限，那么则增加线程，如果线程数已经达到了最⼤值，则使⽤拒绝策略进⾏拒绝
<a name="DciQl"></a>
## 5、谈谈ConcurrentHashMap的扩容机制
1.7版本
   1. 1.7版本的ConcurrentHashMap是基于Segment分段实现的
   1. 每个Segment相对于⼀个小型的HashMap
   1. 每个Segment内部会进⾏扩容，和HashMap的扩容逻辑类似
   1. 先⽣成新的数组，然后转移元素到新数组中
   1. 扩容的判断也是每个Segment内部单独判断的，判断是否超过阈值
1.8版本
   1. 1.8版本的ConcurrentHashMap不再基于Segment实现
   1. 当某个线程进⾏put时，如果发现ConcurrentHashMap正在进⾏扩容那么该线程⼀起进⾏扩容
   1. 如果某个线程put时，发现没有正在进⾏扩容，则将key-value添加到ConcurrentHashMap中，然后 判断是否超过阈值，超过了则进⾏扩容
   1. ConcurrentHashMap是⽀持多个线程同时扩容的
   1. 扩容之前也先⽣成⼀个新的数组
   1. 在转移元素时，先将原数组分组，将每组分给不同的线程来进⾏元素的转移，每个线程负责⼀组或多组 的元素转移⼯作
<a name="HQ2wN"></a>
## 6、Spring中Bean是线程安全的吗？
Spring本身并没有针对Bean做线程安全的处理，所以：
   1. 如果Bean是⽆状态的，那么Bean则是线程安全的
   1. 如果Bean是有状态的，那么Bean则不是线程安全的
另外，Bean是不是线程安全，跟Bean的作⽤域没有关系，Bean的作⽤域只是表示Bean的⽣命周期范围， 对于任何⽣命周期的Bean都是⼀个对象，这个对象是不是线程安全的，还是得看这个Bean对象本身。
<a name="Q1t1q"></a>
## 7、说说你常用的Linux基本操作命令
   1. 增删查改
   1. 防⽕墙相关
   1. ssh/scp
   1. 软件下载 、 解压 、 安装
   1. 修改权限
<a name="JEnIH"></a>
## 8、Maven中Package和Install的区别
   1. Package是打包，打成Jar或War
   1. Install表示将Jar或War安装到本地仓库中
<a name="sOIpG"></a>
## 9、项⽬及主要负责的模块
平时要多了解⼀ 下你⽬前在做的项⽬中的核⼼模块， 核⼼功能的业务与使⽤到的技术
<a name="eXqkZ"></a>
## 10、SpringCloud各组件功能，与Dubbo的区别
   1. Eureka：注册中⼼，⽤来进⾏服务的⾃动注册和发现
   1. Ribbon：负载均衡组件，⽤来在消费者调⽤服务时进⾏负载均衡
   1. Feign：基于接⼝的申明式的服务调⽤客户端，让调⽤变得更简单
   1. Hystrix：断路器，负责服务容错
   1. Zuul：服务⽹关，可以进⾏服务路由、服务降级、负载均衡等
   1. Nacos：分布式配置中⼼以及注册中⼼
   1. Sentinel：服务的熔断降级，包括限流
   1. Seata：分布式事务
   1. Spring Cloud Config：分布式配置中⼼
   1. Spring Cloud Bus：消息总线
   1. ...
[https://www.bilibili.com/video/BV1uy4y1W7tt?from=search&seid=94459244624220142](https://www.bilibili.com/video/BV1uy4y1W7tt?from=search&seid=94459244624220142)
Spring Cloud是⼀个微服务框架，提供了微服务领域中的很多功能组件，Dubbo⼀开始是⼀个RPC调⽤框 架，核⼼是解决服务调⽤间的问题，Spring Cloud是⼀个⼤⽽全的框架，Dubbo则更侧重于服务调⽤，所 以Dubbo所提供的功能没有Spring Cloud全⾯，但是Dubbo的服务调⽤性能⽐Spring Cloud⾼，不过        Spring Cloud和Dubbo并不是对⽴的，是可以结合起来⼀ 起使⽤的。
<a name="ohXcq"></a>
# 四、京东二面
<a name="MOyTS"></a>
## 1、说说类加载器双亲委派模型
JVM中存在三个默认的类加载器：
   1. BootstrapClassLoader
   1. ExtClassLoader
   1. AppClassLoader
AppClassLoader的⽗加载器是ExtClassLoader，ExtClassLoader的⽗加载器是BootstrapClassLoader。
JVM在加载⼀个类时，会调⽤AppClassLoader的loadClass⽅法来加载这个类，不过在这个⽅法中，会先使⽤ExtClassLoader的loadClass⽅法来加载类，同样ExtClassLoader的loadClass⽅法中会先使⽤BootstrapClassLoader来加载类，如果BootstrapClassLoader加载到了就直接成功，如果BootstrapClassLoader没有加载到，那么ExtClassLoader就会⾃⼰尝试加载该类，如果没有加载到，那么则会由AppClassLoader来加载这个类。
所以，双亲委派指得是，JVM在加载类时，会委派给Ext和Bootstrap进⾏加载，如果没加载到才由⾃⼰进⾏加载。
<a name="LqZrQ"></a>
## 2、泛型中extends和super的区别
   1. <? extends T>表示包括T在内的任何T的⼦类
   1. <? super T>表示包括T在内的任何T的⽗类
<a name="KPi7F"></a>
## 3、并发编程三要素
   1. 原⼦性：不可分割的操作，多个步骤要保证同时成功或同时失败
   1. 有序性：程序执⾏的顺序和代码的顺序保持⼀致
   1. 可⽤性：⼀个线程对共享变量的修改，另⼀个线程能⽴⻢看到
<a name="yemIk"></a>
## 4、Spring用到了哪些设计模式
![图片.png](https://cdn.nlark.com/yuque/0/2022/png/22523384/1646145155616-267df7de-1324-40b7-9c72-4fc3ac99f367.png#clientId=u03eef26e-03e0-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=957&id=u3da8b008&margin=%5Bobject%20Object%5D&name=%E5%9B%BE%E7%89%87.png&originHeight=957&originWidth=1500&originalType=binary&ratio=1&rotation=0&showTitle=false&size=130389&status=done&style=none&taskId=u0fae7c4b-8ed4-4a6b-aad6-56a6071e265&title=&width=1500)
<a name="gpStK"></a>
## 5、简述CAP理论
CAP理论是分布式领域⾮常重要的⼀个理论，很多分布式中间件在实现时都需要遵守这个理论，其中：
   1. C表示⼀致性：指的的是分布式系统中的数据的⼀致性
   1. A表示可⽤性：表示分布式系统是否正常可⽤
   1. P表示分区容器性：表示分布式系统出现⽹络问题时的容错性
CAP理论是指，在分布式系统中不能同时保证C和A，也就是说在分布式系统中要么保证CP，要么保证AP，也就是⼀致性和可⽤性只能取其⼀，如果想要数据的⼀致性，那么就需要损失系统的可⽤性，如果需要系统⾼可⽤，那么就要损失系统的数据⼀致性，特指强⼀致性。
CAP理论太过严格，在实际⽣产环境中更多的是使⽤BASE理论，BASE理论是指分布式系统不需要保证数据的强⼀致，只要做到最终⼀致，也不需要保证⼀直可⽤，保证基本可⽤即可。
<a name="c1pcA"></a>
## 6、图的深度遍历和广度遍历
   1. 图的深度优先遍历是指，从⼀个节点出发，⼀直沿着边向下深⼊去找节点，如果找不到了则返回上⼀层找其他节点
   1. 图的⼴度优先遍历只是，从⼀个节点出发，向下先把第⼀层的节点遍历完，再去遍历第⼆层的节点， 直到遍历到最后⼀层
<a name="aOb6H"></a>
## 7、快排算法
快速排序算法底层采⽤了分治法。<br />基本思想是：
   1. 先取出数列中的第⼀个数作为基准数
   1. 将数列中比基准数⼤的数全部放在它的右边，比基准数小的数全部放在它的左边
   1. 然后在对左右两部分重复第⼆步，直到各区间只有⼀个数
Java版算法实现
```java
 public class QuickSort {
     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]; 11
         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); 
 }  
public static void main(String[] args){ 
     int[] arr = {10,7,2,4,7,62,3,4,2,1,8,9,19}; 
     quickSort(arr, 0, arr.length-1); 
     for (int i = 0; i < arr.length; i++) { 
         System.out.println(arr[i]); 
     } 
 }

8、TCP的三次握手和四次挥手

TCP协议是7层⽹络协议中的传输层协议，负责数据的可靠传输。
在建⽴TCP连接时，需要通过三次握⼿来建⽴，过程是：

客户端向服务端发送⼀个SYN
服务端接收到SYN后，给客户端发送⼀个SYN_ACK
客户端接收到SYN_ACK后，再给服务端发送⼀个ACK

在断开TCP连接时，需要通过四次挥⼿来断开，过程是：

客户端向服务端发送FIN
服务端接收FIN后，向客户端发送ACK，表示我接收到了断开连接的请求，客户端你可以不发数据了，不过服务端这边可能还有数据正在处理
服务端处理完所有数据后，向客户端发送FIN，表示服务端现在可以断开连接
客户端收到服务端的FIN，向服务端发送ACK，表示客户端也会断开连接了
9、消息队列如何保证消息可靠传输
消息可靠传输代表了两层意思，既不能多也不能少。

为了保证消息不多，也就是消息不能重复，也就是⽣产者不能重复⽣产消息，或者消费者不能重复消费消息
- ⾸先要确保消息不多发，这个不常出现，也⽐较难控制，因为如果出现了多发，很⼤的原因是⽣产者⾃⼰的原因，如果要避免出现问题，就需要在消费端做控制
- 要避免不重复消费，最保险的机制就是消费者实现幂等性，保证就算重复消费，也不会有问题，通过幂等性，也能解决⽣产者重复发送消息的问题
消息不能少，意思就是消息不能丢失，⽣产者发送的消息，消费者⼀定要能消费到，对于这个问题，就要考虑两个⽅⾯
- ⽣产者发送消息时，要确认broker确实收到并持久化了这条消息，⽐如RabbitMQ的confirm机制，Kafka的ack机制都可以保证⽣产者能正确的将消息发送给broker
- broker要等待消费者真正确认消费到了消息时才删除掉消息，这⾥通常就是消费端ack机制，消费者接收到⼀条消息后，如果确认没问题了，就可以给broker发送⼀个ack，broker接收到ack后才会删除消息
  10、画出项目架构图，介绍自己所处的模块
  需要⼤家⼯作中积极的去了解项⽬架构
  五、蚂蚁一面
  1、二叉搜索树和平衡二叉树有什么关系？
  平衡二叉树也叫做平衡⼆叉搜索树，是二叉搜索树的升级版，二叉搜索树是指节点左边的所有节点都⽐该节点小，节点右边的节点都⽐该节点⼤，⽽平衡二叉搜索树是在二叉搜索的基础上还规定了节点左右两边的子树⾼度差的绝对值不能超过1
  2、强平衡二叉树和弱平衡二叉树有什么区别
  强平衡二叉树AVL树，弱平衡叉二树就是我们说的红⿊树。
1. AVL树⽐红⿊树对于平衡的程度更加严格，在相同节点的情况下，AVL树的⾼度低于红⿊树
2. 红⿊树中增加了⼀个节点颜⾊的概念
3. AVL树的旋转操作⽐红⿊树的旋转操作更耗时
  
  3、B树和B+树的区别，为什么Mysql使用B+树
  B树的特点：
4. 节点排序
5. ⼀个节点了可以存多个元素，多个元素也排序了

B+树的特点：

拥有B树的特点
叶⼦节点之间有指针
⾮叶⼦节点上的元素在叶⼦节点上都冗余了，也就是叶⼦节点中存储了所有的元素，并且排好顺序

Mysql索引使⽤的是B+树，因为索引是⽤来加快查询的，而B+树通过对数据进行排序所以是可以提⾼查询速度的，然后通过⼀个节点中可以存储多个元素，从⽽可以使得B+树的⾼度不会太⾼，在Mysql中⼀个 Innodb⻚就是⼀个B+树节点，⼀个Innodb⻚默认16kb，所以⼀般情况下⼀颗两层的B+树可以存2000万⾏左右的数据，然后通过利⽤B+树叶⼦节点存储了所有数据并且进⾏了排序，并且叶⼦节点之间有指针，可以很好的⽀持全表扫描，范围查找等SQL语句。

4、epoll和poll的区别

select模型，使⽤的是数组来存储Socket连接⽂件描述符，容量是固定的，需要通过轮询来判断是否发⽣了IO事件
poll模型，使⽤的是链表来存储Socket连接⽂件描述符，容量是不固定的，同样需要通过轮询来判断是否发⽣了IO事件
epoll模型，epoll和poll是完全不同的，epoll是⼀种事件通知模型，当发⽣了IO事件时，应⽤程序才进⾏IO操作，不需要像poll模型那样主动去轮询

5、简述线程池原理，FixedThreadPool用的阻塞队列是什么
线程池内部是通过队列+线程实现的，当我们利⽤线程池执⾏任务时：
如果此时线程池中的数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。
如果此时线程池中的数量等于corePoolSize，但是缓冲队列workQueue未满，那么任务被放⼊缓冲队列
如果此时线程池中的数量⼤于等于corePoolSize，缓冲队列workQueue满，并且线程池中的数量小于maximumPoolSize，建新的线程来处理被添加的任务。
如果此时线程池中的数量⼤于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于 maximumPoolSize 那么通过 handler所指定的策略来处理此任务。
当线程池中的线程数量⼤于corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池可以动态的调整池中的线程数

FixedThreadPool代表定⻓线程池，底层⽤的LinkedBlockingQueue，表示⽆界的阻塞队列。

6、sychronized和ReentrantLock的区别

sychronized是⼀个关键字，ReentrantLock是⼀类
sychronized会⾃动的加锁与释放锁，ReentrantLock需要程序员⼿动加锁与释放锁
sychronized的底层是JVM层⾯的锁，ReentrantLock是API层⾯的锁
sychronized是非公平锁，ReentrantLock可以选择公平锁或⾮公平锁
sychronized锁的是对象，锁信息保存在对象头中，ReentrantLock通过代码中int类型的state标识来标识锁的状态
sychronized底层有⼀个锁升级的过程
7、sychronized的⾃旋锁、偏向锁、轻量级锁、重量级锁，分别介绍和联系

偏向锁：在锁对象的对象头中记录⼀下当前获取到该锁的线程ID，该线程下次如果⼜来获取该锁就可以直接获取到了
轻量级锁：由偏向锁升级⽽来，当⼀个线程获取到锁后，此时这把锁是偏向锁，此时如果有第⼆个线程来竞争锁，偏向锁就会升级为轻量级锁，之所以叫轻量级锁，是为了和重量级锁区分开来，轻量级锁底层是通过⾃旋来实现的，并不会阻塞线程
如果⾃旋次数过多仍然没有获取到锁，则会升级为重量级锁，重量级锁会导致线程阻塞
⾃旋锁：⾃旋锁就是线程在获取锁的过程中，不会去阻塞线程，也就⽆所谓唤醒线程，阻塞和唤醒这两个步骤都是需要操作系统去进⾏的，⽐较消耗时间，⾃旋锁是线程通过CAS获取预期的⼀个标记，如果没有获取到，则继续循环获取，如果获取到了则表示获取到了锁，这个过程线程⼀直在运⾏中，相对⽽⾔没有使⽤太多的操作系统资源，⽐较轻量。

8、HTTPS是如何保证安全传输的
https通过使⽤对称加密、非对称加密、数字证书等⽅式来保证数据的安全传输。
客户端向服务端发送数据之前，需要先建⽴TCP连接，所以需要先建⽴TCP连接，建⽴完TCP连接后，服务端会先给客户端发送公钥，客户端拿到公钥后就可以⽤来加密数据了，服务端到时候接收到数据就可以⽤私钥解密数据，这种就是通过⾮对称加密来传输数据
不过⾮对称加密⽐对称加密要慢，所以不能直接使⽤⾮对称加密来传输请求数据，所以可以通过⾮对称加密的⽅式来传输对称加密的秘钥，之后就可以使⽤对称加密来传输请求数据了
但是仅仅通过⾮对称加密+对称加密还不⾜以能保证数据传输的绝对安全，因为服务端向客户端发送公钥时，可能会被截取
所以为了安全的传输公钥，需要⽤到数字证书，数字证书是具有公信⼒、⼤家都认可的，服务端向客户端发送公钥时，可以把公钥和服务端相关信息通过Hash算法⽣成消息摘要，再通过数字证书提供的私钥对消息摘要进⾏加密⽣成数字签名，在把没进⾏Hash算法之前的信息和数字签名⼀起形成数字证书，最后把数字证书发送给客户端，客户端收到数字证书后，就会通过数字证书提供的公钥来解密数字证书，从⽽得到⾮对称加密要⽤到的公钥。
在这个过程中，就算有中间⼈拦截到服务端发出来的数字证书，虽然它可以解密得到⾮对称加密要使⽤的公钥，但是中间⼈是办法伪造数字证书发给客户端的，因为客户端上内嵌的数字证书是全球具有公信⼒的，某个⽹站如果要⽀持https，都是需要申请数字证书的私钥的，中间⼈如果要⽣成能被客户端解析的数字证书，也是要申请私钥的，所以是⽐较安全了。

六、蚂蚁二面

1、设计模式有哪些大类，及熟悉其中哪些设计模式
设计模式分为三⼤类：
创建型

a. ⼯⼚模式（Factory Pattern）
b. 抽象⼯⼚模式（Abstract Factory Pattern）
c. 单例模式（Singleton Pattern）
d. 建造者模式（Builder Pattern）
e. 原型模式（Prototype Pattern）

结构型

a. 适配器模式（Adapter Pattern）
b. 桥接模式（Bridge Pattern）
c. 过滤器模式（Filter 、 Criteria Pattern）
d. 组合模式（Composite Pattern）
e. 装饰器模式（Decorator Pattern）
f. 外观模式（Facade Pattern）
g. 享元模式（Flyweight Pattern）
h. 代理模式（Proxy Pattern）

⾏为型

a. 责任链模式（Chain of Responsibility Pattern）
b. 命令模式（Command Pattern）
c. 解释器模式（Interpreter Pattern）
d. 迭代器模式（Iterator Pattern）
e. 中介者模式（Mediator Pattern）
f. 备忘录模式（Memento Pattern）
g. 观察者模式（Observer Pattern）
h. 状态模式（State Pattern）
i. 空对象模式（Null Object Pattern）
j. 策略模式（Strategy Pattern）
k. 模板模式（Template Pattern）
l. 访问者模式（Visitor Pattern）

2、volatile关键字，他是如何保证可见性，有序性

对于加了volatile关键字的成员变量，在对这个变量进⾏修改时，会直接将CPU⾼级缓存中的数据写回到主内存，对这个变量的读取也会直接从主内存中读取，从⽽保证了可⻅性
在对volatile修饰的成员变量进⾏读写时，会插⼊内存屏障，而内存屏障可以达到禁⽌重排序的效果，从⽽可以保证有序性
3、Java的内存结构，堆分为哪几部分，默认年龄多大进入老年代

年轻代

a. Eden区（8）
b. From Survivor区（1）
c. To Survivor区（1）

⽼年代

默认对象的年龄达到15后，就会进⼊⽼年代

4、Mysql的锁你了解哪些

按锁粒度分类：

⾏锁：锁某⾏数据，锁粒度最小，并发度高
表锁：锁整张表，锁粒度最⼤，并发度低
间隙锁：锁的是⼀个区间

还可以分为：

共享锁：也就是读锁，⼀个事务给某⾏数据加了读锁，其他事务也可以读，但是不能写
排它锁：也就是写锁，⼀个事务给某⾏数据加了写锁，其他事务不能读，也不能写

还可以分为：

乐观锁：并不会真正的去锁某⾏记录，⽽是通过⼀个版本号来实现的
悲观锁：上⾯所的⾏锁、表锁等都是悲观锁

在事务的隔离级别实现中，就需要利⽤所来解决幻读

Java 编程

阿里、京东、蚂蚁真题解析

一、阿里一面

1、ArrayList和LinkedList区别

2、HashMap的Put方法

3、ThreadLocal

4、JVM中哪些是共享区，哪些可以作为gc root

5、项目如何排查JVM问题

6、如何查看线程死锁

8、TCP的三次握手和四次挥手

9、消息队列如何保证消息可靠传输

10、画出项目架构图，介绍自己所处的模块

五、蚂蚁一面

1、二叉搜索树和平衡二叉树有什么关系？

2、强平衡二叉树和弱平衡二叉树有什么区别

3、B树和B+树的区别，为什么Mysql使用B+树

4、epoll和poll的区别

5、简述线程池原理，FixedThreadPool用的阻塞队列是什么

6、sychronized和ReentrantLock的区别

7、sychronized的⾃旋锁、偏向锁、轻量级锁、重量级锁，分别介绍和联系

8、HTTPS是如何保证安全传输的

六、蚂蚁二面

1、设计模式有哪些大类，及熟悉其中哪些设计模式

2、volatile关键字，他是如何保证可见性，有序性

3、Java的内存结构，堆分为哪几部分，默认年龄多大进入老年代

4、Mysql的锁你了解哪些

5、ConcurrentHashMap如何保证线程安全，jdk1.8有什么变化

6、讲⼀下OOM以及遇到这种情况怎么处理的，是否使用过日志分析工具

7、Mysql索引原理

8、介绍⼀下亮点的项目

9、项目的并发大概有多高，Redis的瓶颈是多少

10、项目中遇到线上问题怎么处理的，说一下印象最深刻的