java基础面试题3

Redis 6.0 之后为何引入了多线程？6.0 之前为什么不使用多线程？

在Redis 6.0 之前，Redis 是单线程的，这是因为Redis 的主要瓶颈是在 CPU 上。但是随着硬件的发展，现代服务器的CPU 核心数已经达到了几十个，这就导致Redis 单线程模型无法充分利用多核处理器的性能。因此，Redis 6.0 引入了多线程，以提高 Redis 在多核处理器上的性能

Redis 6.0 之前为什么不使用多线程，主要有以下几个原因：

Redis 单线程模型相对简单，容易维护和调试，代码逻辑也比较清晰
Redis 的主要瓶颈在于CPU，而不是I/O ，因此采用多线程模型并不能显著提高性能
Redis 是一个内存型数据库，它的性能主要受到CPU 和内存带宽的限制。采用多线程模型会增加线程之间的竞争和锁等开销，反而可能降低Redis 的性能

但是随着硬件的发展，多核处理器已经成为了现代服务器的标配，因此Redis 引入多线程的举措可以更好的发挥硬件性能，提高Redis 的吞吐量和响应速度

HTTP 协议中 GET 和 POST 有什么区别？分别适用于什么场景？

HTTP 协议中GET 和 POST 是两种常用的请求方法，它们的区别如下：

参数传递方式不同：GET 请求参数是在URL中以键值对的形式传递的，例如：http://www.example.com/?key1=value1&key2=value2 而POST 请求参数是在请求体中以键值对的形式传递的
参数传递大小不同：GET 请求参数有大小限制，因为URL 长度有限制，不同的浏览器和服务对象对URL 长度的限制不同，一般为 2048 个字符。而POST 请求参数没有大小限制，因为它们是以请求体的形式传递的
安全性不同：GET 请求是明文传输的，因为参数在URL中，如果涉及敏感信息（如密码），容易被窃取或暴露在浏览器历史记录、代理服务器日志等地方。而POST 请求的参数在请求体中传输，相对安全一些，但是也需要注意参数加密和防止CSRF攻击等问题。

GET 和 POST 适用场景不同等问题：

GET 请求适用于获取数据，如浏览网页，搜索等。因为GET 请求参数以明文形式传输，容易被拦截和篡改，所以不适用于提交铭感信息
POST 请求适用于提交数据，如登录，注册，发布内容等。因为POST 请求参数在请求体中传输，相对安全一些，可以提交敏感信息，但是需要注意参数加密和防止CSRF 攻击等问题。

什么是零拷贝？说一说你对零拷贝的理解？

零拷贝（Zero-Copy）是一种高效的数据传输技术，它可以将数据从内核空间直接传出到应用程序的内存空间中，避免不了必要的数据拷贝，从而提高了数据传输的效率和性能。

在传统的数据传输方式中，当应用程序需要从磁盘，网络等外部设备中读取数据时，操作系统需要先将数据从外部设备拷贝到内核空间的缓冲区，然后再将数据从内核空间拷贝到应用程序的内存空间中，这个过程中需要进行两次数据拷贝，浪费了大量的CPU 时间和内存带宽。

而使用零拷贝技术，数据可以直接从外部设备复制到应用程序的内存空间中，避免了中间的内核空间缓冲区，减少了不必要的数据拷贝，提高了数据传输的效率和性能

在网络编程中，零拷贝技术可以用于大文件传输，网络文件系统的读写，数据库查询等场所中，提高数据传输的效率和响应速度。同时，零拷贝技术也可以减少系统内存的开销，提高系统的稳定性和可靠性

什么是 RPC？目前有哪些常见的 RPC 框架？实现 RPC 框架的核心原理是什么？

RPC（Remote Procedure Call）是一种远程协议，允许一台计算机通过网络调用另一台计算机上的服务或方法。它可以让开发人员想本地方法一样调用远程方法，将网络通信细节封装起来，提高了分布式系统中各模块之间的耦合性。

目前常见的RPC框架有：

Dubbo：阿里巴巴开源的分布式RPC框架，支持多种协议和负载均衡策略
gRPC：Google 开源的高性能RPC框架，支持多种语言
Thrift：Facebook 开源的跨语言 RPC 框架，支持多传输协议和数据编码解码方式
Spring Cloud Netfilx：Spring Cloud 的子项目之一，提供了基于Netfilex OSS 开源组件的微服务解决方案，包括服务发现，负载均衡，熔断器等功能。

RPC 框架的核心原理是基于网络传输协议实现的远程方法调用。RPC 框架通常由服务提供者和服务消费者两部分组成，服务提供者将本地方法暴露成远程服务，服务消费者通过远程代理对象调用远程方法

在实现远程方法调用时，需要进行序列化和反序列化。序列化将对象转换为二进制数据流，以便于在网络中传输；反序列化则将收到的二进制数据流转换为对象

为了提高性能，一些RPC 框架使用了二进制协议，如Dubbo 使用的 Hessian 2 协议和gRPC使用的 Protocol Buffers协议，与基于文本的协议（如XML 和 JSON）相比，二进制协议具有更小的传输体积和更高的解析速度，能够减少网络传输的开销。

设计模式可以分为哪几类？一共有多少种主流的设计模式？

设计模式可以分为三类：

创建型模式：这类模式关注对象创建的机制，包括单例模式，工厂模式，抽象工厂模式，建造者模式和原型模式等
结构型模式：这类模式关注对象之间的组合关系，包括适配器模式，装饰器模式，代理模式，组合模式，桥接模式，外观模式和享元模式
行为型模式：这类模式关注对象之间的通信方式和协作方式，包括模板方法模式，策略模式，命令模式，职责链模式，状态模式，观察者模式，中介者模式和访问者模式
目前主流的设计模式有23种：

