面经大合集

1-30

1.HashMap, ConcurrentHashMap的区别?

答: HashMap和ConcurrentHashMap的区别主要在以下几点:

1.线程安全性: HashMap不是线程安全的, 它的增删改操作没有加任何锁, 这导致它无法在并发场景下正确工作。而ConcurrentHashMap通过分段锁的机制来支持并发访问，是线程安全的。

2.并发操作：HashMap对put/get/remove操作没有任何同步机制，而ConcurrentHashMap支持线程安全的putIfAbsent,remove等并发操作。

3.性能：ConcurrentHashMap采用了同步机制保证线程安全，其性能要比HashMap低一些。

4.使用场景：HashMap适用于单线程，ConcurrentHashMap适用于并发读写频繁的多线程环境。

以上就是ConcurrentHashMap和HashMap的主要差异点了。

2.线程池的核心参数和原理？

答：线程池有七大核心参数：

1.corePoolSize：线程池的常驻核心线程数。

2.maximumPoolSize：线程池能够同时执行的最大线程数，且maximumPoolSize >= 1。

3.keepAliveTime：多余线程存活时间，当非核心线程空闲时间达到keepAliveTime，该非核心线程将被销毁，当所有非核心线程都被销毁，最终只剩下corePoolSize个常驻核心线程。

4.unit：keepAliveTime的时间单位。

5.workQueue：任务队列，存放被提交但尚未执行的任务。

6.threadFactory：生成线程池中工作线程的线程工厂，一般用默认即可。

7.handler：拒绝策略，表示当workQueue满了且线程池中忙碌线程达到maximumPoolSize时如何拒绝请求的Runnable任务的策略。

系统的拒绝策略有以下四种：

1.直接抛出异常，这也是默认拒绝策略。

2.不抛异常，直接抛弃不处理。

3.丢弃任务队列中最先入队的任务，加入当前任务。

4.把任务分配给调用线程池execute方法的线程执行。

3.线程池的参数是否可以动态调整？

答：除了核心线程数外，其他参数如最大线程数，拒绝策略等都支持在线程池创建后动态调整，实现更好的运行时管理。

4.JVM内存如何划分区域？

答：JVM内存主要划分为五个区域，包括两个数据共享区：堆，方法区；三个数据私有区：本地方法栈，虚拟机栈，程序计数器。

5.了解什么垃圾回收器？

答: 我了解JVM的三种垃圾收集器：

1.Serial回收器:串行收集，单线程，工作时会一直STW到收集结束，效率低。

2.CMS回收器:收集器是一种以获取最短回收停顿时间为目标的收集器。基本实现垃圾收集线程和用户线程并发工作，大致分为四步：初始标记（短暂STW）->并发标记->重新标记（短暂STW）->并发清除，采用“标记-清除”算法，容易产生内存碎片。

3.G1回收器:在G1中，堆被分成许多区域，且都可以作为独立的新生代，幸存区或老年代。G1优先收集垃圾较多的区域，且在停顿时间上加了预测机制，用户可以指定期望停顿时间，G1收集器可以根据预期时间选择收集的区域数量，采用“标记-整理”算法，不会产生内存碎片，但是比较消耗CPU资源。

总结：Serial简单但效率低,CMS加强了低停顿需求,G1兼顾低停顿和整体回收效率。

6.G1和CMS的区别？

答：区别有以下几点：

1.收集范围：CMS是老年代的收集器，可以配合新生代的Serial和ParNew一起使用。而G1收集器的手机范围是老年代和新生代，不需要结合其他收集器使用。

2.STW停顿时间：CMS以最小的停顿时间为目标。而G1可预测垃圾回收的停顿时间。

3.垃圾碎片：CMS使用“标记-清除”算法进行垃圾回收，易产生内存碎片。而G1采用“标记-整理”算法，不会内存空间碎片。

7.MySQL的索引结构是怎样的？

答：MySQL最广泛使用的索引结构是B+树索引，B+树是一种平衡多叉树，它将数据按照某个字段或字段组合进行排序和分层存储。B+树具有以下特点： 适合做范围查询和排序操作，适合做等值查询和联合查询，但不适合做频繁的插入和删除操作。

8.MySQL有哪些事务隔离级别？MySQL默认隔离级别是什么？

答：MySQL有四种事务隔离级别：读未提交，读已提交，可重复读，串行化。MySQL默认隔离级别是可重复读。

9.什么是MVCC？

答：MVCC，即多版本并发控制，是为了在读取数据时不加锁来提高读取效率和并发性的一种手段。MVCC解决的就是读写时的线程安全问题，线程不用去争抢读写锁。

MVCC原理：每行数据都有两个隐藏字段，trx_id，roll_pointer（版本链指针），且如果表中没有主键和非空唯一索引时，会有第三个隐藏字段row_id。如果一行数据产生多个事务，它会根据时间顺序产生一个版本链，记录在undo_log中，版本链中的trx_id字段的值是递增的。每个事务在执行前会获得一个ReadView，这个ReadView记录了事务创建时刻的隐藏字段值，当事务需要读取这行记录，就会根据ReadView记录的trx_id的值去和undo_log中该行数据的版本链进行一一匹配，根据匹配规则来决定哪些数据可以被当前事务读取到。

10.可重复读是否解决幻读？

答：不完全解决。可重复读可以解决在一个事务当中多次读取的结果一致，但不能完全解决幻读。

可重复读只能保证对同一主键的值多次查询结果不变，但对范围查询的结果不能提供这种保证。

如果有解决幻读的需求，可以把隔离级别设置为串行化，这样就可以解决幻读。

11.如果MySQL宕机了数据还没有落盘是否会丢失数据？

答：事务提交后，数据的持久化分为三步，第一步是写入内存，第二步是同步写入日志文件，第三步是日志文件定期写入数据文件（例如MyISAM文件）。如果MySQL在第二布即写入日志文件之前宕机，那MySQL重启后是无法根据日志文件恢复数据的，也就有可能丢失。但如果MySQL在数据写入日志文件后宕机，MySQL重启还是能读取日志文件来恢复数据的。

12.MySQL为啥使用日志保存数据而不是直接对B+树进行数据保存？

答:MySQL使用日志保存数据而不是直接对B+树保存数据主要有以下原因:

1.日志可以实现数据写入和查询的异步操作,这对性能有很大好处,不会因为数据写入而阻塞查询操作。

2.使用日志可以实现数据的时序性保存，通过日志的顺序读取可以正确地将数据恢复到任何时间节点，这对后台数据安全备份和恢复很重要。

3.日志更适合支持事务和ACID特性。只要正确提交事务的日志，就能保证数据的原子性和一致性，通过回滚日志可以进行回滚操作。

4.B+树适合于有规律的随机查询访问，而不是顺序写入操作，直接对B+树操作难以高效实现日志的特性。

5.从扩展性上考虑，日志更容易支持集群和主从复制功能。

故虽然使用B+树效率高，但日志在实现事务特性和系统扩展性上都具有极大优势，这是MySQL选择日志的重要原因。

13.线程和进程的区别是什么？

答：线程和进程的主要区别如下：

1.资源拥有：进程是资源分配的基础，每个进程拥有独立的一组资源，而线程在一个进程内，通常共享进程的资源。

2.开销：相比进程，线程的开销小得多。

3.同步性：多个进程可并发执行，互不影响；但一个进程内的多个线程需要同步机制来防止资源冲突。

4.上下文切换：线程上下文切换开销小，只涉及少量寄存器等；进程上下文切换开销大，需要保存进程的整个上下文。

5.通信：线程之间通过共享内存通信；进程之间通信复杂，通常通过消息传递和管道进行通信。

14.操作String的类有哪些？

答：常见的有String，StringBuilder，StringBuffer等。

15.String,StringBuilder,StringBuffer的区别有哪些？

答：1.String不可变，每次修改都会创建新的String对象。StringBuilder和StringBuffer都可变。

2.String不可变，所以是线程安全的。StringBuilder不是线程安全的，StringBuffer用同步机制保证了线程安全。

3.性能：StringBuilder > StringBuffer > String

16.TCP/IP分别在网络那一层？

答：TCP位于传输层，负责提供面向连接的可靠字节流传输服务。IP位于网络层。

17.数据库的三个约束？

答：1.主键约束：用于标识每一行记录，不允许为null，每张表只能有一个主键。

2.唯一约束。

3.外键约束：用于限制两张表之间的对应关系。

18.union和union all的区别？

答：union会消除重复，union all不会。

19.LinkedList和ArrayList的区别？LinkedList的优势是什么？

答：区别：1.ArrayList底层用数组存储数据，LinkedList用链表存储数据。

2.ArrayList支持高效的随机访问，LinkedList只能两端遍历。

