【c++、操作系统、计算机网络】核心知识汇总

C++

构造函数：

构造函数是一种特殊的方法，主要用于在创建对象时初始化对象，即为对象成员变量赋初始值。它与new运算符一起使用在创建对象的语句中，确保每个对象的所有数据成员都有一个明显的初始值。构造函数的名字必须与类名相同，可以有任意类型的参数，但不能有返回值，也不能说明为void类型。构造函数一般被声明为公有函数，程序不能直接调用构造函数，它是在创建对象时由系统自动调用的。构造函数可以重载，即根据其参数个数的不同或参数类型的不同来区分它们。如果没有显式定义构造函数，编译器会自动生成一个默认构造函数

说一下你对面向对象的理解（定义、详细介绍三大特性）

它使用“对象”来设计软件。对象可以包含数据（通常称为属性或字段）和代码（通常称为方法或函数）。面向对象编程的核心思想是将现实世界中的事物抽象为对象，并通过对象之间的交互来实现程序的功能。
封装（Encapsulation）：封装是将对象的数据（属性）和行为（方法）组合在一起，并隐藏内部的实现细节，只暴露出一个可以被外界访问的接口。封装的目的是减少系统各部分之间的耦合度，提高模块化，使得代码更加安全和易于维护。通过封装，对象的状态可以被保护，防止外部代码直接访问和修改对象的内部状态。
继承（Inheritance）：继承是一种机制，允许一个类（子类）继承另一个类（父类或超类）的属性和方法。这使得子类可以复用父类的代码，同时还可以添加或修改行为。继承支持代码重用，并且可以创建层次结构，使得类之间的关系更加清晰。继承还可以实现多态，即同一个接口可以有多种不同的实现。
多态（Polymorphism）：多态是指同一个接口可以有多种不同的数据类型。在面向对象编程中，多态性允许将不同类的对象视为同一类型的对象，只要它们共享相同的接口。这可以通过重载（方法名相同，参数不同）和重写（子类重写父类的方法）实现。多态性提高了代码的灵活性和可扩展性，使得程序可以在不修改现有代码的情况下，通过添加新的类来扩展功能。

简述多态实现的原理

编译器发现一个类中有虚函数，便会立即为此类生成虚函数表 vtable。虚函数表的各表项为指向对应虚函数的指针。编译器还会在此类中隐含插入一个指针 vptr（对 vc 编译器来说，它插在类的第一个位置上）指向虚函数表。调用此类的构造函数时，在类的构造函数中，编译器会隐含执行 vptr 与 vtable 的关联代码，将 vptr 指向对应的 vtable，将类与此类的 vtable 联系了起来。另外在调用类的构造函数时，指向基础类的指针此时已经变成指向具体的类的 this 指针，这样依靠此 this 指针即可得到正确的vtable，。
如此才能真正与函数体进行连接，这就是动态联编，实现多态的基本原理。
注意：一定要区分虚函数，纯虚函数、虚拟继承的关系和区别。牢记虚函数实现原理，因为多态
C++面试的重要考点之一，而虚函数是实现多态的基础。

C++中的多态主要通过以下两种方式实现

编译时多态（静态多态或早期多态）：
这是通过函数重载（Function Overloading）实现的，即在同一个作用域内定义多个同名函数，但参数列表不同（参数的类型、数量或顺序不同）。
编译器在编译时根据函数调用的参数类型来确定调用哪个函数版本。
运行时多态（动态多态或晚期多态）：
这是通过虚函数（Virtual Functions）实现的，即在基类中声明一个或多个虚函数，然后在派生类中重写这些函数。
运行时多态允许通过基类的指针或引用来调用派生类中重写的函数，而具体调用哪个函数版本是在运行时根据对象的实际类型来决定的。
运行时多态的实现机制：
虚函数表（VTable）：C++编译器为每个包含虚函数的类生成一个虚函数表，表中存储了类中所有虚函数的地址。
虚函数指针（VPtr）：每个对象都有一个虚函数指针，指向其类的虚函数表。
动态绑定：当通过基类的指针或引用调用虚函数时，程序首先查找对象的虚函数指针，然后通过虚函数表找到正确的函数地址并调用

C++虚函数是什么

在C++中，虚函数是一种特殊的成员函数，它允许在派生类中重写（Override）基类中的实现。虚函数是实现运行时多态（动态多态或晚期多态）的关键机制。以下是虚函数的一些关键特点：
动态绑定：虚函数允许程序在运行时确定应该调用哪个函数版本。这意味着，即使通过基类的指针或引用调用函数，程序也会根据对象的实际类型来调用相应的派生类中的函数。
基类声明：在基类中，虚函数通过关键字 virtual 声明。如果基类中声明了一个虚函数，那么所有派生类中的同名函数都会自动成为虚函数，除非它们被声明为 final。
派生类重写：派生类中的函数如果与基类中的虚函数具有相同的函数签名（相同的返回类型、函数名和参数列表），则该函数会重写基类中的虚函数。在派生类中重写虚函数时，通常使用 override 关键字来明确表示这一行为。
纯虚函数和抽象类：如果一个类中至少有一个纯虚函数（即只有声明没有实现的虚函数），那么这个类就成为了一个抽象类。抽象类不能被直接实例化，但可以作为其他类的基类。
虚析构函数：为了正确的处理对象销毁时的多态行为，通常在基类中声明一个虚析构函数。这样，当通过基类的指针删除派生类的对象时，会调用相应的派生类的析构函数。
虚函数表：C++实现运行时多态的机制之一是使用虚函数表（VTable）。每个包含虚函数的类都有一个虚函数表，其中存储了类中所有虚函数的地址。当创建类的对象时，对象会包含一个指向其虚函数表的指针。

虚函数如何实现

虚函数表（VTable）：每个包含虚函数的类都会有一个与之关联的虚函数表。这个表是一个函数指针数组，每个指针指向一个虚函数的实现。虚函数表在程序的全局数据区分配，并且类的对象会包含一个指向这个表的指针。
虚函数指针（VPtr）：当一个类包含虚函数时，编译器会在对象的内存布局中添加一个或多个虚函数指针，通常称为VPtr。这个指针指向类的虚函数表。
动态绑定（Dynamic Binding）：当通过基类的指针或引用调用虚函数时，程序会使用对象的VPtr来查找对应的虚函数表，然后根据函数的声明找到正确的函数实现。这个过程是在运行时进行的，因此被称为动态绑定。
构造函数和析构函数：在对象的构造和析构过程中，虚函数表指针会被正确地设置或清除。如果对象是通过基类的指针被删除的，虚析构函数确保了正确的析构顺序。
纯虚函数和抽象类：如果类中包含纯虚函数（没有实现的虚函数），则该类成为抽象类，不能被实例化。这通常用来定义接口或行为规范。

析构函数必须是虚函数吗？

析构函数不必要声明为虚函数，但通常推荐这样做，特别是当类被设计为继承体系的一部分时。以下是一些关于虚析构函数的考虑：
多态性：如果你有一个基类指针，指向派生类的对象，并且基类的析构函数不是虚的，那么当通过基类指针删除对象时，只会调用基类的析构函数，而不会调用派生类的析构函数。这将导致派生类中的资源没有被适当地释放。
避免资源泄漏：如果基类的析构函数是虚的，那么删除一个指向派生类对象的基类指针时，将正确地调用派生类的析构函数，接着是基类的析构函数。这样可以确保所有分配的资源都被适当地释放。
实现清晰的继承体系：在多态性设计中，虚析构函数是良好的实践，它确保了派生类对象在通过基类接口被销毁时，能够执行完整的资源清理。
避免未定义行为：如果没有虚析构函数，当基类指针指向派生类对象并被删除时，派生类的析构函数不会被调用，这可能导致未定义行为，因为派生类中特有的资源没有被释放。
默认情况：如果你的类不打算被继承，或者你确定基类的析构函数逻辑足以处理所有派生类的情况，那么基类的析构函数可以不是虚的。
C++11及以后：从C++11开始，如果类有一个或多个虚函数，编译器会自动将析构函数声明为虚函数，即使没有显式地使用 virtual 关键字。

C++内存布局？虚函数表表在什么位置

非静态成员变量：这些是类定义中的数据成员，它们在对象的内存中连续存储，按照它们在类中声明的顺序排列。
虚函数表指针（VPtr）：如果类包含虚函数，编译器会为该类生成一个虚函数表（VTable），并且对象的内存布局中会包含一个指向该表的指针。这个指针通常位于对象内存布局的起始位置，以便于快速访问
其他元数据：可能包括用于支持多态的额外信息，如指向虚基类的虚指针（VBPtr）等。
填充（Padding）：为了满足内存对齐的要求，编译器可能会在成员变量之间或对象的末尾添加一些填充字节。
虚函数表的位置：
虚函数表指针（VPtr）通常位于对象内存布局的最前面，这样做的原因是为了在通过基类指针或引用访问对象时，能够快速地访问到虚函数表。当调用虚函数时，程序首先通过VPtr找到对应的虚函数表，然后根据函数的索引或函数名查找到正确的函数地址，并进行调用
±----------------+
| VPtr to VTable | // 指向虚函数表的指针，通常在最前面
±----------------+
| data (int) | // 非静态成员变量
±----------------+
| Padding | // 可能存在的填充，取决于编译器和平台的内存对齐要求
±----------------+

（C++类的）“组合”是什么概念

在C++中，“组合”（Composition）是一种面向对象设计中的对象关系，其中一个类（称为"包含类"或"组合类"）包含另一个类（称为"成员类"或"组件类"）的一个或多个实例作为其成员变量。组合关系模拟了现实世界中的"部分-整体"关系，其中一个对象是另一个对象的一部分。
组合具有以下特点：
"部分-整体"关系：组合类的对象包含成员类的对象，成员类的对象是组合类对象的一部分。
生命周期管理：成员类对象的生命周期通常与包含类对象的生命周期相关联。当包含类对象被创建时，成员类对象通常也会被创建；当包含类对象被销毁时，成员类对象也会被销毁。
访问控制：组合类可以控制对成员类对象的访问。组合类可以提供公共接口来访问或修改成员类对象的状态，同时隐藏成员类对象的实现细节。
多态性：如果成员类是基类，而组合类包含派生类对象作为成员，那么组合类可以通过成员类接口来使用派生类对象的多态行为。
组合优于继承：在某些情况下，使用组合代替继承可以提供更大的灵活性和可维护性。组合允许更细粒度的控制和更好的封装。

C++指针和智能指针的区别？智能指针的实现原理是什么？指针和函数指针的区别？

C++指针和智能指针的区别：

管理方式：
- 普通指针：需要手动管理内存，包括分配和释放内存。如果忘记释放，会导致内存泄漏；如果错误地释放，会导致程序崩溃。
- 智能指针：自动管理内存，当智能指针超出作用域或被销毁时，它们会自动释放所指向的对象。
所有权：
- 普通指针本身不包含所有权的概念，需要程序员自己确保正确地管理资源。
- 智能指针如 std::unique_ptr 表示独占所有权，std::shared_ptr 表示共享所有权，它们内部处理所有权的转移和复制。
异常安全性：
- 普通指针在异常发生时可能不会释放内存，导致资源泄漏。
- 智能指针通常保证异常安全性，即使发生异常也会正确地释放资源。
资源管理：
- 智能指针可以与自定义的删除器（如 std::default_delete 或自定义的删除策略）一起使用，提供更灵活的资源管理方式。

标题智能指针的实现原理：

智能指针通常通过以下原理实现：

引用计数（主要针对 std::shared_ptr）：
- 多个 std::shared_ptr 可以指向同一个对象，对象的生命周期由引用计数管理。每次创建新的 std::shared_ptr 指向同一对象时，引用计数增加；每次智能指针被销毁或重置时，引用计数减少。当引用计数降到0时，对象被自动删除。
析构函数：
- 智能指针的类定义中包含一个析构函数，当智能指针对象被销毁时，析构函数会被调用，自动释放它所管理的资源。
删除器（Deleter）：
- 智能指针可以与一个自定义的删除器一起使用，当智能指针被销毁时，删除器会被调用来执行实际的资源释放操作。
空指针检查：
- 智能指针通常在释放资源前进行空指针检查，避免释放空悬指针指向的资源。

指针和函数指针的区别：

所指向的内容：
- 普通指针：可以指向任何类型的数据或对象。
- 函数指针：专门用于指向函数，包括全局函数、静态成员函数或函数对象（如lambda表达式）。
使用方式：
- 普通指针通过解引用操作符 * 访问所指向的数据。
- 函数指针通过调用操作符 () 来调用所指向的函数。
语法：
- 普通指针声明：Type* ptr;
- 函数指针声明：returnType (*ptr)(parameterTypes);
调用机制：
- 普通指针的解引用是直接访问内存地址中的数据。
- 函数指针的调用会跳转到函数的内存地址执行函数代码。

C++什么时候可能出现内存泄漏？如何定位到内存泄漏？

丢失指针：当使用 new 分配内存后，如果指针丢失或未被适当地管理，分配的内存就无法释放，导致内存泄漏。
异常安全：在存在异常抛出的情况下，如果异常发生在内存分配之后且没有适当的异常处理机制，分配的内存可能不会被释放。
循环引用：在使用智能指针如 std::shared_ptr 时，如果存在循环引用而没有使用 std::weak_ptr 打破循环，会导致引用计数永远不会达到零，从而无法释放内存。
资源未释放：当资源（如文件句柄、网络连接、数据库连接等）被分配后，如果没有在不再需要时释放这些资源，也会导致资源泄漏。
缓存数据：在某些情况下，程序可能会缓存大量数据，如果缓存未被正确管理，随着时间的推移可能会占用越来越多的内存。
复制构造函数和赋值运算符：如果类中重写了复制构造函数或赋值运算符，但没有正确管理内存，可能会导致内存泄漏。

在C++的多继承里面，怎么知道调用的方法和属性属于哪一个父类？（在方法前面加上类名）

作用域运算符（::）：使用作用域运算符可以明确指定要调用的父类的方法或访问的属性。例如，如果有两个基类 Base1 和 Base2 都有一个名为 method 的方法，可以在派生类中这样调用：
this->Base1::method();this->Base2::method();
构造函数初始化列表：在派生类的构造函数中，可以使用初始化列表来调用基类的构造函数，明确指出使用的是哪个基类的构造函数：
class Derived : public Base1, public Base2 {public: Derived() : Base1(someArgs), Base2(someOtherArgs) {}};
虚继承：如果存在菱形继承结构，并且想要消除二义性，可以使用虚继承（virtual inheritance）来确保基类只被包含一次：
class Base1 { … };class Base2 : virtual public Base1 { … };class Derived : public Base1, public Base2 { … };
强制类型转换：使用静态类型转换（如 static_cast<Base1*>(this)->method()）可以明确地调用特定基类的方法。这通常用于多态性调用，但也可以用于解决二义性问题。
命名空间：如果方法或属性属于不同的命名空间，可以在调用时指定命名空间。
成员函数指针：在某些情况下，可以使用成员函数指针来明确调用特定基类的成员函数
友元类：如果需要，可以将派生类声明为基类的友元，这样派生类就可以访问基类的私有或保护成员。
文档和编码规范：在多继承的情况下，保持清晰的文档和编码规范，以避免名称冲突和二义性。

new和malloc申请内存有什么差别

语法：
new 是C++的运算符，使用时可以直接初始化对象，例如：int* p = new int; 或 int* p = new int(5);。
malloc 是C语言标准库中的函数，需要包含头文件 <stdlib.h>（在C++中是），并且返回的是一个 void 指针，需要强制类型转换，例如：int* p = (int*)malloc(sizeof(int));。
类型安全：
new 是类型安全的，它会根据申请的对象类型自动调整大小，并且可以自动处理构造函数和析构函数的调用。
malloc 不是类型安全的，它只负责分配内存，不会调用构造函数或析构函数。
构造和析构：
使用 new 分配的对象，在对象创建时会自动调用构造函数；在对象释放时，需要使用 delete 运算符，它会调用对象的析构函数。
使用 malloc 分配的内存，不会自动调用构造函数。如果分配的是对象数组，需要手动调用每个对象的构造函数。释放内存时，需要使用 free() 函数，且不会自动调用析构函数。
内存分配失败时的行为：
new 在内存分配失败时会抛出一个 std::bad_alloc 异常。
malloc 在内存分配失败时返回 NULL 或 nullptr。
内存对齐：
new 保证对象的内存对齐符合C++标准的要求，这可能比 malloc 的对齐要求更严格。
调试和诊断：
使用 new 时，C++编译器可能会提供更多的调试支持，例如在调试模式下检查内存越界。
使用场景：
new 更适合C++的面向对象编程，特别是需要对象构造和析构时。
malloc 更适合于底层内存操作，或者在需要手动管理内存大小时使用。

C++11智能指针：

C++11引入了智能指针，如 std::unique_ptr 和 std::shared_ptr，它们使用 new 来分配内存，并自动管理内存的释放，提供了更好的异常安全性和资源管理。

设计模式知道哪些

创建型模式（Creational Patterns）：
单例模式（Singleton）：确保一个类只有一个实例，并提供一个全局访问点。
工厂方法模式（Factory Method）：定义创建对象的接口，让子类决定实例化哪一个类。
抽象工厂模式（Abstract Factory）：创建相关或依赖对象的家族，而不需明确指定具体类。
建造者模式（Builder）：构建一个复杂的对象，并允许按步骤构造。
原型模式（Prototype）：通过拷贝现有的实例创建新的实例，而不是通过新建。
结构型模式（Structural Patterns）：
适配器模式（Adapter）：允许对象间的接口不兼容问题，让它们可以一起工作。
装饰器模式（Decorator）：动态地给一个对象添加额外的职责。
代理模式（Proxy）：为其他对象提供一种代理以控制对它的访问。
外观模式（Facade）：为子系统中的一组接口提供一个统一的高层接口。
桥接模式（Bridge）：将抽象部分与它的实现部分分离，使它们可以独立地变化。
组合模式（Composite）：将对象组合成树形结构以表示“部分-整体”的层次结构。
享元模式（Flyweight）：通过共享来高效地支持大量细粒度的对象。
行为型模式（Behavioral Patterns）：
策略模式（Strategy）：定义一系列算法，把它们一个个封装起来，并使它们可互换。
模板方法模式（Template Method）：在方法中定义算法的骨架，延迟到子类中实现。
观察者模式（Observer）：对象间的一对多依赖关系，当一个对象改变时，所有依赖于它的对象都会被通知并自动更新。
迭代器模式（Iterator）：顺序访问一个聚合对象中的各个元素，不暴露其内部的表示。
责任链模式（Chain of Responsibility）：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。
命令模式（Command）：将请求封装为一个对象，从而使用户可用不同的请求对客户进行参数化。
备忘录模式（Memento）：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。
状态模式（State）：允许一个对象在其内部状态发生改变时改变其行为。
访问者模式（Visitor）：为一个对象结构（如组合结构）增加新能力

