常见面试题200道和答案

Patrick Martin

已于 2023-12-26 13:40:12 修改

阅读量542

点赞数 9

文章标签： java spring spring cloud java-rabbitmq

于 2023-12-21 14:22:49 首次发布

本文链接：https://blog.csdn.net/superppz60/article/details/135129349

版权

Java基础（

线程，jvm模型，jmm模型，

jvm结构，类加载机制，jdk调优命令，类核心加载机制:双亲委派加载机制

gc算法，垃圾收集器，调优

java8特性

git分支

synchronized，同步，重量级锁，

volatile实现机制，内存语义，jmm内存模型

多线程，dcl，并发cas，并发aqs和重入锁，并发工具集合，线程池框架)

linux，yum和其他软件安装

websocket，

spring ioc，aop，日志，spring事务和注解

springboot2.x，springcloud，微服务

mybatis

tomcat，

jenkins，

设计模式，

分布式链路跟踪sleuth

docker，compose，docker集群

配置中心和注册中心zookeeper，dubbo，nacos

消息队列rabbitmq，amqp，rocketmq

kafka，

redis，集群，主从，哨兵机制，

mysql innodb explain 主从分裤分表 mvcc

分布式事务，分布式锁

hbase

elasticsearch

mongodb

架构内容:Skywalking，netty，sentinel，seata，gateway，springsecurityOAuth2,filebeat elk

1hashmap的实现原理，初始容量16，如何扩容，红黑树的原理，左旋右旋，为什么线程不安全

百度安全验证（实现为数组+链表或者数组+红黑树。初始数组容量是16，当数组使用比例达到扩容因子0.75时扩容，每一个桶接一个链表达到8时变成红黑树，小于6时变回链表）。

HashMap为什么线程不安全？-CSDN博客

2while用在多线程里会导致cpu占用率过高

https://www.cnblogs.com/hanzq/p/17332665.html

3AQS的实现原理

AQS实现原理看这一篇就够了 - 知乎

4快照读和当前读

https://blog.csdn.net/qingqingxiaocao1989/article/details/125094127

5 redis和mysql一致性怎么保证 redis hash，多线程多个参数是怎么配合工作的

https://www.cnblogs.com/huang580256/p/17299585.html（有图推荐）

先创建core个线程，再放满阻塞队列等待，再创建外包线程 （核心线程数到最大线程数之间的线程）

6联合索引命中左索引（a b c 只要带a，不管是a，ab，abc都能命中）

MySQL联合索引的命中规则_联合索引命中规则-CSDN博客

7工厂模式的使用（不知道怎么说，我觉得这是一种对代码的归纳和思想）？使用过什么设计模式？

百度安全验证

8如何处理in条件导致的查询慢（分成每次只查500条，最后合并起来，分批次多次查询）

mysql中in大量数据导致查询速度慢怎么优化? - 知乎

9不走索引的情况有哪些

1.查询谓词没有使用索引的主要边界，换句话说就是select *，可能会导致不走索引

2.单键值的b树索引列上存在null值，导致COUNT(*)不能走索引，索引列存在空值

3.索引列上有函数运算，导致不走索引

4.隐式类型转换导致不走索引

5.表的数据库小或者需要选择大部分数据，不走索引

6.！=或<不等于>，可能导致不走索引

7.表字段的属性导致不走索引，字符型的索引列会导致优化器认为需要扫描索引大部分数据且聚簇因子很大，最终导致弃用索引扫描而改用全表扫描方式

8.使用like,in等可能导致不走索引

Sql 中哪些情况可能不会走索引_sql不走索引的情况-CSDN博客（简约）

15个必知的Mysql索引失效场景，别再踩坑了！ - 知乎（全面的版本）

10Java基础包括什么

1、Java语言基础：包括环境搭建、基本数据类型、包装类、变量、常量定义、控制结构、String字符串处理等；

2、Java语言面向对象：面向对象思想、类声明与对象实例化、成员变量、方法重载，封装性以及子类继承与多态特性。

3、Java8的新特性包括：Lambda表达式、流式操作、函数式接口、接口默认方法等。

4、Java应用：多线程编程、框架集成（Spring、Mybatis）、数据库操作（JDBC）、IO Stream字节流处理等。

https://baijiahao.baidu.com/s?id=1759933414605011481&wfr=spider&for=pc（）

11~spring事务失效的8种场景

Spring 事务失效的 8 种场景！-CSDN博客

@Transactional注解的方法之间调用事务是否生效及其他事务失效场景总结_transactional注解生效-CSDN博客

12创建线程的几种方式

大家都说Java有三种创建线程的方式！ - 哔哩哔哩

13final关键字的使用

https://baike.baidu.com/item/Final/18832052?fr=aladdin

14线程的5种状态

线程生命周期及六种状态_线程的生命周期和状态-CSDN博客

15string，stringbuilder（线程不安全）和stringbuffer（线程安全）的区别

String和StringBuffer及StringBuilder的区别-CSDN博客

底层的区别是：

https://blog.csdn.net/qq_55894557/article/details/124059186

首先，String 类中使⽤ final 关键字修饰字符数组来保存字符串。String底层是通过buye数组来储存字符串，被private和final修饰，是类的私有属性且初始化之后不可修改，String对象一旦被创建，其值将不能被改变。

注：在 Java 9 之前，String 类的实现为char 数组存储字符串 private final char value[],在 Java 9 之后改为了byte数组存储字符。

StringBuilder 与 StringBuffer 都继承⾃ AbstractStringBuilder 类，在 AbstractStringBuilder 中也是使⽤字符数组保存字符串 char[]value 但是没有⽤ final 关键字修饰，对象被创建后仍然可以对其值进行修改。所以这两种对象都是可变的。 StringBuilder 与 StringBuffer 的构造⽅法都是调⽤⽗类构造⽅法，即 AbstractStringBuilder 的方法，⼤家可以⾃⾏查阅源码。