单例模式，工厂方法模式，抽象工厂模式，建造者模式，原型模式，适配器模式，装饰模式，代理模式，外观模式，桥接模式，组合模式，享元模式，策略模式，模板方法模式，观察者模式，迭代器模式，职责链模式，命令模式，备忘录模式，状态模式，访问者模式，中介模式，解释器模式

如何在 10 亿个数据中找到最大的 1 万个？（提示：最小堆）

在 10亿个数据中找到最大的 1万个，可以使用最小堆（Min-Heap）算法实现。

最小堆是一种特殊的二叉树结构，每个节点的值都小于或等于其左右子节点的值。在使用最小堆来查找最大的1万个数据时，可以先创建一个大小为1万的最小堆，然后将10亿个数据逐个加入堆中。当堆的大小超过了1万时，将堆顶的元素（最小值弹出，再将当前元素加入堆中。当遍历完所有数据后，堆中剩余的1万个元素就是最大的1万个值）

这种方法的时间复杂度为 O(n log k)，其中 n 是数据总数，k 是要查找的元素数量。因为要维护一个大小为 1万的最小堆，所以空间的复杂度也为O( k ).

#java不一定好实现这种数据处理，可以试试python#

讲一讲 Spring 框架中 Bean 的生命周期？

在Spring 框架中，Bean 的生命周期包括以下几个阶段：

实例化（Instantitaion）：在这个阶段，Spring 将根据配置文件或注解等方式创建Bean 实例，并将其存储在容器中
属性赋值（Populate Properties）：在这个阶段，Spring 将会自动将Bean 的属性值从配置文件或注解等方式注入到Bean 实例中
初始化（Initialization）：在这个阶段，Spring 会调用Bean 实例的init-method 方法，完成一些初始化的操作，例如建立数据库连接等。
使用（In Use）：在这个阶段，Bean 实例已经可以正常使用，供应用程序调用
销毁（Destruction）：在这个阶段，Spring 会调用 Bean 实例的 destory-method 方法，完成一些资源的释放和清理操作，例如关闭数据库连接等

具体的实现方法可以通过实现 BeanPostProocessor 和 BeanFactoryProcessor 接口来进行扩展。其中，BeanPostProcessor 接口定义了两个方法

postProcessBeforeInitialization 和 postProcessAfterInitialization，分别在Bean 的初始化前后被调用，用于扩展Bean 初始化过程；BeanFactoryPostProcessor 接口则定义了一个方法 postProcessBeanFactory，用于在Bean 工程实例化 Bean 定义后对其进行修改。

总之，Spring 的 Bean 的生命周期通过上述阶段进行管理，开发者可以通过实现相关接口和方法来扩展和定制Bean 的创建和销毁过程，以满足各种业务需求。

Redis 有哪些数据类型？基础数据结构有几种？你还知道哪些 Redis 的高级数据结构？

Redis 支持多种数据类型，不同的数据类型可以满足不同的需求。下面是Redis 中常用的数据类型：

String（字符串）：Redis 中最基本的数据类型，可以存储任何形式的数据，例如整数，浮点数，二进制数据等
Hash（哈希）：Redis 中的一种键值对类型，可以存储多个键值对，每个键值对又是一个加键值结构
List（列表）：Redis 中的一个有序列表类型，可以存储多个元素，每个元素都有一个索引，支持多种列表操作，例如插入，删除，查找等。
Set（集合）：Redis 中的一种无序集合类型，可以存储多个元素，每个元素都是唯一的，支持多种集合操作：如交集，并集，差集等
Sorted Set（有序集合）：Redis 中的一种有序集合类型，可以存储多个元素，每个元素都有一个分值，支持根据分值进行排序和查询等操作。

Redis 的基础数据结构有三种：字符串，列表和哈希，其他的数据类型都是基于这三种数据结构进行的扩展和衍生的。例如，Redis 的 Set 数据类型就是基于字符串实现的，除了基础数据结构之外，Redis 还提供了多种高级数据结构，例如：

HyperLogLog：一种基数估计算法，用于估计一个数据集合的基数
GeoHash：一种地理位置编码算法，可以对地理位置信息进行编码和查询
Pub/Sub：一种消息队列机制，可以实现消息的订阅和发布
Bitmaps：一种位图数据结构，可以进行高效的位运算，用于统计用户在线时长，网站访问量等
Lua脚本：Redis 中可以使用Lua 脚本进行扩展和定制，可以实现一些复杂的业务逻辑和算法。

有哪些主流的消息队列，它们分别有什么优缺点、各自的适用场景是什么？

RabbitMQ 优点：可靠性高，性能优秀，支持多种协议，有完善的管理界面。缺点：部署和维护较为复杂。使用场景：使用高可靠性，高吞吐量，多协议，多语言的分布式系统场景。
Kafla 优点：性能优秀，可扩展性好，可靠性高，支持多种数据处理模式。缺点：管理界面不够完善，复杂度较高。适用场景：适用于高吞吐量，高并发，数据处理流程复杂的场景，例如大数据处理，实时日志处理等。
ActiveMQ 优点：功能齐全，易于使用，支持多种协议。缺点：性能相对较低，可靠性不如RabbitMQ。适用场景：需要适用多种协议，支持多种消息类型的场景，例如Web服务，企业应用集成等
RocketMQ 优点：性能优秀，可靠性高，支持海量数据存储和传输。缺点：社区相对较小，功能不够完善。适用场景：适用于海量数据存储和数据传输，例如电商，金融等领域
Redis 优点：速度极快，支持多种数据结构，支持事务操作，支持发布/订阅模式。缺点：可靠性不如RabbtMQ 和 Kafka。适用场景：适用于对性能要求极高，需要使用多种数据结构和事务操作的场景，例如缓存，计数器，实时消息等。

