目录

 操作系统篇

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

2 文件权限怎么修改

3 说说常用的Linux命令

4 说说如何以root权限运行某个程序。

5 说说软链接和硬链接的区别。

6 说说静态库和动态库怎么制作及如何使用，区别是什么。

7 简述GDB常见的调试命令，什么是条件断点，多进程下如何调试。

8 说说什么是大端小端，如何判断大端小端？

9 说说进程调度算法有哪些？

10 简述操作系统如何申请以及管理内存的？

 11 简述Linux系统态与用户态，什么时候会进入系统态？

12 简述LRU算法及其实现方式。

13 一个线程占多大内存？

14 什么是页表，为什么要有？

15 简述操作系统中的缺页中断。

16 说说虚拟内存分布，什么时候会由用户态陷入内核态？

17 简述一下虚拟内存和物理内存，为什么要用虚拟内存，好处是什么？

18 虚拟地址到物理地址怎么映射的？

19 说说堆栈溢出是什么，会怎么样？

20 简述操作系统中malloc的实现原理

22 32位系统能访问4GB以上的内存吗？

23 请你说说并发和并行

24 说说进程、线程、协程是什么，区别是什么？

25 请你说说Linux的fork的作用

26 请你说说什么是孤儿进程，什么是僵尸进程，如何解决僵尸进程

28 说说进程通信的方式有哪些？

29 说说进程同步的方式？

30 说说Linux进程调度算法及策略有哪些？

31 说说进程有多少种状态？

33 简述mmap的原理和使用场景

34 互斥量能不能在进程中使用？

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

36 说说常见信号有哪些，表示什么含义？

37 说说线程间通信的方式有哪些？

41 单核机器上写多线程程序，是否要考虑加锁，为什么？

42 说说多线程和多进程的不同？

43 简述互斥锁的机制，互斥锁与读写的区别？

44 说说什么是信号量，有什么作用？

46 简述自旋锁和互斥锁的使用场景

48 多线程和单线程有什么区别，多线程编程要注意什么，多线程加锁

49 说说sleep和wait的区别？

51 进程和线程相比，为什么慢？

52 简述Linux零拷贝的原理？

 操作系统篇

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

        

五个命令中必选一个

- c : 建立压缩档案

- x ：解压

- t ：查看内容

- r ：向压缩归档文件末尾追加文件

- u ：更新原压缩包中的文件

这几个参数是可选的

- z ：有 gzip 属性的

- j ：有 bz2 属性的

- Z ：有 compress 属性的

- v ：显示所有过程

- O ：将文件解开到标准输出

 答案解析

        

//ps 使用示例

// 显示当前所有进程

ps - A

// 与 grep 联用查找某进程

ps - aux | grep apache

// 查看进程运行状态、查看内存使用情况的指令均可使用 top 指令。

top

2 文件权限怎么修改

        

每种身份 (owner/group/others) 各自的三个权限 (r/w/x) 分数是需要累加的，

例如当权限为： [-rwxrwx---] ，则分数是：

owner = rwx = 4+2+1 = 7

group = rwx = 4+2+1 = 7

others= --- = 0+0+0 = 0

所以我们设定权限的变更时，该文件的权限数字就是 770 ！变更权限的指令 chmod 的语法是这样的：

 

[ root@www ~ ] # chmod [ - R ] xyz 文件或目录

选项与参数：

xyz : 就是刚刚提到的数字类型的权限属性，为 rwx 属性数值的相加。

- R : 进行递归 ( recursive ) 的持续变更，亦即连同次目录下的所有文件都会变更

# chmod 770 douya.c // 即修改 douya.c 文件的权限为 770

3 说说常用的Linux命令

4 说说如何以root权限运行某个程序。

5 说说软链接和硬链接的区别。

gcc hello.c -c //这样就生成hello.o目标文件
ar rcs libhello.a hello.o//生成libhello.a静态库

 动态库的使用：

gcc main . c - lhello - L . / - o dynamicDepot

/*

main.c ： 是指 main 主函数

-lhello ： 是我们生成的 .so 文件砍头去尾（ lib 不要 .so 也不要）前面加 -l

-L ： 是指告诉 gcc 编译器先从 -L 指定的路径去找静态库，默认是从 /usr/lib/ 或者

/usr/local/lib/ 去找。

./ ： 是指当前路径的意思

dynamicDepot ： 是最后想生成的文件名（这里可随意起名字）

*/

 