构造函数和析构函数能不能是虚函数

在C++中，构造函数不能是虚函数，但析构函数可以是虚函数。
为什么构造函数不能是虚函数：
初始化固定性：构造函数的主要任务是初始化对象。如果构造函数是虚函数，那么在创建对象时，就可能需要动态确定调用哪个构造函数，这与构造函数的目的是相悖的。
对象存在性：在调用虚函数之前，对象必须已经被创建并初始化。然而，在构造函数执行之前，对象尚未完全形成，因此无法调用虚构造函数。
多态性实现：多态性是通过虚函数实现的，但是多态性本身依赖于对象已经被构造并拥有虚函数表。构造函数的执行是在对象形成之初，此时多态性尚未建立。
析构函数可以是虚函数：
多态性：析构函数可以设计为虚函数，以支持多态性。当通过基类的指针或引用删除一个对象时，如果基类的析构函数是虚的，那么将调用对象实际类型的析构函数，确保正确的析构顺序。
正确的资源释放：在涉及继承的类层次结构中，如果基类的析构函数不是虚的，那么当删除一个指向派生类对象的基类指针时，只有基类的析构函数会被调用，派生类的析构函数将被忽略，可能导致资源泄漏。
避免资源泄漏：虚析构函数确保当删除一个多态对象时，所有继承层次的析构函数都会被调用，从而适当地释放资源

define 和 const的区别

定义方式：
#define 是预处理指令，由预处理器在编译之前处理，替换文本中所有出现的实例。
const 关键字定义的是常量变量，有数据类型，并且在编译时分配存储空间。
类型安全：
#define 不进行类型检查，因为它只是简单的文本替换，不涉及类型信息。
const 定义的常量具有类型，编译器会进行类型安全检查。
调试：
使用 #define 定义的宏在调试时可能不太方便，因为它们在编译后不存在于代码中。
const 常量在调试时可见，并能观察它们的值。
作用域：
#define 定义的宏没有作用域限制，如果在头文件中定义，可能会影响整个程序。
const 常量具有作用域限制，它们只在定义它们的地方可见。
存储：
#define 宏没有存储空间，它们在预处理阶段被替换。
const 常量在内存中占有存储空间。
链接：
#defne 宏在链接时不可见，因为它们在预处理阶段就被替换了。
const 常量在链接时可见，如果它们是 extern 的，可能需要在多个文件中共享。
优化：
编译器对 const 常量可以进行优化，例如，直接将值内联到使用位置，减少运行时访问内存的需要。
#define 宏的替换可能不会进行这样的优化，有时还可能导致代码膨胀。
使用场景：
#define 通常用于条件编译和定义编译时常量。
const 用于定义运行时常量，特别是需要参与复杂表达式计算的情况。
可维护性：
使用 const 常量可以提高代码的可读性和可维护性，因为它们具有名称和类型。
宏和函数：
#define 可以定义宏函数，但容易导致意外行为，如运算符优先级问题。
const 不能定义函数

空类的大小

在C++中，一个空类（没有成员变量和成员函数的类）的大小是由编译器决定的。理论上，一个没有任何成员的空类不占用任何存储空间，但实际上，编译器可能会为其分配至少一个字节的空间，以满足对象的唯一性要求。

什么是耦合性，类A访问类B的成员变量耦合度高吗，函数调用另一个函数耦合度高吗

耦合性（Coupling）是软件工程中的一个概念，用来描述不同模块（如类、函数、组件等）之间的相互依赖程度。耦合性越低，模块之间的独立性越高，系统的可维护性和可扩展性通常越好。耦合性分为多种类型，包括：
无耦合（Non-coupling）：模块之间没有直接的联系或依赖。
内容耦合（Content coupling）：一个模块直接访问另一个模块的内部数据。
公共耦合（Common coupling）：多个模块共享同一全局数据。
外部耦合（External coupling）：模块之间通过外部数据（如文件、数据库等）进行通信。
控制耦合（Control coupling）：一个模块控制另一个模块的行为，通常是通过传递控制参数。
标记耦合（Stamp coupling）：模块之间传递的是数据结构，而不是控制参数。
数据耦合（Data coupling）：模块之间通过参数和返回值进行数据交换，但不影响对方的内部状态。
消息耦合（Message coupling）：模块之间通过消息进行通信，每个模块保持独立性。
间接耦合（Indirect coupling）：模块之间的联系通过其他模块或机制间接实现。
类A访问类B的成员变量耦合度高吗？
如果类A直接访问类B的公有（public）成员变量，这通常被认为是一种高耦合，特别是如果这些成员变量不是通过接口或抽象层访问的话。这种耦合可能导致以下问题：
低内聚：类A的职责不仅仅是它自己的业务逻辑，还包括对类B状态的管理。
低独立性：类B的变化可能直接影响到类A。
难以维护和扩展：当需要修改类B的实现时，可能需要同时考虑类A的修改。
函数调用另一个函数耦合度高吗？
函数之间的耦合度取决于它们是如何相互调用的：
高耦合：如果一个函数直接修改另一个函数的内部状态或依赖于另一个函数的内部实现细节，这通常被认为是高耦合。
低耦合：如果函数调用是基于定义良好的接口，并且不依赖于被调用函数的内部实现，这被认为是低耦合。
降低耦合性的策略：
使用接口或抽象类：定义清晰的接口或抽象类来规范模块之间的交互。
依赖注入：通过依赖注入来减少模块之间的直接依赖。
使用设计模式：如观察者模式、策略模式等，可以降低模块之间的耦合度。
模块化设计：将系统分解为独立的模块，每个模块负责一部分功能。
在设计软件系统时，应该尽量降低模块之间的耦合度，以提高系统的灵活性和可维护性。

.## stl中unordered_map和map区别

基于的数据结构：
std::map 基于红黑树，它是一个自平衡的二叉搜索树。
std::unordered_map 基于哈希表，它使用哈希函数来快速定位元素。
时间复杂度：
std::map 提供对数时间复杂度（O(log n)）的查找、插入和删除操作。
std::unordered_map 提供平均情况下常数时间复杂度（O(1)）的查找、插入和删除操作，但最坏情况下可能退化到线性时间复杂度（O(n)）。
元素顺序：
std::map 中的元素按照键的顺序自动排序，元素是有序的。
std::unordered_map 中的元素没有特定的顺序。
内存使用：
std::map 通常使用更多的内存，因为它需要存储额外的树节点信息。
std::unordered_map 通常使用较少的内存，因为它不需要存储树结构。
性能特点：
std::map 在有序遍历和范围查询方面表现更好。
std::unordered_map 在无序访问和大量哈希冲突较少的场景下提供更快的访问速度。
迭代器失效情况：
std::map 的迭代器在遍历过程中更稳定，因为树结构变化较少。
std::unordered_map 的迭代器可能会在插入和删除操作中失效，因为哈希表可能需要重新哈希和重新分配内存。
使用场景：
当需要有序遍历键值对时，使用 std::map。
当需要快速访问且不关心元素顺序时，使用 std::unordered_map。

同步性：
std::map 可以提供元素的下界和上界迭代器，以及反向迭代器，方便范围查询。
std::unordered_map 不提供这样的功能，因为它不保证元素顺序。
扩展性：
std::map 更易于扩展到多路归并等操作，因为它基于树结构。
std::unordered_map 在进行大规模数据操作时可能需要更多的考虑，尤其是在哈希表需要扩容时。

C++11新特性

C++11是C++语言的一个重要版本，引入了许多新特性和改进，旨在提高语言的表达力、性能和易用性。以下是一些C++11的主要新特性：

自动类型推断（auto）：
允许编译器根据初始化表达式推断变量类型，简化模板编程。
基于范围的for循环（Range-based for loop）：
提供了一种更简洁的遍历容器元素的方式。
lambda 表达式：
允许在代码中定义匿名函数对象，简化了函数对象的创建。
智能指针（Smart pointers）：
引入了 std::unique_ptr、std::shared_ptr 和 std::weak_ptr，自动管理动态分配的内存。
右值引用和移动语义（Rvalue references and move semantics）：
通过右值引用优化资源的移动，减少不必要的复制，提高性能。
初始化列表（Initializer lists）：
允许使用花括号 {} 来初始化对象，简化构造函数的编写。
委托构造函数（Delegated constructors）：
允许一个构造函数调用另一个构造函数，简化构造函数的重用。
类型推导（Type deduction）：
decltype 关键字可以推导出表达式的类型。
强类型枚举（Strongly-typed enums）：
enum class 提供了更好的类型安全性。
原子操作和线程支持（Atomic operations and threading support）：
引入了 <atomic> 和 <thread> 库，提供了基本的并发和线程同步机制。
条件编译的改进：
使用 constexpr 可以在编译时计算表达式的值。
内存模型和原子性：
定义了新的内存模型，为多线程编程提供了基础。
static_assert：
允许在编译时执行断言，检查常量表达式。
属性和特质（Attributes and traits）：
使用 [[attribute]] 语法为声明添加属性，以及使用 SFINAE（Substitution Failure Is Not An Error）进行模板编程。
变长模板参数（Variadic templates）：
允许模板函数和类接受任意数量的模板参数。
继承构造函数（Inheriting constructors）：
允许从基类继承构造函数，简化代码。
正则表达式库（Regular expressions library）：
提供了对正则表达式的支持。
文件系统库（Filesystem library）：
提供了对文件统操作的支持。
改进的输入/输出流（Improved I/O streams）：
对 <iostream> 和 <iomanip> 进行了改进。
动态数组（Dynamic arrays）：
std::array 提供了固定大小的容器，而 std::vector 增加了更多功能。

C++11的这些新特性使得C++语言更加现代化，提高了开发效率，同时也使得C++能够更好地支持大型和复杂的软件项目。

C++多线程了解吗？如何定义多线程？如何让他们跑起来？（pthread库，join方法）

C++11标准引入了对多线程编程的原生支持，通过、、等头文件提供了一系列用于多线程编程的工具。此外，C++也可以使用 POSIX 线程库（pthreads），这是一个在多种UNIX系统上广泛使用的多线程库。

main函数之前执行一个函数
在C或C++程序中，main 函数是程序的入口点，通常在程序开始执行时首先调用。然而，有时我们可能需要在 main 函数之前执行一些初始化代码。这可以通过几种方式实现：
构造函数：在C++中，你可以使用静态对象的构造函数来确保在 main 函数之前执行某些代码。静态对象在程序启动时自动构造。
初始化数组：在C或C++中，你可以定义一个初始化数组，它将在 main 函数之前被初始化。
C++11及以后版本：C++11引入了初始化列表，可以在 main 函数之前执行一些初始化代码。
C++的 atexit 函数：虽然 atexit 用于注册程序退出时执行的函数，但你可以创造性地使用它来在程序开始时执行代码。
C的 init 函数：某些编译器支持在程序开始时自动调用一个名为 init 的函数，这可以在 main 之前执行。
操作系统特定的代码：某些操作系统可能允许你在程序的可执行文件中指定一个在 main 之前执行的入口点。

在面向对象编程中，一个类可以有多种构造函数，具体数量取决于以下几个因素：

重载构造函数：一个类可以有多个构造函数，只要它们的参数列表不同。参数列表的不同可以是参数的类型、数量或顺序。
默认构造函数：如果没有为类定义任何构造函数，编译器通常会自动生成一个默认构造函数。
拷贝构造函数：用于复制对象的构造函数，如果用户没有定义，编译器会生成一个默认的拷贝构造函数。
移动构造函数：C++11及以后版本支持的构造函数，用于移动资源，而不是复制。如果没有定义，编译器在某些情况下会生成默认的移动构造函数。
转换构造函数：允许将其他类型转换为当前类类型的构造函数。这通常是通过构造函数的参数类型来实现的。
初始化列表构造函数：使用成员初始化列表来初始化成员变量的构造函数。
委托构造函数：一个构造函数调用同一个类中的另一个构造函数。
私有构造函数：虽然不常见，但类可以有私有构造函数，这通常用于实现单例模式或防止类的实例化。
继承相关的构造函数：如果类是继承的，它还可以有继承构造函数，这些构造函数调用基类的构造函数。
析构函数：虽然不是构造函数，但通常与构造函数一起考虑。析构函数用于释放对象占用的资源。

讲一讲const的作用（修饰变量、函数参数、函数返回值、成员函数、常量指针和指针常量）

STL里面的hashmap用到了哪些数据结构？（红黑树和哈希表）

面向对象设计原则是指导软件设计和开发的一系列原则，它们帮助开发者创建出灵活、可维护和可扩展的系统。以下是你提到的三个设计原则的简要介绍：

开闭原则（Open-Closed Principle, OCP）：
- 定义：软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。
- 意义：这意味着设计时应该使系统容易添加新功能，而不需要修改现有的代码。通常通过添加新的代码来实现功能的扩展，而不是更改现有的代码。
单一职责原则（Single Responsibility Principle, SRP）：
- 定义：一个类应该只有一个引起它变化的原因，即一个类只负责一个功能。
- 意义：这有助于降低类的复杂度，提高类的可读性和可维护性。当需求变化时，只会影响到单一职责的类，而不会对其他功能产生影响。
接口隔离原则（Interface Segregation Principle, ISP）：
- 定义：客户端不应该依赖于它不使用的接口。一个类对另一个类的依赖应该建立在最小的接口上。
- 意义：这个原则鼓励将大的接口拆分成小的、特定的接口，这样客户端只会依赖于它需要的接口。这可以减少客户端因为不相关的接口变更而受到影响的风险。

里氏替换原则（Liskov Substitution Principle, LSP）：子类对象应该能够替换掉它们的父类对象，而不影响程序的行为。
依赖倒置原则（Dependency Inversion Principle, DIP）：高层模块不应依赖于低层模块，两者都应该依赖于抽象；抽象不应依赖于细节，细节应依赖于抽象。
迪米特法则（Law of Demeter, LoD）：一个对象应该对其他对象有最少的了解，只与直接的朋友通信。

多继承的虚函数有什么区别

虚函数表（VTable）: 每个有虚函数的类都会有一个虚函数表，用于在运行时动态绑定函数调用。当一个类从多个基类继承时，它可能会有多个虚函数表，一个来自每个基类。
菱形继承问题: 如果一个类继承了两个类，而这两者又有一个共同的基类，就形成了所谓的“菱形继承”。在这种情况下，如果共同的基类中有虚函数，那么派生类会有多个虚函数表条目指向同一个函数，这可能导致一些混淆和错误。
构造函数和析构函数的调用顺序: 在多继承的情况下，构造函数和析构函数的调用顺序会根据继承的顺序来确定。这意味着如果基类A和B都被类C继承，并且C的构造函数首先调用了A的构造函数，那么析构时必须最后调用A的析构函数。
虚函数重写规则: 在多继承中，如果多个基类中有相同签名的虚函数，派生类重写该函数时需要明确指出它重写的是哪个基类的函数。这可以通过使用using声明来实现，例如：using Base1::virtualFunction;。
动态类型识别: 使用dynamic_cast进行类型转换时，在多继承的情况下可能需要更多的信息来确定正确的类型，因为一个对象可能具有多个基类类型。
内存布局: 多继承可能导致对象的内存布局更加复杂，因为每个基类都可能有自己的数据成员和虚函数表。
多重继承的虚函数调用: 当调用一个虚函数时，编译器需要根据对象的动态类型来确定调用哪个函数。在多继承的情况下，这可能涉及到多个虚函数表的查找
。

四种类型转换

静态类型转换（Static Cast）:
使用static_cast(expression)语法。
用于非多态类型之间的转换，例如基本数据类型之间的转换，或者派生类指针向基类指针的转换（向上转型）。
它不会进行运行时类型检查，因此如果转换不合适，可能会导致未定义行为。
动态类型转换（Dynamic Cast）:
使用dynamic_cast(expression)语法。
用于处理包含继承关系的类之间的转换，特别是向下转型（从基类指针或引用转换为派生类指针或引用）。
它在运行时检查转换的有效性，如果转换失败，指针转换将返回nullptr，引用转换将抛出std::bad_cast异常。
重新解释类型转换（Reinterpret Cast）:

使用reinterpret_cast(expression)语法。
允许几乎任何类型的指针或引用之间的转换，包括指针和足够大的整型之间的转换。
这种转换是低级的，不安全，因为它不进行任何类型检查。
C风格类型转换（C-Style Cast）:
使用(type)expression语法。
这是C语言中的类型转换方式，在C++中仍然可用，但通常不推荐使用，因为它的转换规则不明确，容易导致错误。
const_cast:
使用const_cast(expression)语法。
主要用于移除或添加const属性，不改变表达式的值类型。
这种转换通常用于通过指针或引用修改const对象。
在需要高度可配置和可扩展的系统架构时，可能会更多地使用工厂方法和抽象工厂模式。在需要实现复杂的交互和通信模式时，可能会使用观察者模式或责任链模式。设计模式的选择应该基于项目的具体需求和上下文环境

标题单例模式优缺点

优点：
确保唯一性:
单例模式的核心优势在于它能保证一个类只有一个实例对象。
全局访问点:
通过一个全局访问点可以方便地从任何地方访问该实例对象，简化了客户端代码。
资源共享:
当对象的创建成本很高时，使用单例模式可以节省资源，因为只创建一次实例。
控制实例数量:
在某些情况下，控制实例的数量对于程序的逻辑和性能至关重要。
线程安全:
可以通过适当的同步机制确保单例模式在多线程环境中的线程安全。
延迟初始化:
单例模式可以支持延迟初始化，即直到需要时才创建实例。
缺点：
全局状态:
单例提供了全局访问点，这可能导致全局状态的使用，从而使得程序的模块化和可测试性降低。
难以测试:
由于单例模式的全局访问点和唯一实例，它可能会使得单元测试变得困难。
扩展性差:
如果需要修改单例类的行为，可能需要修改所有依赖于该单例的代码。
依赖性:
单例模式增加了代码之间的耦合性，因为其他类需要依赖单例提供的接口。
线程安全问题:
在多线程环境中实现线程安全的单例模式可能会增加实现的复杂性。
生命周期问题:
单例对象的生命周期与应用程序相同，这可能导致资源无法释放或内存泄漏。
单例类职责过重:
单例类可能承担过多的职责，违反单一职责原则。
序列化问题:
在需要序列化和反序列化的场景中，单例模式可能会带来问题，因为序列化和反序列化可能会创建额外的实例。

OC与C++的区别（动态绑定静态绑定）