16为什么string和stringbuffer是线程安全的，stringbuilder不是线程安全的

https://wenku.csdn.net/answer/994f1797fd8d42e789a1ed4205c1cb25

https://zhidao.baidu.com/question/928554716922931139.html

17springboot2和springboot的区别

https://wenku.csdn.net/answer/d0c35a8d91fa099656f7b4c0e2a63db2

18方法的重写和重载

https://baijiahao.baidu.com/s?id=1715051808653426749&wfr=spider&for=pc

19两个加了tranactional注解的事务方法调用，事务是否生效

关于加@Transactional注解的方法之间调用，事务是否生效的问题 - 码农教程

20Docker compose

Docker之compose介绍_docker-compose-CSDN博客

21 left join 和inner join

left join和inner join的含义是怎样的区别是_高三网

left join 只返回左表中所有记录和右表中连接字段（on条件）相等的行

Inner join只返回两个表中连接字段相等的行

22面向对象（封装继承和多态），面向过程（在开发之前基本考虑了实现方式和最终结果，具体步骤清楚，便于节点分析）编程

https://baijiahao.baidu.com/s?id=1727259979383836398&wfr=spider&for=pc

23listsetmap区别

百度安全验证

24低代码平台

自动生成数据库和代码的平台

25zookeeper和dubbo

这个见了很多次了，了解一下，始终好像不太了解

26Spring事务传播机制7种，隔离级别4种，spring事务的实现方式，事务不生效的场景有哪些

答：https://www.jianshu.com/p/1214858faedf

https://blog.csdn.net/sufu1065/article/details/122076645

27Springboot项目和ssm比优势是哪些，有哪些特点，启动流程

https://blog.csdn.net/agadshg/article/details/108712689

28springcloud的7个组件

（1）Spring Cloud Eureka

答案就是Spring Cloud Eureka，我们可以将自己定义的API 接口注册到Spring Cloud Eureka上，Eureka负责服务的注册于发现，如果学习过Zookeeper的话，就可以很好的理解，Eureka的角色和 Zookeeper的角色差不多，都是服务的注册和发现，构成Eureka体系的包括：服务注册中心、服务提供者、服务消费者。

（2）Spring Cloud Ribbon

在上Spring Cloud Eureka描述了服务如何进行注册，注册到哪里，服务消费者如何获取服务生产者的服务信息，但是Eureka只是维护了服务生产者、注册中心、服务消费者三者之间的关系，真正的服务消费者调用服务生产者提供的数据是通过Spring Cloud Ribbon来实现的。

（3）Spring Cloud Feign

Spring Cloud Feign 是一个声明web服务客户端，这使得编写Web服务客户端更容易，使用Feign 创建一个接口并对它进行注解，它具有可插拔的注解支持包括Feign注解与JAX-RS注解，Feign还支持可插拔的编码器与解码器，Spring Cloud 增加了对 Spring MVC的注解，Spring Web 默认使用了HttpMessageConverters, Spring Cloud 集成 Ribbon 和 Eureka 提供的负载均衡的HTTP客户端 Feign。

（4）Spring Cloud Hystrix

Spring Cloud Hystrix正是为了解决这种情况的，防止对某一故障服务持续进行访问。Hystrix的含义是：断路器，断路器本身是一种开关装置，用于我们家庭的电路保护，防止电流的过载，当线路中有电器发生短路的时候，断路器能够及时切换故障的电器，防止发生过载、发热甚至起火等严重后果。

（5）Spring Cloud Config

通过Spring Cloud Config实现了应用多环境的外部化配置以及版本管理

（6）Spring Cloud Zuul

服务网关是微服务架构中一个不可或缺的部分。通过服务网关统一向外系统提供REST API的过程中，除了具备服务路由、均衡负载功能之外，它还具备了权限控制等功能。Spring Cloud Netflix中的Zuul就担任了这样的一个角色，为微服务架构提供了前门保护的作用，同时将权限控制这些较重的非业务逻辑内容迁移到服务路由层面，使得服务集群主体能够具备更高的可复用性和可测试性

（7）Spring Cloud Bus

Spring Cloud Bus正是提供一种操作使得我们在不关闭服务的情况下更新我们的配置。

http://www.guoxiaolong.cn/blog/?id=7699

29Mysql存储引擎和区别

https://www.jianshu.com/p/9bdd29eea267

30Mysql加索引之后为什么快

https://blog.csdn.net/caochuang111111/article/details/124218491

31B+数为什么只io三次

32执行update同时执行insert可以成功吗

可以，走索引的话，update是走索引锁行，不走索引锁表，insert是锁行

33springmvc的工作流程

https://blog.csdn.net/weixin_53353693/article/details/124057001

34post和get的区别

https://www.cnblogs.com/wayaoyao/p/10960379.html

35关键字final

https://baike.baidu.com/item/Final/18832052?fr=aladdin

36Java集合有多少种 3种：list，set，map，其中前两个是继承了collection接口

37Redis穿透（比如id=-1的缓存里没有），雪崩（大量key同时失效），击穿（单个key失效），解决方案是什么

Redis的雪崩，击穿，穿透详解_redis穿透-CSDN博客

Redis缓存穿透、击穿、雪崩问题及其解决方法_redis击穿-CSDN博客

穿透解决：

缓存null值
布隆过滤
增强id的复杂度，避免被猜测id规律
做好数据的基础格式校验
加强用户权限校验
做好热点参数的限流

雪崩解决：

缓存雪崩是指在同一时段大量的缓存key同时失效或者Redis服务宕机，导致大量请求到达数据库，带来巨大压力。

解决方案：

给不同的Key的TTL添加随机值
利用Redis集群提高服务的可用性
给缓存业务添加降级限流策略
给业务添加多级缓存

击穿解决：

