C++ 编译与底层

原文链接

• 编译与底层

 请你来说一下一个C++源文件从文本到可执行文件经历的过程？

• 对于C++源文件，从文本到可执行文件一般需要四个过程：
• 预处理阶段：对源代码文件中文件包含关系（头文件）、预编译语句（宏定义）进行分析和替换，生成预编译文件。
• 编译阶段：将经过预处理后的预编译文件转换成特定汇编代码，生成汇编文件
• 汇编阶段：将编译阶段生成的汇编文件转化成机器码，生成可重定位目标文件
• 链接阶段：将多个目标文件及所需要的库连接成最终的可执行目标文件

 请你来回答一下include头文件的顺序以及双引号””和尖括号<>的区别？

• Include头文件的顺序：对于include的头文件来说，如果在文件a.h中声明一个在文件b.h中定义的变量，而不引用b.h。那么要在a.c文件中引用b.h文件，并且要先引用b.h，后引用a.h,否则会报变量类型未声明错误。
• 双引号和尖括号的区别：编译器预处理阶段查找头文件的路径不一样。
• 对于使用双引号包含的头文件，查找头文件路径的顺序为：1，当前头文件目录；2，编译器设置的头文件路径（编译器可使用-I显式指定搜索路径）；3，系统变量CPLUS_INCLUDE_PATH/C_INCLUDE_PATH指定的头文件路径
• 对于使用尖括号包含的头文件，查找头文件的路径顺序为：1，编译器设置的头文件路径（编译器可使用-I显式指定搜索路径）；2，系统变量CPLUS_INCLUDE_PATH/C_INCLUDE_PATH指定的头文件路径

请你回答一下malloc的原理，另外brk系统调用和mmap系统调用的作用分别是什么？

• malloc函数用于动态分配内存。为了减少内存碎片和系统调用的开销，malloc其采用内存池的方式，先申请大块内存作为堆区，然后将堆区分为多个内存块，以块作为内存管理的基本单位。当用户申请内存时，直接从堆区分配一块合适的空闲块。malloc采用隐式链表结构将堆区分成连续的、大小不一的块，包含已分配块和未分配块；同时malloc采用显示链表结构来管理所有的空闲块，即使用一个双向链表将空闲块连接起来，每一个空闲块记录了一个连续的、未分配的地址。
• 当进行内存分配时，malloc会通过隐式链表遍历所有的空闲块，选择满足要求的块进行分配；
• 当进行内存合并时，malloc采用边界标记法，根据每个块的前后块是否已经分配来决定是否进行块合并。   操作系统  文件管理
• malloc在申请内存时，一般会通过brk或者mmap系统调用进行申请。其中当申请内存小于128K时，会使用系统函数brk在堆区中分配；而当申请内存大于128K时，会使用系统函数mmap在映射区分配。

补充

• 下面示例中，字符数组a的容量是6个字符，其内容为hello。a的内容可以改变，如a[0]= ‘X’。指针p指向常量字符串“world”（位于静态存储区，内容为world），常量字符串的内容是不可以被修改的。从语法上看，编译器并不觉得语句p[0]= ‘X’有什么不妥，但是该语句企图修改常量字符串的内容而导致运行错误。

char a[] = “hello”;
a[0] = ‘X’;
cout << a << endl;
char *p = “world”; // 注意p指向常量字符串
p[0] = ‘X’; // 编译器不能发现该错误
cout << p << endl;

•  操作系统--brk()和mmap()详解
• 认真分析mmap：是什么 为什么 怎么用
• 从内核文件系统看文件读写过程

参考链接

• C++---之动态内存申请new
• C/C++内存申请和释放(二)
• C++内存管理（超长，例子很详细，排版很好）
• c++四种分配内存的方法整理
• C/C++内存申请和释放(一)
• 操作系统--brk()和mmap()详解

 请你说一说C++的内存管理是怎样的？

• 在C++中，虚拟内存分为代码段、数据段、BSS段、堆区、文件映射区、栈区六部分。
• 代码段:   包括只读存储区和文本区，其中只读存储区存储字符串常量，文本区存储程序的机器代码。
• 数据段：存储程序中已初始化的全局变量和静态变量
• bss 段： 存储未初始化的全局变量和静态变量（局部+全局），以及所有被初始化为0的全局变量和静态变量。
• 堆区：调用new/malloc函数时在堆区动态分配内存，同时需要调用delete/free来手动释放申请的内存。
• 映射区:  存储动态链接库以及调用mmap函数进行的文件映射
• 栈：使用栈空间存储函数的返回地址、参数、局部变量、返回值