总的来说，选择适合自己的消息队列需要根据具体业务和场景进行综合评估和选择。

Spring 支持哪几种事务管理类型，Spring 的事务实现方式和实现原理是？

Spring 支持的事务管理类型包括：

编程式事务管理：在代码中显式地编写事务管理相关代码，如开启事务，提交事务，回滚事务等。
声明式事务管理：适用AOP技术，在代码中通过配置进行声明，从而实现对事务管理的控制
注解式事务管理：基于声明式事务管理，适用注解的方式进行事务的管理

Spring 的事务管理实现方式采用了模板方式，通过模板模式实现了业务的封装。Spring 事务管理实现原理主要是通过AOP 和代理模式来实现的。在适用声明式事务管理时，Spring 通过拦截器和代理对象来实现对方法调用的拦截和控制。当方法被调用时，Spring 会在方法调用前开启一个新事务，如果方法执行成功，Spring 会提交事务，否则回滚事务。在使用注解式事务管理时，Spring 会扫描带有事务注解的方法，并在运行时使用动态代理为这些方法生成代理对象，在代理对象的方法调用前后进行事务管理的操作。

Redis 为什么快？

Redis 之所以快，主要有以下几个方面的原因：

内存存储：Redis 的数据都是存储在内存中的，相比于硬盘存储的数据库，内存存储速度更快
单线程模型：Redis 使用单线程模型处理所有的请求，避免了多线程之间的线程切换和竞争等开销，提高了处理请求的效率
非阻塞I/O：Redis 使用非阻塞I/O 处理网络通信，当一个客户端请求到来时，Redis 不会一致等待客户端的响应，而是会先处理其他请求，这样就避免了I/O阻塞带来的性能问题
精简高效的数据结构：Redis 内置了多种高效的数据结构，如哈希表，跳表等，这些数据结构的实现非常精简高效，减少了Redis 对内存和CPU 的占用，从而提高了Redis 的性能
持久化策略：Redis 支持多种持久化策略，如RDB（快照）和AOF（追加式文件）等，这些策略可以将内存中的数据保存到硬盘中，以保证数据的持久性和安全性，同时，Redis 可以将数据以压缩的方式存储在硬盘中，减少了硬盘的占用，提高了数据的读写速度。

综上所述，Redis之所以快，主要得益于其内存存储，单线程模型，非阻塞I/O，高性能的数据结构和灵活的持久化策略等方面的设计与实现

简述 TCP 三次握手、四次挥手的流程？为什么需要三次握手？为什么需要四次挥手？

TCP 三次握手和四次挥手是TCP 协议中建立和终止连接的过程

三次握手流程如下：

客户端向服务器发送SYN包，表示请求建立连接，此时客户端进入SYN_SENT状态
服务器接收到SYN包后，回应一个SYN-ACK包，表示同意建立连接，此时服务器进入SYN-RECEIVED 状态
客户端接收到SYN-ACK 包后，向服务器回应一个ACK 包，表示确认建立连接，此时客户端进入ESTABLISHED 状态。服务器收到ACK 包后也进入 ESTABLISHED 状态。

四次挥手的流程如下：

客户端向服务器发送FIN 包，表示希望关闭连接，此时客户端进入 FIN-WAIT-1 状态
服务器收到FIN 包后，向客户端回应一个ACK 包，表示已经收到了关闭请求，此时服务器进入 CLOSE-WAIT状态，客户端收到ACK 包后进入FIN-WAIT-2 状态
服务器关闭连接后，向客户端发送一个FIN 包，表示可以关闭连接，此时服务器进入LAST-ACK 状态
客户端收到服务器的FIN 包后，向服务器回应一个ACK 包，表示已经收到关闭请求，此时客户端进入 TIME-WAIT状态，等待2MSL（最大报文生存时间）后，关闭连接。服务器收到ACK 包后也进入CLOSED 状态

三次握手是为了确保客户端和服务器都能够收到对方的请求和回应，防止因为网络原因导致请求或回应丢失而建立不了连接。四次挥手则是为了确保连接的正常关闭，防止应为网络原因导致连接无法关闭或出现连接断开后还能够收到数据的情况

什么是 Spring 的依赖注入，依赖注入的基本原则以及好处？

依赖注入（Dependency Injection，简称DI）是Spring框架中的一种设计模式，用于实现控制反转（Inversion of Control，简称IoC）。它是一种将对象之间的依赖关系从硬编码中解耦的方法。通过依赖注入，Spring框架可以在运行时自动为类的属性，构造函数或方法参数提供所需的依赖对象，从而实现对象之间的松耦合

依赖注入的基本原则：

高层模块不应该依赖底层模块。它们都应该依赖抽象
抽象不应该依赖具体实现，具体实现应该依赖抽象

依赖注入的好处：

解耦：依赖注入降低了组件之间的耦合度，使得组件可以独立的进行开发，测试和维护。通过将组件的创建和管理交给IoC容器，组件之间的依赖关系变得更加清晰，有助于提高代码的可维护性
提高代码的可测试性：依赖注入使得对组件进行单元测试变得更加容易。通过使用依赖注入，我们可以轻松的为组件提供模拟（Mock）的依赖对象，从而实现组件在隔离环境中的测试
更好的代码重用：由于组件之间的依赖关系变得更加清晰，这有助于提高代码的可重用性。组件可以在不同的上下文重用，而无需对其进行修改。
更简洁的代码：依赖注入使得代码更加简洁，因为组件不需要直接处理依赖对象的创建和管理。这使得开发人员可以更加专注于组件的核心功能，从而提高开发效率
更容易进行配置管理：依赖注入允许我们将组件的配置与实现代码分离，从而使得配置管理变得更加容易。通过使用外部组件或注解，我们可以在不修改代码的情况下，调整组件之间的依赖关系。

