Java 基础常见面试题整理

1、java的基本数据类型有哪些？

Java的基本数据类型包括以下八种：

• boolean： 用于存储逻辑值，只能存储true和false。
• byte： 用于存储字节数据，占用8位（一个字节）内存空间。
• short： 用于存储较短整数，占用16位（两个字节）内存空间。
• int： 用于存储整数，占用32位（四个字节）内存空间。
• long： 用于存储长整数，占用64位（八个字节）内存空间。
• float： 用于存储单精度浮点数，占用32位（四个字节）内存空间。
• double： 用于存储双精度浮点数，占用64位（八个字节）内存空间。
• char： 用于存储单个字符，占用16位（两个字节）内存空间，采用Unicode编码。

2、java为什么要有包装类型？

主要原因包括以下几点：

• 处理基本数据类型的 null 值：基本数据类型（如 int，double 等）不能直接赋值为 null，而包装类型（如 Integer、Double）可以表示 null 值，这对于某些业务逻辑和数据处理来说非常有用。
• 提供额外功能：包装类型提供了一些额外的方法和功能，这些方法可以用于对基本数据类型进行操作和处理。例如，Integer 类提供了
  parselnt()方法用于将字符串转换为整数。
• 泛型支持：泛型只能接受对象类型，无法直接使用基本数据类型。因此，使用包装类型可以很方使地在泛型中使用基本数据类型。
• 自动装箱与拆箱: Java 提供了自动装箱(autoboxing)和自动拆箱(unboxing)的功能，使得基本类型与其对应的包装类型之间的转换更加便捷。
• 与对象集合的兼容性: Java的集合类(如ArrayList, HashMap等)只能存储对象,不能直接存储基本数据类型。使用包装类型可以方便地将基本数据类型转换为对象类型，从而与集合类兼容。

3、String a = “123” 和 String a = new String(“123”) 区别？

String a = "123"; // a 是一个变量，对字符串常量池中“123”这个对象的引用
// "123" 是一个字符串字面量（字符串对象），它会被存储在字符串常量池中（String Constant Pool）。
// 当字符串常量池不存在“123”对象会创建一个对象，存在则不会创建  
  
String b = new String("123"); // b 是一个变量，但它引用堆的 String 对象  
// 这里，首先 JVM 会检查字符串常量池中是否已经有 "123" 这个字符串。  
// 如果有，它会用常量池中的字符串对象作为参数去调用 String 类的构造函数来创建一个新的 String 对象。  
// 这个新的 String 对象会被分配在堆内存中，并且它的内容（字符数组）会是常量池中字符串对象的一个拷贝。  
// 变量 b 持有对这个新创建的堆上 String 对象的引用，而不是直接引用常量池中的字符串。
// 最多创建2个对象，最少一个

•  

  篇幅限制下面就只能给大家展示小册部分内容了。这份面试笔记包括了：Java面试、Spring、JVM、MyBatis、Redis、MySQL、并发编程、微服务、Linux、Springboot、SpringCloud、MQ、Kafka 面试专题

  需要全套面试笔记【点击此处】即可免费获取

4、String、StringBuilder和StringBuffer的区别？

String、StringBuilder和StringBuffer是Java中用来处理字符串的类，它们之间的区别主要在于性能和线程安全性。

• String: 一旦创建就不能被修改，任何对String的操作都会产生一个新的String对象。
  不可变性使得String在并发环境下是线程安全的，但是频繁的字符串操作会产生大量临时对象，影响性能。

• StringBuilder: StringBuilder是可变的，可以进行插入、追加、删除等操作而不会产生新的对象。
  由于StringBuilder是非线程安全的，所以在单线程环境下比StringBuffer具有更好的性能。

• StringBuffer: 与StringBuilder类似，也是可变的，但是它是线程安全的，所有的方法都是同步的。
  在多线程环境下，为了确保线程安全性，可以使用StringBuffer，但性能相对较差，因为是通过在方法上面加synchronized 关键字来保证同步的。

因此，如果在单线程环境下需要频繁修改字符串，建议使用StringBuilder；如果在多线程环境下需要频繁修改字符串，则应该使用StringBuffer；如果字符串不需要被修改，那么使用String即可。

5、如何理解面向对象和面向过程？

面向过程是一种以过程为中心的编程方法，它将问题分解为一系列步骤或函数。每个函数负责完成一个特定的任务，通过依次调用这些函数来解决问题。

