【面经专栏】成建制面经大杂烩【C++面经】【操作系统面经】【计算机网络面经】【数据库MySQL/Redis面经】

2021年秋季招聘接近尾声，也是时候整理一些自己的面试问题总结了。在7月中旬到9月末开始，陆续整理了以下C++后端岗位的面试问题。

关于来源：
标注【牛客】的部分题目来自牛客上的面试题目，安利一下牛客的秋招集训营，很全面很高效
标注【拓跋阿秀】的问题来自同名公众号，这是阿秀大佬整理的问题
标注【Guide】的问题来自javaguide，这也是大佬整理的问题

注意：本博客仅涉及面试问题的题目，对于题目的具体解答请去上面提到的源头查看，也可自行百度解决

---

【牛客】

C++

语言基础

1.1.1 C++语言的特点

1.1.2 C语言和C++的区别

1.1.3 C++中struct和class的区别

1.1.4 include头文件的顺序，""和<>的区别

1.1.5 C++和C结构体的区别

1.1.6 导入C函数的关键字，C++的编译和C有什么不同

1.1.7 C++从代码到可执行二进制文件的过程（预处理、编译、汇编、链接）

1.1.8 static关键字

1.1.9 数组和指针的区别（char数组初始化、指针初始化）

1.1.10 函数指针

1.1.11 静态变量什么时候初始化

1.1.12 nullptr可以调用成员函数么

1.1.13 野指针

1.1.14 静态局部变量 全局变量 局部变量

1.1.15 内联函数和宏的区别（使用inline的注意事项、使用inline的条件）

1.1.16 运算符i++和++i的区别

1.1.17 new和malloc的区别及其实现原理

1.1.18 const和define的区别

1.1.19 C++中函数指针和指针函数的区别

1.1.20/1.1.24 底层const和顶层const

1.1.21 使用指针的注意事项

1.1.22 内联函数和函数的区别

1.1.23 C++传值方式

内存

1.2.1 堆和栈的区别

1.2.2 C++内存管理（内存分区、内存错误、内存泄漏、检测内存泄漏的方法）

1.2.3 malloc和局部变量分配在堆还是栈上

1.2.4 虚拟地址空间分区，各自作用，程序启动的过程（main函数执行前的工作），判断数据在栈还是堆上

1.2.5 初始化为0的全局变量存放在bss段还是data段

1.2.6 什么是内存泄漏，怎么检测内存泄漏

1.2.10 C++内存对齐（什么是、为什么、怎么） ，#pragma pack

类和对象

1.3.1 什么是面向对象

1.3.2 面向对象的三大特征

1.3.3 C++重载和重写的区别

1.3.4 重载和重写是如何实现的

1.3.5 C如何实现C++中的重载

1.3.6 构造函数有几种（默认构造、初始化构造、拷贝构造、移动构造）

1.3.7 只定义析构函数，会自动生成哪些构造函数；拷贝构造为什么必须传引用

1.3.8 一个类会默认生成哪些函数

1.3.9 C++类对象的初始化顺序（构造函数的初始化过程），有多继承情况下

1.3.10 向下转型，向上转型

1.3.11 深拷贝，浅拷贝（代码实现）

1.3.12 协变

1.3.13 为什么要虚析构，不能虚构造

1.3.14 模板类在什么时候实现的

1.3.15 类继承时，派生类对不同关键字修饰的基类方法的访问权限（public、protected、private）

1.3.16 移动构造函数，移动赋值运算符（代码）

1.3.17 C++类内可以定义引用数据成员么

1.3.19 什么是常函数，有什么用

1.3.20 虚继承

1.3.21 虚函数和纯虚函数，实现原理

1.3.22 纯虚函数能实例化么，为什么

1.3.23 虚函数与纯虚函数的区别

1.3.24 菱形继承问题

1.3.25 构造函数中能不能调用虚函数

1.3.26 拷贝构造函数的参数是什么传递方式，换别的行不行

1.3.27 类方法和数据的访问权限

1.3.28 抽象类怎样理解

1.3.29 除了虚函数，还有什么方式能实现多态

1.3.30 虚析构函数的作用

1.3.31 虚基类，是否可以实例化

1.3.32 拷贝赋值和移动赋值

1.3.33 仿函数是什么，有什么用

1.3.34 C++中什么函数不能声明为虚函数

1.3.35 C++中类模板和模板类的区别

1.3.36 虚函数的表中的内容是什么时候写进去的

STL

1.4.1 STL的基本组成部分

