别人的tx后台开发面经

1.hashmap和treemap底层

HashMap和TreeMap是Java中两种常见的映射（Map）实现，它们具有不同的底层结构和性质。

1. HashMap：
   - 底层结构：HashMap使用哈希表（Hash Table）作为底层数据结构，通过哈希函数将键映射到对应的存储位置。每个存储位置称为桶（Bucket），每个桶可以存储一个或多个键值对（Entry）。
   - 时间复杂度：HashMap的插入、删除和查找操作的平均时间复杂度为O(1)，具有很高的效率。但在散列冲突较多时，操作的时间复杂度可能会升至O(n)。
   - 线程安全性：HashMap是非线程安全的，多个线程同时对HashMap进行操作可能导致不一致的结果。如果需要在多线程环境中使用HashMap，可以使用Collections工具类的synchronizedMap方法或者使用ConcurrentHashMap。

2. TreeMap：
   - 底层结构：TreeMap使用红黑树（Red-Black Tree）作为底层数据结构，它是一种自平衡的二叉搜索树。TreeMap通过键的自然顺序或自定义比较器对键进行排序存储。
   - 时间复杂度：TreeMap的插入、删除和查找操作的时间复杂度为O(log n)，其中n为元素的数量。由于红黑树的自平衡性质，TreeMap在保持有序的同时具有较高的效率。
   - 线程安全性：TreeMap也是非线程安全的，多个线程同时对TreeMap进行操作可能导致不一致的结果。如果需要在多线程环境中使用TreeMap，可以使用Collections工具类的synchronizedSortedMap方法或者使用ConcurrentSkipListMap。

总结：HashMap和TreeMap的底层结构不同，HashMap使用哈希表，而TreeMap使用红黑树。HashMap的插入、删除和查找操作具有较高的效率，而TreeMap的操作具有较稳定的O(log n)时间复杂度。它们都是非线程安全的，如果需要在多线程环境中使用，可以考虑使用线程安全的替代实现，如ConcurrentHashMap和ConcurrentSkipListMap。

2.currentHashMap是线程安全吗 如何实现线程安全

是的，ConcurrentHashMap是线程安全的。它是Java中提供的并发容器之一，专门设计用于在多线程环境中进行高效且安全的并发操作。

ConcurrentHashMap实现了线程安全的并发访问机制，主要通过以下几个方面来实现线程安全性：

1. 分段锁：ConcurrentHashMap内部采用了分段锁（Segment）的机制，将整个哈希表分成多个小的段（Segment），每个段维护自己的一部分桶（Bucket），不同的段可以被不同的线程同时访问，从而提高并发度。

2. 锁分离：每个段（Segment）都可以被独立地锁定，即对于不同的段，可以并发地进行操作，这样在多线程环境下，不同线程可以同时对不同的段进行读写操作，提高了并发性能。

3. 原子操作：ConcurrentHashMap内部使用了原子操作，保证了对桶中键值对的读写操作的原子性，避免了数据不一致的问题。

通过上述机制，ConcurrentHashMap实现了高效且线程安全的并发访问。它允许多个线程同时进行读取操作，而对于写入操作，只需要锁定特定的段，而不需要锁定整个哈希表，从而提供了更好的并发性能。

在JDK 8及之后的版本中，ConcurrentHashMap引入了基于CAS（Compare and Swap）的并发控制机制，用于替代了之前的分段锁机制。具体而言，JDK 8引入了"扩容"和"链表转红黑树"等优化，以及基于CAS的无锁并发算法。

新版的ConcurrentHashMap采用了分段的数组（Segment Array）作为底层数据结构，每个分段内部使用了CAS操作来实现并发安全。这种设计使得不同的线程可以同时访问不同的分段，从而提供更好的并发性能。

3.内存溢出和内存泄漏

内存溢出（Memory Overflow）和内存泄漏（Memory Leak）是两种不同的内存相关问题：

1. 内存溢出（Memory Overflow）： 内存溢出指的是程序在申请内存时，没有足够的内存可供分配，导致无法继续正常执行。这通常发生在以下情况下：

   • 分配过大的对象或数据结构，超过了可用内存的限制。
   • 创建了过多的对象，耗尽了可用内存。
   • 持续运行的程序产生了大量的临时对象，导致堆内存不断增长。
   • 内存泄漏导致可用内存逐渐减少，最终耗尽。