3.ArraysList插入删除效率低，需要移动元素；LinkedList插入删除效率高，只需改变指针。

4.ArrayList的空间占用更大。

5.扩容方式：ArrayList需要复制元素到新的数组，LinkedList则不需要。

LinkedList的优势在于支持搞笑的插入和删除操作，所以LinkedList更适合需要频繁插入删除的场景，例如栈，队列的实现。

20.抽象类和接口的区别？这两者里面可以有main函数吗？

答：区别：1.抽象类可以包含成员属性和实现部分方法，接口只能定义方法。

2.类只能继承一个类，但可以实现多个接口。

抽象类可以包含main方法，可以使用main方法执行抽象类，但不能实例化抽象类。

接口也不能包含main方法。

21.过滤器和拦截器有什么区别?

答:1.触发时机不一样,过滤器是在请求进入容器但未进入servlet之前预处理的。请求结束返回也是，是在servlet处理完后返回前端之前。

2.拦截器可以获取IOC容器的各个bean，而过滤器不可以。因为拦截器是Spring提供并管理的，Spring的功能能被拦截器使用，比如拦截器可以注入Spring的service来调用业务逻辑。而过滤器是JavaEE标准，只依赖于servlet api，不依赖于Spring。

3.过滤器的实现基于回调函数，拦截器是基于代理模式，即反射。

4.过滤器是基于servlet容器，属于servlet规范的一部分，而拦截器是独立存在的，可以在任何情况下使用。

5.过滤器只能在请求的前后使用，拦截器可以具体到每个方法。

22.过滤器和拦截器谁的范围更大？

答：过滤器能对所有web应用中的请求前后进行过滤，而拦截器只能对Spring中的请求起作用，所以过滤器范围更大。

23.方法重载和重写的区别？重载的返回值有没有变化？

答：重载的方法名必须相同，参数类型不同，重写的方法名和参数必须完全相同。重载的返回类型可以不同。

24.多线程的创建和销毁说一下？

答：线程创建：1.实现Runable接口实现run方法。2.继承Thread类重写run方法。3.实现Callable接口实现call方法，用FutrueTask包装器创建带返回值的线程。

线程销毁：1.调用stop强制终止，会破环为执行完的线程，不建议使用。

2.调用interrupt设置一个中断标志，通知线程自己处理并终止，这种方式处理权在线程，不在外部调用，处于阻塞的线程不一定会终止。

25.SpringBoot的核心注解是哪个？

答：@SpringBootApplication是SpringBoot最核心的注解，在SpringBoot启动类上，标识是SpringBoot应用，用来开启SpringBoot的各项能力。有@SpringBootConfiguration,@EnableAutoConfiguration,@CompoentScan三个注解组成，所以Spring提供了统一的注解@SpringBootApplication。

26.MySQL什么情况下需要索引？

答：1.频繁查询。2.连接查询。3.数据量大。4。排序操作。5.分组操作。6.唯一性约束。

27.MySQL什么情况不建索引？

答：1.数据量小。2.列的区分度不高。3.写多读少。4.无序的值不适合作为索引。

28.MySQL索引分类？

答：1.聚簇索引：一般是指主键索引，叶子节点存储表中数据。

2.非聚簇索引：叶子节点存储主键。

29.场景题：我有一个字段是string类型的，我建立的索引是datetime类型的，问能不能匹配上，为什么(原理是啥)？

答：不能匹配上。因为索引字段的类型必须和被查询字段的类型一致。数据库在查找数据时，会先检查索引字段是否和查询条件类型一致，string和datetime类型不一致，索引失效。

30.临键锁?

答:临键锁可以理解为锁住的是索引之间的间隙, 每个数据行的非唯一索引列都会存在一把临键锁，当某个数据持有该临键锁时，会锁柱一段左开右闭的区间，通过它可以解决幻读问题。

31-60

31.MySQL中的锁？

答：根据属性分类：共享锁和排他锁。根据粒度分类：表锁和行锁。

共享锁：多个事务能同时获取共享锁读到数据，但是不能修改。

排他锁：同时只能有一个事务能获取到排他锁，且只有获取排他锁的事务能进行读写操作。

32.讲一下策略模式和责任链模式的使用场景？

答：策略模式：当有一个类有多种行为，且这些行为可以根据环境和参数的不同变化，可以使用策略模式。

责任链模式:当有多个对象都有机会处理某个请求，且多个对象都有可能处理这个请求时使用。

33.怎么使用Sentinel的？

答：Sentinel的使用场景：微服务保护，流量控制，熔断降级。

34.SpringCloud的负载均衡机制？

答：SpingCloud提供了两种负载均衡机制：1.Ribbon：支持轮询，随机，权重轮询等。默认采用轮询算法。

2.Spring Cloud LoadBalancer：整合了Ribbon，并且提供了更多功能，如自定义负载均衡逻辑。

35.负载均衡策略？

答：轮询，带权轮询，随机，IP哈希（根据用户IP生成一个key，映射到一个服务实例上）。

36.如何保证数据库与缓存的强一致性？

答：无论是先更新数据库，再删除缓存，还是先删除缓存，再更新数据库，都有概率并发下的数据的数据不一致问题。比较好的解决方案是延时双删，流程是这样的：先删除缓存，再更新数据库，紧接着睡眠一段时间，再删除缓存。之所以要睡眠一段时间，是为了等其他并发线程把旧数据写入缓存当中再去删除，但这个睡眠时间具体为多少不好预估，如果预估不准确，仍然有可能导致数据不一致。那么，保证完全强一致性的方法只有加分布式锁，保证同一时间只运行一个请求更新缓存。

37.Java8新特性?

答:1.函数式接口，即只包含一个抽象方法的接口。

2.Lambda表达式使代码变得简洁紧凑，格式：（参数列表）->{方法体}，其中（），参数类型，{}可省略（Java8有自动类型推断）。

38.Int几个字节几个比特？

答：int类型占4个字节，32个比特。

39.int，Integer的默认值？

答：int默认值是0，Integer默认值是null。

40.hashCode可以干嘛？

答：哈希码的作用主要用于集合中元素的快速查找，比如在HashMap和HashSet中，内部使用哈希表存储元素，使用哈希码能快速将元素映射到特定桶中，从而只需要在映射桶中查找元素，大大提高效率。

41.concurrentHashMap原理？

答：concurrentHashMap是线程安全的，concurrentHashMap并非锁住整个方法，而是通过原子操作和局部加锁来保证多线程的线程安全，且尽可能减少性能损耗。

42.threadlocal的用途，有什么风险，它的map是什么map？

答：用途：1.保存线程的上下文信息，在任何地方都可以获取。我们可以使用static关键字，在任意时刻都可对threadlocal进行获取设置。例如Spring中的事务，用threadlocal存储了连接对象，保证一次事务的所有操作都在同一连接上。

2.线程之间数据隔离。

风险：内存泄漏。ThreadLocalMap的key是ThreadLocal是弱引用，而value是强引用，在垃圾回收的时候key会被清理掉，而value不会，这样一来就出现了key为null的Entry，假如不做任何措施，value永远不会被GC回收，就会产生内存泄漏。

map：ThreadLocal中有一个ThreadLocalMap的内部类，这个内部类被Thread定义成了成员变量。

43.事物的四大特性，事务传播，隔离级别？

答：四大特性：1.原子性：事务中的所有操作要么全部成功执行，要么全部失败。

2.一致性：事务执行后，数据库状态与其他业务规则保持一致。

3.隔离性：在并发操作中，不同的事务应该隔离开来，互不影响。

4.持久性：一旦事务执行成功，事务中所有的数据必须持久化到数据库中。

事务传播：有两个事务方法A和B，A在调用了B，那么B是重新开启一个事务，还是在A的事务中运行，这取决于B的传播行为。

Spring定义了七种事务传播行为：

1.PROPAGATION_REQUIRED：存在事务就支持该事务，不存在就重新开启一个事务。

2.PROPAGATION_SUPPORTS：存在事务就支持该事务，不存在事务则无事务运行。

3.PROPAGATION_MANDATORY：存在事务则支持事务，不存在就抛异常。

4.PROPAGATION_REQUIRED_NEW：会开启一个事务，如果存在一个事务，会把存在的事务挂起。

5.PROPAGATION_NOT_SUPPORTED：总是非事务的运行，并且挂起任何存在的事务。

6.PROPAGATION_NEVER：总是非事务的运行，存在事务则抛异常。

7.PROPAGATION_NESTED：如果事务存在，则运行在一个嵌套事务中，否则开启新事务。

隔离级别：1.读未提交：能读到其他事务未提交的数据。

2.读已提交，能读到其他事务已提交的数据，解决脏读。

