Spring中的BeanFactory和FactoryBean的区别

Spring里面的核心功能是IOC容器，而IOC容器本质上就是一个Bean的容器或者是一个Bean的工厂，它能够根据XML里面声明的Bean的配置去进行Bean的加载和初始化，BeanFactory来生产我们所需要的各种各样的一个Bean，所以我对BeanFactory的理解有两个，第一个，BeanFactory是所有Spring Bean容器的顶级接口，它为Spring的容器定义了一套规范，并提供像getBean这样的方法从容器中获取指定的Bean实例；第二个，BeanFactory在产生Bean的同时，还提供了解决Bean之间的依赖注入的能力，也就是所谓的DI。

而FactoryBean是一个工厂Bean，它是一个接口，主要功能是动态去生成某一类型的Bean的一个实例，也就是说我们可以自定义一个Bean，并且加载到IOC容器里面，它里面有一个重要的方法，叫getObject()，这个方法就是用来实现动态构建Bean的一个过程。

BeanFactory与ApplicationCobntext的区别

1）BeanFactory是Spring的早期接口，称为Spring的Bean工厂，ApplicationContext是后期更高级接口，称之为Spring 容器；

2）ApplicationContext在BeanFactory基础上对功能进行了扩展，例如：监听功能、国际化功能等。BeanFactory的API更偏向底层，ApplicationContext的API大多数是对这些底层API的封装；

3）Bean创建的主要逻辑和功能都被封装在BeanFactory中，ApplicationContext不仅继承了BeanFactory，而且ApplicationContext内部还维护着BeanFactory的引用，所以，ApplicationContext与BeanFactory既有继承关系，又有融合关系。

4）Bean的初始化时机不同，一个延迟加载，一个立即加载。原始BeanFactory是在首次调用getBean时才进行Bean的创建，而ApplicationContext则是配置文件加载，容器一创建就将Bean都实例化并初始化好。

BeanFactory是核心接口，项目运行过程中肯定有具体实现参与，这个具体实现就是DefaultListableBeanFactory，也是ApplicationContext内部维护的Beanfactory的实现类。

为什么重写equals还要重写hashcode？

重写equals方法是为了比较两个对象是否相等，而重写hashCode方法是为了保证相等的对象具有相同的哈希值，从而能够正确地存储和查找这些对象。

==和equals比较的区别

==比较的是两个对象的引用是否指向同一个内存地址，而equals比较的是两个对象的内容是否相等。

为什么有时会出现4.0 - 3.6 = 0.40000001这种现象？

这是由于计算机在进行浮点数运算时，会存在精度误差。这是因为浮点数在计算机中是以二进制形式存储的，而二进制无法精确表示某些十进制小数，从而导致精度误差。

final关键字的作用

final关键字可以用来修饰类、方法和变量。当修饰类时，表示该类不能被继承；当修饰方法时，表示该方法不能被重写；当修饰变量时，表示该变量的值不能被修改。

介绍Java的集合类

Java的集合类包括List、Set、Map等。List是有序的集合，可以包含重复元素；Set是无序的集合，不包含重复元素；Map是一种键值对的映射表。

ArrayList和LinkedList的区别

ArrayList和LinkedList都是List接口的实现类。ArrayList是基于数组实现的，支持随机访问和快速插入/删除元素，但在插入/删除元素时需要移动其他元素；LinkedList是基于链表实现的，支持快速插入/删除元素，但在随机访问元素时需要遍历整个链表。因此，如果需要频繁进行随机访问操作，应该使用ArrayList；如果需要频繁进行插入/删除操作，应该使用LinkedList。

StringBuilder和StringBuffer的区别

String是不可变的，即一旦一个String对象被创建以后，包含在这个对象中的字符序列是不可改变的，直至这个对象被销毁。

StringBuffer对象则代表一个字符序列可变的字符串，当一个StringBuffer被创建以后，通过StringBuffer提供的append()、insert()、reverse()、setCharAt()、setLength()等方法可以改变这个字符串对象的字符序列。一旦通过StringBuffer生成了最终想要的字符串，就可以调用它的toString()方法将其转换为一个String对象。StringBuffer对象是一个字符序列可变的字符串，它没有重新生成一个对象，而且在原来的对象中可以连接新的字符串。

StringBuilder类也代表可变字符串对象。实际上，StringBuilder和StringBuffer基本相似，两个类的构造器和方法也基本相同。不同的是：StringBuffer是线程安全的，而StringBuilder则没有实现线程安全功能，所以性能略高。StringBuffer类中的方法都添加了synchronized关键字，也就是给这个方法添加了一个锁，用来保证线程安全。

使用场景：

如果要操作少量的数据用 String；
多线程操作字符串缓冲区下操作大量数据 StringBuffer；
单线程操作字符串缓冲区下操作大量数据 StringBuilder。

exception和error的区别

Error 和 Exception 都是Throwable的子类，在java中只有Throwable类型的实例才可以被抛出或者捕获，它是异常处理机制的基本类型。

Exception 和 Error体现了java平台设计者对不同异常情况的分类，Exception是程序正常运行中，可以预料的意外情况，可以被捕获，进行相应的处理。
Error 是指正常情况下,不大可能出现的情况,绝大部分的Error 都会导致程序处于非正常的，不可恢复的状态，不需要捕获，常见的OutOfMemoryError 是Error的子类。
Exception 分为可检查异常(checked) 和不可检查异常(unchecked)。可检查异常在源代码里必须显式的进行捕获处理，这是编译期检查的一部分，不可检查异常是指运行时异常，比如NullPointerException，ArrayIndexOutOfBoundsException之类，通常是可以编码避免的逻辑错误，具体根据需要来判断是否需要捕获，并不会在编译期强制要求。

讲讲mysql索引失效

讲讲sql优化的思路

讲讲mysql子查询可以被什么代替

子查询可以被更有效率的连接（JOIN），连接（JOIN）之所以更有效率一些，是因为 MySQL不需要在内存中创建临时表来完成这个逻辑上的需要两个步骤的查询工作。

讲讲Spring的IOC和AOP

控制反转（IOC）是一种设计思想，就是将原本在程序中需要手动创建对象，现在交由Spring管理创建。举个例子，原本我们要在A类中调用B类的方法，就要直接在A中new出B类对象，然后调用B类中的方法，虽然能实现效果，不过存在一个问题，更改需求会对源代码进行修改，这是大忌。现在创建B对象就交给了Spring，在Spring中，B类对象被看成Bean对象（Spring中类就是Bean），这个Bean对象由spring容器进行创建和管理，当我们在配置文件中配置下的子元素（类的属性）时，Spring就会自动执行在A中B对象的setter方法（前提要有），这样的话A对象获取B对象中的方法，由主动new，变成被动等Spring创建。主动变被动，就可以理解成控制反转，通俗讲就是“你别动，我(Spring)来做就好”，主动变被动，这样就大大降低了耦合，Spring中全都用这种思想，即依赖类不由程序员实例化，而是通过Spring容器帮我们new指定实例并且将实例注入到需要该对象的类中，Spring通过DI（依赖注入）实现IOC（控制反转）。

面向切片编程（AOP—Aspect Oriented Programming）可以说是对OOP（面向对象编程）的补充和完善，面向对象就是将事物的特性和行为抽象为一个对象，如people类有身高、体重、年龄等属性，也有吃饭、睡觉等行为。把这些特性和行为封装成一个类，然后可以统一调用。面向切片也可以举个例子，比如people类有自己的属性和行为，但是有小一部分人生病要去医院看病，看病这个业务逻辑就不属于哪一个类，因为people泛指所有人，所有人不会都看病。AOP就是把医院看病这一个业务逻辑功能抽取出来，然后动态把这个功能切入到需要的方法（或行为）中，需要的才切入，这样便于减少系统的重复代码，降低模块间的耦合度。常用到AOP的就是安全校验、日志操作、事务操作等，给你先定义好，然后在想用的地方用，这样不会影响已经在服务器运行的项目，然后又能注入新功能，灵活。我们开发dao->service->controller是纵向的，这个AOP就是横向切入，如横向切入一个日志Log，打印执行过程。

