网易雷火游戏服务器，问得很多。。

大家好，我是阿Q。

中秋国庆假期就这样结束了，大家还好吗？

哈哈，好与不好都应该好！明天就都复工了，你也要时刻准备着了、、、

所以这么晚打扰大家了。

前面一段时间就都是后端方向的面经，今天给大家分享一个游戏开发的面经，我只能说还得是网易雷火，问得还是很有难度的。

不妨点个关注和收藏慢慢看？

正文：

来源： 

https://www.nowcoder.com/feed/main/detail/989dec68491240bd984c1891c3ba61ae

一面  

1. Docker 利用 Linux 命名空间技术，如PID 命名空间、网络命名空间、文件系统命名空间等，来隔离不同容器的进程、网络、文件系统等资源。每个容器都有自己独立的命名空间，使得它们看起来像是在一个独立的虚拟环境中运行。
2. 控制组（Cgroups）是 Linux 内核的一个特性，允许你限制和管理进程的资源使用，如 CPU、内存、磁盘、网络带宽等。Docker 使用 Cgroups 来确保容器在运行时不会耗尽系统资源，同时也允许你为容器分配适当的资源。
3. Docker 使用联合文件系统来创建容器的文件系统。它采用了一种写时复制（Copy-on-Write）的机制，使得容器可以共享基础镜像的文件，同时在容器内对文件进行修改时，只会在需要的时候复制，以减少存储空间的占用。
4. Docker 镜像是容器的基础，它包含了应用程序的代码、运行时所需的库和依赖项。Docker 镜像采用分层的结构，每个层次都是只读的，这使得镜像可以共享和重用。当你运行一个容器时，Docker 会在基础镜像上创建一个可写层，用于保存容器运行时的修改和数据。
5. Docker 守护进程是在宿主操作系统上运行的后台服务，负责管理容器的生命周期、镜像的构建与管理、网络配置等。用户通过 Docker 命令行工具或 API 与 Docker 守护进程进行交互，从而创建、运行和管理容器。
6. Docker 客户端是用户与 Docker 守护进程交互的接口。用户可以使用 Docker 客户端的命令行工具或图形界面工具来执行各种操作，例如创建容器、构建镜像、查看容器状态等。
7. Docker 镜像仓库是用于存储和分享 Docker 镜像的中央存储库。Docker Hub 是最知名的公共 Docker 镜像仓库之一，用户可以从中获取官方和社区维护的镜像。你也可以搭建自己的私有 Docker 镜像仓库，以便存储和分享自定义镜像。

1. 命名空间（Namespaces）：
1. PID 命名空间：每个容器都有自己独立的进程ID空间，这意味着容器内的进程无法看到或影响宿主系统或其他容器中的进程。
2. 网络命名空间：容器拥有独立的网络命名空间，这意味着每个容器都有自己的网络接口、IP地址和端口空间，从而实现了网络隔离。容器之间可以运行相同的网络端口，而不会发生冲突。
3. 挂载命名空间：容器的文件系统挂载是独立的，容器只能访问其自己的文件系统，不能访问其他容器的文件系统或宿主系统的文件系统。这保护了文件系统的隔离。
4. UTS 命名空间：每个容器都有自己的主机名和域名，这确保了容器内的应用程序不会意外地访问其他容器或宿主系统的主机名信息。
5. 用户命名空间：Docker 可以为每个容器创建独立的用户命名空间，使得容器内的用户和组信息在容器之间隔离，增强了安全性。
2. Cgroups 允许你限制和管理容器内的资源使用，包括 CPU、内存、磁盘和网络带宽等。通过设置适当的 cgroup 限制，Docker 可以确保容器不会耗尽宿主系统的资源。例如，你可以为容器分配一定的 CPU 核心数或内存限制。
3. Docker 使用联合文件系统来创建容器的文件系统。每个容器都有自己的可写层，用于保存容器运行时的修改和数据，而基础镜像是只读的。这使得容器可以共享基础镜像的文件，并且只有在需要时才会复制文件，以减少存储占用。这确保了文件系统的隔离。
4. Docker 提供多种网络驱动程序，包括 Bridge、Host、Overlay、Macvlan 等，这些驱动程序允许你在容器之间实现不同级别的网络隔离。每个容器都有自己的网络栈和独立的 IP 地址，使得容器之间可以互相通信，但也可以根据需要进行网络隔离。
5. Docker 提供了一系列安全配置选项，如 AppArmor、SELinux 等，可以帮助隔离容器的系统调用和访问权限，以增强容器的安全性。

1. CPU 分配：

• Docker 使用 Linux 内核的 Cgroups 功能来管理 CPU 资源的分配。你可以在运行容器时使用 --cpus
  参数来限制容器可以使用的 CPU 核心数量。例如，--cpus=2
  表示容器最多可以使用两个 CPU 核心。
• Docker 还支持 CPU 分配的权重和限制，可以通过设置 --cpu-shares
  （权重）和 --cpu-quota
  （限制）参数来调整容器对 CPU 的访问优先级和时间配额。

1. 内存分配：

• Docker 允许你为容器分配内存限制，使用 --memory
  参数来指定容器可以使用的最大内存量。例如，--memory=1g
  表示容器最多可以使用 1GB 的内存。
