Java面试题汇总 真实面经总结（持续更新20240315）

子主题

底层原理  动态代理

微服务启动后，会周期性地向Eureka Server发送心跳(默认周期为30秒) 以续约自己的信息
Eureka Server在一定时间内没有接收到某个微服务节点的心跳，Eureka Server将会注销该微服务节点(默认90秒)

自我保护机制

投票机制

值传递

引用传递

值传递和引用传递都是传递的栈空间中的内容，因为栈空间存的是基本数据类型的值（所以表现为值传递），而栈空间存的引用类型的地址（所以表现为引用传递）。

值传递和引用传递最大的区别是传递的过程中有没有复制出一个副本来，如果是传递副本，那就是值传递，否则就是引用传递。

Java对象的传递，是通过复制的方式把引用关系传递了，因为有复制的过程，所以是值传递，只不过对于Java对象的传递，传递的内容是对象的引用。

强引用

软引用

弱引用

虚引用

浅拷贝

深拷贝

指计算机执行操作时，CPU不需要先将数据从某处内存复制到另一个特定区域。

NIO的零拷贝由transferTo()方法实现

DMA 

MMP

sendfile

sendfile + DMA Scatter/Gather

direct I/O

使用Collectors.toMap

如何破坏

当一个类加载器试图加载一个类时，它首先会将这个请求委派给其父类加载器，只有在父类加载器无法加载这个类的情况下，才会尝试自己加载。这个过程会一直递归进行，直到达到Bootstrap ClassLoader，如果Bootstrap ClassLoader也无法加载该类，那么会抛出ClassNotFoundException。

比较它们的引用是否指向同一个对象

使用equals()方法可以比较Integer对象的内容而不是引用

对于范围在-128到127之间的整数，无论你创建多少个Integer对象，它们都会引用池中的同一个对象。这意味着这些整数在Set中会被正确去重，因为它们的引用都相同

要去重这些超过范围的整数，你需要确保它们的值相同，并且重写了equals()方法和hashCode()方法以正确比较和去重这些对象。

double/float到long会导致精度丢失

不可以

不可以

private属性是类的私有成员，不能被子类或父类直接访问。

可以

异常分为两种也就是：检查异常和非检查异常

        ①.检查异常/编译 ：编译器要求必须处置的异常。当程序中可能出现这类异常，需要在编译时使用try-catch或者throws声明的异常，如果不处理将无法编译通过。IOException   ClassNotFound

        ②非检查异常/ 运行时：在编译过程中没有任何问题，在java命令执行.class文件的时候，发生在运行期异常,在编译时不需要try-catch或者throws声明的异常，在程序运行期间会抛出。如NullPointerException、ArrayIndexOutOfBoundsException等。

        ①和②主要区别是处理方式不同，对于检查异常需要进行处理，非检查异常则不需要强制处理。而检查异常与非检查异常的区别则在于前者需要在编译时处理，而后者在程序运行时才会抛出。

物理机部署： 独享硬件资源： 在物理机上部署应用，应用程序独享整个物理机的硬件资源，包括 CPU、内存、存储等。 定制化配置： 物理机上的应用可以根据硬件配置的不同进行定制化配置，可以根据实际需求选择更适合的硬件规格。 性能稳定： 由于应用独享硬件资源，性能通常更为稳定，而且不容易受到其他应用的影响。

容器部署：
虚拟化和隔离： 容器部署在物理机上，多个容器共享同一台物理机的资源。每个容器是独立隔离的，通过容器技术实现虚拟化，使得容器之间互不干扰。

轻量级： 容器相对于虚拟机来说更为轻量级，容器共享宿主机的操作系统内核，因此启动更快，占用更少资源。

灵活性和可移植性： 容器提供了更大的灵活性和可移植性，可以在不同环境中运行，保持一致的运行环境。这样，开发、测试和部署都更为简便。

CPU 分配区别：
物理机 CPU 分配： 在物理机上，CPU 的分配通常是直接针对物理核心的。应用可以充分利用物理机的多个核心，但在高负载时，可能会有资源争用的情况。

容器 CPU 分配： 在容器中，CPU 的分配是基于容器级别的。容器可以限制和分配 CPU 的使用，可以指定每个容器可以使用的 CPU 资源。这使得容器可以更加灵活地进行资源管理，但也需要注意容器之间的资源隔离。