讲讲Spring的事务原理

讲讲mysql事务原理（难）

讲讲mysql隔离级别实现原理

mysql默认的隔离级别

mysql的四大特性

原子性：事务是数据库的逻辑工作单位，事务中包含的各操作要么都做，要么都不做
一致性：事务开始前和结束后，数据库的完整性约束没有被破坏
隔离性：一个事务的执行不能被其它事务干扰。即一个事务内部的操作及使用的数据对其它并发事务是隔离的，并发执行的各个事务之间不能互相干扰。
持久化：指一个事务一旦提交，它对数据库中的数据的改变就应该是永久性的。接下来的其它操作或故障不应该对其执行结果有任何影响

消息队列

mybatis中#{}和&{}的区别

讲讲Spring中bean的生命周期

Java垃圾回收

jwt和token

session原理

linux常用命令

进程、线程和协程之间的区别

进程切换为什么比线程切换效率低

每个进程都有对应的页表，进程切换的时候需要切换页表，为了加快虚拟地址的地址转换效率，所以引入了TLB来缓存对应的虚拟地址和物理地址的映射。

切换页表这个操作本身是不太耗费时间的，切换之后，TLB就失效了，所以在进行地址转化的时候需要重新去查找页表，这就造成了程序运行的效率低下。

同一个进程的线程之间是共用一个页表的，所以线程之间的切换是不需要切换页表的。

什么是一致性哈希

TCP三次握手四次挥手全解

TCP滑动窗口机制

socket通信服务端和客户端的流程

10亿个数字取前100大的怎么取？

大根堆具体的原理

redis基本数据结构

mysql底层数据结构

不可重复读和幻读的区别

MVCC实现可重复读

B+树和B树的区别

为什么使用B+树做索引

B+树查询访问几次磁盘？

线程池详解

JVM详解

类加载的过程

双亲委派模型

设计模式

单例模式、懒汉式、线程不安全

十大排序算法

栈和队列详解

多线程并发控制

死锁条件与解除

OSI七层模型

https四次握手

hashmap底层原理

为什么HashMap要用数组➕链表➕红黑树来实现？
HashMap的put方法的大致实现流程？
HashMap中数组的大小有什么特点？
HashMap中数组的大小为什么要是2的幂次方数？
HashMap中是如何计算数组下标的？
HashMap是如何进行扩容的？
HashMap的rehash底层是如何实现的？
HashMap为什么会出现ConcurrentModificationException？

hashmap线程安全问题

rabbitmq消息可靠性

@Async原理

mybatis工作原理

怎么提高项目进度

代码块重用
AOP
优秀的工具

SpringBoot优点

减少开发，测试时间和努力。
使用JavaConfig 有助于避免使用XML。
避免大量的Maven 导入和各种版本冲突。
通过提供默认值快速开始开发。
没有单独的Web 服务器需要。这意味着你不再需要启动Tomcat，Glassfish或其他任何东西。
需要更少的配置因为没有web.xml 文件。只需添加用@ Configuration 注释的类，然后添加用@Bean 注释的方法，Spring 将自动加载对象并像以前一样对其进行管理。您甚至可以将@Autowired 添加到bean 方法中，以使Spring 自动装入需要的依赖关系中。
基于环境的配置使用这些属性，您可以将您正在使用的环境传递到应用程序：-Dspring.profiles.active = {enviornment}。在加载主应用程序属性文件后，Spring 将在（application{environment} .properties）中加载后续的应用程序属性文件。

@AutoConfiguration实现原理

druid特点

连接池的作用

BIO、AIO、NIO、多路复用

多路复用相比NIO的优势

红黑树与平衡二叉树

ConcurrentHashmap底层原理

ConcurrentHashmap更详细的介绍

Volatile和synchronized区别

介绍虚拟内存

多级页表

用户态和内核态切换

索引数据结构

数据库慢查询

ThreadLocal使用

数据库和缓存一致性

二级缓存数据一致性

@SpringBootApplication注解

@PostConstruct注解

Spring工厂模式

rabbitmq延迟队列

java中private string_java 中private static final String string的介绍final的意思

TreeMap

mysql普通索引和唯一索引

字符串常量池

Redis过期key删除

Spring循环依赖

git遇到代码冲突

redis分布式锁如何防止用户重复提交表单

AQS同步队列

联合索引

Java线程安全的容器

ConcurrentModificationException

线程执行问题

反射class.forname

反射在IoC中的运用

@Transactional注解参数

mysql索引分类

mysql锁机制

Redis缓存击穿、穿透、雪崩

MVCC的RC和RR实现

ThreadLocal的结构

多线程下对并发资源访问的隔离性，各个线程有自己的空间
单线程下资源共享

使用ThreadLocal过程中可能存在哪些问题？

内存泄漏问题
- get方法
- set方法
- remove方法

Redis如何推举新的主节点？

主从模式
哨兵模式

一个项目提出到落地的大致流程？

稳定性治理

高可用（中间件）
- 事前
- 事中
- 事后

慢sql/功能调优

sql调优

使用覆盖索引（什么是覆盖索引？）
主键顺序导入
limit索引 + 子查询
order by需要所有条件都是升序或者降序，否则就要建新的索引
不要join太多表，给被驱动表添加合适的索引

写sql的时候需要注意什么？

操作系统进程间的通信方式

线程间的通信方式

B树、B-树和B+树对比

B树、B-树和B+树都是常用于实现数据库索引的树形数据结构，它们相似但有不同的特点和用途：

B树：B树也叫平衡树，它对于节点上的数据没有限制，适合存储大量数据。B树的每个节点包含多个key和多个指向其他子节点的指针，可以支持范围查找和不完全匹配查找，并且树的高度不会很高，通常维护的阶数较高（大于等于2），这样在查询很多数据时，IO访问次数会减少，效率会较高。
B-树：B-树也是平衡树，但它的每个节点需要满足一定的维护规则。其中，每个节点包含多个key和多个指向其他子节点或数据块的指针，每个节点的key值都要小于等于右兄弟节点的所有key值，减少了磁盘IO的访问次数，因此可以更高效地支持范围查找和不完全匹配查找。
B+树：B+树在B-树的基础上做了一些优化，具有更高的查询效率和更适合磁盘存储的特点，也是常见的数据库索引实现方式。B+树的每个节点包含多个key和多个指向其他子节点或数据块的指针，而这些指针都存储在叶子节点上，内部节点只存储key值，叶子节点形成一个链表，方便范围查询。通过这样的设计，可以加快范围查询和逐层扫描的速度，因此常用于大量数据的高效查询中。

总体来说，B树适合随机查询，B-树适合范围查询，B+树在B-树的基础上做了进一步优化，更适合于大量数据的查询，不同类型的树超过特定数据量后，就会发挥出其各自优势。

索引失效的场景

索引失效是查询性能低下的一个常见原因。以下是一些可能导致索引失效的场景：

取值范围过大：如果查询的条件具有广泛的取值范围，那么就会出现索引失效的情况。例如，使用LIKE操作符进行模糊查询。
对索引列进行了函数操作：如果对索引列进行了函数操作，索引就不会被使用。例如，使用LOWER()函数将查询语句中的列转换为小写。
查询条件中使用了“非”操作：如果查询条件中包含“非”操作（例如NOT、<>等），则索引就可能失效。
数据抽样不足：当数据量较大时，系统可能只对表的一小部分进行采样。如果采样数据的列没有被索引，索引就可能失效。
列类型不一致：如果查询条件的列类型与索引列类型不一致，索引就可能失效。例如，将日期格式的字符串与日期类型的索引列进行比较。
多列索引顺序不正确：如果索引由多列组成，但查询条件中只包含了部分列，那么索引就可能失效。在这种情况下，索引列的顺序可能也很重要。