• 你还可以使用 --memory-swap
  参数来设置容器可以使用的虚拟内存大小。默认情况下，Docker 将 --memory
  和 --memory-swap
  设置为相同的值，以避免容器使用交换空间。

1. 磁盘分配：
1. Docker 允许你为容器分配磁盘空间，使用 --storage-opt
   参数来配置容器的存储选项。例如，你可以指定容器的数据卷大小或使用特定的存储驱动程序来管理容器的数据。
2. 网络带宽分配：
1. Docker 支持不同的网络驱动程序，你可以选择合适的网络驱动程序来满足容器的网络需求。例如，使用 Bridge 网络驱动程序将容器放置在一个独立的虚拟网络中，而 Host 网络驱动程序允许容器与宿主系统共享网络栈。
2. 你可以使用 --network
   参数来选择容器的网络配置，也可以通过 Docker Compose 或 Kubernetes 等工具配置容器的网络。
3. 资源限制：
1. Docker 还允许你设置容器的资源限制，以确保容器不会超出指定的资源限制。例如，你可以使用 --ulimit
   参数来设置容器的文件句柄限制、核心转储限制等。
4. 资源监控和管理：
1. Docker 提供了一系列命令和工具，如 docker stats
   和 docker events
   ，以监控容器的资源使用情况和性能。你可以使用这些工具来识别资源瓶颈，并根据需要调整容器的资源分配。

1. 内核空间（Kernel Space）：
1. 内核空间是操作系统内核运行的区域，其中包含了操作系统的内核代码和数据结构。这个区域通常占据了整个内存的一部分，它是操作系统的核心，用于管理系统的硬件资源和提供系统服务。
2. 内核空间用于分配系统资源，例如处理器、内存、设备驱动程序和文件系统等。它还包括了操作系统的各种缓冲区、页表和内核模块等。
2. 用户空间（User Space）：
1. 用户空间是分配给用户进程的区域，其中包含了用户应用程序的代码、数据和堆栈。用户进程在这个空间中运行，并且受操作系统的保护，以防止进程之间相互干扰。
2. 用户空间用于分配应用程序的资源，例如变量、堆内存、栈内存、共享库、堆栈等。每个用户进程都有自己的用户空间。
3. 栈（Stack）：
1. 栈是用户进程中用于存储函数调用、局部变量和函数参数的内存区域。栈是一种后进先出（LIFO）的数据结构，它以函数调用的方式管理数据。
2. 栈用于分配函数调用所需的局部变量和管理函数调用的调用栈。栈通常是有限大小的，过多的递归调用或栈溢出可能导致程序崩溃。
4. 堆（Heap）：
1. 堆是用户进程中用于动态分配内存的区域，它的大小通常是可变的。堆内存由程序员显式分配和释放，通常用于存储动态分配的对象、数据结构和缓冲区。
2. 堆用于分配动态分配的资源，例如通过 malloc()
   、free()
   和 new
   等函数或运算符进行的内存分配和释放。
5. 数据段（Data Segment）：
1. 数据段是用户进程中存储全局变量和静态变量的区域，它包括初始化的数据段（initialized data segment）和未初始化的数据段（uninitialized data segment）。
2. 数据段用于分配全局和静态变量的内存，这些变量在程序启动时分配，并在整个程序生命周期内保持不变。
6. 代码段（Code Segment）：
1. 代码段包含了程序的可执行代码，即应用程序的指令。它通常是只读的，防止代码被修改。
2. 代码段用于存储程序的指令，以便 CPU 执行程序的逻辑。

1. 语言差异：
1. new
   是 C++ 中的运算符，而不是 C 语言中的关键字。它用于动态分配内存并构造对象，通常与类（class）一起使用，用于在堆上创建对象。
2. malloc
   是 C 语言中的标准库函数，用于动态分配内存，但它只是分配内存块，不会调用构造函数初始化对象。
2. 类型差异：
1. new
   用于分配特定类型的对象，因此在分配内存时可以直接指定要创建的对象类型。例如，new int
   将分配用于整数的内存，而 new MyClass
   将分配用于自定义类对象的内存。
2. malloc
   只分配一块指定大小的内存块，不关心内存块中存储的数据类型。你需要使用类型转换来将分配的内存块解释为特定类型。
3. 构造和初始化：
1. new
   不仅分配内存，还会调用构造函数来初始化对象。这意味着通过 new
   分配的对象已经准备好使用，构造函数中的初始化代码已经执行。
2. malloc
   只是分配一块内存，不会自动调用构造函数。你需要手动初始化分配的内存块中的数据，这对于用户自定义类型（例如结构体或类）特别重要。
4. 内存管理：
1. new
   和 delete
   运算符是成对使用的，用于分配和释放对象的内存。例如，使用 new
   来分配内存，然后使用 delete
   来释放内存。
2. malloc
   和 free
   是成对使用的标准库函数，用于分配和释放内存块。例如，使用 malloc
   来分配内存，然后使用 free
   来释放内存。
5. 异常处理：
1. 如果 new
   在分配内存时失败（例如内存不足），它将引发 std::bad_alloc
   异常，你可以捕获并处理它。