CPU时间

内存空间

自动装箱与拆箱（Autoboxing and Unboxing）

增强的for循环（Enhanced for Loop）

泛型（Generics）

可变参数（Varargs）

自动关闭资源（try-with-resources）

lambda

String底层数据结构

不可变的实现

如果String不是不可变量会怎样

String s = new String("java")创建了几个对象

String s = "a" + "b" + "c" 创建了几个对象

String,Stringbuilder,StringBuffer的区别

介绍一下泛型机制

泛型的使用方式有哪几种

项目中怎么用的

泛型擦除是什么?

解释一下泛型的作用

泛型的桥方法

因为Java是一种面向对象语言，很多地方都需要使用对象而不是基本数据类型。比如，在集合类中，我们是无法将int 、double等类型放进去的。因为集合的容器要求元素是Object类型。
为了让基本类型也具有对象的特征，就出现了包装类型，它相当于将基本类型“包装起来”，使得它具有了对象的性质，并且为其添加了属性和方法，丰富了基本类型的操作。

方法定义：接口和抽象类，最明显的区别就是接口只是定义了一些方法而已，接口中只有抽象方法，是没有实现的代码的。（Java8中可以有默认方法）

修饰符：抽象类中的抽象方法可以有public、protected和private和<defaiult>这些修饰符，而接口中默认修饰符是public。不可以使用其它修饰符。（接口中，如果定义了成员变量，还必须要初始化）

构造器：抽象类可以有构造器。接口不能有构造器。

单继承，多实现：一个类可以实现多个接口，但只能继承一个抽象类。接口支持多重继承，即一个接口可以继承多个其他接口。

所以当我们想要定义标准、规范的时候，就使用接口。当我们想要复用代码的时候，就使用抽象类。

default接口默认方法。允许接口中添加非抽象的方法实现，使用default关键字，这使得我们可以向现有的接口中添加新的方法，而不会破坏已有的实现类

Lambda表达式和函数式接口。Lambda表达式本质上是一段匿名内部类，可以将函数作为方法的参数进行传递。使用Lambda表达式可以让代码更加简洁，但需要注意不要滥用，以免影响代码的可读性。

Stream API。Stream API是处理集合类的关键抽象概念，它允许使用函数式编程风格对集合进行复杂的操作，结合Lambda表达式可以轻松地对集合进行过滤、映射、查找等操作。

日期时间API。改进了对日期和时间的处理方式，新的API提供了更加直观和灵活的方法来处理日期时间和时间间隔。

Optional类。在Java 8之前，Google Guava项目引入了Optional作为一种避免空指针异常的方式。Optional类现在已经成为Java 8库的一部分，它鼓励程序员编写更加整洁和健壮的代码，避免代码中过多的null检查。

多核处理器支持。JDK 1.8对多核处理器有更好的处理，提供了更简单的新思路来支持并行操作，避免了用synchronized编写代码，这一代码不仅容易出错，而且在多核CPU上执行所需的成本也比你想象的要高。

21

JDK 8中推出了Lambda表达式、Stream、Optional、新的日期API等
JDK 9中推出了模块化
JDK 10中推出了本地变量类型推断
JDK 12中增加了switch表达式
JDK 13中增加了text block
JDK 14中增加了Records
JDK 14中增加了instance模式匹配
JDK 15中增加了封闭类
JDK 17中扩展了switch模式匹配
JDK 19中增加了协程

如果我们需要持久化 Java 对象比如将 Java 对象保存在文件中，或者在网络传输 Java 对象，这些场景都需要用到序列化。简单来说：序列化：将数据结构或对象转换成二进制字节流的过程反序列化：将在序列化过程中所生成的二进制字节流转换成数据结构或者对象的过程

优点

缺点

1.7

1.8

并发问题

默认负载因子0.75

容量2^n次方

怎么降低hashmap冲突

hashmap 可以不用链表 红黑树么

JDK1.7版本的ReentrantLock+Segment+HashEntry

JDK1.8版本中synchronized+CAS+HashEntry+红黑树

ArrayList是可改变大小的数组

LinkedList双向链表

8个转红黑树

6个退回链表

一个节点可以存储一页数据16k

CREATE INDEX idx_city_age_sex ON user (city, age, sex)

