# 第2章-Linux多进程开发

<font style="background: MediumSpringGreen">
<font style="background:yellow">

1
2

# 目录

目录
1-进程概述
- 1.1.单道、多道程序设计
- 1.2.时间片
- 1.3.并行和并发
- 1.3.PCB
- 目前2min
2-进程状态转换
3-进程创建
4-父子进程虚拟地址空间情况
5-父子进程关系及GDB多进程调试
6-exec函数族
7-进程退出和孤儿进程和僵尸进程
8.wait函数
9.waitpid函数
10.进程间通信简介
11.匿名管道概述
12.父子进程通过匿名管道通信
13.匿名管道通信案例
14.管道的读写特点和管道设置为非阻塞
15.有名管道介绍及使用
16.有名管道实现简单版聊天功能
17.内存映射(1)
18-内存映射(2)
19.信号概述
20.kill、raise、abort函数
21.alarm函数
22.setitimer函数
23-signal 信号捕捉函数_x264
24-信号集及相关函数_x264
25-sigprocmask函数使用_x264
26-sigaction 信号捕捉函数_x264
27.SIGCHILD信号
28.共享内存（1）
29.共享内存（2）
30.守护进程（1）
31.守护进程（2）

[TOC]

# 1-进程概述

这个面试的时候呢，经常会被问到。好了，那从这节课开始呢，我们就正式进入到第二章。

linux 多进程开发的学习了啊，那么这个linux 多进程开发呢是我们这门课程当中啊一个比较重要的部分啊。因为关于这个linux 多进程的内容啊。

在这个面试的时候呢，经常会被问到啊，所以呢同学们一定要好好的去学习这块内容啊。那这节课呢我们先来对进程啊。

一个简单的概述啊，好，让大家呢对这个进程当中啊一些基本的概念呢有所了解啊。

jincheng

# 进程的发展历史

# 1.1.单道、多道程序设计

# 1.2.时间片

# 1.3.并行和并发

下面的比方很好！

# 1.3.PCB

20210705171918

继续

# 目前2min