缓存击穿问题也叫热点Key问题，就是一个被高并发访问并且缓存重建业务较复杂的key突然失效了，无数的请求访问会在瞬间给数据库带来巨大的冲击。

常见的解决方案有两种：

互斥锁
逻辑过期

38Redis内存淘汰策略

https://www.cnblogs.com/frankyou/p/16283974.html

39java的集合list，set，queue，map，数组是和集合并列的 https://blog.csdn.net/qq_45105530/article/details/122490152

40多线程之间的通信方式

https://www.jianshu.com/p/ff581b2b0017/

41Redis比较快的原因。

https://blog.csdn.net/a745233700/article/details/113488673

42查看线程命令。

https://blog.csdn.net/tuziaaa/article/details/106988789

43堆内存溢出。

分析Java堆：内存溢出的原因_堆内存溢出-CSDN博客

https://www.jianshu.com/p/d8c595d43516

内存溢出和内存泄露的区别和产生和预防情况，这个通俗易懂。

https://baijiahao.baidu.com/s?id=1762768454496855526&wfr=spider&for=pc

溢出：比如一个盘子放4个水果，你却放了5个，分为多种，典型的有两种：1）申请一个integer，给了一个long数，2）或者把内存一次用完了，溢出了，死循环或者递归了

引起内存溢出的原因有很多种，列举一下常见的有以下几种:

1. 内存中加载的数据量过于庞大，如一次从数据库取出过多数据;

2. 集合类中有对对象的引用，使用完后未清空，使得JVM不能回收;

3. 代码中存在死循环或循环产生过多重复的对象实体;

4. 使用的第三方软件中的BUG;

5. 启动参数内存值设定的过小

内存溢出的解决方案:

第一步，修改JVM启动参数，直接增加内存。(-Xms，-Xmx参数一定不要忘记加。)

第二步，检查错误日志，查看“OutOfMemory”错误前是否有其它异常或错误。

第三步，对代码进行走查和分析，找出可能发生内存溢出的位置。

内存溢出的解决方案:

第一步，修改JVM启动参数，直接增加内存。(-Xms，-Xmx参数一定不要忘记加。)

第二步，检查错误日志，查看“OutOfMemory”错误前是否有其它异常或错误。

第三步，对代码进行走查和分析，找出可能发生内存溢出的位置。

重点排查以下几点：

1. 检查对数据库查询中，是否有一次获得全部数据的查询。一般来说，如果一次取十万条记录到内存，就可能引起内存溢出。这个问题比较隐蔽，在上线前，数据库中数据较少，不容易出问题，上线后，数据库中数据多了，一次查询就有可能引起内存溢出。因此对于数据库查询尽量采用分页的方式查询。

2. 检查代码中是否有死循环或递归调用。

3. 检查是否有大循环重复产生新对象实体。

4. 检查对数据库查询中，是否有一次获得全部数据的查询。一般来说，如果一次取十万条记录到内存，就可能引起内存溢出。这个问题比较隐蔽，在上线前，数据库中数据较少，不容易出问题，上线后，数据库中数据多了，一次查询就有可能引起内存溢出。因此对于数据库查询尽量采用分页的方式查询。

5. 检查List、MAP等集合对象是否有使用完后，未清除的问题。List、MAP等集合对象会始终存有对对象的引用，使得这些对象不能被GC回收。

第四步，使用内存查看工具动态查看内存使用情况。

泄露：比如1）每次泄露一块内存，多次泄露堆积了之后对程序造成损害。2）程序不停分配内存，直到结束了之后才释放，这样运行几天几个月可能就耗尽系统所有内存。

以发生的方式来分类，内存泄漏可以分为4类：

1. 常发性内存泄漏。发生内存泄漏的代码会被多次执行到，每次被执行的时候都会导致一块内存泄漏。

2. 偶发性内存泄漏。发生内存泄漏的代码只有在某些特定环境或操作过程下才会发生。常发性和偶发性是相对的。对于特定的环境，偶发性的也许就变成了常发性的。所以测试环境和测试方法对检测内存泄漏至关重要。

3. 一次性内存泄漏。发生内存泄漏的代码只会被执行一次，或者由于算法上的缺陷，导致总会有一块仅且一块内存发生泄漏。比如，在类的构造函数中分配内存，在析构函数中却没有释放该内存，所以内存泄漏只会发生一次。

4. 隐式内存泄漏。程序在运行过程中不停的分配内存，但是直到结束的时候才释放内存。严格的说这里并没有发生内存泄漏，因为最终程序释放了所有申请的内存。但是对于一个服务器程序，需要运行几天，几周甚至几个月，不及时释放内存也可能导致最终耗尽系统的所有内存。所以，我们称这类内存泄漏为隐式内存泄漏。

另一个网页的解释：

一、什么是内存泄漏和内存溢出：

1、内存泄漏（memory leak ）：指程序申请内存后，无法释放已申请的内存空间，导致系统无法及时回收内存分配给其他程序使用。

2、内存溢出（out of memory）：指程序申请内存时，没有足够的内存提供给申请者使用，导致无法正常存储到内存中。例如给了一个int类型的存储空间，却存储long型数据就会发生内存溢出。

二、两者关系和区别：

1.关系：内存泄露最终会导致内存溢出，由于系统中的内存是有限的，如果过度占用资源而不及时释放，最后会导致内存不足，从而无法给所需要存储的数据提供足够的内存，从而导致内存溢出。导致内存溢出也可能是由于在给数据分配大小时没有根据实际要求分配，最后导致分配的内存无法满足数据的需求，从而导致内存溢出。

2.区别：内存泄露是由于GC无法及时或者无法识别可以回收的数据进行及时的回收，导致内存的浪费；内存溢出是由于数据所需要的内存无法得到满足，导致数据无法正常存储到内存中。内存泄露的多次表现就是会导致内存溢出。

三、什么场景会引起内存泄漏

1、静态集合引起内存泄漏

