5w字总结 Unix系统编程学习笔记（面试向）（Unix环境高级编程/Unix环境程序设计）

一篇朴实无华的Unix系统编程（Unix环境高级编程）学习笔记。

计算的两个部分

具体的的操作

操作的对象

在计算机内部，这两个部分本质都是0和1，最直观的体现就是前缀表达式：

01100000 xxxx xxxx 加 ADD

00100xxx xxxx xxxx 移 MOV

01110000 xxxx xxxx 跳转 JMP

10000000 xxxx xxxx 函数调用 CALL

C语言在执行上述的基本运算操作时主要的依据是两张表：

【注意】

其中一个很重要的原因在于：函数根据不同的数据类型可能存在重载，需要类型来区别。

另外对于结构的定义和对函数的定义是不一样的：

① 结构定义：没有定义变量，定义的是类型；

② 函数定义：根据所定义的函数的返回值类型，参数类型写入符号表。

计算机是如何将0和1对应到内存表和符号表上做具体操作的呢？

主要是通过下面两类语言作为桥梁：

【例】看一个前缀表达式：

01100000 01100000 01100000

​ ADD 96 96

计算的结果为11000000，如果是无符号数则是192，若翻译为有符号数则是-64，所以存在类型的问题；

通过强制类型转换可以避免构造过多的加法器；

C程序中的数据类型包括：

在不同的系统上，这些类型占据的字节长度是不同的，在32 位的系统上：

数据类型的转换优先级主要是按从小到大排序：

double ←— float 高 ↑ long ↑ unsigned ↑ int ←— char，short 低

（一）参数函数（把函数作为参数）

（1）分析Int (*p)(char)类型*

（2） 分析Int *q(char)类型

（二）返回值函数

（3）分析函数类型：int wfa （int f（char））

（4）void signal 函数类型分析

C程序中每一个语句都是对符号表和内存表的处理。

C语言中的函数是对系列指令进行封装

即语句的集合。

1. 顺序指令

对应操作步骤的组合方式，即对基础指令按一定方式组合；

复合指令多次对内存表和符号表的处理，各指令有顺序/依赖关系。

2. 分支跳转指令 —— if…else

注意C语言的if里不允许赋值，所以ST内容在exp后是不变的，但是内存表M会变。

3. 循环跳转语句 —— while

4. 无条件/直接跳转语句 —— goto

goto不被推荐使用，常用于与if结合，一般用在多个循环的出口。

最简单且常见的替代方式就是用do…while(0)中需要跳转的地方设置break来替代goto。

C程序本质上是字符序列，执行程序需要将字符序列转化成语法树；

定义是由第一个定义和后续定义构成的，通过递归实现上下文无关文法。

什么是函数？

从集合A到集合B的映射 f(A)->B

【例】Int f( char a ) : f是一个变量—>类型（集合），该函数就类型char –> int的映射。

使用函数可以方便代码的复用，减小人工的工作量，但是从某些方面来看并不会让程序的执行变的更为高效。

主要是因为函数调用会产生额外的运算操作（取址，取值，传参，以及有可能的上下文切换等）。

回调函数的一个点

我们可以把C中的struct（结构体）类比C++中的class（类）：

通常情况下：

假如g是函数名，c是函数里的一个变量，那么c存储在什么位置呢？

首先，不可能存储在g对应的代码段中，因为这些代码都是被操作系统要求成只读而不可更改的。

存在栈中，涉及到函数集合（Activation Record）。

在栈中函数的调用叫做函数激活，也称为栈帧，用于单独存储一个函数调用时所需的各种信息。

【例】函数g的每次执行相当于激活。

参数：实参

类型：

局部数据or临时变量：函数中的变量存储位置

控制链：指向调用该函数的函数激活

返回值：给上一个函数激活使用

访问链：指向上一个非本函数自身的函数激活

状态记录：用于记录进程被等停时的状态

调用函数时：

放入代码区、执行main、分配栈中的函数激活；

把实参（从上一个函数激活、全局变量等）放入实参表；

计算结果并存入返回值；

根据控制链找到相应的语句将值写回（若用 * 或 &则会写回改变后的值？）；

释放函数激活（弹出栈帧）；

目标：理解计算机如何管理资源 —— 通过操作系统。

这里的资源指的是：

基本的操作术语理解：

异步：布置出去，不等结果

并发：同一时间框架下，(时空)资源的分享机制（宏并微串）

通信：将信息从一个实体传递给另一实体（进程、设备、主机）

并行: 同时进行

实现同时处理多个时间或任务、满足多任务的时间需求。

system call 是操作系统提供给应用程序的操作系统服务接口。 用户通过调用 systemcall 来完成那些需要操作系统内核进行的操作， 例如硬盘， 网络接口设备的读写、发送信号等。

系统调用是对操作系统服务的一次请求，它会使正常的CPU周期中断，并将CPU控制权交给操作系统，然后操作系统就可以切换到另一个进程上去了。

将程序的指令序列分块

划分与程序对应的独立存储区域

公共空间的使用 ：

​ 3.1：保存与加载

​ 3.2：PC计数器

​ 3.3：通用寄存器

注意：引入3是为了高效，引入4是为了状态记录

慢速系统调用

可能会使进程永久阻塞的一类。

信号：软件层面的中断

IO设备 —— 也需要使用分时的机制

非阻塞和异步的差别：

（1） 异步布置出去一定要做，但是不关注完成时刻

（2） 但是非阻塞是在请求时刻如果不做那就永远不再做

程序是用来完成特定任务的指令序列。

注意：集合是无序的，而序列是有序的

从实际上（就拿c语言）来说，一个.c文件经理预处理、编译、汇编、甚至链接这一系列过程中产生的文件，在广义上都还是属于程序的范畴。 上面说的“过程”简单示意为： name.c —> name.o —> link成 a.out（可执行代码）

关于程序的编译过程，推荐参考这篇文章：Linux下详解gcc编译过程（含代码示例）&& gcc使用教程

进程可以简洁地理解为“运行的程序”，有的解释为程序的一次执行。

更深入一些的理解：

① 创建状态：进程在创建时需要申请一个空白PCB，向其中填写控制和管理进程的信息，完成资源分配。如果创建工作无法完成，比如资源无法满足，就无法被调度运行，把此时进程所处状态称为创建状态。

② 就绪状态：进程已经准备好，已分配到所需资源，只要分配到CPU就能够立即运行。

③ 执行状态：进程处于就绪状态被调度后，进程进入执行状态。

④ 阻塞状态：正在执行的进程由于某些事件（I/O请求，申请缓存区失败）而暂时无法运行，进程受到阻塞。在满足请求时进入就绪状态等待系统调用。

⑤ 终止状态：进程结束，或出现错误（非正常终止），或被系统终止（正常终止），进入终止状态。无法再执行。

其实还有7态图，加入了挂起的概念，涉及换页，这里不展开了。

进程以执行一个指令序列的控制流开始。

更深入一些的理解：