为了解决索引失效的问题，可以采取以下步骤：

确保查询条件与索引列相匹配。
避免对索引列进行函数操作。
避免使用“非”操作符。
确保数据抽样足够。
让查询条件中的列与索引列类型保持一致。
确认多列索引顺序是否正确。

数据库慢查询

有很多因素可能会导致数据库慢查询，最常见的几个原因包括：

缺乏适当的索引：索引是快速查找和过滤数据的关键。如果没有适当的索引，则查询可能会扫描整张表或大部分表，从而导致查询变慢。
数据库结构设计不佳：如果数据库结构设计不合理或不优化，则查询可能会涉及多个表或跨越多个数据段。这会导致查询变慢并增加系统资源的使用量。
数据库负载高：如果有太多用户同时向数据库发送请求，则数据库可能会过载，从而导致查询变慢。
数据库服务器的资源不足：如果数据库服务器没有足够的内存、CPU、磁盘空间或网络带宽等资源，则查询会受到限制，从而导致查询变慢。
数据库连接池配置不当：如果数据库连接池配置得不好，则会出现连接池饱和的情况。这会导致查询处理时间变慢。
数据库中大量的重复数据：如果数据库中存在大量的重复数据，查询需要扫描更多的数据，从而导致查询速度变慢。
数据库系统维护任务：数据库系统维护任务可能会对正常查询造成干扰，导致查询变慢。

为了优化数据库查询性能，可以采取以下步骤：

对数据库进行适当的索引。
优化数据库的结构设计，避免跨表查询。
控制数据库的负载。
确保数据库服务器拥有足够的资源。
配置合适的数据库连接池。
整理数据库中的冗余数据以提高查询效率。
合理规划维护计划并在非高峰期执行。

SQL调优

SQL调优是指对数据库中的SQL语句进行优化，以提升数据库的性能和可靠性。下面是SQL调优的一些常见手段：

编写高效的SQL语句：编写高效的SQL语句是SQL调优的基础。查询要尽可能减少数据集的大小，选择合适的索引字段和索引算法，避免使用向数据库提出太多的小型请求。要尽可能使用批量查询和异步查询等技术，减少网络传输和数据库连接的开销。
创建索引：索引是加速数据访问速度的关键，创建好的索引可以大幅提升查询语句的执行效率。需要指出的是，索引也会增加数据库的存储消耗，因此在创建索引时需要根据实际情况进行权衡。
数据库表设计的优化：数据库的表设计对查询性能有很大影响。需要考虑将冗余信息转移到外部表中，合理分配表和字段的大小，优化表和字段的类型。同时，将频繁查询的字段缓存起来，可以减少查询和处理数据的时间。
合理使用数据库连接池：由于建立数据库连接耗费的时间比较多，因此使用连接池可以减小这个开销，提高数据库访问效率。连接池的大小应该根据应用程序的并发量和数据库服务的性能来设置。
隔离级别的调整：事务隔离级别可以影响到数据的相互影响，过高的事务隔离级别会导致锁的等待时间过长，影响整个系统的响应速度。因此需要根据实际情况合理设置隔离级别

从硬件层面看CAS的原子性

CAS（Compare and Swap，比较并交换）是一种乐观锁机制，它可以在不使用锁的情况下实现对共享资源的原子操作。从硬件层面上来说，CAS要保证原子性，需要CPU提供原子性的指令来支持CAS操作，称之为“原子性指令”。

具体来说，原子性指令包含了三个基本的操作：读取、比较和写入。在CPU底层，这些操作是以一个单独的CPU指令来实现的，这个指令是为了保证在一个CPU周期内完成这三个操作，即“原子化”的执行它们。

当CPU执行CAS指令时，首先读取内存中的变量值，并将其与期望的值进行比较。如果相同，说明该内存变量未被其他线程修改，就可以将新值写入内存；如果不同，说明该内存变量已被修改，CAS指令失败，需要重新尝试。

为了保证CAS操作的原子性，CPU在执行CAS指令时将会禁止其他CPU的访问，这样保证了CAS指令中的三个操作是一个不可分割的整体。在多CPU并发的场景下，每个CPU都有自己的缓存，如果几个线程同时修改一个变量，就会引起“缓存一致性问题”，因此需要利用总线锁或者缓存锁等机制来保证CAS操作之间的互斥性，防止出现非预期的结果。

由于硬件支持，并且不需要使用锁来保证互斥访问，CAS比传统的锁机制具有更高的性能和可扩展性，因此在并发编程中应用广泛。但是需要注意的是，如果修改冲突比较频繁（如并发高），就会引发CAS操作的重试，增加CPU的负载和竞争，因此在选择CAS操作时需要考虑并发情况的实际情况。

Java1.7中hashmap的死锁现象

在Java 1.7中，HashMap存在可能导致死锁现象出现的情况，这个问题的根本原因在于HashMap内部的数据结构实现方式不够健壮，线程不安全，多线程同时操作会引发高并发问题，解决这个问题需要对HashMap进行同步或者使用一些线程安全的数据结构。

具体来说，当多个线程同时对HashMap进行扩容时，如果它们试图同时实例化新的桶位，就会发生死锁现象。这是因为，在扩容时需要对桶位进行分段锁定，但是每个桶位本身也是一个链表，如果在扩容前没有对每个桶位的链表进行同步处理，则可能导致多个线程同时加入新元素而导致死锁。

但是需要注意的是，HashMap在Java 1.8之后已经针对这个问题进行了优化，通过对数据结构的改进，让多线程同时操作HashMap不再造成死锁问题。

因此，如果使用Java 1.7及以下版本的HashMap，为了避免发生死锁，需要对HashMap进行同步操作（如使用ConcurrentHashMap代替HashMap），或是使用一些线程安全的数据结构。

Java1.7和1.8中hashmap的区别

Java 1.7和1.8中hashmap的区别主要体现在以下两个方面：

数据结构的改变

在Java 1.7中，HashMap使用的是数组和单链表的组合实现哈希表的存储和操作。在哈希值冲突的情况下，同一哈希值所对应的元素会添加在同一个单链表中。

而在Java 1.8中，HashMap对其底层的数据结构进行了优化，使用链表和红黑树的结合来实现哈希表。当某一节点链的长度达到阈值（默认为8）时，它将会被转化为红黑树以减少搜索的时间开销。

非常重要的优化

Java 1.8中对HashMap进行了非常重要的优化，即引入了“红黑树优化”（Tree bins）。在Java 1.8中，如果一个桶里的链表长度超过了8个，就将会把链表转化成红黑树。通过这种优化，能够有效地降低添加、查找和删除元素的时间复杂度。

总而言之，Java 1.7和Java 1.8中HashMap的主要区别在于数据结构的改变和引入了红黑树优化。通过对数据结构进行优化，Java 1.8中HashMap的性能有了非常大的提升，特别是在操作复杂的场景下，更加稳定和高效。

OOM出现的场景

OOM（Out Of Memory）指的是Java程序在执行过程中内存不足，无法再分配新的内存空间，从而导致程序无法继续执行的情况。Java中的OOM通常是由以下几个情况引起的：

