面试问题收集

一、个人相关

1.请做一下自我介绍

面试官好，我叫李伟豪，是福州大学计算机专业的一名硕士研究生，我研究的方向是自然语言处理，在研究生期间，我做过一个智能问答相关的项目，这个项目现在已经投入上线使用，我主要在这个项目里负责后端的开发，另外我参加过全国研究生数学建模竞赛和ccf的竞赛，都取得过不错的成绩，我平时大部分的竞赛和项目都是用Java写的，也会使用一些python和c++，这次我面试的岗位是Java岗，希望能通过这次面试，和前辈进行交流和学习。

2.介绍一下项目

这个项目主要是部署在福州人力资源局上的一个智能问答系统，类似于客服机器人，由springboot+mybatis搭建的，我负责的内容主要有两大块，一个是使用ngram的概率统计思想进行智能纠错模块的开发，并提供对应的接口，另一个是对语料库表进行插入、删除、更新和按组查询接口的实现。在后期我还进行了数据库从mysql到oracle的迁移和对接相关的工作，并在对接的时候，针对对方提出的响应时间过长的问题做了一定的优化。

3.具体做了什么优化

一个是对bug的排查，比如在排查的过程中发现有三表连接查询的情况，这个就大大拖慢了响应速度，另外一个是加了一些索引来提高查询的效率。

4.项目亮点和难点

我说一下我这个项目里面重点解决的问题。
我们这个项目主要是做一个类似于客服机器人的智能问答系统，问答的内容是一些民生、社保、社会福利这一方面的内容，在前台输入一个问题，在后台通过对输入问题通过算法的过滤，对后台知识库的匹配会返回一个适合的答案。另外我们这个系统还支持智能纠错，智能补全和敏感词过滤等等，我说一下我负责的智能纠错模块，在这个模块里主要负责对输入语句的纠错，比如我输入怎么申请社保 但是把保错写成了报答的报，这时候我就要把里面的报改成保，我是借助ngram的统计学的思想把句子输入切分成两个两个一组的二元组，比如智能纠错这个我会把他分为 智能 能纠和纠错三个二元组 然后这些二元组存入到hashmap中，hashmap的key就是这些二元组，然后value就是这些二元组出现的频数，这些频数会通过预先训练得到一些初始值，然后会根据用户输入的句子去更新这个value。这样的话比如我输错了，检查发现 某两个字共同出现的概率很低，低于我设定的阈值，就会做替换。

但是，我一开始在做这个的时候没有考虑线程安全的问题，又因为我们插入语料库是批量插入的，然后客户那边就给我们反馈说压力测试报了异常，在大批量的插入的时候，就会比如说有十几句话，要这十几句话同时做切分，判断，还要做value的更新，这样又读又写的话就会出现并发的问题。后面的话，我就去了解了有三种数据选型把hashmap改成线程安全的，分别是Collection.Map,HashTable,和concurrentHashMap，HashTale的话因为每个方法都加了锁，效率太慢了，Collection.Map也同样有这个问题，所以最后是选用了concurrentHashMap解决了这个线程不安全的问题。这个也给我当时还是比较小白的我一个比较好的教训，不能只是停留在会用，也要了解为什么这么用，才会事半功倍。

5.对于供应链，你有什么优势

6.对供应链有什么了解

阿里的供应链系统分为上下游两个部分，上游涉及业务决策层，包括商品、价格、营销活动、营销策略、供应链计划等模块，上游会将结果传输到供应链的下游模块，包括订单情况、库存管理、补货调拨的动作等，然后上下游协同起来构成了整个系统的架构体系。

包括前期的备货、爆款下沉等准备事项、流量调控、销量预测、补货调拨、以及仓、配履行等多个环节

二、框架相关

3.springboot的自动装配原理 （或者如何理解SpringBootApplication）

在springboot主启动类上有@SpringBootApplication注解，@SpringBootApplication是一个复合注解
它包括：@SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan以上三个注解在内部只做一件事情把bean注册到springioc容器。

@SpringBootConfiguration： 负责把@Configuration+@Bean的方式的bean注入到ioc容器中。

@ComponentScan：负责将指定包下含有特定注解的类，（比如：@Service、@Component、@Repository、@Controller等），通过扫描放入到ioc容器中。

@EnableAutoConfiguration：通过spring.factories的配置，来实现bean的注册到springioc容器中。

4.IOC

关键词：超级大工厂，对象控制权，解耦对象间的依赖关系

超级大工厂，对象控制权由调用者移交给容器，使得调用者不必关心对象的创建和管理，专注于业务逻辑开发；
优秀的解耦方式，解耦对象间的依赖关系，避免通过硬编码的方式耦合在一起；
底层实现：反射机制；
(1). IoC（Inversion of Control）是指容器控制程序对象之间的关系，而不是传统实现中，由程序代码直接操控。控制权由应用代码中转到了外部容器，控制权的转移是所谓反转。 对于Spring而言，就是由Spring来控制对象的生命周期和对象之间的关系；IoC还有另外一个名字——“依赖注入（Dependency Injection）”。从名字上理解，所谓依赖注入，即组件之间的依赖关系由容器在运行期决定，即由容器动态地将某种依赖关系注入到组件之中。

(2). 在Spring的工作方式中，所有的类都会在spring容器中登记，告诉spring这是个什么东西，你需要什么东西，然后spring会在系统运行到适当的时候，把你要的东西主动给你，同时也把你交给其他需要你的东西。所有的类的创建、销毁都由 spring来控制，也就是说控制对象生存周期的不再是引用它的对象，而是spring。对于某个具体的对象而言，以前是它控制其他对象，现在是所有对象都被spring控制，所以这叫控制反转。

(3). 在系统运行中，动态的向某个对象提供它所需要的其他对象。

(4). 依赖注入的思想是通过反射机制实现的，在实例化一个类时，它通过反射调用类中set方法将事先保存在HashMap中的类属性注入到类中。 总而言之，在传统的对象创建方式中，通常由调用者来创建被调用者的实例，而在Spring中创建被调用者的工作由Spring来完成，然后注入调用者，即所谓的依赖注入or控制反转。 注入方式有两种：依赖注入和设置注入； IoC的优点：降低了组件之间的耦合，降低了业务对象之间替换的复杂性，使之能够灵活的管理对象。

5.AOP

关键词：模块化、交叉关注点、横切性质的系统级业务

一种新的模块化方式，专门处理系统各模块中的交叉关注点问题，将具有横切性质的系统级业务提取到切面中，与核心业务逻辑分离(解耦)；
便于系统的扩展，符合开-闭原则；
动态AOP的实现，Java动态代理(接口代理)与cglib(类代理)，具体由Bean后处理器生成代理；

AOP理念实践：Spring AOP，Java Web Filter，Struts2 Interceptor， SpringMVC Interceptor，…

(1). AOP面向方面编程基于IoC，是对OOP的有益补充；

(2). AOP利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了 多个类的公共行为封装到一个可重用模块，并将其名为“Aspect”，即方面。所谓“方面”，简单地说，就是将那些与业务无关，却为业务模块所共同调用的 逻辑或责任封装起来，比如日志记录，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。

(3). AOP代表的是一个横向的关 系，将“对象”比作一个空心的圆柱体，其中封装的是对象的属性和行为；则面向方面编程的方法，就是将这个圆柱体以切面形式剖开，选择性的提供业务逻辑。而 剖开的切面，也就是所谓的“方面”了。然后它又以巧夺天功的妙手将这些剖开的切面复原，不留痕迹，但完成了效果。

(4). 实现AOP的技术，主要分为两大类：一是采用动态代理技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行；二是采用静态织入的方式，引入特定的语法创建“方面”，从而使得编译器可以在编译期间织入有关“方面”的代码。

(5). Spring实现AOP：JDK动态代理和CGLIB代理 JDK动态代理：其代理对象必须是某个接口的实现，它是通过在运行期间创建一个接口的实现类来完成对目标对象的代理；其核心的两个类是InvocationHandler和Proxy。 CGLIB代理：实现原理类似于JDK动态代理，只是它在运行期间生成的代理对象是针对目标类扩展的子类。CGLIB是高效的代码生成包，底层是依靠ASM（开源的java字节码编辑类库）操作字节码实现的，性能比JDK强；需要引入包asm.jar和cglib.jar。 使用AspectJ注入式切面和@AspectJ注解驱动的切面实际上底层也是通过动态代理实现的。