进程从单一控制流开始，从第一个激活记录（Activation Record ，可以简单理解为函数栈帧）产生的时候（大多数情况从main开始），执行指令序列。

拓展了解：

注意换页和上写文切换的区别

有了页表就可以将虚拟地址转换为物理内存地址了，这种机制就是虚拟内存。

进程拥有地址空间（它可以访问的内存）和至少一个被称为线程（Thread）的控制流；

执行线程： 程序执行时，由进程程序计数器PC的值来决定下面该执行哪一条进程指令，得到的指令流被称为执行线程（thread of execution），它可以用此程序代码执行期间为程序计数器指定的零地址序列来表示。

什么是线程？

线程： 线程代表了进程内执行线程的一种抽象的类型，有独立的执行栈、程序计数器值、寄存器组和状态。

基于进程资源实现多操作并发，是系统调度的最小单位。

是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程（kernel thread），而把用户线程（user thread）称为线程。

上下文切换： 执行线程中的指令序列对于进程来说就像是一条不间断的地址流。但从处理器CPU的角度来看，来自不同进程的执行线程是混在一起的；执行从一个进程切换到另一个进程的点被称作上下文切换。

进程模型的自然拓展允许多个线程在同一个进程内执行。（同一进程）使用多个线程可以避免上下文切换，并允许共享代码和数据（即共享地址），籍此改善性能。

进程切换与线程切换的一个最主要区别就在于进程切换涉及到虚拟地址空间的切换而线程切换则不会。因为每个进程都有自己的虚拟地址空间，而线程是共享所在进程的虚拟地址空间的，因此同一个进程中的线程进行线程切换时不涉及虚拟地址空间的转换。

同一进程内用户级线程切换不需要触发内核态，不同进程间的用户级线程切换则引起进程切换，所以必定在内核态。

内核态线程切换肯定是要内核调度切换，但是用户态线程切换不需要内核参与。

操作系统为了支持多个应用同时运行，需要保证不同进程之间相对独立（一个进程的崩溃不会影响其他的进程 ， 恶意进程不能直接读取和修改其他进程运行时的代码和数据）。 因此操作系统内核进程需要拥有高于普通进程的权限， 以此来调度和管理用户的应用程序。

于是内存空间被划分为两部分，一部分为内核空间，一部分为用户空间，内核空间存储的代码和数据具有更高级别的权限。内存访问的相关硬件在程序执行期间会进行访问控制（ Access Control），使得用户空间的程序不能直接读写内核空间的内存。

为了管理与调度，操作系统会维护一张进程列表（简称为PL）。 以Linux来说，该进程列表的表项是一个PCB块。

PCB（Process Control Block,程序控制块）是一种数据结构，包含进程的相关信息。系统利用PCB描述进程的情况和活动过程，并控制管理进程。 一定要注意的是：PCB块是由内核来管理和调度的，不属于用户空间！ 这个理解很重要！是理解进程实体的关键！

进程控制块（PCB 即 Process Control Block）是进程状态信息的集合，用来描述进程和用于进程的管理和调度，用PCB可以区分不同的进程。

PCB主要包含的信息有

学习过操作系统的同学肯定都背过这样的标准答案： “ 进程实体由代码段、数据段和PCB组成 ”；

这句标答确实没有毛病，但是对于学习Unix系统编程/高级Unix环境编程的同学来说这样的理解肯定是不够的，我们还要从内核空间和用户空间的角度对进程实体做区分。

首先我们来看看进程列表PL是怎么和进程实体挂上钩的

操作系统维护的进程列表的表项为PCB，而每个PCB对应一个进程实体。

回顾一下，我们在操作系统中记忆的标准答案——“进程实体由数据段、代码段、PCB构成”，这里所说的数据段和代码段其实指的是 “进程用户地址空间”（VM）。

拓展理解性知识：

程序加载之后，可执行程序看起来占据了一个连续的内存块，这个连续的内存块被称为程序映像(program image)。程序映像有几个不同的分区。程序文本或代码显示在内存低端地址中。在映像中已初始化和未初始化的静态变员也有自己的分区。其他的分区包括堆、栈和环境。

活动记录(activation record) 活动记录是在进程栈顶端分配的一个内存块，用来 装载调用过程中函数的执行上下文 。每次函数调用都在栈上创建一个新的活动记录。假如嵌套的函数调用按照后调用先返回的次序工作，那么，函数返回时会将活动记录从栈中删除。 活动记录包括返回地址、参数(参数值从相应的命令行参数小拷贝而来)、状态信息和调用时某些CPU寄存器值的拷贝。进程从记录表示的调用中返回时，要恢复寄存器的值。活动记录中还包括含数执行时在其内部分配的自动变量。活动记录的特定格式取决于硬件和编程语言。

除了静态变量和自动变量之外，程序映像中还包括了argc和argv占用的空间以及 malloc分配的空间。 malloc含数族在一个被称为堆(heap)的空闲内存池中分配存储空间。在堆上分配的存储空间一直存在，直到它被释放或程序退出为止。 如果一个函数调用了 malloc，那么在这个函数返问之后，存储空间仍保持已分配状态。除非程序有一个在函数返叫之后仍然可以访间的指向该存储空间的指针，否则，返回后的程序就不能访问它。

在声明时没有显式初始化的静态变量在运行时被初始化为0。 注意，在程序映像中， 已初始化的静态变量和未初始化的静态变量占据不同的分区。 通常， 已初始化的静态变量是磁盘上可执行模块的一部分，而未初始化的静态变量则不是。 当然，自动变量不是可执行模块的一部分，因为只有当定义它们的程序块被调用时，它们才被分配。除非程序显式地对自动变运进行初始化，否则，它们的初始值是不确定的。

进程实体包含：

（1） 进程组，会话

（2） 进程凭证（权限 —— 各种id）

（3） 文件描述符

（4） 资源限制

（5） Syscall

（6） 信号相关内容

（7） VM（用户空间）

（8） 线程列表（链表，每个链表单元包括独立的线程栈、相关信息（PC计数器、寄存器等）、调度）；

【注意】

① 线程可以共享进程的大多数数据or资源，但是不能通过变量名访问进程VM空间中栈的变量（是局部变量），但是或许可以通过访问局部变量的地址用指针来访问（不同操作系统规定不同）。

② 除了VM中的栈，其他的包括进程组/会话和进程凭证、信号、fdlist、syscall都可以共享

僵尸进程：父进程没有wait子进程（回收子进程的信息）

孤儿进程：父进程先于子进程终止

特殊的进程 —— 系统进程：init进程（PID == 1）

将僵尸/孤儿进程进程组中的父进程信息改为自己，让它们将结束信息向自己汇报，使它们得以释放资源（VM等）。

① 程序：

程序是用来完成特定任务的指令序列，是指令、数据及其组织形式的描述。

② 进程：

进程是一段程序的执行过程。

③ 线程：

是操作系统能够进行运算调度的最小单位。

④ 程序与进程的联系：

当操作系统向内核的数据结构中添加了适当信息并为程序分配了必要资源后，程序就变成了进程。