堆空间不足：当Java程序在创建新对象时，如果发现内存中没有足够大小的空间可以分配给这个对象，就会出现内存溢出（OOM）。这种情况通常是因为系统分配给Java堆的内存空间不足，或者程序设计不良导致堆中的对象无法被及时释放所致。
持久代空间不足：Java堆中的持久代用于存储类的信息、方法等数据，通常情况下不需要过多的空间。但有时候需要加载许多大型的类、动态生成很多类时，可能会导致持久代空间不足，引起OOM。
栈空间不足：Java虚拟机栈用于存储线程执行的状态，包括局部变量、方法调用和返回等。当线程执行的过程中栈空间不足时（通常是由于嵌套调用的方法太多或线程并发量太大所导致），就会发生OOM。
限制设置不当：Java虚拟机中包含一些参数可以用于控制内存的使用，如堆大小、栈深度等。如果这些参数设置不当，就可能导致OOM。例如，将-Xmx（堆最大内存）设置得太小，将-Xss（线程栈大小）设置得太大等。

总之，Java中的OOM主要是由Java堆、持久代、虚拟机栈等内存区域的空间不足引起的，但还包括限制设置不当等因素。要避免OOM，需要合理地设置内存使用参数，代码设计时需要注意及时释放对象，尽量避免创建过多的临时对象等。

Java运行时数据区结构

运行时数据区域是JVM运行Java程序时用于存储数据的内存区域。根据JVM规范，运行时数据区域被分解为以下几个部分：

程序计数器：用于在多线程环境下记录线程执行的位置，以便在发生线程切换时能够恢复执行。每个线程都有自己独立的程序计数器，因此内存消耗非常小。
Java虚拟机栈：栈用于存储Java方法的局部变量、操作数栈、方法出口等数据。当一个方法被调用时，它在栈顶分配一块区域，当方法返回时，该区域就被释放。每个线程都有自己的虚拟机栈，因此内存消耗会随着线程数的增加而增加。
本地方法栈：与Java虚拟机栈类似，不同的是本地方法栈用于处理本地方法，即由本地代码实现的Java方法调用。
Java堆：是JVM中最大的内存区域之一，用于存储Java对象实例。Java堆的内存分配是动态、自适应的。在堆中分配内存时，会自动通过垃圾回收来释放不再使用的对象，因此需要注意的是，Java堆的内存使用情况直接决定着JVM的性能。
方法区：用于存储已被加载的类信息、常量池、静态变量、即时编译器编译后的代码等。可以理解为是Java堆的一部分，但和Java堆的区别在于：堆是用于存储Java对象的，而方法区是用于存储Java类信息的。
运行时常量池：与方法区相关联，用于存储编译期生成的字面量和符号引用。它包含了各种类型的常量，如字符串常量、类和接口名、字段和方法名等等。需要注意的是，运行时常量池中的常量信息是在类加载时被存储进去的，而不是在运行时被动态生成的。

了解运行时数据区域的结构和功能对于Java程序开发者和JVM调优来说都非常重要。通过合理地利用运行时数据区域，可以提高Java程序的性能和稳定性。

JVM的结构

JVM（Java Virtual Machine，Java虚拟机）是Java的核心组件之一，用于在各种计算机平台上执行Java字节码。JVM的结构可分为以下几个部分：

类加载器子系统：它负责加载Java类文件，将其转换为JVM内部的类表示形式。类加载器子系统采用了一种双亲委派机制，以确保不同的类加载器不会重复加载相同的类。
运行时数据区域：它包括方法区，堆栈区，堆区和程序计数器。方法区存储字节码、类信息和常量池等数据；堆栈区用于存放线程的执行状态、方法调用状态和局部变量；堆区用于存储Java对象实例；程序计数器用于记录线程执行的位置，以便在发生线程切换时恢复执行。
执行引擎：该部分负责将字节码转换为机器指令，并执行这些指令。JVM中存在两种执行引擎，即解释器和即时编译器。解释器逐行解释并执行字节码，而即时编译器则将字节码编译为本地机器指令并执行。
本地方法接口：这是一组API，允许Java程序调用由本地代码实现的函数。它为Java语言和本地系统之间提供连接。

JVM的结构非常复杂，但可以看出，它主要分为四个部分：类加载器子系统、运行时数据区域、执行引擎和本地方法接口。对于Java开发人员来说，了解JVM的结构和工作原理是非常重要的，因为这有助于他们编写更高效、更稳定的Java应用程序。

如何破坏双亲委派机制

破坏类加载时的双亲委派机制通常不被推荐，因为这可能会导致安全风险和不稳定性。但是，如果您想了解如何破坏它，以下是一些可能的方法：

自定义ClassLoader：继承自ClassLoader并重写loadClass方法，不再委托给父类的ClassLoader，而是自己加载类。
反射机制：使用反射可以访问私有的ClassLoader中的方法，如setParent方法，可以直接设置父类ClassLoader为null。
OSGi（Open Service Gateway initiative）：OSGi是一种Java模块化的方案，它使用自定义的类加载器从而破坏了双亲委派机制。

需要指出的是，破坏双亲委派机制是有风险的。可能会影响到其他模块或框架的正常运行，不推荐轻易尝试。

StringBuilder和StringBuffer的区别

StringBuilder 和 StringBuffer 都是用于处理字符串的类，在很多方面它们是相似的，但是，它们之间有一些区别。

StringBuilder 和 StringBuffer 是可变的字符序列，可以对字符序列进行增加、删除、修改等操作。而 String 类则是不可变的，如果需要修改字符串，每次都会产生一个新的字符串对象，而这些无用的字符串对象会被垃圾回收器回收，从而浪费一些系统资源。
StringBuilder 和 StringBuffer 的主要区别在于线程安全。StringBuilder 是非线程安全的，而 StringBuffer 是线程安全的。简单来说，如果你的应用程序中只有一个线程对字符串进行操作，那么推荐使用 StringBuilder；而如果有多个线程同时操作字符串，那么就需要用 StringBuffer，以确保线程安全。
StringBuilder 的执行速度略高于 StringBuffer，因为它不需要考虑线程安全。

总的来说，如果你需要在一个单线程的环境下进行字符串操作，那么使用 StringBuilder 是更好的选择；而如果你需要在多线程环境下进行字符串操作，那么使用 StringBuffer 是更安全的选择。

为什么StringBuffer是线程安全的

StringBuffer 是线程安全的，主要是因为它的关键方法都是用 synchronized 关键字修饰的。在多线程环境中，synchronized 确保同一个时间只有一个线程可以访问 StringBuffer 对象的关键方法。

具体来说，StringBuffer 的关键方法，比如 append、insert、delete、indexOf 等，都是带有 synchronized 关键字的。这意味着在执行这些方法时，只有一个线程可以访问这些方法，其他线程需要等待当前线程执行完这些方法后才能访问。这确保了多线程环境中 StringBuffer 对象的安全。

另外，Java 中还有另外一个类 StringBuilder，它与 StringBuffer 类似，但是没有 synchronized 关键字。因此，StringBuilder 不是线程安全的，但在单线程环境中，StringBuilder 的性能优于 StringBuffer。

查自己的信息，select * from table where username=me，如果别人传入参数 where username=me or 1=1该怎么办？

在数据库查询中，传入的参数往往是不可控的。如果直接将传入的参数拼接到 SQL 语句中，则可能会出现 SQL 注入的安全风险。攻击者可以通过一些特殊的输入，绕过原本的 SQL 逻辑，直接执行恶意的 SQL 语句，从而取得非法的数据或者对数据库进行损坏甚至控制。

如果查询语句采用的是预编译的方式，那么传入参数时需要使用“？”，如下所示：

String sql = "select * from table where username=?";
PreparedStatement ps = conn.prepareStatement(sql);
ps.setString(1, "me");// 将实际参数值绑定到参数位置上
ResultSet rs = ps.executeQuery();