其优点包括：

• 流程清晰：按照步骤进行编程，易于理解和调试。

然而，它也存在一些局限性：

• 代码复用性差：功能封装在函数中，但难以复用和扩展。
• 维护困难：代码结构较为松散，修改可能影响多个部分。

面向对象则是一种以对象为中心的编程方法。它将问题抽象为对象，每个对象具有属性和行为。
其优点包括：

• 代码复用性高：通过继承和多态实现代码的重用和扩展。
• 维护方便：修改一个对象的行为不会影响其他部分。
• 模拟现实世界：更符合人类的思维方式。

面向对象编程的关键概念包括：

• 对象：表示现实世界中的实体。
• 类：对象的抽象描述。
• 封装：隐藏对象的内部实现，只暴露必要的接口。
• 继承：实现代码的重用和扩展。
• 多态：不同对象对同一消息的不同响应。

总之，面向对象编程更加注重代码的封装、复用和可扩展性，使得代码更易于维护和扩展。而面向过程编程则更适合一些简单、流程性强的问题。在实际编程中，可以根据具体情况选择合适的编程方法。

6、面向对象的三大基本特征是什么?如何理解？

面向对象的三大基本特征是封装、继承和多态。

封装是将对象的属性和行为封装在一起，对外只提供必要的接口。它的意义在于：

• 信息隐藏：隐藏内部实现细节，提高安全性和可靠性。
• 模块独立性：减少模块之间的耦合，便于模块的独立开发和测试。

继承允许子类继承父类的属性和方法，从而实现代码的重用和扩展。理解继承可以从以下几个方面考虑：

• 代码复用：避免重复编写相同的代码。
• 扩展功能：子类可以在父类的基础上添加新的功能。

多态是指同一个方法在不同的对象上有不同的实现。它的好处包括：

• 灵活性：根据具体对象的类型执行相应的操作。
• 可扩展性：方便添加新的子类并实现不同的行为。

7、java是面向对象还是面向过程？

Java 是一种面向对象的编程语言。

8、什么是反射？为什么需要反射？

反射是指在运行时动态地访问和操作类的信息。

需要反射的原因包括：

• 灵活性：可以在运行时获取类的信息、创建对象、调用方法等，提供了更大的灵活性。
• 动态加载：支持在运行时动态加载和使用类，无需在编译时确定。
• 框架和工具开发：便于开发通用的框架和工具，可适应不同的业务需求。
• 插件机制：支持插件式的扩展，方便添加新的功能。
• XML 配置：与配置文件结合，实现基于配置的动态功能。
• 类操作：对类进行各种操作，如修改属性、方法等。
• 跨模块交互：方便不同模块之间的交互和集成。

通过反射，程序可以在运行时动态地了解和操作类的结构和行为，从而实现更灵活和可扩展的系统设计。

9、为什么不能用浮点数表示金额？ 有什么方法解决？

浮点数在计算机内部的表示方法采用的是 IEEE 标准，它兼顾了数据的精度和大小。32 位的浮点数由 1 比特的符号位、8 比特的阶码和 23 比特的尾数组成。浮点数能表示的数据大小范围由阶码决定，而能够表示的精度完全取决于尾数的长度。对于金额，舍去不能表示的部分，就会产生精度丢失。
十进制的 0.1 在二进制下将是一个无线循环小数，同样，在进行加法、减法、乘法和除法等运算时，这种精度损失可能会累积，导致结果不正确。为了避免这种情况，建议使用 java.math.BigDecimal 类来表示和计算金额。BigDecimal 提供了用于高精度算术运算的方法，能够精确地表示十进制小数，避免浮点数表示和计算中的精度损失问题。

10、为什么不能用字符串来存储金额？

使用字符串来存储金额有一些局限性：

• 计算困难：进行数值计算时，需要额外的处理来转换和解析字符串。
• 效率较低：在涉及大量金额操作时，性能可能受到影响。
• 不支持数学运算：无法直接进行加减乘除等常见的数学运算。
• 易出错：处理字符串转换可能引入错误。
• 数据类型不一致：与其他数值类型的交互可能需要额外的转换。

然而，在某些情况下，可能会选择使用字符串来存储金额：

• 格式灵活：可以方便地表示特定的金额格式。
• 非数值场景：如仅用于显示或存储。