1.4.2 STL中的常见容器（vector、deque、list、set、map、stack、queue、priority_queue）及其实现原理

1.4.3 STL中map、hashtable、deque和list的实现原理

1.4.4 STL的空间配置器allocator（内存分配的三种形式，两级配置器）

1.4.5 STL容器查找、插入、删除的时间复杂度

1.4.6 迭代器的失效情况

1.4.7 迭代器的作用，有了指针为什么还要用迭代器

1.4.8 迭代器是怎么删除元素的（迭代器分类）

1.4.9 resize和reverse的区别

1.4.10 STL容器动态链接可能产生的问题

1.4.11 map和unordered_map的区别，底层实现

1.4.12 vector和list的区别，分别适用于什么场景

1.4.13 vector的实现原理

1.4.14 map的实现原理

1.4.15 vector和list删除元素（末尾/中间），迭代器怎么变化

1.4.16 map和set的区别，底层实现

1.4.17 push_back和emplace_back的区别

新特性

1.5.1 C++11的新特性

1.5.2 智能指针和指针的区别

1.5.3 智能指针有哪些，分别解决了什么问题

1.5.4 C++右值引用与转移语义

1.5.5 unique_ptr、shared_ptr的实现原理

1.5.6 weak_ptr能不能知道对象计数为0

1.5.7 weak_ptr怎样解决shared_ptr的循环引用问题

1.5.8 shared_ptr怎么知道跟他共享对象的指针释放

1.5.9 shared_ptr的线程安全性原理

1.5.10 智能指针有没有内存泄漏的情况

1.5.11 C++11中的四种类型转换const_cast 、static_cast、 reinterpreter_cast、dynamic_cast

1.5.12 auto 与const结合使用

1.5.13 可变参数模板新特

1.5.14 Lambda新特性，匿名函数

操作系统

2.1 Linux查看进程运行状态的命令、查看内存使用情况的命令、tar解压文件的参数

2.2 修改文件权限

2.3 常用的Linux命令

2.4 怎样以root权限运行某个程序

2.5 软链接和硬链接的的区别

2.6 静态库和动态库

2.7 GDB调试命令，条件断点，多进程调试

2.8 大端字节序和小端字节序

2.9/2.30 进程调度算法

2.10 操作系统如何申请、管理内存

2.11 Linux系统态与用户态（进入内核态的三种方式）

2.12 LRU算法及其实现

2.13 一个线程占多大内存

2.14 什么是页表，为什么要有

2.15 缺页中断

2.16/2.21 虚拟内存/进程空间分布，什么时候会由用户态进入内核态

2.17 虚拟内存和物理内存，为什么要用虚拟内存，使用虚拟内存的好处和坏处

2.18 虚拟地址到物理地址是怎么映射的

2.19 堆栈溢出（内存溢出）

2.20 malloc的实现原理

2.22 32位系统能访问4GB以上的内存么

2.23 并发和并行

2.24 进程、线程和协程

2.25 Linux的fork

2.26 孤儿进程、僵尸进程，怎样解决僵尸进程

2.27 守护进程，如何实现

2.28 进程通信方式

2.29 进程同步的方式

2.31 进程状态

2.32 进程通信中管道的实现原理

2.33 mmap的原理和使用场景

2.34 互斥量能不能在进程中使用

2.35 协程是轻量级线程，轻量级表现在哪里

2.36 常见信号

2.37 线程通信方式

2.38 线程同步方式

2.39 死锁，产生条件，如何解决

2.40 有了进程，为什么还要有线程

2.41 单核机器上写多线程程序，是否要加锁

2.42 多线程和多进程的不同

2.43 互斥锁，读写锁

2.44 信号量

2.45 进程、线程中断切换的过程（上下文切换）

2.46 互斥锁和自旋锁的使用场景

2.47 线程状态转换

2.48 多线程和单线程有什么区别

2.49 sleep和wait的区别

2.50 线程池的设计思路

2.51 进程和线程比为什么慢

2.52 Linux零拷贝

2.53 epoll和select的区别，epoll的高效性

2.54 多路IO复用技术，及其区别

2.55 select和epoll的使用场景和区别，epoll水平触发与边缘触发

2.56 Reactor和Proactor模式

2.57 同步和异步，阻塞和非阻塞

2.58 BIO和NIO

2.59 同步和异步的区别

2.60 socket网络编程中client和server用到了哪些函数

计算机网络

3.1 静态路由和动态路由

3.2 常见路由协议

