操作系统

填空题（1*20=20分）简单看看概念

选择题（1*20+ 2 * 5=30分）

简答题（4*5=20分）5道题目，辅修考了：进程的概念，基本特征，中断处理过程

综合题（5*6=30分）6道题目，

考：银行家算法，作业调度算法，PV原语，管程，页面替换算法，存储空间管理，文件索引

[TOC]

绪论

操作系统的定义

操作系统是计算机系统中的一个系统软件，是一些程序模块的集合，它们管理和控制计算机系统中的硬件及软件资源，合理地组织计算机工作流程。以便有效地利用这些资源为用户提供一个具有最够的功能、使用方便、可扩展、安全和可管理的工作环境，从而在计算机与用户之间起到接口的作用。

操作系统的基本类型和特点

批处理操作系统

操作员把用户提交的作业分类，把一批作业编成一个作业执行序列，由专门编制的监督程序自动依次处理

特点：用户脱机使用计算机、成批处理、多道程序运行

分时操作系统

把处理机的运行时间分成很短的时间片，按时间片轮转的方式，把处理机分配给各个进程使用

特点：交互性、多用户同时性、独立性

实时操作系统

在被控对象允许时间范围内做出响应

特征：对实时信息分析处理速度要比进入系统快、要求安全可靠

微机操作系统

单用户单任务OS

只允许一个用户上机，且只允许用户程序作为一个任务运行

最具代表性的是CP/M和MS-DOS

单用户多任务OS

只允许一个用户上机，但允许将一个用户程序分为若干个任务，使他们并发执行

最具代表性的是os/2和MS-WINDOWS

多用户多任务OS

允许多个用户通过各自的终端使用同一台主机，共享主机的各类资源，同时用户程序又可以分成几个任务使它们并发执行

最具代表性的是UNIX OS

操作系统的功能

处理机管理

存储管理

设备管理

文件系统管理（信息管理）

用户接口

程序一级接口

作业一级接口

思考题

问题：鼠标点击“绪论.ppt”图标到屏幕上显示该文件内容

这个过程中，按照先后顺序描述操作系统完成了哪些功能？（尽可能描述细节）

鼠标点击—设备管理，用户接口

启动powerpoint程序—-存储管理，处理器管理

打开绪论.ppt文件—-文件管理，设备管理，存储管理

在屏幕上显示—-设备管理，用户接口

操作系统的特点

并发是两或多个事件在同一时间间隔内发生。

共享性：系统中的所有资源不再为一个程序所独占，而是供同时存在于系统中的多道程序所共同使用

虚拟是指通过某种技术把一个物理实体变为若干个逻辑上的对应物

异步性和不确定性：程序的执行并非“一气呵成”，而是以“走走停停”的方式运行，即程序是以异步方式运行的

作业

是指在一次应用业务处理过程中，从输入开始到输出结束，用户要求计算机所做的有关该次业务处理的全部工作

系统调用

作用：系统调用是系统向编程人员（应用程序，用户程序）提供的唯一接口

实现过程：

（1）用户在源程序中使用系统调用，并给出系统调用名和参数，即产生一条相应的陷阱指令

（2）处理机在执行到这条指令后，引起处理机中断，并发出有关信号给陷阱处理机构

（3）该处理机构收到信号后，启动相关程序保护处理机现场，取系统调用功能号并寻找子程序入口，通过入口地址表找到该系统子程序并执行

（4）执行完毕后，退出中断，返回到用户程序的断点，恢复现场，继续执行用户程序

进程管理

程序顺序执行的特征

顺序性，一个程序开始执行必须要等到前一个程序已执行完成。

封闭性，程序一旦开始执行，其计算结果不受外界因素影响。

可再现性，程序的结果与它的执行速度无关（即与时间无关），只要给定相同的输入，一定会得到相同的结果

程序并发执行的特征

间断性，“走走停停”，一个程序可能走到中途停下来，失去原有的时序关系

失去封闭性，程序在并发执行时，是多个程序共享系统中的各种资源，因而这些资源的状态将由多个程序来改变，致使程序的运行失去了封闭性

不可再现性，程序在并发执行时，由于失去了封闭性，也导致失去了可再现性

并发

概念，一组在逻辑上相互独立的程序或程序段在执行过程中，其执行时间在客观上相互重叠

并发带来的效率提升

进程

概念：在操作系统中进程是一个拥有资源的基本单位，也是一个调度和执行的基本单位

特征：动态性（最基本），并发性，独立性，异步性，结构特性

进程的静态结构

PCB :OS感知进程的存在的唯一标识

PCB，由进程创建原语创建

程序段

数据结构集

进程状态转换

执行，等待，就绪

思考题

如果系统中有N个进程，运行的进程最多几个，最少几个；就绪进程最多几个，最少几个；等待进程最多几个，最少几个？

答：最多有1个进程运行，最少是0个，就绪进程最多N-1个，最少0个

等待进程最多N个，最少0个（死锁）

原语

概念：是指系统态下执行的某些具有特定功能的程序段

原语又称为“原子操作(Atomic Operation)”过程，作为一个整体而不可分割——要么全都完成，要么全都不做

机器指令级的:执行期间不允许中断

功能级的:作为原语的程序段不允许并发执行

临界区

概念：一个进程访问临界资源的那段程序代码称为临界部分或者称为临界区.即访问公用数据的那段程序

使用准则：

（1）不能假设各并发进程的相对执行速度。即各并发进程享有平等的、独立的竞争共有资源的权利，且在不采取任何措施的条件下，在临界区内任一指令结束时，其他并发进程可以进入临界区

（2）并发进程中的某个进程不在临界区时，它不阻止其他进程进入临界区；放弃处理机

（3）并发进程中的若干个进程申请进入临界区时，只能允许一个进程进入。

（4）从并发进程中的某个进程申请进入临界区时开始，应在有限时间内能够进入其临界区

即：空则让进，等则让权（让权等待），忙则等待，等则有限

信号量

信号量的本质是计数器，一个口袋，P是申请拿球，V是放球

sem>0表示有sem个资源可用

sem=0表示无资源可用

sem<0则| sem |表示sem等待队列中的进程个数

sem的应该初值大于等于零

P(S):表示申请一个资源

V(S):表示释放一个资源

进程互斥的实现

软件法：通过平等协商方式实现进程互斥

单标志算法，双标志、先检查算法，双标志、先修改后检查算法，先修改、后检查、后修改者等待算法

硬件法：关中断，专用指令（testset, swap）

信号量

单个临界资源：整型信号量，记录型信号量

多个临界资源:AND型信号量

管程

条件变量：cwait,csignal

局部变量,操作

实现进程的同步和互斥

进程的互斥：由于共享资源而引起的在临界区内不允许并发进程交叉执行的现象称为由共享公有资源而造成的对并发进程执行速度的间接制约

进程的同步：由于并发进程互相共享对方的私有资源所引起的直接制约

进程的前驱关系（时间同步）

一组有关的并发进程在执行时间上有严格的先后顺序时，就会出现时间上的进程同步问题，或者称为进程的前驱关系

进程通信

低级通信：进程之间控制信息的交换。一般只传送一个和几个字节的信息，达到控制进程执行速度的作用。（进程的同步和互斥）

高级通信：用户可以直接利用操作系统所提供的一组通信命令，高效地传送大量数据的一种通信方式。

方式：主从式 (master-servant system) 　，会话式(dialogue system)，