Objective-C (OC) 和 C++ 都是面向对象的编程语言，但它们在很多方面存在差异，特别是在动态绑定和静态绑定的处理上：
语言起源和设计哲学:
Objective-C 是在C语言的基础上增加了面向对象的特性，主要用于苹果公司的操作系统和应用程序开发。
C++ 是C语言的一个扩展，提供了面向对象、泛型编程和多种编程范式。
动态绑定:
Objective-C 支持动态绑定，这意味着可以在运行时解析方法调用。Objective-C 利用消息机制来实现这一点，即对象接收消息，然后在运行时查找相应的方法实现。
C++ 支持虚函数和多态，但这些是基于静态类型信息的动态绑定。C++ 编译器在编译时生成虚函数表（vtable），在运行时通过虚函数表来实现动态绑定，但这仍然依赖于编译时类型信息。
静态绑定:
在 Objective-C 中，静态绑定通常发生在编译时，例如对类方法或静态方法的调用。
C++ 中的静态绑定发生在编译时，包括对非虚函数的调用和模板实例化。
类型系统:
Objective-C 的类型系统相对简单，主要依赖于运行时系统来处理类型相关的问题。
C++ 拥有复杂的类型系统，包括类型转换、模板和类型推导等。
内存管理:
Objective-C 使用引用计数的内存管理方式（ARC之前），需要程序员或编译器管理内存。
C++ 支持手动内存管理，也支持智能指针等自动内存管理机制。
语法和特性:
Objective-C 语法较为简洁，有一些独特的特性，如消息传递机制。
C++ 语法更为复杂，提供了丰富的特性，如运算符重载、模板元编程等。
标准库:
Objective-C 标准库通常较小，主要依赖于Foundation框架提供的功能。
C++ 有一个庞大的标准库（STL），包括容器、算法、输入输出流等。
跨平台:
Objective-C 主要用于苹果生态系统，虽然有GNU Objective-C等实现，但跨平台能力有限。
C++ 是一种高度跨平台的语言，可以在几乎所有操作系统和硬件上编译运行。
编译器和工具链:
Objective-C 通常与Xcode和Clang编译器一起使用。
C++ 可以使用多种编译器，如GCC、Clang、MSVC等。
类和结构体的区别
类（Class）和结构体（Structure）在很多编程语言中都是用来组织数据和功能的复合数据类型，但它们之间存在一些关键的区别。以下是一些常见的区别：
继承：
类可以继承其他类，形成继承层次结构，而结构体通常不支持继承。
访问控制：

标题类通常具有访问控制的概念，比如私有（private）、保护（protected）和公共（public）成员，而结构体通常没有这样的访问控制。

默认成员访问级别：
在某些语言中，如C++，类的成员默认是私有的，而结构体的成员默认是公共的。
构造函数和析构函数：
类可以有构造函数和析构函数，用于初始化和销毁对象。结构体可能没有构造函数和析构函数，或者其行为与类不同。
多态：
类支持多态性，可以通过虚函数实现。结构体通常不支持多态性。
内存分配：
在某些语言中，类的实例通常在堆上分配，而结构体的实例可能在栈上分配。这会影响它们的性能和生命周期。
用途：
类通常用于创建具有复杂行为的对象，而结构体通常用于存储简单的数据集合。
可变性：
在某些语言中，结构体的实例在创建后通常是不可变的，而类的实例可以被修改。
值类型与引用类型：
结构体通常被视为值类型，意味着它们在赋值或作为参数传递时会进行复制。类则被视为引用类型，赋值或传递的是对象的引用。
垃圾回收：
在某些语言中，类实例可能受垃圾回收机制管理，而结构体实例则不是。
深拷贝和浅拷贝
浅拷贝（Shallow Copy）
浅拷贝创建了原始对象的一个新实例，但是这个新实例中的元素（如果对象是复合类型，比如列表、数组或自定义对象）是原始对象中元素的引用。换句话说，浅拷贝只是复制了对象的引用，并没有复制对象内部的数据。
优点：创建速度快，因为不需要复制对象内部的数据。
缺点：如果原始对象中的元素是可变的，那么修改这些元素会影响到浅拷贝对象中的对应元素，反之亦然。
深拷贝（Deep Copy）
深拷贝创建了原始对象的一个完全独立的副本，包括对象内部的所有数据。这意味着深拷贝会递归地复制对象中的所有元素，直到所有元素都是独立的副本。
优点：复制的对象完全独立，修改原始对象不会影响副本，反之亦然。
缺点：创建速度慢，因为需要复制对象内部的所有数据，包括递归复制嵌套的对象

虚函数和纯虚函数

虚函数（Virtual Function）：
定义：在基类中使用virtual关键字声明的函数。
目的：允许派生类重写（Override）基类中的方法，实现不同类对象调用同一接口时执行不同代码的功能。
调用：通过基类指针或引用调用时，将根据对象的实际类型来确定调用哪个函数，即使这个指针或引用被声明为基类类型
纯虚函数（Pure Virtual Function）：
定义：在基类中使用virtual关键字声明，并在函数声明末尾加上= 0的函数。
目的：强制派生类必须重写该函数，使得基类成为一个抽象类（Abstract Class），不能直接实例化。
调用：如果派生类没有重写纯虚函数，则任何尝试实例化该派生类或通过该派生类的指针/引用调用该函数的行为都是不允许的。
区别
实现要求：虚函数在基类中可以有实现，也可以没有；纯虚函数在基类中没有实现，且派生类必须提供实现。
抽象类：包含纯虚函数的类是抽象类，不能被实例化；而包含虚函数的类不一定是抽象类。
多态性：虚函数允许多态性，但不需要强制派生类重写；纯虚函数则强制派生类必须重写以实现多态性。
接口定义：纯虚函数常用于定义接口，确保派生类遵循某种协议；虚函数则更侧重于提供默认行为，派生类可以选择重写或继承。

指针和引用的区别

定义方式:
指针（Pointer）: 使用&运算符取得变量的地址，并使用*来操作该地址处的值。
引用（Reference）: 使用&在定义时必须被初始化，之后作为别名使用。
可变性:
指针: 可以被重新赋值为其他地址。
引用: 一旦被初始化，就不能改变引用的原始对象。
空值:
指针: 可以被设置为nullptr，表示没有指向任何对象。
引用: 不能引用nullptr，必须引用一个已存在的对象。
内存占用:
指针: 需要额外的内存空间来存储地址。
引用: 通常认为没有额外的内存开销，引用其实就是原始变量的别名。
运算:
指针: 可以使用指针运算，如递增指针（pointer++）。
引用: 不能进行引用运算，如递增或比较是否为空。
作用域:
指针: 可以在不同的作用域中使用，可以跨作用域存储地址。
引用: 必须在定义时初始化，并且作用域结束后引用就失效了。
与数组的关系:
指针: 可以很容易地操作数组和字符串。
引用: 可以作为函数参数，方便地传递数组的别名。
与函数参数:
指针: 可以作为函数参数，但需要考虑指针的所有权和生命周期。
引用: 通常用于函数参数，以避免复制大对象，同时保持对原始对象的引用。
内存释放:
指针: 使用delete或delete[]来释放动态分配的内存。
引用: 不需要释放内存，因为它们不拥有对象。
多重赋值:
指针: 一个指针可以指向多个对象（通过复制指针的值）。
引用: 一个引用在任何时刻只能绑定到一个对象。
类型转换:
指针: 可以进行隐式或显式的类型转换。
引用: 不能进行类型转换。
与const关键字:
指针: 可以定义指向const类型或const指针本身。
引用: 可以是const引用，但不能是对const类型的引用（即不能引用一个const对象）。

静态绑定、动态绑定
静态绑定（Static Binding）：
也称为早绑定（Early Binding）。
静态绑定在编译时就确定了方法调用的地址。
通常用于非虚函数的调用，编译器知道调用哪个函数版本。
因为绑定在编译时就完成了，所以调用的开销较小，执行速度较快。
由于绑定发生在编译时，所以不支持多态，即不能在运行时改变绑定的行为。
动态绑定（Dynamic Binding）：
也称为晚绑定（Late Binding）。
动态绑定在程序运行时确定方法调用的地址。
通常用于虚函数的调用，运行时系统根据对象的实际类型来确定调用哪个函数。
因为需要在运行时解析，所以调用的开销相对较大。
支持多态性，允许通过基类指针或引用调用派生类的方法，这使得运行时改变行为成为可能。
区别：
绑定时间: 静态绑定在编译时完成，而动态绑定在运行时完成。
性能: 静态绑定由于在编译时就确定了函数地址，所以执行速度通常更快。动态绑定需要运行时查找，因此速度较慢。
多态性: 动态绑定支持多态性，允许通过基类接口使用派生类的实现。静态绑定不支持多态性。
类型检查: 静态绑定在编译时进行类型检查，而动态绑定在运行时进行类型检查。
使用场景: 静态绑定适用于性能敏感且不需要多态的情况。动态绑定适用于需要多态和运行时决策的场景。

delete[]的含义

在C++中，delete[]是一个运算符，用于删除之前使用new[]运算符分配的数组类型的动态内存。当你使用new[]创建了一个数组，并在不再需要这个数组时，应该使用delete[]来释放分配的内存，以避免内存泄漏。
以下是delete[]的一些关键点：
释放数组内存：delete[]释放由new[]分配的整个数组的内存。
匹配new[]：delete[]必须与new[]配对使用。如果使用new分配了一个数组元素，应该使用delete而不是delete[]来释放内存。
数组指针：delete[]后面跟的应该是一个指向数组的指针。
内存泄漏：如果不再使用动态分配的数组，但不调用delete[]，将导致内存泄漏。
undefined behavior：如果尝试对一个未被new[]分配的指针使用delete[]，或者对同一个指针多次调用delete[]，将会导致未定义行为。
析构函数：对于包含构造函数的对象数组，delete[]会自动调用每个数组元素的析构函数，然后释放内存。
空指针安全：delete[]对空指针的调用是安全的，不会执行任何操作

对象的大小与什么有关

数据类型：
对象中字段的数据类型影响其大小。例如，整型（int）通常占用32位或64位（取决于平台），而浮点型（float或double）分别占用32位和64位。
字段数量：
对象包含的字段越多，其占用的内存空间通常越大。
继承：
如果对象是某个类的实例，而这个类继承自另一个类，那么子类对象的大小将包括所有父类字段的大小。
对齐和填充：
为了优化内存访问，编译器可能会在对象的字段之间插入填充字节，以确保数据按照特定的边界对齐。这可能会增加对象的大小。
对象头：
几乎所有的对象都会包含一个对象头（Object Header），用于存储如对象的类型信息、同步锁等元数据。这个头部的大小取决于平台和JVM实现。
引用大小：
在某些语言中，对象的引用本身也占用一定的空间。例如，在64位JVM中，每个对象引用占用64位。
存储实现：
对象的存储实现方式也会影响其大小。例如，使用指针引用其他对象会占用额外的空间。
垃圾收集器的影响：
某些垃圾收集器可能会在对象中添加额外的内存用于跟踪对象的引用，这会影响对象的大小。
动态类型语言的特性：
在动态类型语言中，对象的大小可能还受到运行时类型信息的影响。
数组或集合：
如果对象包含数组或集合类型的字段，这些字段的大小也会直接影响对象的总大小。
自定义序列化信息：
对象如果需要序列化，可能会包含额外的序列化信息，这也会影响其大小。
平台和编译器：
不同的平台和编译器可能会对对象的内存布局有不同的优化和实现方式，从而影响对象的大小。

C++内存分区

栈（Stack）：
局部变量和函数调用的上下文信息存储在这里。
栈是后进先出（LIFO）的数据结构，由编译器自动管理。
堆（Heap）：
动态内存分配的区域，使用new和delete操作符进行分配和释放。
堆是程序员手动管理的内存区域，需要显式分配和释放。
全局/静态存储区（Global/Static Storage）：
包含全局变量和静态变量。
这些变量的生命周期贯穿整个程序，初始化在程序启动时进行。
文字常量区（String Literals）：
存储字符串常量，如"Hello, World!"。
这些常量通常存储在只读数据段中。
程序代码区（Code Segment/Text Segment）：
存储程序的可执行代码和只读数据。
这部分内存在程序运行时是不可写的。
数据段（Data Segment）：

存储已初始化的全局变量和静态变量。
BSS段（BSS Segment）：
存储未初始化的全局变量和静态变量。
BSS代表“Block Started by Symbol”，这些变量在程序启动时被初始化为零。
寄存器（Registers）：
CPU内部的高速存储区域，用于快速访问变量和指令。
内存映射区（Memory-Mapped I/O）：
某些硬件设备映射到内存地址空间的区域，可以通过读写这些地址来与硬件交互。
栈溢出（Stack Overflow）：
当函数调用太深或局部变量太大，超出栈的容量时，会发生栈溢出。
堆碎片（Heap Fragmentation）：
频繁的内存分配和释放可能导致堆内存碎片化，影响性能。

NULL和nullptr的区别

来源:
NULL: 宏定义，通常在或其他标准头文件中定义，具体值依赖于实现，但传统上定义为 0 或 (void*)0。
nullptr: C++11引入的字面量，不是宏，类型为 std::nullptr_t。
类型安全:
NULL: 由于它可能是定义为 0 或者 (void*)0，所以它在类型上不够安全，可以隐式转换为任何指针类型。
nullptr: 类型安全，只能转换为指针类型或 std::nullptr_t 类型。
兼容性:
NULL: 与C语言兼容，可以用于C和C++代码中。
nullptr: 仅C++11及以后版本支持。
使用场景:

NULL: 可用于需要表示空指针的任何上下文，特别是在C++03及之前的版本中。
nullptr: 推荐在C++11及以后版本中使用，因为它提供了更好的类型检查。
转换:
NULL: 可以隐式转换为任何指针类型，这可能导致类型不匹配的问题。
nullptr: 只能转换为指针类型，并且编译器会进行严格的类型检查。
表达式:
NULL: 在某些旧代码或库中可能仍然使用，尤其是在需要与C兼容的接口中。
nullptr: 在C++11中推荐使用，因为它是C++标准的一部分。
代码清晰度:
nullptr 的使用使得代码更加清晰，明确表示了空指针的意图。
宏问题:
NULL 作为宏，可能在宏展开时引起意外行为，尤其是在复杂的表达式中。
nullptr 作为字面量，不会有宏展开的问题。

操作系统

有三个线程ABC，C必须在A和B运行完之后才能运行，应该怎样实现？
使用互斥锁（Mutex）和条件变量
使用信号量（Semaphore）
使用线程的join函数：
使用std::future和std::async：

如何定位内存泄漏：

使用内存检测工具：
使用如 Valgrind、AddressSanitizer、LeakSanitizer 等内存检测工具来检测内存泄漏。
编写测试用例：
编写自动化测试用例，运行程序并监控内存使用情况，确保在程序的不同阶段没有内存泄漏。
代码审查：
通过代码审查来识别可能的内存泄漏风险点，如未释放的动态分配内存。
使用智能指针：
使用 std::unique_ptr、std::shared_ptr 等智能指针来自动管理内存，减少内存泄漏的风险。
RAII（Resource Acquisition Is Initialization）：
利用RAII原则，确保资源的获取和释放与对象的生命周期绑定，当对象超出作用域时自动释放资源。
日志记录：
在内存分配和释放的地方添加日志记录，以便于跟踪内存使用情况。
分析调用栈：
当检测到内存泄漏时，分析调用栈来确定泄漏发生的位置。
性能分析工具：
使用性能分析工具（如 gperftools）来监控程序的内存分配和释放，帮助定位内存泄漏。
编写析构函数：
确保析构函数正确实现，以便在对象生命周期结束时释放所有分配的资源。
避免循环引用：
如果使用 std::shared_ptr，确保使用 std::weak_ptr 来避免循环引用。

讲一下程序从源代码到可执行程序经过了哪些步骤？（预处理、编译、汇编、链接）每个步骤都做了什么事？

预处理（Preprocessing）：
预处理是编译过程的第一步，由预处理器完成。
预处理器执行的任务包括处理源代码文件中的预处理指令，如 #include 指令（包含头文件），#define 指令（定义宏），条件编译指令（如 #if, #ifdef, #endif）等。
预处理的结果通常是一个或多个经过预处理的源文件，这些文件包含了实际的编译内容。
编译（Compilation）：
编译步骤将预处理后的源代码转换成汇编代码。
编译器（如 GCC 或 Clang）对源代码进行语法分析、语义分析，生成中间表示（Intermediate Representation, IR），然后转换成目标机器的汇编代码。
编译器还会进行一些优化，以提高程序的执行效率。
汇编（Assembly）：
汇编步骤将编译生成的汇编代码转换成机器代码。
汇编器（Assembler）读取汇编代码，将其转换成机器指令，生成目标文件（Object File），通常以 .o 或 .obj 为扩展名。
目标文件包含了程序的机器级指令和一些符号信息，但还不能直接执行，因为它们还没有被链接。
链接（Linking）：
链接步骤将一个或多个目标文件以及它们所依赖的库链接成最终的可执行文件。
链接器（Linker）负责解析目标文件中的符号引用，将它们与定义这些符号的其他目标文件或库文件链接起来。
链接过程包括地址和空间分配、符号解析、重定位等任务。
最终生成的可执行文件包含了程序的所有指令和数据，以及必要的库和资源，可以直接在操作系统上运行。

除了这四个主要步骤，还有一些其他相关的概念和步骤：

优化（Optimization）：在编译过程中，编译器可能会进行代码优化，以提高程序的性能或减少程序的大小。
代码生成（Code Generation）：编译器将源代码转换成机器代码的过程
库（Libraries）：程序可能依赖于外部库，这些库在链接时被包含进来
可执行文件（Executable）：最终生成的文件，包含了程序的所有指令和数据，可以由操作系统加载和执行。

线程和进程的区别？为什么不可以一个进程包含很多个线程呢反而是很多个进程呢？

进程（Process）：
定义：进程是操作系统进行资源分配和调度的一个独立单位，是应用程序运行的实例。
地址空间：每个进程拥有独立的地址空间，进程间内存是相互隔离的，一个进程的代码和数据不能被直接访问。
资源占用：进程拥有独立的系统资源，如文件句柄、子进程、管道等。
创建和销毁开销：进程的创建和销毁开销相对较大，因为涉及到系统资源的分配和回收。
通信方式：进程间通信（IPC）相对复杂，需要使用特定的IPC机制，如管道、消息队列、共享内存、套接字等。
线程（Thread）：
定义：线程是程序执行的最小单位，是操作系统能够进行运算调度的最小单位，一个进程可以包含多个线程。
地址空间：同一进程内的线程共享进程的地址空间，即共享代码、数据和堆等资源。
资源占用：线程相比进程更轻量级，它们共享父进程的资源，因此创建和销毁的开销较小。
执行并发性：线程可以提高程序的并发性，因为同一进程中的多个线程可以同时执行不同的任务。
通信方式：线程间通信较为简单，因为它们共享相同的内存空间，可以直接访问共享数据。