2. 内存泄漏（Memory Leak）： 内存泄漏指的是程序中已经不再使用的内存没有被正确释放或回收，导致这部分内存无法再被程序重新利用。内存泄漏可能导致内存的逐渐减少，最终耗尽系统资源。常见的内存泄漏情况包括：

   • 对象被创建后，占用的内存没有被释放。
   • 对象被长时间引用，无法被垃圾回收机制回收。
   • 对象被意外地保留在集合或缓存中，无法被释放。
   • 循环引用或强引用导致一组对象无法被垃圾回收。

内存溢出和内存泄漏都会导致程序执行的异常或不可预测的结果。为了避免内存溢出和内存泄漏问题，需要注意合理管理内存资源，确保及时释放不再使用的对象，并尽量避免过多的内存分配和持续产生临时对象。此外，使用工具进行内存分析和性能优化也是很重要的。

解决内存溢出和内存泄漏问题通常需要进行以下步骤：

1. 内存溢出的解决：

   • 增加可用内存：可以通过增加JVM的堆内存限制（通过-Xmx和-Xms参数），或者增加物理内存来解决内存溢出问题。
   • 优化内存使用：检查程序中是否存在大内存占用的对象或数据结构，考虑对其进行优化，减少内存消耗。
   • 及时释放资源：确保程序中及时释放不再使用的对象，避免无用的内存占用。
   • 检查内存泄漏：排查是否存在内存泄漏问题，通过内存分析工具等方式找出造成内存溢出的具体原因。

2. 内存泄漏的解决：

   • 审查代码：仔细审查代码，检查是否有资源未正确关闭、对象未正确释放等情况。特别关注长时间持有资源或者集合的地方。
   • 使用弱引用或软引用：在某些情况下，可以使用弱引用（Weak Reference）或软引用（Soft Reference）来持有对象，使得对象在不再被强引用引用时能够被垃圾回收机制自动回收。
   • 避免循环引用：确保对象之间没有循环引用的情况，以便垃圾回收机制能够正确回收不再使用的对象。
   • 使用适当的数据结构：使用合适的集合或缓存数据结构，并注意在适当的时候移除不再需要的元素，避免无用的对象一直被保留。

此外，使用内存分析工具可以帮助定位内存泄漏的具体原因，例如通过查看堆内存快照（Heap Dump）分析对象的引用关系、查看对象的生命周期等。通过综合使用以上方法和工具，可以有效地解决内存溢出和内存泄漏问题。

4.递归会造成栈溢出，循环为什么不会

递归会造成栈溢出的主要原因是每次递归调用都会在调用栈上创建一个新的栈帧，而栈的大小是有限的。如果递归的深度过大，就会导致栈空间被耗尽，从而引发栈溢出异常。

循环不会造成栈溢出的原因是循环的执行过程并不会创建新的栈帧，而是在同一个栈帧中进行迭代。每次循环迭代只需要保存迭代过程中的变量状态，并没有创建新的函数调用栈。因此，循环的内存消耗相对较小，不会出现栈溢出的问题。

需要注意的是，循环也需要考虑迭代的次数和循环体内部的内存消耗。如果循环次数过大或者循环体内部有大量的内存消耗操作，仍然可能导致内存溢出的问题。因此，在编写循环代码时，仍然需要谨慎地处理内存资源，确保循环体内部的操作不会占用过多的内存或导致内存泄漏。

5.CAS怎么解决ABA问题

CAS（Compare and Swap）是一种基于原子性操作的并发控制机制，用于解决多线程环境下的数据竞争问题。然而，CAS机制本身无法解决ABA问题。

ABA问题指的是在多线程环境中，一个共享变量的值从A变为B，然后又从B变回A，但是期间可能发生了其他的变化，导致某些操作产生错误的结果。

为了解决ABA问题，可以使用版本号（Version Number）或标记（Mark）来确保原子操作的正确性。具体的做法是，在共享变量的值上增加一个额外的标记或版本号，每次变化时都更新标记或版本号。这样，在进行CAS操作时，除了比较值是否相等外，还要比较标记或版本号是否一致。

以下是解决ABA问题的一种常见方法：

1. 使用AtomicStampedReference类： AtomicStampedReference是Java中提供的一个原子类，它可以在CAS操作中使用一个额外的整数标记。该标记用于记录共享变量的变化次数或版本号。每次变化时，都需要同时更新共享变量的值和标记。

   示例代码：

