IT小东北

# 面试题

# 项目中在什么场景下使用Redis的ZSet,什么情况下使用的HashSet

Redis的ZSet和HashSet都是常用的数据结构，但在实际项目中，它们通常应用于不同的场景下：

  1. ZSet：ZSet（有序集合）通常适用于需要对数据进行排序和计分的场景。例如，网站上的热门文章列表、排行榜等，这些数据需要根据某个指标（如点击量、评论数、评分等）进行排序展示。ZSet底层使用了一个跳表和一个哈希表，它能够快速地执行范围查询和按照分值排序。
  2. HashSet：HashSet（哈希表）通常适用于缓存一些简单的对象或者键值对，没有特别的需求需要排序或者计分。例如，缓存用户信息、配置信息等等。HashSet底层使用了一个数组和若干个链表，它能够快速地执行键值对的添加、删除、查找操作。

在选择使用ZSet还是HashSet时，要根据具体的业务需求和数据特点来决定。如果需要对数据进行排序和计分，那么可以考虑使用ZSet；如果只是简单地缓存对象或键值对，那么HashSet就足够了。需要注意的是，在使用ZSet和HashSet时，也需要注意数据的安全性和一致性，避免出现数据丢失或损坏等问题。同时，也要根据实际情况来确定数据的存储时间和清理策略，以避免占用过多内存和影响系统性能。

# ThreadLocal的原理？

ThreadLocal是Java语言中的一个线程局部变量，它提供了一种简单的机制，使得每个线程都可以独立地维护自己的值，而不会影响其他线程。ThreadLocal通常用于解决多线程并发访问时对于同一数据资源的共享问题。

ThreadLocal的原理是：在每个线程内部维护了一个ThreadLocalMap对象，该对象是一个以ThreadLocal为键、任意类型对象为值的键值对集合。当通过某个ThreadLocal对象获取值时，实际上是先获取当前线程内部的ThreadLocalMap对象，然后以该ThreadLocal对象为键，从ThreadLocalMap中获取相应的值。由于每个线程内部的ThreadLocalMap对象都是独立的，因此可以保证不同的线程之间访问ThreadLocal对象时，结果不会产生干扰。

具体来说，当调用ThreadLocal的set()方法时，实际上是先获取当前线程内部的ThreadLocalMap对象，然后以该ThreadLocal对象为键，将要设置的值存入其中；而当调用ThreadLocal的get()方法时，则是先获取当前线程内部的ThreadLocalMap对象，然后以该ThreadLocal对象为键，从ThreadLocalMap中获取相应的值。ThreadLocal的remove()方法则是从当前线程的ThreadLocalMap对象中删除该ThreadLocal对象对应的值。这样，在同一个线程中，不同的ThreadLocal对象可以互不干扰地存取各自的值。

需要注意的是，使用ThreadLocal时也要注意避免出现内存泄漏和数据不一致等问题。因为ThreadLocalMap中存储的对象只能被当前线程访问和修改，如果在某个线程结束后没有及时清除ThreadLocal对象，可能会导致该线程关联的值长时间存在于内存中，从而导致内存泄漏；同时，也要注意在使用ThreadLocal时，尽量避免线程间的数据依赖和耦合，以保证数据的一致性。

# JDK8的在一个接口中有defult关键字修饰接口中的方法，那抽象类的意义是什么？

2023/3/23 下午3:37:38

抽象类是在Java中一种特殊的类，它不能被实例化，而只能用作其他类的基类。抽象类可以包含抽象方法，这些方法只有声明，没有具体的实现。子类必须实现所有继承的抽象方法才能被实例化。

与接口相比，抽象类更加灵活，因为它可以包含已经实现的方法和字段，并且可以提供默认的实现。同时它也可以包含抽象方法，来强制子类实现某些方法。而接口中的方法都是抽象的，并且只能包含常量和抽象方法。

在 JDK8 中，接口可以使用 default 关键字修饰方法，这使得接口也可以包含具体的实现方法。这样就减少了抽象类和接口之间的差距，但它们仍然有一些不同，如抽象类可以拥有构造函数，而接口不能，抽象类可以继承普通类，而接口不能等。

2023/3/23 下午3:38:11

# 接口和抽象类的区别？

2023/3/23 下午3:38:33

接口和抽象类都是为了实现代码重用和多态性，但是它们之间有一些关键的区别：

1.语法上的区别