为什么不可以一个进程包含很多个线程而是很多个进程？

资源共享：一个进程包含多个线程可以更高效地利用资源，因为线程共享相同的内存空间和资源，避免了进程间通信的复杂性和开销。
上下文切换：线程之间的上下文切换比进程之间的上下文切换要快，因为线程共享相同的地址空间，不需要重新加载内存地址。
设计简化：使用多线程而不是多进程可以简化程序设计，因为线程共享数据和资源，减少了数据同步和共享的复杂性。
并发性能：多线程可以提高程序的并发性能，因为多个线程可以同时执行，利用多核处理器的优势。
内存管理：多线程共享相同的内存空间，减少了内存占用，而多进程需要为每个进程分配独立的内存空间。
操作系统支持：现代操作系统通常支持多线程模型，提供了丰富的线程管理和同步机制。

讲一下死锁？发现死锁后如何解决？

死锁是指在多任务环境中，两个或多个进程在执行过程中因争夺资源而造成的一种僵局。当这些进程中的每一个都持有一定的资源并等待其他进程释放它们所需的资源时，如果这些资源都被其他进程占有且不释放，那么所有进程都将无法继续执行，进入死锁状态。
互斥条件：进程对所分配到的资源进行排他性使用，即在一段时间内某资源只能被一个进程使用。
占有和等待条件：进程至少已经占有一个资源，并且在等待获取其他进程占有的资源。
不可剥夺条件：已经分配给一个进程的资源，在未使用完之前，不能被强行剥夺，只能由该进程自己释放。
循环等待条件：存在一种进程资源的循环等待关系，即进程间形成一种头尾相接的循环链

进程间通信方式

管道（Pipes）
命名管道（Named Pipes）：
消息队列（Message Queues）：
信号（Signals）信号是一种由操作系统提供的简单通信机制，用于通知进程某个事件已经发生。
共享内存（Shared Memory）
套接字（Sockets
信号量（Semaphores）：
信号量是一种同步机制，用于控制对共享资源的访问，通常用于防止竞态条件。
互斥锁（Mutexes）：
条件变量（Condition Variables）：
事件（Events）：

匿名/有名管道的底层实现，匿名管道在内存中为什么还有fd（虚拟文件系统统一了访问文件的接口，匿名管道可看作是在内存中的文件）

什么样的函数会影响性能

影响性能的函数通常具有以下特点：

复杂度高：时间复杂度或空间复杂度高的函数，如 O(n^2)、O(n^3) 或更高阶的多项式时间复杂度，可能会显著影响性能。
频繁调用：即使单个调用的开销不大，但如果一个函数被频繁调用，其总的执行时间也可能变得很高。
重复计算：执行相同或可预测结果的重复计算，尤其是可以预先计算并存储结果的情况。
阻塞操作：导致程序等待的函数，如等待I/O操作完成、等待网络响应或等待锁释放。
资源密集型：需要大量内存、CPU或I/O资源的函数，可能会因为资源争用而影响性能。
低效的算法实现：即使算法本身效率较高，如果实现不当，也可能导致性能问题。
递归调用：深度递归可能会导致大量的函数调用开销，并且有可能导致堆栈溢出。
锁竞争：在多线程环境中，频繁的锁申请和释放，尤其是在锁竞争激烈的情况下，会严重影响性能。
全局变量访问：频繁访问全局变量可能导致缓存一致性问题，尤其是在多核处理器上。
内存分配：频繁的动态内存分配和释放，尤其是在堆上分配大量小对象，可能会导致内存碎片化和性能下降。
不恰当的数据结构：使用不适合当前问题的数据结构，例如使用链表实现需要频繁随机访问的场景。
冗余数据处理：进行不必要的数据复制、转换或格式化操作。
系统调用：频繁进行系统调用，尤其是那些涉及硬件或操作系统底层操作的调用。
不优化的数据库访问：执行低效的数据库查询，如没有正确使用索引、执行全表扫描或产生大量临时表。
网络通信：在分布式系统中，网络延迟和带宽限制可能会影响性能。
图形和图像处理：进行复杂的图形渲染或图像处理操作，尤其是在实时应用中。
浮点运算密集：大量的浮点运算可能会影响性能，尤其是在没有专用硬件加速的情况下。

epoll用的ET还是LT

epoll 是 Linux 内核提供的一种高效的事件通知机制，用于监控文件描述符（通常是套接字）上的 I/O 事件。epoll 支持两种模式的事件触发：
水平触发（Level-Triggered，LT）：
在水平触发模式下，只要某个事件（如可读、可写）的条件满足，它就会持续地通知应用程序。应用程序必须显式地从文件描述符中读取或写入数据，以清除挂起的事件。

边缘触发（Edge-Triggered，ET）：
边缘触发模式只在事件发生的“边缘”时通知应用程序，即从无到有的变化时。这种模式下，应用程序需要明确地告诉 epoll 它已经处理了数据，以便 epoll 可以继续监控后续的事件。

epoll相比select的优化
文件描述符数量：
select有一个最大文件描述符数量限制（通常为1024），这意味着它不能同时监控超过这个数量的文件描述符。而 epoll 没有这个限制，可以监控的文件描述符数量远超select。
时间复杂度：
select 的时间复杂度为 O(n)，其中 n 是监控的文件描述符数量。这意味着当文件描述符数量增加时，select 的性能会线性下降。
epoll 的时间复杂度为 O(1)，即它处理的效率与监控的文件描述符数量无关，因此在处理大量文件描述符时，epoll 性能更优。
挂起和唤醒效率：
select 在调用时会挂起所有监控的文件描述符，直到它们中的至少一个准备好I/O操作或超时。如果大量文件描述符都未准备好，这会导致不必要的CPU资源浪费。
epoll 仅监控准备好I/O操作的文件描述符，并且在有文件描述符状态变化时才唤醒应用程序，减少了无谓的挂起和唤醒。
水平触发与边缘触发：
select 仅支持水平触发（LT）模式，这意味着它在每次调用时都会检查所有文件描述符的状态，即使它们的状态没有变化。
epoll 支持水平触发和边缘触发（ET）模式，边缘触发模式只在状态变化时通知应用程序，这可以减少不必要的通知，提高效率。

内存和CPU使用：

select 需要将文件描述符集合复制到内核空间，随着监控的文件描述符数量增加，内存和CPU使用也会增加。
epoll 使用更高效的数据结构（红黑树和链表），减少了内存和CPU的使用。
可扩展性：
由于 select 的性能随着监控的文件描述符数量线性下降，它不适合用于大量并发连接的场景。
epoll 由于其高效性，更适合用于高并发的网络服务。
单线程与多线程：
select 通常用于单线程环境，因为它在处理文件描述符时是阻塞的。
epoll 可以用于单线程或多线程环境，因为它可以非阻塞地处理I/O事件。
边缘触发的灵活性：
在 epoll 中，边缘触发模式允许应用程序更细粒度地控制I/O事件的处理，减少了因频繁轮询带来的CPU负载。

栈和堆

栈（Stack）：
数据结构：栈是一种遵循后进先出（LIFO, Last In First Out）原则的数据结构。只能在栈顶添加或移除元素。
内存分配：在程序执行过程中，局部变量通常存储在栈上，由编译器自动分配和释放。
速度：栈的内存分配和释放速度很快，因为它不需要搜索整个内存空间来找到空闲区域。
大小限制：栈通常有大小限制，不同的系统和编译器栈的大小不同，超出栈的大小限制会导致栈溢出。
使用场景：主要用于函数调用时存储参数、局部变量和返回地址等。
堆（Heap）：
数据结构：堆是一种可以被看作是优先队列的数据结构，通常用于实现排序算法，如二叉堆。
内存分配：堆用于动态内存分配，程序员可以使用 new（C++）或 malloc（C）等操作符在堆上分配内存。
速度：堆的内存分配和释放速度通常比栈慢，因为可能需要搜索整个内存空间来找到足够大的空闲区域，并且分配和释放操作可能涉及内存碎片整理。
大小限制：堆的大小通常受到系统资源的限制，但远大于栈，有时甚至没有固定大小限制。
使用场景：用于存储动态分配的对象，其生命周期不由创建它们的函数调用决定，例如，使用 new 创建的对象需要显式地使用 delete 来释放。
在内存管理中的区别：
分配方式：栈内存由编译器自动管理，而堆内存由程序员手动管理。
生命周期：栈上的对象在函数调用结束后自动销毁，堆上的对象需要程序员明确释放，否则会造成内存泄漏。
访问方式：栈上的数据可以通过它们的地址直接访问，堆上的数据需要通过指针或引用来访问。
性能：栈内存分配和释放通常更快，因为它们在函数调用时自动进行，而堆内存管理可能涉及更复杂的内存管理策略。

怎么解决内存碎片多

内存碎片是指在计算机系统中，由于内存分配和释放导致的内存空间不连续现象。内存碎片过多会影响程序的性能，甚至导致内存溢出。以下是一些解决内存碎片问题的方法：

内存池（Memory Pools）：
使用内存池可以预先分配一块大的内存区域，并在该区域内管理小块内存的分配和释放，减少外部碎片。
碎片整理工具：
某些操作系统或第三方工具提供了内存碎片整理功能，可以优化内存的使用。
优化数据结构：
选择合适的数据结构来减少内存分配的频率和大小，避免频繁的小块内存分配。
对象池（Object Pools）：
重用对象而不是频繁地创建和销毁，可以减少内存碎片。
按需分配：
仅在需要时才分配内存，避免提前或过度分配。
合理规划内存分配：
尽量使内存分配的大小和数量适应程序的实际需求，避免分配过大或过小的内存块。
使用标准库容器：
标准库容器（如 std::vector、std::list 等）通常已经优化了内存分配策略，可以减少内存碎片。
避免频繁的小块内存分配：
频繁地分配和释放小块内存容易产生内部碎片，应尽量避免。
使用自定义分配器：
对于C++，可以使用自定义的分配器来控制内存分配的细节，以减少碎片。
定期清理内存：
在程序运行过程中，定期释放不再使用的内存，可以减少内存碎片的积累。
使用垃圾回收语言：
如果可能，使用具有自动垃圾回收功能的编程语言，如Java或C#，它们可以自动管理内存碎片问题。
操作系统调优：
调整操作系统的内存管理参数，如堆大小、内存分配器等，以减少内存碎片。
避免全局变量：
全局变量的生命周期与程序相同，可能导致内存长时间不被释放。
使用内存映射文件：
内存映射文件可以提供大块的连续内存，减少内存碎片。
分析和监控：
使用内存分析工具监控内存使用情况，及时发现和解决内存碎片问题。
避免缓存滥用：
缓存可以提高性能，但滥用缓存可能导致内存占用过高和碎片化。
代码优化：
优化代码逻辑，减少不必要的内存分配和释放操作。

ET模式下，读写操作都发生了什么

注册事件：
首次通知：
非阻塞读写：
处理EPOLLIN事件（读操作）：
处理EPOLLOUT事件（写操作）：
清除事件：
控制事件的再次监控：
EPOLLONESHOT的使用：
错误处理：

缺页中断过程，页表项怎么更新的，怎么得到页表的地址

缺页中断（Page Fault）是当程序试图访问一个未加载到物理内存中的页面时，由操作系统处理的中断。以下是处理缺页中断的一般过程：

触发缺页中断：
当程序访问的数据不在物理内存中时，硬件触发缺页中断信号。
保存当前上下文：
操作系统保存当前进程的状态，包括程序计数器、寄存器等。
分析缺页原因：
操作系统检查缺页的原因，可能是页面未加载、页面被置换出内存，或者访问了无效的地址。
页面置换算法：
如果内存不足以加载新页面，操作系统使用页面置换算法选择一个或多个页面进行置换。
加载页面：
操作系统从磁盘或其他存储设备中读取所需的页面到物理内存中。
更新页表：
操作系统更新页表项，将新加载的页面的物理地址写入页表项，并设置相应的状态位（如P位，表示页面在内存中）。
恢复程序执行：
操作系统恢复进程的上下文，程序从引发缺页中断的指令处重新执行。
处理页表地址转换：
当程序再次访问相同的数据时，硬件页表能够根据更新后的页表项将虚拟地址转换为物理地址。

页表项的更新：

页表项通常包含以下信息：

P（Present）位：表示页面是否在物理内存中。
物理地址：页面在物理内存中的位置。
访问权限：例如读/写权限。
其他状态信息：如修改位（Modified），表示页面自加载到内存以来是否被修改过。
在缺页中断处理过程中，操作系统会检查页表项，如果页面不在内存中，它会：
将P位设置为1，表示页面现在在内存中。
将物理地址填入页表项。
可能还会设置其他状态位，如修改位。

得到页表的地址：

页表的地址可以通过以下方式获得：

页表基址寄存器：在许多架构中，有一个专门的寄存器（如x86架构的CR3寄存器）用于存储当前页表的基地址。
操作系统管理：操作系统管理页表的内存区域，它知道页表的起始地址和大小。
页目录和页帧：在多级页表结构中，页目录的地址首先通过页表基址寄存器获得，然后通过页目录项可以找到页表的物理帧，最后映射到虚拟地址。
内存管理单元（MMU）：MMU硬件负责将虚拟地址转换为物理地址，它使用页表来完成这个转换。
缺页中断是现代操作系统内存管理的关键部分，它允许操作系统以按需加载页面的方式管理内存资源。这个过程需要操作系统、硬件和内存管理单元（MMU）之间紧密协作。

用户态和内核态

在操作系统中，用户态和内核态是两种不同的执行模式，它们具有不同的权限级别和访问控制：

用户态（User Mode）：
- 用户态是操作系统为普通应用程序和用户程序提供的一种执行环境。
- 在用户态下运行的程序只能访问有限的系统资源和执行有限的操作，例如读写文件、网络通信等。
- 用户态程序不能直接访问硬件设备，也不能执行某些特权指令，如修改内存管理单元（MMU）的设置、访问其他进程的内存空间等。
- 用户态的目的是保护系统安全，防止用户程序意外或恶意地破坏系统或影响其他程序的运行。
内核态（Kernel Mode）：
- 内核态是操作系统的核心部分，通常在系统启动时进入内核态，并在执行系统调用、处理中断或异常时切换到内核态。
- 在内核态下运行的程序具有更高的权限，可以访问所有硬件资源和执行所有指令，包括特权指令。
- 内核态程序可以执行内存管理、进程调度、设备驱动等操作，这些操作通常需要对系统硬件和资源有深入的控制。
- 内核态的主要任务是管理和调度用户态程序，确保系统的稳定和安全。
  在现代操作系统中，用户态和内核态之间的切换是通过系统调用和中断处理机制实现的。当用户程序需要执行超出其权限范围的操作时，它会发起一个系统调用请求，操作系统内核会处理这个请求并在必要时切换到内核态执行相应的操作。完成操作后，内核会将控制权返回给用户程序，并切换回用户态。
  这种设计的主要优点是：

安全性：限制用户程序的权限，防止它们访问或修改关键系统资源。
稳定性：即使用户程序发生错误或被恶意攻击，也不会直接影响到操作系统的核心功能。
资源管理：内核可以更有效地管理和调度系统资源，确保所有程序公平地共享硬件。
了解用户态和内核态的概念对于理解操作系统的工作原理和编写高效、安全的程序非常重要。

malloc底层怎么实现的，内存碎片怎么处理

malloc 是 C 语言标准库中的一个函数，用于动态分配内存。其底层实现通常依赖于操作系统和编译器的内存管理机制。以下是 malloc 通常的实现原理和内存碎片的处理方法：

`malloc` 的底层实现原理：

内存分配器：malloc 通常由内存分配器（如 ptmalloc、jemalloc 等）实现，这些分配器负责管理堆（heap）内存。
堆内存：堆是一块可以动态分配和释放的内存区域，操作系统在程序启动时为其分配一定的空间。
数据结构：内存分配器使用各种数据结构（如链表、树、哈希表等）来跟踪内存块的状态（已分配、空闲等）。
内存请求：当调用 malloc 时，分配器会根据请求的大小查找合适的空闲内存块。如果找到合适大小的块，分配器会将其标记为已分配并返回给用户。
内存对齐：为了提高内存访问效率，分配器通常会对分配的内存进行对齐处理，确保内存地址符合特定的对齐要求。
内存分配策略：分配器可能采用多种策略来分配内存，如首次适应（first-fit）、最佳适应（best-fit）和最差适应（worst-fit）等。

内存碎片的处理：

内存碎片是指由于频繁分配和释放内存导致的内存空间不连续，影响内存使用效率的现象。以下是一些处理内存碎片的方法：

内存整理：定期或在特定条件下对空闲内存进行整理，合并相邻的空闲块，减少碎片。
内存池：为特定大小的内存请求创建内存池，预先分配一定数量的固定大小内存块，以减少碎片。
碎片回收：在内存分配器中实现碎片回收机制，当空闲内存块足够大时，将其回收并重新利用。
内存压缩：在某些情况下，可以尝试压缩已分配的内存块，以减少空闲空间并减少碎片。
内存碎片检测：定期检测内存碎片的程度，并在必要时采取行动，如内存整理或压缩。
使用高效的内存分配器：选择或开发高效的内存分配器，这些分配器可以更好地管理内存并减少碎片。
避免频繁的内存分配和释放：设计程序时尽量避免频繁地分配和释放小内存块，这可以减少碎片的产生。
内存分配策略优化：根据程序的内存使用模式优化内存分配策略，如使用最佳适应或首次适应算法。
内存分配器的实现和内存碎片的处理是操作系统和编译器层面的复杂问题，通常由专业的内存管理专家进行优化和维护。作为程序员，了解这些原理有助于编写更高效的程序，但具体的内存管理实现通常由底层系统处理。

虚拟内存

虚拟内存是操作系统用来扩展可用内存容量的一种技术，它通过将虚拟地址映射到物理内存地址来实现。以下是虚拟内存的一些主要作用：
内存抽象：虚拟内存为每个进程提供了一个连续的、大容量的地址空间，隐藏了物理内存的实际布局和大小。
内存空间扩展：允许系统使用比实际物理内存更多的内存。当物理内存不足时，操作系统可以将部分数据暂时存储到磁盘上，这个过程称为“分页”或“交换”。
多任务处理：虚拟内存使得多个进程能够同时运行，每个进程都有自己独立的地址空间，互不干扰。
内存保护：每个进程只能访问自己的虚拟地址空间，操作系统通过硬件和软件机制确保进程不会访问或修改其他进程的内存。
内存碎片管理：虚拟内存的分页机制有助于减少内存碎片，因为操作系统可以更容易地分配和回收内存块。