AtomicStampedReference reference = new AtomicStampedReference<>(initialValue, initialStamp);

// ...

int[] stampHolder = new int[1];
while (true) {
    int currentValue = reference.get(stampHolder);
    int currentStamp = stampHolder[0];

    // 进行业务操作...

    int newStamp = currentStamp + 1;
    if (reference.compareAndSet(currentValue, newValue, currentStamp, newStamp)) {
        // CAS操作成功
        break;
    }
}

通过使用AtomicStampedReference类，可以在CAS操作中添加额外的标记或版本号，从而解决ABA问题。每次CAS操作都会比较共享变量的值和标记，确保操作的正确性。

6.mysql中InnoDB索引底层结构

在MySQL中，InnoDB引擎使用B+树作为索引的底层数据结构。B+树是一种多路平衡查找树，它具有以下特点：

1. 平衡性：B+树是一棵平衡树，保持了所有叶子节点的深度相同，从根节点到叶子节点的路径长度相等。这样可以确保在进行索引查找时，查询的时间复杂度近似为O(log n)。

2. 有序性：B+树中的节点按照键值大小有序存储，使得范围查询和排序操作更加高效。

3. 多路性：B+树的每个节点可以存储多个键值和对应的数据指针，这样可以减少磁盘I/O操作次数，提高查询效率。

4. 叶子节点存储数据：B+树的叶子节点存储了所有的数据记录，而非叶子节点仅存储键值和指向子节点的指针。这种结构使得范围查询更加高效，并且支持顺序遍历。

在InnoDB中，每个表都会有一个主键索引，如果没有显式指定主键，则InnoDB会自动创建一个隐藏的6字节大小的ROWID作为主键。除主键索引外，InnoDB还支持创建唯一索引和普通索引，它们都使用B+树作为底层数据结构。

需要注意的是，InnoDB引擎还支持辅助索引（Secondary Index）和聚簇索引（Clustered Index）。辅助索引是基于主键索引构建的，存储了键值和对应的主键值，用于辅助快速定位数据记录。聚簇索引是指将数据记录直接存储在索引树中，可以根据聚簇索引快速定位数据，并且避免了额外的查找操作。

综上所述，InnoDB索引的底层结构是基于B+树的多路平衡查找树，它提供了高效的索引存储和查询功能，支持主键索引、唯一索引、普通索引、辅助索引和聚簇索引。这些索引结构和特性使得InnoDB在处理大量数据和高并发访问时具有良好的性能和可扩展性。

7.为什么用建议用自增ID作索引而不用UUID

UUID（Universally Unique Identifier）是一种标识符，用于唯一标识信息。它是一个128位的值，通常以36个字符的字符串形式表示，例如："550e8400-e29b-41d4-a716-446655440000"。

UUID的生成算法是根据一定规则在全球范围内保证唯一性。UUID的唯一性是基于以下几个因素：

1. 当前时间戳：UUID的一部分是基于当前时间的，确保在不同时间生成的UUID不会重复。

2. MAC地址：UUID的一部分包含了计算机的MAC地址，用于区分不同计算机上生成的UUID。

3. 随机数：UUID的一部分是随机生成的，增加了生成UUID时的唯一性。

UUID的唯一性保证了在大部分情况下生成的UUID不会重复，即使在不同的计算机上生成也是如此。因此，UUID经常被用作标识符，特别是在分布式系统中需要生成全局唯一标识符的场景下。

在编程和数据库中，我们可以使用相应的函数或库来生成UUID，例如在Java中可以使用java.util.UUID类来生成UUID。UUID的使用场景包括唯一标识数据库记录、生成会话标识、文件命名、分布式系统中的消息传递等。

在数据库中使用自增ID作为索引的主要原因是其性能和存储效率优势，而不是使用UUID。

1. 性能：自增ID是按顺序递增的整数，可以更高效地维护索引的结构和查找数据。由于数据在磁盘上的物理存储通常也是有序的，使用自增ID作为索引可以减少磁盘I/O操作次数，提高查询效率。此外，自增ID还可以更好地利用数据库的缓存机制，减少缓存碎片和冲突。

2. 存储效率：自增ID通常只需要占用较少的存储空间，比如使用整数类型（如INT或BIGINT），而UUID通常需要使用较长的字符串类型（如CHAR(36)），占用更多的存储空间。在大规模数据存储的场景下，使用自增ID可以节省大量的存储空间，减少数据库的存储压力和成本。