接口使用 interface 关键字进行声明，而抽象类使用 abstract 关键字进行声明。接口中只能包含抽象方法和常量，而抽象类可以包含非抽象方法和字段。

2.实现方式的区别

一个类可以实现多个接口，但是只能继承一个抽象类。由于 Java 不支持多重继承，所以如果一个类已经继承了抽象类，则它不能再实现其他类或抽象类。

3.方法实现的区别

接口中的方法全部是抽象的，不带具体实现，而抽象类可以包含具体的实现方法。在 JDK8 中，接口可以包含 default 方法，其实现可以被直接继承，这使得接口的功能更加强大。

4.构造函数的区别

抽象类可以定义构造函数，而接口不能定义构造函数。

5.访问修饰符的区别

接口中的方法默认是 public 的，而抽象类中的方法可以使用任何访问修饰符。

总的来说，接口适用于定义行为的规范，而抽象类适用于提供通用实现的部分功能。如果您需要创建一个包含某些共享代码的基本类，则应该考虑使用抽象类；否则，如果您想定义一组特定的方法，并且希望所有实现此接口的类都实现这些方法，则应该考虑使用接口。

# Spring如何解决循环依赖的？

在 Spring 容器中，如果两个或多个 Bean 之间存在循环依赖关系，当容器实例化这些 Bean 时，就会发生 BeanCurrentlyInCreationException 异常。这是因为容器无法确定哪个 Bean 应该先被创建。

Spring 通过三级缓存解决了循环依赖问题：

  1. 第一级缓存：singletonObjects

在 Spring 中，默认情况下，Bean 的作用域为 Singleton，也就是说每个 Bean 在 Spring 容器中只有一个实例。在创建单例 Bean 时，Spring 将 Bean 实例放入 singletonObjects 缓存中。如果 A Bean 依赖于 B Bean，那么当创建 A Bean 时，Spring 会尝试从 singletonObjects 缓存中获取已经实例化的 B Bean。

  1. 第二级缓存：earlySingletonObjects

如果第一级缓存中没有找到依赖的 Bean，则 Spring 会创建一个未完全初始化的 Bean 并将其放入 earlySingletonObjects 缓存中，然后继续创建它所依赖的其他 Bean。当其他 Bean 创建完成并且返回时，Spring 会回调未完成初始化的 Bean 的 finishBeanFactoryInitialization() 方法来完成它的初始化。

  1. 第三级缓存：singletonFactories

如果第二级缓存中也没有找到依赖的 Bean，Spring 会创建一个 ObjectFactory，并将其放入 singletonFactories 缓存中。ObjectFactory 是一个工厂对象，用于暂时保存创建 Bean 的方法。当其他 Bean 创建完成并且返回时，Spring 会调用 ObjectFactory 的 getObject() 方法来完成 Bean 的创建和初始化。

通过这种方式，Spring 能够解决大部分的循环依赖问题。但是，如果存在多层、复杂的循环依赖关系，可能会导致 Spring 无法解决问题。在这种情况下，需要手动调整 Bean 的依赖关系或者使用 @Lazy 注解延迟加载 Bean。

# 在Java中，枚举是实现单例最好的方案之一，因为它可以保证单例的线程安全性、序列化和反射安全性。

每个枚举类型都是由Java虚拟机在加载枚举类型时自动构造的，枚举类型的构造器默认为私有，并且枚举类型的所有实例都是在枚举类被加载时创建的。这意味着枚举类型的实例是唯一的，并且可以通过枚举值来访问。

枚举类型天生就是线程安全的，因为枚举类型的实例是在类加载时创建的，保证了同步访问的正确性，不需要使用synchronized关键字或者volatile修饰符等线程安全手段。

枚举类型还能够保证序列化和反射的安全性。枚举类默认继承Enum类，而Enum类实现了Serializable接口和Comparable接口，这使得枚举类天生就支持序列化和反序列化操作，并且可以通过其name()方法来反射创建新的枚举实例。

因此，通过使用枚举类型，我们可以轻松地实现线程安全、序列化和反射安全的单例模式。

# 零拷贝

零拷贝（Zero-copy）是一种数据传输技术，它可以在不涉及数据的复制操作时，将数据从一个源端传输到目标端。在Java中，零拷贝通常指的是利用Java NIO（New Input/Output）库提供的直接内存（Direct Memory）来实现零拷贝。