6.bean的生命周期

1. Spring启动，查找并加载需要被Spring管理的bean，进行Bean的实例化
2. Bean实例化后对将Bean的引入和值注入到Bean的属性中
3. 如果Bean实现了BeanNameAware接口的话，Spring将Bean的Id传递给setBeanName()方法
4. 如果Bean实现了BeanFactoryAware接口的话，Spring将调用setBeanFactory()方法，将BeanFactory容器实例传入
5. 如果Bean实现了ApplicationContextAware接口的话，Spring将调用Bean的setApplicationContext()方法，将bean所在应用上下文引用传入进来
6. 如果Bean实现了BeanPostProcessor接口，Spring就将调用他们的postProcessBeforeInitialization()方法。
7. 如果Bean现了InitializingBean接口，Spring将调用他们的afterPropertiesSet()方法。类似的，如果bean使用init-method声明了初始化方法，该方法也会被调用
8. 如果Bean实现了BeanPostProcessor接口，Spring就将调用他们的postProcessAfterInitialization()方法。
9. 此时，Bean已经准备就绪，可以被应用程序使用了。他们将一直驻留在应用上下文中，直到应用上下文被销毁。
10. 如果bean实现了DisposableBean接口，Spring将调用它的destory()接口方法，同样，如果bean使用了destory-method
11. 声明销毁方法，该方法也会被调用。

补充1 spring和spring boot的区别

1、Spring Boot提供极其快速和简化的操作，让 Spring 开发者快速上手。
2、Spring Boot提供了 Spring 运行的默认配置。
3、Spring Boot为通用 Spring项目提供了很多非功能性特性，例如：嵌入式 Serve、Security、统计、健康检查、外部配置等等。

补充2 #{}和${}区别

#{}：占位符号，构造预编译sql语句，好处防止sql注入
${}：sql拼接符号,直接从参数中取值，构造静态sql语句

2021/6/2补充 举例scope

1）singleton （单一实例）
此取值时表明容器中创建时只存在一个实例，所有引用此bean都是单一实例。如同每个国家都有一个总统，国家的所有人共用此总统，而这个国家就是一个spring容器，总统就是spring创建的类的bean，国家中的人就是其它调用者，总统是一个表明其在spring中的scope为singleton，也就是单例模型。
此外，singleton类型的bean定义从容器启动到第一次被请求而实例化开始，只要容器不销毁或退出，该类型的bean的单一实例就会一直存活，典型单例模式，如同servlet在web容器中的生命周期。
2）prototype
spring容器在进行输出prototype的bean对象时，会每次都重新生成一个新的对象给请求方，虽然这种类型的对象的实例化以及属性设置等工作都是由容器负责的，但是只要准备完毕，并且对象实例返回给请求方之后，容器就不在拥有当前对象的引用，请求方需要自己负责当前对象后继生命周期的管理工作，包括该对象的销毁。也就是说，容器每次返回请求方该对象的一个新的实例之后，就由这个对象“自生自灭”，最典型的体现就是spring与struts2进行整合时，要把action的scope改为prototype。
如同分苹果，将苹果的bean的scope属性声明为prototype，在每个人领取苹果的时候，我们都是发一个新的苹果给他，发完之后，别人爱怎么吃就怎么吃，爱什么时候吃什么时候吃，但是注意吃完要把苹果核扔到垃圾箱！对于那些不能共享使用的对象类型，应该将其定义的scope设为prototype。
3）request
再次说明request，session和global session类型只实用于web程序，通常是和XmlWebApplicationContext共同使用。

Spring容器，即XmlWebApplicationContext 会为每个HTTP请求创建一个全新的RequestPrecessor对象，当请求结束后，该对象的生命周期即告结束，如同java web中request的生命周期。当同时有100个HTTP请求进来的时候，容器会分别针对这10个请求创建10个全新的RequestPrecessor实例，且他们相互之间互不干扰，简单来讲，request可以看做prototype的一种特例，除了场景更加具体之外，语意上差不多。
4）session
对于web应用来说，放到session中最普遍的就是用户的登录信息，对于这种放到session中的信息，我们可以使用如下形式的制定scope为session：

Spring容器会为每个独立的session创建属于自己的全新的UserPreferences实例，比request scope的bean会存活更长的时间，其他的方面没区别，如果java web中session的生命周期。
5）global session

global session只有应用在基于porlet的web应用程序中才有意义，它映射到porlet的global范围的session，如果普通的servlet的web 应用中使用了这个scope，容器会把它作为普通的session的scope对待。

三、数据库相关

7.数据库的存储引擎

MySQL常见的三种存储引擎为InnoDB、MyISAM和MEMORY。

8.mysql的索引

1).普通索引：普通索引是最基本的索引，它没有任何限制，允许在定义索引的列中插入重复值和空值
2).唯一索引：索引列的值必须唯一，允许有空值，如果是组合索引，列值的组合必须唯一
3).主键索引：主键索引是一种特殊的唯一索引，一个表只能有一个主键，不允许有空值，一般是在创建表的时候指定主键，主键默认就是主键索引
4）组合索引：多个字段上创建的索引，只有在查询条件中使用了创建索引时的第一个字段，索引才会被使用
5).全文索引 6).空间索引

9.为什么使用b+树作为索引

如果采用Hash表，范围查找需要全表扫描；如果采用二叉查找树，由于无法保证平衡，可能退化为链表；如果采用平衡二叉树，通过旋转解决了平衡的问题，但是旋转操作效率太低；如果采用红黑树，树太高，IO次数多；如果采用普通B树，节点要存数索引和数据，一个内存页可存储的数据还是少，另外范围查找也需要多次IO；

b+树是一个多路平衡查找树，它只有叶子结点存数据，减少IO次数，每次都会查到叶子，查找性能稳定，底层是双向链表，便于范围查找（b+树一般1-3层就可以实现千万级别的数据查找，为什么不用4-5层支持上亿级别的数据？ 一般单表不会支持那么多数据，要进行分表）

10.事务的ACID、隔离级别有哪些，这些隔离级别有什么问题，幻读是如何解决的

（1）原子性：事务包含的所有数据库操作要么全部成功，要不全部失败回滚
（2）一致性：一个事务执行之前和执行之后都必须处于一致性状态。拿转账来说，假设用户A和用户B两者的钱加起来一共是5000，那么不管A和B之间如何转账，转几次账，事务结束后两个用户的钱相加起来应该还得是5000，这就是事务的一致性。
（3）隔离性：一个事务未提交的业务结果是否对于其它事务可见。
（4）持久性：一个事务一旦被提交了，那么对数据库中数据的改变就是永久性的，即便是在数据库系统遇到故障的情况下也不会丢失提交事务的操作。

隔离级别（读不提交，读提交、可重复读、串行）

不可重复读和脏读的区别是：脏读是某一事务读取了另一个事务未提交的脏数据，而不可重复读则是读取了前一事务提交的数据。

幻读和不可重复读都是读取了另一条已经提交的事务（这点就脏读不同），所不同的是不可重复读查询的都是同一个数据项，而幻读针对的是一批数据整体（比如数据的个数）。事务T1对一个表中所有的行的某个数据项做了从“1”修改为“2”的操作，这时事务T2又对这个表中插入了一行数据项，而这个数据项的数值还是为“1”并且提交给数据库。而操作事务T1的用户如果再查看刚刚修改的数据，会发现还有一行没有修改，其实这行是从事务T2中添加的，就好像产生幻觉一样，这就是发生了幻读。

11.索引是用什么来存的

b+树

12.主索引和普通索引叶子有什么区别

主键索引也被称为聚簇索引,叶子节点存放的是整行数据; 而非主键索引被称为二级索引,叶子节点存放的是主键的值.
如果根据主键查询, 只需要搜索这棵B+树
而如果通过非主键索引查询, 需要先搜索k索引树, 找到对应的主键, 然后再到ID索引树搜索一次, 这个过程叫做回表.
总结, 非主键索引的查询需要多扫描一颗索引树, 效率相对更低.

13.什么时候不需要回表

使用覆盖索引，只需要在一棵辅助索引树上就可以获取SQL所需要的所有列数据，不需要回表

14.联合索引的最左（前缀）匹配原则