⑤ 进程与线程的联系：

（1）进程的执行以一个指令序列的控制流开始，进程拥有地址空间和至少一个被称为线程的控制流。

（2）一条线程指的是进程中一个单一顺序的控制流，线程被包含在进程之中，是进程中的实际运作单位。

（3）一个进程中可以并发多个线程，每条线程并行执行不同的任务。

（4）进程实体中含线程列表，Linux中线程列表实际上是一个链表，每个链表单元包括独立的线程栈、计数器、寄存器、TCB块和调度器，各线程独立调度，同一进程下的线程共享进程的地址空间。

⑥ 进程与线程的区别：

（1）进程是资源分配的基本单位，线程是系统调度的实际基本单位。

（2） 每个进程都有自己的虚拟地址空间，而进程内的所有线程共享进程的虚拟地址空间。

（3）进程切换涉及到虚拟地址空间的切换，而线程切换则不会，故进程切换的开销大于线程。

（4）进程的切换需要内核调度切换，但线程的切换分两种情况：基于真实系统调用的内核级线程需要内核调度切换，但基于非阻塞系统调用编写的线程库实现的用户态线程切换不需要内核参与。

每个进程都有一个整型的标识符进行标识 —— 进程号：PID（Process ID）：用于给操作系统识别ID；

fork：创建新进程：通过复制当前进程来完成任务，返回值是pid；

如果父进程中用变量存储了fork的返回值，那么fork后在父进程的栈中fork函数的函数激活的返回值是子进程的pid，而在子进程中则是0；

fork()的返回值：

在父进程中，fork返回新创建子进程的进程ID；

在子进程中，fork返回0；

如果出现错误，fork返回一个负值；

fork()函数通过系统调用创建一个与原来进程（父进程）几乎完全相同的进程。

注意，子进程持有的是上述存储空间的“副本”，这意味着父子进程不共享这些存储空间。linux将复制父进程的地址空间内容给子进程，因此，子进程有了独立的地址空间。也就是这两个进程做完全相同的事。

所有与PID静态相关的东西基本都会继承，动态相关的东西基本都会更新；

PID、运行时间、信号、锁（父进程上的锁、屏蔽的信号不应该带到子进程中）。

exec函数族提供了一种（不需要额外分配资源）加载程序的操作。

在fork后的子进程中使用exec函数族，可以装入和运行其它程序（子进程替换原有进程，和父进程做不同的事）。

相当于是直接对现有某个PE的VM的改动（堆栈全部清空等操作），PE中其他部分基本不动（除了文件描述符列表被清空和信号可能会改动）；

exec函数族可以根据指定的文件名或目录名找到可执行文件，并用它来取代原调用进程的数据段、代码段和堆栈段。在执行完后，原调用进程的内容除了进程号外，其它全部被新程序的内容替换了。另外，这里的可执行文件既可以是二进制文件，也可以是Linux下任何可执行脚本文件。

exec函数族一般规律：

exec函数一旦调用成功，即执行新的程序，不返回。

只有失败才返回，错误值-1，所以通常我们直接在exec函数调用后直接调用perror()，和exit()，无需if判断。

l(list) 命令行参数列表

p(path) 搜索file时使用path变量

v(vector) 使用命令行参数数组

e(environment) 使用环境变量数组，不适用进程原有的环境变量，设置新加载程序运行的环境变量

【注意】事实上，只有execve是真正的系统调用，其他5个函数最终都调用execve，是库函数，所以execve在man手册第二节，其它函数在man手册第3节。

在进程产生时操作系统会为其分配相应的进程实体，包含内核管理的PCB块和用户地址空间VM；

总的来说，一个进程实体包含以下内容：

（1） 进程组，会话

（2） 进程凭证（权限 —— 各种id）

（3） 文件描述符

（4） 资源限制

（5） Syscall

（6） 信号相关内容

（7） VM（用户地址空间）

（8） 线程列表（线程独立栈、计数器、寄存器、调度器）；

而用户地址空间VM包括以下内容：

为了管理与调度，操作系统会维护一张进程列表（PL），以Linux来说，该进程列表的表项是PCB块，用于在进程调度时记录和还原进程当前工作相关信息。

此外，基于进程列表，操作系统根据进程的被标记的状态划分出两个个队列 —— 阻塞队列、就绪队列在此基础上运行进程调度算法（例如轮转法、短进程优先、FIFO算法等），实现进程并发。

指计算机系统能够访问的硬件。

常见的终端设备：

磁盘、磁带、CD-ROM、打印机、键盘、显示器、鼠标、网络接口；

注意：CPU、内存是计算机的核心单元/内部资源，不是终端设备。

如何控制终端设备：操作系统通过系统函数（接口）的调用run设备驱动程序

Unix通过统一的索引接口实现对多数终端设备的访问：

系统IO —— 指Unix系统的IO

一次open的成功返回会创建一个文件实体（fork不涉及open操作，涉及的是dup）。

不管多少个进程的fd列表打开了多少个进程实体，操作系统为了管理，将所有进程打开的文件实体（不论是否重复）都作为表项（记录）维护在文件系统的系统（打开）文件表中。

注意在fork子进程的时候，文件描述符列表中的指针也被复制。

关于上图中的知识体系推荐这篇博客：用图片带你串起进程列表、进程控制块、inode节点、文件描述符列表、文件实体、文件系统等知识_狱典司的博客-CSDN博客

标准IO —— C标准

打开一个文件之后，若要对文件进行多次读写：

在堆（内存）中设置缓存用于存储文件的数据（Block的内容），便于提高读写效率（fopen函数）

【因为在系统IO中文件数据是保存在磁盘中的，多次读写需要多次磁盘IO效率低】

【例】fopen函数将文件信息读到缓冲中。

重定向：把PE的FDL中文件描述符指向别的文件实体。

Dup2（fd1，fd2）会把fd1关掉，（若是fd2已存在则把原fd2关掉）。

fcntl函数可以改变fd的状态（比如阻塞非阻塞）。

编程练习： Unix上用C程序实现pipe管道命令“ | “（pipe，fork，dup2，close，execl，重定向）_狱典司的博客-CSDN博客

① 进程根据其进程实体中文件描述符列表使用其打开的文件，所谓文件描述符列表实际上是files_struct 结构中的struct file *fd[NR_open]数组，文件描述符号则是该数组的下标，每个数组单元是一个指向文件实体（文件结构，即struct file）的指针，而文件系统维护一张由文件实体（struct file）为链表单元组成的双向链表，即系统打开文件表。

② bash子进程默认在文件描述符0，1，2上打开标准输入、标准输出、标准错误输出。

③ fork() 出来的子进程继承父进程的文件列表，双方的文件描述符列表里的指针指向的是同一个文件实体。

④ 使用dup2做重定向时，文件描述符列表里被复制的fd与复制出的fd指向指向同一个文件的同一个文件实体。

⑤ 系统IO下每次open的成功返回都将创建一个文件实体，IO的文件数据是无缓冲的，即保存在磁盘上。