什么是注册中心？如何实现一个注册中心？

注册中心（Service Registry）是微服务架构中的一个关键组件，负责管理服务实例的信息，包括服务实例的地址，端口，元数据等。它允许服务实例在启动时注册自己，并在关闭时注销。服务消费者可以通过查询注册中心来发现可用的服务提供者，并根据负载均衡策略选择合适的服务实例进行调用

实现一个注册中心需要以下几个关键功能：

服务注册：允许服务实例在启动时将自己的信息注册到注册中心，包括地址，端口，元数据等
服务注销：允许服务实例在关闭时从注册中心注销自己
服务发现：允许服务消费者查询可用的服务实例列表，以便找到合适的服务实例进行调用
健康检查：注册中心需要定期检查已经注册的服务实例的健康状态，以确保服务实例列表的准确性。如果发现某个服务实例不再可用，注册中心应将其从列表中移除。

实现一个简单的注册中心可用参考以下步骤：

选择一个合适的数据结构（例如哈希表）存储服务实例的信息
实现一个HTTP API，允许服务实例在启动时向注册中心发送注册请求，将自己的信息添加到数据结构中
实现一个HTTP API，允许服务实例在关闭时向注册中心发送注销请求，将自己的信息从数据结构中移除
实现一个HTTP API，与匈奴服务消费者查询可用的服务实例列表
实现一个定时人物，定期检查已注册的服务实例的健康状况，如果发现某个服务实例不再可用，将其从数据结构中移除

然而，实现一个可靠，高性能，可扩展的注册中心是一个复杂的任务。在实际应用中，通常推荐使用现有的成熟的注册中心组件，例如Eureka，Consul，Zookeeper等。这些注册中心提供了丰富的功能，包括高可用性，数据持久化，动态配置等。

什么是工厂模式？使用工厂模式有什么好处？工厂模式有哪些分类？各自的应用场景是什么？

工厂模式（Factory Pattern）是一种创建型设计模式，它提供了一种封装对象创建过程的方法。工厂模式将对象的创建和使用分离，让一个专门的工厂类负责创建对象实例，而不是在代码中直接使用new操作符。这有助于降低代码的耦合度，提高可维护性和可扩展性

使用工厂模式的好处：

降低耦合度：工厂模式将对象的创建与使用分离，使得客户端代码不直接依赖具体的类，降低了耦合度
提高可扩展性：当需要添加或修改产品类时，只需要修改工厂类，而不需要修改客户端代码，提高了系统的可扩展性
提高可维护性：通过集中管理对象的创建，提高了代码的可维护性
提高代码的复用性：工厂类可用被多个客户端代码复用，减少了重复代码

工厂模式可用分为以下几类：

简单工厂模式（Simple Factory Patten）：一个工厂类根据传入参数决定创建哪个具体产品类的实例。简单工厂模式适用于产品种类较少且不易变化的场景。应用场景：例如：一个简单的图形绘制工具，可用根据传入的参数创建不同类型的图形（如圆形，矩形等）
工厂方法模型（Factory Method Patten）：定义一个接口或抽象类来创建对象，将实际创建对象的工作推迟到子类中。工厂方法模式适用于产品种类较多且可能增加的场景。应用场景：例如：一个日志记录器，一颗根据不同的需求哦i（例如文件日志，数据库日志）使用不同的工厂子类创建相应的日志记录器实例
抽象工厂模式（Abstract Factory Patten）：提供一个接口，用于创建一系列相关或相互依赖的对象，而无需指定它们具体的类。抽象工厂模式适用于产品族的场景。应用场景：例如：跨平台UI框架，可以为不同平台（如Windows，maxOS等）提供不同的UI控件实现，通过抽象工厂来创建对应平台的一系列UI控件

各种工厂模式的应用场景取决于实际需求，需要更具具体问题来选择合适的工厂模式

什么是 AOP？Spring AOP 和 AspectJ AOP 有什么区别？有哪些实现 AOP 的方式？

AOP（Aspect-Oriented Programming，面向切面编程）是一种编程范式，它旨在解决软件开发中的横切关注点（cross-cutting concerns）问题横切关注点是那些分布于多个模块或对象的功能，例如日志记录，安全检查，事务管理等。AOP通过将横切关注点与业务逻辑分离，从而提高了代码的模块化程度，使得开发更加简洁，易于维护

Spring AOP 和 AspectJ AOP 是两种不同的AOP 实现

Spring AOP：是Spring 框架中的AOP 实现，基于动态代理实现。Spring AOP主要用于解决Spring 容器中Bean的横切面关注点问题。由于它使用了动态代理，所以只支持方法级别的切面（即横切关注点只能织入方法的执行）。Spring AOP 的性能略逊于AspectJ，但对于大部分应用来说，性能影响不大
AspectJ AOP：是一个独立的，功能更强大的AOP实现，不仅支持方法级别的切面，还支持字段，构造器等其他切面。AspectJ 可以通过编译时织入（编译时修改字节码）或加载时织入（在类加载时修改字节码）的方式实现AOP。Spring 可以与AspectJ 结合使用，以提供更强大的AOP 功能。

实现AOP 的方式主要有以下几种：

动态代理：通过代理模式，为对象目标生成一个代理对象，然后在代理对象中实现横切关注点的织入。动态代理可以分为JDK 动态代理（基于接口）和 CGLIB 动态代理（基于类）
编译时织入：在编译阶段，通过修改字节码实现AOP，AspectJ 的编译时织入就是这种方式
类加载时织入：在类加载阶段，通过修改字节码实现AOP。AspectJ 的类加载时织入就是这种方式