那首先呢我们来看一下程序和进程啊，我们要理解什么是程序，什么是进程。他们之间呢又有什么区别？那么程序呢它是包含一系列信息的文件啊，那么你像我们啊呃平常啊写的这个源代码文件，对吧？啊，编程编程。写的这个源代码文件，我们可以称之为是程序啊，那这个呢是站在我们人的一个角度啊，这些源代码文件呢是我们认为的这个程序。但是呢站在这个计算机的角度啊，所谓的程序啊，它其实是一个啊这个可执行程序啊，它就是一个文件。那它里面呢。啊，放的是一些这个呃二进制的一零一零的这些数据啊。那么这个程序呢，他是干嘛的呢？这个程序文件呢它。这些信息呢描述了如何在运行时啊，就是运行这个程序的时候呢，创建一个进程啊，也就是说这个程序它是指导。这个计算机啊如何去创建一个进程的啊，那么这个进程呢我们后面呢再说。那么我们要知道这个程序文件当中啊都包含哪些内容。啊，你比如说第一个这个二进制格式的标识啊，那每一个程序呢它其实都有他的一个格式的一个说明啊，就是在这个程序文件当中。嗯。那么呃每个程序文件呢都包含用于描述可执行文件格式的原信息。那什么叫源信息呢？比如说我们一个文件对吧？它里面会存入。存一些数据啊，那么我们这个呃比如说呢这个文件啊存了一些信息啊，描述的是这个啊某一个事物的信息，对吧？那么我们也可以去啊有一些信息啊描述这个文件的信息。比如说这个文件啊，它大小对吧？他的一个这个啊修改的时间，创建的时间等等。啊，那么我们称这些信息呢，回文件的元信息啊，那么每一个文件呢，每一个这个程序文件它其实就包括了啊包含了这个。描述啊这个可执行文件格式的这些信息啊，那么内核呢他利用此信息呢来解释文件中的其他的信息。啊，因为你不同的格式这个内核他去解析的时候是不是也是不一样的呀，对吧？啊，那么像呃现在呢像这个linux 操作系统啊。他都是采用这个e l f 啊，这种可执行链接格式啊，这个呢大家了解一下就ok 了。那么第二个呢就是机器语言指令啊，那它里面呢都是这些一零一零的二进制的啊指令数据啊，那他呢是对程序算法进行一个编码。因为我们程序的最重要运行起来，对吧？那运行起来呢是有这个c p u 啊去执行这些指令啊，那么这个指令这些信息。对吧，肯定也是在这个文件当中的。然后第三个呢就是程序的入口地址啊，那他呢是标识程序开始执行时的。其实指定位置啊，我们都知道这个程序呢它是从慢函数开始执行的，对吧？那么呃我们在这个计算机当中啊，他不知道哪个是面对吧。他要知道啊，他要呃从你这个标识的。一个起始位置啊，其实指定位置开始去运行啊，一条一条的去执行这些指令啊，所以呢在这个程序当中啊，在这个文件当中呢肯定要包含这个其实指定的位置的。然后第四个呢是数据啊，数据呢比如说这个里面呢包含了一些初始化的值，对吧？变量的初始值啊，还有一些程序使用的字面量值。比如说字符串啊，那还有呢像这个符号表以及重定位表啊，那描述程序中函数和变量的位置及名称。那么这些表格啊有多重用途啊？比如说呢可以去进行一个gdp 调试，对吧？我们之前呢去调试这个程序啊，用gdp 去调试。是不是要干嘛呀？宣传这个可以调试的这个啊可真程序对吧？啊，那么这些信息呢都会在这个里面。然后呢还有一些，比如说这个。运行时的符号解析啊，主要的指这个动态链接啊。然后呢，还有包括了这个共享库，还有动态链接信息啊，那么这个呢就跟我们之前介绍的一个啊共享库有关了。啊，那么程序文件啊所包含的一些字段列出了程序运行时需要使用的共享库以及呢加载共享库的动态连接器的路径名。什么意思呢？我们之前在介绍这个动态库的时候呢，或者说共享库的时候呢，我们说啊如果说我们一个程序啊使用了这个动态库，对吧那。那我们在编译生成可执行程序的时候，会不会把动态库的代码一起打包到可执行程序当中，不会对吧？啊，他只是把这个动态库。呃，一些信息啊写到这个可进程序里面啊，那主要呢包括了这个动态库的一个名字，对吧？表示你要使用哪个动态库啊，以及呢你这个动态库。啊，去加载的时候，就是通过这个动态链接器去加载的时候，它的一个路径名，对吧？之前我们是不是涉及到了啊，而我们当时呢呃。加载不到这个动态库啊，我们是通过什么办法去解决的，是不是通过这个环境变量去配置的，对吧？或者呢通过某些文件去配置啊。然后呢，还有一些其他的信息啊呃程序文件啊，还包含了许多其他的信息啊，这些新的这些信息呢都是用来描述如何去创建进程的。啊，总之呢这个程序当中的这些信息就是用来指导这个操作系统啊，如何去创建一个进程。那么接下来我们再来看一下什么是进程。那么进程呢是正在运行的程序的实例啊，那这个呢是官方的一个说明啊，进程是正在运行的程序的实例。啊，但是注意了程序，它占用磁盘的大小吗？程序它是文件，它是占用磁盘的大小的，对吧？那么呃他占不占用系统的一些其他的资源，比如说内存啊。 pu one 啊程序是不占用的啊，那么进程他这样占用的进程呢，它是占用这个内存资源，还有这个c p u 资源的。啊，这个就是程序和进程他们之间的一个区别嘛，对吧？啊，程序呢它好像是死的，而进程的好像是活的，对不对啊？那么呃这个进程呢它是一个具有一定独立功能的程序。关于某个数据集合的一次运行活动啊，它是操作系统执行动态执行的基本单元。在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。那什么意思呢？就是说我们进城啊，就说我们一个程序啊要想运行起来对吧？那操作系统是不是又要给他分配一些啊，就是我们这个程序执行所需要的资源。说内存肯定得要了，对吧？比如说这个呃cpu 对不对啊，那那这个时候呢我们说这。个进程其实就是什么呢？操作系统为我们程序运行所分配的一个啊一些资源啊，我们抽象为这个进程。啊，那么呃在这个操作系统当中啊，进程它是最基本的分配单元，就是你分配这个资源对吧？啊，他分配的时候也是以进程为单位的。那执行的时候呢，也是以这个进程为这个基本的执行单元。那我们可以啊用一个程序来创建多个进程啊，那进程呢是由内核定义的抽象的实体。你注意了，它是一个抽象的实体。啊，其实进程它存不存在了啊，你说他存在也存在，不存在呢也不存在，对吧？那存在呢它其实是呃我们为这个实体分配的一些。用于执行这个程序啊啊他所相关的一些系统资源，比如说内存对吧？那内存肯定是实实在在存在的吧，对吧？还有这个cpu。啊，那么从内核的角度来看呢，进程呢它是由由这个用户空间啊用户内存空间和一系列的内核数据结构组成的。啊，这个就是我们之前啊呃给大家介绍的这个什么虚拟地址空间啊，我们说一个进程启动起来以后呢，哎会为他分配一个虚拟地址空间。对吧那么其中呢用户内存空间呢包含了程序代码啊以及这个代码所使用的变量啊，这个我们之前也说过，对吧？啊，比如说这个text 段。他是存放的是这个城市的代码。那么像这个使用的变量啊，比如说这个局部变量是不是放在这个战略层里面，对不对？而这个内核数据结构呢则用于维护进程状态信息啊，那记录在内核。数据结构中的信息呢啊包括许多与这个进程啊相关的标识号啊，比如说id 啊，对吧？啊，还有虚拟内存表。啊，打开的这个文件描述符表，我们之前是不是也介绍过，对吧？这个文件描述符表啊在我们这个内阁当中是吧啊，然后呢，还有像呃我们后面要学习到的这个信号啊信号传递以及。处理等等相关的信息啊，还有像这个进程资源使用以及极限啊，还有像这个当前的工作公路和大量的其他信息。这些信息呢都是在这个内核当中啊保存的啊。好，那就是呃给大家说的这个程序和进程啊，现在呢大家应该。错啊，了解了对吧？啊，能够区分开他们啊程序呢就是文件啊，进程呢是我们这个程序要运行啊，系统呢为他分配的一些资源啊，它是一个比较抽象的一个概念。那么接着呢我们再来看一下这个呃丹道多道程序设计啊，这个呢我们也要去了解一下。首先说这个单道程序啊。所谓单套程序呢，就是在这个计算机内存当中啊，只允许一个程序去运行。那其实在这个计算机早期的时候呢，这个一个计算机呢它只能运行啊单个程序啊，我们称之为单任务的这个计算机啊。那么如果说你要想运行另外的这个程序的话呢，唉那你当前的这个程序就要停止，然后再去运行其他的这个程序啊，也就是说同时呢只能运行一个城市。这是单任务的这个计算机啊，那么很显然这个单任务的计算机啊，它的这个效率是非常低的，对吧？那么后来呢这个人们呢就开发出了这种。多道程序设计啊就是多任务的计算机。那么多道程序设计技术呢它是在计算机内存当中啊同时存放几道相互独立的程序。啊，使他们在管理程序控制下啊，也就是说呃我这个计算机呢它能够同时运行多个这个独立的这个程序了。啊，那么这些程序呢是由这个一个管理程序去控制的啊。那么这些程序呢，它他们之间啊并不是说啊我这个同时去执行的啊，而是。相互穿插着运行啊，为什么是相互穿插的？疫情没法说啊。那么两个或者两个以上的程序呢，在计算机系统当中啊处于。什么呢？哎，系统中同处于开始到结束之间的状态啊，这些程序呢它是共享计算机系统资源的。也就是说你多个程序在运行的时候呢，它是共享。我们这个计算机的啊相关的一些系统资源。那么引入多道程序设计技术的根本目的是为了什么呢？一开始我们呃一个这个单任务的这个计算机。他是不是只能运行一个这个程序啊，对吧？啊，那么现在呢我们这个计算机呢，它可以啊运行这个多个程序的啊，那么它能够提高。 pu 的一个利用率啊，那你单任务的话，你只能执行一个，对吧？那我现在我可以运行多个，那我这个c p u 的利用率是高量，对不对？那么对于一个单c p u 的系统来说呢，成群程序呢同时处于这个运行状态上的只是一个宏观上的概念啊，像我们现在的这个电脑是不是都是多任务的这个计算机啊，对。那同时呢可以运行多个这个程序。比如说呢我啊打开这个p p t 对吧？我又打开了一个音乐播放器啊，我又打开了这个q q 啊，又打开了这个word，对吧？可是同时呢可以这个运行多个这个应用程序啊，其实应用程序呢就是啊这个在系统当中呢会有这个政策对吧？进程。啊，分配的这些资源。那么我们虽然说呢在这个宏观上来看呢，他们是同时去执行的，对吧？但是呢大家要知道的是，虽然说呢他们。是从这个宏观上来看是同时执行的。但是呢微观上看呢，其实任意一个时刻呢，cpu 上海运行的这个程序呢只有一个。啊，什么意思呢？也就是说这个c p u 啊，他在某一个时刻啊，就某一个时间点上，它只能运行一个。这个程序啊只能运行一个程序啊。那么呃由于这个c p u 啊它的这个速度呢非常的快啊，所以呢导致我们啊呃。就是看的时候呢呃其实这个cpu 呢在多个这个应用程序啊，多个进程之间快速的来回切换。啊，这个这个时间呢是非常短的。所以呢我们看起来好像是这些程序啊同时执行的。但是呢在某一个时刻啊时间点上，它只能运行一个程序。这个大家一定要搞清楚。啊。那么在这个多道程序设计模型当中啊，多个进程呢是轮流去使用cpu 的。好好当下常见的c p u 呢为纳秒级。啊，那么急。啊，我们都知道一秒呢是等于一千毫秒。对吧啊然后一毫秒呢是等于一千。微秒。对吧，然后一一微秒呢又等于一千纳秒。那你算一算，其实这个纳秒一秒的话可以换算成多少个产品。这是不是大概有十亿的对吧？啊，那么呃这个c p u 的速度呢是非常快的啊，一秒呢大概可以执行十亿条。机器指令啊，好，由于这个人的反应速度呢是毫秒级的。所以说呢我们看起来呢是同时运行的。但是在微观的角度来看的话，同一个时刻这。 cpu 呢它只能运行一个程序。好好，这是给大家说的单道和这个多道程序设计。然后呢，在这儿呢，我们又不得不提一个名词叫做时间片啊，那么呃什么叫时间片的英文单词呢？就要time size，对吧？此外就是切片一次啊，时间片就是把时间呢切成一片一片，对吧？一段一段啊，那我们也可以称之为样子，或者呢是处理器片。哎，那你看到这个处理器片，你应该知道是什么意思呢？其实就是我们这个呃处理器啊分配给每一个这个进程。啊，他的这个c p u 的一个运行的时间啊，你看它是操作系统分配给每个正在运行的进程。微观上的一段cpu 的时间啊。那么呃事实上呢，虽然一台计算机啊通常可以有多个c p u 啊。但是呢如果说我们只有一个c p u 的话，呃，那么或者说呢。一个cpu 上的，他永远不可能真正的同时运行多个任务。啊，那么在这个微观上肯定是不能同时运行多个任务的，对吧？啊，因为我们刚才也说了，这个cpu 呢。在同一个时刻，它只能去运行一个程序啊，那么在只考虑一个cpu 的情况下呢，这些进程呢看起来像同时运行啊，实际上呢他们是。轮番的穿插着去运行的啊，什么意思呢？就是说比如说我有一二三四四个进程，对吧？而我cpu 呢同一个时间上他只能去执行一个程序。那么他就在这个呃，一二三四这四个进程当中啊快速的切换，对吧？一先执行优化，二，再进行优化，或者是自执行款，然后三只循环。对吧那么每一个进程它所执行的这个时间啊，我们就是称之为时间片，是cpu 给这个每个进程分配好的啊，这个就是时间片。那么这个十千片呢呃大家想一想，我能不能特别短，或者说特别的长呢？啊，那时间片了，你注意了，他不能特别的短。比如说我时间片呢是呃一毫秒对吧？也就是说我每一个这个呃程序啊运行一毫秒，然后立马切到另外一个这个进程。行，一毫秒再切到另外一个这个进程啊，然后运行一毫秒，对吧？那你想想你只运行一毫秒的话，有马上的期望，马上的情况。比如说你。切换你肯定也要时间嘛，对吧？因为这个切换这个操作系统呢，它有一个进程调度的一个程序去负责进行一个切换。啊，那你切换的话，你是不是要先保存一下你原先的这个程序啊，或者说进程它的执行的一个状态，然后呢再去运行其他的，对吧？那你回来再回来运行的时候啊，你是不是要把这个原先的状态给加载进去，对吧？那你想想这个切换的时间是不是应该也会比较。长啊，对吧？那如果说啊呃举个例子啊，比如说我第一个程序，第二是与其他程序才这三个程序。第一个程序呢运行了一毫秒，然后呢。呃，运行第二个，那么假设呢这个切换的这个时间呢也是为一毫秒啊，那么你你想啊预警一毫秒切换花费一毫秒，然后又运行一毫秒，对吧？那你你算一下啊，其实这个切换的时间在我们整个程序运行过程当中，或者说在这个cpu 执行的过程当中，是不是占了百分之五十的这个时间。那很显然这是不太好的，对吧？太浪费这个啊这个性能啊，那么设置的过高行不行呢？比如说我这个时间点呢设置成一秒。啊，那我一个程序疫情一秒，然后我另外一个程序在运行一秒那一秒，其实人就能够感觉出来了，对不对啊，那如果说你这个呃第一个程序在运行的时候一秒。然后另外一个程序是不是就不能同时去执行了，对吧？就是宏观上的哈是不是不能同时执行的，对吧？啊，所以呢这个时间片呢它通常呢是。啊，在这个linux 上通常呢是五毫秒到八百毫秒啊之间。那么这个时间呢是cpu 他去进行一个啊就是。在我们这个内核当中啊，有一个进程调度的一个程序，他去负责帮我们计算了啊。啊，用户呢是不会感觉到的。那么这个时间片呢，它是由操作系统内核的调度程序分配给每个竞选。啊，那首先呢内核呢会给每个进程呢。配相等的初始的时间片啊。呃那么关于这个进程调度呢呃相关的一些理论知识，大家呢也可以去。啊，自己呢查阅一下相关的书籍啊，面试的时候呢，往往会啊问你呢什么呢？就是你知道这个lining 上啊有哪些这个进程调度的策略，对吧？啊，有哪些进程调度的算法啊？好，那么这些呃理论知识呢我在课上呢就不给大家去介绍了啊。然后呢，我们刚才说这个呃时间片呢，对吧？一开始呢会给每一个进程一二三对吧？比如说有三个进程，每个进程呢都分配相同的这个时间片。比如说啊都分配十毫秒。啊，十毫秒对吧？十毫秒啊，然后呢呃先让这个三个进程呢轮番的去执行相应的时间啊。那么当所有的这个进程都处于时间片耗尽的状态时呢，哎这个时候内核呢他又会重新去为每一个这个进程啊去计算分配的。这个时间片啊又重新去计算啊，到底给该给你分配多长时间的这个时间片啊，如此往复啊，因为你每一个进程呢他呃。格执行啊它执行的时候呢，情况呢是不同的。那么你这个内核呢，他分配的这个时间片呢也是不一样的啊，那么这些呢都是关于这个进程调度里面的知识。好好，那这样呢我们就给大家说到这儿，这个时间片啊。然后呢，下面呢我们还需要掌握两个名词，一个是并行，一个是并发啊。那么所谓并行呢，它是指在同一个时刻有多条指令在多个处理上啊处理器上同时执行。啊，比如说呢我们正好有一张图啊。我比如说我有a b c 对吧？那么你在看一下啊，在同一个时刻是不是a b c 都带去运行啊，对吧？这就是b 型啊。并行。那么呃你可以把它理解为什么呢？我有三个cpu a b c 都是cpu 那么他们都在运行程序，是不是同一个时刻，他们都在疫情啊。这是并行啊，然后呢还有这个并发啊，英文单词呢叫concurrency 是吧？那么他呢是指在同一个时刻，只能有一条指令执行。啊，但多个进程呢指令被快速的轮换执行，使得了宏观上具有多个进程同时执行的效果。但是呢微观上并不能。并不是同时执行的，只是把这个时间分为若干段，对吧？每个进程呢快速交替的去执行啊，这个就是我们刚才说的这个啊c p u 嘛，对吧？有时间片啊，那么你看比如说我在这一段时间是不是a 运行，这段时间是b 运行这段时间c 运行，然后又是a b c 是不是？啊，轮流的去执行啊，对吧？那么你看一下在同一个时刻，是不是只会有一个再去运行同一个时刻，只能会有一个运行，不可能有两个程序同时运行吗，对吧？这个就是并发啊并发，而我们这个往往呢要研究的其实就是这个并发啊，你比如说呢这个天猫双十一的时候是吧？你这个服务器啊。是不是会同时很多人来访问你这个服务器啊，对吧？而你这个服务器的资源是有限的啊，那你如何保证啊同一个时刻。那么多人来访问你的这个服务器，对吧？好，你这个服务器呢哎不能崩掉，对吧？其实这个考虑的就是什么呀，就是并发的一个问题，对吧？同一个时刻好多人呢来访问。你怎么去处理他们，是不是啊？那么为了让大家更好的去理解这个病情和并发呢，在这呢还有一张图啊，我们来看一下，比如说并发呢是两个队列的交替去使用一台咖啡机。啊，比如说呢我照样呢有一个咖啡机对吧？然后呢有两对这个人去喝咖啡啊，去接这个咖啡，对吧？那么你你一对。在接的时候，比如说一个人在照去接的时候，另外一队能不能去接，是不能的，对吧？是不是要等到这个人接完了以后，另外一堆的人才能再去接。对吧，那这个其实就是并发嘛，对吧？我们这个资源是有限的啊，那你人呢又非常多，对吧？那我怎么去处理这个并发的问题？对不对啊，让每个人呢尽可能的这个时间呢短一点，对吧？能够快速的接到这个咖啡是吧？这是并发啊需要考虑的问题。然后呢这个并行啊，那并且呢就是两个队列，同时使用两台咖啡机啊，那比如说有两个咖啡机。然后两队人对吧，那。你记一队人在去接咖啡的时候，跟这一对区间消费相互之间有没有冲突啊，没有任何的冲突，对吧，啊，是不是他们是同时在进行的，对不对？个就是b 型啊，那一般呢我们在程序当中呢也不会去考虑这个啊并行的一个问题，对吧？啊，你想一想你要实现这个并行，是不是你这个计算机。得需要有很多的这个内核吧，对吧？很多的cpu 是吧？那现在呢这个电脑呢呃它有可能有四个这个cpu 是吧？但是呢也不可能。会有更多的这个c p u 对吧？因为这个c p u 的这个呃成本呢是非常高的，是吧？你不可能说你一个电脑呢来一个一千个这个cpu 那是不可能的。是吧所以说呢我们考虑的是这个并发的一个问题啊。好，然后呢还要再给大家说的是这个进程控制块啊，简称呢叫pcb 啊，这个我们也要了解一下。那么为了管理进程啊，内核呢必须为每个进程所做的事情呢来进行清楚的描述。啊，那我们刚才也说了，我们说这个内核呢。他需要干嘛呀？他需要不说我们这个操作系统需要为我们的这个进程啊分配一些资源，对吧？那分配了资源以后呢，我们呃是不是应该尽记录这个。呃，进程它运行的时候，它的一些情况，对吧？那么这个时候呢，内核呢会为每个进程啊分配一个pcp 啊，全身的叫processing control block 进程控制块，用来维护相关的这个进程的信息。啊，那么有的书上呢，这个精神控制快呢，也称之为什么呢？称之为这个进程描述符表啊，就是一张表里面是描述了我们这个。竞选相关的一些信息啊。那你看到这个名词呢不要陌生，他其实就是这个p p t 啊，那p db 这个呃他呢其实在我们linux 内核里面呢。啊，是一个结构体啊结构体啊这个结论问题的类型呢叫task struct。啊，那你可以到这个木匠啊。u s src linux headers. 然后呢，到in include linux 再到这个头文件里面，你可以去查看到这个task ruk 这个结构的一个定义啊，也可以去看一看。这个结构体呢，它里面的成员呢非常多啊，但是我们需要掌握的呢，哎只需要下面这一部分就ok 了啊。也就是说你要知道在这个内核当中啊。他保存了一些啊我们进程哪些信息？比如说第一个进程的id 啊，这个很好理解啊，比如说我们这个学生对吧？学生是不是有学号？是标识你这个呃学生的一个唯一的一个这个边是标识，对不对？那么进程也是啊系统当中呢，每一个进程呢有唯一的id 啊，那么在程序当中呢，它是用这个p i d 杠t 这种类型的去表示的，其实就是一个整数。啊，那么它是一个非负整数。然后呢这个第二个呢呃要了解的是进程的状态啊，有这个就去运行挂起停止等等这些状态。我们呃下一节课呢就会给大家去介绍啊进程的这些状态。好，然后呢，还有像这个进程切换的时候呢，需要保存和恢复的一些c p u 的寄存器。啊，那我们说了呃这个c p u 呢它是在。多个这个进程之间快速的来回的切换，对不对？那么比如说我这个第一个程序啊运行完了，时间片到了对吧？啊，分配的这个时间片。运行完了，那是不是应该要保存这个程序啊，当前执行到哪了，对吧，是不是要保存到一些信息是吧？好，那这个时候呢就会保存到这个啊基层界面。啊，那么我运行二的时候呢，我是不是需要呃找到我这个进程二啊，它上一次运行的这个相关的信息，从上一次运行的地方开始继续往下去运行。是吧那么这个呢他也会保存到这个pcb 里面啊。还有呢像这个虚拟地址空间的信息啊，这个我们就不说了，我们之前啊也给大家介绍过，对吧？啊，还有这个描述控制终端的信息啊，那其实每一个。进程呢他都对应了这个终端是吧，我们程序运行起来以后呢，哎你是不是可以通过这个啊终端去录入一些数据，或者说呢把一些信息呢输出到这个终端了。其实在每一个进程运行的时候呢，他都绑定好了对应的这个终端啊。然后呢，还有像这个当前的工作目录啊，当前的工作目录叫current working directory。啊，这个信息呢也会在这个p c b 里面去保存。啊，那么他为什么会有这个当前工作目录的这个信息呢？啊，我们之前呢再给大家介绍这个虚拟地址空间的时候，是不是呃它里面有一个什么呀？有一个这个环境变量对吧？就是环境的一些信息。保存到这个里面。那那个是通过什么，通过当前的这个环境变量啊，是不是把这个信息保存到这个虚拟地址空间里面的，对吧？所以说在这个pdp 里面，他也会有这个当前工作目录。啊，这个信息好，然后呢还有这个you must 就是我们之前啊呃学习的这个you must 啊，好，然后呢还有像这个文件描述符表。这个不用说了吧，我们之前也介绍过，对不对？那么它里面呢包含了很多指向这个啊文件的结构体的一个指针。啊，文件描述符表，然后呢，还有和信号相关的一些信息。那信号呢我们后面呢学到的时候呢，在具体地区说他啊还有像这个用户id 和组id。啊，用户id 和组id 那这个呢我们一会儿再说。ok 然后呢还有像这个绘画啊，还有这个进程组啊，这些信息也会有啊，然后。那还有像这个进程可以使用的资源上限。啊。这个信息呢都记录在这个pcd 里面。那么在这呢其实有一个指令啊给大家去练一下，我们打开这个h r。在这样呢我们去连接一下。有一个指令叫u limit。好，那么u limit 呢我们呃加上一个参数杠a 啊，可以显示我们这个当前啊这个系统啊，他的一些啊这个。啊，资源的一个什么资源的上线啊，你比如说来看一下啊，比如说有什么呢file size 文件的一个大小，对吧？好，然后呢呃。再往下open bus。打开的一个什么文件数，你看默认值是多少？一零二四版是不是在内核里面写好了呀，对吧？默认就是一零二四啊。好，然后呢还有像这个拍pipe size 管道的一个大小。啊啊，cpu 的一个时间对吧？不限制啊。好，那么呃其实这些值呢是可以改的，怎么改呢？呃，比如说呢你要改这个。 open file 对吧？那你就是you limit，然后呢杠n 这不是有参数吗？对吧？后面呢再加上一个具体的值啊，就可以去修改啊。那么我们一般呢也不会去修改这个内核的一些信息啊，不会去修改啊。这个呢大家知道一下就ok 了。好了，那这节课呢啊主要给大家去介绍一下进程相关的一些概念啊，我们这节课呢。就先介绍的找啊我们下一节课呢，再见。