共享内存：虚拟内存允许多个进程共享同一块物理内存区域，这对于进程间通信非常有用。
内存访问局部性：操作系统可以利用虚拟内存来实现内存访问的局部性原理，即程序倾向于在一段时间内重复访问一小部分数据。通过预加载和页面置换算法，操作系统可以优化内存使用。
程序动态加载：虚拟内存允许程序的代码和数据在需要时才加载到内存中，而不是一次性全部加载，这有助于减少程序启动时间。
内存访问权限控制：操作系统可以为不同的内存区域设置不同的访问权限，如只读、读写等，以增强系统的安全性。
内存映射文件：虚拟内存允许将文件直接映射到进程的地址空间中，这使得文件访问和内存访问具有相同的性能。

中断发生时，进程的信息保存到什么位置

寄存器：
内核栈：
进程控制块（Process Control Block, PCB）：
任务状态段（Task State Segment, TSS）：
内存：
页表：
硬件描述符：
中断服务程序的局部变量：
系统调用栈：
硬件寄存器：

系统调用原理

用户程序请求：
用户程序通过库函数（如C标准库中的系统调用包装器）发起一个系统调用请求。
库函数封装：
库函数将系统调用的参数封装好，并准备通过中断或软件中断指令触发系统调用。
触发系统调用：
用户程序通过执行如int 0x80（在x86架构的Linux系统中）这样的软件中断指令，或者通过其他机制（如在x64架构中通过syscall指令），来触发系统调用。
上下文切换：
中断发生后，CPU从用户态切换到内核态，硬件会自动保存当前的寄存器状态，并加载操作系统内核的栈。
参数传递：
系统调用的参数通过特定的寄存器或者堆栈传递给内核。
系统调用分派：
内核中的系统调用分派器（System Call Dispatcher）根据传递的系统调用号，确定具体要执行的系统调用函数。
执行系统调用：
内核执行相应的系统调用处理程序，该程序实现了系统调用的实际功能。
资源管理：
系统调用处理程序可能会涉及到资源的分配、访问控制、文件操作等。
处理结果：
系统调用完成后，内核将结果返回给用户程序。如果调用成功，返回特定的值；如果失败，返回错误码。
上下文恢复
系统调用完成后，内核恢复用户程序的上下文，包括寄存器状态和用户栈。
返回用户程序：
用户程序从系统调用点继续执行，此时系统调用的返回值已经可以通过寄存器获得。

标题32位系统和64位系统开发有哪些不同，需要注意哪些问题

32位系统和64位系统在开发时存在一些关键的差异和需要注意的问题，主要包括以下几点：
数据类型大小：在32位系统中，int、long和pointer通常都是32位（4字节），而在64位系统中，long和pointer变为64位（8字节），而int通常保持为32位1。这可能导致数据截断问题，特别是在将long或pointer赋值给int时。
数据模型：32位应用通常遵循ILP32模型（int, long, pointer都是32位），而64位应用遵循LP64模型（long和pointer是64位，其他不变）1。
整数和指针操作：32位代码中经常将指针转换为int或unsigned int进行算术运算，而在64位系统中，这种做法可能不再适用。建议使用uintptr_t和intptr_t来保证移植性1。
结构体对齐和填充：在64位系统中，由于对齐要求的变化，结构体的内存布局可能会不同，导致sizeof的结果也不同1。
联合体（Union）：如果联合体中包含不同长度的数据类型，在64位系统中可能需要调整以保持所有成员的大小一致1。
常量类型：在64位系统中，常量表达式可能会丢失精度，导致数据截断。例如，左移操作可能超出数据类型的长度1。

格式化输入输出：使用printf系列函数时，需要注意格式字符串和参数类型是否匹配64位系统的要求1。
sizeof操作符：sizeof返回的类型在64位系统中是unsigned long，如果赋值给int可能会发生截断1。
系统调用和API：一些系统调用和API在32位和64位系统之间可能有所不同，需要注意调用约定和数据类型的变化。
性能考虑：64位系统可能因为更大的指针和数据对齐要求而导致性能差异，需要考虑缓存效率和内存带宽的使用。
字节序问题：不同平台的字节序（Endian）可能不同，这可能影响多字节数据的解释，尤其是在数据共享或网络传输时2。
混合编程：如果程序涉及C和Fortran等不同语言的混合编程，需要注意数据类型和调用约定的一致性，以避免数据截断或错误2。
编译器和工具链：使用编译器时，可能需要特定的选项来生成32位或64位代码，如GCC的-m32和-m64选项2。
共享数据：在32位和64位系统间共享数据时，需要注意数据结构的大小和布局，以确保兼容性2。
操作系统和应用程序支持：随着操作系统和应用程序逐渐停止对32位的支持，需要考虑兼容性和未来的支持问题

标题timerfd操作系统的执行流程

timerfd 是 Linux 操作系统提供的一种定时器抽象，它允许应用程序创建一个定时器，当定时器到期时，可以向应用程序发送通知。timerfd 通常用于实现高精度的定时器和超时机制。以下是使用 timerfd 的基本执行流程：
创建 timerfd: 使用 timerfd_create 系统调用创建一个新的定时器文件描述符。这个调用需要指定定时器的类型（如相对定时器或绝对定时器）和定时器的时钟（如实时时钟或单调时钟）。
设置定时器: 使用 timerfd_settime 系统调用设置定时器的初始值和间隔。这个调用允许你指定定时器何时开始以及之后多久重复。
等待定时器到期: 应用程序可以通过多种方式等待定时器到期：使用 read 系统调用读取定时器文件描述符。当定时器到期时，文件描述符将返回一个64位的整数，表示定时器到期的次数。
使用 select, poll, 或 epoll 等 I/O 多路复用机制等待文件描述符可读。
处理定时器到期: 当定时器到期时，应用程序可以根据需要执行相应的操作。如果定时器设置为重复，应用程序可以再次设置定时器以继续等待下一次到期。
关闭 timerfd: 当定时器不再需要时，使用 close 系统调用关闭定时器文件描述符。
错误处理: 在使用 timerfd 的过程中，需要适当地处理可能发生的错误，例如设置定时器失败或读取文件描述符失败。

.## Linux系统中文件如何存储：
文件系统（Filesystem）：
Linux系统中的文件存储在文件系统中，常见的文件系统有ext4、XFS、Btrfs等。
文件系统提供了一种层次结构来组织文件和目录。
inode（索引节点）：
文件系统中的每个文件都有一个inode，它包含了文件的元数据，如文件大小、权限、时间戳等，但不包括文件名。
inode与文件名通过目录项（dentry）关联。
目录结构:
Linux系统中的文件存储采用树状目录结构，以根目录/开始，然后是子目录和文件。
文件类型：
Linux系统中有多种文件类型，包括普通文件、目录文件、符号链接、设备文件、管道文件、套接字文件等。
数据存储：
文件数据存储在磁盘上，文件系统会将数据分割成块或页进行存储。
文件系统会跟踪哪些块或页被使用，哪些是空闲的。
挂载（Mount）：
文件系统需要挂载到一个挂载点才能使用，挂载点通常是目录。
日志和元数据：
一些文件系统（如ext4、XFS）使用日志来记录文件系统的操作，以提高数据的一致性和可靠性。
文件访问：
通过打开文件描述符来访问文件，文件描述符是一个指向inode的引用。

自旋锁和互斥锁区别

工作方式:
自旋锁: 当一个线程尝试获得一个已被占用的锁时，它不会立即阻塞（即不会进入睡眠状态），而是在当前位置不断循环（自旋），直到锁被释放。
互斥锁: 当一个线程尝试获得一个已被占用的锁时，它会阻塞并进入睡眠状态，直到锁被释放并被操作系统唤醒。
适用场景:
自旋锁: 适用于锁持有时间短且线程不希望在重新调度上花费太多成本的场景，特别是多核处理器上。
互斥锁: 适用于锁可能被长时间持有的场景，或者当等待锁的线程需要执行其他任务时。
性能影响:
自旋锁: 如果锁被长时间持有，自旋锁会导致CPU资源浪费，因为等待的线程在不断循环检查锁的状态。
互斥锁: 通过让线程进入睡眠状态，可以减少CPU资源的浪费，但可能增加线程调度和上下文切换的开销。
优先级考虑:
自旋锁: 通常不考虑线程优先级，所有线程平等地自旋等待。
互斥锁: 可以支持优先级继承等机制，防止高优先级线程饥饿。
实现复杂性:
自旋锁: 实现相对简单，通常只需要一个原子操作。
互斥锁: 实现更复杂，需要操作系统的支持来管理线程的阻塞和唤醒。
可扩展性:
自旋锁: 在多核处理器上，自旋锁可以更好地扩展，因为每个线程可以在不同的核上自旋。
互斥锁: 在多核环境中，互斥锁可能成为性能瓶颈，因为只有一个线程可以持有锁。
死锁风险:
自旋锁: 由于线程不会睡眠，因此减少了死锁的风险。
互斥锁: 如果不当使用，比如不正确的锁顺序，可能会增加死锁的风险。
中断处理:
自旋锁: 通常在不允许睡眠的上下文中使用，如中断处理程序。
互斥锁: 可以在任何需要线程同步的地方使用，包括中断处理程序之外的场景。

cpu调度算法的评价指标?

CPU 利用率（CPU Utilization）:
指CPU执行任务的时间占总时间的比例。理想情况下，CPU利用率应该接近100%。
吞吐量（Throughput）:
指单位时间内CPU完成的进程数量。高吞吐量意味着系统能处理更多的任务。
周转时间（Turnaround Time）:
从进程提交到完成所需的总时间。短的周转时间意味着进程能更快完成。
等待时间（Waiting Time）:
进程在就绪队列中等待CPU的时间。等待时间越短，进程响应越快。
响应时间（Response Time）:
从发出请求到首次得到响应的时间。对于交互式系统，快速的响应时间非常重要。
公平性（Fairness）:
确保所有进程都能公平地获得CPU时间，避免某些进程饥饿或饿死。
上下文切换开销（Context-Switch Overhead）:
切换进程时保存和加载寄存器、程序计数器等所需的时间。减少上下文切换可以提高效率。
优先级（Priority）:
调度算法如何使用和处理进程优先级，以及如何避免高优先级进程饥饿。
可预测性（Predictability）:
对于某些实时系统，调度算法的可预测性非常重要，以确保任务能按时完成。
吞吐量与响应时间的平衡:
调度算法需要平衡吞吐量和响应时间，以满足不同类型的负载需求。
锁的竞争（Lock Contention）:
在多线程环境中，调度算法如何影响线程间锁的竞争。
死锁和饥饿（Deadlocks and Starvation）:
调度算法是否可能导致死锁或某些进程长时间得不到CPU时间（饥饿）。
适应性（Adaptability）:
调度算法适应不同系统负载和不同类型任务的能力。
资源分配效率（Efficiency of Resource Allocation）:
调度算法分配CPU资源的效率，包括是否能够充分利用多核处理器的优势。
复杂性（Complexity）:
调度算法的实现复杂度，包括算法本身的复杂性和对系统性能的影响。

线程调度开销小的原因

上下文切换优化:
线程属于同一进程，它们共享相同的地址空间和资源。因此，线程之间的上下文切换比进程间的上下文切换要快，因为不需要加载不同的地址空间。
资源共享:
同一进程内的线程共享内存和文件描述符等资源，这减少了调度时的资源设置和同步开销。
快速调度路径:
现代操作系统通常对线程调度进行了优化，例如通过优先级继承、锁机制等，减少了线程调度的复杂性和时间。
轻量级线程:
线程有时被称为轻量级进程，因为它们的创建、同步和销毁的开销相对较小。
现代CPU架构:
当前的CPU架构支持快速的线程切换，如通过硬件支持的快速寄存器加载和保存。
调度算法优化:
调度算法可能针对线程调度进行了优化，例如，操作系统可能会优先调度同一进程内的线程，以减少切换成本。
内核优化:
操作系统内核可能对线程调度进行了优化，比如减少中断和系统调用的频率，以及优化调度器的数据结构。
线程局部性:
线程更有可能访问相同的数据集，这增加了数据局部性，减少了缓存未命中和页面错误，从而减少了调度开销。
减少系统调用:
线程之间的交互可以通过更轻量级的机制（如信号量、互斥锁等）来完成，而不是依赖于重量级的系统调用。
调度器智能:
调度器可能会使用智能算法来预测线程的行为，从而减少不必要的调度操作。

硬件支持:

现代处理器提供了硬件支持，如多级缓存和多核架构，这有助于减少线程调度的开销。
并发API和库:
高效的并发API和库可以减少线程调度的需要，通过更好的任务管理和同步机制来提高性能。

并发与并行

并发（Concurrency）
并发指的是多个任务在宏观上同时发生，但不一定在物理上同时执行。在并发系统中，任务通过时间分片或多任务处理在单个处理器上交替执行，给用户一种多个任务同时进行的错觉。并发的关键点在于任务的调度和切换，使得多个任务可以同时处于活跃状态。
特点：
可以提高资源的利用率。
可以在单核或多核处理器上实现。
任务之间可能存在依赖关系，需要同步机制来避免竞态条件。
并行（Parallelism）
并行指的是多个任务在物理上同时执行。在并行系统中，多个处理器或核心同时工作，每个处理器或核心执行不同的任务或任务的一部分。并行计算可以显著提高计算速度，特别是在处理大规模数据或复杂计算时。
特点：
可以显著提高性能，尤其是在处理可以并行化的任务时。
需要多核处理器或分布式计算资源。
任务通常是独立的，或者可以被分解成可以并行处理的子任务。
区别
执行方式：并发是任务在单个或多个处理器上交替执行，而并行是任务在多个处理器或核心上同时执行。
资源使用：并发关注任务的调度和资源的高效利用，而并行关注任务的分割和多处理器的协同工作。
硬件需求：并发可以在单核系统上实现，而并行需要多核或多处理器系统。
性能提升：并行通常能提供更直接的性能提升，因为它利用了多个处理器的计算能力。
应用场景
并发：适用于需要同时处理多个任务的场景，如Web服务器处理多个客户端请求，操作系统管理多个进程和线程等。
并行：适用于需要大量计算的任务，如科学计算、图像处理、大数据分析等，这些任务可以分解成多个子任务并行处理。
指针的大小
系统架构：
在32位系统上，指针通常是32位（4字节）大小。
在64位系统上，指针通常是64位（8字节）大小。
数据模型：
某些系统可能使用不同的数据模型，如ILP32（int, long, pointer都是32位）、LP64（long和pointer是64位，int是32位）等，这会影响指针的大小。
编译器和平台：
不同的编译器和平台可能有不同的默认设置，影响指针的大小。
指针类型：
普通指针、函数指针、数组指针等不同类型的指针可能有不同的大小，尽管在许多系统中它们的大小是相同的。
对齐要求：
指针的大小可能受到内存对齐要求的影响。为了优化内存访问，指针的大小可能会被调整到特定的边界。
指针压缩：
在某些特定的环境或配置下，如嵌入式系统或特定的编译器选项，可能会使用压缩指针来减少内存使用。
语言特性：
某些编程语言可能有自己的指针表示方式，这可能会影响指针的大小或行为。
内存管理：
在某些语言或环境中，指针可能包含额外的信息，如垃圾收集器的元数据，这可能会影响指针的大小。
系统调用和ABI（应用程序二进制接口）：
系统调用和ABI可能规定了指针的大小，以确保应用程序与操作系统之间的兼容性。
64位版本上，指针通常是8字节大小。

体系结构，每一层的作用

计算机体系结构：
计算机体系结构涉及硬件和软件的组织方式，通常分为不同的层次，每一层提供不同的功能和服务。
硬件层：提供物理组件，如CPU、内存、存储设备等，是整个系统的基础。
操作系统层：管理硬件资源，提供程序执行环境，支持文件系统、设备驱动程序、进程管理等。
应用程序接口（API）层：为应用程序提供一组函数和协议，以便与操作系统交互。
应用程序层：运行在操作系统之上，直接与用户交互，执行特定的任务。

网络体系结构：

网络体系结构通常指的是网络通信的分层模型，如OSI模型或TCP/IP模型，每一层负责不同的通信任务。
物理层（OSI模型层1）：处理物理连接和电气信号，如电缆、交换器、集线器等。
数据链路层（OSI模型层2）：管理设备间的数据传输，包括错误检测和纠正，以及访问控制。
网络层（OSI模型层3）：负责数据包在网络中的路由和转发，使用IP地址。
传输层（OSI模型层4）：提供端到端的数据传输服务，包括TCP（可靠连接）和UDP（无连接）。
会话层（OSI模型层5）：管理设备间的会话连接，确保数据的有序传输。
表示层（OSI模型层6）：处理数据的表示、编码和解码，如数据格式转换、数据压缩等。
应用层（OSI模型层7）：为应用软件提供网络服务，如HTTP、FTP、SMTP等网络协议。

每一层的作用可以概括为以下几点：

抽象：每一层为上层提供服务，同时隐藏下层的实现细节。
专业化：每一层专注于执行特定的任务，提高效率和可管理性。
模块化：不同层次可以独立开发和更新，提高系统的灵活性。
兼容性：标准化的层次接口允许不同系统和组件之间进行互操作。

x86和arm特性复杂指令集和简单指令集区别

x86架构
复杂指令集计算（CISC, Complex Instruction Set Computing）：x86架构使用CISC，提供丰富的指令集，包括很多复杂和专用的指令。
可变长度指令：x86指令的长度不是固定的，可以从1字节到11字节不等。
基于寄存器的架构：x86使用基于寄存器的架构，拥有多个通用寄存器和专用寄存器。
后向兼容性：x86架构非常注重向后兼容性，新的处理器设计通常能够运行旧的软件。
广泛用于桌面和服务器：x86架构广泛用于个人电脑和服务器市场。
ARM架构
精简指令集计算（RISC, Reduced Instruction Set Computing）：ARM架构使用RISC，提供较少的、更简单的指令集。
固定长度指令：ARM指令长度通常是固定的，通常是4字节。
基于寄存器的架构：ARM也使用基于寄存器的架构，但寄存器数量通常比x86少。
低功耗设计：ARM设计注重低功耗和高效能，适合移动设备和嵌入式系统。
广泛用于移动设备：ARM架构广泛用于智能手机、平板电脑和其他便携式设备。
复杂指令集（CISC）与精简指令集（RISC）的区别
指令数量：
CISC有大量的指令，包括很多复杂和专用的指令。
RISC有较少的指令，每个指令执行一个简单的操作。
指令复杂性：
CISC的指令可以执行多个操作，如加载数据、执行算术运算等。
RISC的指令通常只执行一个基本操作。
指令长度：
CISC的指令长度是可变的，根据指令的复杂性而变化。
RISC的指令长度通常是固定的。