⑤标准IO下在堆（内存）中设置缓存用于存储文件的数据（Block的内容），便于提高读写效率（fopen函数）。

逻辑概念：

文件系统在磁盘上以块的形式实现，逻辑结构是树（有向图 —— 考虑到链接的情况）；

所谓路径：从某一目录到目标目录的所有分支节点的序列

文件中的clean和dirty块涉及到同步的问题 — 是主计算机和边缘设备（磁盘、打印机等）的同步。

① 常规文件

【特点】Linux中最多的一种文件类型, 包括纯文本文件(ASCII)；二进制文件(binary)；数据格式的文件(data);各种压缩文件。默认会把可以且成功写入的内容保存。

② 目录文件

【特点】其block中存储的不是文件数据而是目录树中其子节点的目录项，包括文件名和inode号。

③ 管道

【特点】是匿名管道，由进程内部的文件描述符指向，非其子进程的外部进程无法使用该管道，且在没有进程打开管道的时候PIPE就消失了；写入的内容随读出而抹除。

④ FIFO（命名管道）

【特点】是一种特殊文件，所有的进程都可以通过其地址（注意不单是文件名）来对FIFO进行访问，且其不会在无进程调用时消失。写入的内容随读出而抹除。

⑤ 字符特殊文件（一个char（字符）的大小为一个字节，通过字节交互）

【特点】串行端口的接口设备，例如键盘、鼠标等等。

⑥ 块特殊文件（收集到一定多字符再处理）

【特点】就是存储数据以供系统存取的接口设备，如硬盘。

包含被编号的块，每一块都可以独立地读取或者写入。而且可以定位于任何块，并且开始读出或写入。

⑦ 链接（软链接/符号链接）

【特点】是一类特殊的文件， 其包含有一条以绝对路径或者相对路径的形式指向其它文件或者目录的引用。

与属于普通文件的硬链接相比，软连接拥有独立的inode节点。

⑧ socket（不在ls可以列出的文件类别范围内）

【特点】由文件描述符指向的可用于（设备间）进程通信的套接字，借助内核分配给的写缓冲和读缓冲实现。

注意文件和inode是一对一的关系。区别于文件和文件实体可以是1对多的关系。

一个分区是一个文件系统（类型），硬链接无法跨分区（inode不一致），软连接可以跨分区存放（比如C盘可以用软连接索引D盘的内容）。

【注意】上述测试中可以看到硬链接属于普通文件，前缀是【-】,而软链接属于单独的文件类型——链接文件，前缀为【l】。

Boot区

Superblock区

扇区

复制的superblock：介绍分区中该扇区信息

Inode Map

Block Map

I节点区

Block区

注意：

每个扇区就是一个文件系统，文件系统之间的Inode Map和 Block Map相互独立，但可以通过软连接索引。

当文件被删除的时候文件的内容并没有被删除，只是inodeMap和blockMap的位被置0；

I节点中存储文件的磁盘块的指针，用户权限等

注意：文件的名字真实存储并不在文件的i节点本身，而是在其目录的block中！

文件编号（实际上是inode的编号，有可能是数组下标，待考证）

类型

权限（所有者的UID和GID）

文件长度

Block 计数

最近的时间信息（创建、访问、修改）

指针（直接指针、单级间接指针、二级间接指针、三级间接指针）指向Block

链接计数（存储该文件的目录数）

【注意】文件系统对于管道缓存的大小、文件名长度、文件内容长度都有所限制。

Block中可能不存真正的文件数据，有的可能存着其他文件或目录的i节点的编号和文件名（当该block的i节点对应文件为目录）—— 称为目录项

注意：文件的名字真实存储并不在文件的i节点本身，而是在其目录的block中！

（这种类型的block存储文件名和对应的i节点号即文件编号）

【考题】

文件系统怎么对一个文件进行增删改？

Key：联系inode和block

注意：若是要删除文件，并不是直接清空其所有的block，而是根据inode节点中的信息将inodeMap和blockMap置0，待下次新文件覆盖写入。

一个进程带有使用者（uid）的信息和所有者（owner）的信息，但是当涉及到操作权限的判断的时候基于进程的有效用户：EUID和EGID

st_mode存储（指定）：文件权限信息、文件类型

注意：stat对于用户只能访问但是不能修改，修改的工作是操作系统的。

获取文件属性，（从inode结构体中获取）。

参数：

path： 文件路径

buf：（传出参数） 存放文件属性，inode结构体指针。

返回值：

成功： 0

失败： -1 errno

获取文件大小： buf.st_size

获取文件类型： buf.st_mode

获取文件权限： buf.st_mode

符号穿透：stat会。lstat不会。

函数原型：int pipe( int filedes[2] )

pipe函数创建了一个通信缓存区，程序可以用通过参数中的文件描述符数组（filedes[2]）来访问这个缓冲区。filedes[0]作为写入文件描述符，filedes[1]作为读出描述符并按照先进先出的顺序从通信缓冲区中取出数据。

匿名管道没有永久的名字，系统只能通过他的两个文件描述符（参数fd[2]）来访问它。

因此，管道只能由创建它的进程或fork()的时候继承了该进程的文件描述符列表的子进程使用，单一进程使用匿名管道意义并不大。

匿名管道与文件指针

【注意】

①函数的参数中fildes[2]分别表示IO的文件描述符，分别指向不同的文件实体，在文件打开状态中记录谁读谁写；这两个打开的文件实体都指向同一个v节点（同一个文件）；

② 即，针对匿名管道pipe，就在同个文件的存储范围内进行（半双工）IO操作，没有额外的缓存空间类似于（buf之类的变量）。

匿名管道的常规使用（建立全双工通信通道）

① 父进程fork出子进程时，子进程可以监听对应文件实体实现进程间通信，但这种通信存在问题 —— 这是一种半双工通信，为实现可靠通信，可双向通信，但同一时刻只能单端做一个操作（即读或写），防止自己写入的数据被自己读走。

② 建立两个单工管道，即对于单个管道（子）进程和（父）进程分别关闭一个读fd和一个写fd，这样单个进程的读/写分工是明确的，实现两个进程的全双工通信（可双向通信、可同时工作），可以保证单一进程写入单一管道的内容不会被自己读取而不被对端读取。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WxgwkvYw-1641561707025)(C:\Users\Sean\AppData\Roaming\Typora\typora-user-images\image-20220103135255042.png)]

匿名管道上调用read

进程在匿名管道上调用read时：

①如果管道非空，read就会立刻返回实际读到的字节数；

②如果管道是空的，那么：

​ （1）只要有进程为写操作打开管道，read就会一直阻塞到某些内容被写入管道为止；

​ （2）如果没有进程为写操作打开管道，read调用就会立即返回0，表示遇到了文件结束EOF。

【注意】这里所描述的情况假定对管道的访问采用的是阻塞型的I/O（由fcntl控制）。

管道的阻塞机制

a）多个进程同时对一个管道进行读写——形成了多生产者多消费者模型