# 2-进程状态转换

# 3-进程创建

fork.c

/*
    #include <sys/types.h>
    #include <unistd.h>

    pid_t fork(void);
        函数的作用：用于创建子进程。
        返回值：
            fork()的返回值会返回两次。一次是在父进程中，一次是在子进程中。
            在父进程中返回创建的子进程的ID,
            在子进程中返回0
            如何区分父进程和子进程：通过fork的返回值。
            在父进程中返回-1，表示创建子进程失败，并且设置errno

        父子进程之间的关系：
        区别：
            1.fork()函数的返回值不同
                父进程中: >0 返回的子进程的ID
                子进程中: =0
            2.pcb中的一些数据
                当前的进程的id pid
                当前的进程的父进程的id ppid
                信号集

        共同点：
            某些状态下：子进程刚被创建出来，还没有执行任何的写数据的操作
                - 用户区的数据
                - 文件描述符表
        
        父子进程对变量是不是共享的？
            - 刚开始的时候，是一样的，共享的。如果修改了数据，不共享了。
            - 读时共享（子进程被创建，两个进程没有做任何的写的操作），写时拷贝。
        
*/

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>

int main() {

    int num = 10;

    // 创建子进程
    pid_t pid = fork();

    // 判断是父进程还是子进程
    if(pid > 0) {
        // printf("pid : %d\n", pid);
        // 如果大于0，返回的是创建的子进程的进程号，当前是父进程
        printf("i am parent process, pid : %d, ppid : %d\n", getpid(), getppid());

        printf("parent num : %d\n", num);
        num += 10;
        printf("parent num += 10 : %d\n", num);


    } else if(pid == 0) {
        // 当前是子进程
        printf("i am child process, pid : %d, ppid : %d\n", getpid(),getppid());
       
        printf("child num : %d\n", num);
        num += 100;
        printf("child num += 100 : %d\n", num);
    }

    // for循环
    for(int i = 0; i < 3; i++) {
        printf("i : %d , pid : %d\n", i , getpid());
        sleep(1);
    }

    return 0;
}

/*
实际上，更准确来说，Linux 的 fork() 使用是通过写时拷贝 (copy- on-write) 实现。
写时拷贝是一种可以推迟甚至避免拷贝数据的技术。
内核此时并不复制整个进程的地址空间，而是让父子进程共享同一个地址空间。
只用在需要写入的时候才会复制地址空间，从而使各个进行拥有各自的地址空间。
也就是说，资源的复制是在需要写入的时候才会进行，在此之前，只有以只读方式共享。
注意：fork之后父子进程共享文件，
fork产生的子进程与父进程相同的文件文件描述符指向相同的文件表，引用计数增加，共享文件偏移指针。
*/

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

# 4-父子进程虚拟地址空间情况

# 5-父子进程关系及GDB多进程调试

hello

#include <stdio.h>
#include <unistd.h>