在MySQL建立联合索引时会遵守最左前缀匹配原则，即最左优先，在检索数据时从联合索引的最左边开始匹配。这是因为索引的底层是一颗B+树，那么联合索引的底层也是一颗B+树，只不过联合索引的B+树节点中存储的是键值。由于构建一棵B+树只能根据一个值来确定索引关系，所以数据库依赖联合索引最左的字段来构建。

15.建立索引怎么确定哪个字段在前面

16.mysql和聚簇索引和非聚簇索引

聚集索引：聚集索引确定表中数据的物理顺序，一个表中只能包含一个聚集索引，但该索引可以包含多个列，聚集索引对于经常要搜索范围值的列特别有效，使用聚集索引找到包含第一个值的行后，便可以确保包含后续索引值的行在物理相邻

聚集索引中索引的叶节点就是数据节点，而非聚集索引的叶节点仍然是索引节点，只不过有一个指针指向相应的数据块

17.所有的存储引擎都有表锁和行锁吗，什么时候使用表锁，什么时候使用行锁

Innodb只有在你增删改查时匹配的条件字段带有索引时，innodb才会使用行级锁，在你增删改查时匹配的条件字段不带有索引时，innodb使用的将是表级锁。因为当你匹配条件字段不带有所引时，数据库会全表查询，所以这需要将整张表加锁,才能保证查询匹配的正确性。在生产环境中我们往往需要满足多人同时对一张表进行增删改查，所以就需要使用行级锁，所以这个时候一定要记住为匹配条件字段加索引。

18.什么是MVCC

MVCC，多版本并发控制。主要是为了提高数据库并发性能，用更好的方式去处理读-写冲突，做到即使有读写冲突时，也能做到不加锁，非阻塞并发读。 它的实现原理主要是依赖记录中的 3个隐式字段，undo日志 ，Read View 来实现的。

19.mysql的主从同步原理

当master(主)库的数据发生变化的时候，变化会实时的同步到slave(从)库。所有的操作都在master上。当master有操作的时候,slave会快速的接收到这些操作，从而做同步。在master机器上，主从同步事件会被写到特殊的log文件中(binary-log);在slave机器上，slave读取主从同步事件，并根据读取的事件变化，在slave库上做相应的更改。

20.索引设计的原则

（1）索引并非越多越好
（2）避免对经常更新的表创建过多的索引，索引中的列要尽可能的小；经常要查询的字段应该创建索引，但是要避免添加不必要的字段
（3）数据量小的表最好不要使用索引
（4）在条件表达式中经常用到的不同值较多的列上建立索引，在不同值少的列上不要建立索引
（5）当唯一性是某种数据本身的特性时，建立唯一索引
（6）在频繁进行排序或者分组的列上建立索引

补充1.三大范式，哪个更严格

1、第一范式（1NF）
　　要求：强调的是列的原子性，即每一列都是不可再分的最小数据单元。
2、第二范式（2NF）
　　要求：
　　1、满足1NF；
　　2、表必须有一个主键；
　　3、对于没有包含在主键中的列（非主键的其他列）必须完全依赖于主键，而不能只依赖于主键的一部分（比如某一个主键）。
3、第三范式(3NF)
　　要求：
　　1、满足2NF；
　　2、非主键列必须直接依赖于主键，不能存在传递依赖。即不能存在：非主键列 A 依赖于非主键列 B，非主键列 B 依赖于主键的情况。

补充2.group by，having，where 执行顺序

Group By 和 Having, Where ,Order by这些关键字是按照如下顺序进行执行的：Where, Group By, Having, Order by。
粗浅的理解的话，
SELECT的语法顺序就是起执行顺序
FROM
WHERE （先过滤单表／视图／结果集，再JOIN）
GROUP BY
HAVING （WHERE过滤的是行，HAVING过滤的是组，所以在GROUP之后）
ORDER BY

四、JVM相关

21.JVM的内存结构（运行时数据区）

JVM 内存共分为虚拟机栈，堆，方法区，程序计数器，本地方法栈五个部分。

程序计数器(线程私有)：
是当前线程锁执行字节码的行号指示器，每条线程都有一个独立的程序计数器，这类内存也称为“线程私有”的内存。正在执行java方法的话，计数器记录的是虚拟机字节码指令的地址(当前指令的地址)。如果是Native方法，则为空。

java 虚拟机栈（线程私有）
实际上，Java虚拟机栈是由一个个栈帧组成，而每个栈帧中都拥有：局部变量表、操作数栈、动态链接、方法出口信息。每个方法从调用到执行完毕，对应一个栈帧在虚拟机栈中的入栈和出栈。
如果线程请求的栈深度大于虚拟机所允许的深度，则StackOverflowError。
如果虚拟机栈可以动态扩展，扩展到无法申请足够的内存，则OutOfMemoryError。

本地方法栈（线程私有）
和虚拟机栈类似，主要为虚拟机使用到的Native方法服务。也会抛出StackOverflowError 和OutOfMemoryError

Java堆（线程共享）
Java 虚拟机所管理的内存中最大的一块，Java 堆是所有线程共享的一块内存区域，在虚拟机启动时创建。此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例以及数组都在这里分配内存。Java 堆是垃圾收集器管理的主要区域，因此也被称作GC堆（Garbage Collected Heap）.从垃圾回收的角度，由于现在收集器基本都采用分代垃圾收集算法，所以Java堆还可以细分为：新生代和老年代：新生代再细致一点有：Eden空间、From Survivor、To Survivor空间等。进一步划分的目的是更好地回收内存，或者更快地分配内存。

方法区/元空间
方法区与 Java 堆一样，是各个线程共享的内存区域，它用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。JDK 1.8 的时候，方法区被彻底移除了（JDK1.7就已经开始了），取而代之是元空间，元空间使用的是直接内存。另外，JVM 已经将运行时常量池从方法区中移了出来，在 Java 堆（Heap）中开辟了一块区域存放运行时常量池。

22.垃圾回收算法

（1）判断一个对象是不是个垃圾
引用计数法：通过引用计数来判断一个对象是否可以被回收，当计数为0的时候回收。引用计算法无法解决循环引用的问题。
可达性分析法：通过一系列的“GC Roots”对象作为起点进行搜索，如果在“GC Roots”和一个对象之间没有可达路径，则称该对象是不可达的，不过要注意的是被判定为不可达的对象不一定就会成为可回收对象。被判定为不可达的对象要成为可回收对象必须至少经历两次标记过程，如果在这两次标记过程中仍然没有逃脱成为可回收对象的可能性，则基本上就真的成为可回收对象了。
（2）可以作为GC Roots的对象
虚拟机栈中栈桢中的局部变量（也叫局部变量表）中引用的对象
方法区中类的静态变量、常量引用的对象
本地方法栈中 JNI (Native方法)引用的对象
（3）强弱软虚引用
强引用：不回收。就算报OOM错也不回收，要回收要先弱化
软引用：内存不够就回收。一个应用需要读取大量的本地图片，如果每次读取都从硬盘读取会严重影响性能，如果一次性全部加载到内存，内存可能会溢出。可以使用软引用解决这个问题，使用一个HashMap来保存图片路径和图片对象管理的软引用之间的映射关系，内存不足时，JVM会自动回收缓存图片对象的占用空间，有效地避免了OOM（Out Of Memory）问题。
弱引用：一定回收。具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。
虚引用：一定回收，get出来就是null，引用形同虚设，主要和引用队列联合使用，在finalize之前会被放到引用队列中。
（4）垃圾回收算法
标记清除：在标记阶段首先通过根节点(GC Roots)，标记所有从根节点开始的对象，未被标记的对象就是未被引用的垃圾对象。然后，在清除阶段，清除所有未被标记的对象。标记-清除算法实现起来比较容易，但是有一个比较严重的问题就是容易产生内存碎片，碎片太多可能会导致后续过程中需要为大对象分配空间时无法找到足够的空间而提前触发新的一次垃圾收集动作
复制：为了解决Mark-Sweep算法的缺陷，Copying算法就被提了出来。它将可用内存按容量划分为大小相等的两块，每次只使用其中的一块。当这一块的内存用完了，就将还存活着的对象复制到另外一块上面，然后再把已使用的内存空间一次清理掉，这样一来就不容易出现内存碎片的问题，这种算法虽然实现简单，运行高效且不容易产生内存碎片，但是却对内存空间的使用做出了高昂的代价，因为能够使用的内存缩减到原来的一半。很显然，Copying算法的效率跟存活对象的数目多少有很大的关系，如果存活对象很多，那么Copying算法的效率将会大大降低。
标记整理：为了解决Copying算法的缺陷，充分利用内存空间，提出了Mark-Compact算法。该算法标记阶段和Mark-Sweep一样，但是在完成标记之后，它不是直接清理可回收对象，而是将存活对象都向一端移动，然后清理掉端边界以外的内存。
分代收集：分代收集算法是目前大部分JVM的垃圾收集器采用的算法。它的核心思想是根据对象存活的生命周期将内存划分为若干个不同的区域。一般情况下将堆区划分为老年代（Tenured Generation）和新生代（Young Generation），老年代的特点是每次垃圾收集时只有少量对象需要被回收，而新生代的特点是每次垃圾回收时都有大量的对象需要被回收，那么就可以根据不同代的特点采取最适合的收集算法。