在传统的IO模型中，数据通常需要经过用户空间和内核空间之间的多次拷贝操作才能完成数据传输，这些拷贝操作对系统性能造成了一定的影响。而在使用零拷贝技术时，数据可以直接从应用程序的缓冲区通过DMA（Direct Memory Access）引擎传输到网络适配器或磁盘控制器等设备上，避免了多次拷贝操作，提高了数据传输的效率和性能。

在Java NIO中，我们可以通过ByteBuffer类的allocateDirect()方法来创建直接内存缓冲区，然后使用FileChannel或SocketChannel等通道来进行读写操作，从而实现零拷贝。需要注意的是，在使用直接内存缓冲区时，必须手动释放内存以避免内存泄漏问题。

除了网络和磁盘IO等场景，零拷贝技术还可以应用于其他许多领域，如图形处理、音视频编解码等。通过使用零拷贝技术，我们可以在不损失程序可读性和可维护性的前提下，提高系统的性能和稳定性。

# Java中深拷贝和浅拷贝的却别

  1. 浅拷贝：浅拷贝是指只复制对象本身和对象内部的基本类型数据，而不复制对象内部引用类型数据所指向的对象。因此，浅拷贝后的对象与原对象共享引用类型数据，对其中一个对象所做的修改可能会影响另一个对象。
  2. 深拷贝：深拷贝是指复制对象本身和对象内部所有引用类型数据所指向的对象，而不是复制引用类型数据本身。因此，深拷贝后的对象与原对象完全独立，对其中一个对象所做的修改不会影响另一个对象。

在Java中，通过实现Cloneable接口和重写clone()方法可以实现对象的浅拷贝。而实现对象的深拷贝需要使用其他的方式，如序列化和反序列化、Java Bean工具类、手动递归复制等。

需要注意的是，对象内部的所有引用类型数据所指向的对象都需要被正确地复制才能实现深拷贝，否则可能会导致浅拷贝的结果。

# Java除了clone 还有哪些方式可以进行对象的深拷贝

在Java中，除了使用clone() 方法之外，还有以下几种方式可以进行对象的深拷贝：

  1. 序列化和反序列化：将对象序列化成字节流，然后再反序列化成一个新的对象。这种方式可以深度复制整个对象图，但需要确保对象及其属性都是可序列化的。
  2. 使用Java Bean工具类：一些Java Bean工具类（例如Apache Commons BeanUtils、Spring BeanUtils等）提供了深拷贝功能，可以通过BeanUtils.copyProperties()方法来完成深拷贝。
  3. 手动递归复制：通过递归遍历整个对象图，并创建一个新的对象来复制每个对象及其属性。这种方法可以确保完全复制对象图，但需要小心处理循环引用的情况。
  4. 利用对象流和字节流：利用对象流和字节流可以实现对象的深度克隆，需要将对象通过对象流序列化到字节流中，然后再通过字节流反序列化成新的对象。

需要注意的是，在使用上述方法进行深拷贝时，要注意确保所有属性和子对象都能够被正确复制，否则可能会导致意想不到的问题。

# 什么是JIT

JIT是Just-In-Time的缩写，指的是即时编译。

JIT编译器的主要作用是在程序运行时将部分代码转换为机器语言，从而提高程序的执行效率。具体来说，JIT可以根据程序的执行情况动态地选择需要优化的代码段，并实时进行编译。

# 什么是逃逸分析

分析对象动态作用域。逃逸分析就是用来判断一个对象是否可能被外部所引用

逃逸类型：

  • 方法逃逸：当一个对象在方法中被定义后，它可能被外部方法所引用，例如作为调用参数传递到其他地方中。
  • 线程逃逸：这个对象设置可能被其他线程访问到，例如赋值给类变量或可以在其他线程中访问的实例变量。

编译器可以对代码做如下优化

  • 同步省略或锁消除
  • 将堆分配转化为栈分配
  • 分离对象或标量替

# 为什么Concurrent的get操作读到空值的时候会加锁

在ConcurrentHashMap中，当一个线程进行get操作时，如果它读到的是null值，那么它会认为当前key对应的value不存在，但实际上该key的value可能正在被其他线程修改或者已经被删除了。因此，为了保证读到的value是最新的值，ConcurrentHashMap会在get操作的时候进行加锁，确保只有一个线程能够对该key进行操作，防止出现并发修改的情况。

具体来说，当一个线程进行get操作时，如果读到的value为null，它会获取一个segment的读锁（读操作可以并发进行），然后再次尝试获取该key的锁。如果获取锁成功，那么它就可以对该key进行操作了；否则，它会释放掉之前获取的segment的读锁，等待其他线程修改完该key之后再重新尝试获取锁。