使用 PreparedStatement 的方式，可以将变量绑定到 SQL 参数上，然后系统会对参数值进行转义和过滤，以防止其中包含特殊字符或 SQL 关键字。如果在构造 SQL 语句时，不得不使用传入的参数，那么也需要进行严格的输入验证，防止 SQL 注入攻击。可以使用类似如下的方式进行验证：

String sql = "select * from table where username='" + username.replaceAll("'", "''") + "'";

其中，使用replaceAll方法对传入的参数中的单引号进行了转义，这样就可以防止传入的参数被恶意篡改。在进行输入验证时，需要对所有的特殊字符进行注意和处理，这样可以切实保障系统的安全性。总而言之，避免 SQL 注入的最好方式是使用预编译的 SQL 参数，从而避免了对输入的过度敏感。

算法题：打印目录树

打印目录树可以使用递归算法遍历目录下的所有文件和子目录。伪代码如下：

void printDirectory(String path, String prefix) {
    // 获取当前文件夹下的文件和文件夹
    File[] files = new File(path).listFiles();
    if (files == null) {
        // 如果当前路径不存在或者不是一个文件夹，则直接返回
        return;
    }
    // 遍历当前文件夹下的文件和文件夹
    for (int i = 0; i < files.length; i++) {
        File file = files[i];
        if (file.isFile()) {
            // 如果当前是一个文件，则打印文件名
            System.out.println(prefix + "├──" + file.getName());
        } else {
            // 如果当前是一个文件夹，则打印文件夹名并递归调用
            System.out.println(prefix + "├──" + file.getName() + "/");
            // 递归调用
            printDirectory(file.getAbsolutePath(), prefix + "│  ");
        }
    }
}

这个函数接受两个参数，第一个参数是要打印的目录的路径，第二个参数是打印前缀，用于设置每一层的缩进。递归的思路是，对于当前目录下的每个文件或者文件夹，先判断是文件还是文件夹，如果是文件，直接打印文件名，否则打印文件夹名并递归调用自身，继续遍历该文件夹下的所有文件和子目录。调用这个函数时，只需要将要打印的目录路径和一个空字符串作为参数传入即可：

printDirectory("/path/to/directory", "");

nginx为什么可以实现负载均衡？有哪些负载均衡策略？

Nginx 可以实现负载均衡的主要原理是使用反向代理，即将 client 请求转发到后端的多台服务器上。可以将多个 Web 服务器组成一个 Web 集群，Nginx 作为 Web 集群的前端负载均衡设备，用来分担每一台服务器的负载压力。

Nginx 实现负载均衡的具体步骤如下：

Nginx 接收到 client 发送的请求。
Nginx 根据事先设定的负载均衡策略，将请求分发到后端的多台服务器上。
后端服务器处理请求，将响应发送回 Nginx。
Nginx 将响应返回给 client。

常见的负载均衡策略有以下几种：

轮询（Round Robin）策略：按照事先设定的顺序逐个向多台后端服务器分发请求，等分后端服务器的负载。
IP 哈希（IP Hash）策略：将 client 的 IP 地址进行哈希计算，将计算结果对后端服务器的数量取模，将请求发送到对应的服务器上，使同一 IP 的请求都被分配到同一台服务器上。
最小连接数（Least Connections）策略：将请求发送到当前连接数最少的服务器上。适用于服务器处理请求速度不一致的情况。
动态加权轮询（Weighted Round Robin）策略：为每台服务器分配一个权重值，Nginx 按权重轮询分配请求。根据服务器的处理能力、运行状态等配置不同的权重值。
URL 哈希（URL Hash）策略：将请求的 URL 地址进行哈希计算，将计算结果对后端服务器的数量取模，将请求发送到对应的服务器上，以实现相同 URL 请求到达同一台服务器的效果。

总之，Nginx 的负载均衡功能可以通过适合的负载均衡策略，让 client 请求平均地分配到多台后端服务器上，提高系统的性能和可靠性。

说说边界值分析、等价类分析

边界值分析和等价类分析是软件测试中常用的两种黑盒测试方法，可以有效地挖掘出测试缺陷。

边界值分析是指将测试参数的边界以及接近边界的地方作为测试用例，这样可以检查系统是否能够正常地处理边界情况。例如，一个输入参数范围是 0~~100，边界值分析就会选择测试用例 0、1、99、100 等。边界值的选择应该包括参数的最小值、最大值、接近最小值和最大值的值，以及某些特殊值，如 0、1、-1、null、空串等等。边界值分析方法可以有效地检测出因为边界问题而导致的程序故障，尤其是在参数范围较大的情况下。
等价类分析是将输入或输出值的所有可能取值划分成若干个等价类，然后选择每个等价类中至少一个值作为测试用例，可以显著地减少测试用例的数量。例如，一个输入参数的取值范围为 1~~100，等价类分析可以将其分为小于 1、1~100、大于 100 三个等价类，然后选择其中一个或多个值作为测试用例。等价类分析方法可以使得测试用例尽量包含产品的所有情况，从而可以尽量地覆盖所有可能的情况，而且测试数量少，测试效率高。

综上所述，边界值分析和等价类分析方法都是黑盒测试常见的方法，可以有效地发现程序的缺陷及问题。在实际测试中，根据测试的具体情况选择合适的测试方法，可以打造更加全面有效的测试。

设计登录的测试用例

登录是 Web 应用程序的核心功能，必须能够安全、可靠地完成。以下是一些设计登录测试用例的建议：

测试用例名称：正确的用户名和密码。预期结果：能够成功登录系统。
测试用例名称：错误的用户名或密码。预期结果：不能登录系统，显示错误提示信息。
测试用例名称：用户名为空或密码为空。预期结果：不能登录系统，显示错误提示信息。
测试用例名称：密码长度不足或超长。预期结果：不能登录系统，显示错误提示信息。
测试用例名称：输入正确的用户名，错误的密码。预期结果：不能登录系统，显示错误提示信息。
测试用例名称：输入过多的无效字符。预期结果：不能登录系统，显示错误提示信息。
测试用例名称：使用非常规字符作为用户名或密码。预期结果：不能登录系统，显示错误提示信息。
测试用例名称：使用 SQL 注入等攻击性字符串作为用户名或密码。预期结果：不能登录系统，显示错误提示信息。
测试用例名称：多次重复登录尝试。预期结果：连续多次输入错误密码，最后该用户将被锁定。
测试用例名称：用户登录后，通过记住密码选项自动登录。预期结果：能够成功自动登录。

以上是设计登录测试用例的一些建议，测试用例应该覆盖尽可能多的情况，以实现全面的测试目标。需要注意的是，测试用例应该基于需求规格说明和功能规范，确保测试人员对测试用例的理解和规范是一致的。同时，在测试中应当关注测试用例的目标和测试结果，对用例结果产生影响的各种因素进行监测、收集和记录，并将测试结果汇总分析，以指导产品的后续开发和测试。

Integer和int的区别

Java 中的 Integer 和 int 都表示整数类型，但是它们的本质及用法是有一些区别的。

Integer 是一个对象类型，而 int 是一个基本数据类型。 int 是在栈中分配的，而 Integer 是在堆中分配的。因此，使用 Integer 时会涉及到对象的创建和销毁，而 int 则不需要。
Integer 能够存储 null 值，而 int 则不能存储 null 值。在某些情况下，如果一个变量需要保存可能为空的整数，需要使用 Integer 类型。
Integer 是一个类，它继承自 Number 类，而 int 虽然没有对应的类，但也可以自动装箱成 Integer 类型，也可以使用 Integer.valueOf() 方法将 int 转换成 Integer 对象。同时，Integer 对象也可以自动拆箱成 int，也可以使用 Integer.intValue() 方法将 Integer 对象转换成 int。
在进行数值计算时，使用 int 类型的运算速度会比 Integer 类型的运算速度更快。