锁(行锁或表锁)的影响，导致select 阻塞

事务隔离级别不同，读取的数据不同

查询计划的改变，索引的影响

确认问题

explain分析查询

检查索引

检查查询条件

检查硬件和资源

优化SQL

监控和日志

数据库优化

分析工具

考虑缓存

优化查询

添加索引

使用缓存

升级硬件资源

数据库分片

分区表

数据归档和清理

使用分布式数据库

数据库优化

选择适当的索引列

避免创建过多的索引

考虑复合索引

前缀索引

id

uuid

通常会选择使用具有更高选择性的单列索引 a

支持

唯一性：主键索引其实是一种特殊的唯一索引，他们都具有唯一性；也就是在一张表中，不能有两行有相同的主键；在同一张表中，主键索引字段的所有值都是唯一的

是否可空：主键索引是不能为NULL的，而唯一键索引是可以为NULL的。

是否可以有多个：主键索引在一张表中只能有一个，而唯一索引在一张表中可以创建多个。

索引结构：在InnoDB中，主键索引就是聚簇索引，而唯一索引通常是非聚簇索引。

是否回表：基于主键索引的查询一定不需要回表，基于唯一索引的查询，通常是需要回表的（这里的通常和上面的通常是一个事儿）

外键：主键可以被其他表引用为外键，而唯一索引是不可以的。

虽然查询条件的顺序与索引的顺序不完全一致，但MySQL通常会重新排列查询条件以充分利用索引，这被称为"索引下推优化"

GRANT permission_type ON database_name.table_name TO 'username'@'host';

CREATE TABLE table_name (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(255),
    age INT,
    gender VARCHAR(10),
    city VARCHAR(255),
    UNIQUE KEY (id),
    INDEX city_age_gender (city, age, gender)
) ENGINE=InnoDB;

分析执行计划

索引优化

查询优化

适当的数据类型

分页查询

工作流程

常用方法

事务

索引

锁

其他

虚拟机栈（栈帧中的本地变量表）中引用的对象。（方法的局部变量）

方法区中类静态属性引用的对象。（类的静态变量，使用static关键字）

方法区中常量引用的对象。（使用static final关键字修饰的常量）

本地方法栈中JNI（即一般说的Native方法）引用的对象。

Java中的并发问题主要源于多线程的运行方式及其对共享资源的访问和修改。在多线程环境下，当多个线程同时执行并尝试读取和修改同一资源（如变量、数据结构、文件等），如果没有适当的协调和同步机制，就可能导致数据不一致、数据丢失或者状态错误等问题

标记清除，标记复制，标记整理

-XX:+UseG1GC

–XX:+UseConcMarkSweepGC

创建阶段（Created）

应用阶段（Using）

不可视阶段（Invisible）

不可达阶段（Unreachable）

可收集阶段（Collected）

终结阶段（Finalized）

对象空间重新分配（Deallocated）

监控和记录GC日志

分析GC日志

分析内存快照

调整堆内存大小

查看GC原因

检查对象的生命周期

更换垃圾回收器

监控工具

查找高CPU进程（PID）

分析高CPU进程

查看日志

性能剖析

代码审查

数据库查询

资源竞争

系统资源

jvisualvm

jstat

jconsole

VisualVM

堆内存已经耗尽，无法为新的对象分配足够的内存空间

加载（Loading）

链接（Linking）

初始化（Initialization）

父类和子类 的加载顺序

CPU使用率

线程数

垃圾回收

线程状态

方法调用栈

外部资源调用

类加载

内存分配

初始化

构造函数调用

返回对象引用

垃圾回收

CMS

G1

指针碰撞：当堆中的内存是连续的，JVM使用一个指针来标记当前可用的内存位置，然后将指针向前移动分配对象所需的内存大小。

空闲列表：当堆中的内存是离散的，JVM会维护一个空闲列表，记录可用的内存块。在分配对象时，JVM会遍历空闲列表，找到足够大小的内存块进行分配。

指针碰撞适用于堆内存连续的情况，它简单高效，但对内存的要求较高。对应着Serial，ParNew GC等垃圾回收器。同时也对应着标记整理算法，复制算法等GC算法
空闲列表适用于堆内存离散的情况，它可以更灵活地利用内存碎片，但需要额外的空间来维护和查找空闲内存块。对应CMS垃圾回收器，算法为标记清除算法