通过这种方式，ConcurrentHashMap保证了在多线程并发操作的情况下，get操作始终能够读取到最新的value值，并且保证了线程安全性。同时，由于只在必要的时候加锁，避免了过多的锁竞争，提高了ConcurrentHashMap的性能。

# 什么是零拷贝技术

零拷贝（Zero Copy）是指在数据传输过程中避免了数据的复制操作，从而提高了数据传输的效率和性能。

在传统的数据传输方式中，数据通常需要从应用程序的缓冲区先拷贝到内核的缓冲区，然后再从内核的缓冲区拷贝到网络协议栈中，最终传输到网络中。这种方式涉及到多次内存复制操作，会带来较大的性能损耗。

零拷贝技术可以避免这种性能损耗，它使用了操作系统提供的文件映射技术或直接内存访问技术，让数据可以直接在内核空间和用户空间之间传输，避免了数据的复制操作。具体来说，当应用程序需要发送或接收数据时，它会调用操作系统提供的系统调用（如sendfile、mmap等）直接将数据从磁盘或内存映射文件读取到内核缓冲区，然后再直接发送或接收数据，避免了多次数据复制操作，提高了数据传输的效率和性能。

在Java中，零拷贝技术通常通过Java NIO（New I/O）库实现。Java NIO提供了一套高效的非阻塞I/O API，通过使用ByteBuffer等数据结构实现了直接内存访问和内存映射文件等零拷贝技术，从而提高了Java程序在网络通信和文件操作等方面的性能

Java中如何实现零拷贝

在Java中，实现零拷贝主要依靠Java NIO（New I/O）库。Java NIO提供了一套高效的非阻塞I/O API，通过使用ByteBuffer等数据结构实现了直接内存访问和内存映射文件等零拷贝技术，从而提高了Java程序在网络通信和文件操作等方面的性能。

以下是一些Java中实现零拷贝的方法：

  1. 使用DirectByteBuffer：DirectByteBuffer是Java NIO中的一个数据结构，它可以通过使用Native函数实现内存的直接操作，从而避免了数据的复制操作。通过将数据读取到DirectByteBuffer中，然后通过Channel将数据直接发送到网络中，实现了零拷贝。
  2. 使用FileChannel.transferTo()方法：FileChannel提供了一个transferTo()方法，该方法可以将一个文件的内容直接传输到另一个Channel中，而无需经过中间缓冲区。这个方法通过底层的操作系统调用（如sendfile）实现了零拷贝，从而提高了文件传输的效率。
  3. 使用内存映射文件（MappedByteBuffer）：内存映射文件可以将一个文件映射到内存中，从而可以直接对文件进行操作，而无需进行数据的复制操作。通过使用MappedByteBuffer，可以将文件的内容直接发送到网络中，从而实现了零拷贝。

需要注意的是，实现零拷贝需要具有一定的系统底层编程知识，因此在实际应用中需要仔细考虑使用零拷贝的场景和实现方式。

# 什么是GRPC

gRPC是由Google开源的高性能、开源的远程过程调用（RPC）框架。它建立在HTTP/2协议上，并使用Protocol Buffers作为数据序列化和传输格式。gRPC支持多种编程语言，包括Java、C++、Python等。

gRPC的主要特点包括：

  1. 基于HTTP/2协议：gRPC使用HTTP/2协议进行通信，具有双向流和头部压缩等优点，能够提高网络传输的效率和性能。
  2. 支持多种编程语言：gRPC支持多种编程语言，包括Java、C++、Python等，可以满足不同编程语言的需求。
  3. 使用Protocol Buffers作为数据序列化和传输格式：gRPC使用Google开源的Protocol Buffers作为数据序列化和传输格式，具有高效、可扩展、跨语言等优点。
  4. 支持多种RPC模式：gRPC支持多种RPC模式，包括Unary、Server Streaming、Client Streaming、Bidirectional Streaming等。
  5. 生成客户端和服务端代码：gRPC可以根据定义的服务和消息格式自动生成客户端和服务端代码，简化了开发过程。

因此，gRPC成为了一种非常流行的RPC框架，被广泛应用于各种类型的网络应用程序中。

# MySQL中三种开启事务的方式：

  1. begin
  2. start transaction
  3. start transaction with consistent snapshot