相比之下，使用UUID作为索引存在以下一些劣势：

1. 性能：UUID是全局唯一标识符，它的值是随机生成的，没有顺序性，因此对于索引的维护和查询会导致更多的磁盘I/O操作。UUID的无序性也增加了缓存碎片和冲突的可能性，影响了数据库的性能。

2. 存储效率：UUID通常需要使用较长的字符串类型来存储，占用更多的存储空间。对于包含UUID的索引字段，它的存储和索引结构会变得更大，导致索引占用更多的存储空间，降低存储效率。

虽然UUID作为索引也有其适用的场景，比如需要在分布式系统中生成全局唯一标识符或需要保护数据隐私等情况下，但在一般的数据库应用中，使用自增ID作为索引更为常见和推荐，可以获得更好的性能和存储效率。

8.A向B发送3个100MB的数据 怎么确保B准确收到

要确保B准确接收到A发送的3个100MB的数据，可以采取以下步骤：

1. 数据分割：将100MB的数据分割成适当的数据包或分片，以便发送和接收。

2. 发送确认：A发送每个数据包后，等待B发送确认消息来确认接收。如果A在一定时间内没有收到确认消息，可以进行重传。

3. 序号和校验：在每个数据包中添加序号和校验信息。序号用于确保数据包的顺序，并帮助识别缺失的数据包。校验信息可以使用校验和或其他错误检测机制，以确保数据包的完整性。

4. 流控制和拥塞控制：在发送过程中，可以使用流控制和拥塞控制机制来控制发送速率，以防止数据包的丢失和网络拥塞。

5. 数据包确认：B接收到每个数据包后，发送确认消息给A。确认消息中可以包含已接收到的数据包的序号，以便A知道哪些数据包已成功接收。

6. 重传机制：如果B在一定时间内没有收到某个数据包或发现某个数据包有错误，可以向A发送重传请求，要求重新发送该数据包。

7. 完整性校验：一旦B接收到所有数据包，可以对整个数据进行完整性校验，例如使用哈希函数计算校验和，确保数据的完整性。

通过以上步骤，可以在发送端和接收端之间建立可靠的数据传输通道，确保B准确接收到A发送的3个100MB的数据。这样可以保证数据的完整性和可靠性，并允许进行必要的重传和校验。

9.TCP流量控制

TCP（Transmission Control Protocol）提供了一种流量控制机制，用于在网络通信中控制数据的传输速率，以避免发送方发送过多的数据而导致接收方无法及时处理。

TCP流量控制的主要目的是确保发送方和接收方之间的数据传输平衡，防止数据的丢失和网络拥塞。以下是TCP流量控制的基本原理和机制：

1. 滑动窗口（Sliding Window）：TCP使用滑动窗口机制来控制发送方发送数据的速率。发送方和接收方都维护一个窗口大小（Window Size），表示接收方可以接收的数据量。发送方根据接收方提供的窗口大小来确定发送的数据量，以确保在接收方的处理能力范围内进行数据传输。

2. 接收方通告窗口大小（Receiver Window）：接收方在TCP报文中的ACK（确认）中通告发送方自己的窗口大小，即可以接收的数据量。发送方根据接收方通告的窗口大小来控制发送的数据量。

3. 拥塞窗口（Congestion Window）：TCP还引入了拥塞控制机制，用于监测网络拥塞情况并调整发送速率。发送方根据网络的拥塞程度动态调整发送的数据量，以避免网络拥塞导致数据丢失和性能下降。

4. 延迟确认（Delayed Acknowledgement）：接收方在收到数据后，并不立即发送ACK确认，而是等待一段时间，如果没有收到更多的数据，则发送ACK。这样可以减少发送的ACK数量，提高网络传输效率。

通过上述机制，TCP流量控制可以使发送方根据接收方的处理能力和网络状况动态调整发送速率，避免发送过多的数据，保证数据传输的平衡和稳定性。这样可以有效地防止数据的丢失、数据堆积和网络拥塞，提高数据传输的可靠性和效率。

10.Socket编程

Socket编程是一种网络编程技术，用于在计算机网络上进行数据传输和通信。它通过使用Socket套接字，提供了一种编程接口和机制，使得应用程序能够建立网络连接、发送和接收数据。

Socket编程通常涉及两个主要角色：客户端和服务器。