请你来说一下C++/C的内存分配

• 32bitCPU可寻址4G线性空间，每个进程都有各自独立的4G逻辑地址，其中0~3G是用户态空间，3~4G是内核空间，不同进程相同的逻辑地址会映射到不同的物理地址中。
• 其逻辑地址其划分如下：
• 各个段说明如下：
• 3G用户空间和1G内核空间

静态区域：

• text segment(代码段):包括只读存储区和文本区，其中只读存储区存储字符串常量，文本区存储程序的机器代码。
• data segment(数据段)：存储程序中已初始化的全局变量和静态变量
• bss segment：存储未初始化的全局变量和静态变量（局部+全局），以及所有被初始化为0的全局变量和静态变量，对于未初始化的全局变量和静态变量，程序运行main之前时会统一清零。即未初始化的全局变量编译器会初始化为0

动态区域：

• heap（堆）： 当进程未调用malloc时是没有堆段的，只有调用malloc时采用分配一个堆，并且在程序运行过程中可以动态增加堆大小(移动break指针)，从低地址向高地址增长。分配小内存时使用该区域。  堆的起始地址由mm_struct 结构体中的start_brk标识，结束地址由brk标识。
• memory mapping segment(映射区):存储动态链接库等文件映射、申请大内存（malloc时调用mmap函数）
• stack（栈）：使用栈空间存储函数的返回地址、参数、局部变量、返回值，从高地址向低地址增长。在创建进程时会有一个最大栈大小，Linux可以通过ulimit命令指定。

补充知识

• 在终端输入wmic memphysical get maxcapacity，将其结果除以1024 再除以1024 (两次)，得到的结果就是电脑可以支持的最大内存

参考链接

• 32/64位系统支持多大内存

 请你回答一下如何判断内存泄漏？

• 原因：内存泄漏通常是由于调用了malloc/new等内存申请的操作，但是缺少了对应的free/delete。
• 内存泄漏(memory leak)是指由于疏忽或错误造成了程序未能释放掉不再使用的内存情况。内存泄漏并非指内存在物理上的消失，而是应用程序分配某段内存后，由于设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

内存泄漏的分类：

• 堆内存泄漏 （Heap leak）。对内存指的是程序运行中根据需要分配通过malloc,realloc new等从堆中分配的一块内存，再是完成后必须通过调用对应的 free或者delete 删掉。如果程序的设计的错误导致这部分内存没有被释放，那么此后这块内存将不会被使用，就会产生Heap Leak.
• 系统资源泄露（Resource Leak）。主要指程序使用系统分配的资源比如 Bitmap,handle ,SOCKET等没有使用相应的函数释放掉，导致系统资源的浪费，严重可导致系统效能降低，系统运行不稳定。
• 没有将基类的析构函数定义为虚函数。当基类指针指向子类对象时，如果基类的析构函数不是virtual，那么子类的析构函数将不会被调用，子类的资源没有正确是释放，因此造成内存泄露。

解决办法：

• 1，为了判断内存是否泄露，我们一方面可以使用linux环境下的内存泄漏检查工具Valgrind
• 2，另一方面我们在写代码时可以添加内存申请和释放的统计功能，统计当前申请和释放的内存是否一致，以此来判断内存是否泄露
• 3，使用mtrace来判断内存是否泄漏

参考链接：

• 使用 Valgrind 检测 C++ 内存泄漏
• Linux 性能分析valgrind（一）之memcheck使用
• bitmap
• 句柄是什么？
• C 什么是句柄？为什么会有句柄？HANDLE
• GCC编译过程（预处理->编译->汇编->链接）
• C/C++内存申请和释放(一)
• C 库函数 - fprintf()
• int main(int argc,char* argv[])详解
• mtrace检查内存泄露
• 聊聊同步、异步、阻塞与非阻塞

请你来说一下什么时候会发生段错误 Segmentation fault (core dumped)