3.3 域名解析过程，本机如何干预

3.4 DNS查询服务器的流程，DNS劫持

3.5 网关作用，同一网段主机怎样通信（ARP协议工作原理）

3.6 CSRF攻击

3.7 MAC地址和IP地址

3.8/3.11 TCP三次握手和四次挥手

3.9 TCP为什么不能两次握手

3.10/3.25 TCP和UDP的区别，头部结构

3.12 TCP连接和关闭的状态转移

3.13 TCP慢启动

3.14 TCP怎样保证有序

3.15 TCP的常见拥塞控制算法

3.16 TCP超时重传

3.17 TCP怎样保证可靠性

3.18 TCP滑动窗口和重传机制

3.19 滑动窗口过小

3.20 三次握手中每次握手的信息没有被对方收到会怎样

3.21 为什么要有TIME_WAIT

3.22 什么是MSL，为什么客户端要等待2MSL才能完全关闭

3.23 什么是SYN flood，怎样防止

3.24 TCP粘包和拆包

3.26 从系统层面上，UDP怎样保证尽量可靠

3.27 TCP的keepalive和HTTP的keepalive

3.28 TCP的延迟ACK和累积应答

3.29 TCP怎样加速大文件的擦户数

3.30 服务器怎样判断客户端断开了连接

3.31 端到端，点到点的区别

3.32 浏览器从输入URL到展现页面的全过程

3.33 HTTP和HTTPS的区别

3.34 HTTP中的referer头的作用

3.35 HTTP的请求方法

3.36 HTTP1.0/1.1/2.0的区别

3.37 HTTP常见响应状态码及其含义（200 301 302 400 403 404 500 503）

3.38 GET请求和POST请求的区别

3.39 Cookie和Session的关系和区别

3.40 HTTPS的加密与认证过程（浏览器验证证书的过程）

数据库

4.1.1 数据库分页

4.1.2 MySQL聚合函数

4.1.3 表与表之间的关联 join（inner join outer join）

4.1.4/4.1.5 外连接

4.1.6 SQL中将行转为列

4.1.7 SQL注入

4.1.8 将一张表的部分数据更新到另一张表

4.1.9 where和having的区别

4.2.1 索引

4.2.2 索引有几种

4.2.3 怎样创建保存MySQL索引

4.2.4 判断要不要加索引

4.2.5 只要创建索引，就一定会走索引么

4.2.6 怎样判断索引是否生效

4.2.7/4.2.10 怎样合理创建索引/所有字段都适合创建索引么

4.2.8 索引越多越好么

4.2.9 避免索引失效

4.2.11 索引的实现原理

4.2.12 索引重构

4.2.13 MySQL索引为什么用B+树

4.2.14/4.2.17 联合索引的存储结构

4.2.15 Hash索引和B树索引的区别

4.2.16 聚簇索引和非聚簇索引的区别

4.2.18 select in怎样使用索引

4.2.19 模糊查询中怎样使用索引

4.3.1/4.3.2 事务，事务分类

4.3.3 ACID特性的实现原理

4.3.4 MySQL的事务隔离级别

4.3.5 事务隔离级别怎样实现

4.3.6 事务可以嵌套么

4.3.7 怎样实现可重复读 MVCC见4.3.3

4.3.8 怎样解决幻读

4.3.9 MySQL怎样实现回滚

4.4.1 数据库的锁（共享锁/排他锁 意向锁 行锁算法 死锁）

4.4.2 间隙锁

4.4.3 InnoDB中行级锁怎样实现

4.4.4 数据库死锁

4.4.5 死锁的解决办法

4.5.1 数据库优化

4.5.2 怎样优化MySQL的查询

4.5.3 怎样优化数据插入

4.5.4 表中含有几千万条数据怎么办

4.5.5 怎样优化慢查询

4.5.6/4.5.7 explain，关注什么

4.6.1 数据库三大范式

4.6.2 MySQL引擎

4.6.3 redolog undolog binlog

4.6.4 MVCC

4.6.5 MySQL主从同步怎样实现

设计模式

5.1 单例设计模式（懒汉、饿汉）

5.2 懒汉模式与饿汉模式怎样保证线程安全

5.3 工厂设计模式

【拓跋阿秀】

C++