目前大部分垃圾收集器对于新生代都采取复制算法，因为新生代中每次垃圾回收都要回收大部分对象，也就是说需要复制的操作次数较少，但是实际中并不是按照1：1的比例来划分新生代的空间的，一般来说是将新生代划分为一块较大的Eden空间和两块较小的Survivor空间，每次使用Eden空间和其中的一块Survivor空间，当进行回收时，将Eden和Survivor中还存活的对象复制到另一块Survivor空间中，然后清理掉Eden和刚才使用过的Survivor空间。而由于老年代的特点是每次回收都只回收少量对象，一般使用的是标记-整理算法。

23.垃圾回收器

CMS GC

虽然 JDK 9 已经宣布废除 CMS 垃圾收集器，但 CMS 却是 JDK 8 以前（包含JDK8） 的追求低延迟 GC 的不错的可选项

年轻代垃圾回收
同一时间内新生代内存只会使用Eden区和一个幸存区，垃圾回收时会将Eden区和幸存区中的存活对象被拷贝到另一个空的幸存区，当新生代对象存活时间达到阈值，对象会被提升到老年代

当老年代内存占用率达到一定比率时，CMS垃圾回收器就开始工作。
老年代垃圾回收会经历4个过程：
初始标记 ：标记GC Roots能直接关联到的对象，需要安全点暂停所有执行线程。
并发标记 ：进行GC Roots Tracing，遍历完从root可达的所有对象。该阶段与工作线程并发执行。
重新标记 ：修正并发标记期间因用户程序继续运作而导致标记产生表动的那一部分对象的标记记录。需要在安全点位置暂停所有执行线程。
并发清理 ：内存回收阶段，将死亡的内存对象占用的空间增加到一个空闲列表(free list),供以后的分配使用。
重置 ：清理数据结构,为下一个并发收集做准备。

G1 GC

在G1算法中，采用了另外一种完全不同的方式组织堆内存，堆内存被划分为多个大小相等的内存块（Region），每个Region是逻辑连续的一段内存，结构如下

每个Region被标记了E、S、O和H，说明每个Region在运行时都充当了一种角色，其中H是以往算法中没有的，它代表Humongous，这表示这些Region存储的是巨型对象（humongous object，H-obj），当新建对象大小超过Region大小一半时，直接在新的一个或多个连续Region中分配，并标记为H。

G1中提供了三种模式垃圾回收模式，young gc、mixed gc 和 full gc，在不同的条件下被触发

发生在年轻代的GC算法，一般对象（除了巨型对象）都是在eden region中分配内存，当所有eden region被耗尽无法申请内存时，就会触发一次young gc，这种触发机制和之前的young gc差不多，执行完一次young gc，活跃对象会被拷贝到survivor region或者晋升到old region中，空闲的region会被放入空闲列表中，等待下次被使用。

当越来越多的对象晋升到老年代old region时，为了避免堆内存被耗尽，虚拟机会触发一个混合的垃圾收集器，即mixed gc，该算法并不是一个old gc，除了回收整个young region，还会回收一部分的old region，这里需要注意：是一部分老年代，而不是全部老年代，可以选择哪些old region进行收集，从而可以对垃圾回收的耗时时间进行控制。

initial mark: 初始标记过程，整个过程STW，标记了从GC Root可达的对象
concurrent marking: 并发标记过程，整个过程gc collector线程与应用线程可以并行执行，标记出GC Root可达对象衍生出去的存活对象，并收集各个Region的存活对象信息
remark: 最终标记过程，整个过程STW，标记出那些在并发标记过程中遗漏的，或者内部引用发生变化的对象
clean up: 垃圾清除过程，如果发现一个Region中没有存活对象，则把该Region加入到空闲列表中

如果对象内存分配速度过快，mixed gc来不及回收，导致老年代被填满，就会触发一次full gc，G1的full gc算法就是单线程执行的serial old gc，会导致异常长时间的暂停时间，需要进行不断的调优，尽可能的避免full gc.

24.类的生命周期及其初始化时机（类加载机制）

类的生命周期主要包括加载、链接、初始化、使用和卸载五个阶段，如下图所示：

类加载指其中的 加载、连接和初始化
1、 加载（Loading）
　　(1). 通过一个类的全限定名来获取定义此类的二进制字节流（并没有指明要从一个Class文件中获取，可以从其他渠道，譬如：网络、动态生成、数据库等）；
　　(2). 将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构；
　　(3). 在内存中(对于HotSpot虚拟就而言就是方法区)生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口；
2、 验证（Verification）：验证是连接阶段的第一步，这一阶段的目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。
3、准备(Preparation)：准备阶段是正式为类变量(static 成员变量)分配内存并设置类变量初始值（零值）的阶段，这些变量所使用的内存都将在方法区中进行分配。
4、解析(Resolution)：解析阶段是虚拟机将常量池内的符号引用替换为直接引用的过程。
5、初始化(Initialization)：初始化阶段是执行类构造器()方法的过程。虚拟机会保证一个类的类构造器()在多线程环境中被正确的加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的类构造器()，其他线程都需要阻塞等待，直到活动线程执行()方法完毕。特别需要注意的是，在这种情形下，其他线程虽然会被阻塞，但如果执行()方法的那条线程退出后，其他线程在唤醒之后不会再次进入/执行()方法，因为 在同一个类加载器下，一个类型只会被初始化一次。

类加载的时机
　1).使用new关键字实例化对象的时候；读取或设置一个类的静态字段（被final修饰，已在编译器把结果放入常量池的静态字段除外）的时候；调用一个类的静态方法的时候。
　2). 对类进行反射调用时：使用java.lang.reflect包的方法对类进行反射调用的时候，如果类没有进行过初始化，则需要先触发其初始化。
　3). 初始化子类时：当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。
　4). 虚拟机启动时：当虚拟机启动时，用户需要指定一个要执行的主类（包含main()方法的那个类），虚拟机会先初始化这个主类。

25.双亲委派

Java提供了三个ClassLoader：

1，BootstrapClassLoader
用于加载JAVA核心类库，也就是环境变量的%JRE_HOME%\lib下的rt.jar、resources.jar、charsets.jar等。

在JVM启动时加入-Xbootclasspath参数，可以把对应路径也加载到Bootstrap的路径列表中来，这个参数有两种用法：

1)，-Xbootclasspath/a:{人工指定路径}，把对应路径加载到Bootstrap默认路径后面，也就是说，如果有class重复，以Bootstrap默认路径下的类为准（因为是按照路径列表顺序加载的），举例：

java -Xbootclasspath/a:D:\test\Test.jar

2)，-Xbootclasspath/p: {人工指定路径}，把对应路径加载到Bootstrap默认路径后面，也就是说，如果有class重复，以指定路径下的类为准，举例：

java -Xbootclasspath/p:D:\test\Test.jar

2，Extention ClassLoader
扩展类加载器，加载环境变量%JRE_HOME%\lib\ext目录下的class文件

这个加载器也可以在JVM启动时使用参数改变加载的行为，参数是-D java.ext.dirs=，作用是替换Java扩展类加载器所加载的文件目录。

注意，该参数是替换而不是追加，因为这个加载器的加载路径只有一个，也就是说，%JRE_HOME%\lib\ext是扩展类加载器的默认路径，如果我们在启动时使用-Djava.ext.dirs=d:/test，那么java就不再加载%JRE_HOME%\lib\ext路径下的文件。