3.可重复读：InnoDB默认隔离级别，保证一个事务中读取同一条记录的结果一致，但无法获取已有记录最新提交的变更，解决脏读，不可重复读。

4.串行化：完全看不到其他事务对数据库的变更，避免脏读，不可重复读，幻读，但效率低下。

44.MySQL索引为什么这么快，数据结构是什么？

答：因为索引可以进行排序进行二分查找，相比于没索引的遍历查找复杂度由O（n）降为O（logn）。数据结构是B+树，一个平衡的多路查找树。

45.索引失效的情况有什么？

答：1.对索引使用函数或表达式计算。

2.数据类型不匹配。

3.对索引使用左或左右模糊匹配。

4.联合索引违背最左匹配原则。

5.对索引隐式类型转换，如字符串不添加引号。

6.is null 或 is not null 无法使用索引。

7.or连接导致索引失效。

8.如果mysql发现全表扫描比走索引快，那就不会走索引。

46.http请求都有什么内容组成？

答:请求行，请求头，换行，请求体。

47.https为什么安全？

答：1.加密传输：使用SSL/TLS协议加密传输，保证传输过程中数据安全。

2.服务器身份验证：客户端可以验证SSL证书是否来自服务器主体，防止中间人假冒。

3.完整性保护：通过数字签名等技术确认传输过程中数据没有被篡改。

4.Cookie安全：只有通过Https传输的Cookie才被浏览器识别为安全Cookie，防止Cookie泄露。

48.对称加密和非对称加密？

答：对称加密：加解密使用同一把密钥。

非对称加密：加解密使用不同的密钥，一把作为公钥，一把作为私钥，公钥加密用私钥解密，私钥加密用公钥解密。

49.设计模式及大类型？

总体来说设计模式分为三大类：

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

50.Spring的设计模式有哪些?

答：单例模式：Spring中的bean默认使用单例模式。

工厂模式：Spring中的BeanFactory就是工厂模式。

代理模式：分静态代理和动态代理，Spring的AOP使用动态代理实现，动态代理又分为JDK动态代理和CGlib动态代理。

51.Spring的拦截器是什么模式?

答：Spring中的拦截器使用了AOP技术，是一种代理模式。

52.Java异常的理解？

答：分类：ERRR:JVM内部错误，程序员无法处理。

RuntimeException：运行时异常，程序员能处理。

IOException：检查时异常，编译器要求强制处理。

53.try catch finally，如果try返回了，finally还会执行吗？

答：会执行，除非虚拟机停止运行，否则finally都会最终执行。

54.Java重入锁？

答：在Java中，可重入锁的典型实现是ReentrantLock类，创建ReentrantLock对象后，一个线程可多次调用lock方法获取锁。可重入锁提供了两种公平性策略：非公平锁（默认）和公平锁：非公平锁在锁释放后，可以让任意等待线程获取锁，而不是按照等待的顺序，这种模式能提高吞吐量，但可能造成某些线程长期等待。公平锁则会按照线程等待的顺序依次获取锁，可以避免饥饿现象，但是性能会下降。

55.synchronized锁升级过程？

答：无锁->偏向锁->轻量级锁->重量级锁。

无锁，当有线程访问同步块时升级为偏向锁。

偏向锁，当有锁竞争时升级为轻量级锁。

轻量级锁，当自旋一定次数失败，升级为重量级锁。

56.熔断,限流,降级区别?

答:熔断:当下游业务出现故障时,暂时停止对下游业务的调用。停止是指当请求到达时，不再调用下游业务，而是根据设定好的策略直接返回。暂时是指并不会一直不再调用下游业务，而是以一定策略，比如每分钟调用十次，当全部成功，再慢慢增大调用次数，当下游服务回复可用，自动停止熔断。

限流：是指当上游服务的QPS超过设定的阈值，通过一定的策略对请求进行限制，以保证服务不被压垮。

降级：当自身服务压力增大时，采用一些手段以增强自身的服务能力，比如，下线非核心业务来保证服务的稳定，降低实时性，一致性。

57.MQ的作用？

答：1.业务异步解耦：在业务中不需要及时返回结果的操作可以异步处理。

2.解耦微服务。

3.流量削峰填谷，比如秒杀场景，避免服务器压力过大。

4.消息分发，比如单子付款成功，消息放在MQ，由其他服务监听获取消息。

58.有哪些集合？

答：ArrayList，LinkedList。

59.TreeMap和LinkedHashMap的区别？

答：TreeMap可以根据key进行排序，基于红黑树实现，顺序查找效率高。

LinkedHashMap基于链表实现，保持存放顺序，增删效率高，查询效率低。

60.HashMap的常用方法？

答：put，get，size。

61-90

61.流式编程用的多吗？

答：有用过，流式编程时JDK1.8的新特性，使用它可以繁琐的循环操作，使代码更加简洁，可读性也更好。

62.什么情况下会使用到ThreadLocal？

答：1.代替参数的显示传递。

2.全局存储用户信息。

3.解决数据库连接的线程安全问题：每个线程连接数据库的时候，从自己的ThreadLocal中获取Connection，如果为null，说明未连接，连接后把Connection对象存入ThreadLocal，这样每一个线程都有只属于自己的数据库连接，解决了多线程连接数据库的线程安全问题。

63.抽象类可以创建对象吗？

答：抽象类不能直接实例化，只能通过他的子类实现抽象类的所有方法才能实例化。

64.synchronized加在静态方法和非静态方法的区别？

答：synchronized加在静态方法，是对静态方法的类本身加锁。synchronized加在非静态方法，是对调用该方法的对象加锁。

65.线程池在什么情况下，任务会放到阻塞队列中？

答：忙碌线程数到达核心线程数，且阻塞队列没满时。

66.最大线程数有什么作用？

答：当所有核心线程都处于忙碌状态，且任务队列被塞满时，为了避免任务被拒绝，如果设置的最大线程数大于核心线程数，就会开启新的线程去处理任务，解决核心线程处理不过来的情况。

67.IO包下有什么类？

答：字节输入流InputStream，字节输出流OutputStream，字符输入流Reader，字符输出流Writer，IO异常类IOException，FileNotFoundException等。

68.Reader和InputStream有什么区别？

答：InputStream读取单位是字节，Reader读取单位是字符，即两个字节。汉字是两个字节，所以在读取中文的时候用Reader。

69.字符流和字节流分别对应什么，怎么互相转换？

答：InputStreamReader和OutputStreamWriter，这两个类能将字节流转换为字符流。

70.ArrayList扩容机制？

答：初始容量为0，当第一个元素添加，扩容成10，接下来每次扩容都是 扩容后的容量=当前容量+当前容量>>1，即1.5倍。addall（）扩容则需要在需要容量和扩容后容量之间选取最大值扩容。

71.反射加载类的几种方式？原理？应用场景？

答：反射加载类主要有两种：通过class对象的newInstance方法，通过Constructor对象的newInstance方法。

原理：每个java文件都会被编译成一个.class文件，这些class文件在程序运行时会被ClassLoader加载到JVM中，当一个类被加载，JVM会在内存中自动产生一个Class对象，通过Class对象可以获取到对象的属性，方法。使用反射只需要传入类名就可以生成对象，降低耦合，使得程序变得灵活。

应用场景：Spring的IOC通过配置文件配置需要的bean，Spring会根据配置动态加载bean。AOP的动态代理。

72.SpringBoot比SpringMVC的进步点？

答：SpringBoot集成了多个优秀的组件，我们不用再考虑各版本组合的问题，达到开箱即用的效果。SpringBoot为每一个集成的依赖设置了一系列的默认配置，十分方便，若我们想去修改或添加配置，只需要实现相关接口，将其添加到IoC容器即可。

73.MySQL怎么看使用了那个索引？

答：在sql语句之前添加explain关键字，就能看到是否使用索引，以及具体使用的索引。

74.Redis使用场景？

答：缓存，分布式锁。

75.分布式锁怎么实现的？

答：利用Redis的setnx命令的互斥性和lua脚本执行一系列redis命令的原子性实现。实际上，Redission框架就是基于setnx和lua脚本实现的分布式锁，另外，他还提供了看门狗锁续期机制，防止持有分布式锁的线程业务没执行完就释放锁。

76.乐观锁和悲观锁怎么实现的？乐观锁和悲观锁区别？

答：乐观锁认为线程安全问题发生的概率较小，所以不加锁也无需等待，只是在提交修改的时候需要验证这段时间内数据是否被其他线程修改。实现：版本号机制或CAS算法。

悲观锁则对线程安全发生的概率持悲观态度，每次修改资源都会加锁且阻塞其他想要修改资源的线程。实现：synchronized或ReentrantLock。

区别：乐观锁适合写比较少的场景。悲观锁适合写比较多的场景。

