爱因斯坦说过“耐心和恒心总会得到报酬的”，我也一直把这句话当做自己的座右铭，这句箴言在今年也彻底在“我”身上实现了。

京东一面：

为了大家可以直观的看到，以下是京东一面的相关面试题，下面是解析！

1、遇到过哪些设计模式？

在学习⼀些框架或中间件的底层源码的时候遇到过⼀些设计模式：

1. 代理模式：Mybatis中⽤到JDK动态代理来⽣成Mapper的代理对象，在执⾏代理对象的⽅法时会去执⾏SQL，Spring中AOP、包括@Configuration注解的底层实现也都⽤到了代理模式

2. 责任链模式：Tomcat中的Pipeline实现，以及Dubbo中的Filter机制都使⽤了责任链模式

3. ⼯⼚模式：Spring中的BeanFactory就是⼀种⼯⼚模式的实现

4. 适配器模式：Spring中的Bean销毁的⽣命周期中⽤到了适配器模式，⽤来适配各种Bean销毁逻辑的执⾏⽅式

5. 外观模式：Tomcat中的Request和RequestFacade之间体现的就是外观模式

6. 模板⽅法模式：Spring中的refresh⽅法中就提供了给⼦类继承重写的⽅法，就⽤到了模板⽅法模式

2、Java死锁如何避免？

造成死锁的⼏个原因：

1. ⼀个资源每次只能被⼀个线程使⽤
2. ⼀个线程在阻塞等待某个资源时，不释放已占有资源
3. ⼀个线程已经获得的资源，在未使⽤完之前，不能被强⾏剥夺
4. 若⼲线程形成头尾相接的循环等待资源关系

这是造成死锁必须要达到的4个条件，如果要避免死锁，只需要不满⾜其中某⼀个条件即可。⽽其中前3个条件是作为锁要符合的条件，所以要避免死锁就需要打破第4个条件，不出现循环等待锁的关系。

在开发过程中：

1. 要注意加锁顺序，保证每个线程按同样的顺序进⾏加锁
2. 要注意加锁时限，可以针对所设置⼀个超时时间
3. 要注意死锁检查，这是⼀种预防机制，确保在第⼀时间发现死锁并进⾏解决

3、深拷⻉和浅拷⻉

深拷⻉和浅拷⻉就是指对象的拷⻉，⼀个对象中存在两种类型的属性，⼀种是基本数据类型，⼀种是实例对象的引⽤。

1. 浅拷⻉是指，只会拷⻉基本数据类型的值，以及实例对象的引⽤地址，并不会复制⼀份引⽤地址所指向的对象，也就是浅拷⻉出来的对象，内部的类属性指向的是同⼀个对象
2. 深拷⻉是指，既会拷⻉基本数据类型的值，也会针对实例对象的引⽤地址所指向的对象进⾏复制，深拷⻉出来的对象，内部的属性指向的不是同⼀个对象

4、如果你提交任务时，线程池队列已满，这时会发⽣什么

1. 如果使⽤的⽆界队列，那么可以继续提交任务时没关系的
2. 如果使⽤的有界队列，提交任务时，如果队列满了，如果核⼼线程数没有达到上限，那么则增加线程，如果线程数已经达到了最⼤值，则使⽤拒绝策略进⾏拒绝

5、谈谈ConcurrentHashMap的扩容机制

1.7版本

1. 1.7版本的ConcurrentHashMap是基于Segment分段实现的

1. 每个Segment相对于⼀个⼩型的HashMap
2. 每个Segment内部会进⾏扩容，和HashMap的扩容逻辑类似
3. 先⽣成新的数组，然后转移元素到新数组中
4. 扩容的判断也是每个Segment内部单独判断的，判断是否超过阈值

1.8版本

1. 1.8版本的ConcurrentHashMap不再基于Segment实现