主要是hashmap，Vector等，如果是静态集合这些集合没有及时setnull的话，就会一直持有这些对象。

2、observer 我们在使用监听器的时候，往往是addxxxlistener，但是当我们不需要的时候，忘记removexxxlistener，就容易内存leak

广播没有unregisterrecevier

3、各种数据链接没有关闭，数据库contentprovider，io，cursor，sokect等

4、非静态内部类：

java中的内部类（匿名内部类），会持有宿主类的强引用this。

所以如果是new Thread这种，后台线程的操作，当线程没有执行结束时，activity不会被回收。

5、单例：

单例中的Context如果传的是Activity，则容易内存泄漏。解决办法使用Application

作者：zmy26
链接：https://www.jianshu.com/p/d8c595d43516
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

44Java循环实现的方式有哪些

https://blog.csdn.net/Twillight_clever/article/details/124781238

45Synchoronied方法，方法块，静态方法的区别

https://blog.csdn.net/qq_39529562/article/details/109322875

46Object类必须实现的方法有哪些

https://blog.csdn.net/m6494854/article/details/128540494

47Java8的特性有哪些

Lambda 表达式、函数式接口consumer function supply predicate 、方法引用：：和几个新增库Stream API forEach map filter limit sorted Collectors 、Optional类判空

https://mp.weixin.qq.com/s?__biz=MzI5MTQ5NDY1MA==&mid=2247487758&idx=1&sn=c7a899ac304104f5c41773b550d0c9d9&chksm=ec0e9e9bdb79178dd2777f4c00e2a802876743a97a1462f6e3f4a86197a334cb1572db1530fe&scene=27

48垃圾回收机制，回收时会对程序造成哪些影响，如何判断一个实例是否要被回收，一个实例在哪些区

https://blog.csdn.net/eternal_yangyun/article/details/89787416

49Java8种数据结构常用哪种

数组（Array）、栈（Stack）、队列（Queue）、链表（Linked List）、树（Tree）、图（Graph）、堆（Heap）、散列表（Hash）等；

50数组增删一个元素时间复杂度是On，链表是O1

https://blog.csdn.net/BBG_Clown/article/details/122440738

51Spring bean是不是单例的为什么，有哪几种原型是，5种

https://blog.csdn.net/qq_39093474/article/details/128376910

52Mysql的b+树和b数的区别，mysql的引擎有哪几种

https://www.jb51.net/article/239422.htm

53动态代理是什么，有什么好处

https://blog.csdn.net/qq_44641527/article/details/120348270?spm=1001.2101.3001.6650.1&utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7ERate-1-120348270-blog-81053130.pc_relevant_recovery_v2&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7ERate-1-120348270-blog-81053130.pc_relevant_recovery_v2

54Redis落盘方式有几种，会持久化吗 rdb和aof

https://blog.csdn.net/weixin_35775778/article/details/113489964

55Rabbitmq挂了的队列如何控制消息不会丢，出异常怎么控制不会丢记录

56redis数据类型有五种:

1）string(字符串)、hash(哈希)、list(列表)、set(集合)、zset(有序集合)，api用的是redis template。

57List是怎么实现的？

一个一个节点实现的，数据量大用linklist，数据量不大的时候还用的ziplist和更加使用quicklist更加省内存

https://www.cnblogs.com/wangzhaobo/articles/9591567.html

58异常的类型有哪些

异常类型（常见异常收集）_异常分类-CSDN博客

https://blog.csdn.net/aiwokache/article/details/118469876

59队列的类型有哪几种

https://cloud.tencent.com/developer/article/2002834

60count1和count*的区别

https://blog.csdn.net/qq_52297656/article/details/127893049

61Mysql语句#和$取值的区别

https://blog.csdn.net/CodingGirl_/article/details/127207556

62Mysql如何优化语句

https://blog.csdn.net/Martin_chen2/article/details/121149963

63索引失效的场景有哪些

https://www.cnblogs.com/xiaolincoding/p/15839040.html

64concurrenthashmap适用场景

https://cloud.tencent.com/developer/article/1415182?from=15425&areaSource=102001.2&traceId=CgN57-q6A3ZCNlHYV6kcf

65string，stringbuffer和stringbuilder的区别

https://blog.csdn.net/weixin_42188778/article/details/124527355

66equals和==的区别

https://blog.csdn.net/qq_44580803/article/details/123556176

67counntdownlatch

https://blog.csdn.net/weixin_44688301/article/details/115554321

68runable和callable的区别

https://blog.csdn.net/syw_0406/article/details/119921114

69sleep和wait的区别

https://zhuanlan.zhihu.com/p/471109617

70kafaka怎么用

https://blog.csdn.net/weixin_45830561/article/details/124853432

71spring框架

https://baike.baidu.com/item/spring/85061?fr=aladdin

72单链表java实现Node，数据域，指针域，怎么判断环

https://blog.csdn.net/qq_42456324/article/details/118117580

73springboot扩展点和启动流程.

https://blog.csdn.net/weixin_44947701/article/details/124055713

74object类的equal hashcode 方法区别，wait waitall 方法的区别，tostring

（1）https://blog.csdn.net/qing_gee/article/details/104569177/

（2）http://www.uwenku.com/question/p-cyyuvlyu-rz.html

75synchoreid和lock的区别

https://baijiahao.baidu.com/s?id=1745216085045248658

76线程的几种状态和线程池的几种状态，7个参数，5种线程池，execute和submit的区别

https://blog.csdn.net/wordwarwordwar/article/details/85924858

线程池参数

这 7 个参数分别是：

corePoolSize：核心线程数。
maximumPoolSize：最大线程数。
keepAliveTime：空闲线程存活时间。
TimeUnit：时间单位。
BlockingQueue：线程池任务队列。
ThreadFactory：创建线程的工厂。
RejectedExecutionHandler：拒绝策略。

线程池7个参数描述_线程池参数-CSDN博客