为了更准确和高效地处理金额，通常使用专门的数值类型或类，例如 Java 中的BigDecimal，它提供了高精度的数值计算功能，能够避免常见的数值计算问题。

11、为什么需要克隆？如何实现对象的克隆？深拷贝和浅拷贝的区别？

需要克隆的原因有以下几点：

• 独立性：创建独立的副本，避免对原始对象的修改影响到其他使用该对象的部分。
• 隔离性：在不同的上下文或操作中使用相同对象的副本，以防止冲突。
• 安全性：确保原始对象的完整性和稳定性。

实现对象的克隆有多种方式，以下是一种常见的方法：

• 实现 Cloneable 接口：确保类实现了 Cloneable 接口。
• 重写 clone 方法：在类中重写 clone 方法。

深拷贝和浅拷贝的区别在于：

深拷贝：复制对象及其引用的所有嵌套对象。

• 副本与原始对象完全独立。
• 修改副本不会影响原始对象。

浅拷贝：只复制对象本身，不复制引用的嵌套对象。

• 嵌套对象仍与原始对象共享。
• 修改副本的嵌套对象会影响原始对象。

深拷贝确保了副本的完全独立性，而浅拷贝在处理嵌套对象时可能会出现问题。在需要完全独立的副本时，应使用深拷贝。

12、try-catch-finally中，如果catch中return了，finally还会执行吗？

在 try-catch-finally 语句中，即使在 catch 块中执行了 return 语句，finally 块仍然会执行。

finally 块的作用是确保无论在 try 块中是否发生异常，某些特定的操作都会被执行，例如资源的释放、清理等。

当执行到 catch 块中的 return 语句时，会先将返回值保存起来，然后执行 finally 块中的代码。最后，再返回保存的返回值。

finally 块的执行具有以下特点：

• 无论是否发生异常，finally 块都会执行。
• 即使在 finally 块中抛出异常，也会继续执行。
• finally 块中的返回值不会影响 try 或 catch 块中的返回值。

使用 finally 块可以确保资源的正确释放，以避免资源泄漏等问题。

13、String为什么设计成不可变的？

String 被设计成不可变有以下几个原因：

1. 安全性和稳定性：避免在多个线程中同时修改字符串时可能出现的竞态条件。
2. 效率：许多操作可以直接利用字符串的不可变性进行优化。
3. 缓存友好：相同字符串可以共享，减少内存占用。
4. 线程安全：无需进行额外的同步操作。
5. 代码简洁：无需处理可变字符串带来的复杂情况。
6. 避免误操作：防止意外修改字符串。
7. 易于实现和理解：简化字符串的内部实现。

不可变的特性使得 String 在多线程环境中更加可靠，并且提高了性能和内存效率。

14、Error和Exception的区别和联系？以及常见的RuntimeException？

区别：

• Error： Error是指Java虚拟机无法解决的严重问题，通常由系统内部错误引起，程序无法通过捕获错误来恢复。一般来说，程序不应该捕获Error类型的异常，而应该在发生Error时让程序终止。常见的Error包括OutOfMemoryError（内存耗尽）和StackOverflowError（栈溢出）等。
• Exception： Exception是指程序运行时可能发生的问题，它可以通过捕获和处理来使程序继续执行。Exception又分为受检异常（Checked Exception）和非受检异常（Unchecked Exception）。受检异常是指在程序编译时需要处理的异常，而非受检异常是指在编译时不需要处理的异常。常见的Exception包括IOException（输入输出异常）和SQLException（数据库访问异常）等。

联系：

Error和Exception都继承自Throwable类，因此它们具有一些共同的特性，如堆栈跟踪和异常信息等。

常见的RuntimeException：

• NullPointerException（空指针异常）： 当试图在一个空对象上调用方法或访问属性时抛出。
• ArrayIndexOutOfBoundsException（数组下标越界异常）： 当试图访问数组中不存在的索引时抛出。
• IllegalArgumentException（非法参数异常）： 当传递给方法的参数不符合方法的要求时抛出。
• ArithmeticException（算术异常）： 当出现除以零的运算时抛出。
• ClassCastException（类转换异常）： 当试图将一个对象转换为它不是的类型时抛出。

15、抽象类和接口的区别是什么？

抽象类和接口是面向对象编程中两种不同的概念，它们在Java中有着明显的区别。

抽象类（Abstract Class）：