综上所述，Integer 和 int 有着不同的本质和用法，具体的选择取决于代码设计和需求。如果需要更多的功能和灵活性，则选择 Integer，如果对性能的需求更高，则选择 int。

Integer之间怎么比较相等

在 Java 中，Integer 对象之间比较相等主要有两种方式。

使用 equals() 方法比较：通过调用 equals() 方法，可以比较 Integer 对象之间是否相等。equals() 方法会比较两个对象的内容是否相等，因此如果两个 Integer 对象的值相等，则返回 true。

例如：

Integer a = 100;
Integer b = 100;
System.out.println(a.equals(b)); // true

equals() 是比较两个对象的内容，比较的是它们保存的值而不是它们在内存中的位置。

使用 == 比较：对于数值在 -128 ~ 127 之间的 Integer 对象，Java 使用了一个 Integer Cache，即全局唯一的 Integer 对象池。当创建了一个数值在该范围内的 Integer 对象时，它将直接从 Integer 对象池中获取对象，而不是创建新的对象。因此，两个数值相同的范围在 -128 ~ 127 之间的 Integer 对象比较相等时使用 == 操作符比较会返回 true。例如：

Integer a = 100;
Integer b = 100;
System.out.println(a == b); // true

需要注意的是，对于数值不在 -128 ~ 127 范围内的 Integer 对象，使用 == 操作符比较就不一定会返回 true，而应该使用 equals() 方法进行比较。

综上所述，两个 Integer 对象之间比较相等可以使用 equals() 方法或者 == 操作符，但需要注意使用的条件和区别。

Java多态是什么

Java 多态是面向对象编程中的一个重要概念，它允许使用不同的对象解释一个相同的方法调用。多态性指的是同样的方法或操作符可以被不同的对象实现不同的行为，多态包括编译时多态性和运行时多态性。其中，编译时多态性是指方法重载、操作符重载等编译时决定的多态性，而运行时多态性则是运行时动态绑定实现的多态性。

Java 中实现多态必须使用继承、重写操作，并且使用父类对象来引用子类对象。具体而言，就是在父类和子类之间定义同名的方法，子类实现自己特有的行为，但方法名和参数的列表是相同的，父类中的方法被子类的方法重写（覆盖）。

在程序运行时，Java 运行时系统会自动判断实际调用对象的类型，并根据对象类型动态绑定相应的方法，实现运行时多态性。这样，即使使用同样的方法名和参数列表，程序仍然可以通过不同的对象来实现不同的行为。

因此，Java 多态性可以让我们在父类和子类之间定义相同的方法，便于代码的扩展和复用，程序可以在运行时根据实际对象的类型动态绑定方法，实现不同的行为。

继承和接口的区别

继承和接口都是面向对象编程中的重要概念，用于实现代码复用和扩展。它们之间主要的区别如下：

继承是子类继承父类的属性和方法，使得子类可以使用和扩展父类的功能。继承是一种 is-a 关系，表示子类是父类的一种类型，它适用于那些可以从通用类派生出特殊类的场景。接口则是一种约定，它定义了一组行为规范，由实现类来实现。接口是一种 has-a 关系，表示一个类具有某种能力。
在 Java 中，只能单继承，即一个类只能直接继承一个父类，但可以实现多个接口。这是因为继承是一种强链接，限制了代码复用的灵活性，而接口是一种比较灵活的抽象，可以实现类与类之间的松耦合。
父类的属性和方法对子类是可见的，子类可以使用它们来满足自己的需要，而接口中定义的属性和方法只是接口规范，需要实现类来具体实现和使用。
子类可以扩展或重写父类的方法，因为它们之间存在继承关系。而实现类必须实现接口中定义的所有方法，没有选择权。
继承是一种类的继承关系，它涉及到类的代码封装、继承和多态等概念。而接口是一种行为的规范，它仅涉及到方法的声明和行为的实现。

综上所述，继承和接口在面向对象编程中都有各自的应用场景和特点，需要根据具体需求来选择使用哪种方式来实现代码复用和扩展。

一个类可以继承多个类吗？可以实现多个接口吗

在 Java 中，一个类只能直接继承一个父类，即 Java 不支持直接多继承。但是，一个类可以间接继承多个类，即一个类可以继承一个类，而这个类又继承另外一个类，以此类推。这被称为类的继承链。通过继承链的方式，一个类可以获取多个父类的属性和方法，并通过重写和扩展实现自己的功能。

另一方面，Java 支持实现多个接口，这被称为接口的多重继承。一个类可以实现多个接口，同时继承一个父类。通过实现多个接口，一个类可以实现多种行为规范，并且可以与其他实现相同接口的类实现松耦合的设计。

需要注意的是，虽然 Java 中可以通过继承链和接口的多重继承实现类间的关系和代码复用，但过于复杂的继承关系和多重继承可能会导致系统的复杂度增加，不利于代码的维护和扩展。因此，在设计类时要避免过于复杂的继承关系和多重继承，考虑实现单一职责原则，避免类的功能过于集中，保证程序的可读性和可维护性。

从输入网址到打开网页的过程

从输入网址到打开网页的过程简单来说就是DNS解析、TCP连接、发送HTTP请求、服务器响应、接收HTTP响应、渲染页面这几个步骤。下面是具体的解释：

DNS解析：当我们在浏览器输入一个网址时，浏览器会先尝试从本机的 DNS 缓存中查找是否有该网址的 IP 地址，如果没有则会向 DNS 服务器请求解析域名对应的 IP 地址。
TCP连接：通过解析域名获取了对应的 IP 地址后，浏览器会与服务器建立 TCP 连接，TCP 向服务器发出连接请求，并等待服务器的响应。
发送HTTP请求：TCP连接建立后，浏览器会向服务器发送 HTTP 请求，请求内容包括请求头和请求体，请求头部分是一系列的参数和信息，用于告诉服务器客户端需要的资源。请求体是可选的，通常是一些额外的数据，如表单数据等。
服务器响应：服务器接收到 HTTP 请求后，会根据请求内容向浏览器返回 HTTP 响应，包括响应头和响应体。响应头部分是一些元数据信息，如响应码、响应类型、响应时间等，告诉浏览器服务器返回了什么内容。响应体是服务器返回的具体的数据，如 HTML、CSS、JavaScript、图片等。
接收HTTP响应：浏览器接收到服务器返回的 HTTP 响应后，会进行解析和处理，根据响应类型的不同，浏览器会选择合适的方式处理响应体，如渲染 HTML 页面、执行 JavaScript 代码、显示图片等。同时，浏览器还会对响应进行缓存，以提高后续访问的速度。
渲染页面：浏览器在接收完 HTTP 响应并解析处理后，会将页面渲染出来，并根据响应中返回的 CSS、JavaScript 等内容来加以渲染和处理。

综上所述，从输入网址到打开网页这个过程经历了多个步骤，每个步骤都需要一些时间和资源，其中 DNS 解析、TCP 连接和 HTTP 请求等是网络传输中重要的环节，对于网页性能有重要影响。因此，对于开发者来说，优化网页性能是提高用户体验的重要手段。

TCP为什么不用两次握手

TCP 为了建立可靠的连接，采用了三次握手来确认连接。如果采用两次握手，会存在以下问题：

可能无法正确识别已经失效的连接：两次握手只能保证客户端和服务端的发送和接收能力正常，无法保证对方的接收能力是否正常。假设客户端发送了一个连接请求，但该请求在网络中滞留，并未到达服务端，超时后客户端会重新发送该请求，如果此时服务端已经接受了该请求并连接成功，它将会向客户端发送确认连接请求，此时客户端将无法正确识别它是一个新的连接请求还是之前已失效的连接请求。
可能会产生不必要的连接：在网络中，可能存在已经失效的连接请求，它们被延迟了很长时间才到达服务端，因此会产生新的连接。如果采用两次握手，就会产生不必要的连接。