2. 如果 malloc
   在分配内存时失败，它将返回 NULL
   指针，你需要检查返回值来处理内存分配失败的情况。

1. brk
   和 sbrk
   ：
1. brk
   和 sbrk
   是用于控制进程堆区大小的系统调用，通常用于实现动态内存分配。
2. brk
   调用可以将进程的堆区底部指针移动到指定位置，从而扩展或收缩堆区的大小。
3. sbrk
   调用可以增加或减少进程堆区的大小，它接受一个整数参数，表示要增加或减少的字节数。
2. mmap
   和 munmap
   ：
1. mmap
   和 munmap
   用于内存映射，通常用于实现动态内存分配和释放。
2. mmap
   调用可以将一个文件或匿名内存映射到进程的地址空间，也可以用于分配一块匿名内存（例如堆区）。
3. munmap
   调用用于取消内存映射，释放已映射的内存区域。

1. 初始化：在程序启动时，C/C++运行时库会初始化用于内存分配的数据结构和参数。这些数据结构用于跟踪已分配和可用的内存块，以及管理堆区大小。
2. 内存分配：
1. 当调用 malloc
   或 new
   时，运行时库会根据请求的内存大小，在内部数据结构中查找可用的内存块，或者使用系统调用来分配新的内存块。
2. 如果请求的内存大小小于一定的阈值，通常会使用 brk
   或 sbrk
   来扩展堆区，以满足内存需求。
3. 如果请求的内存大小较大，可能会使用 mmap
   来映射一块新的内存区域。
3. 内存管理：运行时库会维护一个数据结构，用于跟踪已分配和释放的内存块，以便在需要时进行内存的合并和回收。这有助于防止内存碎片化。
4. 内存释放：
1. 当调用 free
   或 delete
   时，运行时库会将相应的内存块标记为可用，以便将来重新分配。
2. 如果释放的内存块与堆区的边界相邻，并且没有其他内存块分配，可能会使用 brk
   或 sbrk
   来收缩堆区，以回收不再需要的内存。

• 大多数操作系统使用一种延迟分配策略，也称为按需分配。这意味着当你使用 new
  、malloc
  或类似的内存分配函数时，操作系统不会立即分配实际的物理内存。相反，它只会分配虚拟内存，并将内存的物理分配推迟到实际需要访问该内存时。
• 当你首次访问虚拟内存中的某个地址时，操作系统会触发页错误（Page Fault），然后根据需要将相应的物理内存分配给这个虚拟地址。这个过程称为页面调度（Page Fault Handling）。
• 有些情况下，虚拟内存的分配可能会与物理内存分配一起进行，例如当你使用 new
  或 malloc
  后立即对分配的内存进行写入操作时。在这种情况下，操作系统可能会立即分配并初始化相应的物理内存，以确保分配的内存在首次使用时是可用的。
• 当你使用内存映射函数（如 mmap
  ）来分配内存时，操作系统会根据需要将虚拟内存页映射到物理内存或交换空间中。这种映射通常是动态的，只有在你访问内存时才会发生。
• 如果物理内存不足，操作系统可能会将虚拟内存页移动到交换空间中，以释放物理内存供其他进程使用。这个过程通常会导致页面调度，即将虚拟内存页从交换空间移动到物理内存中，以响应进程的内存访问需求。

1. 段选择：
1. 首先，操作系统会使用虚拟地址中的一部分来选择要访问的段。每个段都是一个逻辑内存区域，用于存储不同类型的数据或代码，如代码段、数据段、堆、栈等。
2. 虚拟地址通常会包含一个段选择器或段描述符，该描述符用于标识虚拟地址属于哪个段。段选择器的值通常是一个索引，用于查找段描述符表。
3. 段描述符表中的段描述符包含了有关段的信息，包括段的起始地址、长度、权限位等。操作系统通过查找段描述符表中的相应描述符来确定虚拟地址所属的段。
2. 页内偏移：
1. 一旦确定了虚拟地址属于哪个段，接下来就需要使用虚拟地址中的另一部分，即页内偏移（Offset），来找到在该段中的确切位置。
2. 虚拟地址中的页内偏移通常用于计算数据在段内的位置。例如，对于代码段，页内偏移可以用于确定要执行的指令的位置；对于数据段，页内偏移可以用于找到要访问的数据项。
3. 页内偏移的值通常作为虚拟地址的一部分直接用于计算物理地址。
3. 物理地址计算：
1. 一旦完成了段选择和页内偏移的计算，操作系统就可以使用这些值来计算物理地址。
2. 物理地址通常是通过将段的起始地址与页内偏移相加来计算的。这个过程称为地址转换，它将虚拟地址映射到物理地址。

1. 一级页表（顶级页表）：
1. 一级页表也被称为页目录（Page Directory），它存储了指向二级页表的基地址。
2. 一级页表的大小通常是固定的，每个条目指向一个二级页表（或称页目录项）。
3. 一级页表的目的是将虚拟地址的高位部分映射到二级页表，根据这些高位部分来选择合适的页表。
2. 二级页表（中间页表）：
1. 二级页表也被称为页表（Page Table），它存储了指向物理内存页框的基地址。
2. 二级页表的大小通常也是固定的，每个条目对应一个物理内存页框。
3. 二级页表负责将虚拟地址的中间部分映射到物理内存页框，实现页级别的地址转换。
3. 三级页表（页表项）：
1. 三级页表是页表项，它存储了指向实际数据的物理地址的基地址。
2. 三级页表的大小通常是固定的，每个条目对应一个数据页。
3. 三级页表负责将虚拟地址的低位部分映射到实际的数据页，从而实现字节级别的地址转换。