int fun1(){
union test{
char c;
int i;
};
test t; t.i = 1;
//如果是大端，则t.c为0x00，则t.c != 1，反之是小端
return (t.c == 1);
}

9 说说进程调度算法有哪些？

答案解析

1. 先来先服务调度算法：每次调度都是从后备作业（进程）队列中选择一个或多个 最先进入该队列的 作业 （进程），将它们调入内存，为它们分配资源、创建进程，然后放入就绪队列。

2. 短作业 ( 进程 ) 优先调度算法：短作业优先 (SJF) 的调度算法是从后备队列中选择一个或若干个 估计运 行时间最短的作业（进程） ，将它们调入内存运行。

3. 高优先级优先调度算法：当把该算法用于作业调度时，系统将从后备队列中选择若干个 优先权最高的作业装入内存。当用于进程调度时，该算法是把处理机分配给就绪队列中优先权最高的进程

4. 时间片轮转法：每次调度时， 把 CPU 分配给队首进程，并令其执行一个时间片。时间片的大小从几 ms 到几百 ms 。当执行的时间片用完时，由一个计时器发出时钟中断请求，调度程序便据此信号来 停止该进程的执行，并将它送往就绪队列的末尾 ；然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。

5. 多级反馈队列调度算法：综合前面多种调度算法。

在这些调度算法中，有抢占式和非抢占式的区别。

1. 非抢占式优先权算法

在这种方式下，系统一旦把处理机分配给就绪队列中优先权最高的进程后，该进程便一直执行下

去，直至完成；或因发生某事件使该进程放弃处理机时，系统方可再将处理机重新分配给另一优先

权最高的进程。这种调度算法主要用于批处理系统中；也可用于某些对实时性要求不严的实时系统

中。

2. 抢占式优先权调度算法

在这种方式下，系统同样是把处理机分配给优先权最高的进程，使之执行。但在其执行期间，只要

又出现了另一个其优先权更高的进程，进程调度程序就立即停止当前进程 ( 原优先权最高的进程 ) 的

执行，重新将处理机分配给新到的优先权最高的进程。因此，在采用这种调度算法时，是每当系统

中出现一个新的就绪进程 i 时，就将其优先权 Pi 与正在执行的进程 j 的优先权 Pj 进行比较。如果

Pi ≤ Pj ，原进程 Pj 便继续执行；但如果是 Pi>Pj ，则立即停止 Pj 的执行，做进程切换，使 i 进程投入执

行。显然，这种抢占式的优先权调度算法能更好地满足紧迫作业的要求，故而常用于要求比较严格

的实时系统中，以及对性能要求较高的批处理和分时系统中。

区别： 非抢占式（ Nonpreemptive ）： 让进程运行直到结束或阻塞的调度方式，容易实现，适合专用系统 ，不适合通用系统。抢占式（Preemptive）： 允许将逻辑上可继续运行的在运行过程暂停的调度方式可防止单一进程长时间 独占， CPU 系统开销大 （降低途径：硬件实现进程切换，或扩充主存以贮存大部分程序）。

10 简述操作系统如何申请以及管理内存的？

参考回答

操作系统如何管理内存：

1. 物理内存 ：物理内存有四个层次，分别是寄存器、高速缓存、主存、磁盘。

寄存器：速度最快、量少、价格贵。

高速缓存：次之。

主存：再次之。

磁盘：速度最慢、量多、价格便宜。

 11 简述Linux系统态与用户态，什么时候会进入系统态？

12 简述LRU算法及其实现方式。

        

答案解析

class LRUCache {
list<pair<int, int>> cache;//创建双向链表
unordered_map<int, list<pair<int, int>>::iterator> map;//创建哈希表
int cap;
public:
LRUCache(int capacity) {
cap = capacity;
}
int get(int key) {
if (map.count(key) > 0){
auto temp = *map[key];
cache.erase(map[key]);
map.erase(key);
cache.push_front(temp);
map[key] = cache.begin();//映射头部
return temp.second;
}
return -1;
}
void put(int key, int value) {
if (map.count(key) > 0){
cache.erase(map[key]);
map.erase(key);
}
else if (cap == cache.size()){
auto temp = cache.back();
map.erase(temp.first);
cache.pop_back();
}
cache.push_front(pair<int, int>(key, value));
map[key] = cache.begin();//映射头部
}
};
/**
* Your LRUCache object will be instantiated and called as such:
* LRUCache* obj = new LRUCache(capacity);
* int param_1 = obj->get(key);
* obj->put(key,value);
*/