而采用三次握手则能够解决上述问题，客户端在发送连接请求后，服务端必须发送确认消息，否则客户端会认为连接失败，而服务端在接收到连接请求时，会产生一个新的 socket，并在确认消息中指定新 socket 的信息，这样就能区分已经失效的连接和新的请求。

OS调度算法

操作系统调度算法是用于决定系统内的进程如何分配 CPU 时间、内存等资源以及如何切换进程的策略。下面是常见的操作系统调度算法：

先来先服务算法（FCFS）：按照进程到达的先后顺序，按顺序分配 CPU 时间。对长作业而言，等待时间较长，易产生“饥饿”现象，短作业优先的效果不佳。
短作业优先算法（SJF）：按照作业的执行时间长短来进行调度，短作业优先。这种算法在无预知条件下，能够使平均等待时间最小，但如果发现一个进程的执行时间比较长，等待时间就会变得很长，就会出现“饥饿”现象。
优先级调度算法：为每个作业分配一个优先级，按照优先级高低进行作业调度。优先级可以是静态的，也可以是动态的。静态优先级是固定的，动态优先级根据进程所处的状态以及当前需要的资源情况动态调整。
时间片轮转算法（RR）：所有进程获得一个相同大小的时间片，按照轮转的方式，执行一个时间片后调度到下一个进程。时间片越短，则进程调度的次数越多，平均等待时间较短，但也会削减进程执行速度。
多级反馈队列算法：将进程划分为若干个队列，每个队列的优先级和时间片不同，新到达的进程先进入第一级队列，如果没有执行完毕，则降级到下一级队列中，并重新分配时间片。如果进程在高优先级队列中长时间得不到执行，则会降低优先级，以保证所有进程都能得到执行。

不同的调度算法因其特点、适应性和实现实现代价不同，应根据任务的性质、系统计算机资源的情况及用户的需要选择最合适的算法。

如果检出bug，但后端认为不是bug，你怎么办

在这种情况下，我会采取以下几种措施：

回归测试：如果后端认为这不是一个 bug，那么我可能需要查看本地和测试环境中的数据是否一致，并执行回归测试，以确保发现的问题能够重现，且不是测试环境导致的误报。如果发现确实存在问题，我可能需要与后端进行进一步的沟通和协作，一起确认问题是否需要修复。
沟通：如果后端认为这不是一个 bug，我会与他们进行沟通，并分享我的信息，希望可以找到解决问题的方法。如果我能够提供有效的数据和证据，有可能会使后端改变他们的看法，一起修复 bug。
报告：如果我检查并确定这确实是一个 bug，并且无法解决之前，我会记录这个 bug，并尝试通过适当的方式对团队进行报告。如果该 bug 严重影响了应用程序的功能或性能，那么我可能需要把这个问题报告给更高层的管理人员，以便获得更高的优先级，以解决这个问题。

总之，解决问题的关键是与后端团队进行合作和沟通，并收集尽可能多的证据来支持我们的观点，以确保我们能够共同解决问题，提高软件质量。

JAVA三大特征

Java 三大特征指的是：面向对象、平台无关性和安全性。下面分别介绍：

面向对象：Java 是一门完全面向对象的编程语言，它支持封装、继承和多态等特征，可以很好地组织结构化程序，并易于维护和扩展，具有高度的重用性、灵活性、可读性和可维护性。
平台无关性：Java 程序可以在不同的操作系统和平台上运行，这是因为 Java 编译器将程序编译成字节码格式（即 .class 文件），而不是针对特定的 CPU 架构和操作系统。Java 字节码可以在任何支持 Java 虚拟机（Java Virtual Machine，JVM）的平台上执行，也就是说，只要在不同的平台上安装了 JVM，就可以运行同样的 Java 程序。
安全性：Java 具有很高的安全性，它提供了许多安全特性和技术，例如：安全管理器、类加载器、异常处理机制、访问控制和代码签名等，通过这些措施，Java 可以保证程序在运行时不会对计算机系统造成损害，从而获得了广泛的应用。同时，Java 可以在网络环境中安全地运行，这也是 Java 成功应用于网络应用程序的重要原因之一。

这些特性为 Java 提供了很强的优势和广泛的应用场景，Java 在各种领域得到了广泛应用，例如企业级应用、桌面应用、Web 应用、移动应用和游戏开发等。

了解中断是什么吗

在计算机系统中，中断是一种硬件或软件生成的信号，用于打破 CPU 正在执行的程序的流程，以便处理更高优先级的任务。当中断信号触发时，处理器会暂停当前正在执行的任务，转而执行与中断相关的处理程序或服务例程，这通常被称为中断处理程序，而被中断的程序或进程会被暂时挂起，直到中断处理程序完成并返回到原程序。中断是操作系统处理外部事件的基础，例如输入/输出请求、异常、定时器等。

中断信号可以是内部或外部的。内部中断信号通常由处理器本身生成，例如每个时钟周期产生的时钟中断。外部中断信号则来自外部设备，例如鼠标、键盘、网络接口卡等。所以，中断是一种实现操作系统中与外设交互和实现并行执行的一种重要机制。

线程之间的通信方法有什么

线程间的通信可以使用以下几种方式：

共享内存：在多线程编程中，共享内存是一种用于线程通信的常见方式。线程可以通过读写共享内存中的变量和数据来共享信息。
消息传递：这种通信方式通过发送和接收消息来进行通信。线程可以通过消息传递来共享信息，这种方式适合于多个线程同时工作的情况。
信号量：信号量是一种用于控制访问共享资源的方法，并且可以用于线程之间的同步操作。线程必须获取一个信号量才能访问共享资源，这可以保护共享资源，避免多个线程同时对其进行操作。
互斥量：互斥量是一种用于线程之间同步操作的常见方法，它可以保证在任何时候只有一个线程能够访问共享资源，从而避免资源竞争。
条件变量：条件变量用于线程之间同步操作，当一个线程等待某个条件变为真时，它可以阻塞自己，从而允许其他线程访问共享资源。当条件变量被其他线程设置为真时，等待的线程就会被唤醒。

这些通信方法可以实现线程间的协作和同步，使得多个线程可以在不破坏程序的正确性，同时访问共享资源和并发执行任务。在进行并发编程时，熟悉这些线程通信方法是非常重要的。

tcp建立连接需要三次握手，说一下过程，第三次可以携带数据吗

TCP建立连接需要进行三次握手，其流程如下：

客户端向服务端发送 SYN 包，表示请求建立连接，并且选择一个序列号 x，该包不包含数据部分。
服务端收到 SYN 包后，返回一个 SYN+ACK 包。该包中应当携带服务端选择的序列号 y，以及确认号（ack）为 x+1。这个确认号说明服务端已经成功收到了客户端的请求，并将其放到 accept 队列中等待服务端进程调用 accept() 函数。
客户端再次向服务端发送 ACK 包，该包中确认号（ack）为 y+1，表示客户端收到了服务端返回的 SYN+ACK，并且成功建立连接。此时，TCP 连接已建立，客户端和服务端就可以进行数据传输了。

在三次握手过程中，每个包都必须携带足够的信息（序列号、确认号等）以便另一端可以确认它已经处理了所有包。因此，在建立连接时，第三次握手不能携带任何数据，因为此时客户端和服务端还没有真正建立连接，无法确保对方已经准备好接收数据。只有在建立连接成功后，双方才可以进行数据传输。

在 TCP 连接的关闭过程中，需要进行四次挥手，以确保双方都能正确地关闭连接。在这个过程中，最后一个包（ACK 包）可以包含数据。在这种情况下，可以使用 TCP 的紧急数据指针（URG）进行处理。

四次挥手期间，存在大量closewait状态线程，怎么处理