1. 继承：
1. 多态的基础是继承，其中一个类（称为子类或派生类）可以继承另一个类（称为父类或基类）的属性和方法。
2. 子类通过继承从父类获得了一些通用的特性和行为，同时还可以在其自身中添加特定的属性和方法。
2. 虚函数：
1. 多态的核心是虚函数。虚函数是在基类中声明的函数，其行为可以在派生类中重写。
2. C++ 使用关键字 virtual
   来声明虚函数，而其他面向对象编程语言（如Java和C#）通常默认所有方法都是虚函数，不需要显式声明。
3. 当派生类重写基类中的虚函数时，派生类的实现将被调用而不是基类的实现。
3. 动态绑定：
1. 多态的一个关键特征是动态绑定，也称为运行时绑定。这意味着在运行时，程序会根据对象的实际类型来调用相应的方法，而不是根据变量的声明类型。
2. 这使得程序能够根据具体对象的特性来调用适当的方法，而不需要在编译时知道对象的确切类型。
4. 虚函数表（VTable）：
1. 为了实现动态绑定，大多数编译器在每个类对象的内部维护一个虚函数表（VTable）。这个表是一个指针数组，其中包含了虚函数的地址。
2. 对象的内存布局通常包括一个指向其类的虚函数表的指针。当调用虚函数时，程序会查找虚函数表，找到相应的函数地址，然后调用函数。
3. 派生类可以重写虚函数，并且它们的虚函数表中包含了它们自己的实现。这就实现了多态，因为在运行时，会调用派生类的实际虚函数。

1. 在基类中，通过使用 virtual
   关键字来声明一个虚函数。虚函数在基类中定义，但可以在派生类中重写（覆盖）。

class Animal {
public:
    virtual void makeSound() {
        cout << "Animal makes a sound" << endl;
    }
};

1. 派生类可以重写基类中的虚函数，为其提供自己的实现。这个过程被称为函数的覆盖（override）。

class Dog : public Animal {
public:
    void makeSound() override {
        cout << "Dog barks" << endl;
    }
};

1. 在使用多态时，通常会创建一个基类类型的指针或引用，并将其指向或引用派生类的对象。

Animal* animal = new Dog();

1. 动态绑定：
1. 当通过基类指针或引用调用虚函数时，实际调用的是对象的实际类型的虚函数，而不是基类的虚函数。
2. 这种动态确定要调用的方法的过程称为动态绑定（dynamic binding）或运行时多态。

animal->makeSound();  // 在运行时将调用 Dog 类的 makeSound() 方法

2. 运行时行为：
1. 在运行时，程序会根据实际对象的类型（Dog
   类）来调用相应的虚函数实现，而不是根据指针或引用的声明类型（Animal
   类）来调用。
2. 这使得程序能够在运行时根据对象的实际类型执行不同的行为，从而实现多态性。
3. 内部实现：
1. 为了支持动态多态，编译器通常会在对象的内部存储一个虚函数表（VTable）。这个表包含了虚函数的地址，以及其他用于支持动态绑定的信息。
2. 当调用虚函数时，程序会查找虚函数表中相应函数的地址，然后调用它。

1. 基类（父类）：
1. 在一个类层次结构中，通常是基类（父类）定义了虚函数。这些虚函数在基类中声明为虚函数，然后可以在派生类中被重写（覆盖）。
2. 基类的虚函数表包含了基类中的虚函数的地址。这个虚函数表通常是静态的，编译时就确定了。

class Animal {
public:
    virtual void makeSound() {
        cout << "Animal makes a sound" << endl;
    }
};

1. 派生类（子类）：
1. 派生类可以继承基类的虚函数，并且也可以重写（覆盖）这些虚函数。如果派生类重写了虚函数，它将在自己的虚函数表中有一个新的函数地址。
2. 派生类的虚函数表通常包括了从基类继承的虚函数的地址，以及它自己重写的虚函数的地址。

class Dog : public Animal {
public:
    void makeSound() override {
        cout << "Dog barks" << endl;
    }
};

2. 对象：
1. 对象不直接包含虚函数表。虚函数表的地址存储在对象内部的一个指针中，这个指针通常称为虚函数指针（VPtr）。
2. 虚函数指针指向对象所属类的虚函数表，这允许程序在运行时通过对象来查找和调用适当的虚函数。

Animal* animal = new Dog();