执行速度：
CISC的复杂指令可能需要多个时钟周期来执行。
RISC的简单指令可以在单个时钟周期内执行。
硬件复杂性：
CISC的处理器硬件可能更复杂，因为需要解码和执行复杂的指令。
RISC的处理器硬件相对简单，因为指令集简单。
功耗：
CISC的处理器可能消耗更多的电力。
RISC的处理器设计通常更注重能效。
编译器优化：
CISC可能需要更复杂的编译器来优化代码。
RISC的编译器优化相对简单，因为指令集简单。
应用领域：
CISC架构常用于需要广泛向后兼容性的领域，如桌面和服务器市场。
RISC架构常用于对功耗和性能有严格要求的领域，如移动设备和嵌入式系统。

linux如何查看文件前5行

（head -n 5 filename）

进程里面有哪些内容
程序代码:
进程执行的指令集，即程序的二进制代码。
程序计数器（Program Counter, PC）:
存储下一条要执行的指令的地址。
寄存器集合:
包括通用寄存器、指令寄存器、堆栈指针等，用于存储临时数据和指令。
进程控制块（Process Control Block, PCB）:
操作系统用来存储进程的管理和调度信息的数据结构，包括进程状态、优先级、调度信息等。
内存管理信息:
包括页表、段表等，用于管理进程的虚拟内存。
文件描述符（File Descriptors）:
进程打开的文件列表及其相关信息。
堆栈空间:
用于函数调用时存储局部变量和调用栈。
数据段:
存储进程的全局变量和静态变量。
堆空间:
动态内存分配区域，用于存储进程运行时动态创建的数据结构。
环境变量:
一组键值对，定义了进程执行的环境设置。
信号处理:
进程接收和处理信号的方式。
子进程列表:
由当前进程创建的所有子进程的信息。
会话和进程组:
进程所属的会话和进程组信息，用于作业控制。
资源限制:
操作系统对进程可以使用的资源量的限制。
CPU时间:
进程占用CPU的时间，包括用户态时间和内核态时间。
账户和用户信息:
进程所有者的用户和账户信息。
网络信息:
进程使用的网络连接和套接字信息。
I/O 状态信息:
进程进行输入输出操作的状态。
调度属性:
影响进程调度的属性，如nice值、调度策略等。
安全和权限信息:
进程的安全上下文和权限设置。
进程调用过程，栈帧(针？)里面存的什么内容
返回地址：
当前函数调用结束后，需要返回到调用它的函数中继续执行。返回地址是调用者在调用函数后的下一条指令的地址。
参数传递：
函数调用时，实参（Arguments）的值需要传递给被调用的函数。这些参数通常被压入栈中，以便被调用者访问。
局部变量：
函数内部定义的局部变量（Local Variables）也会被存储在栈帧中。它们的作用域仅限于函数内部。
寄存器保存：
为了确保函数调用的安全性，一些寄存器的值（如基址寄存器、栈指针寄存器等）可能需要在函数调用前保存在栈帧中，并在函数返回前恢复。
栈帧指针：
栈帧指针通常指向当前函数的栈帧底部，用于访问栈帧中的局部变量和参数。
程序计数器（或指令指针）：
虽然程序计数器通常不存储在栈帧中，但它记录了当前正在执行的指令地址。在函数调用过程中，当前函数的程序计数器值会被压栈，以形成返回地址。
静态链：
如果函数使用了嵌套函数或闭包，静态链可能用于链接到外部函数的作用域。
对齐填充（可选）：
为了满足特定硬件的对齐要求，栈帧之间可能存在填充字节。

进程调用过程通常包括以下步骤：

参数压栈：调用函数前，将参数按照一定顺序压入栈中。
调用指令：执行函数调用的指令，如call或jmp。
保存返回地址：将返回地址压入栈中，通常是当前指令后的地址。
栈帧设置：在新栈帧中保存寄存器和局部变量。
函数体执行：执行函数的指令。
返回值压栈（如果需要）：函数返回前，可能将返回值压入栈中。
恢复寄存器：在函数返回前，恢复之前保存的寄存器值。
返回指令：执行返回指令，如ret，从栈中弹出返回地址到程序计数器。
栈帧销毁：返回到调用者，当前函数的栈帧被销毁。

孤儿进程和僵尸进程

孤儿进程（Orphan Process）：
定义:
孤儿进程是指其父进程在子进程终止之前退出的进程。
特性:
孤儿进程不会被其父进程回收（即获取其退出状态）。
处理:
操作系统通常会将孤儿进程的父进程ID改为init进程（通常PID为1），由init进程来回收。
影响:
孤儿进程本身不会导致问题，但如果没有及时被回收，会占用系统资源。
生命周期:
孤儿进程最终会被init进程回收，并从系统中消失。
僵尸进程（Zombie Process）：
定义:
僵尸进程是指已经执行完成（无论是正常退出还是被终止）但尚未被其父进程回收的进程。
特性:
僵尸进程在进程表中仍然存在，占用进程表项，但不占用CPU资源。
处理:
父进程可以通过调用wait()或waitpid()系统调用来回收子进程的退出状态，僵尸进程随后会被系统清除。
影响:
如果父进程没有调用这些系统调用，僵尸进程将一直存在，可能导致进程表满，影响系统性能。
生命周期:
僵尸进程最终会被父进程回收，但如果父进程不存在，init进程会代替父进程回收僵尸进程。
显示:
在Unix-like系统的进程列表中，僵尸进程的状态通常显示为“Z”，表示它已经完成执行但尚未被回收。
区别：
状态:
孤儿进程是失去父进程的子进程，而僵尸进程是已经终止但尚未被父进程回收的子进程。
父进程的角色:
孤儿进程的父进程已经退出，无法对其进行任何操作；僵尸进程的父进程仍然存在，但尚未调用wait()或waitpid()。
系统资源:
僵尸进程占用系统资源（进程表项），而孤儿进程则不占用额外资源，因为它们被init进程接管。
存在时间:
僵尸进程会一直存在，直到被父进程或init进程回收；孤儿进程存在时间较短，因为很快会被init进程接管并回收。
显示:
在进程列表中，僵尸进程会显示其状态为“Z”，而孤儿进程则不会显示特殊的状态。

进程、线程和协程的区别和作用

进程（Process）：
定义：进程是操作系统进行资源分配和调度的基本单位，是一个正在执行的程序的实例。
地址空间：每个进程有自己的独立地址空间，进程间的内存通常相互隔离。
资源拥有：进程拥有独立的系统资源，如文件句柄、I/O等。
通信方式：进程间通信（IPC）需要特定的机制，如管道、消息队列、套接字等。
作用：允许多个程序同时运行，提供隔离性和独立性。
线程（Thread）：
定义：线程是程序执行的最小单元，是操作系统能够进行运算调度的最小单位，线程存在于进程之中。
地址空间：同一进程内的线程共享进程的地址空间和资源。
资源拥有：线程可以拥有独立的栈和程序计数器，但共享其他资源，如全局变量和文件句柄。
通信方式：线程间可以通过共享内存进行通信，不需要特定的IPC机制。
作用：提供并发性，允许在同一个进程中并行执行多个任务。
协程（Coroutine）：
定义：协程是一种程序组件，它允许挂起和恢复执行，通常用于非抢占式多任务处理。
上下文切换：协程的上下文切换由程序控制，而不是由操作系统控制，这使得上下文切换成本较低。
地址空间：协程通常在线程中执行，共享线程的地址空间。
资源拥有：协程通常共享所在线程的资源，但可以有自己的局部变量和状态。
通信方式：协程间可以通过共享栈或通过回调等机制进行通信。
作用：提高程序的执行效率，特别是在I/O密集型或高并发场景下。
主要区别：
资源占用：进程拥有最多的隔离资源，线程共享同一进程的资源，协程则通常在线程内部实现，共享更多资源。
创建和销毁开销：进程的创建和销毁开销最大，线程次之，协程最小。
调度：进程和线程由操作系统调度，协程由程序自己调度。
并发性：进程和线程可以提供真正的并发执行，协程则通常用于协作式多任务处理。
作用：
进程：允许多个任务在操作系统上同时运行，提供资源隔离和保护。
线程：允许在同一个进程中实现任务并行，提高资源利用率和执行效率。
协程：优化程序的执行流程，特别是在I/O密集型应用中，通过减少上下文切换和简化同步机制来提高性能。

动态链接和静态链接的区别

静态链接
定义：在静态链接中，当程序编译时，所有的库和依赖都被合并到最终的可执行文件中。
优点：
可执行文件是自包含的，不需要额外的库文件即可运行。
因为所有依赖都包含在内，所以加载和启动速度可能更快。
缺点：
可执行文件的大小会更大，因为它包含了所有用到的库代码。
如果库更新了，需要重新编译整个程序来包含新的库。
动态链接
定义：在动态链接中，程序在编译时不包含库代码，而是在运行时才从共享库中加载所需的代码。
优点：
可执行文件更小，因为它不包含重复的库代码。
库更新时，不需要重新编译程序，只需替换共享库文件即可。
多个程序可以共享内存中的同一份库代码，节省内存。
缺点：
程序启动时需要加载共享库，可能会稍微慢一些。
如果缺少所需的共享库或库版本不兼容，程序可能无法运行。
其他区别
内存使用：静态链接的程序可能使用更多的内存，因为相同的库代码可能在内存中存在多份副本。动态链接可以减少内存使用，因为多个程序可以共享同一份库代码。
灵活性：动态链接提供了更高的灵活性，因为库可以在不重新编译程序的情况下更新。
兼容性：静态链接的程序通常具有更好的兼容性，因为它们不依赖于外部的库文件。
安全性：静态链接可能更安全，因为它减少了依赖外部库带来的风险。

内核怎么调度线程的？

线程创建:
在多线程程序中，线程可以由用户态的应用程序创建，也可以由内核态的线程创建。
线程状态:
线程有多种状态，如就绪（Ready）、运行（Running）、阻塞（Blocked）和终止（Terminated）。
线程队列:
内核维护一个或多个线程队列，用于管理处于就绪状态的线程。
优先级:
线程可能有不同的优先级，内核根据优先级来决定线程的调度顺序。
上下文切换:
当内核决定将CPU控制权从一个线程转移到另一个线程时，会发生上下文切换，保存当前线程的状态并加载新线程的状态。
调度算法:
内核使用特定的调度算法来选择下一个要运行的线程。常见的调度算法包括先来先服务（FCFS）、轮转调度（RR）、最短作业优先（SJF）和多级反馈队列（MLFQ）等。

调度器的选择:

内核可能提供多个调度器，允许根据应用程序的需要选择不同的调度策略。
抢占:
在抢占式调度中，如果一个高优先级的线程变为就绪状态，内核可能会中断当前正在运行的线程，转而执行高优先级的线程。
时间片:
在时间片轮转调度中，每个线程被分配一个时间片，线程可以运行直到时间片用完或阻塞。
负载均衡:
内核可能会在多核或多CPU系统中进行线程的负载均衡，以优化资源使用。
线程绑定:
某些线程可以被绑定到特定的CPU或核心上，以减少上下文切换或利用特定硬件特性。
中断和信号:
内核响应中断和信号，这可能会影响线程调度，如通过中断处理程序创建新线程。
监控和统计:
内核监控线程的执行情况，收集性能统计数据，以便进行调度决策。
资源限制:
内核可能根据系统资源限制（如CPU时间、内存使用）来调整线程调度。
调度类和属性:
线程可能属于不同的调度类（实时、普通等），具有不同的调度属性。
系统调用:
应用程序可以通过系统调用来请求特定的线程调度行为，如设置线程优先级或执行线程同步。

栈空间一般有多大

编译器默认值:
在很多编译环境中，如果不特别指定栈空间大小，编译器会有一个默认的大小，通常在1MB到4MB之间。
编程语言标准:
某些编程语言的标准可能定义了栈空间的最小要求。例如，C/C++标准并没有规定具体的栈空间大小，但是提供了栈溢出的错误处理机制。
操作系统:
操作系统在创建线程时会分配栈空间，这个大小可以在创建线程时指定，或者使用操作系统的默认值。
环境变量:
在某些操作系统中，可以通过设置环境变量来调整默认的栈空间大小，如在Linux中使用ulimit -s命令。
程序需求:
栈空间的大小可以根据程序的需求进行调整。例如，如果程序需要处理大量递归调用或大尺寸的局部变量，可能需要更大的栈空间。
硬件架构:
硬件架构也会影响栈空间的大小。32位系统和64位系统在栈空间的使用上可能有所不同。
动态分配:
在某些情况下，栈空间可以动态扩展，尽管这通常受到操作系统的限制。
栈溢出保护:
为了防止栈溢出，一些编译器和运行时环境会为栈空间设置保护页。
嵌入式系统:
在嵌入式系统中，由于资源受限，栈空间可能会被配置得更小。
JVM语言:
对于运行在Java虚拟机（JVM）上的语言，如Java和Kotlin，栈空间通常指的是JVM线程栈的大小，这可以在启动JVM时通过-Xss参数设置。
WebAssembly:
WebAssembly等现代运行时环境可能有自己的栈空间管理机制。

Linux用的是什么调度算法

多个队列:
存在多个优先级队列，每个队列都有自己的时间片大小。
动态调整:
进程的优先级会根据其行为动态调整。如果进程长时间占用CPU，它的优先级会被降低，从而减少其在高优先级队列中的时间。
时间片大小:
时间片的大小会随着进程在队列中的级别降低而增加，这有助于防止饥饿。
抢占式:
如果一个高优先级的进程变为就绪状态，它可能会抢占当前正在运行的低优先级进程的CPU时间。
I/O密集型和CPU密集型:
MLFQ能够区分I/O密集型和CPU密集型进程，给予不同的调度策略。
nice值:
用户可以通过设置nice值来影响进程的优先级，nice值越低，进程的优先级越高。
实时进程:
实时进程（Real-Time Processes）有自己的调度策略，通常不通过MLFQ进行调度。
负载均衡:
在多核或多CPU系统中，Linux调度器会尝试进行负载均衡，将进程分配到不同的CPU上。
调度类:
Linux支持多种调度类，如SCHED_OTHER（标准类）、SCHED_FIFO（实时优先级队列）、SCHED_RR（实时轮转调度）等。
调度器选择:
用户可以通过设置调度策略和相关参数来选择不同的调度器。
CFS（Completely Fair Scheduler）:
从Linux 2.6.23版本开始，引入了CFS调度器，作为MLFQ的补充，用于提供更公平的CPU时间分配。

内存对齐
#define ALIGN(size, align) (((size) + (align) - 1) & ~((align) - 1))

标题浮点数在计算机中怎么存储

单精度浮点数（32位）：
符号位（Sign bit）：1位，确定数值的正负，0表示正数，1表示负数。
指数位（Exponent）：8位，用来表示2的指数部分。
尾数位（Fraction/Mantissa）：23位，表示数值的小数部分。
双精度浮点数（64位）：
符号位：1位，同样确定数值的正负。
指数位：11位，表示2的指数部分。
尾数位：52位，表示数值的小数部分。
存储格式说明：
符号位：直接决定了数值的正负。
指数位：存储形式为偏移值，用于表示实际指数的偏移。在单精度中，指数偏移值是127，在双精度中是1023。实际指数 = 存储值 - 偏移值。
尾数位：存储了数值的小数部分，但实际存储的是最接近的二进制表示。尾数的第一位是隐含的1（对于规格化值），所以通常不存储。例如，1.1的二进制表示是1.01，存储时只存储01部分。
特殊值：
无穷大：当指数位全为1，尾数位全为0时，表示无穷大，符号位决定正负。
NaN（Not a Number）：当指数位全为1，尾数位不全为0时，表示非数值，符号位不影响NaN的解释。
规格化数：指数不为全0或全1，尾数位不包含隐含的1。

非规格化数：指数位全为0，尾数位不包含隐含的1，用于表示接近0的数。
隐式位：在规格化数中，尾数的最高位隐含为1，实际不存储。
舍入：在进行浮点数运算时，由于精度限制，可能会发生舍入。

4G物理内存动态分配3G内存会发生什么

内存使用率增加:
系统的整体内存使用率会显著增加，大部分可用内存被分配给特定的用途。
剩余可用内存减少:
剩余的可用内存将大幅减少，可能只留下1GB左右给其他应用程序和系统进程使用。
性能影响:
如果3GB内存分配给了某个应用程序，该应用程序可能会获得更好的性能，因为它拥有足够的内存来存储数据，减少磁盘I/O操作。
其他应用程序受影响:
其他应用程序可能会因为可用内存减少而受到性能影响，特别是那些需要较多内存的应用程序。
内存交换（Swapping）:
如果剩余的物理内存不足以维持系统和其他应用程序的正常运行，操作系统可能会开始使用虚拟内存，将一些不常用的内存页面交换到磁盘上，这可能会导致性能下降。
系统响应变慢:
如果系统开始大量使用虚拟内存，系统响应可能会变慢，因为磁盘I/O速度远低于RAM。
内存碎片:
长时间运行后，系统可能会产生内存碎片，这可能会影响内存的进一步分配和性能。
内存泄漏风险:
如果动态分配的内存没有得到正确的管理，可能会发生内存泄漏，进一步加剧内存不足的问题。
系统稳定性
如果剩余的内存不足以应对突发的内存需求，系统可能会变得不稳定，应用程序可能会崩溃或系统可能会冻结。
资源监控和管理:
系统管理员或用户可能需要更密切地监控内存使用情况，并采取相应的内存管理措施，如优化应用程序的内存使用或重启系统来清理内存。

数据结构

二叉搜索树的概念

有序性：树中的每个节点都包含一个键（key）和可能的值（value）。对于树中的任意节点，其左子树上所有节点的键都小于该节点的键，其右子树上所有节点的键都大于或等于该节点的键。
二叉树结构：每个节点最多有两个子节点，即左子节点和右子节点。
没有兄弟节点：由于每个节点最多只有一个左子节点和一个右子节点，所以树中的节点没有兄弟节点。
树的性质：二叉搜索树是一棵空树，或者它的两个子树也是二叉搜索树，并且左子树上所有节点的键都小于根节点的键，右子树上所有节点的键都大于根节点的键。
中序遍历：对二叉搜索树进行中序遍历（先访问左子树，然后是根节点，最后是右子树）会按升序访问所有节点的键。
二叉搜索树的这些特性使得它在查找、插入和删除操作上具有高效的性能。对于一个平衡的二叉搜索树，这些操作的时间复杂度可以达到 O(log n)，其中 n 是树中节点的数量。然而，在最坏的情况下，比如树严重不平衡时，这些操作的时间复杂度会退化到 O(n)。

二叉搜索树的操作：