3，AppclassLoader
加载classpath中的class类，通过在JVM启动命令中的-classpath参数指定路径，可以指定绝对路径、相对路径、环境变量等，举例：

java –classpath %CLASSPATH%

向上委派:查找缓存，是否加载该类，有则直接返回，没有继续向上
向下查找：查找加载路径，有则加载返回，没有则继续向下查找

保证安全性，避免类的重复加载，jvm中区分不同类，不仅仅根据类型名，相同的class文件被不同的ClassLoad加载就是不同的类

26.异常体系

最顶级的父类Throwable
下面有两个子类Exception和Error
Error是程序无法处理的错误，一旦出现这个错误，则程序被迫停止
Exception不会导致程序停止又分为运行时异常和检测异常，RuntimeException发生在程序运行过程中会导致程序当前线程执行失败，CheckException编译不通过。

五、并发相关

27.线程的生命周期，有哪些状态

创建、就绪、运行、阻塞、死亡
创建：新建一个线程对象
就绪：线程变成可运行，等待获得cpu的使用权
运行：就绪状态获取cpu执行代码
阻塞：由于某些原因放弃cpu使用权，暂时停止运行，知道进入就绪，才有机会转到运行状态
死亡：线程执行完或者发生错误退出run方法，结束生命周期

28.sleep、wait、join、yield

锁池：需要竞争同步锁的线程都会放在锁池
等待池：调用wait方法，线程放到等待池中，等待池的线程不会竞争锁，只有调用notify（）或者notifyall（）等待池放到锁池中

sleep是thread类的静态本地方法
wait是object类的本地方法
sleep不会释放锁，但wait会释放，而且会加入等待队列中
sleep不依赖synchronize，wait依赖
sleep不需要被唤醒，wait需要
sleep一般用于当前线程休眠 wait多用于多线程通信
sleep会让出cpu，并做进程上下文的切换

yield执行后线程直接进入就绪状态
join执行后线程进入阻塞状态，例如在b中调用a的join（）则b进入阻塞，知道a线程执行完或中断

29.乐观锁和悲观锁

悲观锁做事比较悲观，它认为多线程同时修改共享资源的概率比较高，于是很容易出现冲突，所以访问共享资源前，先要上锁。
相反的，如果多线程同时修改共享资源的概率比较低，就可以采用乐观锁。
乐观锁做事比较乐观，它假定冲突的概率很低，它的工作方式是：先修改完共享资源，再验证这段时间内有没有发生冲突，如果没有其他线程在修改资源，那么操作完成，如果发现有其他线程已经修改过这个资源，就放弃本次操作。

30.synchronize的优化以及锁升级过程，与ReentrantLock的区别

31.介绍一下CAS

CAS，是Compare and Swap的简称，在这个机制中有三个核心的参数：

主内存中存放的共享变量的值：V（一般情况下这个V是内存的地址值，通过这个地址可以获得内存中的值）
工作内存中共享变量的副本值，也叫预期值：A
需要将共享变量更新到的最新值：B

主存中保存V值，线程中要使用V值要先从主存中读取V值到线程的工作内存A中，然后计算后变成B值，最后再把B值写回到内存V值中。多个线程共用V值都是如此操作。CAS的核心是在将B值写入到V之前要比较A值和V值是否相同，如果不相同证明此时V值已经被其他线程改变，重新将V值赋给A，并重新计算得到B，如果相同，则将B值赋给V。

值得注意的是CAS机制中的这步步骤是原子性的（从指令层面提供的原子操作），所以CAS机制可以解决多线程并发编程对共享变量读写的原子性问题。

缺点

1. ABA问题
   ABA问题：CAS在操作的时候会检查变量的值是否被更改过，如果没有则更新值，但是带来一个问题，最开始的值是A，接着变成B，最后又变成了A。经过检查这个值确实没有修改过，因为最后的值还是A，但是实际上这个值确实已经被修改过了。为了解决这个问题，在每次进行操作的时候加上一个版本号，每次操作的就是两个值，一个版本号和某个值，A——>B——>A问题就变成了1A——>2B——>3A。在jdk中提供了AtomicStampedReference类解决ABA问题，用Pair这个内部类实现，包含两个属性，分别代表版本号和引用，在compareAndSet中先对当前引用进行检查，再对版本号标志进行检查，只有全部相等才更新值。

2. 可能会消耗较高的CPU
   看起来CAS比锁的效率高，从阻塞机制变成了非阻塞机制，减少了线程之间等待的时间。每个方法不能绝对的比另一个好，在线程之间竞争程度大的时候，如果使用CAS，每次都有很多的线程在竞争，也就是说CAS机制不能更新成功。这种情况下CAS机制会一直重试，这样就会比较耗费CPU。因此可以看出，如果线程之间竞争程度小，使用CAS是一个很好的选择；但是如果竞争很大，使用锁可能是个更好的选择。在并发量非常高的环境中，如果仍然想通过原子类来更新的话，可以使用AtomicLong的替代类：LongAdder。

3. 不能保证代码块的原子性
   Java中的CAS机制只能保证共享变量操作的原子性，而不能保证代码块的原子性。

优点
可以保证变量操作的原子性；
并发量不是很高的情况下，使用CAS机制比使用锁机制效率更高；
在线程对共享资源占用时间较短的情况下，使用CAS机制效率也会较高。

CAS使用场景
使用一个变量统计网站的访问量；
Atomic类操作；
数据库乐观锁更新。

Java提供的CAS操作类–Unsafe类

32.介绍一下AQS，哪些并发类是基于它的

AQS：也就是队列同步器，这是实现 ReentrantLock 的基础。
AQS 有一个 state 标记位，值为1 时表示有线程占用，其他线程需要进入到同步队列等待，同步队列是一个双向链表。

当获得锁的线程需要等待某个条件时，会进入 condition 的等待队列，等待队列可以有多个。
当 condition 条件满足时，线程会从等待队列重新进入同步队列进行获取锁的竞争。
ReentrantLock 就是基于 AQS 实现的，如下图所示，ReentrantLock 内部有公平锁和非公平锁两种实现，差别就在于新来的线程是否比已经在同步队列中的等待线程更早获得锁。

ReentrantLock里面有一个内部类Sync，Sync继承AQS（AbstractQueuedSynchronizer），添加锁和释放锁的大部分操作实际上都是在Sync中实现的。
它有公平锁FairSync和非公平锁NonfairSync两个子类。
ReentrantLock默认使用非公平锁，也可以通过构造器来显示的指定使用公平锁。
和 ReentrantLock 实现方式类似，Semaphore 也是基于 AQS 的，差别在于 ReentrantLock 是独占锁，Semaphore 是共享锁。

33.介绍一下ThreadLocal

ThreadLocal是解决线程安全问题一个很好的思路，它通过为每个线程提供一个独立的变量副本解决了变量并发访问的冲突问题。在很多情况下，ThreadLocal比直接使用synchronized同步机制解决线程安全问题更简单，更方便，且结果程序拥有更高的并发性。变量在每个线程中都有独立拷贝，不会出现一个线程读取变量时而被另一个线程修改的现象。最常见的ThreadLocal使用场景为用来解决数据库连接、Session管理等。
在每个线程Thread内部有一个ThreadLocal.ThreadLocalMap类型的成员变量threadLocals，这个threadLocals就是用来存储实际的变量副本的，键值为当前ThreadLocal变量，value为变量副本（即T类型的变量）。 初始时，在Thread里面，threadLocals为空，当通过ThreadLocal变量调用get()方法或者set()方法，就会对Thread类中的threadLocals进行初始化，并且以当前ThreadLocal变量为键值，以ThreadLocal要保存的副本变量为value，存到threadLocals。 然后在当前线程里面，如果要使用副本变量，就可以通过get方法在threadLocals里面查找。

实际的通过ThreadLocal创建的副本是存储在每个线程自己的threadLocals中的；
为何threadLocals的类型ThreadLocalMap的键值为ThreadLocal对象，因为每个线程中可有多个threadLocal变量.
在进行get之前，必须先set，否则会报空指针异常；如果想在get之前不需要调用set就能正常访问的话，必须重写initialValue()方法。 因为在上面的代码分析过程中，我们发现如果没有先set的话，即在map中查找不到对应的存储，则会通过调用setInitialValue方法返回i，而在setInitialValue方法中，有一个语句是T value = initialValue()， 而默认情况下，initialValue方法返回的是null。