1. 静态成员函数：
1. 静态成员函数是与类关联而不是与类的实例关联的函数。它们与类本身直接相关，而不是与类的实例对象有关。静态成员函数的代码通常存储在程序的代码段（text segment）中，它们在内存中只有一份副本，不会被复制到每个类的实例中。
2. 虚函数：
• 虚函数表（Virtual Function Table，简称 vtable）：每个包含虚函数的类都有一个虚函数表，其中存储了指向虚函数的函数指针。虚函数表存储在类的静态存储区域（static storage）中，每个类只有一个虚函数表。
• 虚函数的实际代码：虚函数的实际代码存储在代码段（text segment）中，但通过虚函数表来访问。每个类的虚函数表中包含了指向各个虚函数的指针，这些指针指向实际的虚函数代码。
1. 虚函数是与类的实例对象关联的函数，它们用于实现多态性。虚函数的存储通常包括两部分：

• 静态成员函数存储在代码段中，与类的实例无关，只有一份副本。
• 虚函数的虚函数表存储在静态存储区域中，虚函数的实际代码存储在代码段中，通过虚函数表来实现多态性。虚函数的存储和调用与类的实例对象相关。

class Base1 {
public:
    void function1() { /* 实现1 */ }
};


class Base2 {
public:
    void function2() { /* 实现2 */ }
};


class Derived : public Base1, public Base2 {
public:
    void function3() { /* 派生类自己的实现 */ }
};

1. 二义性问题：
1. 最常见的问题是二义性（Ambiguity）。如果多个基类中有同名的成员函数或成员变量，编译器可能无法确定在派生类中调用哪个基类的成员。这种情况下，需要通过派生类的作用域来解决二义性，明确指定使用哪个基类的成员。
2. 虚继承：
1. 虚继承是一种解决多重继承问题的机制。在某些情况下，如果一个类需要从多个基类派生而来，并且这些基类之间存在继承关系，可以使用虚继承。虚继承可以避免多个基类在派生类中重复存在的问题，减少冗余。

class Base {
public:
    void commonFunction() { /* 通用功能 */ }
};


class Derived1 : public virtual Base {
public:
    void specificFunction1() { /* 派生类1特有功能 */ }
};


class Derived2 : public virtual Base {
public:
    void specificFunction2() { /* 派生类2特有功能 */ }
};


class MultipleDerived : public Derived1, public Derived2 {
public:
    // 可以直接使用 commonFunction，不会有二义性问题
};

1. 面向对象编程 (OOP):
1. OOP 是一种编程范式，它将数据（称为对象）和操作数据的方法（称为方法或函数）组合在一起，以创建一个具有特定行为和属性的对象。OOP 的核心概念包括类、对象、继承、封装和多态。
2. OOP 中，数据和方法通常封装在类中，类是对象的模板，对象是类的实例。通过类，可以创建多个对象，每个对象具有相同的属性和方法，但其数据可能不同。
3. OOP 的主要目标是模拟现实世界中的实体和它们之间的关系，以更容易地设计和维护复杂的系统。
2. 基于对象编程 (Object-Based Programming):
1. 基于对象编程是一种相对简化的编程思想，它强调使用对象来组织和处理数据，但不一定涉及到所有的面向对象编程概念。
2. 基于对象编程可以包含类和对象，但不一定包括继承和多态等高级概念。通常，它更关注对象的创建、属性设置和方法调用，而不涉及复杂的继承层次和多态行为。

1. B-Tree 索引：
1. B-Tree（Balanced Tree）索引是MySQL中最常见的索引类型，用于加速等值查询、范围查询和排序操作。
2. B-Tree索引将数据存储在树结构中，每个节点都包含多个键值对，其中键值用于搜索和排序数据。B-Tree索引通常是平衡的，因此在查询时能够快速定位数据。
3. InnoDB存储引擎默认使用B-Tree索引。
2. 哈希索引：
1. 哈希索引将索引键的哈希值与数据的存储位置关联起来，用于加速等值查询。
2. 哈希索引在等值查询时非常快，但不支持范围查询或排序。
3. 全文索引：
1. 全文索引用于对文本数据进行全文搜索。它不仅可以用于关键字匹配，还可以进行全文检索和分词等操作。
2. MySQL的全文索引通常使用特殊的数据类型（如FULLTEXT
   类型）和全文搜索函数（如MATCH AGAINST
   ）来实现。
4. 空间索引：
1. 空间索引用于处理地理空间数据，如地理坐标点、多边形等。MySQL提供了空间数据类型和空间索引来支持地理信息系统（GIS）应用。
5. 前缀索引：
1. 前缀索引允许将索引应用于列的前几个字符，而不是整个列。这在处理大文本列时可以减小索引的大小，提高检索效率。
6. 组合索引：
1. 组合索引是将多个列组合成一个索引，用于加速多列条件查询。
2. 组合索引可以包括多个列，并按照从左到右的顺序进行查询优化。因此，在设计组合索引时需要考虑查询的顺序。
7. 覆盖索引：
1. 覆盖索引是一种特殊的索引，它包含了查询所需的所有列，而不仅仅是索引列。这可以避免访问实际数据行，从而提高查询性能。
8. 位图索引：
1. 位图索引使用位图来表示索引键的存在与否，适用于低基数（cardinality）列，其中基数表示唯一值的数量。