三色标记法

可达性分析算法

引用计数法

会，controller是单例的，数据共享必然会有线程安全问题

每个请求一个service对象

@Transactional为什么能实现事务?

一级缓存

二级缓存

三级缓存

BeanFactory

FactoryBean

和reference的区别

1、前置通知（Before Advice）：

执行时机： 在连接点执行之前调用通知。
应用场景： 适用于执行某个方法之前需要进行一些准备工作，例如权限检查、日志记录等。

2、后置通知（After Returning Advice）：

执行时机： 在连接点正常执行完毕后调用通知。
应用场景： 适用于需要在方法成功执行后执行一些操作，例如记录返回值、清理资源等。

3、异常通知（After Throwing Advice）：

执行时机： 在连接点抛出异常时调用通知。
应用场景： 适用于需要在方法抛出异常时执行一些操作，例如异常日志记录、发送通知等。

4、最终通知（After (finally) Advice）：

执行时机： 在连接点执行完毕（无论成功还是抛出异常）后调用通知。
应用场景： 适用于需要在方法执行完毕后无论如何都执行一些操作，例如资源释放、清理工作等。

5、环绕通知（Around Advice）：

执行时机： 在连接点之前和之后都调用通知。它可以完全控制连接点的执行。
应用场景： 适用于需要完全控制连接点执行过程，可以在方法执行前后进行一些自定义的操作，例如性能监控、事务管理等。

@SpringBootApplication 是一个用于标识Spring Boot应用程序主类的注解。它整合了以下三个注解：

@Configuration：标识该类是一个配置类，通常用于定义配置信息或将其他 Bean 定义在该类中。

@EnableAutoConfiguration：开启自动配置功能，Spring Boot会根据项目的依赖自动配置应用程序所需的配置，大大减少了开发者的配置工作。

@ComponentScan：启用组件扫描，使Spring Boot能够扫描并识别应用程序中的组件（包括 @Controller、@Service、@Repository 等）。

通过这三个注解的组合，@SpringBootApplication 可以让Spring Boot应用程序变得非常简洁，同时提供了许多便捷的功能。

部署Spring工程： 将打包好的Spring工程（通常是一个WAR文件）放置到Tomcat的webapps目录下。

1、Tomcat启动： 启动Tomcat服务器。

2、Tomcat加载WAR文件： Tomcat在启动过程中会扫描webapps目录，检测到WAR文件后会将其解压并加载到内存中。

3、初始化Servlet容器： Tomcat在加载WAR文件后会初始化Servlet容器，并根据web.xml或者Servlet注解配置加载相应的Servlet和Filter。

4、加载Spring的DispatcherServlet： Spring应用通常会配置一个DispatcherServlet来接收所有的HTTP请求，并将它们分发到合适的处理器。在Spring工程中，会有一个类似于web.xml的配置文件（通常是一个Java配置类或者XML文件），其中会配置DispatcherServlet。

5、DispatcherServlet初始化： 当Tomcat启动时，它会加载Spring的DispatcherServlet，并调用它的初始化方法。在初始化过程中，DispatcherServlet会加载Spring应用程序上下文（ApplicationContext），并进行一系列的初始化操作，包括扫描组件、加载Bean定义等。

6、Spring应用程序上下文初始化： DispatcherServlet加载Spring应用程序上下文后，Spring会根据配置文件或者注解来初始化所有的Bean，并建立Bean之间的依赖关系。

7、处理请求： 当Tomcat接收到HTTP请求时，DispatcherServlet会根据请求的URL将请求分发给合适的Controller处理。Controller会处理请求，并调用相应的Service或者DAO层来完成业务逻辑。

总的来说，Tomcat作为Servlet容器，通过加载Spring提供的DispatcherServlet来启动和管理Spring工程。Spring的DispatcherServlet负责接收HTTP请求并分发到相应的处理器，从而启动Spring应用程序。

在Spring容器中实例化Bean时，如果Bean的类没有无参构造方法，Spring会尝试使用带有参数的构造方法进行实例化。Spring会选择匹配参数的构造方法来实例化Bean。如果存在多个带有参数的构造方法，Spring会尝试通过类型匹配来选择合适的构造方法。
如果有多个构造方法可以匹配，但没有一个明显的匹配，Spring将抛出UnsatisfiedDependencyException异常，表示无法确定要使用的构造方法。