• 段错误：段错误是指访问的内存超出了系统给这个程序所设定的内存空间，例如访问了不存在的内存地址、访问了系统保护的内存地址、访问了只读的内存地址等等情况
• 段错误通常发生在访问非法内存地址的时候，具体来说分为以下几种情况：
• 使用野指针
• 试图修改字符串常量的内容

补充知识

•  gdb ./main_c 使用gdb调试程序
• (gdb) l  查看程序源码
• (gdb) b 8  在程序第8行设置断点
• (gdb) p i  打印变量i的相关信息
• (gdb) r 程序运行，运行至断点处
• (gdb) n 程序继续执行
• (gdb) quit 退出程序
• man 7 signal | grep SEGV 查看对应的  Segmentation fault 错误信息

参考链接

• C/C++中的段错误（Segmentation fault）[转]
• Linux dmesg命令介绍
• Linux环境下段错误的产生原因及调试方法小结
• C语言段错误调试

请你来回答一下什么是memory leak，也就是内存泄漏

• 内存泄漏(memory leak)是指由于疏忽或错误造成了程序未能释放掉不再使用的内存的情况。内存泄漏并非指内存在物理上的消失，而是应用程序分配某段内存后，由于设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

内存泄漏的分类：

• 1. 堆内存泄漏 （Heap leak）。对内存指的是程序运行中根据需要分配通过malloc,realloc new等从堆中分配的一块内存，再是完成后必须通过调用对应的 free或者delete 删掉。如果程序的设计的错误导致这部分内存没有被释放，那么此后这块内存将不会被使用，就会产生Heap Leak.
• 2. 系统资源泄露（Resource Leak）。主要指程序使用系统分配的资源比如 Bitmap,handle ,SOCKET等没有使用相应的函数释放掉，导致系统资源的浪费，严重可导致系统效能降低，系统运行不稳定。
• 3. 没有将基类的析构函数定义为虚函数。当基类指针指向子类对象时，如果基类的析构函数不是virtual，那么子类的析构函数将不会被调用，子类的资源没有正确是释放，因此造成内存泄露。（这个问题尤其体现在使用数组，每个数组的下标对应一个新分配的对象，需要子类使用 delete【 】 来删除每一个对象分配的空间。如果，不对父类函数进行重载，使用父类的析构函数，会导致仅仅释放一个资源）

请你来回答一下new和malloc的区别

• 1、new分配内存按照数据类型进行分配，malloc分配内存按照指定的大小分配；
• 2、new返回的是指定对象的指针，而malloc返回的是void*，因此malloc的返回值一般都需要进行类型转化。
• 3、new不仅分配一段内存，而且会调用构造函数，malloc不会。
• 4、new分配的内存要用delete销毁，malloc要用free来销毁；delete销毁的时候会调用对象的析构函数，而free则不会。
• 5、new是一个操作符可以重载，malloc是一个库函数。
• 6、malloc分配的内存不够的时候，可以用realloc扩容。new没用这样操作。
• 7、new如果分配失败了会抛出bad_malloc的异常，而malloc失败了会返回NULL。
• 8、申请数组时： new[]一次分配所有内存，多次调用构造函数，搭配使用delete[]，delete[]多次调用析构函数，销毁数组中的每个对象。而malloc则只能sizeof(int) * n

 请你来说一下共享内存相关api

• Linux允许不同进程访问同一个逻辑内存，提供了一组API，头文件在sys/shm.h中。

参考链接

• Linux进程间通信（六）：共享内存 shmget()、shmat()、shmdt()、shmctl()

1）新建共享内存shmget

• int shmget(key_t key,size_t size,int shmflg);
• key：共享内存键值，可以理解为共享内存的唯一性标记。
• size：共享内存大小
• shmflag：创建进程和其他进程的读写权限标识。
• 返回值：相应的共享内存标识符，失败返回-1

2）连接共享内存到当前进程的地址空间shmat

• void *shmat(int shm_id,const void *shm_addr,int shmflg);
• shm_id：共享内存标识符
• shm_addr：指定共享内存连接到当前进程的地址，通常为0，表示由系统来选择。
• shmflg：标志位
• 返回值：指向共享内存第一个字节的指针，失败返回-1

3）当前进程分离共享内存shmdt

• int shmdt(const void *shmaddr);