1. 数据存储：
1. B树中，数据记录可以直接存储在树的节点中，每个节点既包含索引键值，又包含对应的数据记录。
2. B+树中，只有叶子节点存储数据记录，非叶子节点仅包含索引键值，不包含数据。叶子节点之间使用指针连接形成一个有序链表。
2. 叶子节点：
1. B树的叶子节点既包含索引键值，又包含数据记录。因此，对于范围查询或等值查询，可以直接在叶子节点上找到结果。
2. B+树的叶子节点仅包含数据记录，没有索引键值。所有的索引键值都存储在非叶子节点上。因此，范围查询或等值查询需要在叶子节点之间的有序链表上遍历。
3. 叶子节点的有序性：
1. B树中，叶子节点的键值不一定有序，因此范围查询可能需要多次跳转。
2. B+树中，叶子节点的键值总是按照升序排列，并且通过链表连接，支持高效的范围查询。
4. 非叶子节点：
1. B树和B+树的非叶子节点都包含索引键值，但在B+树中，非叶子节点仅用于导航，不存储数据。这使得B+树的高度通常比B树小，提高了查询效率。
5. 范围查询性能：
1. 对于范围查询，B+树通常优于B树，因为B+树的叶子节点有序，并且可以通过链表顺序遍历结果。
2. B树可能需要多次跳转到不同的叶子节点，性能较差。
6. 插入和删除性能：
1. 由于B树的叶子节点包含数据记录，插入和删除操作可能需要移动数据，导致性能损失。
2. B+树的插入和删除操作通常只涉及叶子节点，不需要移动数据，因此性能更稳定。

• 非叶子节点：包含索引键值和指向子节点的指针。
• 叶子节点：包含索引键值和指向对应数据行的指针。

1. 数据存储方式：
1. 聚集索引：每个数据表只能有一个聚集索引。聚集索引决定了数据表的物理存储顺序，实际上表中的数据行按照聚集索引的键值顺序进行物理存储。因此，聚集索引实际上就是数据表本身。
2. 非聚集索引：一个数据表可以有多个非聚集索引。非聚集索引不影响数据表的物理存储顺序，它们是独立的数据结构，包含索引键值和指向数据行的指针。
2. 数据行的物理排列：
1. 聚集索引：数据行按照聚集索引的键值顺序进行物理排列，因此聚集索引可以加速范围查询和排序操作，但插入、删除和更新数据时可能需要调整数据行的位置。
2. 非聚集索引：数据行的物理排列与非聚集索引无关，它们保持独立。非聚集索引主要用于加速等值查询和覆盖查询（Covering Queries），不会影响数据行的物理排列。
3. 主键：
1. 聚集索引：通常情况下，数据表的主键是聚集索引，因为主键列通常用于唯一标识每行数据，并且主键的唯一性要求适合聚集索引的特性。
2. 非聚集索引：非聚集索引可以建立在非主键列上，用于加速特定查询。在非聚集索引上建立的索引通常包含辅助信息以加速查询。
4. 索引维护开销：
1. 聚集索引：插入、删除和更新数据时可能需要调整数据行的位置，因此聚集索引的维护开销可能较高。
2. 非聚集索引：维护非聚集索引通常只涉及索引结构本身，不需要移动数据行，因此维护开销通常较低。
5. 查询性能：
1. 聚集索引：适用于范围查询和排序操作，因为数据行在物理上相邻。但对于等值查询，非聚集索引也可以提供很好的性能。
2. 非聚集索引：主要用于等值查询和特定查询类型，如覆盖查询。

1. B+树结构：B+树包含根节点、内部节点和叶子节点。叶子节点之间形成一个有序链表，包含了所有的数据记录，这个链表的顺序基于键值的顺序。
2. 范围查询的起始点：对于范围查询，首先需要确定查询范围的起始点。假设我们要查询从K1到K2之间的数据。
3. 定位起始点：从根节点开始，沿着B+树的内部节点向下遍历，找到最底层的叶子节点，这个叶子节点的数据键值大于等于K1，并且离K1最近。这个叶子节点是范围查询的起始点。
4. 遍历叶子节点链表：从起始点的叶子节点开始，按顺序遍历叶子节点的链表，将范围内的数据记录返回。遍历过程会一直进行，直到达到了范围的终止点K2，或者遍历到了叶子节点链表的末尾。
5. 返回查询结果：将在范围内找到的数据记录返回给查询操作的调用者。

1. 查找插入位置：首先，数据库系统需要查找要插入的数据在表中的插入位置。这通常涉及到比较新数据的键值与聚集索引中的已有数据的键值，以确定插入的位置。这一步骤确保数据插入后的排序顺序仍然保持。
2. 插入数据：一旦找到插入位置，数据库系统将新数据插入到表中的正确位置。这可能需要在表中的特定页（page）上进行插入操作，以确保数据的物理存储位置与聚集索引的顺序一致。
3. 更新索引：插入新数据后，数据库系统需要更新聚集索引，以反映新数据的位置。这可能涉及到调整聚集索引的内部结构，例如B+树，以包含新插入的数据。

1. 物理排序：聚集索引实际上是数据表的物理排序方式，数据行按照聚集索引的键值顺序存储在磁盘上。因此，当插入新的数据行时，数据库系统必须确保新数据的物理存储位置与排序顺序一致。这可能需要移动现有的数据行，以为新数据腾出空间，或者可能需要在聚集索引中找到合适的插入位置，这都会引起额外的磁盘I/O和数据移动开销。
2. 索引维护：聚集索引的维护成本较高，因为它们不仅要维护索引结构，还要维护数据行的物理位置。每次插入新数据行，都需要更新聚集索引中的数据行及其物理位置，这可能导致随着数据量的增加，插入操作的性能逐渐下降。