int main() {

    printf("begin\n");

    if(fork() > 0) {

        printf("我是父进程：pid = %d, ppid = %d\n", getpid(), getppid());

        int i;
        for(i = 0; i < 10; i++) {
            printf("i = %d\n", i);
            sleep(1);
        }

    } else {

        printf("我是子进程：pid = %d, ppid = %d\n", getpid(), getppid());
        
        int j;
        for(j = 0; j < 10; j++) {
            printf("j = %d\n", j);
            sleep(1);
        }

    }

    return 0;
}

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

# 6-exec函数族

# 1.`execl.c`

/*  
    #include <unistd.h>
    int execl(const char *path, const char *arg, ...);
        - 参数：
            - path:需要指定的执行的文件的路径或者名称
                a.out /home/nowcoder/a.out 推荐使用绝对路径
                ./a.out hello world

            - arg:是执行可执行文件所需要的参数列表
                第一个参数一般没有什么作用，为了方便，一般写的是执行的程序的名称
                从第二个参数开始往后，就是程序执行所需要的的参数列表。
                参数最后需要以NULL结束（哨兵）

        - 返回值：
            只有当调用失败，才会有返回值，返回-1，并且设置errno
            如果调用成功，没有返回值。

*/
#include <unistd.h>
#include <stdio.h>

int main() {


    // 创建一个子进程，在子进程中执行exec函数族中的函数
    pid_t pid = fork();

    if(pid > 0) {
        // 父进程
        printf("i am parent process, pid : %d\n",getpid());
        sleep(1);
    }else if(pid == 0) {
        // 子进程
        // execl("hello","hello",NULL);

        execl("/bin/ps", "ps", "aux", NULL);
        perror("execl");
        printf("i am child process, pid : %d\n", getpid());

    }

    for(int i = 0; i < 3; i++) {
        printf("i = %d, pid = %d\n", i, getpid());
    }


    return 0;
}

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

# 2.`execlp.c`

/*  
    #include <unistd.h>
    int execlp(const char *file, const char *arg, ... );
        - 会到环境变量中查找指定的可执行文件，如果找到了就执行，找不到就执行不成功。
        - 参数：
            - file:需要执行的可执行文件的文件名
                a.out
                ps

            - arg:是执行可执行文件所需要的参数列表
                第一个参数一般没有什么作用，为了方便，一般写的是执行的程序的名称
                从第二个参数开始往后，就是程序执行所需要的的参数列表。
                参数最后需要以NULL结束（哨兵）

        - 返回值：
            只有当调用失败，才会有返回值，返回-1，并且设置errno
            如果调用成功，没有返回值。


        int execv(const char *path, char *const argv[]);
        argv是需要的参数的一个字符串数组
        char * argv[] = {"ps", "aux", NULL};
        execv("/bin/ps", argv);

        int execve(const char *filename, char *const argv[], char *const envp[]);
        char * envp[] = {"/home/nowcoder", "/home/bbb", "/home/aaa"};


*/
#include <unistd.h>
#include <stdio.h>

int main() {


    // 创建一个子进程，在子进程中执行exec函数族中的函数
    pid_t pid = fork();

    if(pid > 0) {
        // 父进程
        printf("i am parent process, pid : %d\n",getpid());
        sleep(1);
    }else if(pid == 0) {
        // 子进程
        execlp("ps", "ps", "aux", NULL);

        printf("i am child process, pid : %d\n", getpid());

    }

    for(int i = 0; i < 3; i++) {
        printf("i = %d, pid = %d\n", i, getpid());
    }


    return 0;
}

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
53
54
55
56
57

# 3.`hello.c`

#include <stdio.h>

int main() {    

    printf("hello, world\n");

    return 0;
}

1
2
3
4
5
6
7
8

# 7-进程退出和孤儿进程和僵尸进程

# 1.`exit.c`

/*
    #include <stdlib.h>
    void exit(int status);

    #include <unistd.h>
    void _exit(int status);

    status参数：是进程退出时的一个状态信息。父进程回收子进程资源的时候可以获取到。
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {

    printf("hello\n");
    printf("world");

    // exit(0);
    _exit(0);
    
    return 0;
}

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

# 2.orphan.c

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>

int main() {

    // 创建子进程
    pid_t pid = fork();

    // 判断是父进程还是子进程
    if(pid > 0) {

        printf("i am parent process, pid : %d, ppid : %d\n", getpid(), getppid());

    } else if(pid == 0) {
        sleep(1);
        // 当前是子进程
        printf("i am child process, pid : %d, ppid : %d\n", getpid(),getppid());
       
    }

    // for循环
    for(int i = 0; i < 3; i++) {
        printf("i : %d , pid : %d\n", i , getpid());
    }

    return 0;
}

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

# 3.zombie.c

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>

int main() {

    // 创建子进程
    pid_t pid = fork();

    // 判断是父进程还是子进程
    if(pid > 0) {
        while(1) {
            printf("i am parent process, pid : %d, ppid : %d\n", getpid(), getppid());
            sleep(1);
        }

    } else if(pid == 0) {
        // 当前是子进程
        printf("i am child process, pid : %d, ppid : %d\n", getpid(),getppid());
       
    }

    // for循环
    for(int i = 0; i < 3; i++) {
        printf("i : %d , pid : %d\n", i , getpid());
    }

    return 0;
}

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

# 8.wait函数

# 1.wait.c

/*
    #include <sys/types.h>
    #include <sys/wait.h>
    pid_t wait(int *wstatus);
        功能：等待任意一个子进程结束，如果任意一个子进程结束了，次函数会回收子进程的资源。
        参数：int *wstatus
            进程退出时的状态信息，传入的是一个int类型的地址，传出参数。
        返回值：
            - 成功：返回被回收的子进程的id
            - 失败：-1 (所有的子进程都结束，调用函数失败)

    调用wait函数的进程会被挂起（阻塞），直到它的一个子进程退出或者收到一个不能被忽略的信号时才被唤醒（相当于继续往下执行）
    如果没有子进程了，函数立刻返回，返回-1；如果子进程都已经结束了，也会立即返回，返回-1.

*/
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>


int main() {

    // 有一个父进程，创建5个子进程（兄弟）
    pid_t pid;

    // 创建5个子进程
    for(int i = 0; i < 5; i++) {
        pid = fork();
        if(pid == 0) {
            break;
        }
    }

    if(pid > 0) {
        // 父进程
        while(1) {
            printf("parent, pid = %d\n", getpid());

            // int ret = wait(NULL);
            int st;
            int ret = wait(&st);

            if(ret == -1) {
                break;
            }

            if(WIFEXITED(st)) {
                // 是不是正常退出
                printf("退出的状态码：%d\n", WEXITSTATUS(st));
            }
            if(WIFSIGNALED(st)) {
                // 是不是异常终止
                printf("被哪个信号干掉了：%d\n", WTERMSIG(st));
            }

            printf("child die, pid = %d\n", ret);

            sleep(1);
        }

    } else if (pid == 0){
        // 子进程
         while(1) {
            printf("child, pid = %d\n",getpid());    
            sleep(1);       
         }

        exit(0);
    }

    return 0; // exit(0)
}

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

# 9.waitpid函数

# 1.`waitpid.c`

/*
    #include <sys/types.h>
    #include <sys/wait.h>
    pid_t waitpid(pid_t pid, int *wstatus, int options);
        功能：回收指定进程号的子进程，可以设置是否阻塞。
        参数：
            - pid:
                pid > 0 : 某个子进程的pid
                pid = 0 : 回收当前进程组的所有子进程    
                pid = -1 : 回收所有的子进程，相当于 wait()  （最常用）
                pid < -1 : 某个进程组的组id的绝对值，回收指定进程组中的子进程
            - options：设置阻塞或者非阻塞
                0 : 阻塞
                WNOHANG : 非阻塞
            - 返回值：
                > 0 : 返回子进程的id
                = 0 : options=WNOHANG, 表示还有子进程或者
                = -1 ：错误，或者没有子进程了
*/
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

int main() {

    // 有一个父进程，创建5个子进程（兄弟）
    pid_t pid;

    // 创建5个子进程
    for(int i = 0; i < 5; i++) {
        pid = fork();
        if(pid == 0) {
            break;
        }
    }

    if(pid > 0) {
        // 父进程
        while(1) {
            printf("parent, pid = %d\n", getpid());
            sleep(1);

            int st;
            // int ret = waitpid(-1, &st, 0);
            int ret = waitpid(-1, &st, WNOHANG);

            if(ret == -1) {
                break;
            } else if(ret == 0) {
                // 说明还有子进程存在
                continue;
            } else if(ret > 0) {

                if(WIFEXITED(st)) {
                    // 是不是正常退出
                    printf("退出的状态码：%d\n", WEXITSTATUS(st));
                }
                if(WIFSIGNALED(st)) {
                    // 是不是异常终止
                    printf("被哪个信号干掉了：%d\n", WTERMSIG(st));
                }

                printf("child die, pid = %d\n", ret);
            }
           
        }

    } else if (pid == 0){
        // 子进程
         while(1) {
            printf("child, pid = %d\n",getpid());    
            sleep(1);       
         }
        exit(0);
    }

    return 0; 
}

# 10.进程间通信简介

# 11.匿名管道概述

# 12.父子进程通过匿名管道通信

# 1.fpathconf.c

#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {

    int pipefd[2];

    int ret = pipe(pipefd);

    // 获取管道的大小
    long size = fpathconf(pipefd[0], _PC_PIPE_BUF);

    printf("pipe size : %ld\n", size);

    return 0;
}

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

# 2.pipe.c

/*
    #include <unistd.h>
    int pipe(int pipefd[2]);
        功能：创建一个匿名管道，用来进程间通信。
        参数：int pipefd[2] 这个数组是一个传出参数。
            pipefd[0] 对应的是管道的读端
            pipefd[1] 对应的是管道的写端
        返回值：
            成功 0
            失败 -1

    管道默认是阻塞的：如果管道中没有数据，read阻塞，如果管道满了，write阻塞

    注意：匿名管道只能用于具有关系的进程之间的通信（父子进程，兄弟进程）
*/

// 子进程发送数据给父进程，父进程读取到数据输出
#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {

    // 在fork之前创建管道
    int pipefd[2];
    int ret = pipe(pipefd);
    if(ret == -1) {
        perror("pipe");
        exit(0);
    }

    // 创建子进程
    pid_t pid = fork();
    if(pid > 0) {
        // 父进程
        printf("i am parent process, pid : %d\n", getpid());

        // 关闭写端
        close(pipefd[1]);
        
        // 从管道的读取端读取数据
        char buf[1024] = {0};
        while(1) {
            int len = read(pipefd[0], buf, sizeof(buf));
            printf("parent recv : %s, pid : %d\n", buf, getpid());
            
            // 向管道中写入数据
            //char * str = "hello,i am parent";
            //write(pipefd[1], str, strlen(str));
            //sleep(1);
        }

    } else if(pid == 0){
        // 子进程
        printf("i am child process, pid : %d\n", getpid());
        // 关闭读端
        close(pipefd[0]);
        char buf[1024] = {0};
        while(1) {
            // 向管道中写入数据
            char * str = "hello,i am child";
            write(pipefd[1], str, strlen(str));
            //sleep(1);

            // int len = read(pipefd[0], buf, sizeof(buf));
            // printf("child recv : %s, pid : %d\n", buf, getpid());
            // bzero(buf, 1024);
        }
        
    }
    return 0;
}

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