77.登录功能怎么做的？

答：1.前端验证用户输入是否符合规范，并将账号密码用公钥进行加密

2. 前端调用后端登录接口，向后端发起登录请求

3. 后端收到请求，通过私钥解密后查验数据库中是否有相应账号以及密码是否正确

4.验证通过后，将成功信息连同token一起发送给前端

5.前端将token储存起来，每次用户进入需要登录才能访问的页面时或者每次进入网站时向后端发送token

6. 若过期，则清除用户信息，回到未登录状态

78.int的取值范围是多少?

答:[-2^31, 2^31 - 1]。

79.Java有哪几种基本数据类型？

答：byte，short，int，long，double，float，boolean，char。

80.get和post请求的区别？

答：1.post请求更安全：请求参数不会作为url的一部分。

2.post请求发送的数据更大：get对url的长度有限制。

3.传参方式不同：get请求参数放在url中，post请求参数放在request body中。

4.get请求产生一个tcp数据包，post请求产生两个：get会把header和data一起发送出去，post先发送header，没问题再发送data。

81.索引优化？

答：1.联合索引首字段不要用范围查询：联合索引第一个字段就范围查询就不会走索引，mysql可能觉得第一个字段就范围查询，结果集会很大，回表查询效率不高，还不如全表扫描。

2.避免强制走索引，除非能确切证明走索引确实比全表扫描效率高。

3.覆盖索引优化：不要使用select *，而是select 具体字段，因为select *一定会回表查询，而select 的具体字段如果已经被索引覆盖，就可避免回表查询。

82.分表策略有哪些？

答：水平分表：把一个表分成结构完全一致的多个表，表中数据根据特定规则划分到这些表中，如根据id取模。

垂直分表：根据字段查询的频率不同，将表的字段进行拆分，进行冷热数据分离，提高查询性能。

83.MySQL了解什么存储引擎？

答：1.InnoDB：MySQL默认事务型存储引擎。支持事务，外键，行级锁。

2.MyISAM:不支持事务，外键，行级锁。优势是访问的速度快。

84.InnoDB的锁有什么？行级锁原理？

答：行锁：共享锁和排他锁。表锁：意向共享锁和意向排他锁。间隙锁，临键锁。

行级锁原理：通过给索引项加锁来实现的，只有根据索引条件来查询数据才能使用行级锁。

85.MySQL日志？undo log作用？bin log？

答：MySQL有三大日志：Redo Log， Undo Log，Bin Log。

undo log作用：回滚事务和实现MVCC。

bin log:记录的是逻辑日志，即原始的SQL语句，是MySQL自带的。作用：数据备份和主从同步。

86.MySQL四个隔离级别分别解决什么问题？怎么实现的？

答：读未提交：解决不了任何问题。

读已提交：解决脏读。因为只会读到已提交的数据。

可重复读：MySQL默认隔离级别，解决脏读，不可重复读。因为事务开启后，某一数据在第一次读取的时候会生成一个快照，再次读取相同数据直接读取快照的内容，就解决了不可重复读的问题。

串行化：解决脏读，不可重复读，幻读。读写都加锁实现，同一时间只允许一个事务执行，效率低下。

87.JVM原理？内存管理？直接内存是否受到JVM管理？

答：原理：JVM是Java语言跨平台的核心所在，当我们通过javac命令把Java代码编译成.class文件之后可以把它们放在JVM中进行运行，之所以能跨平台是因为jdk对于不同的操作系统提供了不同的JVM。

内存管理：1.虚拟机栈：服务于Java方法，每一个Java线程都会对应一个虚拟机栈。

2.本地方法栈：服务于Native方法，用来执行Java本身不能执行的功能，如需要用到C++的函数。

3.程序计数器：寻找下一个要执行的程序。

4.方法区（元空间）：主要存储类加载信息，常量池等等。在老的内存模型中不会使用直接内存，但在新的内存模型中元空间的数据被放在堆外内存也就是直接内存，加大内存空间。

5.堆：主要存储对象内部的数据，分为老年代和新生代。

直接内存不受JVM管理，因为分配和回收成本较高。

88.Linux常用命令？

答：常用命令：ls：查看文件和目录。  pwd：查看当前目录。 mkdir：创建目录。

touch：创建空文件。  cd：切换目录。   cat：查看文件内容。   

echo：创建带内容的文件。     cp：拷贝。    rm：删除文件。    ip addr：显示ip。

grep：查找字符串。

89.Spring的AOP?

答:将与核心业务无关的代码独立的抽取出来，形成一个独立的组件，然后以横向交叉的方式应用到业务中的过程就是AOP。

AOP的优点：代码可复用性强，易维护，使开发者更关注业务逻辑。

AOP有几个重要的概念：

1.连接点：可以织入切面的位置。

2.切点：真正织入切面的方法，一个切点对应多个连接点。

3.通知：增强，具体织入的代码，通知又包括前置通知，后置通知，环绕通知，异常通知，最终通知。

4.切面：切点加通知。

90.分布式事务？

答：分布式事务是指不同的服务通过网络远程协作完成的事务，例如创建订单扣减库存，转账事务。

提到分布式事务就得涉及到CAP定理：C是一致性，A是可用性，P是分区容错性。CAP不可同时满足，一次只能满足其中两个。这就有了BASE理论：BASE理论包含三个思想，基本可用，软状态和最终一致，即允许存在数据短时间内不一致的软状态，但最终达到一致。

基于Seata框架实现的分布式事务有四种模式：XA ，TCC， AT， SAGA。

91-120

91.注册中心是做什么的？nacos和gateway怎么用的？

答：注册中心是用来实现微服务的自动注册和发现，是分布式系统的核心基础服务。

nacos：提供了服务注册，服务发现，服务健康检测，动态配置实现配置热更新等功能。

gateway：API网关，负责承接所有请求并统一管理，geteway实现了路由转发，负载均衡，过滤器，限流等功能。

在微服务中，通常将nacos和gateway一起使用，通过nacos提供的服务者测和发现功能，gateway可以通过nacos获取所有的可用微服务信息，并将请求转发到相应的微服务节点，实现安全控制。

92.压测平时会看哪些指标？

答:响应时间，吞吐量和失败率。

93.JVM参数设置过吗？调优？

答:有了解过。

1.针对JVM堆的设置，一般通过-Xms   -Xmx设置限定最小，最大值，为了防止垃圾收集器在最小最大之间收缩堆而产生额外的时间，通常将最大最小值设置为相同的值。

2.年轻代和老年代根据默认比例（1：2）分配内存，可以通过设置它们之间的比率NewRadio来设置大小。

94.http1.0和http2.0有什么区别?

答:1.连接复用:http1.0每个http请求都会建立一个新的tcp连接,请求结束立即关闭。http2.0引入了多路复用技术，允许在同一个tcp连接上并发发送多个请求和响应，避免了建立和关闭多个连接的开销，提高了性能和效率。

2.请求-响应方式不同：http1.0用的是单向请求响应机制，每个请求对应一个响应。而http2.0引入Server Push机制，服务端可以在客户端请求之前主动推送资源，提高页面响应速度。

3.头部压缩：http1.0请求和响应头部包含大量重复信息。http2.0则对头部进行了空间压缩，降低网络传输的开销。

4.二进制协议：http1.0采用文本格式传输，效率低。http2.0采用二进制格式传输，效率高。

5.流控制和优先级：http1.0没有流控和优先级，都是按照顺序传输的。http2.0引入流控制和优先级的机制，可以根据对请求进行优先级排序和流量控制，确保重要请求优先处理。

6.长连接的支持：http1.0只支持短连接，一个请求结束立即关闭。http2.0支持长连接，一个tcp连接可以承载多个请求，提高性能。

95.HashMap怎么扩容？

答：当HashMap被创建，容量为空，底层是一个空数组，第一次put元素容量会变成16，默认负载因子0.75，阈值等于数组长度乘以负载因子，之后每一次元素数量达到阈值，就会触发一次扩容，数组大小和阈值都变成原来的两倍，当数组的一条链长度大于等于8且数组长度大于64，这条链就会转为红黑树。

96.LinkedList在什么条件下是无序的？

答：随机插入是无序的。

97.Spring事务失效有几种场景？

答：1.抛出检查时异常，Spring默认只会在抛出运行时异常或Error的时候回滚，解决也很简单，只需要配置一下roolbackFor属性为Exception.class属性即可。

2.异常被自己捕获。

3.同一类中的方法调用。因为事务是基于动态代理实现的，如果直接被类的真实对象调用，那就不会走切面逻辑，事务失效。

4.方法使用final或static修饰。如果Spring使用了CGLib代理实现，而业务方法使用static或final会导致CGLib无法重写代理类的子类来实现代理，导致事务失效。