• 抽象类可以包含抽象方法和非抽象方法。抽象方法是没有实际实现的方法，需要子类去实现。非抽象方法有默认实现，子类可以选择性地重写这些方法。
• 一个类只能继承一个抽象类（单继承性）。
• 抽象类可以包含成员变量，可以有构造函数，可以拥有普通方法。
• 抽象类可以有访问控制修饰符，可以定义成员变量，可以包含构造方法。

接口（Interface）：

• 接口中所有的方法都是抽象方法，没有方法体。
• 一个类可以实现多个接口（多继承性）。
• 接口中的成员变量隐式地是static和final的。
• 接口不能包含构造函数。
• 接口中的方法默认是public的，可以省略访问控制符，不能使用其他访问修饰符。

16、==和equals的区别

 篇幅限制下面就只能给大家展示小册部分内容了。这份面试笔记包括了：Java面试、Spring、JVM、MyBatis、Redis、MySQL、并发编程、微服务、Linux、Springboot、SpringCloud、MQ、Kafka 面试专题

需要全套面试笔记【点击此处】即可免费获取

在 Java 中，== 和 equals() 方法的区别主要包括以下几点：

• ==：它是一种基本的数据比较操作符，用于比较两个对象的引用（内存地址）是否相等。
• equals()：它是 Object 类中的方法，通常用于定义对象之间的逻辑相等性。

Object默认是判断地址是否相等， Long、Integer、Date、String等都重写了equals方法。

Object类

public boolean equals(Object obj) {
        return (this == obj);
    }

• 1
• 2
• 3

Long类

public boolean equals(Object obj) {
        if (obj instanceof Long) {
            return value == ((Long)obj).longValue();
        }
        return false;
    }

• 1
• 2
• 3
• 4
• 5
• 6

17、super和this的区别是什么？

super用于访问父类的成员，this用于引用当前对象本身的成员

• 1

18、Java中的集合类有哪些？说说他们的特点？

List（列表）
特点：有序、可重复

• ArrayList：基于数组实现的动态数组，可以根据需要自动增长容量。它提供了快速的随机访问和在末尾添加/删除元素的性能。适合需要频繁随机访问元素，以及需要在末尾进行添加/删除操作的场景。
• LinkedList：基于双向链表实现的列表，可以高效地在任意位置进行添加/删除操作。它提供了快速的插入和删除性能。
• Vector：与ArrayList类似，但它是线程安全的，因此性能通常较低。现在较少使用，更多地被ArrayList和CopyOnWriteArrayList替代。

Set（集合）
特点：无序、不可重复

• HashSet：基于哈希表实现的集合，不允许重复元素。它提供了快速的添加、删除和查找性能。
• TreeSet：基于红黑树实现的有序集合，可以按照自然顺序或自定义顺序对元素进行排序。它提供了快速的查找和有序遍历性能。
• LinkedHashSet：保持元素插入顺序的HashSet，基于LinkedHashMap实现。

Queue（队列）
特点：先进先出

• LinkedList：除了作为列表使用，LinkedList还可以用作队列，实现FIFO（先进先出）的数据结构。
• PriorityQueue：基于优先级堆的无界队列，元素按照其自然顺序或者创建PriorityQueue时所提供的Comparator进行排序。
• ArrayDeque：一个由数组结构提供的双端队列，可以作为栈使用。

Map（映射）
特点：键值对存储、无序

• HashMap：基于哈希表实现的键值对映射，不允许重复键。它提供了快速的添加、删除和查找性能。
• TreeMap：基于红黑树实现的键值对映射，按键的自然顺序或自定义顺序对键值对进行排序。
• ConcurrentHashMap：基于分段锁实现的并发哈希表，支持高并发的读取和部分并发的写入操作。
• Hashtable：与HashMap类似，但它是线程安全的，并且不允许键或值为null。现在较少使用，更多地被ConcurrentHashMap替代。

19、集合的排序方式的实现方案？

List自带的 sort 方法、集合工具类 Collections 下面的sort方法、stream 流中的 sorted方法

区别：

List.sort：
List.sort 是 List 接口的默认方法，可以直接在列表对象上调用。它也是一个对原始列表进行排序的原地排序方法，可以使用自定义的 Comparator 进行排序。

Collections.sort：
Collections.sort 是对实现了 List 接口的集合进行排序的静态方法。它实际上会调用列表对象的 sort 方法来完成排序操作。