# 13.匿名管道通信案例

# 1.parent-child-ipc.c

/*
    实现 ps aux | grep xxx 父子进程间通信
    
    子进程： ps aux, 子进程结束后，将数据发送给父进程
    父进程：获取到数据，过滤
    pipe()
    execlp()
    子进程将标准输出 stdout_fileno 重定向到管道的写端。  dup2
*/

#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <wait.h>

int main() {

    // 创建一个管道
    int fd[2];
    int ret = pipe(fd);

    if(ret == -1) {
        perror("pipe");
        exit(0);
    }

    // 创建子进程
    pid_t pid = fork();

    if(pid > 0) {
        // 父进程
        // 关闭写端
        close(fd[1]);
        // 从管道中读取
        char buf[1024] = {0};

        int len = -1;
        while((len = read(fd[0], buf, sizeof(buf) - 1)) > 0) {
            // 过滤数据输出
            printf("%s", buf);
            memset(buf, 0, 1024);
        }

        wait(NULL);

    } else if(pid == 0) {
        // 子进程
        // 关闭读端
        close(fd[0]);

        // 文件描述符的重定向 stdout_fileno -> fd[1]
        dup2(fd[1], STDOUT_FILENO);
        // 执行 ps aux
        execlp("ps", "ps", "aux", NULL);
        perror("execlp");
        exit(0);
    } else {
        perror("fork");
        exit(0);
    }


    return 0;
}

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66

# 14.管道的读写特点和管道设置为非阻塞

# 管道的读写特点.txt.

管道的读写特点：
使用管道时，需要注意以下几种特殊的情况（假设都是阻塞I/O操作）
1.所有的指向管道写端的文件描述符都关闭了（管道写端引用计数为0），有进程从管道的读端
读数据，那么管道中剩余的数据被读取以后，再次read会返回0，就像读到文件末尾一样。

2.如果有指向管道写端的文件描述符没有关闭（管道的写端引用计数大于0），而持有管道写端的进程
也没有往管道中写数据，这个时候有进程从管道中读取数据，那么管道中剩余的数据被读取后，
再次read会阻塞，直到管道中有数据可以读了才读取数据并返回。

3.如果所有指向管道读端的文件描述符都关闭了（管道的读端引用计数为0），这个时候有进程
向管道中写数据，那么该进程会收到一个信号SIGPIPE, 通常会导致进程异常终止。

4.如果有指向管道读端的文件描述符没有关闭（管道的读端引用计数大于0），而持有管道读端的进程
也没有从管道中读数据，这时有进程向管道中写数据，那么在管道被写满的时候再次write会阻塞，
直到管道中有空位置才能再次写入数据并返回。

总结：
    读管道：
        管道中有数据，read返回实际读到的字节数。
        管道中无数据：
            写端被全部关闭，read返回0（相当于读到文件的末尾）
            写端没有完全关闭，read阻塞等待

    写管道：
        管道读端全部被关闭，进程异常终止（进程收到SIGPIPE信号）
        管道读端没有全部关闭：
            管道已满，write阻塞
            管道没有满，write将数据写入，并返回实际写入的字节数

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

# 2.noblock.c

#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
/*
    设置管道非阻塞
    int flags = fcntl(fd[0], F_GETFL);  // 获取原来的flag
    flags |= O_NONBLOCK;            // 修改flag的值
    fcntl(fd[0], F_SETFL, flags);   // 设置新的flag
*/
int main() {

    // 在fork之前创建管道
    int pipefd[2];
    int ret = pipe(pipefd);
    if(ret == -1) {
        perror("pipe");
        exit(0);
    }

    // 创建子进程
    pid_t pid = fork();
    if(pid > 0) {
        // 父进程
        printf("i am parent process, pid : %d\n", getpid());

        // 关闭写端
        close(pipefd[1]);
        
        // 从管道的读取端读取数据
        char buf[1024] = {0};

        int flags = fcntl(pipefd[0], F_GETFL);  // 获取原来的flag
        flags |= O_NONBLOCK;            // 修改flag的值
        fcntl(pipefd[0], F_SETFL, flags);   // 设置新的flag

        while(1) {
            int len = read(pipefd[0], buf, sizeof(buf));
            printf("len : %d\n", len);
            printf("parent recv : %s, pid : %d\n", buf, getpid());
            memset(buf, 0, 1024);
            sleep(1);
        }

    } else if(pid == 0){
        // 子进程
        printf("i am child process, pid : %d\n", getpid());
        // 关闭读端
        close(pipefd[0]);
        char buf[1024] = {0};
        while(1) {
            // 向管道中写入数据
            char * str = "hello,i am child";
            write(pipefd[1], str, strlen(str));
            sleep(5);
        }
        
    }
    return 0;
}

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
53
54
55
56
57
58
59
60
61
62
63
64
65

# 15.有名管道介绍及使用

# .mkfifo.c

/*
    创建fifo文件
    1.通过命令： mkfifo 名字
    2.通过函数：int mkfifo(const char *pathname, mode_t mode);

    #include <sys/types.h>
    #include <sys/stat.h>
    int mkfifo(const char *pathname, mode_t mode);
        参数：
            - pathname: 管道名称的路径
            - mode: 文件的权限 和 open 的 mode 是一样的
                    是一个八进制的数
        返回值：成功返回0，失败返回-1，并设置错误号

*/

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <unistd.h>

int main() {


    // 判断文件是否存在
    int ret = access("fifo1", F_OK);
    if(ret == -1) {
        printf("管道不存在，创建管道\n");
        
        ret = mkfifo("fifo1", 0664);

        if(ret == -1) {
            perror("mkfifo");
            exit(0);
        }       

    }

    

    return 0;
}

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

# 2.read.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>

// 从管道中读取数据
int main() {

    // 1.打开管道文件
    int fd = open("test", O_RDONLY);
    if(fd == -1) {
        perror("open");
        exit(0);
    }

    // 读数据
    while(1) {
        char buf[1024] = {0};
        int len = read(fd, buf, sizeof(buf));
        if(len == 0) {
            printf("写端断开连接了...\n");
            break;
        }
        printf("recv buf : %s\n", buf);
    }

    close(fd);

    return 0;
}

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

# 3.write.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>

// 向管道中写数据
/*
    有名管道的注意事项：
        1.一个为只读而打开一个管道的进程会阻塞，直到另外一个进程为只写打开管道
        2.一个为只写而打开一个管道的进程会阻塞，直到另外一个进程为只读打开管道

    读管道：
        管道中有数据，read返回实际读到的字节数
        管道中无数据：
            管道写端被全部关闭，read返回0，（相当于读到文件末尾）
            写端没有全部被关闭，read阻塞等待
    
    写管道：
        管道读端被全部关闭，进行异常终止（收到一个SIGPIPE信号）
        管道读端没有全部关闭：
            管道已经满了，write会阻塞
            管道没有满，write将数据写入，并返回实际写入的字节数。
*/
int main() {

    // 1.判断文件是否存在
    int ret = access("test", F_OK);
    if(ret == -1) {
        printf("管道不存在，创建管道\n");
        
        // 2.创建管道文件
        ret = mkfifo("test", 0664);

        if(ret == -1) {
            perror("mkfifo");
            exit(0);
        }       

    }

    // 3.以只写的方式打开管道
    int fd = open("test", O_WRONLY);
    if(fd == -1) {
        perror("open");
        exit(0);
    }

    // 写数据
    for(int i = 0; i < 100; i++) {
        char buf[1024];
        sprintf(buf, "hello, %d\n", i);
        printf("write data : %s\n", buf);
        write(fd, buf, strlen(buf));
        sleep(1);
    }

    close(fd);

    return 0;
}

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
53
54
55
56
57
58
59
60
61
62
63

# 16.有名管道实现简单版聊天功能

# 1.chatA.c

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>

int main() {

    // 1.判断有名管道文件是否存在
    int ret = access("fifo1", F_OK);
    if(ret == -1) {
        // 文件不存在
        printf("管道不存在，创建对应的有名管道\n");
        ret = mkfifo("fifo1", 0664);
        if(ret == -1) {
            perror("mkfifo");
            exit(0);
        }
    }

    ret = access("fifo2", F_OK);
    if(ret == -1) {
        // 文件不存在
        printf("管道不存在，创建对应的有名管道\n");
        ret = mkfifo("fifo2", 0664);
        if(ret == -1) {
            perror("mkfifo");
            exit(0);
        }
    }

    // 2.以只写的方式打开管道fifo1
    int fdw = open("fifo1", O_WRONLY);
    if(fdw == -1) {
        perror("open");
        exit(0);
    }
    printf("打开管道fifo1成功，等待写入...\n");
    // 3.以只读的方式打开管道fifo2
    int fdr = open("fifo2", O_RDONLY);
    if(fdr == -1) {
        perror("open");
        exit(0);
    }
    printf("打开管道fifo2成功，等待读取...\n");

    char buf[128];

    // 4.循环的写读数据
    while(1) {
        memset(buf, 0, 128);
        // 获取标准输入的数据
        fgets(buf, 128, stdin);
        // 写数据
        ret = write(fdw, buf, strlen(buf));
        if(ret == -1) {
            perror("write");
            exit(0);
        }

        // 5.读管道数据
        memset(buf, 0, 128);
        ret = read(fdr, buf, 128);
        if(ret <= 0) {
            perror("read");
            break;
        }
        printf("buf: %s\n", buf);
    }

    // 6.关闭文件描述符
    close(fdr);
    close(fdw);

    return 0;
}

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

# 2.chatB.c

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>