哪几种线程池5种

1.newCachedThreadPool
2.newFixedThreadPool
3.newSingleThreadExecutor
4.newScheduleThreadPool
5.newSingleThreadScheduledExecutor

https://blog.csdn.net/bangyanya/article/details/123518146

77线程池submit和execute的区别

百度安全验证

两个方法都是线程池中提供的，都可以用来执行线程的调度任务，他们的区别如下：

execute()只能执行实现Runnable接口类型的任务;而submit()不仅可以执实现Runnable类型接口的任务，也可以执行实现Callable接口类型的任务

execute()没有返回值，而submit()有在添加Callable类型任务的时候有返回值，我们一般通过返回值查看线程执行情况。

如果线程执行发生异常，submit可以通过Future.get()方法抛出异常，方便我们自定义异常处理；而execute()会终止异常，没有返回值

总结：两者主要区别，其实还是在于有无返回值，实际生产中为了更好的处理异常，使用submit更多一点。

或者更全面一点：

Java - 线程池中submit和execute的区别_线程池中execute方法和submit方法区别-CSDN博客

二. 总结

关于返回值的问题：

submit：有返回值，返回值（包括异常）被封装于FutureTask对象。适用于有返回结果的任务。

execute：void类型的函数，没有返回值，适用于没有返回的任务。

关于异常处理的问题吗，在业务逻辑必定出异常的情况下：

submit：submit的时候并不会抛出异常（此时线程可能处于就绪状态）。只有在get操作的时候会抛出。因为get操作会阻塞等待线程的执行完毕。

execute：在执行的时候会直接抛出。可以通过实现UncaughtExceptionHandler接口来完成异常的捕获。

submit的底层还是调用了execute操作。只不过对我们传入的任务进行了一层层的封装罢了。

Worker–>FutureTask–>Callable–>我们的任务。

归根到底执行的是FutureTask的run函数以及get函数。

任务没执行完则循环等待。执行完毕则直接返回。

也因此，如果任务没有返回值，用execute的效率会更高点。

返回的结果可以分为两大类：

正常的结果：正常的返回值或者是捕获到的异常。

其他异常：抛出异常。

78线程的创建方式，启动线程的方式

线程创建的四种方式_创建线程-CSDN博客

79Java启动线程的方式

继承thread类，实现runnable接口，实现callable接口，创建线程池

https://blog.csdn.net/weixin_43304253/article/details/129051572

80死锁形成的原因

https://baijiahao.baidu.com/s?id=1748986176152180162&wfr=spider&for=pc

81数据库引擎innodb和mysam

https://blog.csdn.net/gdnlnsjd/article/details/119713875

82Redis不持久化数据会丢失吗

https://blog.csdn.net/Left_Zzzz/article/details/126768792

83mongodb怎么使用的

https://baijiahao.baidu.com/s?id=1757047998825685624&wfr=spider&for=pc

84treadlocal的原理

https://blog.csdn.net/u010445301/article/details/111322569

85深拷贝和浅拷贝

https://blog.csdn.net/ling_76539446/article/details/102835484

https://www.cnblogs.com/SpringAndMoon/p/14549609.html

86Stack Overflow错误的原因

https://www.jb51.net/article/254915.htm

87递归无限的后果

https://blog.csdn.net/qq_43393430/article/details/107481075

88Gc机制

https://blog.csdn.net/u011192458/article/details/122881330

89数据库表锁和行锁和脏读，幻读不一样

https://blog.csdn.net/ahuangqingfeng/article/details/124407846?spm=1001.2101.3001.6650.1&utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7ERate-1-124407846-blog-126692772.235%5Ev27%5Epc_relevant_default&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7ERate-1-124407846-blog-126692772.235%5Ev27%5Epc_relevant_default&utm_relevant_index=2

90读表会不会上锁，

普通读不会，对表操作时，读会阻塞就会加锁

https://www.yzktw.com.cn/post/527456.html

91悲观锁和乐观锁思想：

https://blog.csdn.net/striveb/article/details/84826921

92分布式事务怎么处理

https://blog.csdn.net/m0_67322837/article/details/124986327

93分布式锁怎么实现

有3种方式，数据库，缓存（redis setnx），zookeeper https://www.cnblogs.com/barrywxx/p/11644803.html

94统计一个字符在一个文件里所有的出现的次数 linux命令

grep -o ‘location’ new_20221029.log | wc -l

https://jingyan.baidu.com/article/456c463b32846e4b59314419.html

95查看端口占用linux命令

lsof -i:端口号

netstat -tunlp|grep 端口号

这两个命令都可以查看端口被什么进程占用。

https://m.php.cn/article/469680.html

96杀死所有python开头的进程 linux

1killall ： killall python

2pkill： sudo pkill python

3ps 列出所有ttlsa python进程的pid，然后依次kill掉，比较繁琐。的方式： ps -ef|grep python |grep -v grep| awk ‘{print $2}’|xargs kill -9

https://blog.csdn.net/weixin_39582737/article/details/116877503

文件查找命令 https://www.knowbaike.com/it/61089.html

Log级别 log4j是4个，“ERROR、WARN、INFO、DEBUG”。

所有加起来是8个。https://blog.csdn.net/qq_44848204/article/details/129705459

97如何在一个数组里快速去重

放到set里，再遍历set

有12种去重方法：https://blog.csdn.net/m0_64564920/article/details/124056295?utm_medium=distribute.pc_relevant.none-task-blog-2~default~baidujs_baidulandingword~default-0-124056295-blog-126899337.235^v27^pc_relevant_default&spm=1001.2101.3001.4242.1&utm_relevant_index=3

98java8编程（同16）

Lambda 表达式、函数式接口consumer function supply predicate 、方法引用：：和几个新增库Stream API forEach map filter limit sorted Collectors 、Optional类判空

99二分查找法

https://blog.csdn.net/weixin_54046648/article/details/122893969