1. main执行之前和之后执行的代码是什么
2. 结构体内存对齐
3. 指针和引用的区别
4. 堆和栈的区别
5. 指针类型（指针数组、数组指针、函数声明。函数指针）
6. 基类的虚函数表存在内存的哪里，虚表指针vptr的初始化时间
7. new delete和malloc free的区别
8. new delete怎样实现
10. 宏定义#define和函数的区别
11. 宏定义#define和typedef的区别
12. 变量声明和定义的区别
13. 成员初始化列表使用的时机
14. strlen和sizeof的区别
15. 顶层const（常量指针）和底层const（指针常量）的区别
16. 有数组a，a和&a的区别
17. 数组名和指向数组首元素的指针的区别
18. 野指针 悬空指针
19. vector迭代器失效的情况
20. C和C++的区别
21. C++与Java的区别
22. C++中struct和class的区别，C和C++的struct区别
23. 宏定义#define和const的区别
24. C++中const和static的作用，静态成员函数不能声明为const、virtual、volatile的原因
25. 顶层const和底层const
26. 类的对象内存储了什么
27. final override
28. 拷贝初始化和直接初始化
29. 初始化和赋值的区别
30. extern "C"的用法
31. 模板函数和模板类的特例化（模板全特化、模板偏特化）
32. C和C++的类型安全
33. 为什么析构函数一般写成虚函数
34. 构造函数能否声明为虚函数或者纯虚函数
35. C++重载、重写、隐藏
36. C++多态怎样实现（虚函数表与虚表指针的工作流程）
37. C++有几种构造函数
38. 浅拷贝和深拷贝（代码）
39. 宏定义#define和内联inline的区别
40. 构造函数、析构函数、虚函数能否声明为内联函数
41. auto decltype decltype(auto)的用法
42. public private protected作为访问权限和继承权限时的规则
43. 用代码判断大小端存储
44. volatile、mutable、explicit的用法
45. 使用拷贝构造函数的时机
46. C++中有几种类型的new
47. C++中NULL和nullptr的区别
48. C++内存分区（栈、堆、bss、data、text段的分布）
49. C++处理异常的方法
50. static的作用和用法、
51. static变量什么时候初始化
52. const（修饰全局变量、成员变量、函数、对象）
53. 顶层const和底层const
54. 形参和实参的区别
55. 值传递、指针传递、引用传递的区别和效率
56. 类的继承
57. 什么是内存池，怎样实现（allocate deallocate）
60. C++模板的底层实现（两次编译）
61. new和malloc的区别
62. allocator有什么用
63. new new[] delete delete[]的实现原理，delete怎么知道释放内存的大小的
64. malloc申请的存储空间能用delete释放么
65. malloc与free的实现原理（brk mmap）
66. malloc realloc calloc的区别
67. 类成员的初始化方式（赋值初始化 列表初始化） 派生类构造函数的执行顺序 为什么用初始化列表更快
68. 使用成员初始化列表的情况
69. 什么是内存泄漏，怎样检测和避免
70. 对象复用 零拷贝
71. trivial destructor
72. 面向对象三大特性（封装 继承 多态）
73. C++中类的数据成员和成员函数在内存中的分布情况
74. 为什么成员初始化列表比函数体赋值更快
76. 析构函数的作用
77. 构造函数和析构函数可以调用虚函数么（详细）
78. 派生类的构造函数、析构函数的执行顺序
79. 虚析构函数的作用
80. 构造函数、析构函数可否抛出异常
82. 什么时候调用析构函数
83. 构造函数和析构函数可以调用虚函数么
84. 智能指针原理 shared_ptr unique_ptr weak_ptr
85. 构造函数的几种关键字 =default =delete =0
86. 四种强制转换 reinterpret_cast const_cast
87. C++函数调用的压栈过程（函数返回地址、函数参数列表【从右至左】、函数中的变量）
88. 移动构造函数
89. C++中将临时变量作为返回值时的处理过程
90. this指针
91. this指针
92. 构造函数、拷贝构造函数、赋值运算符的区别（代码实现）
93. 拷贝构造函数、赋值运算符重载的区别
94. 智能指针的作用（智能指针头文件、多线程与shared_ptr、智能指针初始化）
95. auto_ptr的作用
96. 智能指针的循环引用（代码）
97. 虚继承（内存分布）
98. 怎样获得结构成员相对于结构开头的字节偏移量
99. 静态类型 动态类型 静态绑定 动态绑定
100. C++11新特性
101. 引用能否实现动态绑定
102. 全部变量 局部变量的区别
103. 指针加减运算
104. 怎样判断两个浮点数是否相等
106. C++中的参数使用指针传递和引用传递的区别
107. 类怎样实现只能静态分配 和只能动态分配
108. 将某个类作为基类，只声明不定义行不行
110. 抽象基类为什么不能创建对象
111. 指针 向上转换 向下转换
112. 组合与继承相比有什么优缺点
113. 函数指针
114. 内存泄漏的后果，如何监测，解决方法
115. RAII
116. 手写实现智能指针（并无代码）
117. 内存对齐的原因 #pragma pack(n)
118. 结构体变量比较是否相等
120. 宏定义#define和const、typedef、inline的区别
121. printf函数的实现原理
122. lambda函数
123. 将字符串打印到屏幕上的全过程
124. 模板类和模板函数的区别
125. 为什么模板类一般放在一个.h文件中
126. 类成员的访问权限 继承权限
127. cout和printf的区别
128. 重载运算符（成员运算符、非成员运算符）
129. 程序中存在函数重载时，函数的匹配原则和顺序
131. 全局变量&static静态变量 static函数&普通函数
132. 静态成员&普通成员
133. ifdef endif
134. 隐式转换，如何避免隐式转换
136. 多继承的优缺点
137. 迭代器的it++和++it哪个好
138. C++怎样处理多个异常
139. 模板定义和实现可不可以写在一个文件中
140. 在成员函数/析构函数中调用delete this会出现什么问题
141. 怎样在不使用额外空间的情况下，交换两个数
142. strcpy和mencpy的区别
143. int main(int argc, char* argv[])
144. volatile关键字的作用，使用场景
145. 空类会默认添加哪些函数
146. C++标准库是什么
147. const char*与string互转
148. 为什么拷贝构造函数必须传引用而不能传值
149. 空类的大小是多少
150. 指针传参和引用传参的适用场合
151. 静态函数能定义为虚函数么
152. this指针调用成员变量时，堆栈有什么变化
153. 静态绑定和动态绑定
154. 设计一个类计算子类的个数
155. 怎么快速定位错误出现的地方
156. 虚函数的代价
157. 类对象的大小受什么因素影响
158. 移动构造函数
159. 什么时候合成默认构造函数
160. 什么时候合成拷贝构造函数，拷贝构造的调用时机
162. 构造函数的执行顺序
164. 哪些函数不能是虚函数
165. strcpy、sprintf、memcpy的区别
167. 数组和指针的区别
168. 怎样阻止类被实例化
169. 怎样禁止程序自动生成拷贝构造函数，禁止调用拷贝构造函数
170. debug和release的区别
171. main函数的返回值
172. 写一个比较大小的模板函数
173. 智能指针出现循环引用怎么办（weak_ptr）
174. strcpy和strncpy函数的区别，哪个函数更安全
175. static_cast比C中的转换强在哪
176. 成员函数中使用memset(this, 0, sizeof(*this) )会怎样
177. 回调函数是什么，作用
178. 一致性哈希
179. 纯虚函数与虚函数的区别
180. C++从代码到可执行程序的过程（预处理、编译、汇编、链接）
181. 为什么友元函数必须在类内声明
182. 用C实现C++的继承
183. 动态编译与静态编译
184. ELF文件的分类 共享库解决了静态库的什么问题
185. 几种典型的锁（读写锁、互斥锁、条件变量、自旋锁）
186. C++左值引用和右值引用
187. STL中hashtable的实现，开链法
188. STL中的traits技法
189. STL中的两级空间配置器（allocator）内存池与空闲链表
190. vector与list的区别
191. vector删除元素后，迭代器的变化 vector扩容与空间释放
192. 顺序容器、关联容器删除一个元素
193. STL迭代器如何实现
194. map、set怎么实现的，红黑树怎样同时实现这两种容器
195. 如何在共享内存上使用STL标准库
196. map插入数据的方式
197. unordered_map和map的区别，unordered_map怎样解决冲突，扩容
198. vector与map越界访问，vector删除元素会释放空间么
199. map中[]与find()的区别
200. list与deque的区别
201. allocator和deallocator 一级配置器与二级配置器
202. STL中hash_map自动扩容发生了什么
203. 常见容器性质总结
204. vector的增加和删除
205. STL每种容器对应的迭代器
206. vector的实现
207. slist的实现
208. list的实现
209. deque的实现
210. stack和queue的实现
211. heap的实现
212. priority_queue的实现
213. set的实现
214. map的实现
215. set和map的区别（红黑树概念）
216. unordered_map和map的区别和应用场景
217. 哈希表中解决冲突有什么方法（线性探测、开链法、再哈希）