13 一个线程占多大内存？

参考回答

一个 linux 的线程大概占 8M 内存 。

linux 的栈是通过缺页来分配内存的，不是所有栈地址空间都分配了内存。因此， 8M 是最大消耗，实际的内存消耗只会略大于实际需要的内存( 内部损耗，每个在 4k 以内 ) 。

        

14 什么是页表，为什么要有？

参考回答

页表是虚拟内存的概念。 操作系统虚拟内存到物理内存的映射表，就被称为页表。

原因 ：不可能每一个虚拟内存的 Byte 都对应到物理内存的地址。这张表将大得真正的物理地址也放不下，于是操作系统引入了页（Page ）的概念。进行分页，这样可以 减小虚拟内存页对应物理内存页的映射表大小 。

答案解析

如果将每一个虚拟内存的 Byte 都对应到物理内存的地址，每个条目最少需要 8 字节（ 32 位虚拟地址 ->32位物理地址），在 4G 内存的情况下，就需要 32GB 的空间来存放对照表，那么这张表就大得真正的物理地址也放不下了，于是操作系统引入了页（Page ）的概念。 在系统启动时，操作系统将整个物理内存以 4K 为单位，划分为各个页。之后进行内存分配时，都以页为单位，那么虚拟内存页对应物理内存页的映射表就大大减小了，4G 内存，只需要 8M 的映射表即可，一些进程没有使用到的虚拟内存，也并不需要保存映射关系，而且Linux 还为大内存设计了多级页表，可以进一页减少了内存消耗。

15 简述操作系统中的缺页中断。

参考回答

1. 缺页异常 ： malloc 和 mmap 函数在分配内存时只是建立了进程虚拟地址空间，并没有分配虚拟内存对应的物理内存。当进程访问这些没有建立映射关系的虚拟内存时，处理器自动触发一个缺页异

常，引发缺页中断 。

2. 缺页中断 ：缺页异常后将产生一个缺页中断，此时操作系统会根据页表中的 外存地址 在外存中找到所缺的一页，将其调入内存 。

答案解析

两者区别。

缺页中断与一般中断一样，需要经历四个步骤： 保护 CPU 现场、分析中断原因、转入缺页中断处理程序、恢复CPU 现场，继续执行。 缺页中断与一般中断区别：

（1）在指令执行期间产生和处理缺页中断信号

（2）一条指令在执行期间，可能产生多次缺页中断

（3）缺页中断返回的是执行产生中断的一条指令，而一般中断返回的是执行下一条指令。

16 说说虚拟内存分布，什么时候会由用户态陷入内核态？

参考回答

1. 虚拟内存分布 ：

17 简述一下虚拟内存和物理内存，为什么要用虚拟内存，好处是什么？

参考回答

1. 物理内存 ：物理内存有四个层次，分别是寄存器、高速缓存、主存、磁盘。

寄存器：速度最快、量少、价格贵。

高速缓存：次之。

主存：再次之

磁盘：速度最慢、量多、价格便宜。

按照以上两步法，就完成了一个三级页表从虚拟地址到物理地址的转换。

19 说说堆栈溢出是什么，会怎么样？

20 简述操作系统中malloc的实现原理

参考回答

malloc 底层实现： 当开辟的空间小于 128K 时，调用 brk （）函数；当开辟的空间大于 128K 时，调用mmap（）。 malloc 采用的是内存池的管理方式，以减少内存碎片。先申请大块内存作为堆区，然后将堆区分为多个内存块。当用户申请内存时，直接从堆区分配一块合适的空闲快。采用隐式链表将所有空闲块，每一个空闲块记录了一个未分配的、连续的内存地址。

21 说说进程空间从高位到低位都有些什么？