5.方法不是public导致事务失效。

6.没有被Spring管理。

98.如何判断环的人口，不用HashMap如何实现？

答：快慢指针相遇后，再定义一个指针指向头节点，满指针和新的指针同时移动，每次移动一步，他们相遇的节点就是环的起始位置。

99.Sentinel怎么配置的？

答：只用过控制台配置。

100.前后端交互怎么实现？

答：通过Nginx反向代理。

101.Nginx有了解过吗？

答：Nginx是非常好用的反向代理服务器，只需简单配置，前端就能把请求发送到nginx由nginx反向代理到服务器返回结果。

102.如何优化LRU?

答:MySQL对LRU缓存的优化：

1.LRU通常是基于链表实现，当访问一个数据，立即将他移动到链表头部，这样下来，链表头部的数据就是热数据，链表尾部的数据就是冷数据，但对于经常访问的热数据，每次访问都要进行移动，性能损耗就有点大。MySQL基于以上这点进行了优化，只有在热数据区域的后四分之三部分被访问才会移动到链表头，访问前四分之一的数据不会移动。

2.MySQL中并不是等LRU缓存的数据满了才去挑选LRU缓存尾部的数据页刷入磁盘，而是有一个后台线程，他会运行一个定时任务，定期的把LRU缓存链表尾部的一些数据页刷入磁盘。

103.MySQL和MongoDB的区别？

答：1.数据库类型不同：MySQL是关系型数据库，MongoDB是文档型数据库。

2.索引不同，MongoDB可以对任何属性加索引，MySQL只能对列加索引。

3.延迟：MongDB写入延迟较低，MySQL延迟较高。

4.事务：MongDB不支持事务，MySQL支持事务。

5.查询语言不同：MongDB面向文档查询，可以用查询JSON数据。MySQL只能用SQL语言。

104.B+比B树好在哪？

答：1.B+树中间节点没有数据，只有索引，B树每个节点都存数据，所以B+树存储性能更高。

2.B树进行范围查询需要查询到范围下限，再通过中序遍历直到找到范围上限，比较耗费性能。

B+树范围查询则只需要找到下限的叶子节点，再沿着叶子节点的顺序遍历，直到找到范围上限，性能相比B树更优。

3.B树每次查询最好情况根节点返回数据，最坏情况搜索到叶子节点返回数据，查询性能不稳定。

B+树每次查询都会搜索到叶子节点性能稳定。

105.微服务架构怎么理解？

答：1.每个微服务都能独立部署和扩展，相互之间只需要轻量级机制彼此通信，实现解耦合。

2.每个微服务围绕自己独立的业务设计和开发，职责单一，出问题容易定位。

3.每个微服务之间可以使用不同的数据库，更具灵活性。

总体来说，微服务将单一应用拆分成一组小型服务，从而提高可扩展性和可维护性。

106.微服务引入的缺点？

答：1.服务粒度大小难以划分。

2.分布式复杂性增大，主要体现在分布式事务，网络延迟，系统容错性等问题解决难度较大。

3.微服务数量较多，对运维，部署更难。

107.如何监控代码的性能？

答：可以使用专业的Java性能分析和监控工具，如Jprofiler。

108.怎么实现观察者模式？

答：观察者模式：当一个对象状态发生改变，会自动通知所有依赖他的对象。

在Java中，可用两个类实现：java.util.Observable类用于定义被观察者，java.util.Observer接口用于在被观察者改变状态时更新自身状态。

109.堆排序算法了解吗？

答：首先用将要排序元素建立一个大根堆，取出堆顶与末尾元素交换，不断重建和交换，这样就取出最大元素，次大元素...直到取完所有元素。（小根堆也同理）。

平均时间复杂度O（nlogn），最坏O（n^2）。

110.红黑树的数据结构？

答:由于平衡二叉树插入和删除容易破坏平衡，需要不断调整树的形态，所以有了红黑树，一般的插入和删除不会破坏红黑特性，无需频繁调整树的形态，即使是需要调整，也是常数级别。

数据结构：1.每个节点不是红就是黑。2.根节点和叶子节点是黑。3.不存在相邻的红节点。4.每个节点到任一叶子节点的路径上，包含的黑节点数目相同。

111.ArrayList和Vector的区别？

答：1.Vector的写操作采用了同步机制，所以他是线程安全的。ArrayList没有同步机制，不是线程安全的。

2.扩容机制不同：ArrayList一次扩容50％，Vector一次扩容100％。所以，Vector更适合存储大量数据。

 112.分布式的一致性算法?

答:Raft算法:

概念：分为三类节点:Leader总统节点，负责发出提案；Follower追随者节点，负责同意提案；Candidater候选人，负责争夺Leader。

步骤：分为两个子问题：Leader选举和状态复制。

Leader选举：

1.每个Folllower都有一个定时器，如果时间到了集群中仍然没有Leader，Follower将声明自己是Candidater并参与Leader选举，同时将消息发给其他节点争取投票。

2.获得多数支持的Candidater将成为第M任Leader。在任期的Leader会不断发送自己的心跳给其他节点证明自己活着，防止其他节点参加Leader选举。

状态复制：

1.Leader负责接收来自Client的提案请求，提案内容包含在Leader发出的下一次心跳中。

2.Follower接收到心跳后回复Leader心跳。

3.Leader接收到多数派Follower的回复后确认提案并写入自己的存储空间，恢复client。

4.Leader通知Follower确认提案并写入存储空间，随后所有节点拥有相同数据。

脑裂问题：

如果网络异常可能导致出现多个Leader导致脑裂问题。当集群再次联通时，旧Leader将成为新Leader的Follower节点。

113.一致性Hash算法？

答：一致性Hash算法是一种Hash算法，它能够在Hash输出空间发生变化时，引起最小的变动。

具体实现是将整个Hash输出空间设置为一个环状区域。改环状区域用[0，2^31 - 1]标识0与2^31 - 1重合。对于用户数据，先进行Hash运算定位到一个位置，顺时针移动遇到的第一个服务器就是它分配的服务器。当一台服务器下线，影响的只有它与它相邻的服务器，对其他无影响。

114.HashMap7，8扩容机制？

答：区别：1.7基于数组＋链表。1.8基于数组＋链表＋红黑树。

扩容机制都是初始容量16，阈值0.75，到达阈值以2^n扩容，最多扩容30次。

115.Redis集群？

1.主从模式，读写分离。

2.哨兵模式：在主从模式的基础上，引入主节点的自动故障转移。

主观下线：一个哨兵判定主节点挂了。客观下线：多数哨兵判定主节点挂了。

客观下线需要实行故障转移，选举一个从节点成为主节点，原主节点重连也只能成为新主节点的从节点。

3.分片集群模式：数据分片：0-16383共16384个哈希槽，集群的每一个节点负责一部分哈希槽。

分片集群模式自带哨兵模式。

116.MQ消息如何保证不重复/不丢失？

答：1.消费幂等性：消费者在处理消息时，需要保证重复消费不会产生副作用。

2.消息确认机制：MQ一般提供消息确认机制，例如ACK机制。消费者成功消费消息发送ACK给MQ，否则不发送，那MQ可以把消息发送给其他消费者处理。

3.消息重试机制：消息处理失败，MQ可以重新投递消息给消费者处理。可以在消息的header设置失败重试的最大次数，到达次数仍然失败将消息投递到死信交换机。

4.持久化机制：MQ可以将消息持久化到磁盘中，防止MQ重启导致的消息丢失。

117.Java和C++的区别?

答:1.C++支持面向对象和过程，Java只支持面向对象。

2.C++是一种与平台相关的语言，Java与平台无关，一次编写到处运行。

3.C++只能编译不能解释，Java可以编译和解释。

4.C++中内存管理是手动的，Java内存是由系统管理。

5.C++强烈支持指针，Java对指针支持有限。

6.Java底层是用C++编写的，不仅继承了C++的优点，还摒弃了C++的多继承，指针等难以理解的概念，因此Java具有功能强大和简单易用的特性。

118.HashMap的hash计算原理？

答：首先调用hashCode（）方法，获取key的hashCode值为h，h右移16位与h进行异或运算，最后得到h的值与（table.length - 1）进行与运算，获取该对象的保留位，最后计算出下标。简单理解成求模取余法。

119.读写锁了解吗？

答：读写锁是一种特殊的同步机制，它允许多个线程同时读，只允许一个线程写。ReentrantLock提供了readLock和writeLock方法获取读写锁。读写锁的实现基于AQS框架，他通过内部维护一个双向链表，根据线程的状态和等待时间来决定获取锁的优先级。

120.MyBatis #{} 和 ${} 区别？