34.线程和进程的区别

进程是资源分配的最小单位，线程是CPU调度的最小单位

做个简单的比喻：进程=火车，线程=车厢线程在进程下行进（单纯的车厢无法运行）一个进程可以包含多个线程（一辆火车可以有多个车厢）不同进程间数据很难共享（一辆火车上的乘客很难换到另外一辆火车，比如站点换乘）同一进程下不同线程间数据很易共享（A车厢换到B车厢很容易）进程要比线程消耗更多的计算机资源（采用多列火车相比多个车厢更耗资源）进程间不会相互影响，一个线程挂掉将导致整个进程挂掉（一列火车不会影响到另外一列火车，但是如果一列火车上中间的一节车厢着火了，将影响到所有车厢）进程可以拓展到多机，进程最多适合多核（不同火车可以开在多个轨道上，同一火车的车厢不能在行进的不同的轨道上）进程使用的内存地址可以上锁，即一个线程使用某些共享内存时，其他线程必须等它结束，才能使用这一块内存。（比如火车上的洗手间）－"互斥锁"进程使用的内存地址可以限定使用量（比如火车上的餐厅，最多只允许多少人进入，如果满了需要在门口等，等有人出来了才能进去）－“信号量”

2021/6/2补充

34.1线程哪些资源是共享的，哪些是独立的？

线程共享的资源包括：
（1） 进程代码段

（2） 进程的公有数据（利用这些数据，线程很容易实现相互之间的通讯）

（3） 进程的所拥有资源。

线程独立的资源包括：
（1）线程ID：每个线程都有自己唯一的ID，用于区分不同的线程。

（2）寄存器组的值：当线程切换时，必须将原有的线程的寄存器集合的状态保存，以便重新切换时得以恢复。

（3）线程的堆栈：堆栈是保证线程独立运行所必须的。

（4）错误返回码：由于同一个进程中有很多个线程同时运行，可能某个线程进行系统调用后设置了error值，而在该线程还没有处理这个错误，另外一个线程就在此时被调度器投入运行，这样错误值就有可能被修改。所以，不同的线程应该拥有自己的错误返回码变量。

（5）线程优先级：线程调度的次序（并不是优先级大的一定会先执行，优先级大只是最先执行的机会大）。

35.进程间是如何通信的

进程间通信 最简单的方式就是管道，管道分为「匿名管道」和「命名管道」。
匿名管道顾名思义，它没有名字标识，匿名管道是特殊文件只存在于内存，没有存在于文件系统中，shell 命令中的「|」竖线就是匿名管道，通信的数据是无格式的流并且大小受限，通信的方式是单向的，数据只能在一个方向上流动，如果要双向通信，需要创建两个管道，再来匿名管道是只能用于存在父子关系的进程间通信，匿名管道的生命周期随着进程创建而建立，随着进程终止而消失。

命名管道突破了匿名管道只能在亲缘关系进程间的通信限制，因为使用命名管道的前提，需要在文件系统创建一个类型为 p 的设备文件，那么毫无关系的进程就可以通过这个设备文件进行通。

消息队列克服了管道通信的数据是无格式的字节流的问题，消息队列实际上是保存在内核的「消息链表」，消息队列的消息体是可以用户自定义的数据类型，发送数据时，会被分成一个一个独立的消息体，当然接收数据时，也要与发送方发送的消息体的数据类型保持一致，这样才能保证读取的数据是正确的。消息队列通信的速度不是最及时的，毕竟每次数据的写入和读取都需要经过用户态与内核态之间的拷贝过程。

共享内存可以解决消息队列通信中用户态与内核态之间数据拷贝过程带来的开销，它直接分配一个共享空间，每个进程都可以直接访问，就像访问进程自己的空间一样快捷方便，不需要陷入内核态或者系统调用，大大提高了通信的速度，享有最快的进程间通信方式之名。但是便捷高效的共享内存通信，带来新的问题，多进程竞争同个共享资源会造成数据的错乱。

那么，就需要信号量来保护共享资源，以确保任何时刻只能有一个进程访问共享资源，这种方式就是互斥访问。信号量不仅可以实现访问的互斥性，还可以实现进程间的同步，信号量其实是一个计数器，表示的是资源个数，其值可以通过两个原子操作来控制，分别是 P 操作和 V 操作。

与信号量名字很相似的叫信号，它俩名字虽然相似，但功能一点儿都不一样。信号是进程间通信机制中唯一的异步通信机制，信号可以在应用进程和内核之间直接交互，内核也可以利用信号来通知用户空间的进程发生了哪些系统事件，信号事件的来源主要有硬件来源（如键盘 Cltr+C ）和软件来源（如 kill 命令），一旦有信号发生，进程有三种方式响应信号 1. 执行默认操作、2. 捕捉信号、3. 忽略信号。有两个信号是应用进程无法捕捉和忽略的，即 SIGKILL 和 SEGSTOP，这是为了方便我们能在任何时候结束或停止某个进程

前面说到的通信机制，都是工作于同一台主机，如果要与不同主机的进程间通信，那么就需要 Socket 通信了。Socket 实际上不仅用于不同的主机进程间通信，还可以用于本地主机进程间通信，可根据创建 Socket 的类型不同，分为三种常见的通信方式，一个是基于 TCP 协议的通信方式，一个是基于 UDP 协议的通信方式，一个是本地进程间通信方式。

线程间通信
同个进程下的线程之间都是共享进程的资源，只要是共享变量都可以做到线程间通信，比如全局变量，所以对于线程间关注的不是通信方式，而是关注多线程竞争共享资源的问题，信号量也同样可以在线程间实现互斥与同步：

互斥的方式，可保证任意时刻只有一个线程访问共享资源；
同步的方式，可保证线程 A 应在线程 B 之前执行
2021/6/2补充

2021/6/2补充 虚拟内存

虚拟内存是计算机系统内存管理的一种技术。它使得应用程序认为它拥有连续的可用的内存（一个连续完整的地址空间），而实际上，它通常是被分隔成多个物理内存碎片，还有部分暂时存储在外部磁盘存储器上，在需要时进行数据交换。目前，大多数操作系统都使用了虚拟内存，如Windows家族的“虚拟内存”；Linux的“交换空间”等

补充1.创建线程池的方法、线程池有哪些参数

java创建线程池的四种方式：

 newCachedThreadPool 创建一个可缓存的线程池，如果线程池长度超过处理需求，可灵活回收空闲线程，若无可回收，则新建线程

newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待

newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行

newSingleThreadExecutor 创建一个单线程化的线程池，它只会唯一的工作线程来执行任务，保证所有任务按照指定

顺序（FIFO，LIFO，优先级）执行

线程池的构造函数有7个参数，分别是corePoolSize、maximumPoolSize、keepAliveTime、unit、workQueue、threadFactory、handler。下面会对这7个参数一一解释。

一、corePoolSize 线程池核心线程大小

线程池中会维护一个最小的线程数量，即使这些线程处理空闲状态，他们也不会被销毁，除非设置了allowCoreThreadTimeOut。这里的最小线程数量即是corePoolSize。

二、maximumPoolSize 线程池最大线程数量

一个任务被提交到线程池以后，首先会找有没有空闲存活线程，如果有则直接将任务交给这个空闲线程来执行，如果没有则会缓存到工作队列（后面会介绍）中，如果工作队列满了，才会创建一个新线程，然后从工作队列的头部取出一个任务交由新线程来处理，而将刚提交的任务放入工作队列尾部。线程池不会无限制的去创建新线程，它会有一个最大线程数量的限制，这个数量即由maximunPoolSize指定。
三、keepAliveTime 空闲线程存活时间
一个线程如果处于空闲状态，并且当前的线程数量大于corePoolSize，那么在指定时间后，这个空闲线程会被销毁，这里的指定时间由keepAliveTime来设定
四、unit 空闲线程存活时间单位
keepAliveTime的计量单位
五、workQueue 工作队列
六、threadFactory 线程工厂
创建一个新线程时使用的工厂，可以用来设定线程名、是否为daemon线程等等
七、handler 拒绝策略

补充2.创建线程的方法

java创建线程的三种方式：