int main() {

    // 1.判断有名管道文件是否存在
    int ret = access("fifo1", F_OK);
    if(ret == -1) {
        // 文件不存在
        printf("管道不存在，创建对应的有名管道\n");
        ret = mkfifo("fifo1", 0664);
        if(ret == -1) {
            perror("mkfifo");
            exit(0);
        }
    }

    ret = access("fifo2", F_OK);
    if(ret == -1) {
        // 文件不存在
        printf("管道不存在，创建对应的有名管道\n");
        ret = mkfifo("fifo2", 0664);
        if(ret == -1) {
            perror("mkfifo");
            exit(0);
        }
    }

    // 2.以只读的方式打开管道fifo1
    int fdr = open("fifo1", O_RDONLY);
    if(fdr == -1) {
        perror("open");
        exit(0);
    }
    printf("打开管道fifo1成功，等待读取...\n");
    // 3.以只写的方式打开管道fifo2
    int fdw = open("fifo2", O_WRONLY);
    if(fdw == -1) {
        perror("open");
        exit(0);
    }
    printf("打开管道fifo2成功，等待写入...\n");

    char buf[128];

    // 4.循环的读写数据
    while(1) {
        // 5.读管道数据
        memset(buf, 0, 128);
        ret = read(fdr, buf, 128);
        if(ret <= 0) {
            perror("read");
            break;
        }
        printf("buf: %s\n", buf);

        memset(buf, 0, 128);
        // 获取标准输入的数据
        fgets(buf, 128, stdin);
        // 写数据
        ret = write(fdw, buf, strlen(buf));
        if(ret == -1) {
            perror("write");
            exit(0);
        }
    }

    // 6.关闭文件描述符
    close(fdr);
    close(fdw);

    return 0;
}

# 17.内存映射(1)

# 1.mmap-parent-child-ipc.c

/*
    #include <sys/mman.h>
    void *mmap(void *addr, size_t length, int prot, int flags,int fd, off_t offset);
        - 功能：将一个文件或者设备的数据映射到内存中
        - 参数：
            - void *addr: NULL, 由内核指定
            - length : 要映射的数据的长度，这个值不能为0。建议使用文件的长度。
                    获取文件的长度：stat lseek
            - prot : 对申请的内存映射区的操作权限
                -PROT_EXEC ：可执行的权限
                -PROT_READ ：读权限
                -PROT_WRITE ：写权限
                -PROT_NONE ：没有权限
                要操作映射内存，必须要有读的权限。
                PROT_READ、PROT_READ|PROT_WRITE
            - flags :
                - MAP_SHARED : 映射区的数据会自动和磁盘文件进行同步，进程间通信，必须要设置这个选项
                - MAP_PRIVATE ：不同步，内存映射区的数据改变了，对原来的文件不会修改，会重新创建一个新的文件。（copy on write）
            - fd: 需要映射的那个文件的文件描述符
                - 通过open得到，open的是一个磁盘文件
                - 注意：文件的大小不能为0，open指定的权限不能和prot参数有冲突。
                    prot: PROT_READ                open:只读/读写 
                    prot: PROT_READ | PROT_WRITE   open:读写
            - offset：偏移量，一般不用。必须指定的是4k的整数倍，0表示不便宜。
        - 返回值：返回创建的内存的首地址
            失败返回MAP_FAILED，(void *) -1

    int munmap(void *addr, size_t length);
        - 功能：释放内存映射
        - 参数：
            - addr : 要释放的内存的首地址
            - length : 要释放的内存的大小，要和mmap函数中的length参数的值一样。
*/

/*
    使用内存映射实现进程间通信：
    1.有关系的进程（父子进程）
        - 还没有子进程的时候
            - 通过唯一的父进程，先创建内存映射区
        - 有了内存映射区以后，创建子进程
        - 父子进程共享创建的内存映射区
    
    2.没有关系的进程间通信
        - 准备一个大小不是0的磁盘文件
        - 进程1 通过磁盘文件创建内存映射区
            - 得到一个操作这块内存的指针
        - 进程2 通过磁盘文件创建内存映射区
            - 得到一个操作这块内存的指针
        - 使用内存映射区通信

    注意：内存映射区通信，是非阻塞。
*/

#include <stdio.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <wait.h>

// 作业:使用内存映射实现没有关系的进程间的通信。
int main() {

    // 1.打开一个文件
    int fd = open("test.txt", O_RDWR);
    int size = lseek(fd, 0, SEEK_END);  // 获取文件的大小

    // 2.创建内存映射区
    void *ptr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if(ptr == MAP_FAILED) {
        perror("mmap");
        exit(0);
    }

    // 3.创建子进程
    pid_t pid = fork();
    if(pid > 0) {
        wait(NULL);
        // 父进程
        char buf[64];
        strcpy(buf, (char *)ptr);
        printf("read data : %s\n", buf);
       
    }else if(pid == 0){
        // 子进程
        strcpy((char *)ptr, "nihao a, son!!!");
    }

    // 关闭内存映射区
    munmap(ptr, size);

    return 0;
}

# test.txt

nihao a, son!!! world,helloworld,helloworld,helloworld,helloworld,helloworld,helloworld,helloworld,helloworld,helloworld,helloworld,helloworld,helloworld,helloworld.

# 18-内存映射(2)

# 1.copy.c

// 使用内存映射实现文件拷贝的功能
/*
    思路：
        1.对原始的文件进行内存映射
        2.创建一个新文件（拓展该文件）
        3.把新文件的数据映射到内存中
        4.通过内存拷贝将第一个文件的内存数据拷贝到新的文件内存中
        5.释放资源
*/
#include <stdio.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>

int main() {

    // 1.对原始的文件进行内存映射
    int fd = open("english.txt", O_RDWR);
    if(fd == -1) {
        perror("open");
        exit(0);
    }

    // 获取原始文件的大小
    int len = lseek(fd, 0, SEEK_END);

    // 2.创建一个新文件（拓展该文件）
    int fd1 = open("cpy.txt", O_RDWR | O_CREAT, 0664);
    if(fd1 == -1) {
        perror("open");
        exit(0);
    }
    
    // 对新创建的文件进行拓展
    truncate("cpy.txt", len);
    write(fd1, " ", 1);

    // 3.分别做内存映射
    void * ptr = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    void * ptr1 = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd1, 0);

    if(ptr == MAP_FAILED) {
        perror("mmap");
        exit(0);
    }

    if(ptr1 == MAP_FAILED) {
        perror("mmap");
        exit(0);
    }

    // 内存拷贝
    memcpy(ptr1, ptr, len);
    
    // 释放资源
    munmap(ptr1, len);
    munmap(ptr, len);

    close(fd1);
    close(fd);

    return 0;
}

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

# cpy.txt和english.txt

见文件

# mmap-anon.c

/*
    匿名映射：不需要文件实体进程一个内存映射
*/

#include <stdio.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <sys/wait.h>

int main() {

    // 1.创建匿名内存映射区
    int len = 4096;
    void * ptr = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
    if(ptr == MAP_FAILED) {
        perror("mmap");
        exit(0);
    }

    // 父子进程间通信
    pid_t pid = fork();

    if(pid > 0) {
        // 父进程
        strcpy((char *) ptr, "hello, world");
        wait(NULL);
    }else if(pid == 0) {
        // 子进程
        sleep(1);
        printf("%s\n", (char *)ptr);
    }

    // 释放内存映射区
    int ret = munmap(ptr, len);

    if(ret == -1) {
        perror("munmap");
        exit(0);
    }
    return 0;
}

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

# 内存映射的注意事项.txt

1.如果对mmap的返回值(ptr)做++操作(ptr++), munmap是否能够成功?
void * ptr = mmap(...);
ptr++;  可以对其进行++操作
munmap(ptr, len);   // 错误,要保存地址

2.如果open时O_RDONLY, mmap时prot参数指定PROT_READ | PROT_WRITE会怎样?
错误，返回MAP_FAILED
open()函数中的权限建议和prot参数的权限保持一致。

3.如果文件偏移量为1000会怎样?
偏移量必须是4K的整数倍，返回MAP_FAILED

4.mmap什么情况下会调用失败?
    - 第二个参数：length = 0
    - 第三个参数：prot
        - 只指定了写权限
        - prot PROT_READ | PROT_WRITE
          第5个参数fd 通过open函数时指定的 O_RDONLY / O_WRONLY

5.可以open的时候O_CREAT一个新文件来创建映射区吗?
    - 可以的，但是创建的文件的大小如果为0的话，肯定不行
    - 可以对新的文件进行扩展
        - lseek()
        - truncate()

6.mmap后关闭文件描述符，对mmap映射有没有影响？
    int fd = open("XXX");
    mmap(,,,,fd,0);
    close(fd); 
    映射区还存在，创建映射区的fd被关闭，没有任何影响。

7.对ptr越界操作会怎样？
void * ptr = mmap(NULL, 100,,,,,);
4K
越界操作操作的是非法的内存 -> 段错误

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

# 19.信号概述

# 20.`kill`、`raise`、`abort`函数

# 1.core.c

#include <stdio.h>
#include <string.h>