答：#{}使用预编译处理，是占位符。${}是拼接符，先拼接再解析SQL，会有SQL注入的风险。

121-150

121.MyBatis大批量插入修改优化？

答：MyBatis提供Batch模式进行批量修改和插入，效率较高。原理是batch模式下MyBatis把sql打包成一个大sql交给数据库执行，减少数据库连接次数，其二就是batch模式减少了预编译的次数。

122.Lock和synchronized区别？

答：1.synchronized是是Java内置的线程同步关键字。Lock是JUC包下的接口，他有很多实现，如ReentrantLock。

2.用法不同：synchnorized用来修饰方法和代码块，Lock则通过lock和unlock方法同步，lock更加灵活。

3.synchnorized只支持非公平锁，Lock支持非公平锁和公平锁。所以在同步复杂的场景下，建议用Lock。

123.Redis持久化机制？

答：1.RDB快照：全量持久化方式，将数据以压缩的二进制格式保存在RDB文件中。

优点：全量数据快照，RDB文件占用空间小，适用于数据备份和灾难恢复。

缺点：RDB是周期性持久化的，会导致某个时间点之后的数据丢失。生成快照时会阻塞Redis服务器，影响性能。

2.AOF日志: 追加式持久化方式，记录的是命令。

优点：记录每一条写的数据，恢复更精确。实时性更好，可达秒级。

缺点：占用更多磁盘空间。需要执行每一条命令，恢复速度慢。

124.对象在什么时候进入老年代？

答：JVM会给对象设置记录年龄，每经过一次GC不被回收，年龄加一，到达设定的阈值，默认为15就会被移入老年代。可通过-XX:MaxTenuringThreshold调整这个阈值。

125.Linux查看被占用端口命令？

答：netstat -参数 （ | grep 查看端口号 ）

126.equals和hashcode?

答:equals方法默认调用的是==，如果两者是基本数据类型，比较的是字面量；如果是引用数据类型，则比较的是地址值，可以通过重写equals方法来比较属性，属性相等返回true。

hashcode用于集合容器，如hashmap，hashset。用hashcode可以定位到容器中的桶位置，桶里有其他元素，才会用equals一一比较去重，所以hashcode的作用就是减少equals的次数，提高效率。

127.mysql分页实现？

答：一般有两种，

1.limit a，b：表示从第a + 1行开始，返回b行数据。

2.limit a offset b：标识从b + 1行开始，返回a行数据。

128.mybatis动态标签?

答：mybatis支持动态sql，就是sql不是固定的，支持在程序运行中动态变化，而mybatis提供了动态标签来支持动态sql的编写。例如：

1.<if>标签有个test属性，用于编写条件变量，只有条件满足才会把标签中的sql拼接到原sql上面。

2.<choose>标签类似于Java中的switch...case...语句，包含<when>和<otherwise>子标签，只有当<when>条件都不满足的时候，才会添加<otherwise>的内容。

3.<where>标签，支持灵活的sql格式校验，去除多余的and或or。

3.<set>标签，一般嵌套<if>标签，实现update语句的动态拼接。

129.Redis实现Session共享登录怎么实现？

答：当Tomcat集群数量多的时候，同一session在每一台tomcat上都要保存，浪费空间。所以用Redis存储session优势明显。

130.短信登陆怎么实现的？

答：短信发送借助阿里云提供的SMS服务实现，服务端只需要把验证码存入Redis，并设置过期时间。

131.Lua脚本实现分布式锁逻辑？

答：lua脚本用来保证setnx和expire两条命令的原子性，以防获取锁后服务区宕机导致锁无法释放。逻辑是这样的：尝试执行lua脚本获取锁，获取成功并存入线程标识，超时释放或者业务执行成功主动释放。

132.Redis用户点赞怎么实现的？

答：用户点赞的核心功能在于一个用户只能点赞一次，如果未点赞，点赞+1，已点赞，点赞-1。

我的实现是这样的，用Blog类代表用户正在查看的博客，添加一个isLike字段表示当前用户是否已经对这篇博客点赞，这个字段在查询博客的时候就顺便把这个用户的点赞记录查出来了，给isLike赋值返回前端，这个查询是否已经点赞是基于Redis的set实现，set存入已点赞用户id，判断id是否存在。

133.Redis的BigKey解决？

答：1.使用Memcached。

2.拆分成多个key，分摊数据。

134.BitMap实现用户签到功能，如何实现的？

答：Redis中利用String数据结构实现的BitMap，因此上限512M，也就是2^31位。把BitMap的每一位映射到每一天，1代表签到，0代表没签。

135.RabbitMQ交换机类型？

答：1.Fanout：路由到所有和他绑定的队列。

2.Direct：路由到BindingKey和RoutingKey完全一致的队列。

3.Topic：路由规则更加复杂，key由.分隔，且支持用特殊字符进行模糊匹配。

4.Headers：根据消息中的Headers进行完全匹配，性能较差。

136.MySQL中select语句的执行流程？

答：大体来说，MySQL分为server层和存储引擎层。

server层包括连接器，查询缓存，分析器，优化器，执行器等，涵盖MySQL的大多数核心服务功能。存储引擎层包括InnoDB，MyISAM，Memory等，默认使用InnoDB。

连接器用于和客户端建立连接。在建立连接并且发出一个查询请求后，MySQL会先去缓存查看是否存在这条sql作为key的键值对，如果存在，直接返回缓存结果。否则，分析器会对sql进行词法分析，判断那些字段作为表名，哪些作为列名，接着语法分析，校验格式是否正确。接着就是当存在多个索引，优化器选择效率最高的一个索引匹配顺序。最后是执行器调用存储引擎执行sql。

137.MySQL的隐式类型转换？

答：当操作符与不同类型的操作数一起使用时，会发生隐式类型转换导致索引失效。

138.CAS有哪些问题？

答：1.ABA问题。

2.长时间自旋不成功，浪费cpu。

3.只能针对一个共享变量，解决：封装成对象。

139.线程池几种常用的阻塞队列？

答：1.LinkedBlockingQueue：容量是2^31-1，可以认为是无界队列。

2.DelayedWorkQueue：会根据任务延迟的时间长短进行优先级排序，内部采用的是“堆”的数据结构。

140.RabbitMQ和Kafka的区别？

答：1.Kafka处理大数据量比RabbitMQ快，Kafka吞吐量高延时低。

2.RabbitMQ可靠性较高。

3.RabbitMQ使用磁盘存储消息，可靠性高。Kafka将消息存储在内存中的日志中，但可能在在节点故障时丢失数据。

4.使用场景不同：RabbitMQ用于高可靠性和持久性场景，如实时通信，金融交易等。

Kafka用于高吞吐量和低延时的场景，如日志分析，实时公交数据等。

141.优先队列的原理？

答：优先队列通过堆实现，堆通过数组实现。添加元素先把元素添加到数组然后上浮到合适位置，出队列会把第一个元素和最后一个元素交换，再通过下沉的方式调整到合适位置。

142.讲讲平衡二叉树？哪些树是平衡二叉树？

答：平衡二叉树在满足二叉搜索树的条件下，且对于每一个节点其左右子树的高度不会相差超过1。平衡二叉树由：红黑树，AVL树等。

143.bean的装配过程?

答:1.实例化bean。

2.bean属性赋值。 

3.检查Bean是否实现了Aware相关的接口, 如果实现了接口, 调用接口中方法。

4.执行bean后处理的的before（）。

5.检查Bean是否实现了InitializingBean接口，如果实现了则调用接口方法。

6.初始化bean。

7.执行bean后处理器的after（）。

144.Java序列化？

答：序列化就是将Java对象转化为二进制格式。

JDK提供了Serializable接口来声明哪些类能被序列化，且提供了ObjectOutputStream来支持序列化和反序列化。

145.Redis的zset和set有何区别？

答：zset有序的，set是无序的。zset每个元素都关联了一个评分，用于排序。

146.ssl证书是什么？

答：ssl证书是为了保证客户端和服务端之间数据传输过程不被截取，保护数据安全而建立在网站和用户之间的安全通道，ssl证书就是这个通道的数字证书，将传统http明文传输升级为https加密传输。

147.https加密过程？

答：https涉及三组密钥:1.第一组用于校验证书是否被篡改，采用非对称加密，加密对象是证书签名。

2.第二组用于协商生成对称加密的密钥，采用非对称加密，加密对象是对称加密的密钥。

3.用于传输数据的加解密，采用对称加密。

148.docker映射命令？docker查看镜像？

答：docker run  -v a:b（a主机目录映射到容器内部的b目录，可跟多个）。doker images

149.从浏览器输入url到返回结果做了什么？

答：1.浏览器对url进行解析，查看自身是否存在缓存，如果有直接返回缓存结果。