1. 当某个线程进⾏put时，如果发现ConcurrentHashMap正在进⾏扩容那么该线程⼀起进⾏扩容
2. 如果某个线程put时，发现没有正在进⾏扩容，则将key-value添加到ConcurrentHashMap中，然后判断是否超过阈值，超过了则进⾏扩容
3. ConcurrentHashMap是⽀持多个线程同时扩容的
4. 扩容之前也先⽣成⼀个新的数组
5. 在转移元素时，先将原数组分组，将每组分给不同的线程来进⾏元素的转移，每个线程负责⼀组或多组的元素转移⼯作

6、Spring中Bean是线程安全的吗？

Spring本身并没有针对Bean做线程安全的处理，所以：

1. 如果Bean是⽆状态的，那么Bean则是线程安全的
2. 如果Bean是有状态的，那么Bean则不是线程安全的

另外，Bean是不是线程安全，跟Bean的作⽤域没有关系，Bean的作⽤域只是表示Bean的⽣命周期范围，对于任何⽣命周期的Bean都是⼀个对象，这个对象是不是线程安全的，还是得看这个Bean对象本身。

7、说说你常⽤的Linux基本操作命令

1. 增删查改
2. 防⽕墙相关
3. ssh/scp
4. 软件下载、解压、安装
5. 修改权限

8、Maven中Package和Install的区别

1. Package是打包，打成Jar或War
2. Install表示将Jar或War安装到本地仓库中

9、项⽬及主要负责的模块

平时要多了解⼀下你⽬前在做的项⽬中的核⼼模块，核⼼功能的业务与使⽤到的技术

10、SpringCloud各组件功能，与Dubbo的区别

1. Eureka：注册中⼼，⽤来进⾏服务的⾃动注册和发现
2. Ribbon：负载均衡组件，⽤来在消费者调⽤服务时进⾏负载均衡
3. Feign：基于接⼝的申明式的服务调⽤客户端，让调⽤变得更简单
4. Hystrix：断路器，负责服务容错
5. Zuul：服务⽹关，可以进⾏服务路由、服务降级、负载均衡等
6. Nacos：分布式配置中⼼以及注册中⼼
7. Sentinel：服务的熔断降级，包括限流
8. Seata：分布式事务
9. Spring Cloud Config：分布式配置中⼼
10. Spring Cloud Bus：消息总线

京东面试真题解析|配套笔记：

Spring Cloud是⼀个微服务框架，提供了微服务领域中的很多功能组件，Dubbo⼀开始是⼀个RPC调⽤框架，核⼼是解决服务调⽤间的问题，Spring Cloud是⼀个⼤⽽全的框架，Dubbo则更侧重于服务调⽤，所以Dubbo所提供的功能没有Spring Cloud全⾯，但是Dubbo的服务调⽤性能⽐Spring Cloud⾼，不过Spring Cloud和Dubbo并不是对⽴的，是可以结合起来⼀起使⽤的。

京东二面：

1、说说类加载器双亲委派模型

JVM中存在三个默认的类加载器：

1. BootstrapClassLoader
2. ExtClassLoader
3. AppClassLoader

AppClassLoader的⽗加载器是ExtClassLoader，ExtClassLoader的⽗加载器是BootstrapClassLoader。

JVM在加载⼀个类时，会调⽤AppClassLoader的loadClass⽅法来加载这个类，不过在这个⽅法中，会先使⽤ExtClassLoader的loadClass⽅法来加载类，同样ExtClassLoader的loadClass⽅法中会先使⽤BootstrapClassLoader来加载类，如果BootstrapClassLoader加载到了就直接成功，如果BootstrapClassLoader没有加载到，那么ExtClassLoader就会⾃⼰尝试加载该类，如果没有加载到，那么则会由AppClassLoader来加载这个类。

所以，双亲委派指得是，JVM在加载类时，会委派给Ext和Bootstrap进⾏加载，如果没加载到才由⾃⼰进⾏加载。

2、泛型中extends和super的区别

1. 表示包括T在内的任何T的⼦类
2. 表示包括T在内的任何T的⽗类

3、并发编程三要素？