区别在于创建 Read View（一致性视图）的时机不同。前两种方式，MySQL执行后不会马上创建视图，是在执行第一条select语句时才会创建，第三种方式执行后会马上创建视图。

# UML类图

# Java中组合关系和聚合关系的区别

  1. 组合关系：组合关系是一种强关联的、包含的关系，表示一个对象（称为整体）由若干个其他对象（称为部分）组成，整体和部分之间是不可分离的关系，如果整体对象被销毁，则部分对象也会随之被销毁。在Java中，组合关系可以通过在一个类中创建另一个类的对象来实现，通常使用new关键字创建对象。例如，一个汽车类包含多个轮子对象，如果汽车对象被销毁，则所有轮子对象也会随之被销毁。
  2. 聚合关系：聚合关系是一种弱关联的、包容的关系，表示一个对象（称为整体）包含若干个其他对象（称为部分），整体和部分之间是可分离的关系，如果整体对象被销毁，则部分对象不会被销毁。在Java中，聚合关系可以通过在一个类中引用另一个类的对象来实现。例如，一个学校类包含多个学生对象，如果学校对象被销毁，则学生对象不会随之被销毁，它们可以被其他学校对象所引用。

# 协程

协程（Coroutine）是一种轻量级的并发编程模型，它允许在一个线程中以协作的方式实现并发执行。与传统的多线程编程模型相比，协程可以更高效地利用计算资源，并简化了编写并发代码的复杂性。

协程可以看作是一种特殊的函数，它可以在执行过程中暂停和恢复，而不会阻塞线程。协程之间可以通过挂起和恢复的方式进行交互，类似于函数之间的调用。这种特性使得协程在处理并发任务时能够更加灵活和高效。

协程通常具有以下特点：

  1. 轻量级：协程是轻量级的执行单元，可以创建大量的协程而不会占用过多的系统资源。
  2. 高效性：协程的切换开销很小，因为切换只发生在协程之间，不涉及线程的切换。
  3. 非抢占式：协程是协作式的，不会强制中断执行，而是由协程主动挂起和恢复。
  4. 异步编程：协程可以用于实现异步编程模型，通过挂起和恢复来处理异步任务。
  5. 状态保存：协程可以在挂起时保存自己的状态，以便在恢复时继续执行。

协程的实现方式和语法特性因编程语言而异。一些编程语言如Kotlin、Python、Go等原生支持协程，提供了相应的语法和库来简化协程的使用。而其他编程语言如Java，在没有原生协程支持的情况下，可以通过第三方库或框架来实现协程功能。

总而言之，协程是一种轻量级的并发编程模型，通过协作式的挂起和恢复来实现高效的并发执行。它可以简化并发编程的复杂性，并提供更好的性能和资源利用。

# Java双亲委派机制的好处

Java双亲委派机制是Java类加载器（Class Loader）的一种工作原理，它的主要好处包括以下几个方面：

  • 避免类的重复加载：双亲委派机制可以避免同样的类被多次加载到内存中。当一个类加载器接收到加载类的请求时，它会先将该请求委派给父类加载器处理。如果父类加载器可以找到并加载该类，就不需要子加载器再次加载，从而避免了类的重复加载。这样可以节省内存空间，同时也确保了类的唯一性。
  • 确保类的安全性：通过双亲委派机制，Java类加载器可以按照一定的层次结构进行类加载，并且只有在父加载器无法加载该类时，才会由子加载器尝试加载。这样可以确保核心类库由系统类加载器加载，而不会被用户自定义的类替换，从而增加了类的安全性。
  • 保护核心类库的完整性：由于Java类加载器的层次结构，核心类库（如Java标准库）位于较高层的父类加载器中，而用户自定义的类位于较低层的子类加载器中。这种层次结构保护了核心类库的完整性，防止用户自定义的类对核心类库进行替换或篡改。
  • 支持类加载器的扩展：通过双亲委派机制，可以很容易地扩展Java类加载器。如果需要加载自定义的类或库，只需要创建一个新的子类加载器，并在加载类时委派给父加载器处理。这样可以灵活地实现类加载器的定制和扩展，满足不同的加载需求。 总的来说，Java双亲委派机制通过层次结构和委派方式，实现了类加载的顺序和隔离，保证了类的唯一性和安全性，并支持类加载器的扩展。这种机制为Java提供了一个可靠和灵活的类加载环境，有助于保持Java应用程序的稳定性和安全性。