4）控制共享内存shmctl

• 和信号量的semctl函数类似，控制共享内存
• int shmctl(int shm_id,int command,struct shmid_ds *buf);
• shm_id：共享内存标识符
• command: 有三个值
• IPC_STAT:获取共享内存的状态，把共享内存的shmid_ds结构复制到buf中。
• IPC_SET:设置共享内存的状态，把buf复制到共享内存的shmid_ds结构。
• IPC_RMID:删除共享内存
• buf：共享内存管理结构体。

请你来说一下reactor模型组成

• reactor模型要求主线程只负责监听文件描述上是否有事件发生，有的话就立即将该事件通知工作线程，除此之外，主线程不做任何其他实质性的工作，读写数据、接受新的连接以及处理客户请求均在工作线程中完成。其模型组成如下：

• 1）Handle：即操作系统中的句柄，是对资源在操作系统层面上的一种抽象，它可以是打开的文件、一个连接(Socket)、Timer等。由于Reactor模式一般使用在网络编程中，因而这里一般指Socket Handle，即一个网络连接。
• 2）Synchronous Event Demultiplexer（同步事件复用器）：阻塞等待一系列的Handle中的事件到来，如果阻塞等待返回，即表示在返回的Handle中可以不阻塞的执行返回的事件类型。这个模块一般使用操作系统的select来实现。
• 3）Initiation Dispatcher：用于管理Event Handler，即EventHandler的容器，用以注册、移除EventHandler等；另外，它还作为Reactor模式的入口调用Synchronous Event Demultiplexer的select方法以阻塞等待事件返回，当阻塞等待返回时，根据事件发生的Handle将其分发给对应的Event Handler处理，即回调EventHandler中的handle_event()方法。
• 4）Event Handler：定义事件处理方法：handle_event()，以供InitiationDispatcher回调使用。
• 5）Concrete Event Handler：事件EventHandler接口，实现特定事件处理逻辑。

请自己设计一下如何采用单线程的方式处理高并发

• 在单线程模型中，可以采用I/O复用来提高单线程处理多个请求的能力，然后再采用事件驱动模型，基于异步回调来处理事件

参考链接

• Redis为什么是单线程，高并发快的3大原因详解
• 详解高并发与多线程的关系,高并发的技术解决方案
• 怎么理解分布式、高并发、多线程？（含面试题和答案解析）

高并发、任务执行时间短的业务怎样使用线程池？

并发不高、任务执行时间长的业务怎样使用线程池？

并发高、业务执行时间长的业务怎样使用线程池？

• 1）高并发、任务执行时间短的业务，线程池线程数可以设置为CPU核数+1，减少线程上下文的切换
• 2）并发不高、任务执行时间长的业务要区分开看：
• a）假如是业务时间长集中在IO操作上，也就是IO密集型的任务，因为IO操作并不占用CPU，所以不要让所有的CPU闲下来，可以加大线程池中的线程数目，让CPU处理更多的业务
• b）假如是业务时间长集中在计算操作上，也就是计算密集型任务，这个就没办法了，和（1）一样吧，线程池中的线程数设置得少一些，减少线程上下文的切换
• c）并发高、业务执行时间长，解决这种类型任务的关键不在于线程池而在于整体架构的设计，看看这些业务里面某些数据是否能做缓存是第一步，增加服务器是第二步，至于线程池的设置，设置参考其他有关线程池的文章。最后，业务执行时间长的问题，也可能需要分析一下，看看能不能使用中间件对任务进行拆分和解耦。

请你说一说C++ STL 的内存优化

1）二级配置器结构

• STL内存管理使用二级内存配置器。

1、第一级配置器

• 第一级配置器以malloc()，free()，realloc()等C函数执行实际的内存配置、释放、重新配置等操作，并且能在内存需求不被满足的时候，调用一个指定的函数。
• 一级空间配置器分配的是大于128字节的空间,如果分配不成功，调用句柄释放一部分内存  如果还不能分配成功，抛出异常

2、第二级配置器

• 在STL的第二级配置器中多了一些机制，避免太多小区块造成的内存碎片，小额区块带来的不仅是内存碎片，配置时还有额外的负担。区块越小，额外负担所占比例就越大。

3、分配原则