继承Thread类创建线程类
（1）定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体(线程体)。

（2）创建Thread子类的实例，即创建了线程对象。

（3）调用线程对象的start()方法来启动该线程。
实现Runnable接口
（1）定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
（2）创建 Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
（3）调用线程对象的start()方法来启动该线程。
通过Callable和Future创建线程
（1）创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。

public interface Callable
{
　　V call() throws Exception;
}
（2）创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方

法的返回值。（FutureTask是一个包装器，它通过接受Callable来创建，它同时实现了Future和Runnable接口。）

（3）使用FutureTask对象作为Thread对象的target创建并启动新线程。

（4）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

Runnable和Callable的区别

 (1) Callable规定（重写）的方法是call()，Runnable规定（重写）的方法是run()。

 (2) Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。

 (3) call方法可以抛出异常，run方法不可以。

 (4) 运行Callable任务可以拿到一个Future对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果future.get()。

补充3.synchronize和volatile的区别与使用

java多线程中的原子性、可见性、有序性（这点也可以补充怎么理解线程安全）
（1）、原子性：是指线程的多个操作是一个整体，不能被分割，要么就不执行，要么就全部执行完，中间不能被打断。
（2）、可见性：是指线程之间的可见性，就是一个线程修改后的结果，其他的线程能够立马知道。
（3）、有序性：为了提高执行效率，java中的编译器和处理器可以对指令进行重新排序，重新排序会影响多线程并发的正确性，有序性就是要保证不进行重新排序（保证线程操作的执行顺序）。

volatile关键字的作用
其实volatile关键字的作用就是保证了可见性和有序性（不保证原子性），如果一个共享变量被volatile关键字修饰，那么如果一个线程修改了这个共享变量后，其他线程是立马可知的。为什么是这样的呢？比如，线程A修改了自己的共享变量副本，这时如果该共享变量没有被volatile修饰，那么本次修改不一定会马上将修改结果刷新到主存中，如果此时B去主存中读取共享变量的值，那么这个值就是没有被A修改之前的值。如果该共享变量被volatile修饰了，那么本次修改结果会强制立刻刷新到主存中，如果此时B去主存中读取共享变量的值，那么这个值就是被A修改之后的值了。
volatile能禁止指令重新排序，在指令重排序优化时，在volatile变量之前的指令不能在volatile之后执行，在volatile之后的指令也不能在volatile之前执行，所以它保证了有序性。

synchronized关键字的作用
synchronized提供了同步锁的概念，被synchronized修饰的代码段可以防止被多个线程同时执行，必须一个线程把synchronized修饰的代码段都执行完毕了，其他的线程才能开始执行这段代码。
因为synchronized保证了在同一时刻，只能有一个线程执行同步代码块，所以执行同步代码块的时候相当于是单线程操作了，那么线程的可见性、原子性、有序性（线程之间的执行顺序）它都能保证了。

volatile关键字和synchronized关键字的区别
（1）、volatile只能作用于变量，使用范围较小。synchronized可以用在变量、方法、类、同步代码块等，使用范围比较广。
（2）、volatile只能保证可见性和有序性，不能保证原子性。而可见性、有序性、原子性synchronized都可以包证。
（3）、volatile不会造成线程阻塞。synchronized可能会造成线程阻塞。

补充4 怎么理解线程安全

线程的安全其实是内存的安全
目前主流操作系统都是多任务的，即多个进程同时运行。为了保证安全，每个进程只能访问分配给自己的内存空间，而不能访问别的进程的，这是由操作系统保障的。

在每个进程的内存空间中都会有一块特殊的公共区域，通常称为堆（内存）。进程内的所有线程都可以访问到该区域，这就是造成问题的潜在原因。

当所有线程都可以访问到这块区域时，在堆内存中的数据由于可以被任何线程访问到，在没有限制的情况下存在被意外修改的风险。

六、计算机网络相关

36.TCP三次握手、四次挥手、拥塞控制、流量控制、TCP如何保证可靠性

为什么不能两次

为了防止 已失效的链接请求报文突然又传送到了服务端，因而产生错误。
　　客户端发出的连接请求报文并未丢失，而是在某个网络节点长时间滞留了，以致延误到链接释放以后的某个时间才到达Server。这是，Server误以为这是Client发出的一个新的链接请求，于是就向客户端发送确认数据包，同意建立链接。若不采用“三次握手”，那么只要Server发出确认数据包，新的链接就建立了。由于client此时并未发出建立链接的请求，所以其不会理睬Server的确认，也不与Server通信；而这时Server一直在等待Client的请求，这样Server就白白浪费了一定的资源。若采用“三次握手”，在这种情况下，由于Server端没有收到来自客户端的确认，则就会知道Client并没有要求建立请求，就不会建立链接。

如何保证可靠性
对于可靠性，TCP通过以下方式进行保证：
数据包校验：目的是检测数据在传输过程中的任何变化，若校验出包有错，则丢弃报文段并且不给出响应，这时TCP发送数据端超时后会重发数据；
对失序数据包重排序：既然TCP报文段作为IP数据报来传输，而IP数据报的到达可能会失序，因此TCP报文段的到达也可能会失序。TCP将对失序数据进行重新排序，然后才交给应用层；
丢弃重复数据：对于重复数据，能够丢弃重复数据；
应答机制：当TCP收到发自TCP连接另一端的数据，它将发送一个确认。这个确认不是立即发送，通常将推迟几分之一秒；
超时重发：当TCP发出一个段后，它启动一个定时器，等待目的端确认收到这个报文段。如果不能及时收到一个确认，将重发这个报文段；
流量控制：TCP连接的每一方都有固定大小的缓冲空间。TCP的接收端只允许另一端发送接收端缓冲区所能接纳的数据，这可以防止较快主机致使较慢主机的缓冲区溢出，这就是流量控制。TCP使用的流量控制协议是可变大小的滑动窗口协议。

拥塞控制

2021/6/2补充 滑动窗口

TCP协议里窗口机制有2种：一种是固定的窗口大小；一种是滑动的窗口。这个窗口大小就是我们一次传输几个数据。对所有数据帧按顺序赋予编号，发送方在发送过程中始终保持着一个发送窗口，只有落在发送窗口内的帧才允许被发送；同时接收方也维持着一个接收窗口，只有落在接收窗口内的帧才允许接收。这样通过调整发送方窗口和接收方窗口的大小可以实现流量控制。

  TCP滑动窗口技术通过动态改变窗口大小来调节两台主机间数据传输。每个TCP/IP主机支持全双工数据传输，因此TCP有两个滑动窗口：一个用于接收数据，另一个用于发送数据。TCP使用肯定确认技术，其确认号指的是下一个所期待的字节。 假定发送方设备以每一次三个数据包的方式发送数据，也就是说，窗口大小为3。发送方发送序列号为1、2、3的三个数据包，接收方设备成功接收数据包，用序列号4确认。发送方设备收到确认，继续以窗口大小3发送数据。当接收方设备要求降低或者增大网络流量时，可以对窗口大小进行减小或者增加，降低窗口大小为2，每一次发送两个数据包。当接收方设备要求窗口大小为0，表明接收方已经接收了全部数据，或者接收方应用程序没有时间读取数据，要求暂停发送。发送方接收到携带窗口号为0的确认，停止这一方向的数据传输。

37.TCP和UDP的运用场景、UDP如何保证可靠性

TCP的应用场景：邮件发送、文件的传输
UDP的应用场景：视频、各大网络视频
UDP如何实现保证可靠性
传输层无法保证数据的可靠传输，只能通过应用层来实现了。实现的方式可以参照tcp可靠性传输的方式，只是实现不在传输层，实现转移到了应用层。实现确认机制、重传机制、滑动窗口

38.cpu 100%的问题如何排查（JVM调优可以说这个）

1. 使用top命令查看cpu占用资源较高的PID
2. 我们已经找到了哪个进程最消耗CPU了，接下来，我们当然要找到该进程下，哪个线程CPU消耗最高咯。这里的进程PID是26045，使用命令top -Hp PID 显示进程PID下所有的线程
3. 然后我们使用jstack命令，拉到26045进程快照信息，输出到文件中，方便我们查看。jstack -l 26045 > ./26045.stack
4. 然后我们cat该文件，并且grep通过16进制找一下该线程cat 26045.stack ｜ grep ‘65be’ -C 20