IOC是一种设计思想，它反转了传统程序中对象的创建和管理方式。在传统的编程中，我们通过new关键字主动创建对象并维护它们的生命周期。而在IOC中，对象的创建和管理被交由容器负责。Spring框架是一个经典的IOC容器，通过XML配置、Java注解或者Java配置，它能够管理对象的生命周期、依赖关系和对象之间的引用。开发者只需关注对象的定义和它们之间的关系，而不需要直接负责对象的创建和销毁。

AOP是一种编程范式，它允许我们模块化横切关注点，例如日志、事务、安全等，与业务逻辑分离。在传统的面向对象编程中，我们主要关注类的设计和组织，而AOP关注的是程序执行过程中横切关注点的处理。AOP通过切面、连接点、通知和切点等概念实现。切面是横切关注点的模块化，通知是在切面的某个连接点上执行的动作，连接点是程序执行的点，切点定义了连接点的集合。Spring框架提供了AOP支持，允许我们通过配置或注解的方式，将横切关注点织入到应用程序中，从而实现更好的模块化和可维护性。主要通过jdklib或cglib动态代理实现

工厂模式（Factory Pattern）：

Spring应用： Spring使用工厂模式通过BeanFactory或ApplicationContext创建和管理Bean实例。
理解： 工厂模式将对象的创建过程封装在一个工厂类中，客户端通过工厂类获取所需的对象，而不需要了解对象的具体创建细节。

单例模式（Singleton Pattern）：

Spring应用： Spring默认情况下是单例管理Bean的，即在容器中一个Bean只有一个实例。
理解： 单例模式确保一个类只有一个实例，并提供一个全局访问点。在Spring中，单例Bean通常用于那些无状态的、可共享的组件。

代理模式（Proxy Pattern）：

Spring应用： Spring AOP（面向切面编程）中使用代理模式来实现横切关注点。
理解： 代理模式允许一个对象代表另一个对象进行控制访问。在Spring AOP中，代理对象织入了横切关注点，实现了对原始对象的增强。

观察者模式（Observer Pattern）：

Spring应用： Spring的事件机制使用了观察者模式，如ApplicationEvent和ApplicationListener。
理解： 观察者模式定义了一种一对多的依赖关系，使得一个对象的状态变化会通知所有依赖于它的对象。

模板模式（Template Pattern）：

Spring应用： Spring的JdbcTemplate和RestTemplate等使用了模板模式。
理解： 模板模式定义了一个算法的骨架，将某些步骤延迟到子类中实现。在Spring中，模板模式通过定义通用的算法骨架，将具体的实现交给子类或回调方法。

策略模式（Strategy Pattern）：

Spring应用： Spring的@Qualifier注解和@Primary注解使用了策略模式。
理解： 策略模式定义了一族算法，将它们封装起来，并使它们可以互相替换。在Spring中，策略模式用于选择特定的实现或配置。

优点：
快速开发： Spring Boot采用了约定大于配置的理念，提供了很多默认配置，可以快速搭建和开发应用，减少了开发者的工作量。

自动配置： Spring Boot通过自动配置根据项目的依赖和约定自动配置应用程序，减少了手动配置的工作。

内嵌服务器： Spring Boot内置了常用的Servlet容器（如Tomcat、Jetty），简化了应用的部署过程，可以将应用打包成可执行的JAR文件。

微服务支持： Spring Boot天然地支持构建和部署微服务架构，与Spring Cloud等配合使用，方便微服务的开发和管理。

丰富的生态系统： Spring Boot基于Spring框架，继承了Spring的丰富生态系统，可以方便地集成各种插件、中间件和其他库。

良好的文档和社区支持： Spring Boot拥有广泛的文档和强大的社区支持，开发者可以轻松地获取到大量的学习资源和问题解答。

缺点：
学习曲线： 对于初学者来说，Spring Boot的学习曲线可能相对陡峭，因为需要理解Spring框架的基础知识。

过于自动化： 对于一些开发者来说，Spring Boot的自动化特性可能有时会导致难以定制和调整，尤其在一些非常定制化的场景下。