操作系统

1. 进程、线程和协程的区别和联系
2. 进程与线程的比较
3. 一个进程可以创建多少个线程
4. 中断与异常有什么区别
5. 进程线程模型（多进程/多线程）
6. 进程调度算法
7. Linux进程通信方式
8. Linux同步机制
9. 快表对系统系统地址转换的影响、
10. 内存交换和覆盖的差别
11. 动态内存分区分配算法
12. 虚拟技术
13. 进程状态切换
14. 一个程序从开始运行到结束的完整过程（预处理、编译、汇编、链接）
15. 逻辑地址转换为物理地址的过程
16. 进程同步的四种方法
17. 操作系统如何管理内存
18. 进程通信方法、线程通信方法（Linux、Windows）
19. 进程通信方法（对问18相关内容的详细解释）
20. 虚拟内存的目的
21. 内存有什么作用
22. 哲学家进餐问题（有代码）
23. 读写问题（有代码）
24. 读写锁、互斥锁、条件变量、自旋锁
25. 逻辑地址和物理地址，相对地址和绝对地址
26. 回收线程的方法（pthread_join、pthread_exit、pthread_detach）
27. 内存覆盖的特点
28. 内存交换的特点
29. 内存交换的时机
30. 终端退出，终端运行的进程会怎样
31. 怎样后台运行进程（不太熟）
32. 什么是快表
33. 使用快表与否的区别、
35. 守护进程、僵尸进程和孤儿进程
36. 如何避免僵尸进程
37. 局部性原理
38. 父进程、子进程、进程组、作业、会话
39. 进程终止的几种方式
40. 异常和中断的区别
41. windows和linux内存分布
42. 由C/C++编译的程序占用内存分为几部分
43. Linux/Windows平台下栈空间的大小
44. 程序从堆中分配内存，虚拟内存上是怎么操作的
45. 常见的磁盘调度算法
46. 交换空间和虚拟内存的关系
47. 什么是抖动
48. 从堆和栈上建立对象哪个快
49. 常见的内存分配方式（静态存储区、栈、堆）
50. 常见的内存分配错误
51. 内存交换中，换出的进程存在哪里
52. 内存交换时优先换出哪些进程
53. ASCII、Unicode、UTF-8编码的区别
54. 如何实现原子操作
55. 内存交换有什么需要注意的点
56. 系统并发和并行
57. 页面置换算法总结
58. 什么是共享
59. 死锁问题总结（检测死锁、预防死锁）
60. 内部碎片与外部碎片
61. 如何消除碎片文件