b) 实际的规则：

（1） nbuf O_NONBLOCK（非阻塞）有效，写满则报错

c) 使用时注意：

（1） 多进程使用管道时，写入长度小于buf（进程实体的资源限制中有PIPE_BUF项）

（2） 当写入长度大于buf的时候：①加锁 ②一 一对应（每个写的进程独占一个管道，写进程对应的这一组管道可以被多个进程读取）

没有进程打开管道时管道就消失了。从这个意义上来说，管道是临时的。POSIX用特殊文件来表示FIFO或命名管道(namedpipe)，这些特殊文件在所有的进程都将其关闭之后仍然存在。

FIFO像普通文件一样，有名字和访问权限，而且会出现在ls列出的目录列表中。任何一个且有恰当权限的进程都可以访问FIFO。可以在命令解释程序（shell）中执行mkfifo命令，或者从程序中调用mkfifo的数来创建FIFO。

mkfifo涵数用来创建新的FIFO特殊文件，创建的文件对应于path指定的路径名。参数 mode为新创建的FIFO指定了权限。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WkBUxRRt-1641561707026)(C:\Users\Sean\AppData\Roaming\Typora\typora-user-images\image-20220103145234211.png)]

PIPE于FIFO的区别：

PIPE是匿名管道，由进程内部的文件描述符指向，非其子进程的外部进程无法使用该管道，且在没有进程打开管道的时候PIPE就消失了；但是FIFO是一种特殊文件，所有的进程都可以通过其地址来对FIFO进行访问，且其不会在无进程调用时消失。

FIFO于文件的区别：

FIFO相当于一个文件，有权限信息，但是区别在于是FIFO（先进先出），写进去的东西读出之后就删掉了（类似于缓存）；而文件将默认会把写入的内容保存。

更细节的内容可以参考： Unix系统编程 信号部分学习笔记_狱典司的博客-CSDN博客

信号是对事件（小事件）相关进程的软件层面通知；

注意：忙等是指连续使用CPU周期来检测事件（通常是一个变量）的发生。

信号：有发出者和接收者（都是进程）→ 进程间通信

类型：int → SIGINT

产生：导致信号发生的事件

递送：传递/签收，目标进程执行与信号绑定的操作，即根据信号采取行动（看到还不算完，还要执行）

挂起：产生了但是还没递送，即以及生成但还没传递（1.时间片没轮到2.信号的屏蔽）

接信号的收者要安装信号处理程序（绑定：信号–>操作）。

如果在传递信号时进程执行了“信号处理程序”，那么进程就捕捉到了这个信号。

程序以用户编写的函数（处理程序）名作为参数调用sigaction来安装信号处理程序，也可以用SIG_DFL或SIG_IGN而不用处理程序来调用sigaction函数：

上面这两种动作都不是在捕捉信号。

信号生成时采取的动作取决于

与信号掩码相关的两个队列

（1）就绪信号队列（2）阻塞信号队列

**【注意】Fork之后信号队列会被清空吗？—— 会，信号掩码会被清空。 **

注意区分阻塞一个信号和忽略一个信号的区别 1.忽略：直接将被忽略的信号丢弃

实现方式：程序通过调用sigaction将信号处理程序设置为SIG_IGN来忽略一个信号。

2.阻塞：信号不会被丢弃；如果一个挂起信号被阻塞了，当进程解除对该信号的阻塞时，信号会被传递出去。

实现方式：程序通过调用sigprocmask来改变它的进程信号掩码来阻塞一个信号。

Kill函数针对pid划分出的四种情况：

【注意】用户只能向其拥有的进程发送信号。

区分一下signal和sigaction

Signal只能绑定而不能查看上一个绑定的操作;

而且没有sigaction这个结构体，也就无法做临时的信号屏蔽（限制）。

【注意】

①POSIX标准中，信号处理程序（sa_handler）就是一个普通的函数，返回void，并有一个int型参数；

②需要注意的是，在绑定函数sigaction的参数中的act并不是真正的信号处理程序！act是一个结构体（struct sigaction），该结构体中的sa_handler才是（常用的）信号处理程序！

进程可以通过阻塞信号暂时地阻止信号的传递。在这个阻塞信号被传递之前，它不会影响进程的行为。

信号掩码（signal mask） 类型：sigset_t 作用：进程的信号掩码给出了当前被阻塞的信号的集合。 可以使用类型为sigset_t的信号即来指定对信号的操作（例如阻塞或解除阻塞的操作）

对信号集（sigset_t）进行操作的五个函数：

造作信号集sigset_t的五个重要函数讲解：

int sigaddset ( sigset_t *set, int signo ) 作用：将signo信号加入信号集set

int sigdelset ( sigset_t *set, int signo ) 作用：将信号signo从信号集set删除

int sigemptyset ( sigset_t *set ) 作用：将信号集set清空

int sigfillset ( sigset_t *set ) 作用：将所有的信号加入信号集set中

int sigismember（const sigset *set， int signo） 作用：报告signo是否在信号集set中 返回值：在则返回1，不在则返回0；

注意：除了sigismember函数，其他函数若成功都返回0，不成功返回-1并设置errno。

函数sigprocmask —— 将信号集设置为阻塞/解除阻塞 函数原型：

参数解析：

POSIX中的函数接口pause、sigsuspend、sigwait提供了三种机制： 将进程挂起，直到信号发生为止。

####函数pause

函数pause(void)的调用会将进程挂起，直到传递了一个信号为止。

pause函数的参数是void，我们是否可以用pause使得进程阻塞等待一个我们期望的（指定的）信号？

答案是肯定的。

pause的作用机制如下：

当收到一个信号，若该信号的绑定动作是终止进程，那么pause不返回；若该信号的绑定了其他的动作，那么回调函数在执行完该绑定动作并返回后，pause就会返回，且总是返回-1。

我们可以在pause前设置相应的信号掩码，让我们期待的信号成为信号掩码（信号屏蔽集）的“漏网之鱼”。

【注意】pause函数存在一个重要的缺陷，也是一个核心问题：

在pause被启动之前信号可能以经被传递了，之后再执行pause的话进程则会一直被阻塞（产生死锁）。**即，pause是一种信号不安全函数。

可以把pause的缺陷简记为：在pause之前传递了信号。

sigsuspend(sigset_t *)

对于pause的缺陷，解决的思路是： 必须再解除对信号的阻塞之后立即启动pause，这两个操作的过程应该被合并成一个原子操作。 sigsuspend函数提供了一种实现原子操作的办法。

sigsuspend是信号安全函数，将sigpromask和pause变成’原子’操作。

且利用参数sigset_t类型的参数（信号集）可以指定我们要阻塞等待的信号。

用siglongjmp和sigsetjmp进行程序控制

siglongjmp和sigsetjmp提供的功能： 信号处理程序直接跳转到期望的终止点。这个跳转过程需要解开程序栈。

将这两个函数与goto语句的用法做类比

【注意】只是表面的类比，内部实现有很大不同：