2.浏览器没缓存，电脑会看操作系统是否有缓存，如果有直接返回。

3.通过迭代，递归的方式向更高级的域名服务器发起查询请求，直到返回一个ip地址给浏览器。

4.根据ip地址建立tcp连接，客户端发送http请求，服务端返回报文，关闭tcp连接。

5.渲染数据。

150.http报文格式？

答：请求行，请求头，请求体。

151-180

151.半连接了解吗？有什么作用？

答：客户端发送syn包，服务端收到并回复syn + ack后，这时候的socket会被放入半连接队列。一个完整连接需要tcp三次握手，三次握手之前的连接就叫半连接。半连接可以设置队列大小，限制连接数，防止系统负载过大。

152.跳表是如何实现的？有何缺陷？

答：Redis中跳表是zset的底层实现。其本质上是可二分查找的有序链表，跳表在普通的有序链表上加了多级索引，通过索引实现二分查找。

缺陷：1.增删操作需要重建整个表，维护成本高。

2.比较占用空间。

153.Redis的key过期策略有哪些？

答：1.定时删除：设置定时器，key过期自动删除。

2.惰性删除：需要用到key才去检查是否过期，过期删除。

3.定期删除：每隔一段时间，定期扫描过期key删除。

4.随机删除：把设置过期时间的key放入一个字典，每次随机删除字典中一部分过期key，防止过多key同时过期导致redis阻塞。

154.select * for update where age > 18，分析加锁情况？

答：for update关键字会让查询过程中加悲观锁，至于加行锁还是表锁，看查询条件是否使用了索引，如果age建立了索引，mysql会加行锁，否则加表锁。假设age字段建立了索引，该语句中使用了>范围查询，那么会加行锁，且锁住的是age最大值后面的间隙。

155.git本地有很多commit提交，如何合并成一个？

答：使用rebase命令。

156.springboot读取配置文件的方式？

答：1.使用@Value注解。

2.使用Environment接口。

3.使用@ConfigurationProperties注解，指定配置项的前缀。

157.Linux文件文件权限修改命令？

答：chmod关键字，权限r（4），w（2），x（1）。

158.进程间通信方式?

答:1.管道,数据只能在一个方向上传输，只能用于父子或兄弟进程。

2.FIFO，可以在无关的进程间通信。

3.消息队列。

4.信号量，是一个计数器，用于进程间同步，而不是数据通信。

5.共享内存，多个进程共享一个存储区。

159.网络协议有哪几层？

答：有七层：应用层，表示层，会话层，传输层，网络层，数据链路层，物理层。

160.数据链路层传输的数据是什么？

答：数据链路层定义了在单个链路上如何传输数据，一般有两种协议：点对点协议和广播协议。

161.传输层协议的作用？

答：传输层协议一般分为tcp和udp，可根据不同的场景选择不同的传输层协议。

162.网络层协议作用？

答：确定数据交换的格式以及相关的同步问题。

163.TCP，UDP区别？

答：TCP面向连接，可靠的基于字节流传输的协议，UDP是一种无连接的协议。TCP数据可可靠完整，UDP传输速度快，实时性好。

164.TCP如何保证可靠传输？

答：1.发送确认机制。

2.丢包重传机制。

3.滑动窗口。对于大数据包拆分，一次发送一个窗口。

4.拥塞控制。数据请求急剧增多自动减少发送数据包频率。

165.mysql的模糊查询？

答：like关键字，%代表多个字符，_代表单个字符。

166.mysql的范式？

答：第一范式：属性具有原子性，不可再分。

第二范式：记录具有唯一性。

第三范式：字段没有冗余，即字段不依赖于其他字段。

167.前端传输的表单数据出现乱码如何排查？

答：这种一般都是编码问题，排查数据库，后端编码是否设置为UTF-8。

168.Redis的线程模型？

答:单线程模型：Redis的单线程，主要是指Redis的网络IO和键值对读写是有一个线程完成的。但其其他部分的功能，如持久化，异步删除，集群数据同步等是由额外线程完成的。

Redis6引入多线程模型：可以引入多个线程来处理网络请求，但是读写仍然是单线程。

169.Java如何保证共享变量的线程安全？

答：加锁，volatile加cas。

170.协程？

答：协程是建立在线程之上，比线程轻量级，完全运行在用户态里。一个线程可以有多个协程。由用户空间直接调度，不需要在内核态和用户态之间来回切换，效率高。如果线程阻塞，上面的协程可以被调度到其他未阻塞线程上运行，充分利用cpu多核。

171.死锁的条件？

答：1.互斥条件：一次只允许一个线程或进程访问。

2.请求与保持条件：持有资源并且在等待其他资源的时候不释放资源。

3.不可剥夺条件：已分配的资源不可强行剥夺，只能等待主动释放。

4.循环等待条件：资源等待的序列成环状。

172.Java实现可见性，原子性？

答：可见性：volatile。

原子性：synchnorized或者juc包下的原子类。

173.Autowired用法及原理？

答:Autowired默认按类型匹配，如果有多个bean，再按名字匹配。@Qualifier匹配注解可以指定匹配的名字。

原理可分为查找解析元信息和属性值注入两步。

174.SpringBoot自动装配原理？

答：SpringBoot自动装配就是自动把第三方的组件装配到IoC容器，不需要我们再去手动写Bean相关配置，大多数配置SpringBoot已经帮我们约定好了，也就是约定大于配置的理念。

底层是@EnableAutoConfiguration注解导入AutoConfigurationImportSelector类，这个类会扫描所有jar下面的对应的META-INF/spring.factories文件，并把所有在spring.factories文件中扫描到的全类名进行实例化加载到IOC容器中。

175.http实现文件上传下载的原理？

答：文件上传：即http请求，请求行没变化，请求头有一个属性Content-Type，设置属性值为multipart/form-data，这种格式就可以上传文件。提交方式必须为post，请求体即文件二进制格式。

下载：获取文件大小，客户端发起下载请求，接受服务端的下载数据。

176.BeanFactory和FactoryBean的区别？

答：BeanFactory是IoC的顶级对象，负责制造bean，是工厂对象。

FactoryBean是工厂bean，负责辅助Spring实例化普通bean对象。

177.JVM堆结构？

答：新生代，老年代。

178.线程同步机制有哪些？

答：1.互斥锁。对资源加锁保证某时刻只能一个线程访问资源。

2.信号量。通过信号变量的值代表状态，自己实现逻辑，比较复杂。

3.条件变量。不满足条件休眠，满足条件被唤醒。

179.ABA问题如何解决？

答：引入版本号机制，CAS比较版本号和值。

180.councurrentHashMap1.7和1.8区别？

答：1.数据结构不同：1.7采用的是Segment数组+HashEntry数组+链表，1.8采用Node数组+链表加红黑树。

2.同步方式不同：1.7用分段锁锁住一部分数据，1.8使用的是优化的synchnorized和cas解决并发安全。

3.效率：1.7一次锁住一个Segment随对应的数据，1.8只会锁住一个链表，1.8粒度更细，效率更高；另一方面，1.8引入了红黑树，提高了单线程查询效率。

181-210

181.JVM怎么创建一个对象？

答：按步骤依次为：加载，连接（验证，准备，解析），初始化，使用，卸载。

182.哪些场景会触发类的加载？

答：1.创建类的实例对象。

2.类的静态方法被调用。

3.类的静态成员变量赋值。

4.调用反射创建实例。

182.双亲委派机制有什么作用？

答：1.避免类的重复加载。如果父类被加载过，直接返回加载的父类。

2.保证核心API不被篡改。在Java中，有一些核心类库，如java.lang包下的类，是由BootStrapClassLoader加载的，如果被篡改，会影响整个Java程序的运行，而双亲委派机制可以保证这些核心API的安全性。

183.线程有哪些状态？

答：五种：1.初始状态：刚被创建。

2.就绪状态：等待获取cpu的使用权。

3.运行状态：获取cpu使用权。

4.阻塞状态：暂时放弃cpu的使用权。

5.终止状态：执行完毕或异常退出。

184.一个线程包含哪些信息？

答：程序计数器，堆栈信息，寄存器。

185.SpringBoot的Web服务器处理过程？

答：一般是指SpringMVC，流程如下：

1.客户端发请求到前端控制器（DispatcherServlet）。

2.前端控制器根据请求信息调用HandlerMapping，获取对应Handler。

3.解析Handler，交给适配器（HandlerAdapter）处理。

4.适配器根据Handler调用真正的处理器处理请求，即业务逻辑。

5.处理器返回ModelAndView对象，Model是数据对象，View是逻辑上的View。

6.ViewResolver根据逻辑View查找实际的View。