计算机网络

1. OSI七层模型及各自功能
2. 输入URL后怎样与服务器通信
3. DNS是什么
4. DNS工作（查询）原理
5. 为什么域名解析用UDP协议
6. 为什么区域传送用TCP
7. HTTP长连接和短连接的区别
8. TCP粘包/拆包的原因和解决方案
9. 服务器缓存的意义，如何实现
10. HTTP请求方法（HTTP1.0 HTTP1.1）
11. GET和POST的区别，为什么不能用GET进行增删改
12. 一个TCP连接可以对应多少HTTP请求
13. 一个TCP连接可以发送多个HTTP请求么
14. 浏览器对同一Host最多建立多少TCP连接
15. 浏览器上输入URL到显示主页的过程
17. DNS解析过程
18. DNS负载均衡
19. HTTPS和HTTP的区别
20. 什么是SSL/TLS
21. SSL怎么保证工作安全
22. 怎样保证公钥不被篡改
23. HTTP请求和响应报文有什么字段
24. cookies是什么
25. cookie用途
26. Session介绍，session的使用过程
27. Session工作原理
28. cookie和session的对比
29. SQL注入攻击
30. OSI七层模型与五层模型与各自功能
31. RARP工作原理
32. 端口有效范围
33. 为什么需要把TCP/IP协议栈分成5层或7层
34. DNS查询方式（递归、迭代）
35. HTTP中缓存的私有和共有字段
36. GET方法的参数写法是固定的么
37. GET方法长度限制
38. POST方法比GET方法安全么
39. POST方法产生两个数据包
40. Session是什么（同问26）
42. Session与cookie的适用场景
43. Session和cookie的区别（补充问28）
44. DDoS攻击，怎样预防
45. MTU和MSS（结合问8）
46. HTTP缓存过期机制
47. TCP头部信息
48. TCP连接状态
49. 七层/五层网络模型的对应协议
50. TCP是什么
51. TCP头部报文字段
52. OSI七层模型的对应功能
53. 应用层常见协议（HTTP、HTTPS、Telnet、FTP、SMTP、DNS）
54. HTTP长连接与短连接
55. 三次握手的过程
56. 为什么需要三次握手，两次握手会怎样
57. 什么是半连接队列，SYN-ACK重传次数
58. ISN是固定的么
59. 三次握手中可以携带数据么
60. SYN攻击是什么
61. 四次挥手过程
62. 为什么要四次挥手
64. 为什么要有2MSL等待状态
66. TCP粘包问题和解决方案
67. ISO七层模型中表示层和会话层的功能
68. 三次握手四次挥手的状态变迁图
69. 对称密钥加密的优缺点
70. 非对称加密的优缺点
71. HTTPS是什么
72. HTTP的缺点
73. HTTPS采用的加密方式（SSL混合加密过程）
74. 为什么有时候刷新页面不需要重新建立SSL连接
75. SSL认证中的证书
76. HTTP怎样禁用缓存
77. GET与POST传递数据的最大长度是多少
78. 网络层常见协议
79. TCP四大拥塞控制算法（详细）
80. 为什么快速重传是3次ACK
81. FIN_WAIT_2、CLOSE_WAIT和TIME_WAIT状态
82. 流量控制原理，发送窗与接收窗
83. 建立TCP服务器的各个系统调用过程
84. TCP协议怎样保证可靠传输
85. TCP协议怎样保证可靠传输，使用校验和能够确保数据不会出错么
86. TCP和UDP的区别
87. UDP的特点
88. 使用TCP的应用层协议
89. 使用UDP的应用层协议
90. 数据链路层常见协议
91. ping命令是哪一层协议
92. 编程实现UDP的时候，一次发送多少字节号（局域网和Internet）
93. TCP利用滑动窗口实现流量控制的机制
94. RTO、RTT和超时重传
95. XSS攻击
96. CSRF攻击，怎样防范CSRF攻击
97. 文件上传漏洞，怎样防止文件上传漏洞
99. 怎样区分流量控制和拥塞控制
100. 常见HTTP状态码