不具体介绍，使用时查看。

格林威治时间是绝对的，和机器运行状态无关，而操作系统提供了四种计时方式（宏）。

CLOCK_REALTIME格林尼治时间

CLOCK_MONOTONIC开机时间

CLOCK_PROCESS_CPUTIME-ID当前代码（进程）所占用cpu时间

CLOCK_THREAD_CPUTIME-ID 当前线程所占用cpu时间

上面四个的clock_id分别代表1、2、3、4

补充：线程安全扩展

Time_t的指针参数 *restrict timer存储在寄存器（公共变量中，多个线程都可以访问）而不是独立变量中，多个线程在时间片轮转下的获取时间操作可能会使上一个线程获取的时间被新的时间覆盖；

进程组是一个或多个进程的集合、通常共同完成一项作业，可以接受来自同一终端的信号。

（“接收来自同意终端的信号”尤为重要，在实际操作中在打开多个终端的情况下，可以看到按下Ctrl+C只会终止单个终端的前台进程）

【注意】每个进程组有一个领头进程。

进程组ID：PGID

PGID一般情况下和进程组的首个进程的PID一致。

共享一个终端的若干进程组，围绕一个共同的终端进行管理和控制。

当有新的用户登录 Linux 时，登录进程会为这个用户创建一个会话。

会话的意义在于将很多的工作集中在一个终端，选取其中一个作为前台来直接接收终端的输入及信号，其他的工作则放在后台执行。

一个会话的组成

因为终端是一个设备，设备是一种文件，要能使用一个文件必须有由一个进程将其打开，该进程就是shell进程，由它创建/开启会话。

前端进程组（只有1个或者0个）

后端进程组（数量不限）

​

【注意】Init系统进程绑定的终端是硬件终端，而Shell等其他进程绑定的是软件终端。

创建终端

绑定终端

Fork

Exec决定使用前端进程/后端进程

① Shell的pid、pgid、sid理论上都是一样的

② 前台进程组：前台进程组首进程的pid和其pgid相同，但与shell的pgid不同，与其组内被它fork出来的进程的pgid相同；sid和shell的相同。

③ 后端进程和前端进程情况类似。

如果调用该函数的进程不是一个进程组的组长（用fork来保证），则此函数创建一个会话，具体会发生以下三件事：

① 该进程变成新会话的会话首进程，该会话的SID是该进程的PID；

② 该进程变成一个新进程的进程组组长进程，该进程组的PGID是该进程的PID；

③ 该进程没有控制终端，如果在setsid之前该进程绑定了一个控制终端，那么这种联系也被切断。

【注意】在会话绑定控制终端之前，不区分前台进程组和后台进程组。

一个会话有绑定一个控制终端的权力，控制终端通常有两种类型：

① 终端设备（在终端登录情况下）

② 伪终端设备（在网络登录情况下）

与终端绑定的会话首进程被称为（终端）控制进程，在shell中，”登录shell”进程（命令解释程序）就是终端控制进程，

控制本体：会话首进程/控制进程（有可能不是首进程）

控制对象：前台/后台进程组

控制方式：前后台都可以用命令行执行

（1） 前台 —— 可以直接和终端交互（接受来自终端的信号、占据终端控制权–终端输入）

（2） 后台 —— 不可以直接和终端交互（可以使用终端输出）

【注意】Ctrl+C对应的是中断信号，Ctrl+\对应的是推出信号。

关闭后端进程

控制哪一个作业（进程组）可以访问终端，哪些进程组在后台运行

是一个命令解释器（程序）—— 解释输入，输出交互。

读入字符串，然后对字符做解析，执行相应操作（fork、exec以及有可能的重定向等）

Shell进程从stdin读入指令后，fork一个子进程，然后解析命令，并exec写入命令以及参数。

这时shell作为父进程wait子进程的返回结果，因为文件描述符列表也被复制到子进程中，且exec不改变文件描述符列表，故此时子进程独占终端（父进程失去对终端的控制）

注意一个细节:

①因为在fork之后父进程的信号掩码在子进程中是被清空的，故fork之后执行exec操作的过程要重设信号掩码。

②进程组和会话在fork的时候都是会被继承的，更改要用setsid（void）

Init用于本地的登录；inetd用于网络远程登录。

Init——getty

Inetd——telnet（getty和telnet都要setsid绑定终端）

然后exec——Login

登陆成功后Exec——login shell（就是会话控制进程/会话首进程）

Login shell通过driver（驱动）绑定terminal（终端）

Fork&&exec后Setpgid —— 产生前端进程组

前台进程组也是绑定和shell同一终端的（IO）

后台进程组类似

后端不能直接和终端交互（关掉标准io），前端可以

① 编写程序

fork()后结束父进程，子进程变成孤儿进程，但还属于原会话

调用setsid()创建新会话 （保证该进程不是会话首进程）。这时候是没有绑定终端设备和终端控制进程的（虽然但是，可以绑定终端，但是要求不与终端产生联系，此时还需要再fork一次来保证不是会话首进程，没有与终端绑定的可能性）。

重复1的操作，保证彻底脱离终端（新进程因不是会话首进程，失去绑定终端的权力）。

chdir()更改工作目录的位置

umask(0022)该变文件访问权限掩码

重定向标准IO到黑洞文件（/dev/null）中

将这段代码保存为thread.c文件，可以执行下面的命令来生成可执行文件： $ gcc thread.c -o thread -lpthread 这段代码的执行结果可能是这样：

注意只是可能有这样的结果，在不同的环境下可能会有出入。因为这是多线程程序，线程代码可能先于第24行代码被执行。

线程是有属性的，这个属性由一个线程属性对象来描述。线程属性对象pthread_attr_t *attr由pthread_attr_init()接口初始化，并由pthread_attr_destory()来销毁，它们的完整定义是：

一般地，Linux下的线程有：绑定属性、分离属性、调度属性、堆栈大小属性和满占警戒区大小属性。

【例】设置线程绑定属性

【例】 设置线程分离属性

① kill只能对终端用户所拥有的进程发送信号。

② Pthread_kill只在进程内部的线程列表范围内发送信号。

pthread_create()接口负责创建了一个线程。线程也属于系统的资源，这跟内存没什么两样，而且线程本身也要占据一定的内存空间。

众所周知的一个问题就是C/C++编程中如果要通过malloc()或new分配了一块内存，就必须使用free()或delete来回收这块内存，否则就会产生著名的内存泄漏问题。

既然线程和内存没什么两样，那么有创建就必须得有回收，否则就会产生另外一个著名的资源泄漏问题，这同样也是一个严重的问题。那么线程的合并就是回收线程资源了。

线程的合并是一种主动回收线程资源的方案。当一个进程或线程调用了针对其它线程的pthread_join()接口，就是线程合并了。这个接口会阻塞调用进程或线程，直到被合并的线程结束为止。当被合并线程结束，pthread_join()接口就会回收这个线程的资源，并将这个线程的返回值返回给合并者。