int main() {

    char * buf;

    strcpy(buf, "hello");

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11

# 2.kill.c

/*  
    #include <sys/types.h>
    #include <signal.h>

    int kill(pid_t pid, int sig);
        - 功能：给任何的进程或者进程组pid, 发送任何的信号 sig
        - 参数：
            - pid ：
                > 0 : 将信号发送给指定的进程
                = 0 : 将信号发送给当前的进程组
                = -1 : 将信号发送给每一个有权限接收这个信号的进程
                < -1 : 这个pid=某个进程组的ID取反 （-12345）
            - sig : 需要发送的信号的编号或者是宏值，0表示不发送任何信号

        kill(getppid(), 9);
        kill(getpid(), 9);
        
    int raise(int sig);
        - 功能：给当前进程发送信号
        - 参数：
            - sig : 要发送的信号
        - 返回值：
            - 成功 0
            - 失败 非0
        kill(getpid(), sig);   

    void abort(void);
        - 功能： 发送SIGABRT信号给当前的进程，杀死当前进程
        kill(getpid(), SIGABRT);
*/

#include <stdio.h>
#include <sys/types.h>
#include <signal.h>
#include <unistd.h>

int main() {

    pid_t pid = fork();

    if(pid == 0) {
        // 子进程
        int i = 0;
        for(i = 0; i < 5; i++) {
            printf("child process\n");
            sleep(1);
        }

    } else if(pid > 0) {
        // 父进程
        printf("parent process\n");
        sleep(2);
        printf("kill child process now\n");
        kill(pid, SIGINT);
    }

    return 0;
}

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
53
54
55
56
57
58
59

# 21.alarm函数

# 1.alarm.c

/*
    #include <unistd.h>
    unsigned int alarm(unsigned int seconds);
        - 功能：设置定时器（闹钟）。函数调用，开始倒计时，当倒计时为0的时候，
                函数会给当前的进程发送一个信号：SIGALARM
        - 参数：
            seconds: 倒计时的时长，单位：秒。如果参数为0，定时器无效（不进行倒计时，不发信号）。
                    取消一个定时器，通过alarm(0)。
        - 返回值：
            - 之前没有定时器，返回0
            - 之前有定时器，返回之前的定时器剩余的时间

    - SIGALARM ：默认终止当前的进程，每一个进程都有且只有唯一的一个定时器。
        alarm(10);  -> 返回0
        过了1秒
        alarm(5);   -> 返回9

    alarm(100) -> 该函数是不阻塞的
*/

#include <stdio.h>
#include <unistd.h>

int main() {

    int seconds = alarm(5);
    printf("seconds = %d\n", seconds);  // 0

    sleep(2);
    seconds = alarm(2);    // 不阻塞
    printf("seconds = %d\n", seconds);  // 3

    while(1) {
    }

    return 0;
}

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

# 2.alarm1.c

// 1秒钟电脑能数多少个数？
#include <stdio.h>
#include <unistd.h>

/*
    实际的时间 = 内核时间 + 用户时间 + 消耗的时间
    进行文件IO操作的时候比较浪费时间

    定时器，与进程的状态无关（自然定时法）。无论进程处于什么状态，alarm都会计时。
*/

int main() {    

    alarm(1);

    int i = 0;
    while(1) {
        printf("%i\n", i++);
    }

    return 0;
}

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

# 22.setitimer函数

# 1.setitimer.c

/*
    #include <sys/time.h>
    int setitimer(int which, const struct itimerval *new_value,
                        struct itimerval *old_value);
    
        - 功能：设置定时器（闹钟）。可以替代alarm函数。精度微妙us，可以实现周期性定时
        - 参数：
            - which : 定时器以什么时间计时
              ITIMER_REAL: 真实时间，时间到达，发送 SIGALRM   常用
              ITIMER_VIRTUAL: 用户时间，时间到达，发送 SIGVTALRM
              ITIMER_PROF: 以该进程在用户态和内核态下所消耗的时间来计算，时间到达，发送 SIGPROF

            - new_value: 设置定时器的属性
            
                struct itimerval {      // 定时器的结构体
                struct timeval it_interval;  // 每个阶段的时间，间隔时间
                struct timeval it_value;     // 延迟多长时间执行定时器
                };

                struct timeval {        // 时间的结构体
                    time_t      tv_sec;     //  秒数     
                    suseconds_t tv_usec;    //  微秒    
                };

            过10秒后，每个2秒定时一次
           
            - old_value ：记录上一次的定时的时间参数，一般不使用，指定NULL
        
        - 返回值：
            成功 0
            失败 -1 并设置错误号
*/

#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>

// 过3秒以后，每隔2秒钟定时一次
int main() {

    struct itimerval new_value;

    // 设置间隔的时间
    new_value.it_interval.tv_sec = 2;
    new_value.it_interval.tv_usec = 0;

    // 设置延迟的时间,3秒之后开始第一次定时
    new_value.it_value.tv_sec = 3;
    new_value.it_value.tv_usec = 0;


    int ret = setitimer(ITIMER_REAL, &new_value, NULL); // 非阻塞的
    printf("定时器开始了...\n");

    if(ret == -1) {
        perror("setitimer");
        exit(0);
    }

    getchar();

    return 0;
}

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
53
54
55
56
57
58
59
60
61
62
63

# 23-signal 信号捕捉函数_x264

# 1.signal.c

/*
    #include <signal.h>
    typedef void (*sighandler_t)(int);
    sighandler_t signal(int signum, sighandler_t handler);
        - 功能：设置某个信号的捕捉行为
        - 参数：
            - signum: 要捕捉的信号
            - handler: 捕捉到信号要如何处理
                - SIG_IGN ： 忽略信号
                - SIG_DFL ： 使用信号默认的行为
                - 回调函数 :  这个函数是内核调用，程序员只负责写，捕捉到信号后如何去处理信号。
                回调函数：
                    - 需要程序员实现，提前准备好的，函数的类型根据实际需求，看函数指针的定义
                    - 不是程序员调用，而是当信号产生，由内核调用
                    - 函数指针是实现回调的手段，函数实现之后，将函数名放到函数指针的位置就可以了。

        - 返回值：
            成功，返回上一次注册的信号处理函数的地址。第一次调用返回NULL
            失败，返回SIG_ERR，设置错误号
            
    SIGKILL SIGSTOP不能被捕捉，不能被忽略。
*/

#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>

void myalarm(int num) {
    printf("捕捉到了信号的编号是：%d\n", num);
    printf("xxxxxxx\n");
}

// 过3秒以后，每隔2秒钟定时一次
int main() {

    // 注册信号捕捉
    // signal(SIGALRM, SIG_IGN);
    // signal(SIGALRM, SIG_DFL);
    // void (*sighandler_t)(int); 函数指针，int类型的参数表示捕捉到的信号的值。
    signal(SIGALRM, myalarm);

    struct itimerval new_value;

    // 设置间隔的时间
    new_value.it_interval.tv_sec = 2;
    new_value.it_interval.tv_usec = 0;

    // 设置延迟的时间,3秒之后开始第一次定时
    new_value.it_value.tv_sec = 3;
    new_value.it_value.tv_usec = 0;

    int ret = setitimer(ITIMER_REAL, &new_value, NULL); // 非阻塞的
    printf("定时器开始了...\n");

    if(ret == -1) {
        perror("setitimer");
        exit(0);
    }

    getchar();

    return 0;
}

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
53
54
55
56
57
58
59
60
61
62
63
64

# 24-信号集及相关函数_x264

# 25-`sigprocmask`函数使用_x264

# 1.sigprocmask.c

/*
    int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
        - 功能：将自定义信号集中的数据设置到内核中（设置阻塞，解除阻塞，替换）
        - 参数：
            - how : 如何对内核阻塞信号集进行处理
                SIG_BLOCK: 将用户设置的阻塞信号集添加到内核中，内核中原来的数据不变
                    假设内核中默认的阻塞信号集是mask， mask | set
                SIG_UNBLOCK: 根据用户设置的数据，对内核中的数据进行解除阻塞
                    mask &= ~set
                SIG_SETMASK:覆盖内核中原来的值
            
            - set ：已经初始化好的用户自定义的信号集
            - oldset : 保存设置之前的内核中的阻塞信号集的状态，可以是 NULL
        - 返回值：
            成功：0
            失败：-1
                设置错误号：EFAULT、EINVAL

    int sigpending(sigset_t *set);
        - 功能：获取内核中的未决信号集
        - 参数：set,传出参数，保存的是内核中的未决信号集中的信息。
*/

// 编写一个程序，把所有的常规信号（1-31）的未决状态打印到屏幕
// 设置某些信号是阻塞的，通过键盘产生这些信号

#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
#include <unistd.h>

int main() {

    // 设置2、3号信号阻塞
    sigset_t set;
    sigemptyset(&set);
    // 将2号和3号信号添加到信号集中
    sigaddset(&set, SIGINT);
    sigaddset(&set, SIGQUIT);

    // 修改内核中的阻塞信号集
    sigprocmask(SIG_BLOCK, &set, NULL);

    int num = 0;

    while(1) {
        num++;
        // 获取当前的未决信号集的数据
        sigset_t pendingset;
        sigemptyset(&pendingset);
        sigpending(&pendingset);

        // 遍历前32位
        for(int i = 1; i <= 31; i++) {
            if(sigismember(&pendingset, i) == 1) {
                printf("1");
            }else if(sigismember(&pendingset, i) == 0) {
                printf("0");
            }else {
                perror("sigismember");
                exit(0);
            }
        }

        printf("\n");
        sleep(1);
        if(num == 10) {
            // 解除阻塞
            sigprocmask(SIG_UNBLOCK, &set, NULL);
        }

    }


    return 0;
}

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

# 26-sigaction 信号捕捉函数_x264

# .sigaction.c

/*
    #include <signal.h>
    int sigaction(int signum, const struct sigaction *act,
                            struct sigaction *oldact);

        - 功能：检查或者改变信号的处理。信号捕捉
        - 参数：
            - signum : 需要捕捉的信号的编号或者宏值（信号的名称）
            - act ：捕捉到信号之后的处理动作
            - oldact : 上一次对信号捕捉相关的设置，一般不使用，传递NULL
        - 返回值：
            成功 0
            失败 -1

     struct sigaction {
        // 函数指针，指向的函数就是信号捕捉到之后的处理函数
        void     (*sa_handler)(int);
        // 不常用
        void     (*sa_sigaction)(int, siginfo_t *, void *);
        // 临时阻塞信号集，在信号捕捉函数执行过程中，临时阻塞某些信号。
        sigset_t   sa_mask;
        // 使用哪一个信号处理对捕捉到的信号进行处理
        // 这个值可以是0，表示使用sa_handler,也可以是SA_SIGINFO表示使用sa_sigaction
        int        sa_flags;
        // 被废弃掉了
        void     (*sa_restorer)(void);
    };

*/
#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>

void myalarm(int num) {
    printf("捕捉到了信号的编号是：%d\n", num);
    printf("xxxxxxx\n");
}

// 过3秒以后，每隔2秒钟定时一次
int main() {

    struct sigaction act;
    act.sa_flags = 0;
    act.sa_handler = myalarm;
    sigemptyset(&act.sa_mask);  // 清空临时阻塞信号集
   
    // 注册信号捕捉
    sigaction(SIGALRM, &act, NULL);

    struct itimerval new_value;

    // 设置间隔的时间
    new_value.it_interval.tv_sec = 2;
    new_value.it_interval.tv_usec = 0;

    // 设置延迟的时间,3秒之后开始第一次定时
    new_value.it_value.tv_sec = 3;
    new_value.it_value.tv_usec = 0;

    int ret = setitimer(ITIMER_REAL, &new_value, NULL); // 非阻塞的
    printf("定时器开始了...\n");

    if(ret == -1) {
        perror("setitimer");
        exit(0);
    }

    // getchar();
    while(1);

    return 0;
}

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

# 27.SIGCHILD信号

# 1.sigchld.c

/*
    SIGCHLD信号产生的3个条件：
        1.子进程结束
        2.子进程暂停了
        3.子进程继续运行
        都会给父进程发送该信号，父进程默认忽略该信号。
    
    使用SIGCHLD信号解决僵尸进程的问题。
*/

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <signal.h>
#include <sys/wait.h>

void myFun(int num) {
    printf("捕捉到的信号 ：%d\n", num);
    // 回收子进程PCB的资源
    // while(1) {
    //     wait(NULL); 
    // }
    while(1) {
       int ret = waitpid(-1, NULL, WNOHANG);
       if(ret > 0) {
           printf("child die , pid = %d\n", ret);
       } else if(ret == 0) {
           // 说明还有子进程或者
           break;
       } else if(ret == -1) {
           // 没有子进程
           break;
       }
    }
}

int main() {

    // 提前设置好阻塞信号集，阻塞SIGCHLD，因为有可能子进程很快结束，父进程还没有注册完信号捕捉
    sigset_t set;
    sigemptyset(&set);
    sigaddset(&set, SIGCHLD);
    sigprocmask(SIG_BLOCK, &set, NULL);

    // 创建一些子进程
    pid_t pid;
    for(int i = 0; i < 20; i++) {
        pid = fork();
        if(pid == 0) {
            break;
        }
    }

    if(pid > 0) {
        // 父进程

        // 捕捉子进程死亡时发送的SIGCHLD信号
        struct sigaction act;
        act.sa_flags = 0;
        act.sa_handler = myFun;
        sigemptyset(&act.sa_mask);
        sigaction(SIGCHLD, &act, NULL);

        // 注册完信号捕捉以后，解除阻塞
        sigprocmask(SIG_UNBLOCK, &set, NULL);

        while(1) {
            printf("parent process pid : %d\n", getpid());
            sleep(2);
        }
    } else if( pid == 0) {
        // 子进程
        printf("child process pid : %d\n", getpid());
    }

    return 0;
}

# 28.共享内存（1）

# 1.共享内存.c

共享内存相关的函数
#include <sys/ipc.h>
#include <sys/shm.h>

int shmget(key_t key, size_t size, int shmflg);
    - 功能：创建一个新的共享内存段，或者获取一个既有的共享内存段的标识。
        新创建的内存段中的数据都会被初始化为0
    - 参数：
        - key : key_t类型是一个整形，通过这个找到或者创建一个共享内存。
                一般使用16进制表示，非0值
        - size: 共享内存的大小
        - shmflg: 属性
            - 访问权限
            - 附加属性：创建/判断共享内存是不是存在
                - 创建：IPC_CREAT
                - 判断共享内存是否存在： IPC_EXCL , 需要和IPC_CREAT一起使用
                    IPC_CREAT | IPC_EXCL | 0664
        - 返回值：
            失败：-1 并设置错误号
            成功：>0 返回共享内存的引用的ID，后面操作共享内存都是通过这个值。


void *shmat(int shmid, const void *shmaddr, int shmflg);
    - 功能：和当前的进程进行关联
    - 参数：
        - shmid : 共享内存的标识（ID）,由shmget返回值获取
        - shmaddr: 申请的共享内存的起始地址，指定NULL，内核指定
        - shmflg : 对共享内存的操作
            - 读 ： SHM_RDONLY, 必须要有读权限
            - 读写： 0
    - 返回值：
        成功：返回共享内存的首（起始）地址。  失败(void *) -1


int shmdt(const void *shmaddr);
    - 功能：解除当前进程和共享内存的关联
    - 参数：
        shmaddr：共享内存的首地址
    - 返回值：成功 0， 失败 -1

int shmctl(int shmid, int cmd, struct shmid_ds *buf);
    - 功能：对共享内存进行操作。删除共享内存，共享内存要删除才会消失，创建共享内存的进行被销毁了对共享内存是没有任何影响。
    - 参数：
        - shmid: 共享内存的ID
        - cmd : 要做的操作
            - IPC_STAT : 获取共享内存的当前的状态
            - IPC_SET : 设置共享内存的状态
            - IPC_RMID: 标记共享内存被销毁
        - buf：需要设置或者获取的共享内存的属性信息
            - IPC_STAT : buf存储数据
            - IPC_SET : buf中需要初始化数据，设置到内核中
            - IPC_RMID : 没有用，NULL

key_t ftok(const char *pathname, int proj_id);
    - 功能：根据指定的路径名，和int值，生成一个共享内存的key
    - 参数：
        - pathname:指定一个存在的路径
            /home/nowcoder/Linux/a.txt
            / 
        - proj_id: int类型的值，但是这系统调用只会使用其中的1个字节
                   范围 ： 0-255  一般指定一个字符 'a'


问题1：操作系统如何知道一块共享内存被多少个进程关联？
    - 共享内存维护了一个结构体struct shmid_ds 这个结构体中有一个成员 shm_nattch
    - shm_nattach 记录了关联的进程个数

问题2：可不可以对共享内存进行多次删除 shmctl
    - 可以的
    - 因为shmctl 标记删除共享内存，不是直接删除
    - 什么时候真正删除呢?
        当和共享内存关联的进程数为0的时候，就真正被删除
    - 当共享内存的key为0的时候，表示共享内存被标记删除了
        如果一个进程和共享内存取消关联，那么这个进程就不能继续操作这个共享内存。也不能进行关联。

    共享内存和内存映射的区别
    1.共享内存可以直接创建，内存映射需要磁盘文件（匿名映射除外）
    2.共享内存效果更高
    3.内存
        所有的进程操作的是同一块共享内存。
        内存映射，每个进程在自己的虚拟地址空间中有一个独立的内存。
    4.数据安全
        - 进程突然退出
            共享内存还存在
            内存映射区消失
        - 运行进程的电脑死机，宕机了
            数据存在在共享内存中，没有了
            内存映射区的数据 ，由于磁盘文件中的数据还在，所以内存映射区的数据还存在。

    5.生命周期
        - 内存映射区：进程退出，内存映射区销毁
        - 共享内存：进程退出，共享内存还在，标记删除（所有的关联的进程数为0），或者关机
            如果一个进程退出，会自动和共享内存进行取消关联。

# 29.共享内存（2）

# 1.read_shm.c

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <string.h>

int main() {    

    // 1.获取一个共享内存
    int shmid = shmget(100, 0, IPC_CREAT);
    printf("shmid : %d\n", shmid);

    // 2.和当前进程进行关联
    void * ptr = shmat(shmid, NULL, 0);

    // 3.读数据
    printf("%s\n", (char *)ptr);
    
    printf("按任意键继续\n");
    getchar();

    // 4.解除关联
    shmdt(ptr);

    // 5.删除共享内存
    shmctl(shmid, IPC_RMID, NULL);

    return 0;
}

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

# 2.write_shm.c

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <string.h>

int main() {    

    // 1.创建一个共享内存
    int shmid = shmget(100, 4096, IPC_CREAT|0664);
    printf("shmid : %d\n", shmid);
    
    // 2.和当前进程进行关联
    void * ptr = shmat(shmid, NULL, 0);

    char * str = "helloworld";

    // 3.写数据
    memcpy(ptr, str, strlen(str) + 1);

    printf("按任意键继续\n");
    getchar();

    // 4.解除关联
    shmdt(ptr);

    // 5.删除共享内存
    shmctl(shmid, IPC_RMID, NULL);

    return 0;
}

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

# 30.守护进程（1）

# 31.守护进程（2）

# 1.daemon.c

/*
    写一个守护进程，每隔2s获取一下系统时间，将这个时间写入到磁盘文件中。
*/

#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/time.h>
#include <signal.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>

void work(int num) {
    // 捕捉到信号之后，获取系统时间，写入磁盘文件
    time_t tm = time(NULL);
    struct tm * loc = localtime(&tm);
    // char buf[1024];

    // sprintf(buf, "%d-%d-%d %d:%d:%d\n",loc->tm_year,loc->tm_mon
    // ,loc->tm_mday, loc->tm_hour, loc->tm_min, loc->tm_sec);

    // printf("%s\n", buf);

    char * str = asctime(loc);
    int fd = open("time.txt", O_RDWR | O_CREAT | O_APPEND, 0664);
    write(fd ,str, strlen(str));
    close(fd);
}

int main() {

    // 1.创建子进程，退出父进程
    pid_t pid = fork();

    if(pid > 0) {
        exit(0);
    }

    // 2.将子进程重新创建一个会话
    setsid();

    // 3.设置掩码
    umask(022);

    // 4.更改工作目录
    chdir("/home/nowcoder/");

    // 5. 关闭、重定向文件描述符
    int fd = open("/dev/null", O_RDWR);
    dup2(fd, STDIN_FILENO);
    dup2(fd, STDOUT_FILENO);
    dup2(fd, STDERR_FILENO);

    // 6.业务逻辑

    // 捕捉定时信号
    struct sigaction act;
    act.sa_flags = 0;
    act.sa_handler = work;
    sigemptyset(&act.sa_mask);
    sigaction(SIGALRM, &act, NULL);

    struct itimerval val;
    val.it_value.tv_sec = 2;
    val.it_value.tv_usec = 0;
    val.it_interval.tv_sec = 2;
    val.it_interval.tv_usec = 0;

    // 创建定时器
    setitimer(ITIMER_REAL, &val, NULL);

    // 不让进程结束
    while(1) {
        sleep(10);
    }

    return 0;
}

# 第2章-Linux多进程开发

# 目录

# 1-进程概述

# 进程的发展历史

# 1.1.单道、多道程序设计

# 1.2.时间片

# 1.3.并行和并发

# 1.3.PCB

# 目前2min

# 2-进程状态转换

# 3-进程创建

# 4-父子进程虚拟地址空间情况

# 5-父子进程关系及GDB多进程调试

# 6-exec函数族

# 1.execl.c

# 2.execlp.c

# 3.hello.c

# 7-进程退出和孤儿进程和僵尸进程

# 1.exit.c

# 2.orphan.c

# 3.zombie.c

# 8.wait函数

# 1.wait.c

# 9.waitpid函数

# 1.waitpid.c

# 10.进程间通信简介

# 11.匿名管道概述

# 12.父子进程通过匿名管道通信

# 1.fpathconf.c

# 2.pipe.c

# 13.匿名管道通信案例

# 1.parent-child-ipc.c

# 14.管道的读写特点和管道设置为非阻塞

# 管道的读写特点.txt.

# 2.noblock.c

# 15.有名管道介绍及使用

# .mkfifo.c

# 2.read.c

# 3.write.c

# 16.有名管道实现简单版聊天功能

# 1.chatA.c

# 2.chatB.c

# 17.内存映射(1)

# 1.mmap-parent-child-ipc.c

# test.txt

# 18-内存映射(2)

# 1.copy.c

# cpy.txt和english.txt

# mmap-anon.c

# 内存映射的注意事项.txt

# 19.信号概述

# 20.kill、raise、abort函数

# 1.core.c

# 2.kill.c

# 21.alarm函数

# 1.alarm.c

# 2.alarm1.c

# 22.setitimer函数

# 1.setitimer.c

# 23-signal 信号捕捉函数_x264

# 1.signal.c

# 24-信号集及相关函数_x264

# 25-sigprocmask函数使用_x264

# 1.sigprocmask.c

# 26-sigaction 信号捕捉函数_x264

# .sigaction.c

# 27.SIGCHILD信号

# 1.sigchld.c

# 28.共享内存（1）

# 1.共享内存.c

# 29.共享内存（2）

# 1.read_shm.c

# 2.write_shm.c

# 30.守护进程（1）

# 31.守护进程（2）

# 1.daemon.c

# 1.`execl.c`

# 2.`execlp.c`

# 3.`hello.c`

# 1.`exit.c`

# 1.`waitpid.c`

# 20.`kill`、`raise`、`abort`函数

# 25-`sigprocmask`函数使用_x264