1. 原⼦性：不可分割的操作，多个步骤要保证同时成功或同时失败
2. 有序性：程序执⾏的顺序和代码的顺序保持⼀致
3. 可⽤性：⼀个线程对共享变量的修改，另⼀个线程能⽴⻢看到

4、Spring⽤到了哪些设计模式

5、简述CAP理论

CAP理论是分布式领域⾮常重要的⼀个理论，很多分布式中间件在实现时都需要遵守这个理论，其中：

1. C表示⼀致性：指的的是分布式系统中的数据的⼀致性
2. A表示可⽤性：表示分布式系统是否正常可⽤
3. P表示分区容器性：表示分布式系统出现⽹络问题时的容错性

CAP理论是指，在分布式系统中不能同时保证C和A，也就是说在分布式系统中要么保证CP，要么保证AP，也就是⼀致性和可⽤性只能取其⼀，如果想要数据的⼀致性，那么就需要损失系统的可⽤性，如果需要系统⾼可⽤，那么就要损失系统的数据⼀致性，特指强⼀致性。

CAP理论太过严格，在实际⽣产环境中更多的是使⽤BASE理论，BASE理论是指分布式系统不需要保证数据的强⼀致，只要做到最终⼀致，也不需要保证⼀直可⽤，保证基本可⽤即可。

6、图的深度遍历和⼴度遍历

1. 图的深度优先遍历是指，从⼀个节点出发，⼀直沿着边向下深⼊去找节点，如果找不到了则返回上⼀层找其他节点
2. 图的⼴度优先遍历只是，从⼀个节点出发，向下先把第⼀层的节点遍历完，再去遍历第⼆层的节点，直到遍历到最后⼀层

7、快排算法

快速排序算法底层采⽤了分治法。

基本思想是：

1. 先取出数列中的第⼀个数作为基准数
2. 将数列中⽐基准数⼤的数全部放在它的右边，⽐基准数⼩的数全部放在它的左边
3. 然后在对左右两部分重复第⼆步，直到各区间只有⼀个数

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就是基准位 10 temp = arr[low]; 1112 while (i<j) { 13 //先看右边，依次往左递减 14 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连接时，需要通过三次握⼿来建⽴，过程是：

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

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

1. 客户端向服务端发送FIN
2. 服务端接收FIN后，向客户端发送ACK，表示我接收到了断开连接的请求，客户端你可以不发数据了， 不过服务端这边可能还有数据正在处理
3. 服务端处理完所有数据后，向客户端发送FIN，表示服务端现在可以断开连接
4. 客户端收到服务端的FIN，向服务端发送ACK，表示客户端也会断开连接了

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

消息可靠传输代表了两层意思，既不能多也不能少。

1. 为了保证消息不多，也就是消息不能重复，也就是⽣产者不能重复⽣产消息，或者消费者不能重复消费消息

a. ⾸先要确保消息不多发，这个不常出现，也⽐较难控制，因为如果出现了多发，很⼤的原因是⽣产者⾃⼰的原因，如果要避免出现问题，就需要在消费端做控制
b. 要避免不重复消费，最保险的机制就是消费者实现幂等性，保证就算重复消费，也不会有问题，通过幂等性，也能解决⽣产者重复发送消息的问题

1. 消息不能少，意思就是消息不能丢失，⽣产者发送的消息，消费者⼀定要能消费到，对于这个问题，就要考虑两个⽅⾯

a. ⽣产者发送消息时，要确认broker确实收到并持久化了这条消息，⽐如RabbitMQ的confirm机制，Kafka的ack机制都可以保证⽣产者能正确的将消息发送给broker
b. broker要等待消费者真正确认消费到了消息时才删除掉消息，这⾥通常就是消费端ack机制，消费者接收到⼀条消息后，如果确认没问题了，就可以给broker发送⼀个ack，broker接收到ack后才会删除消息

10、画出项⽬架构图，介绍⾃⼰所处的模块

需要⼤家⼯作中积极的去了解项⽬架构