与线程合并相对应的另外一种线程资源回收机制是线程分离，调用接口是pthread_detach()。

线程分离是将线程资源的回收工作交由系统自动来完成，也就是说当被分离的线程结束之后，系统会自动回收它的资源。因为线程分离是启动系统的自动回收机制，那么程序也就无法获得被分离线程的返回值，这就使得pthread_detach()接口只要拥有一个参数就行了，那就是被分离线程句柄（pthread_join有两个参数，一个是线程句柄，另一个是传出参数，用于接受线程结束时的返回值）。

【注意】

简单来说： pthread_detach()即主线程与子线程分离，子线程结束后，资源由系统自动回收。pthread_join()即是子线程合入主线程，主线程阻塞等待子线程结束，然后回收子线程资源。

在任何一个时间点上，线程是可结合的（joinable）或者是分离的（detached）。一个可结合的线程能够被其他线程收回其资源和杀死。在被其他线程回收之前，它的存储器资源（例如栈）是不释放的。相反，一个分离的线程是不能被其他线程回收或杀死的，它的存储器资源在它终止时由系统自动释放。

可以单独终止某个线程，并且返回一个存储计算结果的指针，该指针指向进程地址空间VM中的全局或堆中栈（而不能是线程栈）；

一般是正常执行完毕由由线程自己调用pthread_exit终止。

用参数标识出线程并主动将其杀死。

有点类似于进程的abort，属于非正常执行，一般由别人杀死。

（1） 线程结束时的返回value —— 可以通过pthread_join来获取

（2） 进程的内部线程可以通过信号交流（pthread_kill）

【注意】

Pthread_kill因为参数中需要线程号，所以外部进程无法向另一个进程内部的线程发送信号；

而由于进程没有线程号（线程属性结构体），所以线程不可以用pthread_kill向进程发信号

（3） 本质上是生产者和消费者的问题，需要一个共享区（缓冲区）以及同步机制

数据混乱的原因：

资源共享(独享资源则不会)

调度随机(意味着数据访问会出现竞争)

线程间缺乏必要同步机制

一定时间内（有可能被时间片分割的时间段，具有一定长度）

确定某特定交互区域（必然在公共区域中）被独占/独享。

即，对公共区域的数据按序访问。防止数据混乱，产生与时间有关的错误。

线程安全：

线程返回结果必须有明确而独立的的存储位置（地址等）。

锁可以把非线程安全函数转变成线程安全的，锁保护的是返回结果的独享位置或操作的独占。

POSIX线程提供了三种锁机制：

（1） 互斥锁 —— mutex

（2） 条件变量 —— conditional variable （增加使用条件）（判断过程中不能更改）

（3） 读写锁 —— 对于互斥锁的细化

【注意】三种锁都是很小的存储单元（都是变量），对于这类单元的访问可以是原子的，上锁和解锁这个操作是原子操作，不可分拆。

怎么理解建议锁？

建议锁！对公共数据进行保护。所有线程【应该】在访问公共数据前先拿锁再访问。

但，锁本身不具备强制性。

对于程序员来说，锁和临界资源在某种意义上是绑定（该绑定由程序员完成）的；

对于系统来说可以没有这种逻辑限制（比如攻击者可以利用内存泄漏暴露的地址直接访问被锁保护的临界资源），

但对于锁本身是系统内部的机制（包含队列和上锁线程记录）。

———— 即建议锁。

本质上是一种特殊的变量，有两种状态，即锁定和解锁；

互斥锁实际上与信号相关联，每个锁变量有独立的等待队列（将后续线程编号加入等待队列）；

创建这个变量的时候就会创建并初始化等待队列，争夺锁失败的线程会被加入等待队列；

解锁的时候会发送信号通知等待队列中的线程（具体实现与操作系统的具体实现有关）。

【注意】

上锁时系统记录上锁线程的属性struct_pthread_attr_t，解锁时要对照这个属性，非上锁线程无权限解锁！

互斥锁的使用技巧

尽量保证锁的粒度， 越小越好。（访问共享数据前，加锁。访问结束【立即】解锁，尽量不在while()最末尾处才解锁。）

互斥锁，本质是结构体。 我们可以看成整数。 初值为 1。（pthread_mutex_init() 函数调用成功。）

对临界区域（则必须有互斥锁，没有互斥锁就没有临界区这个概念）的访问是有条件的（不仅独占还有条件）。

【注意】条件变量不是锁，但是通常结合锁来使用。

初始化条件变量：

【注意】上锁与判断的顺序：先上锁再判断，将判断作为临界资源的一部分

阻塞等待条件：

【作用】

阻塞等待条件变量queue_not_empty 并解开mutex互斥锁，直到条件变量满足则上mutex锁并执行：

唤醒阻塞在条件变量上的线程

读写锁在互斥锁的基础上增加了读和写的互斥规则（对互斥锁的细化）。

相较于互斥量而言，当读线程多的时候，提高访问效率。

读写锁的操作接口

读写锁的工作原理：

锁只有一把，但是有读模式加锁和写模式加锁；

① 写独占

② 读之间可以共享

③ 写锁优先级高

【注意】

【例】下图中若是T1先来，T2~4一起来： T1的read请求先上锁…解锁；T3作为read被T2和T4的write阻塞；T2和T4按序写；写完之后才轮到T3来read。

是使用锁不恰当导致的现象：

① 锁的理解：

由于线程间的资源共享与竞争、线程的随机调度、以及缺乏必要的同步机制，返回的数据可能存在与时间有关的错误，产生混乱。

锁可以把非线程安全函数转变成线程安全的，锁保护的是返回结果的独享位置或操作的独占。

② 常见的锁类型：

（1）互斥锁 （2）条件变量 （3）读写锁

③ 锁的工作机制：

（1）互斥锁：

（2）条件变量：

（3）读写锁：

读写锁是对互斥锁的细化，在互斥锁的基础上细化了读和写的互斥规则，相较于互斥锁而言，当读线程多的时候，读写锁可以提高访问效率。

读写锁有两种加锁模式：写模式加锁和读模式加锁。

读写锁的加锁规则：1. 写锁独占

​ 2. 读锁之间可并发

​ 3. 写锁优先级高

信号量：应用于线程、进程间同步。

① 相当于初始化值为 N 的互斥量； N值表示可以同时访问共享数据区的线程数。

② 条件变量cond用于线程同步，sem可以用于进程/线程同步（ sem_init中的pshared参数）。

sem_t sem; 定义类型。

sem_init的参数：

一次调用，做一次-- 操作， 当信号量的值为 0 时，再次 – 就会阻塞。 （对比 pthread_mutex_lock）

一次调用，做一次-- 操作， 当信号量的值为 0 时，再次 – 就会阻塞。 （对比 pthread_mutex_lock）

一次调用，做一次++ 操作. 当信号量的值为 N 时, 再次 ++ 就会阻塞。（对比 pthread_mutex_unlock）

做事（作业）的时候基本单位是进程组。

进程是操作系统资源分配的基本单位。