数据库

MySQL

补1-关系型/非关系型数据库的区别

补2-什么是非关系型数据库

1. 为什么使用索引
2. InnoDB为什么使用自增id作为主键
3. MyISAM和InnoDB的B+树有什么区别
4. MySQL怎样执行一条命令
5. MySQL内部构造（存储引擎层 服务层）
6. drop delete truncate的异同
7. MySQL优化
8. 数据库隔离级别（脏读、不可重复读、幻读）
10. B+树优于B树的原因
11. 视图和游标
12. MySQL事务回滚机制
13. InnoDB与MyISAM的区别
14. 数据库并发带来的问题（脏读、丢失修改、不可重复读、幻读）
15. 悲观锁和乐观锁，乐观锁的实现
16. MySQL索引的两种数据结构
17. 数据库分库与分表，两种分表策略
18. 不可重复读与幻读的区别
19. MySQl的四种索引类型
20. 视图的作用，可以修改么
21. B+树相较于B树的优点
22. 怎样优化千万级的数据库
23. 什么情况下使用索引
24. 覆盖索引是什么
25. 超键、候选键、主键、外键
26. 数据库三大范式
27. 总结三大范式
28. InnoDB和MyISAM的区别、适用场景
29. 事务的四大特性（ACID）
30. NOW()和CURRENT_DATE()的区别
33. 聚簇索引、非聚簇索引的区别
34. 创建索引需要注意什么
35. MySQL中char和varchar的区别
36. 使用索引需要注意什么（索引失效的情况）
37. 索引分类，各自特点
38. 为什么不对表的每一列创建索引
39. 索引如何提高查询速度
40. 使用索引需要注意什么
41. 增加B+树的路数可以降低树的高速，那么无限增加树的路数可以有最优的查找效率么
42. 数据库表锁和行锁
43. SQL中内连接、自连接、外连接（左右全）、交叉连接的区别
44. 数据库优化的手段
45. 怎样拆分数据表
47. 为什么数据库索引要使用B+树，而不用hash表和B树
48. 为什么hash表查询时间O(1)优于B+树的查询时间O(logn)，还要使用B+树存储索引呢
49. 关系型数据库的四大特性得不到保障会怎样
50. 数据库怎样保证一致性
51. 数据库怎样保证原子性
52. 数据库怎样保证持久性

Redis