100mysql查询导致cpu过高怎么办

很多：

减少IO量，SQL/index，使用合适的索引减少扫描的行数（需平衡索引的正收益和维护开销，空间换时间）
提升IO处理能力，加cache/加磁盘/SSD
2、减少计算
减少逻辑运算量
- 避免使用函数，将运算转移至易扩展的应用服务器中如substr等字符运算，dateadd/datesub等日期运算，abs等数学函数
- 减少排序，利用索引取得有序数据或避免不必要排序如union all代替 union，order by 索引字段等
- 禁止类型转换，使用合适类型并保证传入参数类型与数据库字段类型绝对一致如数字用tiny/int/bigint等，必需转换的在传入数据库之前在应用中转好
- 简单类型，尽量避免复杂类型，降低由于复杂类型带来的附加运算。更小的数据类型占用更少的磁盘、内存、cpu缓存和cpu周期

3、减少逻辑IO量

index，优化索引，减少不必要的表扫描如增加索引，调整组合索引字段顺序，去除选择性很差的索引字段等等

table，合理拆分，适度冗余如将很少使用的大字段拆分到独立表，非常频繁的小字段冗余到“引用表”

SQL，调整SQL写法，充分利用现有索引，避免不必要的扫描，排序及其他操作如减少复杂join，减少order by，尽量union all，避免子查询等

数据类型，够用就好，减少不必要使用大字段如tinyint够用就别总是int，int够用也别老bigint，date够用也别总是timestamp

4、程序里减少query请求量（非数据库本身）

适当缓存，降低缓存数据粒度，对静态并被频繁请求的数据进行适当的缓存如用户信息，商品信息等
优化实现，尽量去除不必要的重复请求如禁止同一页面多次重复请求相同数据的问题，通过跨页面参数传递减少访问等
合理需求，评估需求产出比，对产出比极端底下的需求合理去除
….

5、升级CPU（非数据库本身）

升级cpu若经过减少计算和减少等待后还不能满足需求，cpu利用率还高T_T 是时候拿出最后的杀手锏了，升级cpu，是选择更快的cpu还是更多的cpu了？

低延迟（快速响应），需要更快的cpu（每个查询只能使用一个cpu）
高吞吐，同时运行很多查询语句，能从多个cpu处理查询中收益

101手写8种排序算法

https://blog.csdn.net/weixin_65657777/article/details/124737660

https://www.cnblogs.com/ll409546297/p/10956960.html

102hashtable和hashmap，concurenthashmap的区别

103Gc可达性分析算法

104String类的方法有哪些

105怎么保证接口幂等性（方法有哪些）

https://blog.csdn.net/itworld123/article/details/117071929

106分布式的理解（为什么redis可以做分布式锁）

因为Redis是一个单独的中间件，不同客户端可以往同一个Redis或者集群中加锁，这样就能保证加锁的地方或者是资源是相同的

并且由于Redis也是单线程的，同时也支持lua脚本，可以保证“并发安全”的问题，所以可以很简单的实现分布式锁的功能。

https://www.zhihu.com/question/317687988/answer/2508631770

107数据存储量

108索引

109Java数据结构

数组（Array）、栈（Stack）、队列（Queue）、链表（Linked List）、树（Tree）、图（Graph）、堆（Heap）、散列表（Hash）等；

list，set是collection接口，map不是collection接口

https://blog.csdn.net/weixin_45928836/article/details/117266233

110mybatis怎么持久化

为了使用Mybatis进行持久化操作，通常有如下操作步骤：

开发持久化类PO和编写持久化操作的Mapper.xml, 在其中定义要执行的SQL语句
获取SqlSessionFactory
获取SqlSession
用面向对象的方式操作数据库
关闭事务，关闭SqlSession

https://blog.csdn.net/tsuixh/article/details/78719751

111线程数配置

http://e.betheme.net/article/show-1262877.html

核心线程：
CPU密集型：核心线程数=CPU核心数(或核心线程数=CPU核心数+1)。
I/O密集型：核心线程数=2*CPU核心数（或核心线程数=CPU核心数/（1-阻塞系数))。

112客户端初始化

https://www.coder.work/article/6093463

113rabbitmq监听端口的方法

Netstat –ano|findstr “< 端口号 >”

114悲观锁和乐观锁

悲观锁总是假设最坏的情况，认为共享资源每次被访问的时候就会出现问题(比如共享数据被修改)，所以每次在获取资源操作的时候都会上锁，这样其他线程想拿到这个资源就会阻塞直到锁被上一个持有者释放。也就是说，共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程。

乐观锁总是假设最好的情况，认为共享资源每次被访问的时候不会出现问题，线程可以不停地执行，无需加锁也无需等待，只是在提交修改的时候去验证对应的资源（也就是数据）是否被其它线程修改了（具体方法可以使用版本号机制或 CAS 算法）。

悲观锁就是资源互斥锁，开销大，适用于写多的情景，乐观锁就是cas实现锁，开销小，适用于读多的场景。

https://blog.csdn.net/qq_34337272/article/details/81072874

115sql优化方式

EXPLAIN

SELECT语句务必指明字段名称

当只需要一条数据的时候，使用limit 1

分段查询

不建议使用%前缀模糊查询

避免在where子句中对字段进行表达式操作

避免隐式类型转换

对于联合索引来说，要遵守最左前缀法则

必要时可以使用force index来强制查询走某个索引

注意范围查询语句

关于JOIN优化利用小表去驱动大表

https://blog.csdn.net/Lost_in_the_woods/article/details/125659716

116springboot注解，注解为什么能生效

@Component

可以用来标注其他注解,被他标注的注解,会起到与它相同或者类似的作用，服务层

@Controller

控制器层

@responseBody

@responseBody注解可以将Controller的方法返回的对象通过适当的转换器转换为指定的格式,一般用来返回JSON数据或者是XML

@Autowired