1. 逻辑排序：非聚集索引仅存储索引键值和指向实际数据行的指针（或行标识符）。这意味着数据行的物理存储顺序与非聚集索引的键值顺序无关。因此，插入新数据行到表中时，不需要考虑数据的物理排序，只需更新非聚集索引即可。
2. 较低的维护成本：由于非聚集索引只存储索引键值和指针，其维护成本通常较低。插入新数据行时，只需更新相关的非聚集索引，而不必移动现有的数据行或重排数据。

• 通常，数据库表中的每一行都包含多个列，而索引仅包含表中一个或多个列的子集。当执行查询时，如果查询需要的列在索引中已经包含，数据库可以直接使用索引来满足查询的需求，而不需要再去访问数据表本身。这就是覆盖索引的基本原理。
• 覆盖索引通过将查询中的列包含在索引中，使得查询可以在索引上完成，而不必查找和检索数据表的行。

• 性能提升：覆盖索引可以显著提高查询性能，因为它减少了磁盘I/O操作和数据传输的次数。尤其在大型数据库中，这种性能提升尤为明显。
• 减少资源消耗：由于不需要访问数据表，覆盖索引可以减少数据库系统的资源消耗，例如CPU、内存和磁盘带宽。
• 适用于特定查询：覆盖索引通常用于特定类型的查询，例如选择查询（SELECT），特别是对于查询中涉及到的列都在覆盖索引中的情况。这可以包括范围查询、排序和聚合查询等。

employee_id (主键)
first_name
last_name
salary
hire_date

1. 原子性（Atomicity）：原子性指的是事务是一个不可分割的操作单元。它要么全部成功执行，要么全部失败回滚，没有中间状态。如果在事务执行过程中发生错误，所有已经执行的操作都会被撤销，数据库恢复到事务开始前的状态。原子性确保了数据库的一致性，即使发生了故障或错误。
2. 一致性（Consistency）：一致性确保事务在执行前后，数据库从一个一致性状态转移到另一个一致性状态。这意味着事务必须满足预定义的业务规则和约束。如果一个事务违反了一致性规则，它将被回滚，数据库不会进入不一致的状态。
3. 隔离性（Isolation）：隔离性描述了多个并发事务之间的相互独立性。每个事务应该被视为在隔离的环境中运行，不受其他事务的影响。事务隔离级别定义了不同事务之间的可见性和影响，包括读未提交、读提交、可重复读和串行化等级别。更高的隔离级别通常会带来更多的锁和性能开销。
4. 持久性（Durability）：持久性确保一旦事务提交，其结果将永久保存在数据库中，即使在系统故障或崩溃的情况下也是如此。这通常涉及将事务日志（transaction log）记录到持久性存储介质（例如硬盘）上，以便在恢复后重新应用事务日志来还原数据库的状态。

1. 数据库中通常有一组预定义的业务规则、约束和完整性条件，这些规则规定了数据在数据库中的合法状态。这些规则可以包括唯一性约束、参照完整性、域完整性等。事务在执行过程中必须遵守这些规则。
2. 在事务内部，数据库系统必须确保事务操作的一致性。这意味着事务的各个操作（例如插入、更新、删除等）必须遵守数据库的规则，并且不会导致数据不一致。如果在事务内部违反了一致性规则，整个事务将会被回滚，以保持数据库的一致性状态。
3. 除了事务内一致性，数据库系统还必须确保多个并发事务之间的一致性。这是通过隔离性（Isolation）来实现的，隔离性定义了不同事务之间的可见性和影响。在多用户环境中，数据库系统使用锁和事务日志等机制来防止并发事务之间的干扰和冲突，以维护一致性。
4. 如果事务在执行过程中发生了错误或违反了一致性规则，数据库系统会回滚（Rollback）整个事务，即撤销事务中的所有操作，将数据库恢复到事务开始前的状态。这确保了即使在事务执行期间出现问题，数据库也不会进入不一致的状态。

1. 读未提交（Read Uncommitted）：这是最低级别的隔离。在该级别下，一个事务的修改对其他事务都是可见的，即使这些修改尚未提交。这会导致脏读（Dirty Read）问题，即一个事务读取了另一个事务未提交的数据。读未提交级别提供了最高的并发性，但最低的数据一致性。
2. 读提交（Read Committed）：这是大多数数据库默认的隔离级别。在该级别下，一个事务只能读取其他已提交事务的数据，这消除了脏读问题。然而，它仍然允许出现不可重复读（Non-Repeatable Read）问题，即同一事务内的两次读取之间，其他事务修改了数据。
3. 可重复读（Repeatable Read）：在可重复读级别下，一个事务在执行期间看到的数据不会受到其他事务的影响，即使其他事务修改或插入数据。这解决了不可重复读问题，但仍然可能发生幻读（Phantom Read）问题，即在同一事务内的两次查询之间，其他事务插入了新数据。
4. 串行化（Serializable）：串行化是最高级别的隔离级别。在该级别下，事务是完全隔离的，不会发生脏读、不可重复读和幻读等问题。但它牺牲了一部分并发性，可能导致性能下降，因为事务需要等待其他事务释放锁。