应用大小： 由于Spring Boot内嵌了Servlet容器等组件，打包的应用可能相对较大，尤其在需要构建独立的可执行JAR文件时。

不适合所有项目： 对于小型和简单的项目，Spring Boot可能提供了过多的功能，可能不是最佳的选择。选择使用Spring Boot需要根据具体项目需求来评估是否合适。

spring.profiles.active

@ConditionalOnClass： 当类路径下存在指定的类时，才会创建Bean或激活配置

@ConditionalOnMissingClass： 当类路径下不存在指定的类时，才会创建Bean或激活配置。

@ConditionalOnProperty： 当指定的属性存在并且值满足条件时，才会创建Bean或激活配置。

@ConditionalOnExpression： 当指定的SpEL表达式为true时，才会创建Bean或激活配置。

过滤器是Servlet规范定义的一种用于在请求到达Servlet之前或响应离开Servlet之后执行过滤任务的组件。过滤器的生命周期由Servlet容器管理。以下是过滤器的触发时机：

请求到达Servlet之前： 在请求到达Servlet之前，过滤器可以执行一些预处理任务，例如身份验证、日志记录等。doFilter方法用于实际过滤操作。

响应离开Servlet之后： 在Servlet处理完请求并生成响应后，响应离开Servlet之前，过滤器可以执行一些后处理任务。

拦截器是Spring MVC框架提供的组件，用于在请求到达控制器之前或离开控制器之后执行拦截任务。拦截器的生命周期由Spring容器管理。以下是拦截器的触发时机：

请求到达控制器之前： 在请求到达Spring MVC控制器之前，拦截器可以执行一些预处理任务。preHandle方法用于实际拦截操作。

控制器处理完请求后： 在控制器处理完请求后，返回视图之前，拦截器可以执行一些后处理任务。postHandle方法用于实际拦截操作。

视图渲染完毕后： 在视图渲染完毕后，即响应已经生成并准备发送到客户端时，拦截器可以执行一些最终的任务。afterCompletion方法用于实际拦截操作。

总体而言，过滤器是在Servlet规范层面实现的，而拦截器是在Spring MVC框架中实现的。过滤器的生命周期由Servlet容器管理，而拦截器的生命周期由Spring容器管理。拦截器提供了更细粒度的控制和更多的钩子方法，但在一些情况下，过滤器可能更适合处理一些通用的Web请求过滤任务。

1、拦截器是基于java的反射机制的，而过滤器是基于函数回调。
2、拦截器不依赖于servlet容器，过滤器依赖与servlet容器。
3、拦截器只能对action请求起作用，而过滤器则可以对几乎所有的请求起作用。
4、拦截器可以访问action上下文、值栈里的对象，而过滤器不能访问。
5、在action的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次。
6、拦截器可以获取IOC容器中的各个bean，而过滤器就不行，这点很重要，在拦截器里注入一个service，可以调用业务逻辑。

Spring中通过代理实现事务管理。如果同一个类内部的方法直接调用，而不是通过代理对象调用，事务可能会失效。因为代理对象无法截获同类方法的调用，从而无法处理事务。

作用对象

底层原理

锁的优化

ABA问题 ，加版本号

并发处理： 当有多个任务需要同时执行，且相互之间不影响或依赖的时候，可以使用多线程来提高系统的并发处理能力，提高效率。

异步编程： 多线程可以用于处理异步任务，例如在用户界面中进行网络请求、文件读写等操作，以避免阻塞用户界面。

任务分解： 将大任务分解为多个小任务，每个任务由一个线程独立执行，可以提高任务的并行度，加速任务的完成。

提高系统性能： 多线程可以利用多核处理器，提高系统整体的性能。

多线程是一种并发编程的手段，它允许程序同时执行多个独立的线程，每个线程都有自己的执行路径。多线程可以使得程序在某些情况下更加高效，充分利用计算资源，提高系统的响应速度和吞吐量。

然而，多线程也带来了一些挑战，如竞态条件、死锁、资源竞争等问题。因此，在使用多线程时需要注意线程安全性、同步机制等问题，以保证程序的正确性和稳定性。

JDK 8 线程：
使用基于线程的并发模型，每个线程对应一个执行路径。
线程切换会涉及上下文切换，可能会带来一些性能开销。
线程通常需要占用一定的内存资源。