AOP 的实现方式取决于具体需求和技术选型。对于Spring 应用来说，通常可以使用Spring AOP 满足大部分需求，如果需要更强大的AOP 功能，可以考虑使用AspectJ

什么是分布式的 BASE 理论，它与 CAP 理论有什么联系？

BASE 理论是分布式系统中用于描述数据一致性的一个概念。它是一个缩写，分别代表：

基本可用（Basic Availability）：分布式系统在出现故障时，依然能够保证系统的可用性，但可能会出现部分功能或性能降低的情况
软状态（Soft State）：由于分布式系统中各个节点的状态可能会有一定的延迟，系统允许在一定时间内存在数据不一致的情况
最终一致性（Eventual Consistency）：在一段时间内，分布式系统中的数据可能不一致，但最终会到达一致的状态。这个过程可能需要一定的时间

CAP 理论是另一个关于分布式系统的理论，它指出在分布式系统中，不能同时满足以下三个属性：

一致性（Consistency）：在分布式系统中的所有节点，在同一时刻具有相同的数据
请求性（Availability）：分布式系统在任何时候都能对外提供服务，响应用户请求
区分容错性（Partition Tolerance）：分布式系统在遇到网络区分（部分节点之间通信中断）的情况下仍然能够正常运行

BASE 理论和CAP 理论之间的关系是：BASE理论实际上是对 CAP 理论的一种实践和解释。在CAP 理论中，由于无法同时满足三个属性，因此在实际的分布式系统设中，通常需要在一致性和可用性之间做出权衡。BASE理论就是这种权衡的一种体现，它强调基本的可用性，软状态和最终一致性，而不是追求强一致性。在很多场景中，采用BASE 理论能够带来更高的系统可用性和更好的性能表现

如何使用 Redis 实现分布式锁？

使用Redis实现分布式锁的基本思路是使用Redis 的原子操作来确保在多个客户端之间只有一个客户端可用成功获取锁。以下是使用Redis 实现分布式锁的步骤：

获取锁：客户端尝试获取锁，可用使用Redis 的SET 命令结合 NX 和 EX 选项来实现。SET 命令用于设置一个键值对， NX 选项表示只有在键不存在时才设置，EX 选项表示一个过期时间（单位为秒）。

示例： SET lock_key unique_value NX EX 30。这个命令表示如果lock_key 不存在，就设置它的值为unique_value，并设置30秒的过期时间。如果设置成功，表示获取锁成功；如果设置失败，表示锁已经被其他客户端持有，需要等待或重试
持有锁：在持有锁的客户端执行临界区代码。在此期间，其他客户端无法获取锁。
释放锁：在临界区代码执行完毕后，需要释放锁以供其他客户端使用。为例避免误解锁的情况（例如，由于执行时间过长导致锁过期，然后被其他客户端获取），在释放锁时需要检查锁的值是否与获取锁时设置的值相同。这可以通过Redis的EVAL 命令来实现，使用Lua 脚本进行原子性操作。

示例：EVAL “if redis.call(‘get’, key[1])== ARGV[1] then return redis.call(‘del’, key[1]) else return 0 and 1 lock_key unique_value “ 这个命令表示检查lock_key 的值是否为unique_value ，如果是，则删除lock_key 以释放锁；否则不执行任何操作

通过以上步骤，可以实现一个基本的Redis 分布式锁。在实际应用中，还需要考虑一些其他因素，例如获取锁的重试策略，锁的续期等

如何用 Redis 中的 HyperLogLog 统计页面 UV?

在Redis 中， HyperLogLog 是一种基数估算算法，可以用于快速计算一个集合中的不同元素数量的近似值。

在使用 HyperLogLog 统计页面 UV 时，我们可以将每个访问者的 IP 地址作为一个元素加到HyperLogLog中，然后通过计算HyperLogLog 中的元素数量的近似值来估计页面的唯一访问者数量

以下是一个示例代码，展示如何使用 Redis 的 HyperLogLog 实现页面 UV 统计：

import redis

// 连接 Redis 服务器
    r = redis.Redis(host='localhost', port=6379)
// 记录访问者IP地址
    ip_address = '192.168.0.1'
// 将IP地址加入到HyperLogLog中
    r.pfadd('page_views', ip_address)
// 获取HyperLogLog 中元素数量的近似值
    uv = r.pfcount('page_views')
// 输出页面 UV    
    print('页面UV: ', uv)

在上面的示例代码中，我们使用Redis 的 pfadd() 方法将每个访问者的IP 地址加入到名为page_views 的HyperLogLog中。然后，我们使用pfcount() 方法获取page_views 中元素数量的近似值，并将其作为页面UV 的估计值输出到控制台
需要注意的是，由于HyperLogLog 是一种基数估算算法，其结果是一个近似值，并不是精确值。因此，在实际使用中，需要根据具体情况调整参数和精确等级，以获得更准确的结果

有哪些常见的消息队列模型？分别适用于什么场景？

消息队列是一种在分布式系统中用于异步通信的模型，它允许不同的组件通过将消息发送到队列来实现解耦和灵活性。以下是常见的消息队列模型以及其适用场景：

点对点模型（Point-to-Point Model）：这种模型中，消息生产者将消息发送到一个队列中，消息消费者从该队列中接收消息，一个消息只会被一个消费者接收，消费者处理完消息之后会将其从队列中删除它。这种模型适用于需要保证消息只会被一个消费者处理的场景，例如订单系统，日志处理
发布-订阅模型（Publish-Subscribe Model）：这种模型中，消息生产者将消息发送到一个主题（Topic）中，多个消息消费者可以订阅这个主题并接收到所有的消息。每个消息可以被多个消费者接收，消费者在处理完消息之后不会从主题中删除它，这种模型适用于需要将消息广播给多个消费者的场景，例如新闻订阅，实时数据分析等
请求-应答模型（Request-Response Model）：这种模型中，消息生产者发送一个请求到一个队列中，消息消费者从该队列中接收请求并返回一个响应消息。一个请求只会被一个消费者接收并处理，处理完成后返回响应消息给消息生产者。这种模型适用于需要请求-响应模式的场景，例如远程过程调用，微服务通信等。
推拉模型（Push-Pull Model）：这种模型中，消息生产者将消息推送到一个队列中，消息消费者从该队列中拉取消息。消息生产者将消息发送到队列中，消费者按需从队列中拉去消息进行处理。这种模型适用于需要灵活控制消息消费速度的场景，例如数据采集，视频流传输等