1. 客户端（Client）：客户端是发起连接的一方。它创建一个Socket对象，通过指定目标服务器的IP地址和端口号来建立与服务器的连接。客户端可以发送请求到服务器并接收服务器的响应。

2. 服务器（Server）：服务器是接受连接的一方。它创建一个ServerSocket对象，并在指定的端口上监听客户端的连接请求。一旦接受到客户端的连接请求，服务器会创建一个新的Socket对象，与客户端建立连接，并进行数据的交互。

Socket编程的基本流程如下：

1. 服务器端创建ServerSocket对象，并指定要监听的端口号。
2. 服务器端调用ServerSocket的accept()方法，等待客户端的连接请求。
3. 客户端创建Socket对象，并指定要连接的服务器的IP地址和端口号。
4. 客户端调用Socket的connect()方法，与服务器建立连接。
5. 服务器端接受到客户端的连接请求后，创建一个新的Socket对象与客户端建立通信。
6. 服务器端和客户端可以通过Socket对象进行数据的传输和通信。
7. 数据传输完成后，可以关闭Socket连接。

Socket编程可以实现不同计算机之间的网络通信，可以在同一台计算机的不同进程之间进行通信，也可以在不同计算机之间的不同进程之间进行通信。它提供了一种简单、灵活和可靠的方式来实现网络通信需求，广泛应用于各种网络应用程序和系统中。

介绍一下参加比赛的项目 实现了什么功能 个人职责
使用过的技术
平时有没有使用到多线程
11.进程和线程共享的区域

进程和线程是操作系统中的概念，它们在执行程序时具有不同的特性和资源分配方式。在多线程的程序中，线程是进程的一部分，它们共享某些资源和区域。

1. 内存空间：进程中的所有线程共享同一地址空间，它们可以访问相同的变量、对象和数据结构。这意味着线程可以直接读取和修改进程中的全局变量，实现数据的共享。

2. 文件描述符：文件描述符是进程打开的文件、网络连接等的引用。在多线程程序中，进程打开的文件描述符在所有线程之间是共享的，因此可以在不同线程之间共享打开的文件。

3. 系统资源：进程中的线程共享一些系统资源，如打开的文件、网络连接、定时器等。这意味着线程可以通过共享的系统资源相互通信和同步。

4. 信号处理器：进程中的信号处理器通常被所有线程共享。当操作系统发送信号时，可以由任何线程中的信号处理器处理。

然而，进程和线程也有一些私有的区域和资源，它们是各自独立的：

1. 栈空间：每个线程拥有自己的栈空间，用于存储局部变量和函数调用的上下文信息。线程的栈空间是私有的，不与其他线程共享。

2. 寄存器和程序计数器：每个线程有自己的寄存器和程序计数器，用于保存线程的执行状态和当前指令的位置。

3. 线程特定数据：线程可以拥有自己的线程特定数据，它们是线程私有的，不与其他线程共享。

总之，进程和线程共享的区域包括内存空间、文件描述符、系统资源和信号处理器。这些共享区域使得线程之间可以共享数据和资源，实现并发编程和线程间的通信。同时，进程和线程也有各自的私有区域，用于保存线程的上下文信息和私有数据。

12.如何实现进程通信

在操作系统中，进程通信（IPC，Inter-Process Communication）是指不同进程之间进行数据交换和通信的机制。以下是几种常见的进程通信的方式：

1. 管道（Pipe）：管道是一种半双工的通信方式，适用于具有亲缘关系的父子进程间通信。在Linux中，使用pipe()系统调用创建管道，父进程和子进程可以通过管道进行数据的读取和写入。

2. 命名管道（Named Pipe）：命名管道也是一种管道，但可以用于不具有亲缘关系的进程间通信。它在文件系统中有一个唯一的名字，进程通过打开这个命名管道来进行通信。

3. 共享内存（Shared Memory）：共享内存是一种高效的进程通信方式，它允许多个进程共享同一块内存区域。进程可以直接访问这块共享内存，无需进行复制和数据传输。

4. 消息队列（Message Queue）：消息队列是一种在进程之间传递消息的机制，它将消息保存在一个队列中，接收进程可以按照特定的优先级顺序获取消息。

5. 信号量（Semaphore）：信号量用于实现进程之间的同步和互斥，多个进程可以通过信号量来控制对共享资源的访问。