自动装配，作用是为了省略Java代码里面的getter/setter与bean属性中的property。并且getter也可以看需求，如果私有属性 需要对外提供的话，应当予以保留。

当Spring发现@Autowired注解时，将自动在代码上下文中找到和其匹配（默认是类型匹配）的Bean，并自动注入到相应的 地方去。

但是bean里面如果有property属性配置项,java代码里面又去掉了属性的getter/setter并使用@Autowired注解标注,Spring会 按照xml优先的原则去java代码中寻找属性的getter/setter，则会导致初始化bean报错。

如果我们删除了xml文件中的Bean定义，Spring容器便找不到这个了。如果属性找不到又不想让Spring容器抛异常，而只是显 示null，我们可以将@Autowired注解的required属性设置为false

117redis数据结构和内存淘汰机制

1）string(字符串)、hash(哈希)、list(列表)、set(集合)、zset(有序集合)，api用的是redis template。

8种淘汰策略：

# volatile-lru -> Evict using approximated LRU, only keys with an expire set.

# 加入键的时候如果过限，首先从设置了过期时间的键集合中驱逐最久没有使用的键

# allkeys-lru -> Evict any key using approximated LRU.

# 加入键的时候，如果过限，首先通过LRU算法驱逐最久没有使用的键

# volatile-lfu -> Evict using approximated LFU, only keys with an expire set.

# 从所有配置了过期时间的键中驱逐使用频率最少的键

# allkeys-lfu -> Evict any key using approximated LFU.

# 从所有键中驱逐使用频率最少的键

# volatile-random -> Remove a random key having an expire set.

# 加入键的时候如果过限，从过期键的集合中随机驱逐

# allkeys-random -> Remove a random key, any key.

# 加入键的时候如果过限，从所有key随机删除

# volatile-ttl -> Remove the key with the nearest expire time (minor TTL)

# 从配置了过期时间的键中驱逐马上就要过期的键

# noeviction -> Don't evict anything, just return an error on write operations.

# 当内存使用超过配置的时候会返回错误，不会驱逐任何键，默认配置

https://blog.csdn.net/weixin_38937840/article/details/119566731?spm=1001.2101.3001.6661.1&utm_medium=distribute.pc_relevant_t0.none-task-blog-2%7Edefault%7ECTRLIST%7ERate-1-119566731-blog-125533413.235%5Ev32%5Epc_relevant_default_base3&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-2%7Edefault%7ECTRLIST%7ERate-1-119566731-blog-125533413.235%5Ev32%5Epc_relevant_default_base3&utm_relevant_index=1

118nginx配置url

https://www.yingsoo.com/news/servers/72302.html

119zookeeper工作模式

120redis事务

121消息队列延迟问题，消息积压和消息丢失

122oop和aop

123分布式事务

124如何判断jvm对象被回收

125hbase的协处理器

https://blog.csdn.net/mxk4869/article/details/125613372

126mongodb支持的数据量

单实例副本支持最大4TB

https://blog.csdn.net/qq_41765918/article/details/122904055

127redis里一般存什么数据

一般是string字符串，比如一些json。

列表list，比如一些元素push到list里

散列hash hset user username chen

集合set 插入，删除，判断是否存在效率很高

有序集合，sorted set，每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序

https://www.php1.cn/detail/redis_HuanCunDuC_eb0ee148.html

128springboot2.0比1.0的新特点是什么

129kafka用的多吗，怎么使用（有具体代码）

Kafka入门使用_kafka使用-CSDN博客

130rabbitmq消息堆积，丢失了怎么办

RabbitMQ消息丢失、积压、重复等解决方案 - 知乎

https://baijiahao.baidu.com/s?id=1737713844357727373&wfr=spider&for=pc

131mysql的truncate，drop，delete的区别

https://blog.csdn.net/han_cui/article/details/116929805

132手写一个快排算法。

https://blog.csdn.net/littlecorner1205/article/details/119707574

133arthas怎么用的，启动项目，下载arthas并启动，trace 类名 方法名

https://m.elecfans.com/article/2205152.html

134说说hbase的存储原理，为什么查询快，

https://blog.csdn.net/weixin_59383491/article/details/131420064（查询快的原因）

https://www.ngui.cc/el/3512251.html?action=onClick（hbase的组成结构）

135redis怎么存储热点数据的

Redis是如何缓存热点数据的_redis缓存热门数据-CSDN博客

https://www.27ka.cn/126321.html（含搭建步骤）

136怎么保证redis和mysql数据一致：双写模式（Dual Write），读后写模式（Read-Modify-Write），异步同步模式（Asynchronous Replication）

百度安全验证

如何保持mysql和redis数据一致性？_redis和mysql如何保证数据一致-CSDN博客

https://www.cnblogs.com/huang580256/p/17299585.html（有图推荐）

137常用的java加密类有哪些：base64，Message Digest，对称加密（DES，Triple DES，AESAES，PBE），非对称性加密（RSA，DH算法）

https://blog.csdn.net/m0_67129275/article/details/127528473

138hystrix怎么使用，搭配feign

Hystrix使用篇 - Hystrix的使用-CSDN博客

139nacos怎么使用，搭配接口鉴权

Nacos的使用

https://blog.csdn.net/weixin_43564627/article/details/112257721

140怎么使用带生成token的接口，或者使用oauth：createToken和validToken过程

https://blog.51cto.com/u_16099334/7194510

141，es索引为什么倒排

https://mp.weixin.qq.com/s?__biz=MzU0OTE4MzYzMw==&mid=2247561160&idx=2&sn=b0dd7b2ec0c645f4ae86b6d36875e906&chksm=fbb06636ccc7ef20c453611a13e621f1976ce163f2205c824877e4af914294db774e59897da9&scene=27

142，threadlocal怎么用

https://www.cnblogs.com/luxiaoxun/p/8744826.html

143，四种锁的区别，synchronized，lock，volatile，threadlocal的区别