jstack Dump 日志文件中的线程状态, dump 文件里，值得关注的是线程状态有：

死锁，Deadlock（重点关注）
执行中，Runnable
等待资源，Waiting on condition（重点关注）
等待获取监视器，Waiting on monitor entry（重点关注）
暂停，Suspended
对象等待中，Object.wait() 或 TIMED_WAITING
阻塞，Blocked（重点关注）
停止，Parked

39.DNS

1、DNS客户端（DNS_Client）检查HOSTS文件及本地DNS缓存，没有找到对应的记录；
2、DNS_Client 联系本地的DNS服务器（DNS_Server），查询域名www.google.com；
3、DNS_Server 联系根提示中的某个根域服务器（Root_Server），查询域名www.google.com；
4、根域名服务器（Root_Server）也不知道www.google.com的对应值，于是向 DNS_Server 返回一个参考答复，告诉其.com顶级域的权威DNS服务器（.com_DNS_Server）;
5、DNS_Server 联系 .com_DNS_Server ，查询域名 www.google.com；
6、.com_DNS_Server 也不知道www.google.com的对应值，于是就向 DNS_Server 返回一个参考答复，告诉它google.com域的权威DNS服务器（google.com_DNS_Server）地址；
7、DNS_Server 联系 google.com_DNS_Server，查询域名 www.google.com；
8、google.com_DNS_Server 知道对应IP地址（IP_Address），并将其返回给DNS_Server；
9、DNS_Server 向 DNS_Client 返回 www.google.com 的 IP_Address；
10、DNS_Client 向 IP_Address 的服务器发送数据传输请求，建立连接，解析完毕。

40.http和https的区别

Http协议运行在TCP之上，明文传输，客户端与服务器端都无法验证对方的身份；Https是身披SSL(Secure Socket Layer)外壳的Http，运行于SSL上，SSL运行于TCP之上，是添加了加密和认证机制的HTTP。二者之间存在如下不同：
端口不同：Http与Http使用不同的连接方式，用的端口也不一样，前者是80，后者是443；
资源消耗：和HTTP通信相比，Https通信会由于加减密处理消耗更多的CPU和内存资源；
开销：Https通信需要证书，而证书一般需要向认证机构购买；
Https的加密机制是一种共享密钥加密和公开密钥加密并用（对称与非对称均有）的混合加密机制。

41.服务器发出http请求的过程

(1). 浏览器查询 DNS，获取域名对应的IP地址:具体过程包括浏览器搜索自身的DNS缓存、搜索操作系统的DNS缓存、读取本地的Host文件和向本地DNS服务器进行查询等。对于向本地DNS服务器进行查询，如果要查询的域名包含在本地配置区域资源中，则返回解析结果给客户机，完成域名解析(此解析具有权威性)；如果要查询的域名不由本地DNS服务器区域解析，但该服务器已缓存了此网址映射关系，则调用这个IP地址映射，完成域名解析（此解析不具有权威性）。如果本地域名服务器并未缓存该网址映射关系，那么将根据其设置发起递归查询或者迭代查询；
(2). 浏览器获得域名对应的IP地址以后，浏览器向服务器请求建立链接，发起三次握手；
(3). TCP/IP链接建立起来后，浏览器向服务器发送HTTP请求；
(4). 服务器接收到这个请求，并根据路径参数映射到特定的请求处理器进行处理，并将处理结果及相应的视图返回给浏览器；
(5). 浏览器解析并渲染视图，若遇到对js文件、css文件及图片等静态资源的引用，则重复上述步骤并向服务器请求这些资源；
(6). 浏览器根据其请求到的资源、数据渲染页面，最终向用户呈现一个完整的页面。

42.OSI七层协议

43.TCP/IP

补充1.常见状态码

HTTP请求结构： 请求方式 + 请求URI + 协议及其版本
HTTP响应结构： 状态码 + 原因短语 + 协议及其版本

1×× : 请求处理中，请求已被接受，正在处理
2×× : 请求成功，请求被成功处理
200 OK
3×× : 重定向，要完成请求必须进行进一步处理
301 : 永久性转移
302 ：暂时性转移
304 ： 已缓存
4×× : 客户端错误，请求不合法
400：Bad Request,请求有语法问题
403：拒绝请求
404：客户端所访问的页面不存在
5×× : 服务器端错误，服务器不能处理合法请求
500 ：服务器内部错误
503 ： 服务不可用，稍等

补充2 session和cookie的区别？cookie怎么保证里面的数据安全？

1.cookie 是一种发送到客户浏览器的文本串句柄，并保存在客户机硬盘上，可以用来在某个WEB站点会话间持久的保持数据。
2.session其实指的就是访问者从到达某个特定主页到离开为止的那段时间。 Session其实是利用Cookie进行信息处理的，当用户首先进行了请求后，服务端就在用户浏览器上创建了一个Cookie，当这个Session结束时，其实就是意味着这个Cookie就过期了。
注：为这个用户创建的Cookie的名称是aspsessionid。这个Cookie的唯一目的就是为每一个用户提供不同的身份认证。
3.cookie和session的共同之处在于：cookie和session都是用来跟踪浏览器用户身份的会话方式。

4.cookie 和session的区别是：cookie数据保存在客户端，session数据保存在服务器端。
(1)cookie数据存放在客户的浏览器上，session数据放在服务器上
(2)cookie不是很安全，别人可以分析存放在本地的COOKIE并进行COOKIE欺骗,如果主要考虑到安全应当使用session
(3)session会在一定时间内保存在服务器上。当访问增多，会比较占用你服务器的性能，如果主要考虑到减轻服务器性能方面，应当使用COOKIE
(4)单个cookie在客户端的限制是3K，就是说一个站点在客户端存放的COOKIE不能3K。
(5)所以：将登陆信息等重要信息存放为SESSION;其他信息如果需要保留，可以放在COOKIE中

2021/6/2补充 get和post的区别

POST和GET都是向服务器提交数据，并且都会从服务器获取数据。

区别：
1、传送方式：get通过地址栏传输，post通过报文传输。
2、传送长度：get参数有长度限制（受限于url长度），而post无限制
3、GET和POST还有一个重大区别，简单的说：
GET产生一个TCP数据包；POST产生两个TCP数据包

七、操作系统相关

44.死锁的条件
45.银行家算法

八、java基础零碎知识点

46.抽象，封装，继承，多态

Java 的四大特性总结如下：
封装：把对象的属性和行为（数据）封装为一个独立的整体，并尽可能隐藏对象的内部实现细节；
继承：一种代码重用机制；
多态：分离了做什么和怎么做，从另一个角度将接口和实现分离开来，消除类型之间的耦合关系；表现形式：重载与重写；
抽象：对继承的另一种表述；表现形式：接口(契约)与抽象类(模板)。

47.什么是面向对象

举一个洗衣机洗衣服的例子吧。
面向过程的解决方法：1、执行加洗衣粉方法；2、执行加水方法；3、执行洗衣服方法；4、执行清洗方法；5、 执行烘干方法；以上就是将解决这个问题的过程拆成一个个方法（是没有对象去调用的），通过一个个方法的执行来解决问题。
面向对象的解决方法： 1、我先弄出两个对象：“洗衣机”对象和“人”对象 2、针对对象“洗衣机”加入一些属性和方法：“洗衣服方法”“清洗方法”、“烘干方法” 3、针对对象“人”加入属性和方法：“加洗衣粉方法”、“加水方法”4、然后执行人.加洗衣粉人.加水 洗衣机.洗衣服洗衣机.清洗洗衣机.烘干解决同一个问题 ，面向对象编程就是先抽象出对象，然后用对象执行方法的方式解决问题。下次再洗衣服我们可以直接调用洗衣服的方法，就不需要再去写每一个洗衣服的过程了。

static和final的区别

一、static关键字
1、static关键字只能用于修饰成员变量和成员方法。
2、static修饰变量，称为静态变量或类变量，其内存只分配一次
3、static修饰方法，直接通过类调用该方法

二、final关键字

1、final关键字可用于修饰类、成员变量和成员方法。
2、final修饰变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。
3、final修饰方法，使用final修饰的方法不能被子类重写。(最终方法)
4、final修饰类，该类不能被继承，但是可以继承其它类。

2021/6/2补充 加密算法