消息或信箱机制(message)，共享存储区方式(shared memory）

死锁

**概念：**指多个进程因竞争资源而造成的一种僵局，若无外力的作用，这些进程将永远不能再向前推进

产生死锁的必要条件：互斥，部分分配，不剥夺条件，环路等待

1. Mutual-exclusion - 一个口袋一个球，得到球才能继续
2. Wait-for - 得到球的人想要更多的球
3. No-preemption - 不能抢别人的持有的球
4. Circular-chain - 形成循环等待球的关系

预防死锁

**预防死锁设计思路：**设置某些限制条件，去破坏死锁四个必要条件中的一个或多个，来防止死锁。

防止“互斥条件”：使用Spooling技术来管理设备

防止“不剥夺”条件的出现：一个已经保持了某些资源的进程，当它再提出新的资源要求而不能立即得到满足时，必须释放它已经保持的所有资源，待以后需要时再重新申请

防止部分分配（摒弃请求和保持条件）：系统要求任一进程必须预先申请它所需的全部资源，而且仅当该进程的全部资源要求能得到满足时，系统才能给予一次性分配，然后启动该进程运行

防止“环路等待”条件的出现：把系统中所有资源类型线性排队，并按递增规则赋予每类资源以唯一的编号，进程申请资源时，必须严格按资源编号的递增顺序进行，否则系统不予分配

死锁避免：

安全状态：存在某种资源调度顺序，来为每个进程分配其所需资源，直至最大需求,保证所有进程正常运行完成，则称该状态为安全状态。

不安全状态：不存在可满足所有进程正常运行的资源调度顺序，则称该状态为不安全状态

避免死锁的实质是如何使系统不进入不安全状态

银行家算法

判断是否为安全状态，对于进程的资源请求，判断是否能够进行分配

银行家算法_Banker’s_Algorithm_哔哩哔哩_bilibili

死锁的检测和恢复

死锁的检测：实质是确定是否存在环路等待现象

死锁的恢复：立即结束所有进程的执行,并重新启动操作系统；撤销进程；剥夺资源

线程

线程是调度和执行的基本单位，不作为独立分配资源的单位

引入线程则是为了减少程序并发执行时的所付出的时空开销

线程本身拥有少数资源，多个线程共享所属进程的资源

线程分类：用户级线程，系统级线程

适用范围：多处理机系统，网络与分布式系统

处理器调度

调度的分级

作业调度（宏观调度，高级调度），交换调度（中级调度），内外存的进程交换，进程调度，分配处理机

作业调度的衡量

周转时间：从提交到完成的时间

带权周转时间：周转时间除运行时间

调度算法（考）

先来先服务（FCFS）：将用户作业和就绪进程按提交顺序或变为就绪状态的先后排成队列，并按照先来先服务的方式进行调度处理，它优先考虑在系统中等待时间最长的作业，而不管要求运行时间的长短

轮转法:

把CPU划分成若干时间片。将系统中所有的就绪进程按照FCFS原则，排成一个队列每次调度时将CPU分派给队首进程，让其执行一个时间片

时间片的选择：

时间片长度S＝R/Nmax

R：响应时间;

Nmax：最大进程数

多级反馈轮转法:

系统中设置多个就绪队列

每个就绪队列分配给不同时间片，优先级高的为第一级队列，时间片最小，随着队列级别的降低，时间片加大

优先级法:静态优先级,动态优先级

最短作业优先法

对预计执行时间短的作业（进程）优先分派处理机

比FCFS改善平均周转时间和平均带权周转时间，缩短作业的等待时间；

提高系统的吞吐量

最高响应比优先法:响应比R = 1 +（作业等待时间/ 作业执行时间）

实时系统中的任务分类

按照时限严格程度类型分类

硬实时任务：要求系统必须完全满足任务的时间要求

软实时任务：允许系统对任务的时限要求有一定的延迟，时限要求是一个相对条件

按照时限是周期or时刻分类

周期性任务：要求在周期T内完成或开始进行处理

非周期性任务：存在一个完成或开始进行处理的时间

存储管理

概念

**逻辑地址:**程序经编译或汇编以后形成目标程序，其指令的顺序都是以零作为参考地址，这些地址称为 逻辑地址

虚拟地址空间:

虚存容量的扩大是以牺牲CPU工作时间以及内、外存交换时间为代价的 （时间换空间）

虚拟存储器的最大容量（用户编程空间）由计算机的地址结构和寻址方式决定

如直接寻址时，若CPU的有效长度为16位，则其地址范围是0～～64K-1(216-1)，最大容量为64K**(确认地址位数)**

静态重定位

在装入一个作业时，把作业中的指令地址和数据地址全部转换为物理地址（地址转换工作是在作业执行前集中一次完成的）在作业执行过程中就无须再进行地址转换工作

动态重定位:地址转换是在作业执行时动态完成

内存保护

上下界保护法

在CPU中设置一对上界寄存器和下界寄存器存放用户作业在内存中的起始地址和终止地址；每当CPU要访问内存时，硬件自动将被访问的内存地址与界限寄存器的内容进行比较，以判断是否越界

保护键法

为每一个被保护存储块分配一个单独的保护键。保护键可设置成对读写同时保护的或只对读、写进行单项保护的；在程序状态字中则设置相应的保护键开关字段, 不同的进程赋予不同的开关代码；

界限寄存器与CPU的用户态或核心态工作方式相结合的保护方式

在这种保护模式下，用户态进程只能访问那些在界限寄存器所规定范围内的内存部分，而核心态进程则可以访问整个内存地址空间

内存扩充

覆盖方式：

一个程序的几个代码段或数据段，按照时间先后来占用公共的内存空间

交换方式：

由操作系统把那些在内存中处于等待状态的进程换出内存，以及把那些等待事件已经发生，处于就绪态的进程换入内存，以及那些即将执行的程序数据调入内存

调入方式：

请求调入方式, 预调入方式

内存管理

常用方法:

分区存储管理,页式管理,段式管理,段页式管理

动态分区分配

最先适应法:要求空闲分区按首址递增的次序组织可用表或自由链

最佳适应法:空闲分区链按照分区容量递增的方式形成

最坏适应法:要求空闲区按大小递减的顺序组织可用表(或自由链)

动态分区回收:

a,与空闲区合并。b,与上空闲区合并。c,与下空闲区合并。d,不合并

缺点：

所谓“碎片”(fragmentation)：就是指不能分配给作业使用的一段无效存贮空间。

固定分区管理存在内碎片，可变分区管理存在外碎片

碎片使得内存的空闲空间得不到充分利用，并且存储每个用户作业都要受到实际存储容量的限制。

页式管理（考计算）

页式管理中给定逻辑地址的组成，页表，将逻辑地址转换为物理地址

计算过程：程序地址/页长

页式管理的问题：CPU要存取一个数据，需访问主存两次

解决：快表

请求（动态）页式管理的实现：

与每个虚页号相对应，除了页面号之外，再增设该页是否在内存的中断位以及该页在外存中的副本起始地址，还应增加一项以记录该页是否曾被改变

段式存储管理（考计算）

给定段表，计算逻辑地址对应的物理地址

页面置换算法（考）

注意刚开是空页放入也计入表格

FIFO算法：淘汰最早建立的页面，Belady现象

LRU:最近最久没有使用,当需要淘汰时，应淘汰当前时间最近的一段时间内最久没有使用过的页

LFU:最不经常使用,淘汰被访问次数最少的页

NUR：当需要淘汰某一页时，从那些最近一个时期内未被访问的页中任选一页淘汰

理想型页面置换法（OPT）：选择“未来不再使用的”或“在离当前最远位 置上出现的”页面被置换

缺页率的计算：缺页次数/访问页面次数

Belady现象

采用FIFO算法时，如果对一个进程未分配它所要求的全部页面，有时就会出现分配的页面数增多，缺页率反而提高的异常现象。

原因：

FIFO算法的置换特征与进程访问内存的动态特征是矛盾的，即被置换的页面并不是进程不会访问的

局部性原理

指程序在执行过程中的一个较短时期，所执行的指令地址和指令的操作数地址，分别局限于一定区域

还可以表现为：

时间局部性，即一条指令的一次执行和下次执行，一个数据的一次访问和下次访问都集中在一个较短时期内；

空间局部性，即当前指令和邻近的几条指令，当前访问的数据和邻近的数据都集中在一个较小区域内

内存抖动问题

定义：

在虚存中，页面在内存与外存之间频繁调度，以至于调度页面所需时间比进程实际运行的时间还多，此时系统效率急剧下降，甚至导致系统崩溃。这种现象称为颠簸或抖动

产生的原因

分配给进程的物理页面数太少

页面淘汰算法不合理

避免的方法

扩大工作集

选择不同的淘汰算法

文件系统

文件的逻辑结构与存取方法

逻辑结构

字符流式的无结构文件：源程序、可执行文件、库函数等

记录式的有结构文件：数据库

存取方法

(1)顺序存取法

⑵ 随机（直接）存取法

⑶ 按关键字存取法

文件的物理结构与存储设备

物理结构

为了有效地管理文件存储器，通常把文件存储空间划分成若干个大小相等的物理块，物理块是分配及传输信息的基本单位

常用的物理结构：连续文件，串联文件，索引文件；

存储设备

顺序存储设备：磁带

直接存储设备：磁盘

磁盘臂调度算法

先来先服务(FCFS):

磁盘驱动程序每次接收一个请求并按照接收顺序完成请求

最短寻道时间优先（shortest seek time first，SSTF）:

下一次总是处理与磁头距离最近的请求以使寻道时间最小化

文件空间管理

空闲文件目录

空闲块链

UNIX中使用成组链法

位视图

文件接口

OPEN, close, create,delete

目录结构

单级目录

结构简单，实现容易

搜索速度较慢，不允许文件重名

二级目录

解决了文件的重名问题和文件共享问题

提高搜索速度，查找时间降低

多级目录

层次结构清晰，便于管理和保护；有利于文件分类；解决重名问题；

查找一个文件按路径名逐层检查，由于每个文件都放在外存，多次访盘影响速度

文件的共享

绕道法

使用绕道法进行文件共享时，用户从当前目录出发向上返回到与所要共享文件所在路径的交叉点再顺序下访到共享文件

链接法

在相应目录表之间进行链接。即将一个目录中的链指针直接指向被共享文件所在的目录

基本文件目录表BFD

把所有文件目录的内容分成两部分：

基本文件目录表BFD：存放除了文件名之外的文件说明信息和文件内部标识符；

符号文件目录表SDF：存放文件名和文件内部标识符

存取权限控制

（1）文件的共享：指不同的用户共同使用一个文件

（2）文件的保护：指文件本身需要防止文件的拥有者或其他用户破坏文件内容。

（3）文件的保密：指未经拥有者许可，任何用户不得访问该文件。（防止窃取）

设备管理

SPOOLNG系统

假脱机真联机技术：设备管理的虚拟技术

它使用直接存取的大容量磁盘作为缓冲，将一个可共享的磁盘空间改造成若干个输入设备和输出设备，并使得I/O设备和CPU并行操作。（在联机情况下实现的同时外围操作）

SPOOLING 系统的组成

（1）输入井和输出井（2）输入缓冲区和输出缓冲区

（3）输入进程和输出进程（输入管理模块、输出管理模块）

特点：

1. 提高了I/O速度

   从对低速I/O设备进行的I/O操作变为对输入井或输出井的操作,如同脱机操作一样,提高了I/O速度,缓和了CPU与低速I/O设备速度不匹配的矛盾

2. 设备并没有分配给任何进程

   在输入井或输出井中,分配给进程的是一存储区和建立一张I/O请求表.

3. 实现了虚拟设备功能

   多个进程同时使用一独享设备,而对每一进程而言,都认为自己独占这一设备,不过,该设备是逻辑上的设备

数据传输控制方式

程序直接控制：由用户进程来直接控制内存或CPU和外设间的信息传送。

中断方式：进程通过CPU发出指令启动外设，该进程阻塞。当输入完成时，I/O控制器通过中断请求线向CPU发出中断信号，CPU进行中断处理。

DMA方式：在外设和内存之间开辟直接的数据交换通路。（成块）

通道控制方式：CPU发出启动指令，指出通道相应的操作和I/O 设备，该指令就可启动通道并使该通道从内存中调出相应的通道指令执行。（成组）

中断技术

中断的概念

指CPU对系统发生的某个事件作出的一种反应：

CPU暂停正在执行的程序，

保留现场后自动转去执行相应的处理程序，

处理完该事件后再返回断点继续执行被“打断”的程序。

中断的处理过程

1、保存被中断程序的现场，其目的是为了在中断处理完之后，可以返回到原来被中断的地方继续执行；

2、分析中断源，判断中断原因；

3、转去执行相应的处理程序；

4、恢复被中断程序现场，继续执行被中断程序。

分类

根据中断源的产生的条件，可把中断分为外中断和内中断

中断和陷阱的主要区别

将中断源按照外界因素的作用程度进行划分，常可分为自愿型中断与强迫型中断两大类

	区别
中断	强迫型中断
陷阱	自愿型中断

缓冲技术

引入缓冲技术的原因

1、改善CPU与I/O设备间速度不匹配的矛盾

2、可以减少对 CPU的中断频率，放宽对中断响应时间的限制

3、提高 CPU和 I／O设备之间的并行性

缓冲的设置

根据位置：专用硬件缓冲器，软件缓冲

根据个数：单缓冲、双缓冲和缓冲池

设备分配数据结构

设备无关性

为了提高系统的可适应性和可扩展性，我们希望所编制的用户程序与实际使用的物理设备无关，这就是所谓与设备无关性。

为此，我们将逻辑设备与物理设备区分，并引入逻辑设备名称和物理设备名称的概念

为了实现与设备的无关性，系统中必须有一张联系逻辑设备名称和物理设备名称的映射表，（ＬＵＴ表）

用户I/O：用户程序通过内核提供的系统调用接口与逻辑I/O层交互

设备无关程序

对设备驱动程序的统一接口——向用户层软件提供一个一致接口

设备命名——设备无关软件负责将设备名映射到相应驱动程序

设备保护——检查是否有权访问申请的设备（个人计算机不提供任何保护）

提供独立于设备块大小——逻辑记录到物理记录的转换

缓冲区管理与块设备的存储分配

独占性外围设备的分配和释放——通过 OPEN 打开相应的设备文件进行申请；关闭独占设备同时将释放该设备

错误报告——关键系统数据结构出错（如读磁盘使用状况位图），操作系统打印出错信息，并终止运行

设备驱动程序的功能

(1) 接收由I/O进程发来的命令和参数，并将命令中的抽象要求转换为具体要求，例如，将磁盘块号转换为磁盘的盘面、磁道号及扇区号。　

(2) 检查用户I/O请求的合法性，了解I/O设备的状态，传递有关参数，设置设备的工作方式。

(3) 发出I/O命令，如果设备空闲，便立即启动I/O设备去完成指定的I/O操作；如果设备处于忙碌状态，则将请求者的请求块挂在设备队列上等待。　

(4) 及时响应由控制器或通道发来的中断请求，并根据其中断类型调用相应的中断处理程序进行处理。

(5) 对于设置有通道的计算机系统，驱动程序还应能够根据用户的I/O请求，自动地构成通道程序。

I/O中断处理程序

通知用户程序输入输出操作推进的程度

通知用户程序输入输出操作正常结束（设备通知通道/控制器→CPU）

通知用户程序发现的输入输出操作异常，及提前中止操作的原因

通知程序外围设备上有重要的异步信号，如设备报到、设备结束等

LINUX操作系统

Linux进程调度原则：

按照进程优先级，调度最高优先级进程

进程优先级随时间动态变化

Linux的进程分为普通进程和实时进程

对于普通进程采用可抢占式动态优先级调度：SCHED_OTHER

对于实时进程，采用两种调度策略：

基于优先级(rt-priority)的先进先出调度：SCHED_FIFO，

基于优先级(rt-priority)的时间片轮转调度：SCHED_RR

Linux系统采用段页式存储管理技术，提供虚拟存储功能

补充

管程

是一种共享的数据结构，内部资源只能由内部函数访问，

基本特征：

各外部进程/线程只能通过管程提供的特定入口才能访问共享数据，

每次仅允许一个进程在管程内执行某个内部进程

新增 SSH 密钥到 GitHub 帐户 - GitHub 文档

第一步

1
2
3

cd ~/.ssh
ls
//看是否存在 id_rsa 和 id_rsa.pub文件，如果存在，说明已经有SSH Key

第二步：生成ssh key

如果不存在ssh key，使用如下命令生成

1
2

ssh-keygen -t rsa -C "xxx@xxx.com"
//执行后一直回车即可

第三步：获取ssh key公钥内容（id_rsa.pub）

1
2

cd ~/.ssh
cat id_rsa.pub

复制该内容

第四步：Github账号上添加公钥

进入Settings设置
添加ssh key，把刚才复制的内容粘贴上去保存即

第五步：验证是否设置成功

1

ssh -T git@github.com

注意之后在clone仓库的时候要使用ssh的url，而不是https！

Mysql问题

说一说事物隔离级别

SQL标准的事务隔离级别包括：

读未提交，读提交，可重复读，串行化

事务的四大特性有哪些？

原子性，一致性，隔离性，持久性

Linux系统目录

C++11新特性总结

final关键字

使派生类不可覆盖它所修饰的虚函数

override描述符

如果派生类在虚函数声明时使用了override描述符，那么该函数必须重载其基类中的同名函数

关于左值，右值

C++中所有的值都必然属于左值、右值二者之一。左值是指表达式结束后依然存在的持久化对象，右值是指表达式结束时就不再存在的临时对象。所有的具名变量或者对象都是左值，而右值不具名。很难得到左值和右值的真正定义，但是有一个可以区分左值和右值的便捷方法：看能不能对表达式取地址，如果能，则为左值，否则为右值。

右值引用

左值是指可以出现在=左侧者，

右值是指只能出现在=右侧者

临时对象是个右值

右值引用与move语义的关系

• 关联性: 右值引用是实现move语义的基础
• 作用: 允许”偷取”临时对象的资源而非复制
• 应用场景: 容器操作中大量临时对象的处理

移动语义

右值则临时对象

1

c.insert(ite,Vtype(buf));

左值则使用move关键字

1
2

M c1(c);
M c2(std::move(c1));

• 核心机制
  • 当赋值右侧是右值时，左侧对象可直接”偷取”资源
  • 避免不必要的资源分配和拷贝
• 实现要点
  • 类需要同时实现拷贝和移动语义版本
  • 移动操作后原对象应处于有效但未定义状态
  • 容器需要支持右值版本的插入操作
• 注意事项
  • 被移动后的对象不应再使用
  • 移动构造函数应标记为noexcept
  • 临时对象自动被视为右值
• 典型应用
  • 容器扩容时的元素迁移
  • 返回临时对象的优化
  • 明确不再使用的左值资源转移

应用

1. 函数返回值优化。
2. STL 容器的高效插入与操作。
3. 动态资源管理（如智能指针）。

完美转发

1. 底层数据结构

• 动态数组：元素连续存放且可动态扩展的数组。
• 链表：使用指针将元素链接而成的结构，可分为单向链表与双向链表。
• 平衡二叉树：自平衡的二叉搜索树，常用的是红黑树（Red-Black Tree）。
• 哈希表：以哈希函数作为索引，通过哈希冲突解决机制（如拉链法）高效存储数据。
• 堆：通常是二叉堆，支持动态调整以保证堆顶始终是最大值或最小值。

2. 元素存储特点

• 连续存储：vector 和 array 采用连续存储，内存紧凑，随机访问快。
• 分段连续存储：deque 分段实现，以保证在头尾添加数据的高效性。
• 不连续存储：list、forward_list、set 等采用链表或树结构，插入/删除效率高，但随机访问速度较慢。

3. 访问方式

• 下标访问 ([])：vector、array 支持随机访问，可迅速获取指定位置的元素。
• 头尾访问：stack 和 queue 限制为某些特定操作。
• 优先访问：priority_queue 只能访问堆顶元素（最大值/最小值）。
• 基于 key 访问：map、unordered_map 以键值对方式支持查找。

4. 是否支持随机访问

• 支持随机访问的容器（如 vector、array、deque 等）提供 O(1) 复杂度的下标访问，操作简单。
• 不支持随机访问的容器（如 list、set 等）需要遍历或依赖搜索结构，访问效率较低。

5. 动态大小调整

• 动态容器（如 vector、deque、list）可以根据元素数目动态分配或收缩内存。
• 静态容器（如 array）在定义时需指定固定大小。

6. 应用场景

每种容器都有其典型应用场景，选择合适的容器取决于业务需求（如性能、顺序性、查找效率）。

根据需求选择不同容器：

1. 需要快速随机访问：使用 vector、array。
2. 需要频繁插入和删除：使用 list、deque（插入和删除表现良好）。
3. 需要数据自动排序：使用 set、multiset（有序集合）或 map、multimap（有序键值对）。
4. 需要快速查找，不关心顺序：优先选择哈希容器，比如 unordered_set 和 unordered_map。
5. 使用栈或队列模型：考虑 stack、queue 或 priority_queue。

项目背景： 设计并实现了一个基于 Linux 平台的轻量级 HTTP 服务器，采用多 Reactor 多线程高并发模型，通过 epoll 提供高效的 I/O 复用。结合自动增长缓冲区、定时器和异步日志等技术，实现了高性能和稳定运行的目标。

主要工作

内存优化：设计了内存池和 LFU 缓存，减少内存碎片，提升内存使用效率。

高效事件处理：利用 epoll 多路复用机制，高效监听和处理客户端连接及数据传输事件。

高并发模型：基于 Reactor 模型，实现 One Loop per Thread，支持多客户端并发连接。

动态缓冲区：实现自动增长缓冲区，动态调整大小以适配不同请求，优化内存分配。

连接管理：使用小根堆实现高效定时器，管理连接超时时间，防止长期空闲连接浪费资源。

异步日志：设计异步日志模块，基于单例模式和阻塞队列，实现高效日志写入，避免同步写入的性能开销。

关于项目

介绍一下

本项目是一个高性能的WEB服务器，使用C++实现，项目底层采用了多线程多Reactor的网络模型，并且在这基础上增加了内存池，高效的双缓冲异步日志系统，以及LFU的缓存。

服务器的网络模型是主从reactor加线程池的模式，IO处理使用了非阻塞IO和IO多路复用技术，具备处理多个客户端的http请求和ftp请求，以及对外提供轻量级储存的能力。

项目中的工作可以分为两部分，

一部分是服务器网络框架、日志系统、存储引擎等一些基本系统的搭建，

另一部分 是为了提高服务器性能所做的一些优化，比如缓存机制、内存池等一些额外系统的搭建。

最后还对系统中的部分功能进行了功能和压力测试。对于存储引擎的压力测试，

在本地测试下，存储引擎读操作的QPS可以达到36万，写操作的QPS可以达到30万。对于网络框架的测试，使用webbench创建1000个进程对服务器进行60s并发请求，测试结果表明，对于短连接的QPS为1.8万，对于长连接的QPS为5.2万。

项目难点

根据工作分为两部分

一部分是服务器网络框架，日志系统，存储引擎等一些基本系统的搭建，这部分的难点主要就是技术理解和选型，以及将一些开源的框架调整后应用到我的项目中去。

另一部分就是性能优化方面，比如缓存机制，内存池等一些额外系统的搭建。这部分的难点在于找出服务器的性能瓶颈所在，然后结合自己的想法突破瓶颈，提高服务器性能。

遇到的困难，怎么解决

一方面是对技术理解不够深刻，难以选出合适的技术框架，这部分主要是阅读作者的技术文档，找相关的解析文章看

另一部分是编程遇到的困难，由于工程能力不足出现bug，这部分主要是通过日志定位bug，推断bug出现的原因并尝试修复，如果以自己能力无法修复，先问问ai能提供什么思路，或者搜索相关的博客。

内存优化

设计了内存池和 LFU 缓存

缓存机制

为什么选择LFU

因为最近加入的数据因为起始的频率很低，容易被淘汰，而早期的热点数据会一直占据缓存。

高效事件处理：

epoll 多路复用机制

采用非阻塞I/O模型，执行系统调用就立即返回，不检查事件是否发生，没有立即发生返回-1，errno设置为在处理中。所以要采用I/O通知机制（I/O复用和SIGIO信号）来得知就绪事件。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

I/O多路复用技术
I/O 多路复用允许一个线程同时监视多个 I/O 文件描述符（如网络 socket），并在其中一个或多个文件描述符变为"可操作"时返回。应用程序可以据此进行相应的 I/O 操作（如读、写）。

1.1 select
简介
select 是一种最早的 I/O 多路复用接口，几乎所有主流平台都支持。

它允许程序监视多个文件描述符，查询它们是否可读、可写或出现错误。
select 的接口会使用三个位图（readset、writeset 和 exceptset）指定文件描述符的状态。
工作原理
调用 select 时，程序将文件描述符集（一个位图）传递给内核。
内核在超时时间内扫描这些文件描述符并返回那些状态发生变化的描述符（如变为可读或可写）。
用户态程序可根据返回结果进行相应的 I/O 操作。
缺点
支持的文件描述符数量有限（通常受 FD_SETSIZE 限制，默认 1024）。
每次调用时都需要将文件描述符的状态从用户态复制到内核态，这带来一定的性能开销。
内核需要线性遍历所有文件描述符（效率低），尤其在大并发连接时性能较差。
1.2 poll
简介
poll 是 select 的改进版本，克服了文件描述符数量限制的问题。

它使用一个数组结构而不是位图来描述文件描述符及其事件。
工作原理
用户定义一个 pollfd 数组，该数组中每一个元素保存一个文件描述符及其相关事件。
调用 poll 时，内核会遍历这个数组，检查哪些文件描述符有事件发生，并返回结果。
优点
支持任意数量的文件描述符，突破了 select 的 FD_SETSIZE 限制。
缺点
和 select 类似，每次调用都需要将监控的文件描述符数组从用户态复制到内核态，开销较大。
和 select 一样，内核需要线性遍历文件描述符，在高并发场景下效率仍然较低。
1.3 epoll
简介
epoll 是 Linux 平台下提供的高性能 I/O 多路复用接口，它是 select 和 poll 的替代品。

epoll 被设计用于解决 select 和 poll 的性能问题，是一种效率更高的方式处理大量并发连接的技术。
工作原理
epoll 的核心思想是使用事件驱动机制（Event-Driven）替代轮询机制。

创建一个 epoll 实例（epoll_create），用作事件管理器。
使用 epoll_ctl 向内核注册需要监听的具体文件描述符及其事件类型（关注可读、可写或异常事件）。
调用 epoll_wait，等待事件发生。
发生事件的文件描述符被加入到一个内核维护的就绪列表，并从中直接返回。
这避免了不必要的遍历额外文件描述符的开销。
优点
事件驱动模型：文件描述符有变化时通过回调机制加入就绪列表，只需处理活跃文件描述符。
无大小限制：最大受限于系统的内存资源，而非固定限制。
高性能：避免了线性遍历，即使监视十万连接，只需处理少量已就绪的描述符。
缺点
仅支持 Linux 系统，不跨平台。
epoll 的两种触发模式
LT（Level Trigger，水平触发）： 默认模式，文件描述符只要处于就绪状态，就会不断返回。
ET（Edge Trigger，边缘触发）： 更高效，只在文件描述符状态从未就绪到就绪时触发（适用于非阻塞 I/O）

IO多路复用

LT与ET

LT:水平触发模式，只要内核缓冲区有数据就一直通知，只要socket处于可读状态就一直返回sockfd；是默认的工作模式，支持阻塞IO和非阻塞IO

ET：边沿触发模式，只有状态发生变化才通知并且这个状态只会通知一次，只有当socket由不可写到可写或由不可读到可读，才会返回sockfd：只支持非阻塞IO

为什么用epoll，其他多路复用方式以及区别

高并发模型

基于 Reactor 模型，实现 One Loop per Thread

Reactor模式通常用同步I/O模型实现

Proactor模式通常用异步I/O模型实现

1. 主线程往epoll内核事件表注册socket读就绪事件
2. 主线程调用epoll_wait等待socket上有数据可读
3. 当socket上有数据可读时，epoll_wait通知主线程，主线程将socket可读事件放入请求队列
4. 工作线程被唤醒，读数据处理请求，然后往epoll内核事件表注测socket写就绪事件
5. 主线程调用epoll_wait等待socket可写
6. 当socket可写，epoll_wait通知主线程，主线程将socket可写事件放入请求队列
7. 睡眠在请求队列的工作线程被唤醒，往socket上写入服务器处理客户请求的结果

动态缓冲区

实现自动增长缓冲区

1. 核心数据结构

1
2
3
4
5
6

class Buffer {
private:
    std::vector<char> buffer_;  // 主缓冲区（使用vector自动管理内存）
    size_t readerIndex_;         // 读指针（数据起始位置）
    size_t writerIndex_;         // 写指针（数据结束位置）
};

采用vector作为底层容器，自动处理内存分配/释放

读写指针分离设计，支持零拷贝操作

零拷贝是指计算机执行IO操作时，CPU不需要将数据从一个存储区域复制到另一个存储区域，从而可以减少上下文切换以及CPU的拷贝时间。它是一种I/O操作优化技术。

2. 自动增长机制

(1) 扩容触发条件

当writableBytes() < 待写入数据量时自动扩容

通过vector的resize实现：

1
2
3
4
5
6
7

void append(const char* data, size_t len) {
    if (writableBytes() < len) {
        makeSpace(len);  // 扩容操作
    }
    std::copy(data, data+len, beginWrite());
    writerIndex_ += len;
}

(2) 智能扩容策略

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

void makeSpace(size_t len) {
    if (writableBytes() + prependableBytes() < len) {
        // 需要真正扩容：vector.resize(writerIndex_ + len)
        buffer_.resize(writerIndex_ + len);
    } else {
        // 通过移动数据复用空间
        size_t readable = readableBytes();
        std::copy(begin()+readerIndex_, begin()+writerIndex_, begin());
        readerIndex_ = 0;
        writerIndex_ = readable;
    }
}

3. 高性能IO优化

(1) 双缓冲区读操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

ssize_t readFd(int fd, int* saveErrno) {
    char extrabuf[65536]; // 64KB栈缓冲区
    iovec vec[2];
    
    vec[0].iov_base = begin() + writerIndex_;
    vec[0].iov_len = writableBytes();
    vec[1].iov_base = extrabuf;
    vec[1].iov_len = sizeof(extrabuf);
    
    // 根据剩余空间决定使用1个还是2个缓冲区
    const int iovcnt = (writableBytes() < sizeof(extrabuf)) ? 2 : 1;
    ssize_t n = readv(fd, vec, iovcnt);
    
    // 处理读入的数据...
}

使用readv系统调用实现分散读

优先使用主缓冲区空间，不足时使用栈缓冲区过渡

避免频繁扩容带来的性能损耗

(2) 写操作优化

1
2
3

ssize_t writeFd(int fd, int* saveErrno) {
    return ::write(fd, peek(), readableBytes());
}

直接使用write系统调用

peek()返回有效数据起始指针，避免内存拷贝

4. 关键特性总结

1. 智能扩容：按需自动增长，兼顾内存使用效率

2. 零拷贝设计：读写指针分离，减少内存拷贝

3. 双缓冲策略：栈空间+主缓冲区组合优化IO性能

4. 线程安全：单次IO操作原子性保证

5. 内存高效：自动回收已读区域空间

典型工作流程：

1. 读取数据时优先使用主缓冲区空间

2. 空间不足时暂存到栈缓冲区

3. 触发自动扩容后合并数据

4. 写入数据时直接操作有效数据区域

连接管理

使用小根堆实现高效定时器，管理连接超时时间

1
2

using Entry = std::pair<Timestamp, Timer*>; // 以时间戳作为键值获取定时器
using TimerList = std::set<Entry>;          // 底层使用红黑树管理，自动按照时间戳进行排序

1
2

// 定时器管理红黑树插入此新定时器
timers_.insert(Entry(when, timer));

异步日志

设计异步日志模块，基于单例模式和阻塞队列

日志系统是多生产者，单消费者的任务场景

多生产者负责把日志写入缓冲区，单消费者负责把缓冲区数据写入文件

前端往后端写，后端往硬盘写

双缓冲技术 ，写满就交换，相当于将多条日志拼接成一个大buffer传送到后端然后写入文件，减少了线程开销

Mysql问题

说一说事物隔离级别

SQL标准的事务隔离级别包括：

读未提交，读提交，可重复读，串行化

事务的四大特性有哪些？

原子性，一致性，隔离性，持久性

Linux系统目录

为什么服务器要以root身份启动，不能以root身份运行

为什么要以 root 启动？

绑定低编号端口（如 80、443）。
配置共享内存、设备文件、调整资源等需要的高权限操作。

为什么不能以 root 运行？

潜在漏洞可能导致系统被完全攻破。
不符合最小权限原则。
服务隔离无法实现，其他服务可能受到影响。
意外操作可能导致灾难性的后果。
如何解决这个问题？

启动时以 root 完成特权操作，然后立刻降级为普通用户运行。
使用 setuid() 和 setgid() 等 Linux 用户管理接口实现特权降级。

字节面试准备

1. C++ 基础

(1) 面向对象的三个特性

C++ 是一种支持面向对象编程的语言，其面向对象编程的三个核心特性是：封装（Encapsulation）、继承（Inheritance）、多态（Polymorphism）。

• 封装
  封装是将数据（成员变量）和操作这些数据的代码（成员函数）绑定在一起，形成一个整体（类）。
  优点：

  • 限制对内部成员的访问，保护数据隐私（通过 public、protected、private 访问权限控制关键字）。
  • 提高代码的可维护性和复用性。

• 继承
  继承是一种用于实现代码复用和建立层次化关系的机制。子类可以继承父类的属性和行为。
  优点：

  • 重用父类代码。
  • 可以通过父类指针或引用操作多态对象。

• 多态
  多态是允许通过基类引用或指针访问派生类对象，并调用派生类的重写方法。基于动态绑定（Run-time Polymorphism）的多态主要通过虚函数实现。
  优点：

  • 提高代码的扩展性和灵活性，可以使用统一的接口处理不同类型的对象。

(2) 多态和虚函数的底层实现

• 多态的实现

  • 多态的核心是通过 虚函数表（Virtual Table）和虚函数表指针实现的。
  • 编译器会在类中生成一个指向虚函数表的指针，称为 vptr。
  • 虚函数表是一个数组，存储了该类的所有虚函数的函数指针。
  • 在运行时，通过 vptr 指向的虚函数表，根据实际的动态类型调用对应的方法。

• 虚函数的底层实现

  • 类中有虚函数时，类会生成一个虚函数表（存储虚函数指针）。
  • 每个对象的内存布局中会加入一个指向虚函数表的指针（vptr）。
  • 通过 vptr 和虚函数表在运行时找到并调用具体的函数。

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

class Base {
public:
    virtual void display() { std::cout << "Base" << std::endl; }
};

class Derived : public Base {
public:
    void display() override { std::cout << "Derived" << std::endl; }
};

int main() {
    Base* obj = new Derived();
    obj->display(); // 执行 Derived::display()
}

区别场景：带虚函数与不带虚函数

• 如果类中没有虚函数，那么对象内存只存储成员变量。
• 带虚函数的类，内存中会存储额外的虚函数表指针。
• 因此，带虚函数的对象的内存占用会比没有虚函数的对象多。

(3) 多继承的特殊情况（菱形继承问题）

场景：如何区分多继承中调用的同名成员和方法？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#include <iostream>
class A {
public:
    int x;
    void func() { std::cout << "A::func()" << std::endl; }
};

class B : public A {
public:
    void func() { std::cout << "B::func()" << std::endl; }
};

class C : public A {
public:
    void func() { std::cout << "C::func()" << std::endl; }
};

class D : public B, public C {};

int main() {
    D obj;
    // 调用 B::func 或 C::func？
    obj.B::func(); // 通过类名加作用域区分
    obj.C::func();
    return 0;
}

菱形继承问题的解决方式：

• 普通继承会导致 A 的成员在 B 和 C 中各有一份（两份副本）。
• 使用 虚继承 可以解决该问题，确保 A 的成员在多继承的子类中只有一份。

1
2
3
4

class A { public: int x; };
class B : virtual public A {};
class C : virtual public A {};
class D : public B, public C {};

D 类中只有一份 A::x。

3. 内存

(1) malloc 和 new 的区别

1. malloc：

   • 只分配内存，不调用构造函数。
   • 返回 void* 需要强制类型转换。
   • 需要 free 手动释放。

2. new：

   • 分配内存并自动调用构造函数初始化对象。
   • 返回目标类型的指针，无需强转。
   • 使用 delete 释放内存并调用析构函数。

(2) 只分配内存或只调用构造函数

1. 只分配内存（不调用构造函数）：

   • 可使用 operator new：

     1	void* ptr = ::operator new(sizeof(MyClass)); // 只分配内存

2. 只调用构造函数（对象已分配内存）：

   • 可通过 placement new：

     1	MyClass* obj = new(ptr) MyClass(args); // 在已有内存 `ptr` 上构造对象

operator new：用来分配原始内存，不涉及对象的构造。
operator delete：用来释放原始内存，不涉及对象的析构。
普通的 new 调用等价于：

1
2

MyClass* obj = static_cast<MyClass*>(::operator new(sizeof(MyClass))); // 分配内存
new (obj) MyClass(); // 构造对象

普通的 delete 调用等价于：

1
2

obj->~MyClass();             // 调用析构函数
::operator delete(obj);      // 释放内存

注意：new不能重载，只有operator new才能重载

(3) sizeof 结构体的对齐规则

C++ 中结构体内存对齐主要受到以下因素影响：

1. 每个成员变量的对齐方式由编译器决定（通常与成员类型的大小相关）。
2. 结构体的总大小必须是最大对齐成员的倍数。

示例：

1
2
3
4
5
6
7
8
9
10

struct S1 {
    char A;  // 1 字节
    char B;  // 1 字节
    int C;   // 4 字节
};
struct S2 {
    char A;  // 1 字节
    int C;   // 4 字节
    char B;  // 1 字节
};

• 对于 S1，内存布局为：A + B + padding + C（总大小 8）
• 对于 S2，内存布局为：A + padding + C + B + padding（总大小 12）

4. STL 和智能指针

(1) 智能指针概览

C++ 标准库提供了三种智能指针：

1. std::unique_ptr: 独占所有权，不可复制。
2. std::shared_ptr: 共享所有权，使用引用计数。
3. std::weak_ptr: 使用弱引用，依赖 shared_ptr，避免循环引用。

(2) std::shared_ptr 的实际应用

• 场景：共享资源的生命周期管理（如线程池中的任务对象）。
• 示例：

  1 2 3 4

  std::shared_ptr<int> p = std::make_shared<int>(10); { std::shared_ptr<int> q = p; // 引用计数+1 } // q 离开作用域，引用计数-1

使用智能指针（如 std::shared_ptr）的优点：

自动化的内存管理，避免内存泄漏和悬垂指针。简化代码逻辑，减少人工管理内存的复杂性。更容易与标准容器（如 std::vector）配合使用。不使用智能指针是可以的，

但代价是：

更容易引入 bug，例如内存泄漏、悬垂指针问题。
增加代码维护难度，并且可能需要大量的单元测试来覆盖所有的边界情况。
难以保证代码的健壮性，特别是在复杂的资源关系中。

RAII是什么

RAII（Resource Acquisition Is Initialization，资源获取即初始化）是一种资源管理的编程惯用法，是 C++ 中处理资源管理的重要设计理念。它通过将资源的生命周期与对象的生命周期绑定来确保资源得到正确的分配和释放，从而避免资源泄漏。

核心思想

1. 资源绑定到对象的生命周期：

   • 当一个对象在栈上或通过堆分配时，与该对象相关联的资源（例如内存、文件句柄、锁、网络连接等）也随之初始化。
   • 当该对象离开作用域（或者析构）时，资源会被自动释放。

2. 依靠析构函数来释放资源：

   • C++ 中，当一个对象生命周期结束时，其析构函数会被自动调用。因此，可以利用析构函数自动释放资源，而无需手动释放。
   • 通过 RAII，资源分配后不用担心异常、早退或其他复杂逻辑干扰正确释放。

RAII 的优点

1. 自动化资源管理：用户不需要手动释放资源，不用担心遗漏或错误。
2. 异常安全：即使代码中间发生异常，析构函数仍然会自动释放资源。
3. 代码简洁：减少了显式的资源释放代码，避免了冗余或错误。

应用场景

RAII 在内存分配、文件操作、线程锁、数据库连接等场景广泛应用。例如：

1. 智能指针：
   • std::unique_ptr：独占资源，适合动态内存管理。
   • std::shared_ptr：共享资源，适合多个对象共享动态内存。
2. 互斥锁：
   • std::lock_guard<std::mutex> 和 std::unique_lock。
3. 文件与流对象：
   • C++ 的 IO 流类如 std::ifstream 和 std::ofstream。
4. 其他自定义的资源管理类：
   • 如管理数据库连接、网络套接字、句柄等。

总结

RAII 的核心就是将资源的生命周期绑定到对象的生命周期，通过构造函数和析构函数确保资源的正确分配和释放。这种机制有效避免了手动管理资源时的各种问题（如资源泄漏、重复释放等），是 C++ 中非常重要的编程思想，尤其在异常安全和代码简洁性方面效果显著。

面试中，如果被问到 RAII，你可以直接引用 C++ 智能指针、文件流或锁管理类作为例子展开解释。进一步可以说明 RAII 提升了程序的安全性及简洁性，使 C++ 的资源管理更加工程化和易用化。

5. 操作系统

(1) 并发与并行的区别

• 并发（Concurrency）：多个任务在逻辑上同时进行，但实际上可能是按时间片交替执行。
• 并行（Parallelism）：多个任务在物理上真正同时运行（需要多核 CPU 支持）。

(2) 最大并发线程池设计

• 关键点：
  1. 使用任务队列管理任务。
  2. 通过信号量或条件变量限制线程并发数量。
  3. 动态创建、销毁线程降低资源消耗（即线程复用）。

6. 网络

(1) HTTPS 的通信过程

1. 客户端发送请求，包括支持的协议版本、加密套件等。
2. 服务器发送证书，客户端验证证书的合法性。
3. TLS 握手，双方协商对称密钥（通过非对称加密交换密钥）。
4. 加密通信，之后的所有数据使用对称密钥加密。

7. 项目挑战

Buffer 的思想

• 临时缓存用于解决数据处理速度的差异（如网络接收速度慢于处理速度）。
• **自动增长：**通过动态分配内存扩容实现，常用 指数增长（2 倍增长） 策略；也可以按照具体业务需要调整。

智能指针

unique_ptr

作用域指针，不能复制

栈分配指针，当死亡时，自动释放所管理的内存，无需显示调用delete

1
2
3

std::unique_ptr<int> p1 = std::make_unique<int>(10); // 管理动态分配的内存
// std::unique_ptr<int> p2 = p1; // 错误！unique_ptr不支持拷贝
std::unique_ptr<int> p2 = std::move(p1); // 通过 std::move 转移所有权

只能显示调用构造函数，因为其构造函数有explicit关键字，没有了构造函数的隐式转换

最好的调用还是使用make_unique会捕获异常，不会产生悬空指针问题

shared_ptr

追踪引用计数，如果引用为0，则释放内存

需要分配内存用于计数

1

shared_ptr<Entity> p = make_shared<Entity>();

作用主要包括：

1. 自动管理动态分配的对象，避免手动调用 delete。
2. 支持共享所有权，让多个 shared_ptr 可以安全地访问同一对象。
3. 借助引用计数机制，实现对象的生命周期控制，当最后一个 shared_ptr 销毁后，自行释放资源。

unique_ptr：独占所有权，不支持多个指针管理同一个对象；更轻量且不存在循环引用问题。

weak_ptr：用于观察 shared_ptr 管理的对象，不增加引用计数；主要用于辅助 shared_ptr，避免循环引用的问题。

std::weak_ptr

std::weak_ptr 是 C++11 引入的一种智能指针，和 std::shared_ptr 一起使用，用于避免 循环引用 问题，同时提供了一种对 std::shared_ptr 所管理对象的弱引用（non-owning reference）。它不改变所管理对象的引用计数。

• 循环引用问题：
  在使用 std::shared_ptr 时，如果两个对象互相以 shared_ptr 引用彼此，会导致内存泄漏，因为它们的引用计数无法递减到 0。
  • shared_ptr 通过引用计数管理对象的生命周期，当引用计数为 0 时，自动释放对象。
  • 如果存在循环引用，两个对象会始终持有对方，这样它们的引用计数永远不会减为 0，因此无法释放内存。
• 非拥有性的弱引用：
  有时候，一个对象只需要 “观察” 对另一个对象的引用，而无需控制它的生命周期。这时使用 std::weak_ptr 是更合理的选择。

std::weak_ptr 提供了一种临时、不影响生命周期的引用，从而解决了上述问题。

总结

std::weak_ptr 的主要使用场景包括：

1. 解决 std::shared_ptr 的循环引用问题。
2. 跨组件之间的非拥有性引用，例如缓存对象的管理。
3. 事件监听器或回调函数，避免悬垂指针的产生。
4. 在弱引用需求场景下提供更加灵活的资源管理，而不是一味增加强引用计数。

std::weak_ptr 的特点

1. 不控制对象的生命周期：
2. 检测对象是否已销毁：
   • 可以通过调用 weak_ptr 的 expired() 方法来检查被引用的对象是否已经销毁。
3. 使用 lock() 转换为 shared_ptr：
   • 如果需要安全地访问被引用的对象，可以调用 weak_ptr 的 lock() 方法，返回一个临时的 shared_ptr。如果对象已销毁，lock() 会返回一个空指针。

假设我们有两个类 A 和 B，它们通过 std::shared_ptr 互相引用。如果没有使用 weak_ptr，将会发生循环引用，导致内存泄漏。

示例代码（循环引用问题）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#include <iostream>
#include <memory>

class B; // 前向声明

class A {
public:
    std::shared_ptr<B> ptrB; // A 持有共享指针引用 B
    ~A() { std::cout << "A destroyed" << std::endl; }
};

class B {
public:
    std::shared_ptr<A> ptrA; // B 持有共享指针引用 A
    ~B() { std::cout << "B destroyed" << std::endl; }
};

int main() {
    // 创建循环引用
    auto a = std::make_shared<A>();
    auto b = std::make_shared<B>();
    a->ptrB = b; // A 持有 B
    b->ptrA = a; // B 持有 A

    // 离开 main() 作用域时，A 和 B 的引用计数不会减到 0，导致内存泄漏
    return 0;
}

运行结果：

1

# 没有输出，因为 `A` 和 `B` 无法正常析构，发生内存泄漏。

解决循环引用的正确做法：
将其中一个引用改为 std::weak_ptr，避免两个对象互相增加引用计数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class B; // 前向声明

class A {
public:
    std::weak_ptr<B> ptrB; // 弱引用 B
    ~A() { std::cout << "A destroyed" << std::endl; }
};

class B {
public:
    std::shared_ptr<A> ptrA; // 共享指针持有 A
    ~B() { std::cout << "B destroyed" << std::endl; }
};

int main() {
    auto a = std::make_shared<A>();
    auto b = std::make_shared<B>();
    a->ptrB = b; // A 弱引用 B
    b->ptrA = a; // B 持有 A

    // 离开作用域时，A 和 B 都将正确析构
    return 0;
}

运行结果：

1
2

B destroyed
A destroyed

通过将某一侧的引用改为 std::weak_ptr，打破了循环引用。

跨组件间的弱引用

如果某些对象之间并无强依赖关系，但仍需临时引用，则可以使用 std::weak_ptr。

示例 1：缓存管理
在缓存系统中，如果一个对象的存在依赖于被缓存的内容，则可以使用 std::weak_ptr：

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

#include <iostream>
#include <memory>
#include <unordered_map>
#include <string>

class CachedObject {
public:
    CachedObject(std::string name) : name(name) {
        std::cout << name << " created" << std::endl;
    }
    ~CachedObject() {
        std::cout << name << " destroyed" << std::endl;
    }
    void printName() { std::cout << "Object name: " << name << std::endl; }

private:
    std::string name;
};

int main() {
    std::unordered_map<std::string, std::weak_ptr<CachedObject>> cache;

    {
        auto obj1 = std::make_shared<CachedObject>("Object1");
        cache["key1"] = obj1;

        auto obj2 = std::make_shared<CachedObject>("Object2");
        cache["key2"] = obj2;

        // 使用缓存中的对象
        if (auto obj = cache["key1"].lock()) {
            obj->printName(); // 输出：Object name: Object1
        }
    } // obj1 和 obj2 均超出作用域，被释放

    // 尝试访问释放的对象
    if (cache["key1"].expired()) {
        std::cout << "Object1 no longer exists" << std::endl; // 输出
    }

    return 0;
}

运行结果：

1
2
3
4
5
6

Object1 created
Object2 created
Object name: Object1
Object2 destroyed
Object1 destroyed
Object1 no longer exists

事件回调（防止悬垂引用）

如果某类对象注册了一个事件监听器或回调函数，而监听器的生命周期可能比被观察的对象短，那么可以使用 std::weak_ptr 避免访问悬垂的指针。

例如：

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

#include <iostream>
#include <memory>
#include <functional>

class EventSource;

class Listener {
public:
    Listener(std::shared_ptr<EventSource> source) : source(source) {}
    void onEvent() {
        if (auto src = source.lock()) { // 检查 source 是否仍有效
            std::cout << "Event handled" << std::endl;
        } else {
            std::cout << "Source no longer exists" << std::endl;
        }
    }

private:
    std::weak_ptr<EventSource> source;
};

class EventSource : public std::enable_shared_from_this<EventSource> {
public:
    void fireEvent() {
        if (listener) listener(); // 调用回调
    }

    void setListener(std::function<void()> callback) {
        listener = callback;
    }

private:
    std::function<void()> listener;
};

int main() {
    std::shared_ptr<EventSource> source = std::make_shared<EventSource>();
    {
        auto listener = std::make_shared<Listener>(source);
        source->setListener([listener]() { listener->onEvent(); });

        source->fireEvent(); // 输出：Event handled
    }

    // Listener 已销毁，无悬垂引用
    source->fireEvent(); // 不输出，Listener 已解除绑定

    return 0;
}