查找（Search）：从根节点开始，比较键值，根据比较结果决定是移动到左子树还是右子树，直到找到键或确定树中不存在该键。
插入（Insert）：类似查找操作，找到合适的插入位置，然后插入新的节点。
删除（Delete）：删除节点稍微复杂，需要考虑三种情况：无子节点、只有一个子节点、有两个子节点。对于有两个子节点的情况，通常的做法是用其右子树的最小值节点替换它，然后删除那个最小值节点。
平衡操作：为了保持二叉搜索树的平衡，可能需要进行旋转等操作，如 AVL 树和红黑树。
二叉搜索树是一种基础且重要的数据结构，在计算机科学中广泛应用于各种场景，包括但不限于数据库索引、文件系统、搜索算法等。

哈希表的底层

哈希表（Hash table），也称为散列表，是一种数据结构，它提供了快速的数据插入和查找功能。其底层实现通常基于以下概念：

哈希函数（Hash Function）：
- 哈希表使用一个函数（称为哈希函数）将输入（通常是字符串或者数字）转换为一个索引值，这个索引值通常称为哈希码（hash code）。
数组（Array）：
- 哈希表底层通常是一个数组结构，用于存储键值对（key-value pairs）。哈希函数的输出直接用作数组的索引。
冲突解决（Collision Resolution）：
- 由于不同的输入可能会产生相同的哈希码，这种情况称为冲突。哈希表需要一种机制来解决冲突，常见的方法包括：
  - 链地址法（Chaining）：在每个数组位置维护一个链表，所有映射到该位置的元素都存储在这个链表中。
  - 开放寻址法（Open Addressing）：寻找空的数组位置来存储发生冲突的元素，可以使用线性探测、二次探测或双重哈希等技术。
动态扩容（Dynamic Resizing）：
- 当哈希表中的元素太多，导致冲突增加时，性能会下降。此时，哈希表可能需要进行扩容，即创建一个更大的数组，并将所有元素重新映射和复制到新数组中。
负载因子（Load Factor）：
- 负载因子是哈希表中已使用槽（元素）数量与总槽数量的比率。它是一个衡量哈希表性能的关键指标，通常在达到一定阈值时触发扩容。
哈希表的迭代器（Iterators）：
- 哈希表提供迭代器以支持顺序访问所有元素，尽管元素在内存中可能不是顺序存储的。
内存分配（Memory Allocation）：
- 哈希表需要连续的内存空间来存储数组和链表节点（如果使用链地址法）。现代实现通常会使用内存分配器来优化内存使用。
性能优化（Performance Optimizations）：
- 为了提高性能，哈希表的实现可能会采用一些优化技术，如使用高位缓存友好的探测序列、哈希函数的优化选择等。
线程安全（Thread Safety）：
- 在多线程环境中，哈希表可能需要额外的同步机制来保证线程安全，如使用读写锁（rwlock）或细粒度锁。
扩展功能（Extensions）：

一些哈希表实现可能提供额外的功能，如重哈希（rehashing）、自定义内存分配器、自定义哈希函数等。

黑树（Red-Black Tree）是一种自平衡的二叉搜索树，它在插入和删除操作中能够快速地保持树的平衡，确保操作的效率。以下是红黑树的一些关键特性：

每个节点都有颜色属性：可以是红色或黑色。
节点的null左孩子和null右孩子被视为黑色。
根节点是黑色。
所有叶子节点（null）都是黑色。
每个红色节点的两个子节点都是黑色（从每个叶子到根的所有路径上不能有两个连续的红色节点）。
从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点。
新插入的节点都是红色。
红黑树的这些特性确保了从根到叶子的最长路径不会超过最短路径的两倍。因此，红黑树大致是平衡的，查找操作的最坏情况时间复杂度能够保持在 O(log n)。

数据结构的栈和队列有什么区别

操作方式：
栈：遵循后进先出（Last In First Out, LIFO）原则。这意味着最后添加到栈中的元素将是第一个被移除的元素。
队列：遵循先进先出（First In First Out, FIFO）原则。这意味着最先添加到队列中的元素将是第一个被移除的元素。
添加元素：
栈：元素在栈顶添加和移除，这通常称为“压栈”（push）操作。
队列：元素在队尾添加，称为“入队”（enqueue）操作。
移除元素：
栈：元素从栈顶移除，称为“弹栈”（pop）操作。
队列：元素从队首移除，称为“出队”（dequeue）操作。
访问元素：
栈：通常只允许访问栈顶元素，即最后一个添加的元素。
队列：通常只允许访问队首元素，即第一个添加的元素。
使用场景：
栈：常用于实现函数调用的堆栈、表达式求值、回溯算法、括号匹配等。
队列：常用于任务调度、广度优先搜索（BFS）、缓冲处理、实时系统的消息传递等。
变体：
栈：有变体如双栈（使用两个栈进行操作）或多栈（多个栈的集合）。
队列：有变体如循环队列（使用固定大小数组实现的队列）、优先队列（元素有优先级）、双端队列（允许在两端添加和移除元素）等。
性能特点：
栈：压栈和弹栈操作通常都是O(1)时间复杂度。
队列：入队和出队操作通常也都是O(1)时间复杂度，但在使用链表实现时，可能在队尾添加元素是O(1)，而在队首移除元素是O(n)。
实现方式：
栈：可以用数组或链表实现。
队列：可以用数组（需要移动元素）、链表或循环数组实现

标题哈希冲突，也称为哈希碰撞（Hash Collision），发生在两个或多个不同的输入（键）经过哈希函数处理后得到相同的哈希值的情况。由于哈希函数的值域通常远小于输入的空间，随着数据量的增加，冲突在所难免。以下是几种常见的解决哈希冲突的方法：

链地址法（Chaining）：
在这种方法中，每个哈希表槽（bucket）都维护一个链表。当发生冲突时，新的元素可以追加到链表的末尾。
开放寻址法（Open Addressing）：
开放寻址法试图在哈希表中找到一个空闲位置来存储发生冲突的元素。这可能通过线性探测（Linear Probing）、二次探测（Quadratic Probing）或双重哈希（Double Hashing）等技术实现。
再哈希法（Rehashing）：
当发生冲突时，使用另一个哈希函数重新计算哈希值，直到找到一个空闲的槽位。
哈希表扩容：
当哈希表的负载因子（即哈希表中已存储元素的数量与槽位数的比例）超过一定阈值时，可以通过扩容哈希表来减少冲突的概率。
双重哈希（Double Hashing）：
使用两个哈希函数计算新的位置，如果再次冲突，继续应用第二个哈希函数，直到找到空闲位置。
链表和开放寻址的混合：
某些哈希表实现可能结合了链地址法和开放寻址法的优点，例如，在每个槽位使用小型链表或动态数组来减少冲突。
一致性哈希（Consistent Hashing）：
在分布式系统中，一致性哈希用于减少因节点增减导致的大规模数据迁移，它通过将哈希值映射到一个虚拟的环形空间来实现。
哈希函数的选择：
选择一个好的哈希函数可以减少哈希冲突的概率。理想的哈希函数应该能够均匀分布输入，使得冲突最小化。
负载均衡：
在分布式系统中，通过负载均衡算法合理分配数据到不同的节点，可以降低单个节点上的哈希冲突概率。
虚拟哈希表：
通过将哈希表划分为多个较小的子表，每个子表使用独立的哈希函数，可以减少冲突并提高性能。

链表和数组的区别

内存分配:
数组：通常需要连续的内存空间，大小在声明时确定（静态数组）或在运行时确定但需一次性分配（动态数组）。
链表：不需要连续内存空间，每个元素（节点）包含数据部分和指向下一个节点的指针，可以分散在内存的任何位置。
大小调整:
数组：大小一旦确定，静态数组无法改变大小，动态数组可以通过重新分配内存来调整大小，但这通常涉及复制整个数组。
链表：大小可以随时调整，通过插入或删除节点来增加或减少元素，不需要移动其他元素。
访问方式:
数组：提供随机访问，可以通过索引快速访问任意位置的元素，时间复杂度为O(1)。
链表：不支持随机访问，访问特定位置的元素需要从头开始遍历链表，时间复杂度为O(n)。
插入和删除:
数组：在数组中插入或删除元素可能需要移动后续所有元素以维持连续性，平均时间复杂度为O(n)。
链表：在链表中插入或删除元素只需要改变相邻节点的指针，时间复杂度为O(1)，但如果要插入或删除特定位置的元素，需要先找到该位置，这可能需要O(n)时间。
内存开销:
数组：除了存储元素本身，额外的内存开销较小。
链表：每个节点除了存储数据外，还需要额外的空间来存储指向下一个（及可能的前一个）节点的指针，因此内存开销相对较大。
性能:
数组：由于内存连续，缓存友好，访问速度快，但调整大小和插入/删除操作可能较慢。
链表：插入和删除操作快，但访问速度慢，且由于指针的存在，内存使用效率较低。
用途:
数组：适用于索引访问频繁的场景，如大量数据的存储和检索。
链表：适用于插入和删除操作频繁的场景，特别是数据元素大小经常变化的情况。
实现复杂性:
数组：实现相对简单，大多数编程语言都内置了对数组的支持。
链表：实现相对复杂，需要手动管理内存和指针。
多维结构:
数组：容易实现多维数组，如二维数组（矩阵）。
链表：实现多维结构较为复杂，通常需要嵌套链表或使用其他数据结构。

计算机网络

TCP和UDP的区别

连接性：
TCP：是一种面向连接的协议。在数据传输开始之前，必须在两端建立一个连接。这通过一个称为三次握手的过程来实现。
UDP：是无连接的协议。数据可以被发送到目标地址而无需事先建立连接。
数据完整性：
TCP：提供可靠的数据传输，确保数据包正确无误地到达目的地。如果数据在传输过程中丢失或出错，TCP会重新发送数据。
UDP：不保证数据包的可靠传输。如果数据包在传输过程中丢失或损坏，UDP不会自动重发。
拥塞控制：
TCP：具有拥塞控制机制，可以根据网络状况调整数据传输速率，避免网络拥塞。
UDP：没有拥塞控制，发送速率由应用程序控制，不考虑网络状况。
传输效率：
TCP：由于需要建立连接、数据校验和拥塞控制，TCP的传输效率可能不如UDP高。
UDP：由于没有这些额外的控制机制，UDP通常具有较低的延迟和较高的传输效率。
顺序保证：
TCP：保证数据包的顺序传输。如果数据包到达的顺序与发送时不同，TCP会重新排序数据包。
UDP：不保证数据包的顺序，应用程序需要自行处理顺序问题。
流量控制：
TCP：具有流量控制机制，可以避免发送方过快发送数据导致接收方处理不过来。
UDP：没有流量控制，发送方可以以任意速率发送数据，接收方必须能够处理这种速率。
头部开销：
TCP：头部较大，包含序列号、确认号、窗口大小等控制信息。
UDP：头部较小，只包含源端口、目的端口、长度和校验和等基本信息。
用途：
TCP：适用于需要可靠传输的应用，如网页浏览（HTTP）、文件传输（FTP）、邮件传输（SMTP）等。
UDP：适用于对实时性要求较高的应用，如实时视频会议、在线游戏、DNS查询等。
校验和：
TCP：头部包含校验和字段，用于检测头部和数据在传输过程中的错误。
UDP：也包含校验和字段，但它是可选的，用于检测头部、数据和伪首部在传输过程中的错误。

详细说一下TCP三次握手过程。第一、二、三次握手失败后分别会做什么事？序号和确认号怎么变的？

第一次握手 - SYN：
客户端选择一个初始序列号（ISN，Initial Sequence Number）并发送一个SYN（同步序列编号）标志位的TCP段给服务器，表示希望建立连接。这个段不包含应用层数据，但它的序列号是客户端选择的初始序列号。
第二次握手 - SYN-ACK：
服务器收到这个SYN段后，如果同意连接请求，会发送一个SYN-ACK（同步确认）标志位的TCP段作为响应。服务器在自己的SYN段中也选择一个初始序列号，并将ACK（确认应答）设置为客户端的ISN加1。这个段同样不包含应用层数据。
第三次握手 - ACK：
客户端收到服务器的SYN-ACK段后，会发送一个ACK标志位的TCP段给服务器，确认收到服务器的SYN。客户端的ACK设置为服务器的ISN加1。此时，连接建立成功，客户端和服务器可以开始发送应用层数据。
序列号和确认号的变化：
序列号：在TCP连接建立时，客户端和服务器各自选择一个初始序列号（ISN）。序列号用于标识发送的数据字节，确保数据的顺序，并允许接收方检测丢包。
确认号：确认号是期望收到的下一个序列号。在三次握手过程中，客户端的ACK确认号是服务器SYN中序列号加1，服务器的ACK确认号是客户端SYN中序列号加1。
三次握手失败后的处理：
第一次握手失败：
如果客户端的SYN段在网络中丢失或由于其他原因未能到达服务器，客户端会因为超时而重传SYN段。
第二次握手失败：
如果服务器的SYN-ACK段丢失或未能到达客户端，客户端在超时后会重传它的SYN段。服务器在收到重传的SYN后，可能会再次发送SYN-ACK段
第三次握手失败：
如果客户端的ACK段丢失，服务器会因为超时而重传SYN-ACK段。客户端在收到重传的SYN-ACK后，会重新发送ACK段。
在所有这些情况下，TCP的超时和重传机制确保了可靠连接的建立。如果重传次数超过系统设定的阈值，连接尝试会失败，客户端通常会报告连接错误。

讲一下TCP的四次挥手？能不能优化成三次？

第一次挥手 - FIN：
当一方（假设为A）准备关闭连接时，发送一个带有FIN（结束）标志位的TCP段给另一方（假设为B），表示A已经完成数据发送。
第二次挥手 - ACK：
B收到A的FIN段后，发送一个ACK确认应答给A，确认已经收到A的结束请求。
第三次挥手 - FIN：
B在发送完ACK之后，如果它自身也已经完成数据发送，会发送一个带有FIN标志位的TCP段给A，表示B也准备关闭连接。
第四次挥手 - ACK：
A收到B的FIN段后，发送一个ACK确认应答给B，确认已经收到B的结束请求。至此，TCP连接被完全关闭。
为什么TCP关闭连接需要四次挥手，而不是三次？
TCP连接的全双工特性意味着数据可以在两个方向上独立传输。因此，每个方向上的连接都需要单独关闭。四次挥手的必要性在于：
当A发送FIN表示它已经完成发送数据时，它仍然能够接收B的数据。
B可能还有未发送完的数据，所以它不能立即关闭连接。B发送ACK确认收到A的FIN，但可能还需要一些时间来完成数据的发送。
当B完成数据发送后，它发送自己的FIN，表示B也准备关闭连接。
A收到B的FIN后，发送ACK确认，此时A知道B已经完成数据发送，可以关闭连接。
能否优化成三次挥手？
理论上，如果B在收到A的FIN后立即发送FIN，那么挥手过程可以减少到三次。然而，这需要满足以下条件：
B在收到A的FIN后，立即发送自己的FIN，而不是等待所有数据发送完毕。
A在发送完FIN后，立即发送ACK，而不是等待B的FIN。
然而，在实际应用中，这种优化并不常见，因为：
B可能需要时间来完成所有数据的发送，确保数据的完整性。
网络延迟和数据传输时间可能导致B在收到A的FIN后不能立即发送FIN。
四次挥手提供了更可靠的连接终止机制，确保双方都能正确地关闭连接。
DNS用的什么协议？
UDP和TCP

如何在弱网络的情况下优化TCP？

调整TCP窗口大小：
增大TCP窗口可以减少往返时间（RTT）对传输速度的影响，从而加速数据的传输。在高速网络中，启用窗口缩放选项可以大幅提升数据传输的效率9。
优化内核参数：
调整操作系统的TCP相关内核参数，如内存分配、缓冲区大小、拥塞控制算法等，可以提高TCP的性能917。
使用快速重传和选择性确认（SACK）：
快速重传可以在没有收到三次重复的ACK时立即重传丢失的数据包。SACK允许接收方告知发送方哪些数据包已经成功接收，从而避免不必要的重传12。
减少连接建立时间：
利用TCP的快速开放（TCP Fast Open）等技术减少连接建立的时间，这可以减少首次传输数据的网络延迟
使用Nagle算法的优化：
禁用Nagle算法可以减少小数据包的传输延迟，但在某些情况下，启用Nagle算法可以减少小包的数量，提高网络利用率
使用延迟确认（Delayed ACK）：
调整延迟确认的超时时间，可以减少ACK包的数量，降低网络负载
优化DNS查询：
减少DNS查询次数，使用本地DNS缓存或公共DNS服务，避免域名劫持和DNS污染11。
减少数据包大小和优化包量：
通过压缩、精简包头、消息合并等方式减小数据包大小和包量，降低因数据包过大导致的分片和丢包11。
使用前向纠错（FEC）：
使用FEC技术可以在发送时添加冗余数据，接收方可以使用这些冗余数据恢复丢失的数据包，减少重传的需求
优化ACK包的处理：
在弱网络情况下，减少ACK包的发送频率，同时保证数据传输的可靠性11。
使用QUIC协议：
QUIC是一种基于UDP的传输层协议，它结合了TCP的可靠性和UDP的低延迟特性，适用于弱网络环境12。
使用移动网络优化技术：
对于移动设备，使用如CDN、断线重连、减少数据连接创建次数等策略来优化网络连接11。
调整TCP的超时和重传策略：
在弱网络环境下，调整TCP的超时和重传策略，以适应不稳定的网络条件。
使用带宽估计和自适应流控制：
动态调整TCP的发送速率，以匹配当前的网络带宽。

CLOSE WAIT多是怎么回事，客户端正常

对于客户端来说，一旦它发送了FIN包，并且收到了服务器的ACK响应，它就认为自己已经完成了关闭过程。客户端的应用程序可能不会等待服务器端完全关闭连接，因此在客户端看来，连接已经正常关闭。

DNS解析的过程？系统DNS查询时可能存在什么缺陷？（耗时？

客户端发起请求：
本地DNS缓存查询：
递归查询：
迭代查询：
获取结果：
缓存结果：
系统DNS查询可能存在的缺陷包括：
缓存污染：
DNS劫持
DDoS攻击
隐私问题
耗时

标题HTTP与HTTPS的区别