list.stream().sorted：
list.stream().sorted 是使用流的排序方法，它会产生一个新的经过排序的流，可以在后续收集为一个列表或执行其他操作。
如果使用 sorted(null)，则会使用默认的自然排序进行排序。

性能对比：

在大多数情况下，原地排序的方法（Collections.sort 和 List.sort）的性能会优于使用流进行排序（list.stream().sorted）。
原地排序方法直接在原始列表上进行操作，不需要额外的内存分配，因此速度更快。
流排序方法（list.stream().sorted）通常会引入额外的内存和计算，因此在速度和性能上可能会略逊于原地排序。

20、ArrayList、LinkedList与Vector的区别？

1. 数据结构：

• ArrayList 基于数组实现。
• LinkedList 基于双向链表实现。
• Vector 也基于数组实现。

2. 线程安全性：

• ArrayList是非线程安全的。

• LinkedList是非线程安全的。

• Vector是线程安全的。

3. 性能：

• 随机访问时，ArrayList性能较好。

• 频繁插入和删除时，LinkedList性能较好。

• Vector在某些情况下性能可能相对较低。

4. 扩容机制：

• ArrayList和Vector都有扩容机制，ArrayList是1.5倍扩容，Vector是两倍扩容。
• LinkedList是一个双向链表，没有初始化大小，也没有扩容的机制，就是一直在前面或者后面新增就好。

21、HashMap、Hashtable和ConcurrentHashMap的区别？

1. 线程安全性：

• HashMap 是非线程安全的。
• Hashtable 是线程安全的，但效率较低。
• ConcurrentHashMap 是线程安全的，支持高并发环境。

2. 性能：

• 一般情况下，HashMap 的性能较好，Hashtable 由于线程安全的实现，性能相对较差，ConcurrentHashMap
  在保证线程安全的同时，性能也比较优秀。

3. null 值：

• HashMap 允许键和值为 null。

• Hashtable 不允许键和值为 null。

• ConcurrentHashMap 允许键为 null，但不允许值为 null。

22、HashMap的初始化，put流程，get流程，扩容流程说明

推荐参考：ArrayList 和 HashMap 源码解析

初始化：

• HashMap 在创建时可以指定初始容量和负载因子。
• 如果没有指定，默认初始容量为 16，负载因子为 0.75。

put 流程：

• 计算键的哈希值。

• 根据哈希值确定存储位置（通过取模运算）。

• 如果该位置没有元素，直接插入。

• 如果该位置已有元素，判断是否与要插入的键相等，若相等则更新值；否则形成链表结构。

get 流程：

• 计算键的哈希值。

• 根据哈希值找到对应的存储位置。

• 在该位置遍历链表或直接返回对应的值。

扩容流程：

• 当元素数量超过当前容量与负载因子的乘积时，进行扩容。
• 扩容时，创建一个新的容量为原来两倍的数组，并将原数组中的元素重新哈希并迁移到新数组中。

23、HashMap、HashSet、ArrayList是线程安全的吗？

HashMap、HashSet和ArrayList都不是线程安全的。

24、创建线程的几种方式？

继承Thread类、实现Runnable接口、使用线程池

25、线程同步的方式有哪些方式？

synchronized关键字、加锁、volatile、原子类

26、synchronized如何使用？加在普通方法上和加在静态方法的区别？

当 synchronized 关键字加在普通方法上时，它会锁定对象实例；而加在静态方法上时，它锁定的是类的Class对象。让我通过一个简单的Java类来说明这两种情况。

public class SynchronizedExample {
    // 用于演示锁定对象实例的普通方法
    public synchronized void synchronizedMethod() {
        // 同步的操作
    }

    // 用于演示锁定类的Class对象的静态方法
    public static synchronized void synchronizedStaticMethod() {
        // 同步的操作
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11

现在我们创建两个线程来演示这两种情况：

public class Main {
    public static void main(String[] args) {
        final SynchronizedExample example = new SynchronizedExample();

        // 在普通方法上加锁的示例
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                example.synchronizedMethod();
            }
        });

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                example.synchronizedMethod();
            }
        });

        // 在静态方法上加锁的示例
        Thread thread3 = new Thread(new Runnable() {
            @Override
            public void run() {
                SynchronizedExample.synchronizedStaticMethod();
            }
        });

        Thread thread4 = new Thread(new Runnable() {
            @Override
            public void run() {
                SynchronizedExample.synchronizedStaticMethod();
            }
        });

        // 启动线程
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41