在 TCP 连接的关闭过程中，当某个端点完成它的发送任务，并发送了一个 FIN 包时，就会进入 CLOSE_WAIT 状态。在该状态下，这个端点所处的进程可能仍然有数据要发送，但此时已经无法向远程端点发送数据了。因此，应用程序需要负责关闭发送任务并关闭连接。

如果存在大量处于 CLOSE_WAIT 状态的线程，可能会导致系统资源耗尽，影响整个应用程序的性能。为了解决这个问题，可以采取以下措施：

对于客户端，应该在关闭连接后及时释放相关资源。例如调用 closesocket() 函数来关闭连接并释放相应的资源。
对于服务端，必须在一定时间内停止运行，关闭所有打开的 socket 连接，释放使用的系统资源。在服务端程序中，可以设置 SO_LINGER 套接字选项来定义 socket 关闭时的行为。
如果大量 CLOSE_WAIT 状态的线程无法被及时释放，可能需要进行一些诊断和调试工作，例如查找是否存在死锁现象，或者检查应用程序代码中是否存在资源泄露的问题。

综上所述，及时释放连接，正确使用 socket 套接字并进行必要的资源管理，可以避免 CLOSE_WAIT 状态线程积压造成的问题。

http有什么版本，区别是什么

HTTP 协议有以下几个版本：

HTTP/0.9：HTTP 协议最初的版本，设计用于通过互联网传递请求和响应。该版本中仅支持 GET 方法，并且响应中只包含 HTML 格式文本，无法支持图片、音频、视频等多媒体信息。
HTTP/1.0：1996 年发布，该版本增加了多种请求方法（POST、HEAD）、状态码（404 Not Found）和多部分 MIME 类型数据（图片、音频、视频等）。它通过在每个请求和响应中添加头部信息来扩展功能。但其缺陷在于每个请求都需要建立和断开一次 TCP 连接，会造成性能瓶颈。
HTTP/1.1：1999 年发布，目前被广泛使用。该版本改进了上一个版本的连接管理，允许复用单个连接发送多个请求/响应（持久连接），并支持管道化，可以在一个连接上并行发送多个请求。此外，HTTP/1.1 还引入了 Chunked Transfer Encoding，允许发送大小不确定的数据和分块编码传输数据。
HTTP/2：2015 年发布，该版本在 HTTP/1.x 的基础上做出了改进，引入了二进制协议、多路复用、服务器推送等新特性，大幅提升了请求响应速度和效率。同时也让服务端有了更多主动权，可以更好地控制流程，并避免雪崩效应。
HTTP/3：2020 年发布，该版本基于 UDP 协议，通过 QUIC 协议实现。提供了更好的传输效率，更快的响应速度和更好的安全性，在保证兼容性的情况下，使 HTTP 获得更好的性能。

以上是 HTTP 协议的几个版本及其主要区别。不同版本的 HTTP 协议不仅对应着不同的功能和特性，也反映了互联网技术的不断进步和发展趋势。

JWT中，下一次携带token访问server时，server如何确定client的身份？

在使用 JWT 进行认证时，client 下一次访问 server 时是通过在请求头中附加 Token（通常以 "Bearer " 开头）的方式来带上 Token 的。而 server 如何确定传递过来的 Token 是合法的，即确定 client 的身份，则需要验证该 Token 是否正确、是否过期等信息，具体步骤如下：

server 验证 JWT 的格式是否正确：例如，它是否包含了必须的三部分 Header、Payload 和 Signature。
server 验证 JWT 的签名是否正确：Signature 部分是由 Header 和 Payload 以及一个秘钥进行签名生成的，server 需要使用同样的秘钥来验证签名的正确性。
server 验证 Token 是否已过期：在 JWT 的 Payload 中，可以包含过期时间（exp）以及发布时间（iat），server 可以使用当前时间与这些时间进行比较，从而确定 Token 是否过期。
server 验证 Token 是否受到篡改：如果 Token 被篡改，其签名也会发生变化，server 可以通过验证 Signature 部分的方式确定 Token 是否受到篡改。

总之，在验证 Token 时，server 需要先解码它，然后验证签名、过期时间等信息。如果验证没有通过，则需要拒绝该 Token 和请求。反之，则可以确定 client 的身份，接受该请求并提供相应的服务。

有了session，为什么还要cookie？

Session 和 Cookie 是 Web 应用程序中常见的两种状态维护方式。Session 是服务端维护的一种状态，而 Cookie 是客户端维护的一种状态。

虽然 Session 能够提供一定程度的状态保存，但 Cookie 仍然具有其不可替代的优势，主要体现在以下几个方面：

储存数据量：相比 Session，Cookie 能够存储更多的数据量，最大可以存储 4KB 的数据。这使得 Cookie 更适合用于处理一些小型的数据存储。
客户端存储：Cookie 能够被客户端直接存储，在服务器端不需要专门的存储空间，这种机制使得 Cookie 更加灵活，更加适合大规模的分布式系统。
跨服务器：通过 Cookie 的机制，用户可以绕过服务端负载均衡，跨越不同的服务器之间进行会话管理。这在大型分布式系统中尤其有用。
处理性能：Session 维护在服务端，每个用户都会在服务器上分配一块内存用于存储用户的状态信息。如果用户量很大，那么服务器的资源压力也会随之增大。而 Cookie 机制可以进行一定程度的状态缓存，减轻了服务器的压力，提高了系统的处理性能。
安全性：Cookie 机制可以使用 HTTPS 协议，确保数据的安全性。

总的来说，虽然 Session 和 Cookie 都可以用来维护 Web 应用程序的用户状态，但是它们各自具备一些独特的优势。因此，在实际应用中，Session 和 Cookie 应根据业务需求的不同而灵活使用，互补使用，以达到最佳的功能和性能。

【Java学习】八股整理（上）

Spring中的BeanFactory和FactoryBean的区别

BeanFactory与ApplicationCobntext的区别

为什么重写equals还要重写hashcode？

==和equals比较的区别

为什么有时会出现4.0 - 3.6 = 0.40000001这种现象？

final关键字的作用

介绍Java的集合类

ArrayList和LinkedList的区别

StringBuilder和StringBuffer的区别

exception和error的区别

讲讲mysql索引失效

讲讲sql优化的思路

讲讲mysql子查询可以被什么代替

讲讲Spring的IOC和AOP

mysql的四大特性

进程切换为什么比线程切换效率低

怎么提高项目进度

SpringBoot优点

B树、B-树和B+树对比

索引失效的场景

数据库慢查询

SQL调优

从硬件层面看CAS的原子性

Java1.7中hashmap的死锁现象

Java1.7和1.8中hashmap的区别

OOM出现的场景

Java运行时数据区结构

JVM的结构

如何破坏双亲委派机制

StringBuilder和StringBuffer的区别

为什么StringBuffer是线程安全的

查自己的信息，select * from table where username=me，如果别人传入参数 where username=me or 1=1该怎么办？

算法题：打印目录树

nginx为什么可以实现负载均衡？有哪些负载均衡策略？

说说边界值分析、等价类分析

设计登录的测试用例

Integer和int的区别

Integer之间怎么比较相等

Java多态是什么

继承和接口的区别

一个类可以继承多个类吗？可以实现多个接口吗

从输入网址到打开网页的过程

TCP为什么不用两次握手

OS调度算法

如果检出bug，但后端认为不是bug，你怎么办

JAVA三大特征

了解中断是什么吗

线程之间的通信方法有什么

tcp建立连接需要三次握手，说一下过程，第三次可以携带数据吗

四次挥手期间，存在大量closewait状态线程，怎么处理

http有什么版本，区别是什么

JWT中，下一次携带token访问server时，server如何确定client的身份？

有了session，为什么还要cookie？