HTTP（超文本传输协议）和HTTPS（安全超文本传输协议）都是用于从网络传输超媒体到本地浏览器的传输协议，但它们在安全性方面有显著的不同：
加密:
HTTP: 传输的数据未经加密，可能被中间人攻击或窃听。
HTTPS: 使用SSL/TLS协议对数据进行加密，保护数据传输过程中的安全性，防止数据被窃听或篡改。
端口:
HTTP: 默认使用80端口。
HTTPS: 默认使用443端口。
安全性:
HTTP: 没有建立安全层，因此被认为是不安全的。
HTTPS: 通过SSL/TLS建立了安全层，被认为是安全的。
性能:
HTTP: 由于没有加密和解密的过程，性能可能略高。
HTTPS: 由于加密和解密的过程，可能会消耗更多的CPU资源，但现代硬件和优化技术已经大大减少了性能损耗。
搜索引擎优化（SEO）:
许多搜索引擎，包括Google，倾向于提高使用HTTPS的网站的排名。
信任和认证:
HTTP: 不需要证书。
HTTPS: 需要从证书颁发机构（CA）获取SSL证书，这增加了网站的可信度。
成本:
HTTP: 通常免费。
HTTPS: 虽然现在许多证书是免费的，但获取和维护证书可能会涉及一些成本。
使用场景:
HTTP: 适用于不需要安全传输的场景，如公开信息的浏览。
HTTPS: 适用于需要保护用户数据和隐私的场景，如网上银行、在线购物等。
混合内容:
当HTTPS页面请求HTTP资源时，这被称为混合内容，可能会导致安全警告。
协议指示:
在浏览器地址栏中，HTTP页面通常没有特别的标志。
HTTPS页面通常会有一个锁形标志，表明连接是安全的。

通信双方中一方要释放连接会发生哪些事，第一次挥手丢失了会发生哪些事
通信双方中一方要释放连接：
FIN（结束）标志设置:
发起关闭的一方发送一个TCP段，其中FIN标志被设置，表示这一方已经完成发送数据。
等待关闭:
发送FIN的端点进入FIN-WAIT-1状态，等待接收对方的确认。
确认ACK:
接收端接收到FIN后，发送一个确认应答（ACK），进入CLOSE-WAIT状态。
接收端关闭:
接收端发送完ACK后，可以开始关闭它的写入方向，等待完成发送所有数据。
发送端确认:
发送端接收到ACK后，进入FIN-WAIT-2状态，等待接收端发送它的FIN。
接收端发送FIN:
一旦接收端完成数据发送，它将发送一个带有FIN标志的TCP段。
最终确认:
发送端接收到这个FIN后，发送一个最终的ACK，并进入TIME-WAIT状态，等待足够的时间以确保接收端接收到了最终的ACK。
连接终止:
接收端接收到最终的ACK后关闭连接，发送端在TIME-WAIT状态超时后关闭连接。
第一次挥手丢失了：
超时重传:
如果最初的FIN没有被确认，发送端将经历一个超时并重新发送FIN。
状态保持:
在超时重传期间，发送端保持在FIN-WAIT-1状态。
可能的数据丢失:
如果发送端在FIN-WAIT-1状态下重传FIN时，它仍然可以接收数据，但无法发送新数据。
连接超时:
如果FIN重传多次后仍未得到确认，连接可能会因为超时而完全断开。
资源占用:
重传FIN会占用网络资源，可能导致发送端的TCP连接占用状态延长。
应用程序影响:
应用程序可能会注意到连接关闭的延迟，因为TCP层正在尝试可靠地关闭连接。
可能的重置:
如果FIN丢失导致超时太长，发送端或接收端可能会发送RST（重置）标志来强制关闭连接。
网络拥塞:

重传可能会增加网络拥塞，尤其是在拥塞控制算法不完善的情况下。

TCP最大连接数：

TCP连接数受多种因素影响，包括操作系统参数、内存大小、网络配置等。以下是一些影响TCP最大连接数的关键因素：
文件描述符限制：
每个TCP连接都需要一个文件描述符，操作系统对文件描述符的数量有限制。
内存限制：
TCP连接需要消耗内存来存储缓冲区、套接字结构等，可用内存的大小限制了TCP连接的数量。
操作系统参数：
Linux操作系统提供了多个参数来控制TCP连接的数量，如fs.file-max（系统级别的文件描述符限制）、net.core.somaxconn（套接字监听队列的长度）等。
网络配置：
网络设备的配置，如MTU（最大传输单元）大小、TCP窗口大小等，也会影响TCP连接的性能和数量。
TCP连接状态：
TCP连接在不同状态（如SYN_SENT、ESTABLISHED、CLOSE_WAIT等）会占用不同的资源。
并发连接数：
实际应用中，通常关注的最大并发连接数，即同时处于活跃状态的TCP连接数量。
性能和资源：
系统的性能和可用资源也会影响TCP连接数，如CPU、内存、网络带宽等。
优化和调整：
通过优化操作系统参数和网络配置，可以提高TCP连接数，但需要权衡资源消耗和性能需求。

传输层有哪些协议介绍一下

TCP 是面向连接的、可靠的字节流传输服务。
它使用三次握手建立连接，并通过序列号、确认应答、重传机制、流量控制和拥塞控制等机制确保数据的可靠传输。
用户数据报协议（UDP, User Datagram Protocol）：
UDP 是无连接的传输层协议，提供一种简单的方式来发送封装的IP数据报。
它不保证数据的可靠传输，不提供拥塞控制或流量控制，适用于对实时性要求较高的应用。
实时传输协议（RTP, Real-time Transport Protocol）：
RTP 常用于流媒体应用，如音频和视频会议，以及实时游戏。
它设计用来支持多媒体数据的传输，可以与RTCP（实时传输控制协议）一起使用，以提供传输质量反馈。

流控制传输协议（SCTP, Stream Control Transmission Protocol）：
SCTP 是一种可靠的传输层协议，支持多路复用和多宿主支持。
它能够在单一连接中传输多个独立的数据流，适用于需要高可靠性和多路径传输的场景。
数据报拥塞控制协议（DCCP, Datagram Congestion Control Protocol）：
DCCP 提供一种无连接的传输层服务，它结合了TCP的一些拥塞控制特性和UDP的低延迟特性。
适用于需要快速传输但不需要重传机制的应用，如某些流媒体服务。
Internet 协议传输协议（IPT, Internet Protocol Transport Protocol）：
IPT 是一个实验性的协议，旨在提供一种简单的传输层服务，类似于UDP，但具有一些额外的特性，如连接建立和连接终止。
可靠数据报协议（RDP, Reliable Datagram Sockets）：
RDP 是一种提供可靠传输服务的协议，它在UDP的基础上增加了可靠性机制，如确认和重传。
序列包协议（SPP, Sequenced Packet Protocol）：
SPP 是一种面向连接的、可靠的、基于字节流的传输层协议，主要用于Novell NetWare网络。
高级数据链路控制协议（HDLC, High-Level Data Link Control）：
虽然HDLC主要用于数据链路层，但它也可以在某些情况下提供传输层服务，特别是在一些特定的网络环境中。
如何解决TCP包的乱序问题
序列号和确认应答：
TCP通过序列号来确保数据包的顺序。每个TCP段都包含一个序列号，接收方使用这个序列号来重新排序数据包。
数据重排：
接收方的TCP堆栈会缓存乱序到达的数据包，并在正确的顺序到达时将其传递给应用程序。
滑动窗口协议：
TCP使用滑动窗口协议来进行流量控制，这包括接收方告知发送方其接收缓冲区的大小，从而控制发送方的发送速率。
拥塞控制算法：
TCP的拥塞控制算法（如慢启动、拥塞避免、快重传和快恢复）有助于在网络拥塞时调整发送速率，减少乱序和丢包。
保证发送方发送速度能让接收方来得及处理：
流量控制：
TCP的流量控制机制确保发送方不会发送过多数据以至于接收方无法处理。接收方通过通告窗口大小来限制发送方的发送量。
动态调整窗口大小：
接收方根据其处理能力动态调整通告的窗口大小，从而控制发送方的发送速率。
接收方缓冲区管理：
接收方需要合理配置和优化其接收缓冲区大小，以适应不同的网络条件和处理能力。
发送方速率限制：
发送方可以根据接收方的窗口大小调整自己的发送速率，避免超出接收方的处理能力。
拥塞控制：
通过拥塞控制算法，TCP能够感知网络的拥塞程度，并相应地调整发送速率。
选择性确认（SACK）：
当出现丢包时，SACK允许接收方告知发送方哪些数据包已经成功接收，从而只重传丢失的包，而不是整个窗口的数据。
延迟计算：
发送方可以通过测量往返时间（RTT）来估计网络延迟，并据此调整发送策略。
应用程序级别的控制：
在某些情况下，应用程序可以通过调整其数据处理逻辑来适应网络条件，例如通过缓冲或请求/应答模式来控制数据流。
网络设备和协议的支持：
使用支持QoS（服务质量）的网络设备和协议，可以为特定的流量提供优先级和带宽保证
HTTPS的通信过程
客户端发起请求：
客户端（通常是浏览器）向服务器发起HTTPS请求。
服务器响应：
服务器接收到请求后，会将网站的SSL证书发送给客户端。
证书验证：
客户端接收到证书后，会验证证书的有效性，包括证书是否过期、证书颁发机构是否可信等。
密钥交换：
如果证书验证通过，客户端和服务器将使用证书中的公钥开始SSL/TLS握手过程，其中包括密钥交换算法的选择和生成用于本次会话的加密密钥。
握手完成：
握手过程完成后，客户端和服务器都有了一组用于加密和解密数据的密钥。
加密数据传输：
客户端开始使用服务器的公钥加密数据，然后发送给服务器。服务器使用私钥解密数据。
服务器处理请求：
服务器解密请求后，处理客户端的请求，并准备响应数据。
加密响应数据：
服务器使用协商的会话密钥加密响应数据，然后将加密的数据发送回客户端。
客户端解密响应：
客户端接收到加密的响应数据后，使用会话密钥解密数据，获取服务器的响应内容。
会话结束：
当数据传输完成后，客户端和服务器可以结束SSL/TLS会话，释放加密密钥。
会话重启：
对于后续的请求，客户端和服务器可能会重新进行SSL/TLS握手过程，或者使用会话恢复技术来减少握手的开销。

HTTP状态码

1xx（信息性状态码）：
表示接收到的请求正在处理中。
100 Continue：客户端应继续发送请求体（如POST请求）。
2xx（成功状态码）：
表示请求已成功被服务器接收、理解并接受。
200 OK：请求成功。
201 Created：请求成功并且服务器创建了新的资源。
202 Accepted：服务器已接受请求，但尚未处理。
204 No Content：服务器成功处理了请求，但没有返回任何内容。
3xx（重定向状态码）：
表示为了完成请求，需要进一步操作。
301 Moved Permanently：请求的资源已永久移动到新位置。
302 Found：请求的资源临时移动到另一个URI。
303 See Other：服务器指示客户端使用GET方法获取资源。
304 Not Modified：自从上次请求后，资源未被修改，使用缓存版本。
4xx（客户端错误状态码）：
表示客户端似乎有问题。
400 Bad Request：服务器无法理解请求。
401 Unauthorized：请求需要用户的身份认证。
403 Forbidden：服务器理解请求但拒绝执行。
404 Not Found：服务器找不到请求的资源。

405 Method Not Allowed：请求方法不被允许。
408 Request Timeout：服务器在指定的时间内没有收到客户端的任何请求
409 Conflict：请求无法完成，因为资源存在冲突。
5xx（服务器错误状态码）：
表示服务器由于服务器内部错误而无法完成请求。
500 Internal Server Error：服务器内部错误，无法完成请求。
501 Not Implemented：服务器不支持请求的功能。
502 Bad Gateway：服务器作为网关或代理，从上游服务器收到无效响应。
503 Service Unavailable：服务器目前无法使用（由于超载或停机维护）。
504 Gateway Timeout：网关或代理在等待上游服务器响应时超时。

TCP的流控和拥塞控制

流量控制（Flow Control）：
流量控制是为了确保接收方能够跟上发送方的数据发送速率，避免接收方的缓冲区溢出。TCP 使用以下机制来实现流量控制：
滑动窗口机制:
发送方维护一个发送窗口，接收方维护一个接收窗口。接收窗口的大小表示接收方还能接收多少字节的数据。
接收窗口大小:
接收方在TCP报文中的窗口缩放字段中通告其接收窗口的大小。发送方根据这个大小来控制发送的数据量。
ACK 确认:
接收方发送的确认报文（ACK）包含接收窗口的当前大小，发送方根据这个信息调整其发送窗口。
停止-等待机制:
当发送方填满接收方的接收窗口后，必须等待接收方发送新的ACK来增加窗口大小，否则会进入停止-等待状态。
拥塞控制（Congestion Control）：
拥塞控制是为了防止过多的数据注入到网络中，从而避免网络拥塞和数据包的大量丢失。TCP 主要通过以下算法来实现拥塞控制：
慢启动（Slow Start）:
发送方开始时以较低的速率发送数据，然后逐渐增加发送速率，直到达到一个阈值（ssthresh）。
拥塞避免（Congestion Avoidance）:
当达到慢启动阈值后，发送方进入拥塞避免阶段，此时窗口大小增长速率会减慢。
快重传（Fast Retransmit）:
当接收方连续收到三个相同的ACK（表明发送方的某个数据段丢失），发送方会立即重传丢失的数据段，而不是等待重传计时器超时。
快恢复（Fast Recovery）:
结合快重传，快恢复算法允许发送方在重传丢失的数据段后，不降低拥塞窗口的大小，而是稍微减慢增长速率。
拥塞窗口（Congestion Window, cwnd）:
TCP 通过调整拥塞窗口的大小来控制发送到网络中的数据量。拥塞窗口的大小决定了未被确认的数据量。
随机早期检测（Random Early Detection, RED）:
一种网络交换机中的算法，可以在数据包丢失之前检测到拥塞并采取措施。
显式拥塞通知（Explicit Congestion Notification, ECN）:
一种允许网络中的节点向发送方明确报告网络拥塞的机制，通过IP数据包的头部标记来实现。

客户端从输入网址到显示网页内容经历的过程
（解析域名、建立连接、请求与回应、解析网页）

为什么TIME_WAIT要等待2MSL

确保数据传输完成:
等待 2MSL 时间可以确保所有已发送的数据包（包括可能的重传）都被对方接收，即使它们因为网络延迟而晚到。
防止旧的数据包干扰:
如果一个新的连接使用相同的IP地址和端口号，等待 2MSL 可以确保在这个时间内，旧连接的数据包不会干扰新连接。
允许被动关闭方确认连接关闭:
如果连接的被动关闭方（即接收到FIN的一方）没有正确接收到主动关闭方的FIN确认（ACK），它可能会重发FIN请求。TIME_WAIT 状态确保主动关闭方有时间接收并确认这些可能的重发。
处理网络延迟和重传:
网络延迟可能导致TCP段在连接关闭后仍然到达接收方。TIME_WAIT 状态确保即使在最坏的情况下，这些延迟的TCP段也能被正确处理。
防止连接状态混淆:
如果连接快速地重新建立并使用相同的源地址和端口，没有足够的时间间隔，可能会导致接收方混淆新旧连接的状态。
满足TCP规范要求:
TCP协议规范要求实现必须等待足够的时间来处理重复的数据段，2MSL 是一个确保所有实现都能兼容的时间长度。
避免资源泄露:
如果不等待 2MSL，快速重用端口可能会导致资源泄露，因为操作系统可能需要时间来清理旧的连接状态。
当你做进程同步的时候会引入锁机制，锁会带来性能开销，你是怎么考虑这个事情的？那怎么尽量较少锁带来的性能开销呢？（锁的粒度不能太小）

假设在系统里要执行一个程序，简单讲讲从操作系统的角度来看需要做哪些事

用户请求执行:
用户通过某种方式（如命令行、图形界面、快捷方式等）向操作系统发出执行程序的请求。
查找程序:
操作系统根据请求查找可执行文件的位置，这可能涉及到搜索文件系统中的指定路径。
加载程序:
操作系统加载程序的代码和任何必要的库到内存中。这可能包括解析符号链接、加载共享库等。
内存分配:
为程序分配内存空间，包括代码段、数据段、堆和栈。
创建进程:
操作系统创建一个新的进程，分配一个唯一的进程标识符（PID），并初始化进程控制块（PCB）。
设置执行环境:
初始化程序的执行环境，包括设置程序的初始寄存器状态、打开文件描述符、设置环境变量等。
编译（如果需要）:
如果程序是某种中间代码或脚本（如Java字节码、Python脚本等），操作系统可能需要调用相应的解释器或编译器来编译执行。
跳转到程序入口点:
操作系统将控制权转移到程序的入口点，通常是main函数的开始。
执行程序:
程序开始执行，操作系统负责管理程序的执行，包括CPU调度、内存管理、I/O操作等。
处理I/O请求:
程序可能会发起I/O请求，操作系统负责处理这些请求，如读写文件、网络通信等。
错误处理:
如果程序执行过程中出现错误（如非法访问内存、除零错误等），操作系统将捕获这些异常并进行处理。
程序终止:
程序执行完成后，会进行清理工作，包括关闭打开的文件描述符、释放内存等，并退出进程。
资源回收:
操作系统回收程序使用的所有资源，包括CPU时间、内存空间、I/O资源等。
返回结果:
操作系统将程序的退出状态返回给用户，这可能包括程序的退出代码、运行时间等信息。
日志记录:
操作系统可能记录程序执行的日志信息，用于审计、调试或性能分析。

怎么实现切换网络还可以无缝连接的

自动重连机制：
应用程序应该实现自动重连逻辑，当检测到网络断开时，尝试重新连接到网络。
网络状态监听：
应用程序需要监听网络状态的变化，如使用Android的ConnectivityManager或iOS的Reachability类。
使用合适的协议：
一些网络协议如HTTP/2支持连接复用，可以在同一个TCP连接上并行处理多个请求，减少连接建立和断开的开销。
心跳机制：
定期发送心跳包来保持连接活跃，即使在网络状况不佳的情况下也能及时检测到连接问题。

断线重试策略：

实现指数退避或其他重试策略，避免在网络不稳定时频繁重连导致的问题。
预连接：
在预计可能需要切换网络时，预先建立备用网络连接，一旦主网络连接断开，立即切换到备用连接。
多路径路由：
使用支持多路径路由的协议，如MP-TCP（Multipath TCP），允许应用程序同时在多个网络路径上发送数据。
服务端支持：
服务端应支持快速重连，如通过维持用户会话状态，使得客户端在重新连接后能快速恢复到之前的状态。
使用代理或网关：
使用网络代理或网关可以在后端处理网络切换，对客户端透明。
本地缓存：
对于某些应用，可以在本地缓存数据，当网络切换时，使用本地缓存继续提供服务，直到网络恢复。
无缝切换技术：
在移动设备上，可以使用如Android的无缝WiFi切换技术，该技术允许设备在不同WiFi网络之间无缝切换。
状态同步：
确保应用程序状态能够在网络切换后同步，使用如数据库事务日志、状态机等机制。
错误处理：
应用程序应该优雅地处理网络错误，提供用户友好的错误信息，并在可能的情况下恢复操作。
网络切换提示：
在网络切换时，给予用户适当的提示，告知他们当前的网络状态和预计的等待时间。