需要注意的是：以上模型并不是完全独立的，实际使用中可以更具具体场景组合适用不同的模型。例如，可以将点对点模型和请求-应答模型结合适用，实现异步的RPC调用。另外，在选择消息队列模型的时候，还需要考虑消息传输的可靠性，顺序性，延迟等因素

有几台机器存储着几亿的淘宝搜索日志，假设你只有一台 2g 的电脑，如何选出搜索热度最高的十个关键词？

针对 top k l类文本问题，通常比较好的方案是【分治 + trie树/hash + 小顶堆】，即先对数据集按照hash 方法分解成多个小数据集，然后适用 trie 树或者 hash 统计每个小数据集中 query 词频，之后用小顶堆求出每个数据集中出现频率最高的前k个数，最后在所有Top K中求出最终的 top K。

拆分成 n 多个文件：以首字母区分，不同的字母放在不同文件，长度仍过长的继续按照首字母进行拆分。这样一来，每个文件的每个数据长度相同且首字母尾字母也相同，就能保证数据被独立的分为了n个文件，且各个文件中不存在的关键字的交集

分词频统计：对于每个文件，适用hash 或者 Trie 树进行词频统计

小顶堆排序：依次处理每个文件，并逐渐更新最大的十个词

什么是双亲委派模式？有什么作用？

双亲委派模式（Parent-Delegate Model）是Java类加载器（ClassLoader）在加载类时所采用的一种设计模式。这种模式的核心思想是：当一个类加载器收到类加载请求时，首先不会尝试自己加载这个类，而是将请求委派给其父类加载器。依次递归，直到最顶层的启动类加载器（Bootstrap ClassLoader）；如果父类加载器无法加载该类，子类加载器才会尝试自己去加载。

双亲委派模式的作用主要有以下几点：

避免类的重复加载：通过委派给父类加载器加载类。可以确保同一个类不会被多个类加载器重复加载。者有助于节省内存资源，并确保类之间的互操作性
保护Java核心类库：由于双亲委派模式的存在，用户自定义的类加载器无法直接加载Java核心类库（如Java.lang.Object等）。这有助于确保Java核心类库的安全性，防止恶意代码篡改或破坏Java核心类
维护类加载器的层次结构：双亲委派模式使得各级类加载器可以按照一定层次结构来组织和管理。这有助于降低类加载器的复杂性，简化类加载过程。

双亲委派模式在java类加载器中的应用是一种优秀的设计原则，它有助于确保类加载过程的稳定性，安全性和可维护性

然而，在某些特殊场景下（如OSGi，Java热加载等），双亲委派模式可能无法满足需求，需要采用其他类加载策略。在这些场景下，开发者需要充分了解类的加载机制，以避免产生意外的问题

什么是正向代理和反向代理，如何使用 Nginx 做反向代理？

正向代理和反向代理都是代理服务器的两种应用场景，它们在网络请求的处理过程中扮演不同角色

正向代理（Forward Proxy）：正向代理位于客户端和目标服务器之间，客户端通过正向代理来访问目标服务器。正向代理代表客户端发起的请求，隐藏客户端的真实身份。常见的应用场景包括科学上网，访问内网资源，缓存和过滤等

反向代理（Reverse Proxy）：反向代理位于客户端和目标服务器之间，客户端直接访问反向代理服务器，反向代理将请求转发给目标服务器。反向代理代表目标服务器接收请求，隐藏目标服务器的真实身份。常见的应用场景包括：负载均衡，安全防护，缓存和SSL终端等

使用Nginx作为反向代理的方法如下：

安装Nginx：根据操作系统的需求选择合适的Nginx版本进行安装。安装完成后，启动Nginx

配置反向代理：编辑Nginx 的配置文件（通常位于/etc/nginx/nginx.conf 或 /etc/nginx/sites-available/default），在http 或 server块中添加反向代理配置。

示例配置：

http {
    ...
    server {
        listen 80;	# 监听的端口号
        server_name example.com;	# 反向代理的域名
            
        location / {
            proxy_pass http://backend_server;	# 将请求转发给目标服务器
            proxy_set_header Host $host;	# 设置请求头部信息
            proxy_set_header X-Real-IP $remote_addr
            proxy_set_header X-Forwarded-For $proxt_add_x_forward_for;
        }
    }
}

在这个示例中，将客户端的请求转发给名为backend_server的目标服务器。同时设置了一些请求头部信息，以便目标服务器获取客户端的真实IP地址

重启Nginx：保存配置文件并重启Nginx，使配置生效。通常可以使用nginx -s reload 或 systemctl restart nginx命令重启Nginx。

完成以上步骤后，Nginx就被配置为反向代理服务器，可以将客户端的请求转发给目标服务器

什么是 Git 的 fork 命令？它和 clone 命令有什么区别

实际上，Git本身并没有一个名为fork 命令。Fork 是一种在代码托管平台（如github，gitlab等）上进行协作开发的概念