1. Redis是什么
2. Redis的五种数据结构（SDS、hash、list、zskiplist、ziplist）
3. Redis数据结构（string、hash、list、set、sorted_set）
4. 有了MySQL为什么还要用Redis（高性能、高并发）
5. C++中的map也是缓存型数据结构，为什么不同map，而用Redis做缓存
6. Redis的优点
7. Memcached和Redis的区别
8. Redis比Memcached的优势是什么
9. 缓存中的热点数据和冷数据是什么
10. Redis为什么是单线程，不用多线程
11. Redis的单线程为什么会这么快
12. Redis的线程模型（IO复用机制）
13. Redis设置过期时间的两种方案（定期删除、惰性删除）
14. Redis内存淘汰策略
15. Redis怎样处理大量请求
16. 缓存雪崩、缓存穿透、缓存预热、缓存更新、缓存击穿、缓存降级
17. 假设MySQL中有1000万数据，采用Redis作为缓存，取其中的10万，怎样保证Redis中的都是热点数据
18. Redis持久化机制（RDB、AOF）
19. AOF重写，子进程重写过程
20. Redis集群
21. 怎样解决Redis的并发竞争key问题
22. 怎样保证缓存与数据库双写时的数据一致性
23. 数据为什么会出现不一致
24. 常见的数据优化方案

【Guide】

操作系统

1.1 什么是操作系统

1.2 什么是系统调用

2.1 进程和线程的区别

2.2 进程的状态（运行态、就绪态、阻塞态）

2.3 进程通信方式

2.4 线程同步的方式

2.5 进程调度算法

3.1 内存管理是做什么的

3.2 内存管理机制（页式、段式、段页式）

3.3 快表和多级页表

3.4 分页机制和分段机制的异同

3.5 逻辑地址（虚拟地址）和物理地址

3.6 CPU寻址，为什么需要虚拟地址空间

4.1 什么是虚拟内存

4.2 局部性原理

4.3 虚拟存储器

4.4 虚拟内存的技术实现（请求分页、请求分段、请求段页式）

4.5 页面置换算法

计算机网络

3.1.1 OSI七层、TCP/IP四层、五层网络的结构与功能，都有什么协议

3.1.2 TCP三次握手、四次挥手

3.1.2 TCP、UDP的区别

3.1.3 TCP怎样保证可靠传输

3.1.4 ARQ协议

3.1.5 滑动窗口和流量控制

3.1.6 拥塞控制

3.1.7 打开一个网页的过程（输入URL地址到显示主页）

3.1.8 状态码

3.1.9 HTTP协议与其他协议的关系

3.1.10 HTTP长连接，短连接

3.1.11 HTTP不保存状态，怎样保存用户状态

3.1.12 cookie的作用是什么，与session的区别

3.1.13 HTTP1.0和1.1的区别

3.1.12 URI和URL的区别

3.1.13 HTTP和HTTPS的区别

数据库

MySQL

4.1.3 MyISAM和InnoDB的区别

4.1.5 MyISAM和InnoDB的B+树有什么区别

4.1.6 查询缓存的使用

4.1.7 事务

4.1.8 事务的四大特性（ACID）

4.1.9 并发事务带来哪些问题（脏读、丢失修改、不可重复读、幻读）

4.1.10 事务隔离级别（读未提交、读提交、可重复读、串行化）

4.1.11 表锁、行锁、行锁的算法（Record lock / Gap lock / Next-key lock）

4.1.12 大表优化

4.1.13 池化设计思想，数据库连接池

4.1.14 分库分表以后，id主键如何处理

4.1.15 一条SQL语句在MySQL中怎样执行

4.1.16 MySQL高性能优化

4.1.17 SQL语句执行很慢的原因

Redis

1. 介绍一下Redis
2. 分布式缓存常见的技术选型
3. Redis和Memcached的区别
4. 缓存数据的处理流程
5. 为什么要用Redis/缓存
6. Redis常见数据结构
7. Redis单线程模型
8. Redis为什么不使用多线程
9. Redis6.0为什么引入多线程
10. Redis的缓存数据过期时间
11. Redis判断数据是否过期
12. 过期数据的删除策略
13. Redis内存淘汰机制
14. Redis持久化机制（快照持久化RDB，只追加文件AOF），对持久机制的优化
15. Redis事务（multi，exec），为什么Redis不支持回滚
16. 缓存穿透，应对办法（缓存无效key、布隆过滤器）
17. 缓存雪崩，应对办法（针对Redis服务不可用，针对热点缓存失效）
18. 怎样保证缓存和数据库数据的一致性