• 如果要分配的区块大于128bytes，则移交给第一级配置器处理。
• 如果要分配的区块小于128bytes，则以内存池管理（memory pool），又称之次层配置（sub-allocation）：每次配置一大块内存，并维护对应的16个空闲链表（free-list）。下次若有相同大小的内存需求，则直接从free-list中取。如果有小额区块被释放，则由配置器回收到free-list中。
• 当用户申请的空间小于128字节时，将字节数扩展到8的倍数，然后在自由链表中查找对应大小的子链表
• 如果在自由链表查找不到或者块数不够，则向内存池进行申请，一般一次申请20块
• 如果内存池空间足够，则取出内存
• 如果不够分配20块，则分配最多的块数给自由链表，并且更新每次申请的块数
• 如果一块都无法提供，则把剩余的内存挂到自由链表，然后向系统heap申请空间，如果申请失败，则看看自由链表还有没有可用的块，如果也没有，则最后调用一级空间配置器

2）二级内存池

• 二级内存池采用了16个空闲链表，这里的16个空闲链表分别管理大小为8、16、24......120、128的数据块。这里空闲链表节点的设计十分巧妙，这里用了一个联合体既可以表示下一个空闲数据块（存在于空闲链表中）的地址，也可以表示已经被用户使用的数据块（不存在空闲链表中）的地址。

1、空间配置函数allocate

• 首先先要检查申请空间的大小，如果大于128字节就调用第一级配置器，小于128字节就检查对应的空闲链表，如果该空闲链表中有可用数据块，则直接拿来用（拿取空闲链表中的第一个可用数据块，然后把该空闲链表的地址设置为该数据块指向的下一个地址），如果没有可用数据块，则调用refill重新填充空间。

2、空间释放函数deallocate

• 首先先要检查释放数据块的大小，如果大于128字节就调用第一级配置器，小于128字节则根据数据块的大小来判断回收后的空间会被插入到哪个空闲链表。

3、重新填充空闲链表refill

• 在用allocate配置空间时，如果空闲链表中没有可用数据块，就会调用refill来重新填充空间，新的空间取自内存池。缺省取20个数据块，如果内存池空间不足，那么能取多少个节点就取多少个。
• 从内存池取空间给空闲链表用是chunk_alloc的工作，首先根据end_free-start_free来判断内存池中的剩余空间是否足以调出nobjs个大小为size的数据块出去，如果内存连一个数据块的空间都无法供应，需要用malloc取堆中申请内存。
• 假如山穷水尽，整个系统的堆空间都不够用了，malloc失败，那么chunk_alloc会从空闲链表中找是否有大的数据块，然后将该数据块的空间分给内存池（这个数据块会从链表中去除）。

3、总结：

• 1. 使用allocate向内存池请求size大小的内存空间，如果需要请求的内存大小大于128bytes，直接使用malloc。
• 2. 如果需要的内存大小小于128bytes，allocate根据size找到最适合的自由链表。
• a. 如果链表不为空，返回第一个node，链表头改为第二个node。
• b. 如果链表为空，使用blockAlloc请求分配node。
• x. 如果内存池中有大于一个node的空间，分配竟可能多的node(但是最多20个)，将一个node返回，其他的node添加到链表中。
• y. 如果内存池只有一个node的空间，直接返回给用户。
• z. 若果如果连一个node都没有，再次向操作系统请求分配内存。
• ①分配成功，再次进行b过程。
• ②分配失败，循环各个自由链表，寻找空间。
• I. 找到空间，再次进行过程b。
• II. 找不到空间，抛出异常。
• 3. 用户调用deallocate释放内存空间，如果要求释放的内存空间大于128bytes，直接调用free。
• 4. 否则按照其大小找到合适的自由链表，并将其插入。

请你说说select，epoll的区别，原理，性能，限制都说一说

1）IO多路复用

• IO复用模型在阻塞IO模型上多了一个select函数，select函数有一个参数是文件描述符集合，意思就是对这些的文件描述符进行循环监听，当某个文件描述符就绪的时候，就对这个文件描述符进行处理。
• 这种IO模型是属于阻塞的IO。但是由于它可以对多个文件描述符进行阻塞监听，所以它的效率比阻塞IO模型高效。