synchronized和lock的区别:https://my.mbd.baidu.com/r/1bHGYaMoZxe?f=cp&u=bc1df57ef7089a10

volatile关键字:【volatile关键字的作用】https://mbd.baidu.com/ma/s/h8wVFqnH

144，docker怎么使用

http://t.csdnimg.cn/DYU3h

145，spring boot和spring，springmvc的区别

spring boot的10大新增特性+

【手把手带你剖析 Springboot 启动原理！】https://mbd.baidu.com/ma/s/W9rbkPJH

146，list和map的区别

https://my.mbd.baidu.com/r/1bHJ9ylTezS?f=cp&u=d85b4e03a38e9dba

147，arraylist和linkedlist的区别

【ArrayList和LinkedList的区别】https://mbd.baidu.com/ma/s/XueIQyCz

148，concurentlinkedlist如何保证线程安全

java线程安全的linkedlist_使ArrayList，LinkedList变成线程安全的1.使⽤SynchronizedListSynchronizedList是⼀个线程安全的包装类。继承于SynchronizedCollection，SynchronizedCollection实现了Collection接⼝，SynchronizedList包含⼀个List对象，对List的访问修改⽅法进⾏了⼀些封装，在封装的⽅法中会对list使⽤同步锁加锁，然后再进⾏存取和修改操作。使⽤⽅法如下LinkedList linkedList = new LinkedList();//调⽤Collections的synchronizedList⽅法，传⼊⼀个linkedList，会返回⼀个SynchronizedList实例对象List synchronizedList = Collections.synchronizedList(linkedList);//调⽤Collections的synchronizedList⽅法，ArrayList，返回⼀个SynchronizedRandomAccessList实例对象ArrayList arrayList = new ArrayList();List synchronizedRandomAccessList = Collections.synchronizedList(linkedList);(Collections.synchronizedList()⽅法会判断传⼊的对象是否实现了 RandomAccess接⼝，是的话，会返回⼀个SynchronizedRandomAccessList对象，SynchronizedRandomAccessList是SynchronizedList的⼦类，只是会多⼀个以线程安全的⽅式获取⼦数组的⽅法)。SynchronizedList类的部分代码如下：static class SynchronizedListextends SynchronizedCollectionimplements List {final List list;//源listfinal Object mutex;SynchronizedCollection(Collection c) {this.c = Objects.requireNonNull(c);mutex = this;//mutex就是SynchronizedList实例⾃⼰，作为同步锁使⽤}public E get(int index) {synchronized (mutex) {是⽗类中的成员变量，在⽗类中会将list赋值给mutexreturn list.get(index);}}public E set(int index, E element) {synchronized (mutex) {return list.set(index, element);}}2.使⽤CopyOnWriteArrayListCopyOnWriteArrayList跟ArrayList类似，都是实现了List接⼝，只不过它的⽗类是Object，⽽不是AbstractList。CopyOnWriteArrayList与ArrayList的不同在于，1.内部持有⼀个ReentrantLock类型的lock成员变量，final transient ReentrantLock lock = new ReentrantLock();在对数组进⾏修改的⽅法中，都会先获取lock，获取成功才能进⾏修改，修改完释放锁，保证每次只允许⼀个线程对数组进⾏修改。2.CopyOnWriteArrayList内部⽤于存储元素的Object数组使⽤volatile//CopyOnWriteArrayListprivate transient volatile Object[] array;//ArrayListprivate transient Object[] elementData;//transient可以看到区别主要在于CopyOnWriteArrayList的Object是使⽤volatile来修饰的，volatile可以使变量具备内存可见性，⼀个线程在⼯作内存中对变量进⾏修改后，会⽴即更新到物理内存，并且使得其他线程中的这个变量缓存失效，其他线程在读取会去物理内存中读取最新的值。(volatile修饰的是指向数组的引⽤变量，所以对数组添加元素，删除元素不会改变引⽤，所以为了保证内存可见性，CopyOnWriteArrayList.add()⽅法在添加元素时，都是复制出⼀个新数组，进⾏修改操作后，再设置到就数组上)注意事项:Object数组都使⽤transient修饰是因为transient修饰的属性不会参与序列化，ArrayList通过实现writeObject()和readObject()⽅法来⾃定义了序列化⽅法(基于反序列化时节约空间考虑，如果⽤默认的序列⽅法，源elementData数组长度为100，实际只有10个元素，反序列化时也会分配长度为100的数组，造成内存浪费。)public boolean add(E e) {final ReentrantLock lock = this.lock;//1. 使⽤Lock，保证写线程在同⼀时刻只有⼀个lock.lock();try {//2. 获取旧数组引⽤Object[] elements = getArray();int len = elements.length;//3. 创建新的数组，并将旧数组的数据复制到新数组中Object[] newElements = Arrays.copyOf(elements, len + 1);//4. 往新数组中添加新的数据newElements[len] = e;//5. 将旧数组引⽤指向新的数组setArray(newElements);return true;} finally {lock.unlock();}3.SynchronizedList和CopyOnWriteArrayList优缺点SynchronizedList是通过对读写⽅法使⽤synchronized修饰来实现同步的，即便只是多个线程在读数据，也不能进⾏，如果是读⽐较多的场景下，会性能不⾼，所以适合读写均匀的情况。⽽CopyOnWriteArrayList是读写分离的，只对写操作加锁，但是每次写操作(添加和删除元素等)时都会复制出⼀个新数组，完成修改后，然后将新数组设置到旧数组的引⽤上，所以在写⽐较多的情况下，会有很⼤的性能开销，所以适合读⽐较多的应⽤场景。

149，list删除元素的方式有哪些

【阿里二面:Java中遍历list动态删除元素,五分钟说了6种方式,稳稳拿捏住了!!】https://mr.baidu.com/r/1bHBbP5bwvC?f=cp&u=c1c027d05673e326