1. 不可见未提交数据：在"读已提交"级别中，其他事务尚未提交的数据对当前事务是不可见的。如果一个事务正在修改某一行数据，其他事务在此时读取同一行，会等待直到修改事务提交。

1. 快照读取：在"可重复读"级别中，事务会创建一个数据快照，记录了事务启动时刻的数据库状态。这个快照在事务执行期间用于所有查询，因此事务看到的数据是一致的。
2. 锁定读取：为了防止其他事务修改已读取的数据，"可重复读"级别通常会使用共享锁（Shared Locks）或行级锁（Row-Level Locks）来锁定已读取的数据，以确保其他事务不能修改或插入相关数据。

1. 阻塞I/O模型（Blocking I/O）：在阻塞I/O模型中，当程序发起一个I/O操作（如读取文件或从网络套接字接收数据）时，程序会被阻塞，直到操作完成。这意味着程序无法继续执行其他任务，直到I/O操作完成。阻塞I/O模型通常简单易用，但可能导致程序在等待I/O完成时浪费大量的时间。
2. 非阻塞I/O模型（Non-blocking I/O）：非阻塞I/O模型允许程序在执行I/O操作时继续执行其他任务，而不必等待I/O操作完成。程序会周期性地查询或轮询I/O操作的状态，以确定是否已经完成。非阻塞I/O模型需要编写更复杂的代码来轮询I/O状态，但允许更好地利用CPU。
3. 多路复用I/O模型（I/O Multiplexing）：多路复用I/O模型允许程序同时监视多个I/O操作的状态，通过一个系统调用（如select()
   或poll()
   ）来等待多个I/O事件。当其中任何一个I/O操作准备就绪时，程序可以处理它。这减少了轮询的开销，提高了效率。常见的例子是使用事件驱动的网络编程，如基于select的服务器。
4. 异步I/O模型（Asynchronous I/O）：在异步I/O模型中，程序发起一个I/O操作后，可以继续执行其他任务，而不必等待或轮询I/O状态。当I/O操作完成时，系统会通知程序。这种模型通常需要使用回调函数或事件处理程序来处理I/O完成事件。异步I/O模型可以极大地提高I/O效率，但编程复杂度较高。

1. 发起非阻塞读取请求：应用程序首先向操作系统发起非阻塞读取请求，请求指定了要读取的文件以及读取的字节数。应用程序不会被阻塞，可以继续执行其他任务。
2. 操作系统启动I/O操作：操作系统开始执行非阻塞读取操作。它会尝试读取文件的一部分数据（通常是缓冲区大小的一部分），而不会等待数据完全就绪。如果文件中有足够的数据可供读取，操作系统将尽可能多地读取数据，然后返回已读取的字节数。
3. 返回读取结果：操作系统将读取的数据传输到应用程序指定的缓冲区，并返回已读取的字节数。如果没有足够的数据可供读取（例如，文件尾部或者暂时没有数据可用），操作系统会返回一个指示当前没有数据可读的状态，而不会阻塞应用程序。
4. 应用程序处理结果：应用程序收到操作系统返回的读取结果后，可以根据已读取的数据字节数和数据内容来处理数据。如果还需要继续读取文件的剩余部分，应用程序可以再次发起非阻塞读取请求，然后继续执行其他任务。
5. 轮询或事件通知：如果应用程序希望等待更多数据就绪，它可以使用轮询或事件通知机制来检查文件是否有更多数据可读。这允许应用程序不断地检查文件的状态而不阻塞，从而实现非阻塞I/O。

1. 非阻塞I/O系统调用：在典型的非阻塞I/O操作中，可能涉及以下系统调用：
1. open()
   ：打开文件，通常只调用一次。
2. fcntl()
   ：设置文件描述符为非阻塞模式，通常只调用一次。
3. read()
   ：读取数据，可能会多次调用，每次读取一部分数据。
4. select()
   、poll()
   、epoll_wait()
   等：用于轮询或事件通知，可能会多次调用，每次等待I/O事件的状态。
2. 用户态和内核态切换：非阻塞I/O操作可能导致多次用户态和内核态之间的切换，具体次数取决于如下因素：
1. 对于每个系统调用，都会发生一次用户态到内核态的切换，以执行操作系统内核中的相应代码。
2. 在轮询或事件通知过程中，应用程序通常会进入内核态等待I/O事件。每次等待事件时都会发生一次用户态到内核态的切换，当事件就绪后再次切换回用户态。

上面这些问题问的既基础也有含量，大家可以参考参考我的回答，拿捏不准的还是要找一些官方的资料确认一下。

如果感觉我还总结的不错，还麻烦用你拿offer的小手给我点个赞和关注，我会持续为大家输出更多更优质的文章供大家学习。。。

最后，阿Q建了一个学习交流群，可点击我主页私我，免费拉你进群，群里都是一群上进、努力的小伙伴，我们可以一起学习、一起进步、一起成长！！