Fork 操作的本质是复制一个仓库到自己账户下，这样你就能在自己的仓库中进行修改，而不影响原始仓库。当你对自己仓库中的代码进行了修改，并希望将这些修改合并到原始仓库时，可以发起一个Pull Requset。仓库的所有者可以审核你的修改，并选择是否将其合并到原始的仓库中。

git clone命令是一个Git 命令，用于将远程仓库克隆到本地计算机上。当你克隆一个仓库时，Git 会将远程仓库的所有提交历史，分支和标签下载到本地。这样你就可以在本地进行开发，修改和提交操作

Fork 和 Clone 的区别如下：

操作层面：Fork是在代码托管平台上进行的操作，它会在你的账户下创建一个新的仓库，与原始仓库相互独立。而Clone是在本地计算机上进行的操作，用于将远程仓库的内容复制到本地
目的：Fork 主要用于协作开发，它让你可以在自己的仓库中进行修改，然后通过Pull Request 将修改提交给原始仓库。而Clone 用于将远程仓库的内容下载到本地，以便你可以在本地进行开发和在修改
权限：Fork操作不需要原始仓库的写权限，只需要读权限。而clone操作通常需要在本地提交修改后，将修改推送到远程仓库。这可能需要原始仓库的写权限（除非你在自己Fork的仓库中进行开发）

总之，Fork和Clone 是两个不同层面的操作，它们在协作开发和版本管理中扮演不同的角色。在实际应用中，你可能需要同时使用Fork和Clone来协同开发。例如，在Github上，你可以先Fork一个仓库到自己的账户下，然后使用git clone命令将Fork的仓库克隆到本地进行开发

常见的垃圾回收算法有几种类型？他们对应的优缺点是什么？

常见的垃圾回收算法有以下几种类型：

标记-清楚算法（Mark-Sweep）：分为标记和清除两个阶段。标记阶段遍历所有活动对象并打上标记，清楚阶段将未被标记的对象删除。优点是不需要连续内存空间，缺点是清楚后可能会产生内存碎片。
复制算法（Copying）：将可用内存分为两块，只使用其中一块，当这一块满了后，将存活对象复制到另一块未被使用的空间，然后清楚使用的那块。优点是简单高效，没有内存碎片问题，缺点是需要额外的空间来存储复制后的对象
标记-整理算法（Mark-Compact）：在标记阶段和标记-清除算法类似，但在清除阶段将存活对象整理到内存的一端，然后清除边界以的所有对象。优点是不会产生内存碎片，缺点是比较慢
分代收集算法（Generational）：根据对象存货时间将内存分为几个区域，每个区域采用不同的回收策略。一般将新生代分为Eden区和两个Survivor区，采用复制算法回收；将老年代采用标记-清除或标记-整理算法回收。优点是提高了回收效率，缺点是需要额外的维护成本

这些算法各有优缺点，适用于不同场景。标记-清除算法简单，但可能会产生内存碎片；复制算法适用于短时间内产生大量垃圾的场景，但需要额外的空间存储复制后的对象；标记-整理算法不会产生内存碎片，但比较慢；分代收集算法提高了回收效率，但需要额外的维护成本

对于一个应用程序，选择合适的垃圾回收算法需要综合考虑应用场景，内存需求，性能要求等多个因素，以便达到最佳效果

CC 攻击是什么？什么叫 DDOS 攻击？什么是网站数据库注入？

CC 攻击（CC Attack）是一种网络攻击方式，全称为“压力测试（Concurrent Connections）攻击”。它通常是指对服务器进行大量并发请求的攻击，从而导致服务器的瘫痪。攻击者通过使用大量的机器或网络中的代理服务器，想目标服务器发送大量请求，以消耗服务器的带宽和资源，从而使其无法正常提供服务。CC攻击可以是攻击者自己编写的脚本，也可以是专门的CC攻击工具

DDOS 攻击（Distributed Denial of Service Attack）是一种网络攻击方式，它通常是指利用大量计算机或网络中的代理服务器，同时向目标服务器发送大量请求，从而导致目标服务器的瘫痪。DDOS攻击可以采用多种实现方式，如SYN攻击，UDP攻击，ICMP攻击等

网站数据库注入（SQL Injection）是一种利用Web 应用程序漏洞的攻击方式，攻击者通过及那个恶意SQL 代码插入到Web 应用程序的输入字段中，从而获取对数据库的未授权访问。网站数据库注入攻击可以导致许多问题，如破坏数据库的完整性，泄漏敏感数据，执行未经授权的操作。常见的防御措施包括输入验证，参数化查询，使用安全的API等

你是否了解过新版本的 Java 特性？对 Java 未来的发展有什么看法？

Java 8（2014）：

Lambda 表达式：简化函数式编程
Stream API：用于处理集合，支持函数式操作，如过滤，映射和聚合
默认方法：在接口中提供默认实现，提高接口的灵活性
Optional类：减少空指针异常，提高代码可读性

Java 9（2017年）：

模块系统（Project-Jigsaw）：将Java 的庞大代码库划分为可重用的模块，简化大型应用的构建和维护
JShell：Java的交互式命令行工具，用于快速尝试和测试Java 代码片段
新的集合工厂方法：方便的创建不可变集合，如List.of()，Set.of() 和 Map.of()。

Java 10（2018年）：

局部变量类型推断：使用var关键字自动推断局部变量的类型，简化代码
垃圾回收器接口改进：提高了垃圾收集器的可插拔性和灵活性

Java 11 （2018年，长期支持版本）：

新的HTTP客户端API：支持HTTP/2 和 WebSocket，提供了更现代化的编程方式。
改进的垃圾收集：引入了ZGC和Eplion 垃圾收集器
String类的新方法：如lines()，isBlank()，strip()等

Java 12 - 17的部分新特性：