参考回答

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/stat.h>
#define MAXFILE 65535
int main(){
//第一步:创建进程
int pid = fork();
if (pid > 0)
exit(0);//结束父进程
else if (pid < 0){
printf("fork error!\n");
exit(1);//fork失败，退出
}
//第二步:子进程成为新的会话组长和进程组长,并与控制终端分离
setsid();
//第三步:改变工作目录到
chdir("/");
//第四步:重设文件创建掩模
umask(0);
//第五步:关闭打开的文件描述符
for (int i=0; i<MAXFILE; ++i)
close(i);
sleep(2);
}
return 0;
}

31 说说进程有多少种状态？

参考回答

进程有五种状态： 创建、就绪、执行、阻塞、终止 。一个进程创建后，被放入队列处于就绪状态，等待 操作系统调度执行，执行过程中可能切换到阻塞状态（并发），任务完成后，进程销毁终止。

答案解析

创建状态

一个应用程序从系统上启动，首先就是进入 创建状态 ，需要获取系统资源创建进程管理块（ PCB ：

Process Control Block ）完成资源分配。

就绪状态

在 创建状态 完成之后，进程已经准备好，处于 就绪状态 ，但是还未获得处理器资源，无法运行。

运行状态

获取处理器资源，被系统调度， 当具有时间片 开始进入 运行状态 。如果进程的时间片用完了就进入 就绪 状态 。

阻塞状态

在 运行状态 期间，如果进行了阻塞的操作，如耗时的 I/O 操作，此时进程暂时无法操作就进入到了 阻塞状 态 ，在这些操作完成后就进入 就绪状态 。等待再次获取处理器资源，被系统调度， 当具有时间片 就进入 运行状态 。

终止状态

进程结束或者被系统终止，进入 终止状态

相互转换如图

#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define INPUT 0
#define OUTPUT 1
int main(){
//创建管道
int fd[2];
pipe(fd);
//创建子进程
pid_t pid = fork();
if (pid < 0){
printf("fork error!\n");
exit(-1);
}
else if (pid == 0){//执行子进程
printf("Child process is starting...\n");
//子进程向父进程写数据，关闭管道的读端
close(fd[INPUT]);
write(fd[OUTPUT], "hello douya!", strlen("hello douya!"));
exit(0);
}
else{//执行父进程
printf ("Parent process is starting......\n");
//父进程从管道读取子进程写的数据 ，关闭管道的写端
close(fd[OUTPUT]);
char buf[255];
int output = read(fd[INPUT], buf, sizeof(buf));
printf("%d bytes of data from child process: %s\n", output, buf);
}
return 0;
}

33 简述mmap的原理和使用场景

参考回答

原理 ： mmap 是一种内存映射文件的方法 ，即将一个文件或者其它对象映射到进程的地址空间，实现文件磁盘地址和进程虚拟地址空间中一段虚拟地址的一一对映关系。实现这样的映射关系后，进程就可以采用指针的方式读写操作这一段内存，而系统会自动回写脏页面到对应的文件磁盘上，即完成了对文件的操作而不必再调用read, write 等系统调用函数。相反，内核空间对这段区域的修改也直接反映用户空间，从而可以实现不同进程间的文件共享。如下图：

34 互斥量能不能在进程中使用？

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

参考回答

1. 协程调用跟切换比线程效率高 ：协程执行效率极高。协程不需要多线程的锁机制，可以不加锁的访问全局变量，所以上下文的切换非常快。

2. 协程占用内存少 ：执行协程只需要极少的栈内存（大概是 4 ～ 5KB ），而默认情况下，线程栈的大小为1MB 。

3. 切换开销更少 ：协程直接操作栈基本没有内核切换的开销，所以切换开销比线程少。

36 说说常见信号有哪些，表示什么含义？

参考回答

编号为1 ~ 31 的信号为传统 UNIX 支持的信号，是不可靠信号 ( 非实时的 ) 。不可靠信号和可靠信号的区别在于前者不支持排队，可能会造成信号丢失，而后者不会。编号为1 ~ 31 的信号如下：

而常见信号如下 ：

其中最重要的就是 "1"、"9"、"15"、"17"这几个信号。

37 说说线程间通信的方式有哪些？

T1 说：不行，你要先给我 R2 ，我才能给你 R1

那么就这样，死锁产生了。如下图：

40 有了进程，为什么还要有线程？

参考回答

1. 原因

进程在早期的多任务操作系统中是基本的 执行单元 。每次进程切换，都要先保存进程资源然后再恢