6. 套接字（Socket）：套接字是一种用于网络通信的进程间通信机制，它可以在不同主机上的进程之间进行通信。

7. 文件（File）：进程可以通过读写文件来进行通信，多个进程可以共享同一个文件。

这些进程通信的方式各有优劣，选择合适的通信方式取决于具体的应用场景和需求。在实际应用中，通常需要结合不同的通信方式来满足复杂的通信需求。

13.进程从内存中读取100MB要读几次

当一个进程从内存中读取100MB的数据时，读取的次数取决于多个因素，包括硬件和操作系统的配置、内存管理机制以及文件系统的缓存机制等。以下是一些可能的情况：

1. 如果进程所需的数据已经完全在内存中，并且可以一次性读取到进程的缓冲区中，则只需要一次读取操作即可。

2. 如果进程所需的数据只部分在内存中，而另一部分在磁盘或其他存储介质中，则需要多次读取操作。读取的次数取决于每次读取的数据块大小和内存的可用空间。

3. 如果操作系统使用了文件系统缓存或磁盘缓存，那么部分数据可能已经被缓存到内存中，进程可以通过较少的读取操作从缓存中获取数据。

4. 如果操作系统采用了预读取机制，它可能会在进程请求读取数据之前提前读取一部分数据到内存中，从而减少后续的读取次数。

综上所述，读取100MB的数据可能需要多次读取操作，具体的读取次数取决于多个因素。在现代计算机系统中，内存和硬件的性能通常很高，操作系统也会进行一定的优化，因此通常可以快速读取大量数据。

要读取100MB的数据，读取次数取决于每次读取的数据量和系统的内存管理机制。

通常情况下，内存的数据传输是按照块（block）的方式进行的。每个块的大小可以是固定的，例如4KB、8KB等，也可以根据系统的设置和需求进行调整。假设我们采用4KB的块大小，那么要读取100MB的数据，需要进行的读取次数可以通过以下计算得到：

100MB = 100 * 1024KB = 102400KB

每次读取4KB，所以需要读取的次数为：

102400KB / 4KB = 25600次

因此，对于4KB的块大小，需要进行25600次读取才能读取完100MB的数据。

需要注意的是，实际的读取次数可能会受到操作系统、文件系统和硬件等因素的影响。系统可能会进行一些优化和缓存，使得数据的读取效率更高。此外，还可能存在其他的因素，如磁盘速度、IO操作的开销等，也会对读取次数产生影响。因此，上述计算只是一个简单的估算，实际情况可能会有所不同。

14.操作系统内存态和用户态

在操作系统中，内存态（Memory Mode）和用户态（User Mode）是两个关键概念，用于描述操作系统内核和用户程序之间的执行环境和权限级别。

1. 内存态（Memory Mode）：
   - 内存态是操作系统内核执行的一种特权级别。在内存态下，操作系统内核具有最高的权限和访问系统资源的能力。
   - 内存态下，操作系统内核可以执行特权指令、访问受保护的硬件资源和内存区域，进行底层的系统操作和管理。
   - 内存态下的代码和数据通常被称为内核空间（Kernel Space），只有操作系统内核才能直接访问和操作。

2. 用户态（User Mode）：
   - 用户态是用户程序执行的一种权限级别。在用户态下，用户程序的权限和访问能力受到限制。
   - 用户态下，用户程序无法直接执行特权指令、访问受保护的硬件资源和内存区域。
   - 用户态下的代码和数据通常被称为用户空间（User Space），用户程序在这个空间中运行。

操作系统通过将处理器的运行状态从内存态切换到用户态，以及从用户态切换到内存态，来控制内核和用户程序的执行环境和权限。

当用户程序执行时，它处于用户态，只能访问用户空间中的资源，不能直接操作底层的系统资源。当用户程序需要访问系统资源或执行特权操作时，例如发起系统调用、申请内存、进行输入输出操作等，它必须通过触发异常或中断的方式从用户态切换到内存态，进入操作系统内核执行相应的操作。完成后，又将控制权从内存态切换回用户态，继续用户程序的执行。

这种内存态和用户态的切换机制有效地保护了操作系统内核的安全性和稳定性，防止用户程序对系统造成不良影响，并提供了对系统资源的合理分配和管理。

反问
15.两个编程题：快排+查找链表的中间节点

排序：https://blog.csdn.net/guorui_java/article/details/122972781

查找中间节点：快慢指针

还会更新...