admin管理员组文章数量:1570219
目录
… 1
大厂面试的基本流程 17
字节跳动 17
阿里 17
腾讯 18
网易游戏 18
面试前需要准备： 18
面试中可以借鉴的套路 19
- 用简历争取到更多的面试机会 19
- 自我介绍时，立即全面抛出技术栈和亮点 20
- 先介绍项目背景，打消面试官疑问 21
- 通过说项目管理工具，说明你不仅会写代码 22
- 用 SPRING BOOT 项目举例，说明你的技术基本面 23
- 用实例说明你在内存调优方面的经验 24
- 展示你在数据库调优方面的经验 25
- 总结前文说辞 26
- 准备项目说辞时，更可以准备后继面试官的问题 27
JAVA 进阶训练营 28
2021 【美团】面试真题： 32
1、SPRING AOP 底层原理 32
2、HASHMAP 的底层数据结构是怎样的？ 32
3、HASHMAP 的扩容机制是怎样的？ 33
4、CONCURRENTHASHMAP 的存储结构是怎样的？ 33
5、线程池大小如何设置？ 34
6、IO 密集=NCPU*2 是怎么计算出来？ 34
7、G1 收集器有哪些特点？ 34
8、你有哪些手段来排查 OOM 的问题？ 35
9、请你谈谈MYSQL 事务隔离级别，MYSQL 的默认隔离级别是什么？ 35
10、可重复读解决了哪些问题？ 35
11、对 SQL 慢查询会考虑哪些优化？ 36
12、谈一谈缓存穿透、缓存击穿和缓存雪崩，以及解决办法？ 36
13、LRU 是什么？如何实现？ 37
14、什么是堆内存？参数如何设置？ 37
15、栈和队列，举个使用场景例子？ 38
16、MYSQL 为什么INNODB 是默认引擎？ 38
17、MYSQL 索引底层结构为什么使用 B+树？ 38
18、B+ 树的叶子节点链表是单向还是双向？ 39
19、MVCC 是什么？它的底层原理是什么？ 39
20、UNDO LOG 具体怎么回滚事务 ？ 39
21、如何查询慢 SQL 产生的原因 39
22、索引失效的情况有哪些？ 39
23、一个 REDIS 实例最多能存放多少的KEYS？LIST、SET、SORTED SET 他们最多能存放多少元素？ 40
24、REDIS 数据结构压缩列表和跳跃表的区别 40
25、为什么数据量小的时候用压缩列表 ? 40
26、REDIS 主从同步是怎么实现的？ 40
27、REDIS 持久化RDB 和AOF 优缺点 41
28、谈谈自己对于 SPRING AOP 的了解？ 42
29、 SPRING BEAN 容器的生命周期是什么样的？ 42
30、RABBITMQ 如何保证消息不丢失？ 43
2021 【阿里】面试真题： 43
1、TCP 和UDP 区别？ 43
2、TCP/IP 协议涉及哪几层架构？ 43
3、描述下TCP 连接 4 次挥手的过程？为什么要 4 次挥手？ 43
4、计算机插上电源操作系统做了什么？ 44
5、LINUX 操作系统设备文件有哪些？ 44
6、多线程同步有哪些方法？ 44
7、一个对象的两个方法加 SYNCHRONIZED，一个线程进去SLEEP，另一个线程可以进入到另一个方法吗？ 44
8、什么是可重入锁（REENTRANTLOCK）？ 44
9、创建线程的三个方法是什么？ 45
10、JAVA 怎么获取多线程的返回值？ 45
11、线程池有哪几种创建方式？ 45
12、线程池参数有哪些？ 46
13、线程池拒绝策略有哪些？ 46
14、你认为对线程池的核心参数实现自定义可配置，三个核心参数是？ 46
15、THREADPOOLEXECUTOR 线程池，COREPOOLSIZE=5， MAXIMUMPOOLSIZE=10，QUEUECAPACITY=10，有 20 个耗时任务交给这个线程池执行，线程池会如何执行这 20 个任务？ 46
16、给用户发消息任务超出队列，你用哪个拒绝策略？有其他方法吗 ？ 47
17、JAVA8 新特性有哪些了解? 47
18、什么时候用多线程、为什么要设计多线程？ 47
19、多线程越多效率越高吗？ 48
20、多线程会产生哪些并发问题 ? 48
21、MYBATIS 如何将对象转换成SQL？ 48
22、虚拟内存是什么，虚拟内存的原理是什么？ 48
23、栈会溢出吗？什么时候溢出？方法区会溢出吗？ 49
24、JVM 如何加载类的？ 49
25、自己写过 STRING 类能加载吗，之前的STRING 是什么时候加载进去的？ 50
26、描述 THREADLOCAL（线程本地变量）的底层实现原理及常用场景？ 50
27、什么是微服务架构？ 51
28、微服务有哪些特点？ 51
29、LAMBDA 表达式是啥？优缺点？ 51
30、讲一下 LAMBDA 的表达式作用域（LAMBDA SCOPES）。 52
31、MYSQL 事务的特性有什么，说一下分别是什么意思？ 52
2021 【京东】面试真题： 52
1、哪些情况下的对象会被垃圾回收机制处理掉？ 52
2、讲一下常见编码方式？ 53
3、UTF-8 编码中的中文占几个字节；INT 型几个字节？ 53
4、静态代理和动态代理的区别，什么场景使用？ 53
5、简述下JAVA 的异常体系。 54
6、谈谈你对解析与分派的认识。 54
7、修改对象A 的EQUALS 方法的签名，那么使用HASHMAP 存放这个对象实例的时候，会用哪个EQUALS 方法？
…54
8、JAVA 中实现多态的机制是什么？ 55
9、如何将一个JAVA 对象序列化到文件里？ 55
10、说说你对 JAVA 反射的理解。 55
11、说说你对 JAVA 注解的理解。 56
12、说一下泛型原理，并举例说明。 57
13、谈谈你对 JAVA 中STRING 的了解。 57
14、STRING 为什么要设计成不可变的？ 58
15、REDIS 常见的几种数据结构说一下？各自的使用场景？ 58
16、谈一谈缓存穿透、缓存击穿和缓存雪崩，以及各自的解决方案？ 59
17、讲下 KAFKA、RABBITMQ、ROCKETMQ 之间的区别是什么？ 60
18、KAFKA 的架构说一下？ 60
19、KAFKA 怎么保证消息是有序的？ 61
20、KAFKA 怎么保证消息不丢失？ 61
21、KAFKA 怎么解决重复消费？ 62
22、介绍下 MYSQL 聚簇索引与非聚簇索引的区别（INNODB 与MYISAM 引擎）？ 62
23、然后给一个联合索引(A,B)和一个语句,SELECT * FROM TABLE WHERE B = ‘XXX’，判断是否能命中索引？为什么？
…62
24、JAVA 多线程有哪几种实现方式？ 63
25、用过 CONCURRENTHASHMAP，讲一下他和 HASHTABLE 的不同之处？ 63
26、JAVA 怎么实现线程安全？ 63
27、描述 THREADLOCAL（线程本地变量）的底层实现原理及常用场景。 63
28、介绍下 SPRING BEAN 都有哪些作用域？ 64
29、注解 @AUTOWIRED 和@RESOURCE 有什么区别？ 64
30、RPC 的实现基础？ 65
31、CMS，G1 垃圾回收器中的三色标记了解吗？ 65
2021 【腾讯】面试真题： 66
1、KAFKA 是什么？主要应用场景有哪些？ 66
2、KAFKA 为什么有TOPIC 还要用PATITION? 67
3、客户端和服务器之间最多能建立多少个连接？ 67
4、HASHMAP 结构，线程不安全举个例子？ 67
5、MYSQL 索引分类? 67
6、了解线程& 进程的区别吗？ 68
7、JAVA 进程间的几种通信方式？ 68
8、多台服务器同时对一个数据定时任务，怎么处理？ 69
9、常见分布式锁的几种实现方式？ 69
10、REDIS 分布式锁实现原理？ 69
11、REDIS 的数据类型及它们的使用场景？ 70
12、信号量与信号的区别? 70
13、SELECT 和EPOLL 的底层结构是什么原理 70
14、场景题：1 亿个数据取出最大前 100 个有什么方法？ 71
15、KAFKA 如何保证消息可靠? 72
16、消息队列的使用场景? 72
17、乐观锁和悲观锁的理解及如何实现，有哪些实现方式？ 73
18、ARRAYLIST 和LINKEDLIST 的区别在哪里？ 73
19、谈谈你对 SQL 注入式攻击的理解？ 74
20、数据库事务的特性？ 74
21、REDIS 如何做内存优化？ 74
22、缓存穿透，缓存击穿，缓存雪崩都是咋回事？解决办法？ 75
23、数组和链表的区别？当数组内存过大时会出现什么问题？链表增删过多会出现的什么问题？ 76
24、常见排序算法和分别的复杂度？ 76
25、JDK 1.8 的JVM 内存划分模型，堆和栈的区别 76
26、简单描述 MYSQL 中，索引，主键，唯一索引，联合索引的区别，对数据库的性能有什么影响（从读写两方面）？ 77
27、I/O 模型有哪几种？ 77
28、当你用浏览器打开一个链接的时候，计算机做了哪些工作步骤？ 77
29、虚拟 DOM 的优劣如何? 77
30、幻读是什么，用什么隔离级别可以防止幻读？ 78
2021 【百度】面试真题： 78
1、SPINGBOOT 也有定时任务？是什么注解？ 78
2、请描述线程的生命周期，它们之间如何切换？ 78
3、什么情况线程会进入WAITING 状态？ 79
4、简述多进程开发中JOIN 和DEAMON 的区别？ 79
5、异步和同步、阻塞和非阻塞之间的区别？ 79
6、为什么要分内核态和用户态? 80
7、说下类加载器与类加载？加载的类信息放在哪个区域？ 80
8、UDP 协议和TCP 协议的区别？ 80
9、LIMIT 1000000 加载很慢的话，你是怎么解决的呢？ 81
10、MYSQL 的索引分类是什么？ 81
11、什么是散列表？ SELECT * 和 SELECT 1？ 82
12、MYSQL 的主从复制了解吗？ 82
13、SPRING 框架事务注解用什么注解？使用该注解的失效场景？ 82
14、FINAL、FINALLY、FINALLIZE？FINALLY 是在RETURN 之前执行还是之后？FINALLY 块里的代码一定会执行吗？ 82
15、I/O 多路复用实现方式有哪些？ 83
16、SELECT、POLL、EPOLL 区别有哪些？ 83
17、哈希算法解决哈希冲突方式有哪些？ 83
18、如何保证 REDIS 中的数据不丢失？ 83
19、如何保证 REDIS 中的数据都是热点数据？ 84
20、REDIS 持久化机制是如何做的？ 84
21、REDIS 为什么在使用RDB 进行快照时会通过子进程的方式进行实现? 85
22、介绍下 MYSQL 的主从复制原理？产生主从延迟的原因？ 86
23、父进程如果宕掉，子进程会怎样？ 86
24、孤儿进程和僵尸进程有什么区别？ 86
25、MYSQL 中有哪几种锁？ 86
26、互斥锁（MUTEX）和自旋锁（SPINLOCK）分别在什么场景使用？ 87
27、描述 SYNCHRONIZED、REENTRANTLOCK 的区别？ 87
28、HASHMAP 扩容操作是怎么实现的？ 87
29、CONCURRENTHASHMAP 1.7 与 1.8 区别？ 87
30、如何使用 JAVA 的反射？ 87
2021 【华为】面试真题： 88
1、JAVA 常用集合及特点？ 88
2、开启一个线程的方法？ 89
3、JAVA 面向对象包括哪些特性，怎么理解的？ 89
4、JAVA 如何保证线程安全？ 90
5、介绍SPRING MVC 的工作流程？ 90
6、SPRING 框架中用到了哪些设计模式？ 90
7、REDIS 的特点是什么？ 91
8、为什么使用REDIS，有什么好处？ 91
9、REDIS 雪崩和击穿了解吗？ 91
10、什么是面向对象，谈谈你的理解？ 92
11、访问数据库除了 JDBC 还有什么？ 92
12、你知道有哪些设计原则？ 92
13、在生产环境 LINUX 服务器上，发现某台运行 JAVA 服务的服务器的 CPU100，不借助任何可视化工具，怎么进行问题的定位？ 92
14、JDK 里面带的工具你知道哪些？ 93
15、基本数据类型 BIT 长度？ 93
16、CHAR 能不能存中文？ 93
17、谈谈你对泛型的理解？ 93
18、JAVA 程序是怎样运行的？ 94
19、GC ROOT 有哪些? 94
20、栈帧的大小什么时候确定？ 94
21、静态 FILED 声明和构造器哪个先执行？ 95
22、线程创建方式是什么？ 95
23、传统 I/O 跟NIO 的区别？ 95
24、消息队列的在各种场景下如何选型？ 95
25、JAVA 的安全性体现在哪里？ 97
26、STATIC 方法怎么访问非STATIC 变量？ 97
27、讲下你理解的 JAVA 多继承? 98
28、JAVA 基本类型有哪些？ 98
29、线程池如果满了会怎么样？ 98
30、什么是双亲委派机制，它有什么作用？ 98
JAVA I/O 99
1、I/O 流的分类 99
2、字节流如何转为字符流？ 99
3、字节流和字符流，你更喜欢使用哪一个？ 99
4、SYSTEM.OUT.PRINTLN 是什么？ 100
5、什么是FILTER 流？ 100
5、有哪些可用的FILTER 流？ 100
6、有哪些FILTER 流的子类？ 100
7、NIO 和I/O 的主要区别 100
8、BIO、NIO、AIO 有什么区别？ 101
9、NIO 有哪些核心组件？ 102
10、SELECT、POLL 和EPOLL 什么区别 102
11、什么是 JAVA 序列化，如何实现JAVA 序列化？ 103
12、如何实现对象克隆？ 103
13、什么是缓冲区？有什么作用？ 103
14、什么是阻塞 IO？什么是非阻塞 IO？ 103
15、请说一下 PRINTSTREAM BUFFEREDWRITER PRINTWRITER 有什么不同？ 104
KAFKA 104
1、KAFKA 是什么？主要应用场景有哪些？ 104
2、和其他消息队列相比,KAFKA 的优势在哪里？ 105
3、什么是 PRODUCER、CONSUMER、BROKER、TOPIC、PARTITION？ 105
4、KAFKA 的多副本机制了解吗？ 105
5、KAFKA 的多分区（PARTITION）以及多副本（REPLICA）机制有什么好处呢？ 106
6、ZOOKEEPER 在KAFKA 中的作用知道吗？ 106
7、KAFKA 如何保证消息的消费顺序？ 106
8、KAFKA 如何保证消息不丢失？ 107
9、KAFKA 判断一个节点是否还活着有那两个条件？ 108
10、PRODUCER 是否直接将数据发送到BROKER 的LEADER(主节点)？ 108
11、KAFA CONSUMER 是否可以消费指定分区消息吗？ 108
12、KAFKA 高效文件存储设计特点是什么？ 108
13、PARTITION 的数据如何保存到硬盘？ 108
14、KAFAKA 生产数据时数据的分组策略是怎样的？ 109
15、CONSUMER 是推还是拉？ 109
16、KAFKA 维护消费状态跟踪的方法有什么？ 109
MYSQL 109
1、据库三大范式是什么 109
2、MYSQL 有关权限的表都有哪几个？ 109
3、MYSQL 的BINLOG 有有几种录入格式？分别有什么区别？ 110
4、MYSQL 存储引擎MYISAM 与INNODB 区别 110
5、MYISAM 索引与INNODB 索引的区别？ 110
6、什么是索引？ 111
7、索引有哪些优缺点？ 111
索引的优点 111
索引的缺点 111
8、索引有哪几种类型？ 111
9、MYSQL 中有哪几种锁？ 112
10、MYSQL 中INNODB 支持的四种事务隔离级别名称，以及逐级之间的区别？ 112
11、CHAR 和VARCHAR 的区别？ 112
12、主键和候选键有什么区别？ 112
13、如何在 UNIX 和MYSQL 时间戳之间进行转换？ 112
14、MYISAM 表类型将在哪里存储，并且还提供其存储格式？ 113
15、MYSQL 里记录货币用什么字段类型好 113
16、创建索引时需要注意什么？ 113
17、使用索引查询一定能提高查询的性能吗？为什么 113
18、百万级别或以上的数据如何删除 114
19、什么是最左前缀原则？什么是最左匹配原则 114
20、什么是聚簇索引？何时使用聚簇索引与非聚簇索引 114
21、MYSQL 连接器 114
22、MYSQL 查询缓存 115
23、MYSQL 分析器 115
24、MYSQL 优化器 115
25、MYSQL 执行器 115
26、什么是临时表，何时删除临时表？ 116
28、什么叫外链接？ 117
29、什么叫内链接？ 117
30、使用 UNION 和UNION ALL 时需要注意些什么？ 117
31、MYISAM 存储引擎的特点 117
32、INNODB 存储引擎的特点 118
NETTY 118
1、为什么要用NETTY 呢？ 118
2、NETTY 有哪些应用场景？ 119
3、NETTY 的优势有哪些？ 119
3、NETTY 核心组件有哪些？分别有什么作用？ 119
5、EVENTLOOPGROUP 了解么?和EVENTLOOP 啥关系? 120
6、请说下对BOOTSTRAP 和SERVERBOOTSTRAP 的了解？ 121
7、请说下NETTY 线程模型？ 121
8、NETTY 服务端和客户端的启动过程是怎样的？ 121
9、什么是TCP 粘包/拆包? 122
10、如何在 NETTY 中解决TCP 粘包问题？ 122
11、TCP 长连接和短连接了解么？ 123
12、为什么需要心跳机制？NETTY 中心跳机制了解么？ 123
13、讲讲 NETTY 的零拷贝 124
14、NETTY 和TOMCAT 的区别？ 124
15、NETTY 发送消息有几种方式？ 124
分布式 125
1、分布式服务接口的幂等性如何设计？ 125
2、分布式系统中的接口调用如何保证顺序性？ 125
3、说说ZOOKEEPER 一般都有哪些使用场景？ 125
4、说说你们的分布式SESSION 方案是啥？怎么做的？ 126
5、分布式事务了解吗？ 126
6、那常见的分布式锁有哪些解决方案？ 127
7、ZK 和REDIS 的区别，各自有什么优缺点？ 127
8、MYSQL 如何做分布式锁？ 127
9、你了解业界哪些大公司的分布式锁框架 128
10、请讲一下你对 CAP 理论的理解 128
11、请讲一下你对 BASE 理论的理解 129
12、分布式与集群的区别是什么？ 129
13、请讲一下 BASE 理论的三要素 130
14、请说一下对两阶段提交协议的理解 130
15、请讲一下对 TCC 协议的理解 131
微服务 131
1、你对微服务是怎么理解的？ 131
2、说说微服务架构的优势。 131
3、微服务有哪些特点？ 132
4、单体应用、SOA 和微服务架构有什么区别？ 132
5、在使用微服务架构时，你面临的挑战是什么？ 132
6、什么是SPRING BOOT？ 133
7、SPRING BOOT 有哪些优点？ 133
8、什么是JavaConfig？ 133
9、什么是SPRING CLOUD？ 134
10、使用 SPRING BOOT 开发分布式微服务时，我们需要关注哪些问题？ 134
11、服务注册和发现是什么意思？SPRING CLOUD 如何实现？ 134
12、负载平衡的意义什么？ 134
13、什么是 HYSTRIX？ 135
14、什么是 NETFLIX FEIGN？它的优点是什么？ 135
15、SPRING CLOUD 断路器的作用 135
消息队列 135
1、为什么使用消息队列？ 135
2、消息队列有什么优点和缺点？ 135
3、KAFKA、ACTIVEMQ、RABBITMQ、ROCKETMQ 都有什么区别，以及适合哪些场景？ 136
4、如何保证消息不被重复消费？ 136
5、如何保证消息消费的幂等性？ 137
6、如何保证消息的可靠性传输？（如何处理消息丢失的问题） 137
7、如果让你写一个消息队列，该如何进行架构设计啊？说一下你的思路。 139
8、如何解决消息队列的延时以及过期失效问题？ 139
9、消息队列满了以后该怎么处理？ 140
10、消息如何分发？ 140
11、消息怎么路由？ 140
12、消息基于什么传输？ 141
13、为什么不应该对所有的 MESSAGE 都使用持久化机制？ 141
14、如何保证高可用的？RABBITMQ 的集群 141
15、RABBITMQ 的工作模式 142
16、为什么需要消息系统，MYSQL 不能满足需求吗？ 142
DUBBO 143
1、说说核心的配置有哪些？ 143
2、DUBBO 支持哪些协议，每种协议的应用场景，优缺点？ 144
3、服务提供者能实现失效踢出是什么原理？ 145
4、RPC 架构有哪些组件？ 145
5、DUBBO 服务调用是阻塞的吗？ 145
6、DUBBO 核心功能有哪些？ 145
7、DUBBO 服务器注册与发现的流程？ 146
8、DUBBO MONITOR 实现原理？ 146
9、DUBBO 和SPRING CLOUD 有什么关系？ 147
10、DUBBO 和SPRING CLOUD 有什么哪些区别？ 147
11、DUBBO 有哪些注册中心？ 147
12、DUBBO 的注册中心集群挂掉，发布者和订阅者之间还能通信么？ 147
13、DUBBO 集群提供了哪些负载均衡策略？ 147
14、DUBBO 的集群容错方案有哪些？ 148
15、DUBBO 超时设置有哪些方式？ 148
JAVA 集合 148
1、说说LIST, SET, QUEUE, MAP 四者的区别？ 148
2、如何选用集合? 149
3、为什么要使用集合？ 149
4、 ARRAYLIST 和VECTOR 的区别? 149
5、ARRAYLIST 与LINKEDLIST 区别? 149
6、COMPARABLE 和COMPARATOR 的区别？ 150
7、无序性和不可重复性的含义是什么 150
8、比较HASHSET、LINKEDHASHSET 和TREESET 三者的异同 150
9、试比较QUEUE 与DEQUE 的区别 151
10、请谈一下对 PRIORITYQUEUE 的认识？ 151
11、HASHMAP 和HASHTABLE 的区别？ 151
12、HASHSET 如何检查重复？ 152
13、HASHMAP 的长度为什么是 2 的幂次方？ 152
这个算法应该如何设计呢？ 153
14、CONCURRENTHASHMAP 和HASHTABLE 的区别？ 153
15、CONCURRENTHASHMAP 线程安全的具体实现方式是怎样的？ 153
16、TREEMAP 和TREESET 在排序时如何比较元素？COLLECTIONS 工具类中的SORT()方法如何比较元素？ 154
17、COLLECTION 和COLLECTIONS 有什么区别？ 154
18、ARRAY 和ARRAYLIST 有何区别？ 155
19、HASHMAP 和CONCURRENTHASHMAP 的区别 155
20、如果使用 OBJECT 作为HASHMAP 的KEY，应该怎么办呢？ 155
21、为什么 HASHMAP 中STRING、INTEGER 这样的包装类适合作为 K？ 155
22、什么是哈希冲突？ 156
23、你知道 FAIL-FAST 和FAIL-SAFE 吗？ 156
24、ARRAYS.ASLIST 获得的 LIST 应该注意什么？ 156
25、FINAL、FINALLY 和FINALIZE()的区别 157
26、内部类有哪些分类，分别解释一下 157
27、项目为 UTF-8 环境，CHARC=中，是否合法 157
28、动态代理是基于什么原理 158
29、EXCEPTION 和ERROR 有什么区别 158
30、反射的基本原理，反射创建类实例的三和方式是什么 158
ZOOKEEPER 158
1、ZOOKEEPER 是什么？ 158
2、ZOOKEEPER 提供了什么？ 159
3、ZOOKEEPER 文件系统 159
4、ZAB 协议？ 159
5、四种类型的数据节点ZNODE 160
6、ZOOKEEPER WATCHER 机制 – 数据变更通知 160
7、客户端注册WATCHER 实现 161
8、服务端处理WATCHER 实现 161
9、客户端回调WATCHER 162
10、ACL 权限控制机制 162
12、会话管理 163
13、服务器角色 163
14、ZOOKEEPER 下SERVER 工作状态 164
15、数据同步 164
16、ZOOKEEPER 是如何保证事务的顺序一致性的？ 165
17、分布式集群中为什么会有 MASTER？ 165
18、ZK 节点宕机如何处理？ 165
19、ZOOKEEPER 负载均衡和NGINX 负载均衡区别 166 - ZOOKEEPER 有哪几种几种部署模式？ 166
- 集群最少要几台机器，集群规则是怎样的? 166
- 集群支持动态添加机器吗？ 166
- ZOOKEEPER 对节点的WATCH 监听通知是永久的吗？为什么不是永久的? 167
- ZOOKEEPER 的JAVA 客户端都有哪些？ 167
- CHUBBY 是什么，和ZOOKEEPER 比你怎么看？ 167
- 说几个ZOOKEEPER 常用的命令。 167
- ZAB 和PAXOS 算法的联系与区别？ 167
- ZOOKEEPER 的典型应用场景 168
JAVA 并发编程 171
1、在JAVA 中守护线程和本地线程区别？ 171
2、线程与进程的区别？ 171
3、什么是多线程中的上下文切换？ 171
4、死锁与活锁的区别，死锁与饥饿的区别？ 172
5、什么是线程组，为什么在JAVA 中不推荐使用？ 172
6、为什么使用EXECUTOR 框架？ 173
7、在JAVA 中EXECUTOR 和EXECUTORS 的区别？ 173
8、什么是原子操作？在JAVA CONCURRENCY API 中有哪些原子类(ATOMIC CLASSES)？ 173
9、JAVA CONCURRENCY API 中的LOCK 接口(LOCK INTERFACE)是什么？对比同步它有什么优势？ 174
10、什么是 EXECUTORS 框架？ 175
11、什么是阻塞队列？阻塞队列的实现原理是什么？如何使用阻塞队列来实现生产者-消费者模型？ 175
12、什么是 CALLABLE 和FUTURE? 176
13、什么是 FUTURETASK?使用EXECUTORSERVICE 启动任务。 176
14、什么是并发容器的实现？ 176
15、多线程同步和互斥有几种实现方法，都是什么？ 177
16、什么是竞争条件？你怎样发现和解决竞争？ 177
17、你将如何使用 THREAD DUMP？你将如何分析 THREAD DUMP？ 177
18、为什么我们调用 START()方法时会执行RUN() 方法，为什么我们不能直接调用RUN()方法？ 178
19、JAVA 中你怎样唤醒一个阻塞的线程？ 178
20、在 JAVA 中CYCLIBARRIAR 和COUNTDOWNLATCH 有什么区别？ 179
21、什么是不可变对象，它对写并发应用有什么帮助？ 179
22、什么是多线程中的上下文切换？ 180
23、JAVA 中用到的线程调度算法是什么？ 180
24、什么是线程组，为什么在 JAVA 中不推荐使用？ 181
25、为什么使用 EXECUTOR 框架比使用应用创建和管理线程好？ 181
26、JAVA 中有几种方法可以实现一个线程？ 181
27、如何停止一个正在运行的线程？ 181
28、NOTIFY()和 NOTIFYALL()有什么区别？ 182
29、什么是 DAEMON 线程？它有什么意义？ 182
30、JAVA 如何实现多线程之间的通讯和协作？ 182
31、什么是可重入锁（REENTRANTLOCK）？ 182
32、当一个线程进入某个对象的一个 SYNCHRONIZED 的实例方法后，其它线程是否可进入此对象的其它方法？
…183 33、乐观锁和悲观锁的理解及如何实现，有哪些实现方式？…183
34、SYNCHRONIZEDMAP 和CONCURRENTHASHMAP 有什么区别？ 184
35、COPYONWRITEARRAYLIST 可以用于什么应用场景？ 185
36、什么叫线程安全？SERVLET 是线程安全吗? 185
37、VOLATILE 有什么用？能否用一句话说明下 VOLATILE 的应用场景？ 185
38、为什么代码会重排序？ 186
39、在 JAVA 中WAIT 和SLEEP 方法的不同？ 186
40、一个线程运行时发生异常会怎样？ 186
41、如何在两个线程间共享数据？ 186
42、JAVA 中NOTIFY 和NOTIFYALL 有什么区别？ 186
43、为什么 WAIT, NOTIFY 和NOTIFYALL 这些方法不在THREAD 类里面？ 186
44、什么是 THREADLOCAL 变量？ 187
45、JAVA 中INTERRUPTED 和ISINTERRUPTED 方法的区别？ 187
46、为什么 WAIT 和NOTIFY 方法要在同步块中调用？ 187
47、为什么你应该在循环中检查等待条件? 188
48、JAVA 中的同步集合与并发集合有什么区别？ 188
49、什么是线程池？ 为什么要使用它？ 188
50、怎么检测一个线程是否拥有锁？ 188
51、你如何在 JAVA 中获取线程堆栈？ 188
52、JVM 中哪个参数是用来控制线程的栈堆栈小的? 189
53、THREAD 类中的YIELD 方法有什么作用？ 189
54、JAVA 中CONCURRENTHASHMAP 的并发度是什么？ 189
55、JAVA 中SEMAPHORE 是什么？ 189
56、JAVA 线程池中SUBMIT() 和EXECUTE()方法有什么区别？ 190
57、什么是阻塞式方法？ 190
58、JAVA 中的READWRITELOCK 是什么？ 190
59、VOLATILE 变量和ATOMIC 变量有什么不同？ 190
60、可以直接调用 THREAD 类的RUN ()方法么？ 190
61、如何让正在运行的线程暂停一段时间？ 191
62、你对线程优先级的理解是什么？ 191
63、什么是线程调度器(THREAD SCHEDULER)和时间分片(TIME SLICING )？ 191
64、你如何确保 MAIN()方法所在的线程是JAVA 程序最后结束的线程？ 191
65、线程之间是如何通信的？ 192
66、为什么线程通信的方法 WAIT(), NOTIFY()和 NOTIFYALL()被定义在 OBJECT 类里？ 192
67、为什么 WAIT(), NOTIFY()和NOTIFYALL ()必须在同步方法或者同步块中被调用？ 192
68、为什么 THREAD 类的SLEEP()和YIELD ()方法是静态的？ 192
69、如何确保线程安全？ 193
70、同步方法和同步块，哪个是更好的选择？ 193
71、如何创建守护线程？ 193
72、什么是 JAVA TIMER 类？如何创建一个有特定时间间隔的任务？ 193
MYBATIS 194
1、什么是MYBATIS？ 194
2、MYBAITS 的优点： 194
3、MYBATIS 框架的缺点： 194
4、MYBATIS 框架适用场合： 194
5、MYBATIS 与HIBERNATE 有哪些不同？ 195
6、#{}和${}的区别是什么？ 195
7、当实体类中的属性名和表中的字段名不一样，怎么办？ 195
8、 模糊查询LIKE 语句该怎么写? 196
9、通常一个XML 映射文件，都会写一个DAO 接口与之对应，请问， 这个DAO 接口的工作原理是什么？DAO 接口里的方法，参数不同时， 方法能重载吗？ 196
10、MYBATIS 是如何进行分页的？分页插件的原理是什么？ 197
11、MYBATIS 是如何将SQL 执行结果封装为目标对象并返回的？都有哪些映射形式？ 197
12、如何执行批量插入? 197
13、如何获取自动生成的(主)键值? 198
14、在 MAPPER 中如何传递多个参数? 199
15、MYBATIS 动态SQL 有什么用？执行原理？有哪些动态SQL？ 200
16、XML 映射文件中，除了常见的SELECT|INSERT|UPDAE|DELETE 标签之外，还有哪些标签？ 200
17、MYBATIS 的XML 映射文件中，不同的XML 映射文件，ID 是否可以重复？ 200
18、为什么说 MYBATIS 是半自动ORM 映射工具？它与全自动的区别在哪里？ 201
19、 一对一、一对多的关联查询？ 201
20、MYBATIS 实现一对一有几种方式?具体怎么操作的？ 202
21、MYBATIS 实现一对多有几种方式,怎么操作的？ 202
22、MYBATIS 是否支持延迟加载？如果支持，它的实现原理是什么？ 202
23、MYBATIS 的一级、二级缓存 203
24、什么是 MYBATIS 的接口绑定？有哪些实现方式？ 203
25、使用 MYBATIS 的MAPPER 接口调用时有哪些要求？ 203
26、MAPPER 编写有哪几种方式？ 203
27、简述 MYBATIS 的插件运行原理，以及如何编写一个插件。 205
REDIS 205
1、什么是REDIS? 205
2、REDIS 的数据类型？ 206
3、使用REDIS 有哪些好处？ 206
4、REDIS 相比MEMCACHED 有哪些优势？ 207
5、MEMCACHE 与REDIS 的区别都有哪些？ 207
6、REDIS 是单进程单线程的？ 207
8、REDIS 的持久化机制是什么？各自的优缺点？ 207
9、REDIS 常见性能问题和解决方案： 208
10、REDIS 过期键的删除策略？ 209
11、REDIS 的回收策略（淘汰策略）? 209
12、为什么 REDIS 需要把所有数据放到内存中？ 210
13、REDIS 的同步机制了解么？ 210
14、PIPELINE 有什么好处，为什么要用 PIPELINE？ 210
15、是否使用过 REDIS 集群，集群的原理是什么？ 210
16、REDIS 集群方案什么情况下会导致整个集群不可用？ 210
17、REDIS 支持的JAVA 客户端都有哪些？官方推荐用哪个？ 210
18、JEDIS 与REDISSON 对比有什么优缺点？ 211
19、REDIS 如何设置密码及验证密码？ 211
20、说说 REDIS 哈希槽的概念？ 211
21、REDIS 集群的主从复制模型是怎样的？ 211
22、REDIS 集群会有写操作丢失吗？为什么？ 211
23、REDIS 集群之间是如何复制的？ 211
24、REDIS 集群最大节点个数是多少？ 212
25、REDIS 集群如何选择数据库？ 212
26、怎么测试 REDIS 的连通性 212
27、怎么理解 REDIS 事务？ 212
28、REDIS 事务相关的命令有哪几个？ 212
29、REDIS KEY 的过期时间和永久有效分别怎么设置？ 212
30、REDIS 如何做内存优化？ 212
31、REDIS 回收进程如何工作的？ 212
32、都有哪些办法可以降低 REDIS 的内存使用情况呢？ 213
33、REDIS 的内存用完了会发生什么？ 213
34、一个 REDIS 实例最多能存放多少的KEYS？ LIST、SET、SORTED SET 他们最多能存放多少元素？ 213
35、MYSQL 里有 2000W 数据，REDIS 中只存 20W 的数据，如何保证REDIS 中的数据都是热点数据？REDIS 内存数据集大小上升到一定大小的时候，就会施行数据淘汰策略。 相关知识：REDIS 提供 6 种数据淘汰策略： 214
36、REDIS 最适合的场景？ 214
37、假如 REDIS 里面有 1 亿个KEY，其中有 10W 个KEY 是以某个固定的已知的前缀开头的，如果将它们全部找出来？ 215
38、如果有大量的 KEY 需要设置同一时间过期，一般需要注意什么？ 215
39、使用过 REDIS 做异步队列么，你是怎么用的？ 216
40、使用过 REDIS 分布式锁么，它是什么回事 216
SPRING 217
1、不同版本的SPRING FRAMEWORK 有哪些主要功能？ 217
2、什么是SPRING FRAMEWORK？ 217
3、列举SPRING FRAMEWORK 的优点。 217
4、SPRING FRAMEWORK 有哪些不同的功能？ 217
5、SPRING FRAMEWORK 中有多少个模块，它们分别是什么？ 218
6、什么是SPRING 配置文件？ 219
7、SPRING 应用程序有哪些不同组件？ 219
8、使用SPRING 有哪些方式？ 219
9、什么是SPRING IOC 容器？ 219
10、什么是依赖注入？ 220
11、可以通过多少种方式完成依赖注入？ 220
12、区分构造函数注入和 SETTER 注入 220
13、SPRING 中有多少种IOC 容器？ 221
14、区分 BEANFACTORY 和APPLICATIONCONTEXT。 221
15、列举 IOC 的一些好处。 221
16、SPRING IOC 的实现机制。 221
17、什么是 SPRING BEAN？ 222
18、SPRING 提供了哪些配置方式？ 223
19、SPRING 支持集中BEAN SCOPE？ 223
20、SPRING BEAN 容器的生命周期是什么样的 224
21、什么是 SPRING 的内部BEAN？ 224
22、什么是 SPRING 装配 225
23、自动装配有哪些方式？ 225
24、自动装配有什么局限？ 226
25、什么是基于注解的容器配置 226
26、如何在 SPRING 中启动注解装配？ 226
27、@COMPONENT, @CONTROLLER, @REPOSITORY,@SERVICE 有何区别 227
28、@REQUIRED 注解有什么用？ 227
29、@AUTOWIRED 注解有什么用？ 228
30、@QUALIFIER 注解有什么用？ 228
31、@REQUESTMAPPING 注解有什么用？ 229
32、SPRING DAO 有什么用？ 229
33、列举 SPRING DAO 抛出的异常。 229
34、SPRING JDBC API 中存在哪些类？ 230
35、使用 SPRING 访问HIBERNATE 的方法有哪些？ 230
36、列举 SPRING 支持的事务管理类型 230
37、SPRING 支持哪些ORM 框架 230
38、什么是 AOP？ 231
39、什么是 ASPECT？ 231
40、什么是切点（JOINPOINT） 232
41、什么是通知（ADVICE）？ 232
43、指出在 SPRING AOP 中CONCERN 和CROSS-CUTTINGCONCERN 的不同之处。 232
45、SPRING AOP AND ASPECTJ AOP 有什么区别？ 233
46、如何理解 SPRING 中的代理？ 233
47、什么是编织（WEAVING）？ 233
48、SPRING MVC 框架有什么用？ 233
49、描述一下 DISPATCHERSERVLET 的工作流程 234
50、介绍一下 WEBAPPLICATIONCONTEXT 235
51、什么是 SPRING? 235
52、使用 SPRING 框架的好处是什么？ 235
53、SPRING 由哪些模块组成? 236
54、核心容器（应用上下文) 模块。 236
55、BEANFACTORY – BEANFACTORY 实现举例。 236
66、XMLBEANFACTORY 236
67、解释 AOP 模块 236
68、解释 JDBC 抽象和DAO 模块。 236
69、解释对象/关系映射集成模块。 237
70、解释 WEB 模块。 237
72、SPRING 配置文件 237
73、什么是 SPRING IOC 容器 237
74、IOC 的优点是什么？ 237
75、APPLICATIONCONTEXT 通常的实现是什么? 237
76、BEAN 工厂和APPLICATION CONTEXTS 有什么区别？ 238
77、一个 SPRING 的应用看起来象什么？ 238
78、什么是 SPRING 的依赖注入？ 238
79、有哪些不同类型的 IOC（依赖注入）方式？ 238
80、哪种依赖注入方式你建议使用，构造器注入，还是 SETTER 方法注入？ 239
81、什么是 SPRING BEANS? 239
82、一个 SPRING BEAN 定义包含什么？ 239
83、如何给 SPRING 容器提供配置元数据? 239
84、你怎样定义类的作用域? 239
85、解释 SPRING 支持的几种BEAN 的作用域 240
86、SPRING 框架中的单例BEAN 是线程安全的吗? 240
87、解释 SPRING 框架中BEAN 的生命周期。 240
88、哪些是重要的 BEAN 生命周期方法？你能重载它们吗？ 241
89、什么是 SPRING 的内部BEAN？ 241
90、在 SPRING 中如何注入一个JAVA 集合？ 241
91、什么是 BEAN 装配? 241
92、什么是 BEAN 的自动装配？ 241
93、解释不同方式的自动装配 242
94、自动装配有哪些局限性 ? 242
95、你可以在 SPRING 中注入一个NULL 和一个空字符串吗？ 242
96、什么是基于 JAVA 的SPRING 注解配置? 给一些注解的例子 242
97、什么是基于注解的容器配置? 243
98、怎样开启注解装配？ 243
99、@REQUIRED 注解 243
100、@AUTOWIRED 注解 243
101、@QUALIFIER 注解 243
102、在 SPRING 框架中如何更有效地使用JDBC? 244
103、JDBCTEMPLAT 244
104、SPRING 对DAO 的支持 244
105、使用 SPRING 通过什么方式访问HIBERNATE? 244
106、SPRING 支持的ORM 244
108、SPRING 支持的事务管理类型 245
109、SPRING 框架的事务管理有哪些优点？ 245
110、你更倾向用那种事务管理类型？ 245
111、解释 AOP 245
112、ASPECT 切面 245
113、在 SPRING AOP 中，关注点和横切关注的区别是什么？ 246
114、连接点 246
115、通知 246
116、切点 246
117、什么是引入? 246
118、什么是目标对象? 247
119、什么是代理? 247
120、有几种不同类型的自动代理 247
121、什么是织入。什么是织入应用的不同点？ 247
122、解释基于 XML SCHEMA 方式的切面实现。 247
123、解释基于注解的切面实现 247
124、什么是 SPRING 的MVC 框架？ 247
125、DISPATCHERSERVLET 247
126、WEBAPPLICATIONCONTEXT 248
127、什么是 SPRING MVC 框架的控制器？ 248
128、@CONTROLLER 注解 248
129、@REQUESTMAPPING 注解 248
JVM 248 - 什么是 JVM？ 251
1.1 请问 JDK 与 JVM 有什么区别？ 251
1.2 你认识哪些 JVM 厂商? 251
1.3 ORACLEJDK 与 OPENJDK 有什么区别? 252
1.4 开发中使用哪个版本的 JDK？生产环境呢? 为什么这么选？ 252 - 什么是 JAVA 字节码？ 252
2.1 字节码文件中包含哪些内容? 252
2.2 什么是常量? 253
2.3 你怎么理解常量池? 253 - JVM 的运行时数据区有哪些? 253
3.1 什么是堆内存？ 253
3.2 堆内存包括哪些部分？ 255
3.3 什么是非堆内存? 255 - 什么是内存溢出？ 255
4.1 什么是内存泄漏? 255
4.2 两者有什么关系？ 257 - 给定一个具体的类，请分析对象的内存占用 257
5.1 怎么计算出来的? 257
5.2 对象头中包含哪些部分？ 257 - 常用的 JVM 启动参数有哪些? 259
6.1 设置堆内存 XMX 应该考虑哪些因素？ 261
6.2 假设物理内存是 8G，设置多大堆内存比较合适? 261
6.3 设置的值与 JVM 进程所占用的内存有什么关系? 261
6.4 怎样开启 GC 日志？ 261 - JAVA8 默认使用的垃圾收集器是什么? 263
7.1 JAVA11 的默认垃圾收集器是什么? 263
7.2 常见的垃圾收集器有哪些? 263
7.3 什么是串行垃圾收集? 263
7.4 什么是并行垃圾收集? 263
7.5 什么是并发垃圾收集器? 265
7.6 什么是增量式垃圾收集? 265
7.7 什么是年轻代？ 265
7.8 什么是 GC 停顿(GC PAUSE)? 265
7.9 GC 停顿与 STW 停顿有什么区别？ 265 - 如果 CPU 使用率突然飙升，你会怎么排查？ 265
8.1 如果系统响应变慢，你会怎么排查？ 266
8.2 系统性能一般怎么衡量？ 266 - 使用过哪些 JVM 相关的工具？ 266
9.1 查看 JVM 进程号的命令是什么? 266
9.2 怎么查看剩余内存? 266
9.3 查看线程栈的工具是什么？ 266
9.4 用什么工具来获取堆内存转储? 266
9.5 内存 DUMP 时有哪些注意事项? 267
9.6 使用 JMAP 转储堆内存大致的参数怎么处理？ 267
9.7 为什么转储文件以结尾? 267
9.8 内存 DUMP 完成之后，用什么工具来分析? 267
9.9 如果忘记了使用什么参数你一般怎么处理? 267 - 开发性问题：你碰到过哪些 JVM 问题？ 267
大厂面试的基本流程
以下是一些大厂面试的基本流程，大家可以参考下：
字节跳动
阿里
腾讯
网易游戏
面试前需要准备：
-
Java 八股文：了解常考的题型和回答思路；
-
算法：刷 100-200 道题，记住刷题最重要的是要理解其思想，不要死记硬背，碰上原题很难，但大多数的解题思路是相通的。
-
项目：主要准备最近一家公司所负责的业务和项目：
项目的背景，为啥要做这个项目；
系统的演进之路，有哪几个阶段，每个阶段主要做了什么；
项目中的技术选型，在项目中使用一些工具和框架时的调研，为啥选这个；
项目的亮点：就是你在项目中做过最牛逼的事，复杂的需求方案设计、性能优化、线上问题处理、项目重构等等；
-
架构设计：主要是平台化的一些思想、DDD 领域驱动设计思想，随着经验的增加，这块会越来越重要。
-
项目管理：主要是在主导跨团队的项目时，如何高效的协调好各个团队的工作，使用哪些方法来保障项目的按时交付。在项目遇到困难时，作为项目负责人如何应对等等。跟架构设计一样，这块也是随着经验的增加越来越重要。
-
通用问题：几个比较容易被问到的问题是：1）为什么离职；2）在上家公司哪些能力得到了成长；3）平时怎么学习的？
-
问面试官：每次面试最后面试官一般会问有没有什么想问的，如果不知道问什么，可以问下团队当前负责的业务是什么？主要面临的挑战是什么？
面试中可以借鉴的套路:
- 用简历争取到更多的面试机会
注意点 1：阅读职位介绍上的技能要求年限，在简历上的醒目位置标明你有足量的相关技术项目经验。
比如某职位需要有 Spring boot 3 年经验，又如某职位需要有 2 年大数据开发经验，而你恰好有了， 就在简历第一页个人信息介绍下直接写明。
万一假设你缺乏一些，比如要求是有 2 年大数据，而你就只有一年，你就回想下，你在读书阶段，有没有在外面做过兼职，有没有帮老师一起做过项目，有的话别客气，把这部分的技术年限也加上。
注意点 2：再仔细阅读职位介绍上要求的技术，也列在第一页的醒目位置。
比如某职位需要有 jave 核心开发，多线程开发经验，分布式组件开发经验。其实对做开发的人来说， 这些技术多少在项目里也用过，但如果你不写上，甚至你的简历没法过筛选，甚至你没有面试机会。
注意点 3：再多少写些你的亮点，怎么写看下面的范例。
也就是说，在简历第一页，你写好姓名性别年龄和手机邮箱等基本信息后，一般可以用如下概要的形式，向面试官展示你和职位的匹配度，如下是范例。
具有 3 年 Java 开发经验，2 年 Spring Boot 开发经验，2 年数据库开发经验。（这里的年限需要大于等于职位介绍上的要求，如果达不到，很多公司就不给面试机会）
再根据职位介绍上要求的技术，总纲性列出你掌握的技术，以此证明你很匹配
这里你可以尽可能多地列出你掌握的 JD 上的技能，然后，你可以多列些你的亮点。
其实对大多数初级开发而言，应该都具备上述技能，哪怕当下不具备，用个把月绝对也能学会，所以大家完全可以写在简历上。
相反，姑且先不论候选人是培训班出身还是科班出身，但就凭在简历第一页醒目地展示和该职位的匹配度，至少面试官就肯继续往下看项目经验了，这样得到面试的机会，乃至通过面试的机会，就大大增加了。
- 自我介绍时，立即全面抛出技术栈和亮点
在面试的开始阶段，面试官大概率会让候选人自我介绍，这部分别的不用说，就直接根据上文给出的简历上列出的总纲性要点介绍自己，如下给出范例说辞。
先说技能和 JD 的匹配度。
我叫张三，今年 25 岁，18 年从交大大学毕业，计算机系，目前有 3 年 Java 开发经验（这个是 jd 上的要求），有 Oracle,MySQL 的开发经验，有 xx 等技术经验（这些经验也是 jd 上的要求）。
再说自己的亮点。
在项目里，我用过用索引和执行计划等进行数据库调优经验，有 JVM 方面排查 OOM 的经验，大数据方面，用过 Spark 等框架，分布式组件方面，用过 Redis 和 Dubbo 等，有在 linux 上看日志然后排查线上问题的经验。
其实天地良心，上述提到的亮点，除了大数据 spark 以外，其它技能亮点初级开发应该都会，哪怕不会也能轻易学会。但就这样，很多候选人不会说，不过反过来，你说了就比别人强。然后立即引申出最近的项目，因为大多数公司会衡量 jd 技术是否在最近项目里用过。
在最近的项目里，我用到了 Spring Boot 框架，具体用到了 JPA 组件，数据库用 Oracle，最近的项目是 xx 系统，用到了敏捷开发模式，在这个项目里，我除了做 coding 外，还做过单元测试，讨论需求和详细设计等工作，并且最近的项目进度比较紧，我自己感觉还能主动加班，一起和同事们保质保量地完成项目。
在自我介绍阶段甚至也不必展开项目，因为后面你有机会详细说明，但你第一要以此进一步突出你最近的技能经验和职位介绍很匹配，第二还要以此说明你肯加班等特性(毕竟通过项目举例说明自己肯加班，比单纯说肯加班要可信得多)。
再强调下，在自我介绍阶段，只需要说明自己能胜任当前工作的要点，这些要点不需要展开，比如不必展开说明自己如何排查 OOM 异常的。而其它没和找工作没关系的，比如兴趣爱好，家庭成员，个人性格等一概不需要说。
大家在面试前，可以根据上述范例练习下说辞，不紧不慢地说这些话，估计也就需要 2 分钟，哪怕再腼腆再内向口才再不好的人，多练几遍也能说好，但如果因为没说好被面试官认为沟通能力差，就太冤枉了。
- 先介绍项目背景，打消面试官疑问
由于你在自我介绍阶段已经涉及到最近项目了，所以面试官一定就会再问下去。不过不管怎么样，面试官总会问及你最近的项目，所以你总是有机会通过介绍项目经验来验证自己能胜任这份工作。
当面试官让你介绍下最近的项目时，你可以先大致先说下项目背景。因为有些候选人在简历上的项目经验看上去就像学习项目（其实我知道不少项目经验还真是），但你可以通过如下的说辞，证明这个项目是商业项目经验。
我最近是在 xx 公司（以此突出商业项目）里做了 xx 项目，这个项目的客户方是 xx，已经上线（但如果是 web 项目面试官大概率会去核对）。这个项目用到了敏捷开发模式（提一下别展开，算抛出个提问点）， 这个项目组人员是 xx 人，做了 n 个月，我在里面做了 xx 和 xx 模块。
你这样一说，能通过项目所在公司和客户方等要素，说明这个项目不是你编的。有人会问了，如果项目真的是编的，该怎么说？这块我不管，你自己想办法说。
但你这样说之前，事先需要做好如下的功课。
-
了解敏捷开发模式，比如站会每个人该说什么，用 jira 管理进度，一年定好若干个发布日期，一个月发布一次等，因为你提到了，面试官大概率后继会问到。 - 如果你说的是 xx 财务系统 xx 图书馆系统等，一些资深的面试官可能会问，这块有现成的项目， 为什么你们公司还要自己开发？所以说你在准备项目描述时，不能夸张，比如把一个数据收集模块的维护项目夸张成 xx 财务系统。不过我也遇到过一些候选人，他们就说这是公司接的项目，为什么人家还要下订单做此项目他们管不着。
- 你一旦说了这个项目，那么面试官就会认为你真实做过，所以其中每个业务需求，比如数据从哪里收集，客户从哪个前端发请求，客户请求处理的流程，以及数据表的规模等信息，你得知道并且事先准备好回答预案，我就经常用此来确认候选人的项目是真实项目还是编的项目。
- 通过说项目管理工具，说明你不仅会写代码
在介绍项目背景之后，你更可以说些项目管理的工具，以此证明你在项目里还做过其它事情，不仅是仅会写代码，具体的说辞范例如下。
在这个项目里，我们用到了 maven，用 git 来管理代码，用 jira 来管理任务和 bug，用 jenkins 工具来发布。我还用过 junit 编写过单元测试，我们还用 sonar 来统计代码的测试覆盖度，我们项目经理要求，只有当“行覆盖率高于 80%”，代码才能提交。
上文提到 maven，Git 和 junit 这块不难，jira 管理 bug 和 task 这个也没什么可问，但你要事先了解下 sonar 管理代码质量的基础知识以及行覆盖率等要点，至于 jenkins 发布脚本，这个无需一般开发操心，你说下就行了。在上文里你仅仅提到的是工具，但你更要通过这些工具，来进行自我表扬。
我在使用 junit 时，不会敷衍地编写案例，而会根据真实的业务数据来编写案例，并且我还会着重考虑各种边界情况（这些哪怕初级开发也有本事做到），而且在编写代码时，我会非常注意编码规范，比
如定义变量时会让人一看就理解 ，在关键代码地方多写注释，在 if 等条件里不会写太复杂，一个方法不会写太长，或者你可以再说些其它好的编码规范。而且，一旦遇到我的 bug，我会第一时间跟进， 并会和相关对应的人一起解决掉。
上述文字，虽然说是自卖自夸，但由于你结合到了项目，所以面试官不会有违和感。而且你这样一说，面试官就会认为你除了写代码外，其它开发项目的综合能力也很强。
不过千万注意，介绍项目经验的目的主要是证明技能的匹配度，所以上文提到的“介绍项目背景”和
“说明项目用到的工具”以及“自卖自夸”的说辞，你别说太多，可以通过练习把它们控制在 1 分钟以内。
- 用 Spring Boot 项 目举例，说明你的技术基本面
然后就需要介绍项目里用到的技术，哪怕你的亮点说辞再说，你也得保证技术的基本面说辞，这里就用当前 Java 项目的主流框架 Spring Boot 为例，告诉大家如何以此展示 Java 开发的基本功。
我们这个项目用到了 Spring Boot 框架，其中用 JPA 连接 Oracle（或 MySQL 等）数据库，在控制层里用到了@RequestMapping 注解来编写业务处理方法。在业务代码里，是用@Autowired 注解来以
IOC 的方式引入类，还用到了@Service 和@Component 注解。当我们从数据库里拿到数据后，会用包含@Entity 和@Table 注解的模型类来映射数据。在这个项目里，我们还用到了@Transactional 注解来定义事务，这个注解是作用在 Service 层上的，在这个项目里，我们还用到多个 Java 集合类和异常处理类。
通过上文的范例，大家应该可以很好地展示 Spring Boot 的基本技术面，其实对大多数 Java 初级开发而言，日常工作也就是用 Spring Boot 写一些增删改查的工作，所谓根据现有的业务再编写新的业
务，所以上述说辞足够了。但是由于你提到了 Spring Boot，所以在提问阶段，面试官大概率会问及如下的问题。
@Service 和@Component 注解的差别？
各种 Restful 请求格式以及各种 http 请求返回码。
@Transactional 事务里的事务隔离级别和事务传播机制概念。
Spring 依赖注入概念和@Autowired 的用法。
Spring Bean 的生命周期。
甚至可能还会问 Spring Boot 启动流程以及底层源码。
- 用实例说明你在内存调优方面的经验
当你介绍好基于 Spring Boot 的技术基本面以后，你还可以进一步说明诸多亮点，这里就先给出结合项目展示内存调优方面说辞的范例。
（之前是介绍项目技术基本面，比如 Spring Boot）在本项目里，我会非常注意内存的使用性能，并在项目里有过排查分析 OOM 的项目经验，我在编码的时候，也会非常注意内存性能，同时我也了解过 JVM 内存结构以及 GC 算法。
不管怎么组织语言，这方面你需要突出四点： 第一强调你有内存调优意识，
第二说明你有排查 OOM 的经验，
第三说明你写代码的时候也会注意内存性能，
第四说明你还了解 JVM 结构和 GC 流程的知识。
但这里依然要强调，你尚在项目介绍阶段，你说明要点即可，别展开，如果这里你展开说明内存调优的做法，面试官会认为你思路不清晰，不过既然你提到了，面试官可能立即就打断你介绍让你详细说明，或者你介绍完项目后会继续问，总之你是有机会详细展示内存调优亮点技能了。
如果面试官事后详细问你排查 OOM 经验细节时，你可以这样回答。
在测试环境，我们经常会收到内存使用率高于 70%的告警，（至于怎么告警的相关设置，你可以看下new relic，如果你是初级开发，甚至不需要掌握相关经验），收到告警后，我第一通过 dump 命令观察当前内存镜像（你得熟悉下 dump 命令以及 dump 文件的打开方式和 dump 文件的内容），第二通过日志观察是哪个方法抛出的，最后发现是因为在订单模块（或其它模块）一个 JDBC 连接对象没关闭（或一个大的 Hashmap 对象用好没 clear），所以导致了内存无法回收，发现问题后对应回收掉即可。
这里你结合的业务（比如订单模块）来说明，然后面试官再问 dump 细节时，你再说下 dump 文件的结构，这就行了。
如果面试官再问你如何在代码里注意内存性能，你可以这样说：
在写代码时，我会非常注意，在 try…catch…finally 从句里关闭或释放 Connection 和大的集合，一些大的对象用好以后，我会及时把它们设置成 null，以此提升它们的回收时间，在 for 等循环里，我不会频繁地操作 String 对象，因为会产生大量内存碎片。同时，我会非常谨慎地使用 finalize 方法（事先看下），因为这可能会导致对象无法回收。
其实说上这四点就够了， 如果你自己感觉有本事，可以在了解强引用、弱引用和软引用的前提下在说如下的点，这很值钱。
在数据同步的业务场景里，我用到了弱引用（或软引用），以此提升数据对象的回收时间。
如果面试官问你 JVM 内存结构及 GC（垃圾回收）流程，这其实是理论问题，网上资料太多，靠背就行了，所以这里就不再详细说了。但话说回来，GC 流程以及 JVM 体系结构这方面的理论知识，这属于面试常用考点，你准备下不吃亏。
- 展示你在数据库调优方面的经验
很多候选人其实不会在面试中展示内存调优方面的经验，而你如果按照上述说辞，一方面在介绍项目经验时引出要点，另一方面在后继交流中很好地说明细节，那么可以这样说，你就超越了很多竞争 者，甚至说句不该说的话，一些初级开发甚至还能以此充实自己的项目经验。
在介绍项目经验时，如果单纯展示内存调优方面的经验，可能说服力不强，这里再给出用实际说明数据库调优技能的范例。首先你可以在介绍项目时，适当地通过如下的说辞来引入要点。
在本项目里，我参与过数据表设计，所以会考虑用反范式来避免因大表关联而导致的性能损耗，同时我们会合理地设置索引以提升数据库的访问性能，并且我还有过用执行计划优化语句的经验，同时在使用事务的时候，我会非常注意配置事务隔离级别和事务传播机制，以免造成锁表。
同样，在项目介绍阶段，数据库调优方面的说辞不需要展开，给出点即可，由于你提到了，所以面试官在后面大概率会问到。
不过你在面试前，需要准备如下的技能（其实这些技能属于数据库基本点，你不准备反而会有问题）。
1 你去看下索引的数据结构（比如 B+树），建索引的语句，索引的种类，尤其是复合索引以及对应的回表和最左匹配原则。
2 事先看下索引的正确用法，以及哪些情况下用不到索引，比如 where a != 'xx’可能就用不到。
3 索引的代价（会占硬盘，以及大批量读写时会重建索引，所以性能慢），以及在小表里，无需建索引。
4 执行计划的概念，以及通过执行计划排查慢 sql 时该注意的点（避免全表扫描，设置合理的关联表方式等）。
5 三范式和反范式相关概念，因为你提到了。
6 事务隔离级别里的脏读等概念，以及事务传播机制，尤其地，你要具体说出你项目里用的是哪个。
- 总结前文说辞
这里根据上文给出的要点，整理下介绍项目经验的说辞。
(介绍项目背景)我最近的项目是在 xx 公司做的 xx 社区爱心超市项目（项目别说太大），客户方是 xx
公司，项目组里是 6 个人，开发了八个月，最近还在开发，在其中我做了删除和更新订单模块的业务
（如果是在校阶段做的项目需要再加上如下的话），这个项目是我从大三开始，外面找 xx 公司做的兼职项目，做项目的时候我每月还能拿到钱。
（介绍项目技术，JD 上列的尽量说全）这个项目用到了 Spring Boot 框架，数据库是 Oracle，用
JPA 连接 Oracle（或 MySQL 等）数据库，在控制层里用到了@RequestMapping 注解来编写业务处理方法。在业务代码里，是用@Autowired 注解来以 IOC 的方式引入类，还用到了@Service 和
@Component 注解。当我们从数据库里拿到数据后，会用包含@Entity 和@Table 注解的模型类来映射数据。在这个项目里，我们还用到了@Transactional 注解来定义事务，这个注解是作用在
Service 层上的，在这个项目里，我们还用到多个 Java 集合类和异常处理类。
（介绍项目管理工具）这个项目用到了敏捷开发模式，用 Maven 框架，用 sonar 管理质量，用 git 管理项目版本，用 jenkins 发布，用 logback 打日志， 我在这个项目里，除了写代码外，还有用 Junit 进行单元测试的经验。我们还用 sonar 来统计代码的测试覆盖度，我们项目经理要求，只有当“行覆盖率高于 80%”，代码才能提交。
（最后抛出亮点）在这个项目里，我用到了单例和工厂设计模式，在这个项目里，我做过 JVM 调优和数据库调优的的事情，在做项目时为了加深理解，我还看了 ArrayList 快速失效的底层代码，也看过
HashMap 关于 HashCode 以及 put 和 get 部分的底层源码。这个项目后期进度比较紧，我也能通过加班等手段保证项目能正常上线，而且一旦遇到线上问题，我也会尽量参与并解决。
大家在面试前，可以根据上述范例合理地准备说辞，次序和内容上可以做调整，但包含的几个要素尽量都说全。如果可以，事先要多练习几遍，确保能足量地抛出你的相关技能和亮点。
不过千万注意，在介绍项目时，对具体的点，比如内存调优，你点到为止，别展开，否则的话，面试官一定会认为里思路不清晰。总之在介绍项目时，需要遵循的要点是：第一要尽可能全面地说明你用过 JD 上的技能，第二要抛出亮点话题，等待面试官提问。
- 准备项目说辞时，更可以准备后继面试官的问题
其实大多数面试官在面试前，有可能还在调试代码，或者还在开会，也就是他们事先是不会准备面试问题的。所以当你在自我介绍和介绍项目经验时抛出亮点后，他们往往会随口接着这个话题问下去， 也就是说，只要实现准备好，你是知道面试官会问什么的。
根据上文给出的项目介绍说辞，你提到了敏捷开发，Spring Boot 框架，数据库调优，内存调优，设计模式，junit 以及项目管理软件，java 集合以及底层源码等话题，在前文里也给出了一些面试官可能问到的问题以及对应的准备要点，除此之外，大家还可以做如下的准备。
理解单例模式，尤其是双重检查的单例模式，要会写代码，并给出一个项目使用场景，比如某工具类需要用单例的方式创建。同样地，对于工厂模式也准备一个使用场景，这更好办，比如 xml 解析器类，是用 Factory 模式创建的。
在理解的基础上，背诵并会默写 ArrayList 快速失效的底层代码，面试时，当面试官顺着你给出的言辞继续提问时，你可以边写边说，同时也可以准备 HashMap 以及 Hashcode 的底层源码。
去看下 JVM 内存调优和垃圾回收相关理论，最好再看下强引用，弱引用和软引用理论。
这里请注意，你在自我介绍和项目介绍时，可以通过抛出亮点来引导面试官提问，但同时，你更需要准备其它常见问题，因为有些面试官依然会问其它问题。对此大家可以在 Spring Boot 框架，数据库和 Java 核心开发这三个方面多刷些面试题，甚至可以多准备些笔试题。那么这样一说，你抛出亮点有什么好处呢？
第一，真有些面试官在顺着你言辞提问后，发现你回答很好（因为你事先准备过，想不好回答都难），然后他们就不再提问了。
第二，面试官多少会问及些你提到的亮点，这样你就能最大程度避免面试官问及你不熟悉的点。
第三，其实大多数初级开发在项目中只是做增删改查，但一方面你根据上文描述准备了若干常稳点， 另一方面你能很好证明你熟悉设计模式，有 JVM 和数据库调优经验，那么你就有可能在面试中表现比其它人强。
总之，你在准备项目经验的前提下准备些基础和亮点技术点，准不会吃亏。
以上整理自知乎 hsmcomputer 相关问题回答
Java 进阶训练营
学员口中的大厂面试宝典
2021 【美团】面试真题：
1、Spring AOP 底层原理
aop 底层是采用动态代理机制实现的：接口+实现类
如果要代理的对象，实现了某个接口，那么 Spring AOP 会使用 JDK Proxy，去创建代理对象。
没有实现接口的对象，就无法使用 JDK Proxy 去进行代理了，这时候 Spring AOP 会使用
Cglib 生成一个被代理对象的子类来作为代理。
就是由代理创建出一个和 impl 实现类平级的一个对象，但是这个对象不是一个真正的对象， 只是一个代理对象，但它可以实现和 impl 相同的功能，这个就是 aop 的横向机制原理，这样就不需要修改源代码。
2、HashMap 的底层数据结构是怎样的 ？
JDK1.8 之前
JDK1.8 之前 HashMap 底层是 数组和链表 结合在一起使用也就是 链表散列。
HashMap 通过 key 的 hashCode 经过扰动函数处理过后得到 hash 值，然后通过 (n - 1) & hash 判断当前元素存放的位置（这里的 n 指的是数组的长度），如果当前位置存在元素的话，就判断该元素与要存入的元素的 hash 值以及 key 是否相同，如果相同的话， 直接覆盖，不相同就通过拉链法解决冲突。
所谓扰动函数指的就是 HashMap 的 hash 方法。使用 hash 方法也就是扰动函数是为了防止一些实现比较差的 hashCode() 方法 换句话说使用扰动函数之后可以减少碰撞。
JDK1.8 之后
当链表长度大于阈值（默认为 8）时，会首先调用 treeifyBin()方法。这个方法会根据
HashMap 数组来决定是否转换为红黑树。只有当数组长度大于或者等于 64 的情况下，才会执行转换红黑树操作，以减少搜索时间。否则，就是只是执行 resize() 方法对数组扩容。
3、HashMap 的扩容机制是怎样的？
一般情况下，当元素数量超过阈值时便会触发扩容。每次扩容的容量都是之前容量的 2 倍。
HashMap 的容量是有上限的，必须小于 1<<30，即 1073741824。如果容量超出了这个数，则不再增长，且阈值会被设置为 Integer.MAX_VALUE。
JDK7 中的扩容机制
空参数的构造函数：以默认容量、默认负载因子、默认阈值初始化数组。内部数组是空数组。
有参构造函数：根据参数确定容量、负载因子、阈值等。
第一次 put 时会初始化数组，其容量变为不小于指定容量的 2 的幂数，然后根据负载因子确定阈值。
如果不是第一次扩容，则 新容量=旧容量 x 2 ，新阈值=新容量 x 负载因子 。
JDK8 的扩容机制
空参数的构造函数：实例化的 HashMap 默认内部数组是 null，即没有实例化。第一次调用 put 方法时，则会开始第一次初始化扩容，长度为 16。
有参构造函数：用于指定容量。会根据指定的正整数找到不小于指定容量的 2 的幂数，将这个数设置赋值给阈值（threshold）。第一次调用 put 方法时，会将阈值赋值给容量， 然后让 阈值 = 容量 x 负载因子。
如果不是第一次扩容，则容量变为原来的 2 倍，阈值也变为原来的 2 倍。（容量和阈值都
变为原来的 2 倍时，负载因子还是不变）。此外还有几个细节需要注意：
首次 put 时，先会触发扩容（算是初始化），然后存入数据，然后判断是否需要扩容；
不是首次 put，则不再初始化，直接存入数据，然后判断是否需要扩容；
4、ConcurrentHashMap 的存储结构是怎样的？
Java7 中 ConcurrnetHashMap 使用的分段锁，也就是每一个 Segment 上同时只有一个线程可以操作，每一个 Segment 都是一个类似 HashMap 数组的结构，它可以扩容，它的冲突会转化为链表。但是 Segment 的个数一但初始化就不能改变，默认 Segment 的个数是 16 个。
Java8 中的 ConcurrnetHashMap 使用的 Synchronized 锁加 CAS 的机制。结构也由
Java7 中的 Segment 数组 + HashEntry 数组 + 链表 进化成了 Node 数组 + 链表 / 红黑树，Node 是类似于一个 HashEntry 的结构。它的冲突再达到一定大小时会转化成红黑树，在冲突小于一定数量时又退回链表。
5、线程池大小如何设置？
CPU 密集型任务(N+1)： 这种任务消耗的主要是 CPU 资源，可以将线程数设置为 N
（CPU 核心数）+1，比 CPU 核心数多出来的一个线程是为了防止线程偶发的缺页中断， 或者其它原因导致的任务暂停而带来的影响。一旦任务暂停，CPU 就会处于空闲状态，而在这种情况下多出来的一个线程就可以充分利用 CPU 的空闲时间。
I/O 密集型任务(2N)： 这种任务应用起来，系统会用大部分的时间来处理 I/O 交互，而线程在处理 I/O 的时间段内不会占用 CPU 来处理，这时就可以将 CPU 交出给其它线程使用。因此在 I/O 密集型任务的应用中，我们可以多配置一些线程，具体的计算方法是
2N。
如何判断是 CPU 密集任务还是 IO 密集任务？
CPU 密集型简单理解就是利用 CPU 计算能力的任务比如你在内存中对大量数据进行排序。单凡涉及到网络读取，文件读取这类都是 IO 密集型，这类任务的特点是 CPU 计算耗费时间相比于等待 IO 操作完成的时间来说很少，大部分时间都花在了等待 IO 操作完成上。
6、IO 密集=Ncpu*2 是怎么计算出来？
I/O 密集型任务任务应用起来，系统会用大部分的时间来处理 I/O 交互，而线程在处理
I/O 的时间段内不会占用 CPU 来处理，这时就可以将 CPU 交出给其它线程使用。因此在
I/O 密集型任务的应用中，我们可以多配置一些线程。例如：数据库交互，文件上传下载，网络传输等。IO 密集型，即该任务需要大量的 IO，即大量的阻塞，故需要多配置线程数。
7、G1 收集器有哪些特点？
G1 的全称是 Garbage-First，意为垃圾优先，哪一块的垃圾最多就优先清理它。 G1 GC 最主要的设计目标是：将 STW 停顿的时间和分布，变成可预期且可配置的。被视为 JDK1.7 中 HotSpot 虚拟机的一个重要进化特征。它具备一下特点：
并行与并发：G1 能充分利用 CPU、多核环境下的硬件优势，使用多个 CPU（CPU 或者
CPU 核心）来缩短 Stop-The-World 停顿时间。部分其他收集器原本需要停顿 Java 线程执行的 GC 动作，G1 收集器仍然可以通过并发的方式让 java 程序继续执行。
了分代的概念。
空间整合：与 CMS 的“标记-清理”算法不同，G1 从整体来看是基于“标记-整理”算法实现的收集器；从局部上来看是基于“标记-复制”算法实现的。
可预测的停顿：这是 G1 相对于 CMS 的另一个大优势，降低停顿时间是 G1 和 CMS 共同的关注点，但 G1 除了追求低停顿外，还能建立可预测的停顿时间模型，能让使用者明确指定在一个长度为 M 毫秒的时间片段内。
G1 收集器在后台维护了一个优先列表，每次根据允许的收集时间，优先选择回收价值最大的
Region（这也就是它的名字 Garbage-First 的由来）
8、你有哪些手段来排查 OOM 的问题？
增 加 两 个 参 数 -XX:+HeapDumpOnOutOfMemoryError - XX:HeapDumpPath=/tmp/heapdump.hprof，当 OOM 发生时自动 dump 堆内存信息到指定目录。
同时 jstat 查看监控 JVM 的内存和 GC 情况，先观察问题大概出在什么区域。
使用 MAT 工具载入到 dump 文件，分析大对象的占用情况，比如 HashMap 做缓存未清理，时间长了就会内存溢出，可以把改为弱引用。
9、请你谈谈 MySQL 事务隔离级别，MySQL 的默认隔离级别是什么？
为了达到事务的四大特性，数据库定义了 4 种不同的事务隔离级别：
READ-UNCOMMITTED（读取未提交）：最低的隔离级别，允许脏读，也就是可能读取到其他会话中未提交事务修改的数据，可能会导致脏读、幻读或不可重复读。
READ-COMMITTED（读取已提交）： 只能读取到已经提交的数据。Oracle 等多数数据库默认都是该级别 （不重复读），可以阻止脏读，但是幻读或不可重复读仍有可能发生。
REPEATABLE-READ（可重复读）：对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改，可以阻止脏读和不可重复读，但幻读仍有可能发生。
SERIALIZABLE（可串行化）：最高的隔离级别，完全服从 ACID 的隔离级别。所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，该级别可以防止脏读、不可重复读以及幻读。
MySQL 默认采用的 REPEATABLE_READ 隔离级别。
10、可重复读解决了哪些问题？
可重复读的核心就是一致性读(consistent read);保证多次读取同一个数据时，其值都和事务开始时候的内容是一致，禁止读取到别的事务未提交的数据，会造成幻读。
而事务更新数据的时候，只能用当前读。如果当前的记录的行锁被其他事务占用的话，就需要进入锁等待。
查询只承认在事务启动前就已经提交完成的数据。
可重复读解决的是重复读的问题，可重复读在快照读的情况下是不会有幻读，但当前读的时候会有幻读。
11、对 SQL 慢查询会考虑哪些优化 ？
分析语句，是否加载了不必要的字段/数据。
分析 SQL 执行计划（explain extended），思考可能的优化点，是否命中索引等。
查看 SQL 涉及的表结构和索引信息。
如果 SQL 很复杂，优化 SQL 结构。
按照可能的优化点执行表结构变更、增加索引、SQL 改写等操作。
查看优化后的执行时间和执行计划。
如果表数据量太大，考虑分表。
利用缓存，减少查询次数。
12、谈一谈缓存穿透、缓存击穿和缓存雪崩，以及解决办法？
缓存穿透
问题：大量并发查询不存在的 KEY，在缓存和数据库中都不存在，同时给缓存和数据库带来压力。
原因：一般而言，缓存穿透有 2 种可能性：业务数据被误删，导致缓存和数据库中都没有数据。恶意进行 ddos 攻击。
分析：为什么会多次透传呢？不存在 一直为空，需要注意让缓存能够区分 KEY 不存在和查询到一个空值。
解决办法：缓存空值的 KEY，这样第一次不存在也会被加载会记录，下次拿到有这个
KEY。Bloom 过滤或 RoaingBitmap 判断 KEY 是否存在，如果布隆过滤器中没有查到这个数据，就不去数据库中查。在处理请求前增加恶意请求检查，如果检测到是恶意攻击， 则拒绝进行服务。完全以缓存为准，使用延迟异步加载的策略（异步线程负责维护缓存的数据，定期或根据条件触发更新），这样就不会触发更新。
缓存击穿
问题：某个 KEY 失效的时候，正好有大量并发请求访问这个 KEY。 分析：跟穿透其实很像，属于比较偶然的。
解决办法：KEY 的更新操作添加全局互斥锁。完全以缓存为准，使用延迟异步加载的策略
（异步线程负责维护缓存的数据，定期或根据条件触发更新），这样就不会触发更新。
缓存雪崩
问题：当某一时刻发生大规模的缓存失效的情况，导致大量的请求无法获取数据，从而将流量压力传导到数据库上，导致数据库压力过大甚至宕机。
原因：一般而言，缓存雪崩有 2 种可能性：大量的数据同一个时间失效：比如业务关系强相关的数据要求同时失效 Redis 宕机
分析：一般来说，由于更新策略、或者数据热点、缓存服务宕机等原因，可能会导致缓存数据同一个时间点大规模不可用，或者都更新。所以，需要我们的更新策略要在时间上合适，数据要均匀分享，缓存服务器要多台高可用。
解决办法：更新策略在时间上做到比较平均。如果数据需要同一时间失效，可以给这批数据加上一些随机值，使得这批数据不要在同一个时间过期，降低数据库的压力。使用的热数据尽量分散到不同的机器上。多台机器做主从复制或者多副本，实现高可用。做好主从的部署，当主节点挂掉后，能快速的使用从结点顶上。实现熔断限流机制，对系统进行负载能力控制。对于非核心功能的业务，拒绝其请求，只允许核心功能业务访问数据库获取数据。服务降价：提供默认返回值，或简单的提示信息。
13、LRU 是什么？如何实现？
最近最少使用策略 LRU（Least Recently Used）是一种缓存淘汰算法，是一种缓存淘汰机制。
使用双向链表实现的队列，队列的最大容量为缓存的大小。在使用过程中，把最近使用的页面移动到队列头，最近没有使用的页面将被放在队列尾的位置
使用一个哈希表，把页号作为键，把缓存在队列中的节点的地址作为值，只需要把这个页对应的节点移动到队列的前面，如果需要的页面在内存中，此时需要把这个页面加载到内存中，简单的说，就是将一个新节点添加到队列前面，并在哈希表中跟新相应的节点地 址，如果队列是满的，那么就从队尾移除一个节点，并将新节点添加到队列的前面。
14、什么是堆内存？参数如何设置？
堆内存是指由程序代码自由分配的内存，与栈内存作区分。
在 Java 中，堆内存主要用于分配对象的存储空间，只要拿到对象引用，所有线程都可以访问堆内存。
-Xmx, 指定最大堆内存。 如 -Xmx4g. 这只是限制了 Heap 部分的最大值为 4g。这个内存不包括栈内存，也不包括堆外使用的内存。
-Xms, 指定堆内存空间的初始大小。 如 -Xms4g。 而且指定的内存大小，并不是操作系统实际分配的初始值，而是 GC 先规划好，用到才分配。 专用服务器上需要保持 –Xms
和 –Xmx 一致，否则应用刚启动可能就有好几个 FullGC。当两者配置不一致时，堆内存扩容可能会导致性能抖动。
-Xmn, 等价于 -XX:NewSize，使用 G1 垃圾收集器 不应该 设置该选项，在其他的某些业务场景下可以设置。官方建议设置为 -Xmx 的 1/2 ~ 1/4.
-XX：MaxPermSize=size, 这是 JDK1.7 之前使用的。Java8 默认允许的 Meta 空间无限大，此参数无效。
-XX：MaxMetaspaceSize=size, Java8 默认不限制 Meta 空间, 一般不允许设置该选项。
-XX：MaxDirectMemorySize=size，系统可以使用的最大堆外内存，这个参数跟 -
Dsun.nio.MaxDirectMemorySize 效果相同。
-Xss, 设置每个线程栈的字节数。 例如 -Xss1m 指定线程栈为 1MB，与- XX:ThreadStackSize=1m 等价
15、栈和队列，举个使用场景例子？
栈（后进先出）可以用于字符匹配，数据反转等场景 队列（先进先出）可以用于任务队列，共享打印机等场景
16、MySQL 为什么 InnoDB 是默认引擎？
聚集索引是指数据库表行中数据的物理顺序与键值的逻辑（索引）顺序相同。一个表只能有一个聚簇索引，因为一个表的物理顺序只有一种情况，所以，对应的聚簇索引只能有一个。聚簇索引的叶子节点就是数据节点，既存储索引值，又在叶子节点存储行数据。
Innodb 创建表后生成的文件有：
frm: 创 建 表 的 语 句 idb:表里面的数据+索引文件
17、MySQL 索引底层结构为什么使用 B+树？
哈希虽然能够提供 O(1) 的单数据行操作性能，但是对于范围查询和排序却无法很好地支持，最终导致全表扫描；B 树能够在非叶节子点中存储数据，但是这也导致在查询连续数据时可能会带来更多的随机 I/O，而 B+树的所有叶节点可以通过指针相互连接，能够减少顺序遍历时产生的额外随机 I/O；
第一，B 树一个节点里存的是数据，而 B+树存储的是索引（地址），所以 B 树里一个节点存不了很多个数据，但是 B+树一个节点能存很多索引，B+树叶子节点存所有的数据。
第二，B+树的叶子节点是数据阶段用了一个链表串联起来，便于范围查找。
18、B+ 树的叶子节点链表是单向还是双向？
双向链表
19、MVCC 是什么？它的底层原理是什么？
MVCC，多版本并发控制,它是通过读取历史版本的数据，来降低并发事务冲突，从而提高并发性能的一种机制。 事务版本号
表的隐藏列 undo log read view
20、undo log 具体怎么回滚事务 ？
举个例子：
对于 insert 类型的 sql，会在 undo log 中记录下方才你 insert 进来的数据的 ID，当你想roll back 时，根据 ID 完成精准的删除。
对于 delete 类型的 sql，会在 undo log 中记录方才你删除的数据，当你回滚时会将删除前的数据 insert 进去。
对于 update 类型的 sql，会在 undo log 中记录下修改前的数据，回滚时只需要反向
update 即可。 对于 select 类型的 sql，别费心了，select 不需要回滚。
21、如何查询慢 SQL 产生的原因
分析 SQL 执行计划（explain extended），思考可能的优化点，是否命中索引等。
没有索引或者没有用到索引(这是查询慢最常见的问题，是程序设计的缺陷)。
内存不足。
网络速度慢。
是否查询出的数据量过大（可以采用多次查询，其他的方法降低数据量）。
是否返回了不必要的行和列。
锁或者死锁。
I/O 吞吐量小，形成了瓶颈效应。
sp_lock,sp_who,活动的用户查看,原因是读写竞争资源。
22、索引失效的情况有哪些？
like 以%开头索引无效，当 like 以&结尾，索引有效。
or 语句前后没有同事使用索引，当且仅当 or 语句查询条件的前后列均为索引时，索引生效。
组合索引，使用的不是第一列索引时候，索引失效，即最左匹配规则。
数据类型出现隐式转换，如 varchar 不加单引号的时候可能会自动转换为 int 类型，这个时候索引失效。
在索引列上使用 IS NULL 或者 IS NOT NULL 时候，索引失效，因为索引是不索引空值得。
在索引字段上使用，NOT、 <>、！= 、时候是不会使用索引的，对于这样的处理只会进行全表扫描。
对索引字段进行计算操作，函数操作时不会使用索引。 当全表扫描速度比索引速度快的时候不会使用索引。
23、一个 Redis 实例最多能存放多少的 keys？List、Set、Sorted Set 他们最多能存放多少元素？
理论上 Redis 可以处理多达 232 的 keys，并且在实际中进行了测试，每个实例至少存放了 2 亿 5 千万的 keys。我们正在测试一些较大的值。任何 list、set、和 sorted set 都可以放 232 个元素。换句话说，Redis 的存储极限是系统中的可用内存值。
24、Redis 数据结构 压缩列表和跳跃表的区别
压缩列表（ziplist）本质上就是一个字节数组，是 Redis 为了节约内存而设计的一种线性数据结构，可以包含多个元素，每个元素可以是一个字节数组或一个整数。
跳跃表（skiplist）是一种有序数据结构，它通过在每个节点中维持多个指向其他节点的指针，从而达到快速访问节点的目的。跳跃表支持平均 O（logN）、最坏 O（N）复杂度的节点查找，还可以通过顺序性操作来批量处理节点。
25、为什么数据量小的时候用压缩列表 ? 为了省内存。 26、Redis 主从同步是怎么实现的？
全量同步
master 服务器会开启一个后台进程用于将 redis 中的数据生成一个 rdb 文件，与此同时，服务器会缓存所有接收到的来自客户端的写命令（包含增、删、改），当后台保存进程处理完毕
后，会将该 rdb 文件传递给 slave 服务器，而 slave 服务器会将 rdb 文件保存在磁盘并通过读取该文件将数据加载到内存，在此之后 master 服务器会将在此期间缓存的
命令通过 redis 传输协议发送给 slave 服务器，然后 slave 服务器将这些命令依次作用于自己本地的数据集上最终达到数据的一致性。
增量同步
从 redis 2.8 版本以前，并不支持部分同步，当主从服务器之间的连接断掉之后，master 服务器和 slave 服务器之间都是进行全量数据同步。
从 redis 2.8 开始，即使主从连接中途断掉，也不需要进行全量同步，因为从这个版本开始融入了部分同步的概念。部分同步的实现依赖于在 master 服务器内存中给每个 slave 服务器维护了一份同步日志和同步标识，每个 slave 服务器在跟 master 服务器进行同步时都会携带自己的同步标识和上次同步的最后位置。当主从连接断掉之后，slave 服务器隔断时间（默认1s）主动尝试和 master 服务器进行连接，如果从服务器携带的偏移量标识还在 master 服务器上的同步备份日志中，那么就从 slave 发送的偏移量开始继续上次的同步操作，如果 slave 发送的偏移量已经不再 master 的同步备份日志中（可能由于主从之间断掉的时间比较长或者在断掉的短暂时间内 master 服务器接收到大量的写操作），则必须进行一次全量更新。在部分同步过程中，master 会将本地记录的同步备份日志中记录的指令依次发送给 slave 服务器从而达到数据一致。
Redis 主从同步策略
主从刚刚连接的时候，进行全量同步；全同步结束后，进行增量同步。当然，如果有需要，
slave 在任何时候都可以发起全量同步。redis 策略是，无论如何，首先会尝试进行增量同步，如不成功，要求从机进行全量同步。
27、Redis 持久化 RDB 和 AOF 优缺点
RDB
RDB 持久化方式，是将 Redis 某一时刻的数据持久化到磁盘中，是一种快照式的持久化方法 。 RDB 优点：
RDB 是一个非常紧凑（有压缩）的文件,它保存了某个时间点的数据,非常适用于数据的备份。
RDB 作为一个非常紧凑（有压缩）的文件，可以很方便传送到另一个远端数据中心 ，非常适用于灾难恢复。
RDB 在保存 RDB 文件时父进程唯一需要做的就是 fork 出一个子进程,接下来的工作全部由子进程来做，父进程不需要再做其他 IO 操作，所以 RDB 持久化方式可以最大化 redis 的性能。
与 AOF 相比，在恢复大的数据集的时候，RDB 方式会更快一些。
RDB 缺点：
Redis 意外宕机时，会丢失部分数据。
当 Redis 数据量比较大时，fork 的过程是非常耗时的，fork 子进程时是会阻塞的，在这期间 Redis 是不能响应客户端的请求的。
AOF
AOF 方式是将执行过的写指令记录下来，在数据恢复时按照从前到后的顺序再将指令都执行一遍。
AOF 优点：
使用 AOF 会让你的 Redis 更加持久化。
AOF 文件是一个只进行追加的日志文件，不需要在写入时读取文件。
Redis 可以在 AOF 文件体积变得过大时，自动地在后台对 AOF 进行重写 。 AOF 文 件 可 读 性 高 ， 分 析 容 易 。AOF 缺点：
对于相同的数据来说，AOF 文件大小通常要大于 RDB 文件。 根据所使用的 fsync 策略，AOF 的速度可能会慢于 RDB。
28、谈谈自己对于 Spring AOP 的了解？
AOP(Aspect-Oriented Programming:面向切面编程)能够将那些与业务无关，却为业务模块所共同调用的逻辑或责任（例如事务处理、日志管理、权限控制等）封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可拓展性和可维护性。
29、 Spring Bean 容器的生命周期是什么样的？
Bean 容器找到配置文件中 Spring Bean 的定义。
Bean 容器利用 Java Reflection API 创建一个 Bean 的实例。 如果涉及到一些属性值 利用 set()方法设置一些属性值。 如果 Bean 实现了 BeanNameAware 接口，调用 setBeanName()方法，传入 Bean 的名
字。 如果 Bean 实现了 BeanClassLoaderAware 接口，调用 setBeanClassLoader()方法，传
入 ClassLoader 对象的实例。 如果 Bean 实现了 BeanFactoryAware 接口，调用 setBeanFactory()方法，传入
BeanFactory 对象的实例。 与上面的类似，如果实现了其他 *.Aware 接口，就调用相应的方法。 如果有和加载这个 Bean 的 Spring 容器相关的 BeanPostProcessor 对象，执行
postProcessBeforeInitialization() 方法
如果 Bean 实现了 InitializingBean 接口，执行afterPropertiesSet()方法。
如果 Bean 在配置文件中的定义包含 init-method 属性，执行指定的方法。
如果有和加载这个 Bean 的 Spring 容器相关的 BeanPostProcessor 对象，执行
postProcessAfterInitialization() 方法
当要销毁 Bean 的时候，如果 Bean 实现了 DisposableBean 接口，执行 destroy() 方法。
当要销毁 Bean 的时候，如果 Bean 在配置文件中的定义包含 destroy-method 属性，执行指定的方法。
30、RabbitMQ 如何保证消息不丢失 ？
生产者：
方案 1：开启 RabbitMQ 事务(同步，性能差) 方案 2：开启 confirm 模式(异步，性能较好)
MQ：(1)exchange 持久化 (2)queue 持久化 (3)消息持久化消费者：关闭自动 ACK
2021 【阿里】面试真题：
1、TCP 和 UDP 区别？
TCP 基于连接，UDP 基于无连接。 TCP 要求系统资源较多，UDP 较少。 UDP 程序结构较简单。
TCP 保证数据正确性，UDP 可能丢包。
TCP 保证数据顺序，UDP 不保证。
2、TCP/IP 协议涉及哪几层架构？
应用层 传输层 互连网络层 网络接口层。
3、描述下 TCP 连接 4 次挥手的过程？为什么要 4 次挥手？
因为 TCP 是全双工，每个方向都必须进行单独关闭。关闭连接时，当 Server 端收到 FIN 报文时，很可能并不会立即关闭 SOCKET，所以只能先回复一个 ACK 报文，告诉 Client 端，”你
发的 FIN 报文我收到了”。只有等到 Server 端所有的报文都发送完了，我才能发送 FIN 报文，因此不能一起发送。故需要四步握手。
4、计算机插上电源操作系统做了什么？
加电––––打开电源开关，给主板和内部风扇供电。
启动引导程序––––CPU 开始执行存储在 ROM BIOS 中的指令。
开机自检––––计算机对系统的主要部件进行诊断测试。
加载操作系统––––计算机将操作系统文件从磁盘读到内存中。
检查配置文件，定制操作系统的运行环境––––读取配置文件，根据用户的设置对操作系统进行定制。
准备读取命令和数据––––计算机等待用户输入命令和数据。
5、Linux 操作系统设备文件有哪些？
字符设备、块设备。
6、多线程同步有哪些方法？
使用 synchronized 关键字
wait 和 notify 使用特殊域变量 volatile 实现线程同步 使用重入锁实现线程同步 使用局部变量来实现线程同步 使用阻塞队列实现线程同步 使用原子变量实现线程同步
7、一个对象的两个方法加 synchronized，一个线程进去 sleep，另一个线程可以进入到另一个方法吗？
不能。
8、什么是可重入锁（ReentrantLock）？
举例来说明锁的可重入性 public class UnReentrant{ Lock lock = new Lock();
public void outer(){ lock.lock();
inner(); lock.unlock();
}
public void inner(){ lock.lock();
//do something lock.unlock();
}
}
outer 中调用了 inner，outer 先锁住了 lock，这样 inner 就不能再获取 lock。其实调用
outer 的线程已经获取了 lock 锁，但是不能在 inner 中重复利用已经获取的锁资源，这种锁即称之为不可重入可重入就意味着：线程可以进入任何一个它已经拥有的锁所同步着的代码块。
synchronized、ReentrantLock 都是可重入的锁，可重入锁相对来说简化了并发编程的开发。
9、创建线程的三个方法是什么？
通过继承 Thread 类创建线程类。
实现 Runnable 接口创建线程类。
通过 Callable 和 Future 接口创建线程。
10、Java 怎么获取多线程的返回值？
主线程等待。
使用 Thread 的 join 阻塞当前线程等待。
实现 Callable 接口（通过 FutureTask 或线程池的 Future）。
11、线程池有哪几种创建方式？
Java 通过 Executors（jdk1.5 并发包）提供四种线程池，分别为：
newCachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
12、线程池参数有哪些？
corePoolSize 核心线程大小。
maximumPoolSize 线程池最大线程数量。
keepAliveTime 空闲线程存活时间。
unit 空间线程存活时间单位。
workQueue 工作队列。 threadFactory 线程工厂。 handler 拒绝策略。
13、线程池拒绝策略有哪些？
ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出 RejectedExecutionException 异常
（默认拒绝策略）。
ThreadPoolExecutor.DiscardPolicy：丢弃任务，但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新提交被拒绝的任务。
ThreadPoolExecutor.CallerRunsPolicy：由调用线程（提交任务的线程）处理该任务。
14、你认为对线程池的核心参数实现自定义可配置，三个核心参数是？
corePoolSize : 核心线程数线程数定义了最小可以同时运行的线程数量。
maximumPoolSize : 当队列中存放的任务达到队列容量的时候，当前可以同时运行的线程数量变为最大线程数。
workQueue: 当新任务来的时候会先判断当前运行的线程数量是否达到核心线程数，如果达到的话，信任就会被存放在队列中。
15 、 ThreadPoolExecutor 线 程 池 ，corePoolSize=5， maximumPoolSize=10，queueCapacity=10，有 20 个耗时任务 交给这个线程池执行，线程池会如何执行这 20 个任务？
如果当前线程数<corePoolSize，如果是则创建新的线程执行该任务 。
如果当前线程数>=corePoolSize，则将任务存入 BlockingQueue 。
如果阻塞队列已满，且当前线程数<maximumPoolSize，则新建线程执行该任务。
如果阻塞队列已满，且当前线程数>=maximumPoolSize，则抛出异常 。
RejectedExecutionException，告诉调用者无法再接受任务了。
16、给用户发消息任务超出队列，你用哪个拒绝策略？有其他方法吗 ？
ThreadPoolExecutor.CallerRunsPolicy
无界队列（LinkedBlockingQuene）,继续添加任务到阻塞队列中等待执行。
用消息队列存任务数据，线程池慢慢处理。
17、Java8 新特性有哪些了解?
接口的默认方法
Lambda 表达式
函数式接口
方法和构造函数引用
Lamda 表达式作用域
内置函数式接口
Optional Streams(流)
Parallel Streams(并行流) Maps
Date API(日期相关 API) Annotations(注解)
18、什么时候用多线程、为什么要设计多线程？
高并发
系统接受实现多用户多请求的高并发时，通过多线程来实现。线程后台处理大任务
一个程序是线性执行的。如果程序执行到要花大量时间处理的任务时，那主程序就得等待其执行完才能继续执行下面的。那用户就不得不等待它执行完。
这时候可以开线程把花大量时间处理的任务放在线程处理，这样线程在后台处理时，主程序也可以继续执行下去，用户就不需要等待。线程执行完后执行回调函数。
大任务
大任务处理起来比较耗时，这时候可以起到多个线程并行加快处理（例如：分片上传）。
好处：可以提高 CPU 的利用率。在多线程程序中，一个线程必须等待的时候，CPU 可以运行其他的线程而不是等待，这样就大大提高了程序的效率。也就是说允许单个程序创建多个并行执行的线程来完成各自的任务。
19、多线程越多效率越高吗？
不是
当线程总数较少时，线程越多，效率越高。
当线程总数较多时，由于线程本身调用耗时，线程越多，效率越低。线程数越多会造成：
线程的生命周期开销非常高
消耗过多的 CPU 资源。
20、多线程会产生哪些并发问题 ?
安全性问题：在单线程系统上正常运行的代码，在多线程环境中可能会出现意料之外的结果。活跃性问题：不正确的加锁、解锁方式可能会导致死锁 or 活锁问题。
性能问题：多线程并发即多个线程切换运行，线程切换会有一定的消耗并且不正确的加锁。
21、Mybatis 如何将对象转换成 SQL？
SQL 绑定是在加载 Mybatis 配置文件，然后扫描到哪个 mapper 子节点，再加载 mapper 映射文件，扫描里面的 SQL 节点，然后封装成对象（MappedStatement，在这个对象的
SqlSource 封装着 sql 语句）。所有的配置信息保存在 Configuration 类，最后动态代理执行的时候，取出来封装 sql 的对象，执行 sql。
22、虚拟内存是什么，虚拟内存的原理是什么？
虚拟内存是计算机系统内存管理的一种技术。虚拟内存有以下两个优点：
虚拟内存地址空间是连续的，没有碎片。
虚拟内存的最大空间就是 cup 的最大寻址空间，不受内存大小的限制，能提供比内存更大的地址空间。
当每个进程创建的时候，内核会为每个进程分配虚拟内存，这个时候数据和代码还在磁盘上， 当运行到对应的程序时，进程去寻找页表，如果发现页表中地址没有存放在物理内存上，而是在磁盘上，于是发生缺页异常，于是将磁盘上的数据拷贝到物理内存中并更新页表，下次再访问该虚拟地址时就能命中了。
23、栈会溢出吗？什么时候溢出？方法区会溢出吗？
栈是线程私有的，它的生命周期与线程相同，每个方法在执行的时候都会创建一个栈帧，用来存储局部变量表，操作数栈，动态链接，方法出口等信息。局部变量表又包含基本数据类型， 对象引用类型。如果线程请求的栈深度大于虚拟机所允许的最大深度，将抛出
StackOverflowError 异常，方法递归调用产生这种结果。如果 Java 虚拟机栈可以动态扩展， 并且扩展的动作已经尝试过，但是无法申请到足够的内存去完成扩展，或者在新建立线程的时候没有足够的内存去创建对应的虚拟机栈，那么 Java 虚拟机将抛出一个 OutOfMemory 异常。(线程启动过多)。
方法区会发生溢出。
HotSpot jdk1.7 之前字符串常量池是方法区的一部分，方法区叫做“永久代”，在 1.7 之前无限的创建对象就会造成内存溢出，提示信息：PermGen space 而是用 jdk1.7 之后，开始逐步去永久代，就不会产生内存溢出。
方法区用于存放 Class 的相关信息，如类名、访问修饰符、常量池、字段描述、方法描述等， 如果动态生成大量的 Class 文件，也会产生内存溢出。常见的场景还有：大量 JSP 或动态产生
JSP 文件的应用（JSP 第一次运行时需要编译为 java 类）、基于 OSGi 的应用（即使是同一个类文件，被不同的类加载器加载也会视为不同的类）。
24、JVM 如何加载类的？
JVM 类加载机制分为五个部分：加载，验证，准备，解析，初始化。
加载
加载是类加载过程中的一个阶段， 这个阶段会在内存中生成一个代表这个类 java.lang.Class 对象， 作为方法区这个类的各种数据的入口。注意这里不一定非得要从一个 Class 文件获取，这里既可以从 ZIP 包中读取（比如从 jar 包和 war 包中读取），也可以在运行时计算生成（动态代理），也可以由其它文件生成（比如将 JSP 文件转换成对应的 Class 类）。
验证
这一阶段的主要目的是为了确保 Class 文件的字节流中包含的信息是否符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。
准备
准备阶段是正式为类变量分配内存并设置类变量的初始值阶段，即在方法区中分配这些变量所使用的内存空间。注意这里所说的初始值概念，比如一个类变量定义为：
实际上变量 v 在准备阶段过后的初始值为 0 而不是 8080， 将 v 赋值为 8080 的 put static
指令是程序被编译后， 存放于类构造器方法之中。
但是注意如果声明为：
public static final int v = 8080;
在编译阶段会为 v 生成 ConstantValue 属性，在准备阶段虚拟机会根据 ConstantValue 属性将 v 赋值为 8080。
解析
解析阶段是指虚拟机将常量池中的符号引用替换为直接引用的过程。符号引用就是 class 文件中的
public static int v &
版权声明：本文标题：2021 Java面试真题集锦 内容由热心网友自发贡献，该文观点仅代表作者本人， 转载请联系作者并注明出处：https://m.elefans.com/dongtai/1727663210a1124425.html， 本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容，一经查实，本站将立刻删除。
发表评论