• IO多路复用就是我们说的select，poll，epoll。select/epoll的好处就在于单个process就可以同时处理多个网络连接的IO。它的基本原理就是select，poll，epoll这个function会不断的轮询所负责的所有socket，当某个socket有数据到达了，就通知用户进程。
• 当用户进程调用了select，那么整个进程会被block，而同时，kernel会“监视”所有select负责的socket，当任何一个socket中的数据准备好了，select就会返回。这个时候用户进程再调用read操作，将数据从kernel拷贝到用户进程。
• 所以，I/O 多路复用的特点是通过一种机制一个进程能同时等待多个文件描述符，而这些文件描述符（套接字描述符）其中的任意一个进入读就绪状态，select()函数就可以返回。
• I/O多路复用和阻塞I/O其实并没有太大的不同，事实上，还更差一些。因为这里需要使用两个system call (select 和 recvfrom)，而blocking IO只调用了一个system call (recvfrom)。但是，用select的优势在于它可以同时处理多个connection。
• 所以，如果处理的连接数不是很高的话，使用select/epoll的web server不一定比使用multi-threading + blocking IO的web server性能更好，可能延迟还更大。select/epoll的优势并不是对于单个连接能处理得更快，而是在于能处理更多的连接。）
• 在IO multiplexing Model中，实际中，对于每一个socket，一般都设置成为non-blocking，但是，如上图所示，整个用户的process其实是一直被block的。只不过process是被select这个函数block，而不是被socket IO给block。

2、select

• select：是最初解决IO阻塞问题的方法。用结构体fd_set来告诉内核监听多个文件描述符，该结构体被称为描述符集。由数组来维持哪些描述符被置位了。对结构体的操作封装在三个宏定义中。通过轮寻来查找是否有描述符要被处理。

存在的问题：

• 1. 内置数组的形式使得select的最大文件数受限与FD_SIZE；
• 2. 每次调用select前都要重新初始化描述符集，将fd从用户态拷贝到内核态，每次调用select后，都需要将fd从内核态拷贝到用户态；
• 3. 轮寻排查当文件描述符个数很多时，效率很低；

3、poll

• poll：通过一个可变长度的数组解决了select文件描述符受限的问题。数组中元素是结构体，该结构体保存描述符的信息，每增加一个文件描述符就向数组中加入一个结构体，结构体只需要拷贝一次到内核态。poll解决了select重复初始化的问题。轮寻排查的问题未解决。

4、epoll

• epoll：轮寻排查所有文件描述符的效率不高，使服务器并发能力受限。因此，epoll采用只返回状态发生变化的文件描述符，便解决了轮寻的瓶颈。
• epoll对文件描述符的操作有两种模式：LT（level trigger）和ET（edge trigger）。LT模式是默认模式

1. LT模式

• LT(level triggered)是缺省的工作方式，并且同时支持block和no-block socket.在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的fd进行IO操作。如果你不作任何操作，内核还是会继续通知你的。

2. ET模式

• ET(edge-triggered)是高速工作方式，只支持no-block socket。在这种模式下，当描述符从未就绪变为就绪时，内核通过epoll告诉你。然后它会假设你知道文件描述符已经就绪，并且不会再为那个文件描述符发送更多的就绪通知，直到你做了某些操作导致那个文件描述符不再为就绪状态了(比如，你在发送，接收或者接收请求，或者发送接收的数据少于一定量时导致了一个EWOULDBLOCK 错误）。但是请注意，如果一直不对这个fd作IO操作(从而导致它再次变成未就绪)，内核不会发送更多的通知(only once
• ET模式在很大程度上减少了epoll事件被重复触发的次数，因此效率要比LT模式高。epoll工作在ET模式的时候，必须使用非阻塞套接口，以避免由于一个文件句柄的阻塞读/阻塞写操作把处理多个文件描述符的任务饿死。

3、LT模式与ET模式的区别如下：

• LT模式：当epoll_wait检测到描述符事件发生并将此事件通知应用程序，应用程序可以不立即处理该事件。下次调用epoll_wait时，会再次响应应用程序并通知此事件。
• ET模式：当epoll_wait检测到描述符事件发生并将此事件通知应用程序，应用程序必须立即处理该事件。如果不处理，下次调用epoll_wait时，不会再次响应应用程序并通知此事件。