7.前端控制器把返回的Model传给View，也就是这一步进行视图渲染。

8.返回View给请求者。

186.前中后序遍历的区别?

答:前序遍历:根左右。中序遍历：左根右。后序遍历：左右根。

187.网络层和传输层有何区别？

答：1.网络层用于主机之间的通信，传输层用于进程之间的通信。

2.网络层通过IP地址识别通信主机，传输层通过端口号识别应用进程。

3.网络层只对报文头部进行差错检测，传输层会对整个报文进行差错检测。

188.网络层和传输层各有什么协议？

答：网络层：IP，ICMP，ARP。传输层：TCP，UDP。

189.操作系统组成？

答：1.驱动程序：最底层的，直接监控各类硬件，负责隐藏硬件的具体细节，并向上提供抽象通用的接口。

2.内核：拥有最高级权限。

3.接口库：把系统提供的基本服务包装成应用程序能直接使用的API。

4.外围：除以上三者的其余部分。

190.什么是mysql的索引下推？

答：索引下推是mysql5.6引入的新特性，它可以在对联合索引遍历的过程中，对索引包含的索引字段先进行判断，过滤掉不符合条件的索引在进行回表，能有效减少回表次数。

191.Java多线程出现问题的原因?

答：多线程并发问题是指多个线程同时访问共享资源而产生竞争和冲突，从而导致程序出现不可预测，不稳定的行为。常见的多线程并发问题包括：线程安全问题，死锁，线程饥饿等。线程安全问题是指多个线程对同一变量并发读写产生相互覆盖的问题，从而导致不可预测。

192.Full GC触发条件？

答：1.堆内存空间不足。

2.调用System.gc（）方法触发强制Full GC。

3.新生代GC频繁：频繁触发新生代gc（minor gc），却仍然内存不够用。

193.有哪些限流方式？

答：1.固定窗口算法，实现简单性能高，但是临界流量最高可达阈值两倍。

2.滑动窗口算法，解决瞬时高峰问题，但是流量不够平滑。

3.漏桶算法：可以平滑流量，但是效率固定，不允许瞬时流量激增。

4.令牌桶算法：允许突发流量激增，更灵活。

194.分布式事务的一致性方案？

答：概念：TM（事务协调者）, RM（事务参与者）

1.XA： 两阶段提交，一阶段等所有RM都返回结果再决定提交还是回滚，效率低。

2.AT：也是两阶段提交，不同的是不需要等所有RM都返回结果，而是一个RM失败再根据日志执行回滚，效率比XA高。

3.TCC：三阶段：try（资源预留），confirm（提交），cancel（释放预留资源），无全局锁，效率较高。缺陷是代码侵入较强，且confirm，cancel需要保证幂等性。

4.SAGA。

195.讲一下AQS?

答:AQS的全称是AbstractQueuedSynchronizer，译为抽象队列同步器，是juc包下的类，是一个构建锁和同步器的框架，ReentrantLock就是基于AQS实现的。

AQS的核心思想是，如果被请求的资源空闲，就将请求资源的线程设置为有效的工作线程，且将资源设置为锁定状态。如果请求的资源被占用，就需要一套线程阻塞等待和被唤醒时锁分配的机制，这个机制AQS使用CLH（虚拟的双向队列）队列锁实现的，即将暂时获取不到锁的线程加入到队列中等待。

196.讲一下BIO，NIO和AIO区别？

答：BIO是同步阻塞的，效率差，适用于连接数小的场景。

NIO是同步非阻塞（多路复用）的，性能好，适用于连接数多且连接时间短的场景。

AIO是异步非阻塞的，性能好，适用于连接数多且连接时间长的场景。

197.Spring如何自定义并处理异常？

答：继承RuntimeException以自定义异常。

使用@ControllerAdvice标识异常处理类， 和@ExceptionHandler定义处理具体异常的方法。

198.Java泛型上下界？

答：泛型的上界指定了必须是某个类及其子类或者实现某个接口，如 <T extends B>。

泛型的下界指定了必须是某个类的超类， 如<T super B>。

199.Redis实现延时队列?

答：Redis是用zset实现延时队列的。主要步骤如下：

1.把需要延迟处理的任务放到zset中。

2.启动一个子线程不断从zset中获取当前时间可以处理的任务，并执行处理逻辑。

200.stream的中间操作和终止操作有哪些？

答：中间操作：filter（过滤），distinct（去重），sorted（排序）等。返回新的流。

终止操作：forEach，toArray，min，max等。

201.注册bean的方式？

答：注解，xml。

202.hashtable扩容？

答：Hashtable每次扩容为原来的两倍＋1。

203.Spring的DI？DI和IOC关系？

答：DI是依赖注入，是一种通过外部注入对象的依赖关系来解决对象依赖的方法。

DI是IOC的一种实现方式。

204.左连接？内连接？

答：左连接又叫左外连接，指取出左表所有记录与与右表匹配，没匹配上则用null代表右表的列。

内连接去两表的交集部分。

205.CountDownLaunch？

答：CountDownLaunch是Java中多线程同步的工具类，用于控制线程的顺序，他的核心思想是：设置一个计数器，每次线程完成任务后，计数器减1，当计数器减到0时，所有等待该计数器的线程开始执行，他的构造函数中需要传入一个整数，表示需要等待的线程数量。

API：countDown（）：计数器减1。                      await（）：等待计数器减到0再执行。

205.oom如何排查？

答：查看系统日志，使用jstat工具，检查配置文件等。

206.内核态和用户态的区别？

答：用户态：不能直接使用系统资源，也不能改变CPU工作状态，只能访问用户程序自己的存储空间。

内核态：可以使用计算机的所有硬件资源，需要执行操作系统的程序就必须切换到内核态。

207.什么是热部署？

答：热部署就是应用在运行时升级，不需要重启。对于Java程序来说，热部署就是在运行时更新Java类文件，同时触发Spring等第三方框架重新加载的过程。

208.年轻代为什么使用复制算法？

答：因为年轻代存活的对象较少，用复制算法只需要复制少量对象，效率高且不需要占用太多内存。

209.线程池参数，核心参数的设置标准？

答：核心线程数：cpu密集型：cpu核心数的1.5到2倍。  io密集型：cpu核心数的2倍以上。

存活时间单位：cpu密集型：0。   io密集型：1分钟以上。

队列：cpu密集型：有界队列。    io密集型：无界队列。

210.两个线程之间如何传递参数？

答：构造方法，set方法。

211-240

211.Type字段有哪些？

答：all：遍历所有数据。   index：走索引。    ange：范围查询。

212.跳表插入数据的过程？  

答：1.随机指定这个元素在跳表中的层数，如果层数大于已有层数，还需要扩大层数。

2.依次把数据插入每一层。

213.tcp为什么要3次握手和4次挥手？

答：三次握手双方都能确认对方发送和接收是正常的。

服务端在受到客户端断开连接的请求后，并不会立即关闭连接，而是先发送一个ACK包告诉客户端受到连接关闭的请求，只有当服务器的所有报文发送完毕之后，才发送FIN报文断开连接，因此需要四次挥手。

214.为什么第4次挥手后要等2MSL？

答：为了确保服务端收到第四次挥手的报文，假设服务端未收到第四次挥手的报文，他就会重发一次第三次挥手，来回时间刚好2MSL。

214.limit怎么优化？

答：1.使用游标（Cursor），可以避免将完整的结果集加载到内存中，提升性能。

2.使用order by子句加速查询。

215.young gc时机？

答：新生代的Eden区满了就会触发young gc，用“标记-复制”算法。

216.堆内存分布？

答：堆分为新生代和老年代，新生代又可分为一个Eden区和两个Survivor区。

217.IOC三级缓存？

答：IOC三级缓存解决的是bean循环依赖问题。

一级缓存： 存储完整的单例bean对象, 属性都已赋值。

二级缓存：存储早期单例bean对象, 属性没有赋值。

三级缓存：存储单例工厂对象, 创建单例bean的单例工厂对象。

218.HTTP协议在哪一层?

答：应用层。

218.https结构？

答：https是在http基础上加了SSL/TLS协议，即加密模块，使得数据加密传输。

219.代码块执行顺序?

答:一个类：静态代码块->普通代码块->子类构造方法。

多个类：父类静态代码块->子类静态代码块->父类普通代码块->父类构造方法->子类普通代码块->子类构造方法

220.Java迭代器？

答：迭代器是一种对象，它允许按顺序遍历集合中的元素，而不需要知道集合的底层结构。

优势：1.并发安全性：迭代器提供了一种安全的方式来遍历集合，通过维护迭代器的状态来保证遍历过程中不会发生并发安全问题。

2.通用性：迭代器是一种通用的设计模式。

221.线程池的API？

答：