系统调度的基本单位是线程。

出于安全的考虑划分成两块：内核区域和用户区域

用户与系统之间存在隔离。

由于操作系统支持多用户、会话、进程组 -->用户间的隔离：各用户的进程只能访问自己的VM。

通信的核心：可供多端读写的公共介质。

内存中的共享内存和文件中的自定义文件没有提供锁机制：

解决方案：

内存：找一段地址自定义一个锁（可以用1个bit的0和1表示）。

自定义文件：文件锁。

（1） 信号量 （用户空间）---- 同一进程的线程之间或者多个进程之间。

（2） 信号量集（内核空间）---- 进程之间使用（多个信号量则表示多种资源的生产和消费）

所谓共享内存就是使得多个进程可以访问同一块内存空间，是最快的可用IPC形式。

下面实例演示了使用shmget函数创建一块共享内存。

程序中在调用shmget函数时指定key参数值IPC_PRIVATE，这个参数的意义是创建一个新的共享内存区，创建成功后使用shell命令ipcs来显示系统下共享内存的状态。命令参数-m为只显示共享内存的状态。

htons --> 本地–>网络 (port)

ntohl --> 网络–> 本地（IP）

ntohs --> 网络–> 本地（Port）

sockaddr地址结构： IP + port --> 在网络环境中唯一标识一个进程。

domain：AF_INET、AF_INET6、AF_UNIX

type：SOCK_STREAM、SOCK_DGRAM

protocol: 0

返回值： 成功： 新套接字所对应文件描述符

​ 失败: -1 errno

sockfd: socket 函数返回值

addr: 传入参数**(struct sockaddr )&addr* 【注意】做强制类型转换。

addrlen: sizeof(addr) 地址结构的大小。

返回值：成功：0，失败：-1 errno。

sockfd: socket 函数返回值

backlog：上限数值。最大值 128.

返回值： 成功：0

​ 失败：-1 errno

sockfd: socket 函数返回值

addr：传出参数。成功与服务器建立连接的那个客户端的地址结构（IP+port）

socklen_t clit_addr_len = sizeof(addr);

addrlen：传入传出。 &clit_addr_len

入：addr的大小。 出：客户端addr实际大小。

返回值：

​ 成功：能与客户端进行数据通信的 socket 对应的文件描述。

​ 失败： -1 ， errno

​

sockfd： socket 函数返回值

struct sockaddr_in srv_addr; // 服务器地址结构

srv_addr.sin_family = AF_INET;

srv_addr.sin_port = 9527 跟服务器bind时设定的 port 完全一致。

inet_pton(AF_INET, “服务器的IP地址”，&srv_adrr.sin_addr.s_addr);

addr：传入参数。服务器的地址结构

addrlen：服务器的地址结构的大小

返回值： 成功：0

​ 失败：-1 errno

如果不使用bind绑定客户端地址结构, 采用"隐式绑定"。

server:

socket() 创建socket

bind() 绑定服务器地址结构

listen() 设置监听上限

accept() 阻塞监听客户端连接

read(fd) 读socket获取客户端数据

处理

write(fd)

close();

client:

socket() 创建socket

connect(); 与服务器建立连接

write() 写数据到 socket

read() 读处理后的数据。

显示读取结果

close()

更多的内容涉及网络编程，不展开叙述。

①同步/异步关注的是消息通信机制 (synchronous communication/ asynchronous communication) 。

所谓同步，就是在发出一个调用时，在没有得到结果之前， 该调用就不返回。 异步则是相反，调用在发出之后，这个调用就直接返回了，所以没有返回结果。

【例】

②阻塞/非阻塞关注的是程序在等待调用结果（消息，返回值）时的状态。

阻塞调用是指调用结果返回之前，当前线程会被挂起。调用线程只有在得到结果之后才会返回。 非阻塞调用指在不能立刻得到结果之前，该调用不会阻塞当前线程。

阻塞/非阻塞， 同步/异步的概念要注意讨论的上下文（字面意思）：

① 在进程通信层面： 阻塞/非阻塞， 同步/异步基本是同义词， 但是需要注意区分讨论的对象是发送方还是接收方。

发送方阻塞/非阻塞（同步/异步）和接收方的阻塞/非阻塞（同步/异步） 是互不影响的。

【注意】上述不同类型的发送方式和不同类型的接收方式，可以自由组合。

② 在 IO 系统调用层面（ IO system call ）：

非阻塞IO 系统调用 和 异步IO 系统调用存在着一定的差别， 它们都不会阻塞进程， 但是返回结果的方式和内容有所差别， 但是都属于非阻塞系统调用（ non-blocing system call ）

一个非阻塞I/O 系统调用 read() 操作立即返回的是任何可以立即拿到的数据， 可以是完整的结果， 也可以是不完整的结果， 还可以是一个空值。

而异步I/O系统调用 read（）结果必须是完整的， 但是这个操作完成的通知可以延迟到将来的一个时间点。

非阻塞系统调用（non-blocking I/O system call 与 asynchronous I/O system call） 的存在可以用来实现线程级别的 I/O 并发， 与通过多进程实现的 I/O 并发相比可以减少内存消耗以及进程切换的开销。

【原理】

考虑一个单进程服务器程序， 收到一个 Socket 连接请求后， 读取请求中的文件名，然后读请求的文件名内容，将文件内容返回给客户端。CPU 和 硬盘IO 的资源大部分时间都是闲置的。 此时， 我们会希望在等待 I/O 的过程中继续处理新的请求。

方案一： 多进程

方案二：多线程

引申问题： 一个进程中的某一个线程发起了 system call 后， 是否造成整个进程的阻塞？ 如果会， 那么多线程方案与单进程方案相比就没有明显的改善。

解决办法1：内核支持的线程（kenerl supported threads）

解决办法2： 用户支持的线程（user supported threads）

从上面的过程可以看出，用户支持线程的解决方案基于非阻塞IO系统调用( non-blocking system call) ， 且是一种基于操作系统内核事件通知（event-driven）的解决方案， 基于这个流程, 可以引申到更为宽泛的 event-driven progreamming 话题上。

①同步/异步更多的关注消息通信机制：

（1）所谓同步，就是在发出一个调用时，在没有得到结果之前， 该调用就不返回。

（2）异步则是调用在发出之后，返回的结果必须是完整的， 但是这个操作完成的通知可以延迟到将来的一个时间点。

（3）通信的发送方阻塞/非阻塞（同步/异步）和接收方的阻塞/非阻塞（同步/异步） 是互不影响的。

同步的例子：线程互斥锁的使用。

异步的例子：epoll基于事件驱动的监听机制。

②阻塞/非阻塞关注的是在 IO 系统调用层面：

（1）阻塞调用是指调用结果返回之前，当前线程会被挂起。调用线程只有在得到结果之后才会返回。

（2）非阻塞调用指操作立即返回的是任何可以立即拿到的数据， 可以是完整的结果， 也可以是不完整的结果， 还可以是一个空值，该调用不会阻塞当前线程。