JDK 19 协程：
协程是一种轻量级的线程，不需要创建新的线程。
协程的切换是用户级的，不涉及内核级别的上下文切换，避免了一些性能开销。
协程可以更灵活地管理并发，不需要关心线程的创建和销毁。

优势和选择取决于具体的使用场景：
协程适用于高并发、高吞吐量的场景，特别是在IO密集型任务中。
线程适用于CPU密集型任务，或者需要与外部系统交互的任务。

1.synchronized是关键字,Lock是接口;

2.synchronized是隐式的加锁,lock是显式的加锁;

3.synchronized可以作用于方法上,lock只能作用于方法块;

4.synchronized底层采用的是objectMonitor,lock采用的AQS;

5.synchronized是阻塞式加锁,lock是非阻塞式加锁支持可中断式加锁,支持超时时间的加锁;

6.synchronized在进行加锁解锁时,只有一个同步队列和一个等待队列, lock有一个同步队列,可以有多个等待队列;

7.synchronized只支持非公平锁,lock支持非公平锁和公平锁;

8.synchronized使用了object类的wait和notify进行等待和唤醒, lock使用了condition接口进行等待和唤醒(await和signal);

9.lock支持个性化定制, 使用了模板方法模式,可以自行实现lock方法;

场景

java多线程如何实现线程同步，手写多线程死锁代码

进程和线程的区别

Java线程和linux线程什么关系，是一对一还是一对多

有进程了为什么还要有线程

线程安全是指在多线程环境下，一个操作或一系列操作能够被正确执行，而不会导致数据不一致、状态异常或者程序中断。具体而言，线程安全的代码能够确保在并发执行时，不会出现数据竞争、死锁、活锁等并发问题。保障数据的原子性，可见性和有序性

在使用 wait 和 notify 时，通常会将 wait 放在一个 while 循环中，而不是 if 语句中。这是为了防止虚假唤醒，即在没有调用 notify 或 notifyAll 的情况下，线程也可能从等待状态中被唤醒。通过放在 while 循环中，可以确保线程在被唤醒后重新检查条件，从而避免不正确的执行。

wait 和 notify： wait 和 notify 方法是用于实现线程间通信的机制，因此它们被定义在 Object 类中。这是因为所有的Java对象都可以被用作锁，而线程间通信通常涉及到对共享资源的锁定和释放。

sleep： 相比之下，sleep 方法是 Thread 类的静态方法，用于暂停当前线程的执行一段时间。这是因为 sleep 是与线程的时间控制相关的，而不是与特定的对象或锁有关。

corePoolSize线程池中的常驻核心线程数

maximumPoolSize：线程池能够容纳同时执行的最大线程数，此值大于等于1

keepAliveTime:多余的空闲线程存活时间，当空间时间达到keepAliveTime值时，多余的线程会被销毁 
   直到剩下corePoolSize个线程为止

Unit：keepAliveTime的单位

WorkQueue：任务队列，被提交但尚未被执行的任务

ThreadFactory：表示生成线程池中工作线程的线程工厂，用户创建新线程，一搬用默认即可

Handler：拒绝策略，表示当线程队列满了并且工作线程大于等于线程池的最大线程数 
   （maximumPoolSize）时如何来拒绝请求执行的runnable的策略

在 runWorker 方法中，工作线程首先通过 getTask 方法获取任务，然后执行任务的 run 方法。任务执行完毕后，会调用 afterExecute 方法。

在 afterExecute 方法中，会检查线程池的终止状态，并根据终止状态来决定是否进行线程的回收。如果线程池需要进行回收，会调用 processWorkerExit 方法，该方法包含了线程的退出逻辑。

为什么用redis

redisson为什么好

布隆过滤器怎么提供准确度

redis主从复制原理

epoll poll 区别

集群如何保证顺序写入读取

发送者、消费者、kafka服务自己如何做到不丢数据

消费者如何做到不重复消费

partition的副本机制项目中是如何使用的

项目中如何解决kafka的重复消息

项自为什么kaka而不是其他的?kafka和rocketmg有什么区别，适用场景

kafka如何保证一致性和可用性

业务代码修改mysql数据库后发送kafka消息然后事务回滚，但消息已经发了咋办

kafka的rebalance机制