Switch 表达式：简化switch语句的编写，支持使用箭头的语法
文本块：简化多行字符串字面量的表示
Record：简化数据类的定义，自动为其生成构造函数，getter，hashCode，equals，toString方法
Pattern Matching for instanceof（预览功能）：简化instanceof操作符的使用，避免显式类型转换
密封类
删除实验性 AOT 和 JIT 编译器
特定于上下文的反序列化过滤器

Java未来的发展趋势将会更加注重性能，安全和可靠性。以下是一些可能会影响Java未来发展的趋势

云计算和容器化：Java非常适合在云环境中使用，因为它具有高度的可移植性和跨平台性。Java的未来将会更加注重云计算和容器化的支持
数据科学和人工智能：Java 16中的 Record 和 Sealed Classes 是一种更简洁的语法，未来Java可能会继续简化语法以提高代码的可读性和可维护性

总之，Java未来将会继续发展和改进，以适应不断变化的编程环境和需求

什么是 Git 的 cherry-pick？

Git 的 cherry-pick 是一种将指定的提交（commit）应用到当前分支的操作。它可以帮助我们将某个分支上的某次提交复制到另一个分支上，而无需将整个分支合并过来。

通常，我们在使用 Git 进行版本控制时，会在不同分支上进行不同的开发工作。有时候，我们需要将某个分支上的某次提交（commit）应用到当前分支上，这时候就可以使用check-pick 操作

使用cherry-pick 操作，我们可以复制指定的提交，然后将其应用到当前分支上，这个提交就成为了当前分支上的一个新的提交。cherry-pick 操作可以方便将某个分支上的某个功能或修复应用到另一个分支上，而无需将整个分支合并过来

cherry-pick 操作的使用方法如下

git cherry-pick <commit-id>

其中，指定了要复制的提交的ID，这个命令将会复制指定的提交，然后将其应用到当前分支上

需要注意的是，使用 cherry-pick 操作时，可能会出现冲突，这时候需要手动解决冲突，并提交一个新的提交来解决冲突。因此，在使用cherry-pick 操作之前，我们需要仔细考虑哪些提交需要复制，以及是否会产生冲突等问题

如何在 Linux 中查看系统资源使用情况？比如内存、CPU、网络端口。

在Linux中，可以使用一些命令和工具来查看系统资源使用情况。下面介绍一些常用的命令和工具：

top：top命令可以实时的显示系统中各个进程的资源使用情况，包括CPU使用率，内存使用率，进程ID等信息。可以通过top命令来查看当前系统的CPU 和内存使用情况
free：free命令可以查看系统中的内存使用情况，包括总内存使用量，已使用内存量和可用内存量等。可以通过free命令来查看当前系统的内存使用情况。
df：df命令可以查看系统中磁盘的使用情况，包括磁盘总容量，已使用空间和可用空间等，可用通过df命令查看当前系统的磁盘使用情况
iostat：iostat 命令可以查看系统的CPU 和磁盘I/O 使用情况。可以通过iostat命令来查看当前系统的CPU 和磁盘I/O 使用情况。
netstat：netstat 命令可以查看系统中的网路连接情况，包括本地地址，远程地址，连接状态等信息，可以通过netstat命令来查看当前网络连接情况
lsof：lsof 命令可以查看系统中打开的文件和网络连接情况，包括文件名，文件描述符，进程ID，进程名等信息，可以通过lsof 命令查看当前系统的文件和网路连接情况。

这些命令和工具都可以帮助我们了解当前系统资源的使用情况，方便我们对系统进行优化和管理。同时，也可以通过一些其他工具，如htop，iotop等，来查看系统资源使用情况

如何用 Nginx 做限流，有几种限流算法，分别如何实现？

Nignx 可以通过配置限制每个客户端请求的速率来实现限流。具体来说，Nginx 有两中限流方式：基于请求速率限制和基于连接速率限制

下面分别介绍这两种方式以及常用的限流算法。

基于请求速率限制：基于请求限制是指限制每个客户端的请求速率，常用的限流算法有以下几种：
- 漏桶算法：在单位时间内处理一定数量的请求，多余的请求则会放入一个”漏桶“中，随后以固定速率处理
- 令牌桶算法：在每个单位时间内，讲一定数量的”令牌“放入桶中，每次请求需要获得一个令牌才能被处理，当桶中没有令牌时，请求将被拒绝
- 计数器算法：简单的对请求计数，并限制每个客户端在单位时间内最多考研处理的请求数量
在Nginx 中实现基于请求速率的限流通常需要使用模块，入ngx_http_limit_req_module，ngx_http_limit_conn_module等。
基于连接速率限制：基于连接速率限制时指限制每个客户端的连接速率，常用的限流算法有以下几种：
- 并发连接数：限制每个客户端同时能够建立的连接数，以此来限制连接速率
- 队列长度：将每个连接加入到一个队列这中，限制队列中同时存在的连接数量，以此来限制连接速率
在Nginx 中实现基于连接速率的限流通常需要使用模块，如 ngx_http_limit_conn_module等

要实现基于请求速率或连接速率的限流，我们需要在Nginx 配置文件中设置相应的限流规则。以下是一个基于漏桶算法的Nginx 配置示例：

http {
    limit_req_zone $binary——remote_addr zone=one:10m rate=10r/s;
    
    server {
        localtion / {
            limit_req zone=one burst=20;
            proxy_pass http://backend;
        }
    }
}

其中，limit_req_zone 指定了一个名为one 的共享内存区间，用于存储请求的统计信息，同时指定了速率为10r/s 。在localtion 中，limit_req 指定了限流规则，并将请求转发到后端服务器

需要注意的是，不同的限流算法适用于不同的场景，我们需要根据实际情况选择合适的算法和配置参数。同时，在实际应用中，为了防止恶意攻击和DDOS攻击，通常需要将多种限流算法组合起来适用