在这个例子中，thread1和thread2演示了加在普通方法上的 synchronized 关键字，它们都是针对同一个SynchronizedExample对象实例的。
thread3和thread4演示了加在静态方法上的 synchronized 关键字，它们是针对SynchronizedExample类的Class对象的。
在静态方法上使用 synchronized 关键字时，该关键字锁定的是类的 Class 对象，而不是类的实例对象。这种机制保证了无论类的实例有多少个，同一时刻只能有一个线程执行该类的静态 synchronized 方法，从而确保了对静态方法的同步访问。

springMVC中的service是单例的，因此在service的实现类impl中加 synchronized 关键字，也能使controller层的请求排队。

27、java级别的锁都有哪些？你怎么分类？

推荐参考：java锁介绍

28、什么情况下需要对对象进行序列化？

对象序列化是一个将对象状态转换为字节流的过程，主要用于实现对象的完全保存或网络传输。当需要满足以下场景时，通常需要对对象进行序列化：

• 网络传输：在分布式系统中，对象经常需要在不同的进程或机器之间进行传输。为了在网络中有效地传输对象，需要将对象序列化为字节流，以便在接收端进行反序列化并恢复为原始对象。
• 数据备份和恢复：当需要将对象状态保存在计算机中以备将来使用时，序列化是一种有效的手段。通过序列化，可以方便地将对象保存到文件或数据库中，以便在需要时进行恢复。
• 持久化存储：序列化是实现对象持久化存储的一种常见方法。通过将对象序列化为字节流并保存到文件中，可以确保对象状态的长期保存，即使程序关闭或重启后也能恢复对象状态。

29、什么是AIO、BIO和NIO？

AIO、BIO和NIO都是IO模型，它们在处理输入输出操作时具有不同的特点和适用场景。

BIO（Blocking I/O）：

• BIO是同步阻塞I/O模型。在BIO方式中，一个连接对应一个线程。当客户端发起连接请求后，服务端就需要启动一个线程进行处理。如果这个连接不做任何事情就会造成不必要的线程开销。这种方式的缺点在于，如果有大量客户端并发请求，就需要创建大量的线程来处理，这将导致系统资源的大量消耗，严重情况下甚至会导致系统崩溃。BIO方式适用于连接数量少且固定的场景。

NIO（Non-blocking I/O）：

• NIO是同步非阻塞IO模型。它引入了通道（Channel）和缓冲区（Buffer）的概念。数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。这种模型允许一个线程要求一个通道将数据读入一个缓冲区，在数据从通道读入缓冲区的期间，这个线程可以进行其他操作，直到数据完成从通道读入到缓冲区时，线程再继续处理它。数据从缓冲区写入通道时也是如此。此外，NIO还引入了选择器的概念，使得一个线程可以监听多个通道的数据传输情况。NIO适用于连接数目多且业务比较轻的场景，如聊天服务器。

AIO（Asynchronous I/O）：

• AIO是异步非阻塞IO模型。在JDK1.7之后，Java提供了异步的相关通道实例。AIO的最大特点是具备异步功能，需要借助操作系统，当底层操作系统具有异步IO模型时，AIO可以在对应的read/write/accept/connection等方法上异步执行，完成后会主动调用回调函数，实现一个CompletionHandler对象。AIO消除了用户态和内核态的切换耗时，使多任务的发展更加容易。此外，它的缓冲机制使得不同的文件读写有更少的线程切换和上下文引起的性能损失。AIO适用于连接数目多且连接比较长（业务重操作）的场景，需要操作系统充分参与并发操作。

 篇幅限制下面就只能给大家展示小册部分内容了。这份面试笔记包括了：Java面试、Spring、JVM、MyBatis、Redis、MySQL、并发编程、微服务、Linux、Springboot、SpringCloud、MQ、Kafka 面试专题

需要全套面试笔记【点击此处】即可免费获取

33、volatile能保证原子性吗？为什么？

不可以，volatile 关键字能够保证变量的可见性，但是不能保证原子性。

在没有使用 volatile 关键字的情况下，当一个线程修改了变量的值，这个修改之后的值会先被保存在线程的工作内存中，并不会立即刷新到主内存中。这是由于 CPU 和内存优化的特性所决定的。

数据最终会从线程的工作内存刷新到主内存中，但具体刷新的时间并没有明确定义。这取决于底层的架构、CPU 的具体行为，以及 JVM 和编译器应用的各种优化。