复，这称为上下文切换。 但是进程频繁切换将引起额外开销，从而严重影响系统的性能。 为了减少

进程切换的开销，人们把两个任务放到一个进程中，每个任务用一个更小 粒度 的执行单元来实现并

发执行，这就是 线程 。

2. 线程与进程对比

（1） 进程间的信息难以共享。 由于除去只读代码段外，父子进程并未共享内存，因此必须采用一

些进程间通信方式，在进程间进行信息交换。

但 多个线程共享 进程的内存，如代码段、数据段、扩展段，线程间进行信息交换十分方便。

（2）调用 fork() 来创建进程的代价相对较高，即便利用写时复制技术，仍然需要复制诸如内存页

表和文件描述符表之类的多种进程属性，这意味着 fork() 调用在时间上的开销依然不菲。

但创建线程比创建进程通常要快 10 倍甚至更多。 线程间是共享虚拟地址空间的，无需采用写时复

制来复制内存，也无需复制页表。

41 单核机器上写多线程程序，是否要考虑加锁，为什么？

参考回答

在单核机器上写多线程程序，仍然需要线程锁。

原因 ：因为线程锁通常用来实现线程的同步和通信。在单核机器上的多线程程序，仍然存在线程同步的问题。因为在抢占式操作系统中，通常为每个线程分配一个时间片，当某个线程时间片耗尽时，操作系统会将其挂起，然后运行另一个线程。如果这两个线程共享某些数据，不使用线程锁的前提下，可能会 导致共享数据修改引起冲突。

42 说说多线程和多进程的不同？

参考回答

（1）一个线程从属于一个进程；一个进程可以包含多个线程。

（2）一个线程挂掉，对应的进程挂掉，多线程也挂掉；一个进程挂掉，不会影响其他进程，多进程稳

定。

（3）进程系统开销显著大于线程开销；线程需要的系统资源更少。

（4）多个进程在执行时拥有各自独立的内存单元，多个线程共享进程的内存，如代码段、数据段、扩展

段；但每个线程拥有自己的栈段和寄存器组。

（5）多进程切换时需要刷新 TLB 并获取新的地址空间，然后切换硬件上下文和内核栈；多线程切换时只

需要切换硬件上下文和内核栈。

（6）通信方式不一样。

（7）多进程适应于多核、多机分布；多线程适用于多核

43 简述互斥锁的机制，互斥锁与读写的区别？

参考回答

1. 互斥锁机制 ： mutex ，用于保证在任何时刻，都只能有一个线程访问该对象。当获取锁操作失败

时，线程会进入睡眠，等待锁释放时被唤醒。

2. 互斥锁和读写锁 ：

（1） 读写锁区分读者和写者，而互斥锁不区分

（2）互斥锁同一时间只允许一个线程访问该对象，无论读写；读写锁同一时间内只允许一个写

者，但是允许多个读者同时读对象。

答案解析

原理详解 ：

互斥锁其实就是一个 bool 型变量，为 true 时表示锁可获取，为 false 时表示已上锁。这里说的是 互斥锁 ， 其实是泛指linux 中所有的锁机制。 我们采用互斥锁保护临界区，从而防止竞争条件。也就是说，一个线程在进入临界区时应得到锁；它在退出临界区时释放锁。函数 acquire() 获取锁，而函数 release() 释放锁，如图 ：

每个互斥锁有一个布尔变量 available ，它的值表示锁是否可用。如果锁是可用的，那么调用 acquire() 会成功，并且锁不再可用。当一个线程试图获取不可用的锁时，它会阻塞，直到锁被释放。

按如下定义 acquire() ：

acquire() {
while (!available);
/* busy wait */
available = false;
}

按如下定义 release() ：

release () {

available = true ;

}

44 说说什么是信号量，有什么作用？

#include <windows.h> // 首先应该先导入头文件

Sleep ( 500 ) ; // 注意第一个字母是大写。

// 就是到这里停半秒，然后继续向下执行。

如果是 CPU 密集型应用，则线程池大小设置为： CPU 数目 + 1

如果是 IO 密集型应用，则线程池大小设置为： 2 * CPU 数目 + 1

最佳线程数目 = （线程等待时间与线程 CPU 时间之比 + 1 ） * CPU 数目

51 进程和线程相比，为什么慢？

52 简述Linux零拷贝的原理？