UNIX环境高级编程

LiteralliJeff · 发表于 2023-2-17 15:12

I/O	文件系统	进程	线程	进程间通信
一.文件I/O 三.标准I/O库八.高级I/O	二.文件和目录	四.进程环境五.进程控制	六.线程七.线程控制	九.进程间通信十.信号

7.Core Dump（外加）

一.文件I/O

本章描述的函数经常被称为不带缓冲的I/O，不带缓冲值的是每个read和write都调用内核中的一个系统调用。这些不带缓冲的I/O函数不是ISO C的组成部分，它们是POSIX.1和Single UNIX Specification的组成部分
1.文件描述符

对于内核而言，所有打开的文件都通过文件描述符引用。文件描述符是一个非负数。范围是0~OPEN_MAX-1。当进程创建时，默认为它打开了3个文件描述符，它们都链接向终端：

通常使用STDIN_FILENO，STDOUT_FILENO和 STDERR_FILENO来替代这三个幻数，从而提高可读性。这三个常量位于<unistd.h>中
复制文件描述符

对于dup函数
对于dup2函数：

这些函数返回的新文件描述符与参数fd共享同一个文件表项：

2.相关调用

2.1 打开文件

参数：

对于openat函数，被打开的文件名由fd和path共同决定：

由 open/openat 返回的文件描述符一定是最小的未使用的描述符数字
2.2 创建文件

参数：
- mode：指定该文件的访问权限。文件访问权限常量在 <sys/stat.h> 中定义，有下列九个：

该函数等价于open(path,O_WRONLY|O_CREAT|O_TRUNC,mode)
creat的存在一个不足是：它以只写方式打开创建的文件。如果要创建一个临时文件，并要先写该文件，然后又读该文件，则必须先调用create、close，然后再调用open，新版本open出来后，可以以下列方式实现：
open(path,O_RDWR|O_CREAT|O_TRUNC,mode)
2.3 关闭文件

注意：

2.4 定位读写位置

参数：
- offset：

每个打开的文件都有一个与其关联的“当前文件偏移量”。它通常是个非负整数，用于度量从文件开始处计算的字节数。通常读、写操作都从当前文件偏移量处开始，并且使偏移量增加所读写的字节数。注意：

lseek 并不会引起任何 I/O 操作，lseek仅仅将当前文件的偏移量记录在内核中

当前文件偏移量可以大于文件的当前长度。此时对该文件的下一次写操作将家常该文件，并且在文件中构成一个空洞。空洞中的内容位于文件中但是没有被写过，其字节被读取时都被读为0（文件中的空洞并不要求在磁盘上占据存储区。具体处理方式与操作系统有关）

2.5 文件读

参数：

读操作从文件的当前偏移量开始，在成功返回之前，文件的当前偏移量会增加实际读到的字节数
有多种情况可能导致实际读到的字节数少于期望读到的字节数：

2.6 文件写

参数：

write的返回值通常都是与nbytes相同。否则表示出错（出错的一个常见原因是磁盘写满，或者超过了一个给定进行的文件长度限制）
对于普通文件，写操作从文件的当前偏移量处开始。如果打开文件时指定了O_APPEND选项，则每次写操作之前，都会将文件偏移量设置在文件的当前结尾处。在一次成功写之后，该文件偏移量增加实际写的字节数
2.7 fcntl函数

fcntl可以改变已经打开文件的属性

参数：
- cmd：有下列若干种：
  - 复制一个已有的描述符（还可以使用dup或dup2）
  arg：依赖于具体的命令

3.进程间文件共享

UNIX系统支持在不同进程间共享打开文件。内核使用3种数据结构描述打开文件。它们之间的关系决定了在文件共享方面一个进程对另一个进程可能产生的影响

内核为每个进程分配一个进程表项（所有进程表项构成进程表），进程表项中都有一个打开的文件描述符表。每个文件描述符占用一项，其内容为：
内核为每个打开的文件分配一个文件表项（所有的文件表项构成文件表）。每个文件表项的内容包括：
每个打开的文件或者设备都有一个 v 结点结构。 v 结点结构的内容包括：

现在假设进程 A 打开文件 file1，返回文件描述符 3；进程 B 也打开文件 file1，返回文件描述符 4：

内核在文件表上新增两个表项：

对文件的操作结果：

每次 write 之后，在文件表项中的当前文件偏移量即增加所写入的字节数
如果用 O_APPEND 标志打开一个文件，则相应标志也设置到文件表项的文件状态标志中
若用 lseek 定位到文件当前的尾端，则文件表项中的当前文件偏移量设置为 i 结点中的文件长度

4.原子操作

多个进程写同一文件时，可能产生预想不到的结果。为了避免这种情况，需要理解原子操作

多个进程同时追加写一个文件时，如果通过 lseek 到末尾然后 write 可能出现问题：因为 “先定位到文件尾端，然后写” 并不是一个原子操作，如果先执行两个进程的 lseek ，然后执行 write ，就会出现问题
UNIX提供了一种原子操作方法：通过 O_APPEND选项打开文件。这样做使得内核在每次调用 write 执行写操作之前，都将进程的当前偏移量设置到该文件的末尾，于是就不需要执行lseek定位操作
定位读和定位写

参数：

调用pread相当于先调用lseek再调用read.但是调用pread时，无法中断其定位和读操作，并且不更新当前文件偏移量
调用pwrite相当于先调用lseek再调用write.但是调用pwrite时，无法中断其定位和写操作，并且不更新当前文件偏移量
5.数据同步

UNIX操作系统在内核中设有缓冲区高速缓存或页高速缓存，大多数磁盘 I/O 都通过缓冲区进行。当我们想文件写入数据时，内核通常都先将数据复制到缓冲区中，然后排入队列，晚些时候再写入磁盘。这种方式称为延迟写
以下2种情况会将缓冲区中的数据写回到磁盘：

参数（前两个函数）：

3个函数的区别：

sync（update 守护进程会周期性(一般每隔30s)的调用sync函数。命令sync也会调用sync函数）：
fsync：
fdatasync：

二.文件和目录

文件系统

可以把一个磁盘分成一个或多个分区。每个分区可用包含一个文件系统
inode是固定长度的记录项，包含有关文件的大部分信息

可以进一步分析inode和数据块部分：

这种链接类型称为硬链接

符号链接

下图为在一个目录下创建一个目录testdir，注意testdir所在目录，以及新建目录testdir的inode链接数：

1.获取文件信息

stat

fstat

lstat

stat

fstatat：获取相对于打开目录fd的文件pathname的统计信息

文件信息结构用一个结构体stat表示，实际定义可能随具体实现有所不同，但基本形式是：

struct stat{
mode_t st_mode;/*文件模式字，包含有文件类型、ID和读写权限位信息*/
ino_t st_ino;/* inode号 */
dev_t st_dev;/* 设备号（文件系统） */
dev_t st_rdev;/* 特殊文件的设备号 */
nlink_t st_nlink;/* 链接数 */
uid_t st_uid;/* 所有者的用户ID */
gid_t st_gid;/* 组所有者的ID */
off_t st_size;/* 字节大小，用于一般文件 */struct timespec st_atime;/* 最后一次访问时间 */struct timespec st_mtime;/* 最后一次修改时间 */struct timespec st_ctime;/* 最后一个文件状态改变的时间 */
blksize_t st_blksize;/* 磁盘块(block)大小 */
blkcnt_t st_blocks;/* 分配的磁盘块(block)数量 */};

复制代码

POSIX.1未要求st_rdev、st_blksize和st_blocks字段。Single UNIX Specification XSI扩展定义了这些字段

timespec结构类型按照秒和纳秒定义了时间，至少包括下面2个字段：

time_t tv_sec;long tv_nsec;

复制代码

使用stat函数最多的地方可能就是ls -l命令获得有关一个文件的所有信息

2.文件类型

普通(一般)文件

目录文件

块特殊文件

字符特殊文件

FIFO

套接字

符号链接

文件类型信息包含在stat结构的st_mode成员中。可以使用下图的宏判断文件类型（传入st_mode）：

POSIX.1允许实现将进程间通信(IPC)对象说明为文件。通过下图的宏可以确定IPC对象的类型（传入stat结构的指针）

3.用户ID和组ID

3.1 进程与文件的用户ID及组ID

与一个进程相关联的ID有6个或更多，下图是用户ID和组ID

实际用户ID和组ID

有效用户ID、有效组ID以及附属组ID

文件访问权限

有效用户ID

实际用户ID

有效组ID

实际组ID

所有者

组所有者

文件模式字

有效用户ID

有效组ID

设置用户ID位

进程的有效用户ID

文件所有者的用户ID

设置组ID位

进程的有效组ID

文件组所有者的ID

设置用户ID位

设置组ID位

因此，如果文件所有者是超级用户，而且设置了该文件的设置用户ID位，那么当该程序文件由一个进程执行时，该进程具有超级用户权限。不管执行此文件的进程的实际用户ID是什么，都会是这样

保存的设置用户ID和保存的设置组ID

3.2 修改文件的所有者和组所有者

如果owner或group中的任意一个是-1，则对应的ID不变：

chown函数

fchown函数

fchownat函数：更改相对于已打开目录fd的文件pathname的用户ID和组ID
- 函数在下列2种情况下，与chown或lchown相同
  flag
lchown函数：直接对符号链接进行更改

基于BSD的系统一直规定只有超级用户才能更改一个文件的所有者；System V则允许任一用户更改他们所拥有的文件的所有者

能否更改还与_POSIX_CHOWN_RESTRICTED常量是否对文件生效有关

4.文件访问权限

下图列出了文件访问权限的所有权限位，以及它们对普通文件和目录文件的作用：

最后9个常量还可以分成如下3组：

4.1 进程的文件访问权限

文件stat结构的st_mode成员除了包含设置用户ID位和设置组ID位用以修改进程的有效用户ID和有效组ID，还包含9个文件访问权限的位，这些权限位指明了所有者、组和其他对于该文件的访问权限，可分为3类：

任何文件类型都有访问权限

执行权限

读权限

文件

读权限

写权限

创建和删除文件：必须对该文件所在的目录具有写权限和执行权限
进程每次打开、创建或删除一个文件时，内核就进行文件访问权限测试，内核进行的测试如下：

若进程的有效用户ID是0

若进程的有效用户ID等于文件的所有者ID

若进程的有效组ID或进程的附属组ID之一等于文件的组ID

按顺序执行这4步

如果进程希望按照其实际用户ID和实际组ID来测试其访问能力，那么可以使用下列函数（进程使用实际用户ID和实际组ID来测试其访问能力也分成4步，与上面相同）：

mode：欲测试的权限位标志（可以是下列值按位或）
flag参数可以用于改变faccessat的行为，如果flag设置为AT_EACCESS，访问检查用的是调用进程的有效用户ID和有效组ID，而不是实际用户ID和实际组ID

这两个函数在下面2种情况下是相同的：

4.2 新文件的文件访问权限

可以使用umask函数为进程设置文件模式创建屏蔽字，并返回之前的值：

在进程创建一个新文件或新目录时，一定会使用文件模式创建屏蔽字。在文件模式创建屏蔽字为1的位，在文件mode中的相应位一定被关闭。因此，使用creat创建文件时，指定的mode，屏蔽掉文件模式创建屏蔽字中为1的位，就是新创建文件的权限
子进程的文件模式创建屏蔽字不会影响父进程。因此，如果子进程修改了文件模式创建屏蔽字，父进程的文件模式创建屏蔽字不会改变（如shell在调用一个会修改文件创建屏蔽字的程序前后使用umask打印文件创建屏蔽字，不会发生改变）
下图为八进制的屏蔽位和含义：

4.3 修改文件访问权限

chmod函数

fchmod函数

fchmodat函数

chmod函数

修改文件的权限位的前提是：进程的有效用户ID必须等于文件的所有者ID，或者进程必须具有超级用户权限

ls -l列出的是文件内容最后修改的时间，这里介绍的函数修改文件权限是在修改inode，所以ls -l列出的时间不会发生变化

5.新文件和目录的所有权

用户ID

进程的有效用户ID

关于组ID，POSIX.1允许实现选择下列之一作为新文件或新目录的组ID

6.粘着位

即S_ISVTX

粘着位

保存正文位

用途

现在，系统扩展了粘着位的使用范围，Single UNIX Specification允许针对目录设置粘着位。如果对一个目录设置了该位，只有满足下列2个情况，才能删除或重命名该目录下的文件：

目录/tmp和/var/tmp就是设置粘着位的典型候选者

7.文件长度

stat结构的st_size成员表示以字节为单位的文件的长度。该字段只对普通文件、目录文件和符号链接有意义

普通文件

符号链接

7.1 文件中的空洞

普通文件可以包含空洞。空洞是由所设置的偏移量超过文件尾端，并写入了某些数据后造成的
空洞并不占用实际磁盘空间，但是会参与文件大小的计算，在读文件时，读到空洞部分的内容是字节0
7.2 文件截断

可以在打开文件时使用O_TRUNC标志将文件截断为0
下列函数可以截断文件：

8.硬链接

8.1 创建硬链接

link函数

linkat函数

现有文件
新的路径名
flag

对于linkat函数：

如果两个路径名中的任一个是相对路径，那么需要通过相对于对应的文件描述符进行计算
如果两个路径名中的任一个是绝对路径，那么相应的文件描述符参数就会被忽略

如果实现支持创建指向一个目录的硬链接，那么也仅限于超级用户才可以这样做

8.2 删除硬链接

要删除硬链接，必须对包含该目录项(硬链接)的目录具有写和执行权限

unlinkat

rmdir

unlinkat

unlink

如果pathname是符号链接，那么unlink删除该符号链接，而不是删除由该链接所引用的文件

unlink

rmdir

这两个函数会删除目录项，并将由pathname所引用文件的链接计数减1

何时删除实际文件？

关闭一个文件时，内核首先检查打开该文件的进程个数。如果这个数达到0，内核再去检查其链接数；如果链接数，如果也是0，那么就删除该文件的内容
unlink的这种特性经常被程序用来确保即使是在程序崩溃时，它所创建的临时文件也不会遗留下来。进程用open或creat创建一个文件，然后立即调用unlink，因为该文件仍旧是打开的，所以不会将其内容删除。只有当进程关闭该文件或终止时，该文件的内容才被删除
也可以用remove函数（c库函数）解除对一个文件或目录的链接：

9.符号链接

符号链接是对一个文件的间接指针。与硬链接直接指向文件的inode不同，符号链接是为了避开硬链接的一些限制：

对于符号链接以及它指向何种对象并无任何文件系统限制（符号链接一般用于将一个文件或整个目录结构移到系统中另一个位置）
下图指明当传入的文件名表示一个符号链接时，函数能否跟随符号链接处理其链接的目标文件：

上图没有mkdir、mkinfo、mknod和rmdir，因为当这些函数的路径名是符号链接时，函数出错返回

用open打开文件时，如果传递给open函数的路径名指定了一个符号链接，那么open跟随此符号链接到达所指定的文件。若此符号链接所指向的文件并不存在，则open返回出错，表示它不能打开该文件

9.1 创建符号链接

symlink函数

symlinkat函数

symlink

9.2 读取符号链接

因为open函数跟随符号链接，所以需要一种方法打开该链接本身，并读该链接中的名字。下列函数提供了这种功能：

readlinkat

readlink

readlinkat

两个函数组合了open、read和close的所有操作。如果函数成功执行，则返回读入buf的字节数。在buf中返回的符号链接的内容不以null字节终止
10.目录

10.1 创建目录

mkdirat函数

mkdir函数

对于目录通常至少要设置一个执行权限位，以允许访问该目录中的文件名
10.2 删除目录

10.3 读目录

对某个目录具有访问权限的任一用户都可以读该目录，但是，为了防止文件系统产生混乱，只有内核才能写目录

fdopendir函数

telldir函数

seekdir函数

结构dirent定义在<dirent.h>中，具体实现相关，至少包含下列2个成员：

struct dirent{
ino_t d_ino;/* inode号 */char d_name[];/* null-terminated文件名 */...};

复制代码

DIR结构是一个内部结构，用以保存当前正在被读的目录的有关信息。作用类似于FILE结构
10.4 更改当前目录

每个进程都有一个当前工作目录，此目录是搜索所有相对路径名的起点（不以斜线开始的路径名为相对路径名）
用户登录到UNIX系统时，其当前工作目录通常是口令文件（/etc/passwd）中该用户登录项的第6个字段——用户的起始目录

下列2个函数可以更改当前工作目录：

这两个函数分别用pathname或打开文件描述符fd来指定新的当前工作目录
10.5 获取当前目录的绝对路径

11.重命名

如果oldname指的是一个文件(而不是目录)，并且newname已经存在，且不是一个目录
如果oldname指的是一个目录，并且newname已经存在，且是一个目录（而且应当是空目录）
如果oldname或newname是符号链接
不能对.和..重命名（更确切的说，.和..都不能出现在oldname和newname的最后部分）如果oldname和newname引用同一文件，则函数不做任何更改而成功返回

权限：如果newname已经存在，则调用进程对它需要由写权限。另外，调用进程将删除oldname目录项，并可能要创建newname目录项，所以它需要对包含oldname及包含newname的目录具有写和执行权限
12.文件的时间

对每个文件维护3个时间字段，他们的意义如下图：

12.1 更改文件的访问和修改时间

下列2个函数包含在POSIX.1中，可以指定纳秒级精度的时间戳：

times：日历时间，自特定时间（1970年1月1日00:00:00）以来所经过的时间
utimensat函数的path参数是相对于fd参数进行计算的，fd要么是打开目录的文件描述符，要么设置为特殊值AT_FDCWD（强制通过相对于调用进程的当前目录计算path）。如果path指定了绝对路径，那么fd参数被忽略。如果flag参数设置了AT_SYMLINK_NOFOLLOW标志，那么修改的是符号链接本身。默认的行为是会跟随符号链接

时间戳可以按下列4种方式之一进行指定：

执行这些函数所要求的权限取决于times参数的值：

如果times是非空指针

下列函数包含在Single UNIX Specification的XSI扩展选项中，时间戳是用秒和微妙表示的：

13.设备特殊文件

st_dev和st_rdev两个字段的有关规则：

major

minor

可以使用cat /proc/devices查看系统上的字符设备和块设备号：

chenximing@chenximing-MS-7823:~$ cat /proc/devices
Character devices:
1 mem
4 /dev/vc/0
4 tty
4 ttyS
5 /dev/tty
5 /dev/console
5 /dev/ptmx
5 ttyprintk
6 lp
7 vcs
10 misc
13 input
21 sg
29 fb
89 i2c
99 ppdev
108 ppp
116 alsa
128 ptm
136 pts
180 usb
189 usb_device
216 rfcomm
226 drm
247 mei
248 hidraw
249 bsg
250 watchdog
251 rtc
252 dimmctl
253 ndctl
254 tpm
Block devices:
1 ramdisk
259 blkext
7 loop
8 sd
9 md
11 sr
65 sd
66 sd
67 sd
68 sd
69 sd
70 sd
71 sd
128 sd
129 sd
130 sd
131 sd
132 sd
133 sd
134 sd
135 sd
252 device-mapper
253 virtblk
254 mdp

复制代码

我的环境中有一块磁盘划分了3个分区：

chenximing@chenximing-MS-7823:~$ df -h |grep'sda'
/dev/sda2 46G 32G 12G 74% /
/dev/sda1 453M 433M 0 100% /boot
/dev/sda3 275G 30G 232G 12% /home
chenximing@chenximing-MS-7823:~$ ls -l /dev/sda1 /dev/sda2 /dev/sda3
brw-rw---- 1 root disk 8, 1 6月 19 10:11 /dev/sda1
brw-rw---- 1 root disk 8, 2 6月 19 10:11 /dev/sda2
brw-rw---- 1 root disk 8, 3 6月 19 10:11 /dev/sda3

复制代码

对于下列程序：

#include<sys/stat.h>#include<stdio.h>#include<stdlib.h>intmain(){struct stat buf1,buf2,buf3;if(stat("/dev/sda1",&buf1)<0)exit(1);if(stat("/dev/sda2",&buf2)<0)exit(1);if(stat("/dev/sda3",&buf3)<0)exit(1);printf("dev = %d/%d",major(buf1.st_dev),minor(buf1.st_dev));if(S_ISCHR(buf1.st_mode)||S_ISBLK(buf1.st_mode))printf(" (%s) rdev = %d/%d",(S_ISCHR(buf1.st_mode))?"character":"block",major(buf1.st_rdev),minor(buf1.st_rdev));printf("\n");printf("dev = %d/%d",major(buf2.st_dev),minor(buf2.st_dev));if(S_ISCHR(buf2.st_mode)||S_ISBLK(buf2.st_mode))printf(" (%s) rdev = %d/%d",(S_ISCHR(buf2.st_mode))?"character":"block",major(buf2.st_rdev),minor(buf2.st_rdev));printf("\n");printf("dev = %d/%d",major(buf3.st_dev),minor(buf3.st_dev));if(S_ISCHR(buf3.st_mode)||S_ISBLK(buf3.st_mode))printf(" (%s) rdev = %d/%d",(S_ISCHR(buf3.st_mode))?"character":"block",major(buf3.st_rdev),minor(buf3.st_rdev));printf("\n");return0;}

复制代码

输出结果为：

chenximing@chenximing-MS-7823:~$ ./a.out
dev = 0/6 (block) rdev = 8/1
dev = 0/6 (block) rdev = 8/2
dev = 0/6 (block) rdev = 8/3

复制代码

将"/dev/sda1"，"/dev/sda2"、"/dev/sda3"分别替换成"/boot"、"/“和”/home"，输出结果为:

chenximing@chenximing-MS-7823:~$ ./a.out
dev = 8/1
dev = 8/2
dev = 8/3

复制代码

三.标准I/O库

标准I/O库处理很多细节，如缓冲区分片、以优化的块长度执行I/O等。这些处理使用户不必担心如何选择使用正确的块长度。这使得它便于用户使用，但是如果不深入了解I/O库函数的操作，也会带来一些问题
1.流

标准I/O库与文件I/O区别：

围绕文件描述符

围绕流

当用标准I/O库打开或者创建一个文件时，就有一个内建的流与之相关联
1.1 流的定向

流的定向决定了所处理的字符是单字节还是多字节的

对于ASCII字符集，一个字符用一个字节表示；对于国际字符集，一个字符可以用多个字节表示。标准I/O文件流可用于单字节或者多字节字符集。流的定向决定了所处理的字符是单字节还是多字节的

当一个流最初被创建时，它并没有定向

只有两个函数可以改变流的定向

参数：
- mode：流的定向模式。

注意：如果fp是无效流，由于fwide从返回值无法得知函数执行成功还是失败。那么我们必须采用这个方法：首先在调用fwide之前清除errno。然后在fwide之后检查errno的值。通过errno来检测fwide执行成功还是失败
1.2 3个标准流

操作系统对每个进程定义了3个流，并且这3个流可以自动地被进程使用，他们都是定义在<stdio.h>中：

标准输入

标准输出

标准错误

2.FILE对象

当使用fopen函数打开一个流时，它返回一个指向FILE对象的指针（书中称作文件指针）。该对象通常是一个结构，包含了标准I/O库为管理该流所需要的所有信息，包括：

应用程序没必要检验FILE对象，只需要将FILE指针作为参数传递给每个标准I/O函数
FILE对象包含有文件描述符，标准I/O函数可以看作是对fd直接操作的系统调用的封装，优点是带有I/O缓冲，从而减少系统调用的次数：

3.缓冲

标准IO库提供缓冲的目的是：尽量减少使用read和write调用的次数。标准I/O库对每个I/O流自动地进行缓冲管理，从而避免了程序员需要手动管理这一点带来的麻烦
3.1 3种缓冲类型

标准I/O库提供了三种类型的缓冲：

全缓冲

行缓冲：此时当输入和输出中遇到换行符时，标准I/O库执行实际的I/O操作。但是注意：
不带缓冲：标准I/O库不进行缓冲。此时任何I/O都立即执行实际的I/O操作

在一个流上执行第一次I/O操作时，相关标准的I/O函数通常调用 malloc 获取使用的缓冲区
下列函数可以设置流的缓冲类型：

参数：
- mode：指定缓冲类型。可以为：
  size：缓冲的长度

注意：

如果在一个函数内分配一个自动变量类型的标准I/O缓冲区，为了防止内存泄露，从该函数返回之前，必须关闭流。因为自动变量是栈上分配，函数返回之后自动变量被销毁

这种情况下若关闭此流，则标准I/O库会自动释放缓冲区

3.2 缓冲区冲洗

参数：

冲洗是双向的：1）输出流 —> 内核 —> 磁盘或者终端； 2）输入流—> 用户缓冲区
冲洗并不是立即写到磁盘文件中。冲洗只是负责数据传到内核
3.3 标准流与缓冲

标准输入与标准输出

行缓冲

全缓冲

标准错误

不带缓冲

4.相关调用

4.1 打开流

参数：
- type：指定对该I/O流的读写方式（具体见下图）
  pathname：待打开文件的路径名fp：指定的流（若fp已经打开，则先关闭该流；若fp已经定向，则清除该定向）fd：指定的文件描述符。获得的标准I/O流将与该描述符结合

这几个函数的常见用途：

某些特殊类型的文件（如管道、socket文件）不能用fopen打开，必须先获取文件描述符，然后对文件描述符调用fdopen

注意：当以读和写类型打开一个文件时(type中带+号的类型)，有下列限制：

如果写操作后面没有fflush,fseek,fsetpos,rewind操作之一，则写操作后面不能紧跟读操作

如果读操作后面没有fseek,fsetpos,rewind操作之一，也没有到达文件末尾，则在读操作之后不能紧跟写操作

默认情况下，流被打开时是全缓冲的。但是如果流引用的是终端设备，则流被打开时是行缓冲的
4.2 关闭流

4.3 读写流

一旦打开了流，可以在3种不同类型的非格式化I/O中选择，对流进行读、写操作：

每次一个字符的I/O。一次读、写一个字符。若流是带缓冲的，则标准I/O函数处理所有缓冲
每次一行的I/O。一次读、写一行。每一行都以一个换行符终止
直接I/O(二进制I/O、一次一个对象I/O)。每次I/O读、写某种数量的对象，每个对象具有指定的长度。常用于从二进制文件中每次读或写一个结构

格式化I/O由printf和scanf族函数完成

1）每次读一个字符

参数：

注意：

getchar()等价于getc(stdin)。它从标准输入中读取一个字符
- getc和fgetc的区别在于：getc可能通过宏定义来实现，而fgetc不能实现为宏。因此：
  这三个函数在返回下一个字符时，将unsigned char类型表示的字符转换成了int类型。（因为需要通过返回EOF来标记到达末尾或者出错。而EOF通常是常量 -1 。所以需要返回 int）

2）读取错误判断

上述3个函数不管是出错还是到达文件尾端，都返回相同值，下面的函数可以进行区分

参数：

大多数实现中，为每个流在FILE对象中维护了两个标志：文件出错标志和文件结束标志。clearerr函数用来清除这两个标志
3）将读取字符压回流中

参数：

注意：

ungetc通常用于这样的情形：正在读取一个输入流，然后需要根据某个字符串（标记字符串）来对输入进行切分。那么我们就需要先看一看下一个字符，来决定如何处理当前字符。此时需要方便的将刚查看的字符回送

ungetc只是将字符压入流缓冲区中，并没有压入底层的磁盘文件或者操作系统内核中

4）每次写一个字符

参数：

注意：

5）每次读一行

参数：

注意：

对于fgets函数，必须指定缓冲区的长度n。该函数一直读到下一个换行符为止，但是不超过n-1个字符
对于gets函数，从标准输入总读取字符。由于无法指定缓冲区的长度，因此很可能造成缓冲区溢出漏洞，故该函数不推荐使用。gets与fgets的另一个区别是：gets并不将换行符存入缓冲区中对于发生错误和读到末尾，都是返回NULL

6）每次写一行

参数：

注意：

字符串不要求以换行符结尾！

但是puts随后又将一个换行符写到标准输出中！

7）二进制I/O

参数：
返回值：
- 成功或失败：读/写的对象数

使用二进制I/O的基本问题是：它只能用在读取同一个操作系统上已写的数据。如果跨操作系统读写，则很可能工作异常。因为：

4.4 定位流

有3种方法定位标准I/O流：

需要移植到非UNIX系统上运行的应用程序应该使用fgetpos和fsetpos

1）ftell与fseek

对于二进制文件
对于文本文件

rewind函数也可以将一个流设置到文件的起始位置
2）ftello与fseeko

除了偏移量的类型是off_t而非long，ftello函数与ftell相同，fseeko函数与fseek相同
3）fgetpos与fsetpos

fgetpos和fsetpos都是ISO C标准引入的
fgetpos将文件位置指示器的当前值存入由pos指向的对象中，在以后调用fsetpos时，可以使用此值将流重新定位至该位置
4.5 格式化I/O

1）格式化输出

格式说明的格式：%[flags][fldwidth][precision][lenmodifier]convtype

最小字段宽(fldwidth)
精度(precision)
参数长度(lenmodifier)

2）格式化输入

scanf族用于分析输入字符串，将字符序列转换成指定类型的变量。在格式之后的各参数中包含了变量的地址，用转换结果对这些变量赋值
除了转换说明和空白字符以外，格式字符串中的其他字符必须与输入匹配。如有一个字符不匹配，则停止后续处理，不再读输入的其余部分
转换说明的格式：%

[fldwidth][m][lenmodifier]convtype

4.6 获取流相应的文件描述符

如果要调用dup或fcntl等函数，则需要此函数

fileno不是ISO C标准部分，而是POSIX.1支持的扩展

4.7 创建临时文件

ISO C标准I/O库提供了2个函数以帮助创建临时文件

tmpnam 产生一个与现有文件名不同的一个有效路径名字符串，每次调用都产生一个不同路径名。最多调用TMP_MAX次，定义在<stdio.h>中
- ptr：指向存放临时文件名的缓冲区的指针
tmpfile 创建一个临时二进制文件(类型wb+)，在关闭该文件或程序结束时将自动删除这种文件（注意，UNIX对二进制文件不进行区分）

tmpfile 经常使用的标准UNIX技术是先调用tmpnam产生一个唯一的路径名，然后，用该路径名创建一个文件，并立即unlink它。对一个文件解除链接并不删除其内容，关闭该文件时才删除其内容。而关闭文件可以是显式的，也可以在程序终止时自动进行
Single UNIX Specification为处理临时文件定义了另外两个函数：mkdtemp和mkstemp，它们是XSI的扩展部分：

mkdtemp 创建一个目录，该目录有一个唯一的名字
mkstemp 创建一个文件，该文件有一个唯一的名字

名字是通过template字符串进行选择的。这个字符串是后6位设置为XXXXXX的路径名。函数将这些占位符替换成不同的字符来构建一个唯一的路径名。如果成功的话，这两个函数将修改template字符串反映临时文件名
5.内存流

内存流：一种标准IO流，虽然它通过 FILE指针来访问，但是并没有底层的文件。所有的IO都是通过在缓冲区和主存之间来回传送字节来完成。虽然它看起来像是文件流，但是更适用于字符串操作

参数：
- size：内存流缓冲区的大小（字节数）
  type:控制如何使用流（即打开内存流的方式）

注意：

无论何时以追a方式打开内存流时，当前文件位置设为缓冲区中第一个null字节处。
当内存流不是a方式打开时，当前位置设置为缓冲区的开始位置如果buf是null，则打开流进行读或者写都没有任何意义。因为此时缓冲区是通过fmemopen分配的，没办法找到缓冲区的地址。任何时候需要增加流缓冲区中数据流以及调用fclose、fflush、fseek、fseeko、fsetpos时都会在当前位置写入一个null字节

创建内存流的其他两个函数：

参数：

open_memstream 创建的流是面向字节的，open_wmemstream 创建的流是面向宽字节的
这两个函数与fmemopen的不同在于：

在缓冲区地址和大小使用上要遵守规则：

因为避免了缓冲区溢出，内存流非常适用于创建字符串。因为内存流只访问主存，不访问磁盘上的文件，所以对于把标准I/O流作为参数用于临时文件的函数来说，会有很大的性能提升

四.进程环境

1.进程的启动与终止

1.1 main函数

C程序总是从main函数开始执行的。main函数的原型是：

int main(int argc,char* argv[]);

复制代码

参数：

#include<stdio.h>#include<stdlib.h>intmain(int argc,char* argv[]){printf("%d parameters: \n",argc);for(int i =0; i < argc; i++){//argv[argc]为NULLprintf(" %s\n", argv[i]);}return0;}

复制代码

上面的程序可以打印调用程序时的参数：

chenximing@chenximingdeMacBook-Pro ? ~ ? ./a.out hello ' ' world
4 parameters:
./a.out
hello
world

复制代码

当内核通过exec函数执行 C 程序、在调用main之前先调用一个特殊的启动例程

启动例程使得从main返回后立即调用exit函数。如果将启动例程以C代码形式表示（实际上该例程常常以汇编语言编写），则它调用main函数的形式可能是：

exit(main(argc,argv));

复制代码

1.2 进程终止的方式

有 8 种方式使得进程终止，其中 5 种为正常终止，3 种异常终止：

正常终止方式：
异常终止方式：

1.3 终止函数

下列3个函数正常终止一个程序

参数：

三个终止函数的区别：

exit和_Exit是由 ISO C 说明的， _exit是由 POSIX 说明的，因此头文件不同

1.4 终止状态

exit、exit、_Exit 都带有一个整型参数，称为终止状态（或称作退出状态）。大多数 UNIX 系统 shell 都提供检查进程终止状态的方法：

下列情况，进程的终止状态是未定义的：
下列情况，进程的终止状态是0：

main函数返回一个整型值与用该值调用exit是等价的：

main 函数中: exit(100);
等价于
return 100;

复制代码

在LINUX中，退出状态码最高是255，一般自定义的代码值为0~255，如果超出255，则返回取模后的值

1.5 登记终止处理程序

参数：

按照ISO C的规定，一个进程可以登记最多32个函数（通常操作系统会提供多于32个的限制。可以用sysconf函数查询这个限制值），这些函数将由exit函数自动调用。这些函数称作终止处理程序

2.环境表

每个程序都会接收一张环境表

与参数表一样，环境表也是一个字符指针数组
全局变量environ包含了该指针数组的地址：extern char **environ。我们称environ为环境指针，它位于头文件unistd.h中按照惯例，环境字符串由name=value这种格式的字符串组成

环境表和环境字符串通常存放在进程存储空间的顶部（栈的上方）

2.1 获取环境变量

getenv由ISO C定义，可以用其获取环境变量值

下图为一些环境变量和在不同系统上的支持情况：

2.2 修改环境变量

并不是所有系统都支持修改环境变量：

中间3个函数的原型如下：

setenv ：修改环境变量。如果环境变量已经存在，有下列2种可能：
unsetenv ：删除环境变量，即删除name的定义。即使不存在这种定义也不算出错

这些函数内部操作环境表非常复杂，下面是原理：

修改：
增加：
- 如果这是第一次增加一个新的name：
- 如果这不是第一次增加一个新的name，则可知以前已经调用了malloc：
删除：

修改和增加复杂的原因在于：环境表和环境字符串通常占用的是进程地址空间的顶部，所以它不能再向高地址方向扩展；同时也不能移动在它之下的各栈帧，所以也不能向低地址方向扩展。两者组合使得该空间的长度不能再增加

3.C程序的存储空间布局

正文段（.text段）：这是由CPU执行的机器指令部分
初始化数据段（.data段）：通常将它称作数据段（存放在磁盘可执行文件中，故而占磁盘空间）
未初始化数据段（.bss段）：通常将它称作bss段。在程序开始执行之前，内核将此段中的数据初始化为0或者空指针
栈：临时变量以及每次函数调用时所需要保存的信息都存放在此段中
堆：通常在堆中进行动态存储分配

注意：

存放在磁盘文件中

正文段

初始化数据段

下列程序打印不同段数据的位置：

#include<stdio.h>#include<stdlib.h>#include<unistd.h>externchar** environ;int global1;int global2 =1;intmain(){//1.环境变量char**env = environ;while(*env){printf("(%p) (%p) %s\n", env,*env,*env);
env++;}printf("\n");//2.全局变量printf("%p\n",&global1);printf("%p\n\n",&global2);//3.栈int local;char*localc =(char*)malloc(10);printf("%p\n",&local);printf("%p\n\n",&localc);//4.堆printf("%p\n\n", localc);return0;}

复制代码

我的环境下，输出如下：

chenximing@chenximing-MS-7823:~$ ./a.out
(0x7ffe4aa6f4c8) (0x7ffe4aa7078a) XDG_SESSION_ID=1
(0x7ffe4aa6f4d0) (0x7ffe4aa7079b) TERM=xterm-256color
(0x7ffe4aa6f4d8) (0x7ffe4aa707af) SHELL=/bin/bash
(0x7ffe4aa6f4e0) (0x7ffe4aa707bf) XDG_SESSION_COOKIE=526d72c400c09a742df8809a58e50d0e-1529375799.783462-1767108743
(0x7ffe4aa6f4e8) (0x7ffe4aa70810) SSH_CLIENT=192.168.2.1 53068 22
(0x7ffe4aa6f4f0) (0x7ffe4aa70830) SSH_TTY=/dev/pts/25
(0x7ffe4aa6f4f8) (0x7ffe4aa70844) USER=chenximing
...
(0x7ffe4aa6f508) (0x7ffe4aa70d75) MAIL=/var/mail/chenximing
(0x7ffe4aa6f510) (0x7ffe4aa70d8f) PATH=/home/chenximing/bin:/usr/local/go/bin:/usr/lib/jvm/jdk1.8.0_144/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/home/chenximing/bin
(0x7ffe4aa6f518) (0x7ffe4aa70e47) QT_QPA_PLATFORMTHEME=appmenu-qt5
(0x7ffe4aa6f520) (0x7ffe4aa70e68) PWD=/home/chenximing
(0x7ffe4aa6f528) (0x7ffe4aa70e7d) JAVA_HOME=/usr/lib/jvm/jdk1.8.0_144
(0x7ffe4aa6f530) (0x7ffe4aa70ea1) LANG=zh_CN.UTF-8
(0x7ffe4aa6f538) (0x7ffe4aa70eb2) SHLVL=1
(0x7ffe4aa6f540) (0x7ffe4aa70eba) HOME=/home/chenximing
(0x7ffe4aa6f548) (0x7ffe4aa70ed0) GOROOT=/usr/local/go
(0x7ffe4aa6f550) (0x7ffe4aa70ee5) LANGUAGE=zh_CN:zh
(0x7ffe4aa6f558) (0x7ffe4aa70ef7) LOGNAME=chenximing
(0x7ffe4aa6f560) (0x7ffe4aa70f0a) CLASSPATH=.:/usr/lib/jvm/jdk1.8.0_144/lib
(0x7ffe4aa6f568) (0x7ffe4aa70f34) SSH_CONNECTION=192.168.2.1 53068 192.168.2.4 22
(0x7ffe4aa6f570) (0x7ffe4aa70f64) LC_CTYPE=zh_CN.UTF-8
(0x7ffe4aa6f578) (0x7ffe4aa70f79) GOPATH=~/go
(0x7ffe4aa6f580) (0x7ffe4aa70f85) LESSOPEN=| /usr/bin/lesspipe %s
(0x7ffe4aa6f588) (0x7ffe4aa70fa5) XDG_RUNTIME_DIR=/run/user/1000
(0x7ffe4aa6f590) (0x7ffe4aa70fc4) LESSCLOSE=/usr/bin/lesspipe %s %s
(0x7ffe4aa6f598) (0x7ffe4aa70fe6) _=./a.out
0x60106c
0x601050
0x7ffe4aa6f3bc
0x7ffe4aa6f3c0
0x1725010

复制代码

画图表示：

4.共享库

大多数UNIX系统支持共享库

共享库的优点
共享库的缺点

不同系统中，程序可能使用不同的方法说明是否要使用共享库。比较典型的有cc(1)：

//以下阻止使用共享库
gcc -static hello1.c
//以下，gcc默认使用共享库
gcc hello1.c

复制代码

可以使用size a.out观察上面两种情况下可执行文件正文和数据段的长度变化
静态链接库与动态链接库

链接库按是否被编译到程序内部而分成动态与静态链接库

静态链接库

动态链接库

为了加速动态链接库的访问效率，一般需要将动态链接库载入内存中，从而避免读取磁盘。加载到高速缓存中的动态链接库所在的目录在文件/etc/ld.so.conf中指定，可以使用命令ldconfig将该文件中指定目录下的动态库读入缓存中
如果在编译时指定了动态链接库及库的路径，但是/etc/ld.so.conf文件中没有包含该路径，即这个动态链接库没有载入内存，那么运行生成的可执行文件会报错
ldd命令可以查看某个可执行的二进制文件含有什么动态链接库，对于前面的问题，如果某个动态链接库没有载入内存，即动态链接库的路径没有包含在文件/etc/ld.so.conf中。使用ldd查看时，这个库会显示“not found”
生成/加载静态链接库与动态链接库
图片来源
5.进程堆空间的管理

堆上空间分配和释放核心都是通过调整program break来实现的，malloc和free维护空闲空间链表，以减少调整program break的系统调用的调用次数

1）调整program break来分配与释放

可以通过brk函数和sbrk函数改变进程的program break位置，从而分配或释放内存。program break与进程的内存布局结构中&end位置相同
program break的位置抬升后，程序可以访问新分配区域内的任何内存地址，而此时物理内存页尚未分配。内核会在进程首次试图访问这些虚拟内存地址时自动分配新的物理内存页

brk：将program break设置为参数指定的位置
sbrk：将program break在原有地址上增加参数increment大小（intptr_t为整形类型），该函数成功时返回前一program break的地址

sbrk(0)将返回program break的当前位置，可以用于跟踪堆的大小，或是监视内存分配函数的行为

2）使用C库函数进行分配释放

malloc相比brk和sbrk，具有以下优点：

malloc ：分配指定字节数的存储区。存储区中的初始值不确定
calloc ：为指定数量指定长度的对象分配存储空间。空间中的每一位都初始化为0
realloc ：增加或减少以前分配区的长度
free ：上述3个函数都需通过free释放。一般情况下，free并不降低program break的位置，而是将这块内存增加到空闲内存列表中，供后续的malloc循环使用，原因是：

这3个分配函数所返回的指针一定是适当对齐的，使其可用于任何数据对象
这些分配例程通常用sbrk系统调用实现

malloc和free相关的致命性错误

3）malloc和free的实现

malloc的实现

首先会扫描（不同实现扫描策略可能不同）之前由free释放的空闲内存块列表，试图找到尺寸大小大于或等于要求的一块空闲内存
如果空闲内存列表中根本找不到足够大的空闲内存块（如首次调用malloc时），那么malloc会调用sbrk以分配更多的内存（为了减少对sbrk的调用次数，malloc并不是严格按所需字节数来分配内存，而是以更大幅度来增加program break，并将超出部分置于空闲内存列表）

当malloc分配内存块时，会额外分配几个字节来存放记录这块内存大小的整数值。该整数位于内存块的起始处，而实际返回给调用者的内存地址恰好位于这一长度记录字节之后：

free的实现

C语言允许程序创建指向堆中任意位置的指针，并修改其指向的数据，包括由free和malloc函数维护的内存长度、指向前一空闲块和后一空闲块的指针。如果发生这种缓冲区溢出的情况，会带来严重的后果

6.进程资源限制

每个进程都有一组资源限制，其中一些可以用getrlimit和setrlimit函数查询和更改：

进程的资源限制通常是在系统初始化时由0进程建立的，然后由后续进程继承。每种实现都可以用自己的方法对资源限制做出调整

参数

struct rlimit{
rlim_t rlim_cur;/* soft limit: current limit */
rlim_t rlim_max;/* hard limit: maximum value for rlim_cur */};

复制代码

资源限制影响到调用进程并由其子进程继承
7.Core Dump

内容参考
7.1 Core Dump的概念及用途

Core Dump是一个文件，它记录了程序运行过程中异常终止或崩溃时的内存映像

概念：当程序运行的过程中异常终止或崩溃，操作系统会将程序当时的内存状态记录下来，保存在一个文件中，这种行为就叫做Core Dump（中文有的翻译成“核心转储”)。可以认为 core dump 是“内存快照”，但实际上，除了内存信息之外，还有些关键的程序运行状态也会同时 dump 下来，例如寄存器信息（包括程序指针、栈指针等）、内存管理信息、其他处理器和操作系统状态和信息

Dump指的是拷贝一种存储介质中的部分内容到另一个存储介质，或者将内容打印、显示或者其它输出设备。dump 出来的内容是格式化的，可以使用一些工具来解析它

用途：core dump 对于编程人员诊断和调试程序是非常有帮助的，因为对于有些程序错误是很难重现的，例如指针异常，而 core dump 文件可以再现程序出错时的情景
7.2 产生Core Dump

ulimit -c可以查看shell进程产生的core dump文件大小，默认情况下为0，即不产生core dump文件，若要产生，使用ulimit -c unlimited开启core dump功能（也可以改成为某一值，注意这种修改方式只会对当前终端环境生效）

常见的几种情况：调用abort()函数、访存错误、非法指令等
以下列出几种会产生Core Dump的信号（不仅限于这几种）：

信号	动作	说明
SIGQUIT	终止+core	终端退出符(ctrl+\)
SIGILL	终止+core	非法硬件指令
SIGABRT	终止+core	异常终止(abort)
SIGSEGV	终止+core	无效内存引用
SIGTRAP	终止+core	硬件故障

修改core dump文件名

修改core dump文件的保存位置及文件名格式

7.3 调试Core Dump

1）无效内存引用

#include<stdio.h>intmain(){int*p =NULL;int x =*p;return0;}

复制代码

生成core dump：

root@068ca8da6d06:~# gcc -g test.c
root@068ca8da6d06:~# ls
a.out test.c
root@068ca8da6d06:~# ./a.out
Segmentation fault (core dumped)
root@068ca8da6d06:~# ls
a.out core test.c

复制代码

使用gdb调试：

root@068ca8da6d06:~# gdb a.out core...
...
Core was generated by `./a.out'.
Program terminated with signal SIGSEGV, Segmentation fault.
#0 0x0000556146c2160a in main () at test.c:6
6 int x = *p;
(gdb) where
#0 0x0000556146c2160a in main () at test.c:6
(gdb) info frame
Stack level 0, frame at 0x7ffe5f70daa0:
rip = 0x556146c2160a in main (test.c:6); saved rip = 0x7f65fcff1b97
source language c.
Arglist at 0x7ffe5f70da90, args:
Locals at 0x7ffe5f70da90, Previous frame's sp is 0x7ffe5f70daa0
Saved registers:
rbp at 0x7ffe5f70da90, rip at 0x7ffe5f70da98

复制代码

从上面可以看出,我们可以还原程序执行时的场景,并使用 where 可以查看当前程序调用函数栈帧, 还可以使用 gdb 中的命令查看寄存器,变量等信息

五.进程控制

1.进程标识

进程通过进程ID进行标识
进程ID可以复用。大多数UNIX系统实现延迟复用算法，使得赋予新建进程的ID不同于最近终止进程所使用的ID，从而防止新进程被认为是使用同一ID的某个已终止进程
1.1 2个特殊进程

0号进程：调度进程(也被称为系统进程或交换进程)

性质

1号进程：init进程

性质

启动时机

职责：

1.2 进程相关的ID获取函数

这些函数都没有出错返回
2.进程的创建

下列函数可以用来创建进程：

2.1 fork

返回值：

子进程和父进程继续执行fork调用之后的指令
1）执行顺序

一般来说，fork后父子进程谁先执行是不确定的，取决于内核所用的调度算法
2）数据共享

因为fork之后经常跟随着exec，所以很多实现中，子进程的数据段、堆和栈指向相应的父进程版本，因此父子进程共享使用，如果子进程有修改，会执行写时复制(COW)（通常将修改所在的一”页“进行复制）。从而不会影响父进程

注意父子进程之间I/O缓冲区的复制：
注意父子进程的文件描述符：

一个进程fork了一个子进程，然后等待子进程终止。假定，作为普通处理的一部分，父进程和子进程都向标准输出进行写操作。如果父进程的标准输出已重定向，那么子进程写到该标准输出时，它将更新与父进程共享的该文件的偏移量
除了打开的文件描述符之外，子进程还继承了父进程的下列属性：

父子进程的区别为：

3）fork失败的主要原因

4）fork的2种用法

2.2 vfork

vfork用于创建一个新进程，该新进程的目的是exec一个新程序，因此子进程并不将父进程的地址空间完全复制到子进程中
在子进程调用exec或exit之前，它在父进程的空间中运行。这种优化在某些UNIX系统的实现中提高了效率，但如果子进程修改数据、进程函数调用、或者没有调用exec或exit就返回都可能会带来未知的结果
vfork和fork之间的另一个区别是：vfork保证子进程先运行，在它调用exec或exit之后父进程才可能被调度运行（如果在调用这两个函数之前子进程依赖于父进程的进一步动作，则会导致死锁）

int globval =6;
int main(int argc,char ** argv) {
int val;
pid_t pid;
val = 88;
printf("before vfork\n");
if ((pid = vfork()) < 0) {
exit(1);
} else if (pid == 0) {
globval++;
val++;
_exit(0); //_exit并不执行标准I/O缓冲区的冲洗操作，如果调用的是exit，输出是不确定的
}
printf("pid=%ld,glob=%d,val=%d\n", (long) getpid(), globval, val);
exit(0);
}

复制代码

上述程序子进程会修改父进程地址空间中的数据，子进程修改变量后即退出，以下为父进程的输出：

before vfork
pid=30595,glob=7,val=89

复制代码

3.进程的终止

8种终止方式
不管进程如何终止，最后都会执行内核中的同一段代码。这段代码为相应进程关闭所有打开描述符，释放它所使用的存储器等
3.1 子进程向父进程传递状态

子进程正常终止

子进程异常终止

不管正常终止或异常终止，内核都向父进程发送SIGCHLD信号，父进程可以选择忽略该信号(默认动作)，或者提供一个信号处理函数
父进程能通过wait、waitpid获取子进程的终止状态

参数

父进程调用wait、waitpid时可能出现几种情况：

3.2 父子进程以不同顺序终止

父进程在子进程之前终止

孤儿进程

子进程在父进程之前终止

僵死进程

4.竞争条件

竞争条件是多个进程企图对共享数据进程某种处理，最终结果取决于进程运行的顺序
如果fork之后的某种逻辑显示或隐式地依赖于在fork之后是父进程先运行还是子进程先运行，那么fork就会是竞争条件活跃的滋生地
防止竞争条件最简单的手段：

子进程可以通过下列方式等待父进程先运行结束
1. while(getppid() != 1)
2. sleep(1);
复制代码
但是这种轮询方式会大量浪费CPU浪费

好的办法是使用信号进行通信，或者使用IPC
在父进程和子进程的关系中，常常出现下列情况：在fork之后，父进程和子进程都有一些事情要做。例如，，父进程可能要用子进程ID更新日志文件中的一个记录，而子进程则可能要为父进程创建一个文件。在本例中，要求每个进程在执行完它的一套初始化操作后要通知对方，并且在继续运行之前，要等待另一方完成其初始化操作：

TELL_WAIT();/* set things up for TELL_xxx & WAIT_xxx */if((pid =fork())<0){err_sys("fork error");}elseif(pid ==0){/* child *//* child does whatever is necessary ... */TELL_PARENT(getppid());/* tell parent we're done */WAIT_PARENT();/* and wait for parent *//* and the child continues on its way ... */exit(0);}/* parent does whatever is necessary ... */TELL_CHILD(pid);/* tell child we're done */WAIT_CHILD();/* and wait for child *//* and the parent continues on its way ... */exit(0);

复制代码

5.exec函数

当进程调用一种exec函数时，该进程执行的程序完全替换成新程序，而新程序则从main函数开始执行

正文段

数据段

堆

栈

有7种不同的exec函数可以供使用，它们被统称称作exec函数：

新程序指定方式

前四个

路径名

后两个函数取文件名作为参数（函数名中带p）
最后一个取文件描述符做参数

新程序的命令行参数

函数名中的l

函数名中的v

新程序的环境变量

函数名中的e

否则

7个函数之间的关系如下图：

执行exec后，进程ID没有改变。新程序从调用进程继承了下列属性：

注意：

系统默认行为是不设置执行时关闭标志

进程的实际用户ID 和实际组ID 不变，有效用户ID 和有效组ID 是否改变取决于所执行程序文件的设置用户ID位和设置组ID位是否设置

6.更改用户ID和更改组ID

用以修改进程的特权及访问控制

UNIX中，特权及访问控制，是基于用户ID和组ID的

6.1 setuid与setgid

谁能更改ID需要遵循若干规则，以用户ID为例（针对setgid的讨论类似setuid）：

进程具有超级用户特权

进程没有超级用户特权

上述讨论中，假设_POSIX_SAVED_IDS为真。如果未提供此功能，则对于保存的设置用户ID部分都无效
操作系统内核为每个进程维护3个用户ID：实际用户ID、有效用户ID、保存的设置用户ID：

只有超级用户进程可以更改实际用户ID

仅当对程序文件设置了设置用户ID位时，exec函数才设置有效用户ID。如果设置用户ID位没有设置，则exec函数不会改变有效用户ID，而是维持其现有值
保存的设置用户ID是由exec复制有效用户ID而得到。如果设置了文件的设置用户ID位，则exec根据文件的用户ID设置了进程的有效用户ID之后，这个副本就保存起来

下图总结了更改这3个用户ID的不同方法：

目前可以通过getuid获取进程的当前实际用户ID，可以通过geteuid获取进程的当前有效用户ID，但是没有函数获取进程当前的保存的设置用户ID
6.2 setreuid和setregid

历史上，BSD支持setreuid函数，其功能是交换实际用户ID和有效用户ID的值

若其中任一参数为-1，则表示相应的ID应当保持不变
一个非特权用户总能交换实际用户ID和有效用户ID（这就允许一个设置用户ID程序交换用户的普通权限，以后又再次交换回设置用户ID权限。POSIX.1引进了保存的设置用户ID特性后，其规则也相应加强，它允许一个非特权用户将其有效用户ID设置为保存的设置用户ID）
6.3 seteuid和setegid

POSIX.1提供下列2个函数，类似于setuid和setgid，但是他们只更改有效ID，不更改实际ID：

非特权用户

特权用户

7.system函数

system用于将一个字符串作为命令来执行
ISO C定义了system函数，但是其操作对系统的依赖性很强。POSIX.1包括了system接口，它扩展了ISO C定义，描述了system在POSIX.1环境中的运行行为

参数：
返回值：
- system等同于同时调用了fork、exec、waitpid，有3种返回值：

system VS fork + exec：

优点

缺点：一旦调用system的进程具有超级用户权限，则system执行的命令也具有超级用户权限。因为system的实现过程中并没有更改有效用户ID和实际用户ID的操作

8.用户标识

返回值：

通常失败的原因是：调用此函数的进程没有连接到用户登录时所用的终端。比如守护进程
9.进程调度

进程可以通过调整nice值选择以更低优先级运行，只有特权进程允许提高调度权限

进程可以通过nice函数获取或更改它的nice值，进程只能影响自己的nice值，不能影响任何其他进程的nice值：

参数
返回值

getpriority函数可以像nice函数那样用于获取进程的nice值，但是它还可以获取一组相关进程的nice值：

参数：
- which：控制who参数是如何解释的。可以取三个值之一：
- who：选择感兴趣的一个或者多个进程
  value：nice的增量

setpriority函数可用于为进程、进程组和属于特定用户ID的所有进程设置优先级

参数：

Single UNIX Specification没有对在fork之后子进程是否继承nice值制定规则。而是留给具体实现自行决定。但是遵循XSI的系统要求进程调用exec后保留nice值。在FreeBSD 8.0、Linux 3.2.0、MacOS x 10.6.8以及Solaris 10中，子进程从父进程中继承nice值

10.进程时间

任一进程可调用times函数获得它自己以及已终止子进程的墙上时钟时间、用户CPU时间、系统CPU时间

该函数填写由buf指向的tms结构：

struct tms{
clock_t tms_utime;/* 用户CPU时间 */
clock_t tms_stime;/* 系统CPU时间 */
clock_t tms_cutime;/* 已终止子进程的用户CPU时间 */
clock_t tms_cstime;/* 已终止子进程的系统CPU时间 */};

复制代码

结构中两个针对子进程的字段包含了此进程用wait函数族已等待到的各子进程的值
墙上时钟时间作为函数返回值返回。这个值是相对于过去的某一时刻度量的，所以不能用其绝对值而必须使用相对值。例如，调用times，保存其返回值。在以后某个时间再次调用times，从新返回的值中减去以前返回的值，此差值就是墙上时钟时间（一个长期运行的进程可能其墙上时钟时间会溢出，当然这种可能性极小）
所有由此函数返回的clock_t值都用sysconf(_SC_CLK_TCK)(每秒时钟滴答数)转换成秒数
六.线程

当一个进程需要另一个实体来完成某事时，Unix上大多数网络服务器通过fork一个子进程来处理。但是fork调用存在一些问题：

fork是昂贵的

写时拷贝

fork返回之后父子进程之间信息的传递需要进程间通信(IPC)机制

线程有助于解决上述问题，它被称为“轻量级进程”，创建可能比进程的创建快10~100倍。但是，伴随这种简易性而来的是同步问题
线程之间的资源共享：

同一进程内的线程共享

线程之间不共享

这一章介绍的是POSIX线程，也称为Pthread。POSIX线程作为POSIX.1c标准的一部分在1995年得到标准化，大多数UNIX版本将来会支持这类线程。所有Pthread函数都以pthread_打头

1.相关函数

1）pthread_create函数

该函数用于创建一个POSIX线程。当一个程序由exec启动执行时，称为“初始线程”或“主线程”的单个线程就创建了。其余线程则由pthread_create函数创建

tid

attr

func

arg

如果发生错误，函数返回指示错误的某个正值，不会设置errno变量
创建的线程通过调用指定的函数开始执行，然后显示地（通过调用pthread_exit）或隐式地（通过让该函数返回）终止
线程创建时，并不能保证哪个线程会先运行
2）pthread_join函数

pthread_join类似于进程中的waitpid，用于等待一个给定线程的终止

tid

status

对于一个非脱离状态的线程，如果没有其它线程调用pthread_join等待线程终止，那么线程终止后的资源无法回收，会造成资源浪费，进而影响同一进程创建的线程数量

#include "apue.h"
#include <pthread.h>
void *
thr_fn1(void *arg)
{
printf("thread 1 returning\n");
return((void *)1);
}
void *
thr_fn2(void *arg)
{
printf("thread 2 exiting\n");
pthread_exit((void *)2);
}
int
main(void)
{
int err;
pthread_t tid1, tid2;
void *tret;
err = pthread_create(&tid1, NULL, thr_fn1, NULL);
if (err != 0)
err_exit(err, "can't create thread 1");
err = pthread_create(&tid2, NULL, thr_fn2, NULL);
if (err != 0)
err_exit(err, "can't create thread 2");
err = pthread_join(tid1, &tret);
if (err != 0)
err_exit(err, "can't join with thread 1");
printf("thread 1 exit code %ld\n", (long)tret);
err = pthread_join(tid2, &tret);
if (err != 0)
err_exit(err, "can't join with thread 2");
printf("thread 2 exit code %ld\n", (long)tret);
exit(0);
}

复制代码

上述程序输出如下：

thread 1 returning
thread 2 exiting
thread 1 exit code 1
thread 2 exit code 2

复制代码

3）pthread_self函数

线程可以使用pthread_self获取自身的线程ID，类似于进程中的getpid

新线程不应该根据主线程调用pthread_create函数时传入的tid参数来获取自身ID，而是应该调用pthread_self，因为新线程可能在主线程调用pthread_create返回之前运行，如果读取tid，看到的是未经初始化的内容
4）pthread_detach函数

该函数把指定的线程转变为脱离状态，通常由想让自己脱离的线程调用：pthread_detach(pthread_self());
一个线程或者是可汇合的，或者是脱离的：

可汇合

脱离：脱离的线程像守护进程，当它们终止时，所有相关资源都被释放，不能等待它们终止

5）pthread_exit函数

线程终止的一个方法：

status

让一个线程终止的其它方法：

线程执行的函数返回

被同一进程的其它线程调用pthread_cancel取消

任何线程调用returnexit、_Exit、_exit终止时，整个进程就终止了，其中包括它的任何线程

如果主线程调用了pthread_exit，而非exit或return，那么其它线程将继续运行

下列程序status指向一个栈上的结构，这个栈上的对象被后来的线程覆盖：

#include"apue.h"#include<pthread.h>struct foo {int a, b, c, d;};voidprintfoo(constchar*s,conststruct foo *fp){printf("%s", s);printf(" structure at 0x%lx\n",(unsignedlong)fp);printf(" foo.a = %d\n", fp->a);printf(" foo.b = %d\n", fp->b);printf(" foo.c = %d\n", fp->c);printf(" foo.d = %d\n", fp->d);}void*thr_fn1(void*arg){struct foo foo ={1,2,3,4};printfoo("thread 1:\n",&foo);pthread_exit((void*)&foo);}void*thr_fn2(void*arg){printf("thread 2: ID is %lu\n",(unsignedlong)pthread_self());pthread_exit((void*)0);}intmain(void){int err;
pthread_t tid1, tid2;struct foo *fp;
err =pthread_create(&tid1,NULL, thr_fn1,NULL);if(err !=0)err_exit(err,"can't create thread 1");
err =pthread_join(tid1,(void*)&fp);if(err !=0)err_exit(err,"can't join with thread 1");sleep(1);printf("parent starting second thread\n");
err =pthread_create(&tid2,NULL, thr_fn2,NULL);if(err !=0)err_exit(err,"can't create thread 2");sleep(1);printfoo("parent:\n", fp);exit(0);}

复制代码

mac上输出如下：

thread 1:
structure at 0x700000080ed0
foo.a = 1
foo.b = 2
foo.c = 3
foo.d = 4
parent starting second thread
thread 2: ID is 123145302839296
parent:
structure at 0x700000080ed0
[1] 34604 segmentation fault ./badexit2

复制代码

6）pthread_equal函数

线程ID是用pthread_t数据类型来表示的，实现的时候可以用一个结构来表示该数据类型，所以可移植的操作系统实现不能把它作为整数处理。因此必须使用一个函数来对两个线程ID进程比较

Linux 3.2.0使用无符号长整型表示pthread_t数据类型。Solaris 10将其表示为无符号整形。FreeBSD 8.0和Mac OS X 10.6.8用一个指向pthread结构的指针来表示pthread_t数据类型

7）pthread_cancel函数

该函数可以被某一线程调用，用来请求取消同一进程中的其它线程

线程控制自身对pthread_cancel函数的响应行为：取消选项
8）pthread_cleanup_push和pthread_cleanup_pop函数

以下函数被线程调用时，可以添加或清除清理函数：

这2个函数可以被实现为宏，通常pthread_cleanup_push会带有一个{，而pthread_cleanup_pop会带有1个’}’。因此，在使用时，2个函数应该配对出现

下列情况会调用清理函数：

以下情况不会调用清理函数；

不管excute参数是否为0，pthread_cleanup_pop函数都会将线程清理函数栈的栈顶函数删除
以下为一个测试程序：

#include<stdio.h>#include<pthread.h>intexceptionFun(){pthread_exit((void*)0);//会调用clean//return 0; //会不会调用clean取决于exceptionFun外的pthread_cleanup_pop的参数//exit(0); //不会调用clean//_Exit(0); //不会调用clean}voidclean(void*arg){printf("clean function\n");}void*thr1(void*arg){printf("thread 1 created\n");pthread_cleanup_push(clean,NULL);//pthread_exit((void *)0); //会调用clean，第2个线程会启动//return 0; //不会调用clean，且第2个线程不会启动//exit(0); //不会调用clean，且第2个线程不会启动//_Exit(0); //不会调用clean，且第2个线程不会启动pthread_cleanup_pop(1);//pthread_cleanup_pop(0)时，如果没有在push和pop之间退出，那么不会执行clean//否则，根据退出时调用的是pthread_exit，return...决定}void*thr2(void*arg){printf("thread 2 created\n");pthread_cleanup_push(clean,NULL);exceptionFun();pthread_cleanup_pop(1);}intmain(){
pthread_t tid;pthread_create(&tid,NULL,thr1,NULL);pthread_join(tid,NULL);pthread_create(&tid,NULL,thr2,NULL);pthread_join(tid,NULL);return0;}

复制代码

2.线程同步

互斥锁

读写锁

条件变量

自旋锁

屏障

2.1 互斥锁

也称为互斥量

多线程编程中，多个线程可能修改相同的变量，导致错误发生。互斥锁可以用于保护共享变量：访问共享变量的前提条件是持有该互斥锁，按照Pthread，互斥锁的类型为pthread_mutex_t的变量
1）互斥锁的初始化与销毁

如果某个互斥锁变量是静态分配的，必须把它初始化为常值PTHREAD_MUTEX_INITIALIZER

如果在共享内存区中分配一个互斥锁，必须通过调用pthread_mutex_init函数在运行时初始化，此时在释放内存前需要调用pthread_mutex_destroy

如果释放互斥锁时，有一个以上的线程阻塞，那么所有该锁上的阻塞线程都会变成可运行状态，第一个变为运行的线程就可以对互斥锁加锁，其它线程就会看到互斥锁依然是锁着的，只能回去再次等待它重新变为可用。这种方式下，每次只有一个线程可以向前执行
2）互斥锁的加锁与解锁

mptr

pthread_mutex_lock

pthread_mutex_trylock

pthread_mutex_unlock

使用互斥锁解决修改相同变量的问题（本书作者测试这个程序和前面有问题的版本运行的时间，差别是10%，说明互斥锁并不会带来太大的开销）
使用互斥锁时避免死锁：

如果使用多个互斥锁，并且每个线程取得其中一个，阻塞于对另一个的请求上，也会死锁

3）互斥锁的定时加锁

该函数试图对一个互斥锁进行加锁，如果互斥锁已经上锁，那么线程会阻塞到参数tsptr指定的时刻（这个时间是一个绝对时间，即某个时刻，而不是一个等待时间段）。如果仍为获得互斥锁，那么返回ETIMEDOUT

Max OS X 10.6.8还没有支持该函数

2.2 读写锁

也称作共享互斥锁：当读写锁是读模式锁住时，可以说成是共享模式锁住的；当它是写模式锁住时，可以说成是以互斥模式锁住的

读写锁与互斥锁类似，不过读写锁允许更高的并行性：

锁住状态

不加锁状态

读写锁可以有3种状态

读写锁非常适合于对数据结构读的次数远大于写的情况
1）读写锁的初始化与销毁

读写锁在使用之前必须初始化，释放它们底层的内存之前必须销毁：

Single UNIX Specification在XSI扩张中定义了PTHREAD_RWLOCK_INITIALIZER常量。如果默认属性就足够的话，可以用它对静态分配的读写锁进行初始化
2）读写锁的加锁与解锁

Single UNIX Specification还提供了下列版本：

3）读写锁的定时加锁

与互斥锁一样，Single UNIX Specification提供了带有超时的读写锁加锁函数：

该函数试图对一个读写锁进行加锁，如果读写锁已经上锁，那么线程会阻塞到参数tsptr指定的时刻（这个时间是一个绝对时间，即某个时刻，而不是一个等待时间段）。如果仍为获得读写锁，那么返回ETIMEDOUT
2.3 条件变量

条件变量可以在某个条件发生之前，将线程投入睡眠
按照Pthread，条件变量是类型为pthread_cond_t的变量
1）条件变量的初始化与销毁

如果条件变量是静态分配的，那么可以使用PTHREAD_COND_INITIALIZER初始化
2）等待某个条件变量

pthread_cond_wait

pthread_cond_timewait

两个函数成功返回时，线程需要重新计算条件，因为另一个线程可能已经在运行并改变了条件
为什么每个条件变量都要关联一个互斥锁呢？因为”条件“（这里不是指条件变量）通常是线程之间共享的某个变量的值。允许不同线程设置和测试该变量要求有一个与该变量关联的互斥锁
3）通知条件已经满足

pthread_cond_signal

pthread_cond_broadcast

2.4 自旋锁

自旋锁与互斥锁类似，区别是：自旋锁在获取锁之前一直处于忙等（自选）阻塞状态。因为忙等会消耗大量CPU，因此适用于锁持有时间不长（即操作可以较快完成）的场景

事实上，有些互斥锁的实现在试图获取互斥锁的时候会自旋一小段时间，只有在自旋计数到达某一阈值的时候才会休眠

1）自旋锁的初始化与销毁

pshared：进程共享属性，表明自旋锁是如何获取的

2）自旋锁的加锁与解锁

pthread_spin_lock

pthread_spin_trylock

pthread_spin_unlock

在持有自旋锁时，不要调用可能会进入休眠状态的函数。如果调用了这些函数，会浪费CPU资源，因为其他线程需要获取自旋锁需要等待的时间就延长了
2.5 屏障

屏障是用户协调多个线程并行工作的同步机制。屏障允许每个线程等待，直到所有的合作线程都到达某一点，然后从该点继续执行

pthread_join就是一种屏障，允许一个线程等待，直到另一个线程退出

1）屏障的初始化与销毁

count：在允许所有线程继续运行之前，必须到达屏障的线程数目
attr：屏障对象的属性，设为NULL时使用默认属性初始化屏障

2）增加到达屏障点的线程

该函数用以表明，线程已完成工作，准备等待所有其他线程赶上来

一旦到达屏障计数值，而且线程处于非阻塞状态，屏障就可以被重用
只有先调用pthread_barrier_destroy函数，接着又调用pthread_barrier_init并传入一个新的计数值，否则屏障计数无法改变
七.线程控制

1.线程限制

Single UNIX Specification定义了与线程操作有关的一些限制，这些限制可以通过sysconf函数进程查询：

下图为apue描述的4种操作系统实现中的限制值：

这些限制的使用是为了增强应用程序在不同的操作系统实现之间的可移植性

我的环境(Max OS X 10.11.6)下：

printf("%ld\n",sysconf(_SC_THREAD_STACK_MIN));//8192printf("%ld\n",sysconf(_SC_THREAD_THREADS_MAX));//-1（正常值，因为没有设置errno）

复制代码

2.线程属性

2.1 线程属性

线程属性用以初始化线程，定义在结构体pthread_attr_t中，一般包括：

下图为POSIX.1定义的线程属性在apue描述的4种操作系统实现中的支持情况：

POSIX.1还为线程执行调度选项定义了额外的属性，用以支持实时应用，但这里不打算讨论这些属性

在MAC OS X 10.11.6下的测试：

pthread_attr_t attr;pthread_attr_init(&attr);pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);int state;
size_t stack_size;
size_t guardsize;pthread_attr_getdetachstate(&attr,&state);pthread_attr_getstacksize(&attr,&stack_size);pthread_attr_getguardsize(&attr,&guardsize);printf("state:");if(state == PTHREAD_CREATE_DETACHED){printf("PTHREAD_CREATE_DETACHED\n");//PTHREAD_CREATE_DETACHED}elseif(state == PTHREAD_CREATE_JOINABLE){printf("PTHREAD_CREATE_JOINABLE\n");}printf("stack_size:%u\n",stack_size);//524288(512*1024)bytesprintf("guardsize:%u\n",guardsize);//4096pthread_attr_destroy(&attr);

复制代码

1）线程属性的初始化和销毁

如果pthread_attr_init的实现对属性对象的内存空间是动态分配的，那么pthread_attr_destroy会释放该内存空间。除此之外，pthread_attr_destroy还会用无效的值初始化属性对象，因此，如果该属性对象被误用，将会导致pthread_create函数返回错误码
要注意pthread_attr_destroy的返回值，如果忽略其错误返回可能出现的最坏情况是，如果pthread_attr_init已经分配了内存空间，就会有少量的内存泄露。另一方面，如果pthread_attr_init成功地对线程属性进行了初始化，但之后的pthread_attr_destroy清理工作失败，那么将没有任何补救策略，因为线程属性结构对应用程序来说是不透明的，可以对线程属性结构进行清理的唯一接口是pthread_attr_destroy，但它失败了
2）分离属性的获取与设置

3）栈属性的获取与设置

对于进程来说，虚地址空间的大小是固定的。因为进程中只有一个栈，所以它的大小通常不是问题。但对于线程来说，同样大小的虚地址空间必须被所有的线程栈共享。如果应用程序使用了许多线程，以致这些线程栈的累计大小超过了可用的虚地址空间，就需要减小默认的线程栈大小。另一方面，如果线程调用的函数分配了大量的自动变量，或者调用的函数涉及许多很深的栈帧，那么需要的栈大小可能要比默认的大
如果线程栈的虚地址空间都用完了，那么可以使用malloc或mmap来为可替代的栈分配空间，并用下列函数设置或者获取线程栈的最低内存地址：

4）栈大小属性的获取与设置

如果希望改变默认的栈大小，但又不想自己处理线程栈的分配问题，使用pthread_attr_setstacksize非常有用
5）境界缓存大小的获取与设置

如果guardsize线程属性被修改了，操作系统可能会把它取为页大小的整数倍

如果线程的栈指针溢出到警戒区域，应用程序就可能通过信号接收到出错信息

2.2 取消选项

有两个线程属性没有包含在pthread_attr_t结构中：

可取消状态

可取消类型

这两个属性影响着线程在响应pthread_cancel函数调用时所呈现的行为
1）可取消状态属性

新旧状态的设置是一个原子操作
pthread_cancel调用并不等待线程终止。默认情况下，线程在取消请求发出后还是继续运行，直到线程到达某个取消点。取消点是线程检查它是否被取消的一个位置，POSIX.1保证线程调用下列函数时，取消点都会出现：

可取消状态可以是下面的值：

取消请求对这个线程来说还处于挂起状态

如果线程长时间不会调用前面所述函数进入一个取消点，可以通过下列函数添加取消点：

下列2个条件满足时，该函数会使线程被取消：

否则，该函数没有效果
2）可取消类型属性

oldtype：旧的可取消类型

3.同步属性

就像线程具有属性一样，线程的同步对象也有属性。在使用某种线程同步机制时，同步属性用以初始化相应的同步机制。比如互斥锁属性用以初始化互斥锁、条件变量属性用以初始化条件变量…

进程共享属性控制着同步对象是否可用于进程与进程之间

3.1 互斥锁属性

互斥锁属性用pthread_mutexattr_t结构表示
3个值得注意的互斥锁属性：

进程共享属性

健壮属性

类型属性

1）互斥锁属性的初始化和销毁

获得默认互斥锁属性

2）进程共享属性的获取和设置

这个属性是可选的。可以通过2种方式检查是否支持该属性：
1）检查系统中是否定义了_POSIX_THREAD_PROCESS_SHARED符号判断这个平台是否支持进程共享这个属性；
2）可以在运行时把_SC_THREAD_PROCESS_SHARED参数传给sysconf函数进行检查）

3）健壮属性的获取和设置

互斥锁的健壮属性与在多个进程间共享的互斥锁有关。意味着，当持有互斥锁的进程终止时，需要解决互斥锁状态恢复的问题。这种情况发生时，互斥锁处于锁定状态，恢复起来很困难。其它阻塞在这个锁的进程将会一直阻塞下去

如果应用状态无法恢复，在线程对互斥锁解锁后，该互斥锁将处于永久不可用状态。为了避免这样的问题，线程可以通过调用pthread_mutex_consistent函数，指明该互斥锁相关的状态在互斥锁解锁以前是一致的

如果线程没有先调用pthread_mutex_consistent就对互斥锁进行了解锁，那么其它试图获取该互斥锁的阻塞线程就会得到错误码ENOTRECOVERABLE。如果发生这种情况，互斥锁将不再可用。线程通过提前调用pthread_mutex_consistent，就能让互斥锁正常工作，这样它就可以持续被使用
4）类型属性的获取和设置

类型属性控制着互斥锁的锁定特性。POSIX.1定义了4种类型：

默认特性和行为

下图为不同的类型属性和行为：

不占用时解锁：一个线程对被另一个线程加锁的互斥锁进行解锁

3.2 读写锁属性

读写锁属性用pthread_rwlockattr_t结构表示
进程共享属性是读写锁的唯一属性
1）读写锁属性的初始化与销毁

2）进程共享属性的获取与设置

进程共享属性是读写锁的唯一属性，可以通过下列函数获取与设置

虽然POSIX只定义了一个读写锁属性，但不同平台的实现可以自由地定义额外的、非标准的属性

3.3 条件变量属性

条件变量属性用pthread_condattr_t结构表示
Single UNIX Specification目前定义了条件变量的2个属性：

进程共享属性

时钟属性

1）条件变量属性的初始化与销毁

2）进程共享属性的获取与设置

与其他的同步属性一样，条件变量支持进程共享属性。它控制着条件变量是可以被单进程的多个线程使用，还是可以被多进程的线程使用

3）时钟属性的获取与设置

时钟属性控制计算pthread_cond_timedwait函数的超时参数tsptr采用的是哪个时钟

pthread_condattr_getclock

pthread_condattr_setclock

3.4 屏障属性

条件变量属性用pthread_barrierattr_t结构表示
进程共享属性是屏障的唯一属性
1）屏障属性的初始化与销毁

2）进程共享属性的获取与设置

目前定义的屏障属性只有进程共享属性，它控制着屏障是可以被多进程的线程使用，还是只能被初始化屏障的进程内的多线程使用

4.线程特定数据

线程特定数据也称为线程私有数据，是存储和查询某个线程相关数据的一种机制。它是每个线程私有的数据副本，因此不需要担心与其它线程的同步访问问题

无法简单的分配一个每线程数据数组

线程特定数据提供了让基于进程的接口适应多线程环境的机制

一个线程没有办法阻止另一个线程访问它的数据。线程特定数据也不例外。虽然底层的实现部分并不能阻止这种访问能力，但管理线程特定数据的函数可以提高线程间的数据独立性，使得线程不太容易访问到其它线程的线程特定数据

每个系统支持有限数量的线程特定数据元素，POSIX要求这个限制不小于128(每个进程)，系统为每个进程维护一个称之为Key结构的数组，如下图：

标志

除了进程范围的Key结构数组外，系统还在进程内维护关于每个线程的多条信息，记录在Pthread结构（由系统维护）中：

pKey数组的所有元素都被初始化为空指针。这128个指针是和进程内的128个可能的索引（称为”键“）逐一关联的值
一般步骤如下：

所有线程可以使用这个新键通过pthread_getspecific索引自己的pkey数组的相应位置
调用pthread_key_create函数时指定的析构函数会释放保存在每个线程pkey数组中的线程特定数据

1）pthread_once和pthread_key_create函数

pthread_key_create函数：

keyptr

作为返回值

destructor

下列情况会调用析构函数：

下列情况不会调用析构函数：

线程退出时，线程特定数据的析构函数将按照操作系统实现中定义的顺序被调用。当所有的析构函数都调用完成之后，系统会检查是否还有非空的线程特定数据值与键关联，如果有的话，再次调用析构函数。这个过程将会一直重复到线程所有的键都为空，或者已经做了PTHREAD_DESTRUCTOR_ITERATIONS中定义的最大次数的尝试
pthread_once函数：

onceptr

init

2）pthread_getspecific和pthread_setspecific函数

3）pthread_key_delete函数

该函数用来取消键与线程特定数据值之间的关联。它并不会激活与键关联的析构函数。要释放任何与键关联的线程特定数据值的内存，需要在应用程序中采取额外的步骤
5.线程和信号

每个线程都有自己的信号屏蔽字，但是信号的处理是进程中所有线程共享的。这意味着单个线程可以阻止某些信号，但当线程修改了与某个给定信号相关的处理行为以后，所有的线程都必须共享这个处理行为的改变。这样，如果一个线程选择忽略某个给定信号，那么另一个线程就可以通过以下两种方式撤销上述信号选择：恢复信号的默认处理行为，或者为信号设置一个新的信号处理程序
进程中的信号是递送到单个线程的：

5.1 阻止信号发送

sigprocmask的行为在多线程的进程中没有定义，线程必须使用pthread_sigmask：

how：set与线程信号屏蔽字的作用方式
set：信号集oset：如果不为NULL，保存线程之前的信号屏蔽字

线程可以通过把set设为NULL，把oset参数设为sigset_t结构的地址，来获取当前的信号屏蔽字。这种情况下，how参数会被忽略
5.2 等待信号

线程调用下列函数等待一个或多个信号出现

如果信号集中的某个信号在函数调用时处于等待挂起状态，那么函数将无阻塞地返回

注意：

要把信号发送给进程，可以调用kill。要把信号发送给线程，可以调用pthread_kill：

可以传一个0值的signo来检查线程是否存在。如果信号的默认处理动作是终止该进程，那么把信号传递给某个线程仍然会杀死整个进程
闹钟定时器是进程资源，并且所有的线程共享相同的闹钟。所以，进程中的多个线程不可能互不干扰地使用闹钟定时器
6.线程和fork

当线程调用fork时，就为子进程创建了整个进程地址空间的副本：

如果fork后马上调用其中一个exec函数，就能避免这样的问题。这种情况下，旧的地址空间被丢弃，所以锁的状态无关紧要
在多线程的进程中，为了避免不一致状态的问题，POSIX.1声明，在fork返回和子进程调用其中一个exec之间，子进程只能调用异步信号安全的函数。这就限制了在调用exec之前子进程能做什么，但不涉及子进程中锁状态的问题
要清除锁状态，可以调用pthread_atfork建立fork处理程序：

该函数可以安装清除锁的函数，最多3个：

prepare：
parent：
child：

如果不需要使用其中某个处理程序，可以给特定的处理程序参数传入空指针，它就不会起任何作用了
可以多次调用pthread_atfork函数从而设置多套fork处理程序。使用多个fork处理程序时，处理程序的调用顺序并不相同

这样可以允许多个模块注册它们自己的fork处理程序，而且可以保持锁的层次
7.线程和I/O

在多线程进程中，因为线程共享相同的文件描述符，所以应该使用pread和pwrite而不是read和write，使得偏移量的设定和数据的读取成为一个原子操作

八.高级I/O

下图为UNIX下5种I/O模型的比较

同步I/O：I/O操作过程中会导致请求进程阻塞，直到I/O操作完成
异步I/O：不导致请求进程阻塞

2.记录锁

商用UNIX系统提供了记录锁机制
记录锁的功能是：当第一个进程正在读或修改文件的某个部分时，使用记录锁可以阻止其他进程修改同一文件区
POSIX.1通过fcntl函数提供记录锁功能

此时cmd参数是下面3个：

第三个参数是一个指向flock结构的指针：

struct flock{short l_type;/* F_RDLCK,F_WRLCK,or F_UNLCK */short l_whence;/* SEEK_SET,SEEK_CUR,or SEEK_END */
off_t l_start;/* offset in bytes,relative to l_whence */
off_t l_len;/* length, in bytes; 0 means lock to EOF */
pid_t l_pid;/* returned with F_GETLK */};

复制代码

关于加锁或解锁区域的说明还要注意下列几项规则：

1）读写锁的关系

有两种类型的锁：共享性读锁(l_type=F_RDLCK)，独占性写锁(l_type=F_WRLCK)。互斥规则为：

任意多个进程可以在一个给定的字节上有一把共享性读锁。如果在一个给定字节上已经有了一把或者多把读锁，则不能在该字节上添加写锁

在一个给定字节上只能有一个进程有一把独占性写锁。如果在一个给定字节上已经有了一把写锁，则不能在该字节上添加任何读锁或者写锁

注意：该规则适用于不同进程提出的锁请求，不适合单个进程提出的多个锁请求。如果某个进程对一个文件区间已经有了一把锁，后来该进程又企图在同一个文件区间再加一把锁，则新锁将会替换旧锁
2）锁与文件描述符类型的关系

3）一般性步骤

通常使用F_GETLK命令来测试能否建立一把锁，然后用F_SETLK或者F_SETLKW试图建立那把锁。但是注意到：这二者不是一个原子操作！因此不能保证在这两次fcntl调用之间，可能另有一个进程插入并建立一把相同的锁从而导致本进程建立锁的过程失败
4）相邻区域的组合与分裂

第100~199字节是加锁区：

解锁第150字节，内核将维持2把锁：

如果又对第150字节加锁，那么系统会把3个相邻的加锁区合并成一个：

5）记录锁的隐含继承和释放

记录锁与进程和文件两者相关联
fork产生的子进程并不继承父进程所设置的记录锁。这是因为父进程与子进程是不同的进程，而记录锁是与进程和文件两者相关联（子进程想获得记录锁，可以在继承而来的文件描述符上调用fcntl函数来设置记录锁）在执行exec后，新程序可以继承原程序的记录锁。但注意：如果对一个文件描述符设置了执行时关闭标志，则作为exec的一部分关闭该文件描述符时，将释放相应文件的所有锁

6）文件尾端加锁与解锁

如果你想解除的锁包括之前刚写入的一个字节，则应该flockptr->l_len=-1 ，负的长度值表示在指定偏移量之前的字节数
当对文件的一部分加锁时，内核将指定的偏移量变换成绝对文件偏移量。这是因为当前偏移量和文件尾端可能不断变化，但是这种变化不应该影响已经存在的锁的状态，所以内核必须独立于当前文件偏移量和文件尾端而记住锁的位置
7）建议性锁和强制性锁

建议性锁

强制性锁

对于一个特定文件，打开其设置组ID位，同时关闭其组执行位，就开启了对该文件的强制性锁机制。

因为当组执行位关闭时，设置组ID位不再有意义（设置组ID位的目的就是为了那些需要特殊组执行权限）

如果一个进程试图read/write一个强制性锁起作用的文件，但是将要读/写的部分又由其他进程上了锁，则结果取决于三方面的因素：操作类型read/write，其他进程在该区域上持有的记录锁的类型（读锁/写锁），read/write文件描述符是阻塞的还是非阻塞的

除了read/write函数外，open函数也会受到另一个进程持有的强制性锁的影响：

一个恶意用户可以使用强制性记录锁，对大家都可读的文件加一把读锁，这样就能阻止任何人写该文件。

强制性锁是可以设法避开的：强制性锁机制对unlink函数没有影响，因此你可以先将内容写到一个临时文件中，然后删除原文件，最后将临时文件改名为原文件名
4.异步I/O

这里主要介绍POSIX异步I/O

POSIX异步I/O接口为对不同类型的文件进程异步I/O提供了一套一致的方法。现在所有的平台都要求支持这些接口
4.1 AIO控制块

这些异步I/O接口使用AIO控制块来描述I/O操作，aiocb结构定义了AIO控制块，该结构至少包括下面这些字段：

struct aiocb{int aio_fildes;// 文件描述符
off_t aio_offset;// 文件偏移量volatilevoid*aio_buf;// IO缓冲区
size_t aio_nbytes;// 传输的字节数int aio_reqprio;// 优先级struct sigevent aio_sigevent;// 信号信息int aio_lio_opcode;// IO操作列表}

复制代码

aio_buf：
aio_nbytes：指定了要读或者写的字节数aio_reqprio：指定了异步IO的优先级，操作系统根据该优先级来安排执行顺序。但是操作系统对于该顺序只有有限的控制能力，因此不一定能够遵循该提示aio_lio_opcode：参见lio_listio函数的说明。它指定了该AIO控制块是用于多操作、写操作、还是空操作
aio_sigevent：指定IO事件完成后，如何通知应用程序
1. struct sigevent{int sigev_notify;// 通知类型int sigev_signo;// 信号编号union sigval sigev_value;// 通知的参数void(*sigev_notify_function)(union sigval);// 作为线程执行的函数
2. pthread_attr_t *sigev_notify_attributes;// 线程属性};
复制代码
- sigev_notify：指定了通知的类型，可以为下列三种之一

4.2 异步读与异步写

在进行异步I/O前需要先初始化AIO控制块。调用aio_read函数来进行异步读操作，或调用aio_write函数来进行异步写操作

当这些函数返回成功时，异步I/O请求就已经被操作系统放入等待处理的队列中了。这些返回值与实际I/O操作的结果没有任何关系。
注意：I/O操作在等待时，必须确保AIO控制块和数据缓冲区保持稳定。它们下面对应的内存必须始终是合法的，除非I/O操作完成，这些内存不应该被复用
如果想强制所有等待中的异步操作不等待而写入持久化的存储（如硬盘）中，可以设立一个AIO控制块并调用aio_fsync函数：

参数：
- op：指定模式：
  aiocb：指向AIO控制块

AIO控制块中的aio_fildes字段指定了其异步写操作不等待而写入持久化的存储的那个文件
就像aio_read/aio_write函数一样，在安排了同步时，aio_fsync操作立即返回。在异步的同步操作（指的是将数据修改同步到硬盘上的这个操作是异步执行的）完成之前，数据不会被持久化。AIO控制块控制我们如何被通知
4.3 获取异步I/O的状态

返回值：

4.4 获取异步I/O返回值

返回值：

直到异步操作完成之前，都要小心的不要调用aio_return函数。操作完成之前，该函数调用的结果是未定义的。
还需要小心地对每个异步操作只调用一次aio_return函数，一旦调用了该函数，操作系统就可以释放掉包含IO操作返回值的记录
4.5 阻塞进程到异步I/O完成

如果在完成了所有事务时，还有异步操作未完成，可以调用调用该函数来阻塞进程，直到操作完成：

参数：
- list：AIO控制块指针的数组。每个元素指向了要等待完成的异步操作
  nent：该数组的长度timeout：指定超时时间。如果想永不超时，则设定它为NULL

aio_suspend可能返回三种结果：

如果在调用该函数时，所有的异步I/O操作都已完成，那么函数将在不阻塞的情况下直接返回
4.6 取消异步I/O

当我们不想再完成等待中的异步I/O操作时，可以尝试使用aio_cancel函数来取消它们

参数：
返回值：

如果aiocb为NULL，则系统将尝试取消所有在fd文件上未完成的异步I/O操作。其他情况下尝试取消由AIO控制块描述的单个异步I/O操作。之所以说尝试，是因为无法保证系统能够取消正在进程中的任何异步操作
如果异步I/O操作被成功取消，则对应的AIO控制块调用aio_error函数将会返回错误ECANCELED
如果异步I/O操作不能被取消，那么相应的AIO控制块不会被修改
4.7 批量提交异步I/O请求

AIO控制块列表描述了一系列I/O请求，可以由该函数提交

参数：
- mode：决定了IO是否同步的。其值可以为：
  list：AIO控制块指针的数组，该数组指定了要允许的IO操作。如果数组包含空指针，则跳过这些空指针nent：数组的长度sigev：指定了当所有IO操作完成后，发送的异步通知（如果不想被通知，则将sigev设置为NULL）。只有当mode=LIO_NOWAIT才有意义

4.8 异步I/O的数量限制

异步IO的数量有限制，这些限制都是运行时不变量

这些常量的意义为：

6.存储映射I/O

存储映射I/O能将一个磁盘文件映射到存储空间中的一个缓冲区上，于是：

当从缓冲区中取数据时，就相当于读文件中的相应字节

将数据存入缓冲区时，相应字节就自动写入文件

因此，就可以在不使用read和write的情况下执行I/O
效率：与mmap和memcpy相比，read和write执行了更多的系统调用，并做了更多的复制。read和write将数据从内核缓冲区中复制到应用缓冲区(read)，然后再把数据从应用缓冲区复制到内核缓冲区(write)。而mmap和memcpy则直接把数据从映射到地址空间的一个内核缓冲区复制到另一个内核缓冲区。当引用尚不存在的内存页时，这样的复制过程就会作为处理页错误的结果而出现（每次错页读发生一次错误，每次错页写发生一次错误）。如果系统调用和额外的复制操作的开销和页错误的开销不同，那么两者方法中就会有一种比另一种表现更好
mmap的优劣：

劣：
优

6.1 mmap建立映射

内核将一个给定的文件映射到一个存储区域中是由mmap实现的：

参数：
- prot：指定了映射存储区的保护要求，可以为下列之一（也可以为PROT_READ、PROT_WRITE、PROT_EXEC的按位或）：
- flag：影响映射存储区的多种属性：
  fd：指定要被映射文件的描述符。在文件映射到地址空间之前，必须先打开该文件off：要映射字节在文件中的起始偏移量

注意：

下图是存储映射文件的基本情况。其中“起始地址”是mmap的返回值

假设文件长度为 12 字节，系统页长为 512 字节，则系统通常会提供 512 字节的映射区，其中后 500字节被设置为0 。可以修改后面的这 500 字节，但是任何变动都不会在文件中反映出来。因此，不能用mmap将数据添加到文件中（可以先加长该文件，使得能够将后面500字节的改动反映到文件中去）
与映射区相关的信号有：SIGSEGV和SIGBUS

如：用文件长度映射了一个文件，但在引用该映射区之前，另一个进程已将该文件截断，此时如果进程试图访问被截断部分对应的映射区，则接收到SIGBUS信号

子进程能够通过fork继承存储映射区（因为子进程复制了父进程地址空间，而存储映射区是该地址空间的组成部分）。但是一旦子进程调用了exec，则新程序不再拥有存储映射区了
6.2 mprotect修改映射区权限

参数：

6.3 msync冲洗映射区

如果修改的页是通过MAP_SHARED标志映射到地址空间的，那么对内存映射区的修改并不会立即写回到底层文件中。何时写回脏页（即被修改的页）由内核的守护进程决定，决定的依据有两个：

因此，如果只修改了一页中的一个字节，当修改被写回到文件中时，整个页都被写回
如果共享映射中的页已修改，则可以调用msync函数将该页冲洗到底层文件中。它类似于fsync，但作用于存储映射区：

参数：
- flags：用于控制如何冲洗存储区。下列两个常量二选一

如果存储映射是私有的，则不修改底层的文件
6.4 munmap解除映射

当进程终止时，会自动解除存储映射区的映射。也可以直接调用munmap函数来手动解除映射区

参数：

munmap并不影响被映射的对象。即调用munmap并不会使映射区的内容写到磁盘文件上

注意，对于创建存储映射区时使用的文件描述符，如果关闭该描述符，并不会解除映射区
使用mmap拷贝文件

#include"apue.h"#include<fcntl.h>#include<sys/mman.h>#define COPYINCR (1024*1024*1024) /* 1 GB */intmain(int argc,char*argv[]){int fdin, fdout;void*src,*dst;
size_t copysz;struct stat sbuf;
off_t fsz =0;if(argc !=3)err_quit("usage: %s <fromfile> <tofile>", argv[0]);if((fdin =open(argv[1], O_RDONLY))<0)err_sys("can't open %s for reading", argv[1]);if((fdout =open(argv[2], O_RDWR | O_CREAT | O_TRUNC,
FILE_MODE))<0)err_sys("can't creat %s for writing", argv[2]);if(fstat(fdin,&sbuf)<0)/* need size of input file */err_sys("fstat error");if(ftruncate(fdout, sbuf.st_size)<0)/* set output file size */err_sys("ftruncate error");while(fsz < sbuf.st_size){if((sbuf.st_size - fsz)> COPYINCR)
copysz = COPYINCR;else
copysz = sbuf.st_size - fsz;if((src =mmap(0, copysz, PROT_READ, MAP_SHARED,
fdin, fsz))== MAP_FAILED)err_sys("mmap error for input");if((dst =mmap(0, copysz, PROT_READ | PROT_WRITE,
MAP_SHARED, fdout, fsz))== MAP_FAILED)err_sys("mmap error for output");memcpy(dst, src, copysz);/* does the file copy */munmap(src, copysz);munmap(dst, copysz);
fsz += copysz;}exit(0);}

复制代码

九.进程间通信

1.管道

管道是UNIX系统IPC的最古老形式，所有UNIX系统都提供此种通信机制
管道有2中局限性：

半双工

只能在具有公共祖先的两个进程间使用

尽管有上述局限，半双工管道仍是最常用的IPC形式。每当在管道中键入一个命令序列，让shell执行时，shell都会为每一条命令单独创建一个进程，然后用管道将前一条命令进程的标准输出与后一条命令的标准输入相连接
1.1 创建管道

fd：函数调用返回后记录了管道的2个文件描述符

POSIX.1允许实现支持全双工管道。对于这些实现，fd[0]和fd[1]以读/写方式打开

一般创建管道后，会fork子进程，然后根据数据流向选择性的关闭父子进程中管道的读端或写端，从而建立父子进程之间通信的IPC：

1.2 管道的读写规则

1.3 标准I/O库管道函数

2.协同进程

UNIX系统过滤程序从标准输入读取数据，向标准输出写数据。几个过滤程序通常在shell管道中线性连接。当一个过滤程序既产生某个过滤程序的输入，又读取该过滤程序的输出时，它就变成了协同进程
popen只提供连接到另一个进程的标准输入或标准输出的一个单向管道，而协同进程则有连接到另一个进程的两个单向管道：一个连接到其标准输入，另一个则来自其标准输出。我们想将数据写到其标准输入，经其处理后，再从标准输出读取数据

协同进程的标准输入和标准输出连接到管道

3.FIFO

FIFO有时候被称为命名管道，和管道不同的是，它可以在不相关的进程间使用，不必具有继承关系

FIFO是一种文件类型，通过stat结构的st_mode成员的编码可以知道文件是否是FIFO类型。可以用S_ISFIFO宏对此进行测试

FIFO有以下2个用途：

3.1 创建FIFO

创建FIFO类似于创建文件。FIFO的路径名存在于文件系统中

mkfifoat：和mkfifo函数相似，但是该函数可以被用来在fd文件描述符表示的目录相关的位置创建一个FIFO

应用程序可以用mknod和mknodat函数创建FIFO。因为POSIX.1原先并没有包括mknod函数，所以mkfifo是专门为POSIX.1设计的。mknod和mknodat函数现在已包括在POSIX.1的XSI扩展中

3.2 打开FIFO

使用这两个函数创建FIFO时，要用open来打开它：

3.3 读写FIFO

一个给定的FIFO有多个写进程是常见的。这意味着，如果不希望多个进程所写的数据交叉，则必须考虑原子写操作。和管道一样，常量PIPE_BUF说明了可被原子地写到FIFO的最大数据量
4.XSI IPC

有3种称作XSI IPC的IPC：消息队列、信号量、共享存储。它们之间有很多相似之处
4.1 标识符和键

1）标识符

标识符

IPC标识符

2）键

标识符是IPC对象的内部名。为使多个合作进程能够在同一IPC对象上汇聚，需要提供一个外部命名方案。为此，每个IPC对象都与一个键相关联，将这个键作为该对象的外部名（创建IPC结构时，应指定一个键）。键的类型是基本系统数据类型key_t，通常在<sys/types.h>中被定义为长整形。这个键由内核变换成标识符
4.2 权限结构

每个IPC结构关联了一个ipc_perm结构（<sys/ipc.h>），规定了权限和所有者，至少包括以下成员：

struct ipc_perm{
uid_t uid;/* 拥有者的有效用户ID */
gid_t gid;/* 拥有者的有效组ID */
uid_t cuid;/* 创建者的有效用户ID */
gid_t cgid;/* 创建者的有效组ID */
mode_t mode;/* 访问模式 */...};

复制代码

对于任何IPC结构都不存在执行权限，消息队列和共享内存使用术语”读“和”写“，信号量则用”读“和”更改“。下图显示了每种IPC的6种权限：

4.3 结构限制

所有3种形式的XSI IPC都有内置限制。大多数限制可以通过重新配置内核来改变
4.4 优点和缺点

优点
缺点

”无连接“指无需先调用某种形式的打开函数就能发送消息的能力
5.消息队列

后文把消息队列简称为“队列”，把标识符简称为"队列ID"

消息队列是消息的链接表，存储在内核中，由消息队列标识符标识
5.1 与消息队列相关的结构

每个队列都有一个msqid_ds结构与其关联，这个结构定义了队列的当前状态：

struct msqid_ds{struct ipc_perm msg_perm;
msgqnum_t msg_qnum;/* 队列中的消息数 */
msglen_t msg_qbytes;/* 队列中消息的字节 */
pid_t msg_lspid;/* 最后调用msgsnd()的进程ID */
pid_t msg_lrpid;/* 最后调用msgrcv()的进程ID */
time_t msg_stime;/* 最后调用msgsnd()的时间 */
time_t msg_rtime;/* 最后调用msgrcv()的时间 */
time_t msg_ctime;/* 最后一次修改队列的时间 */...};

复制代码

下图为消息队列的系统限制：

“导出的”表示这种限制来源于其它限制
5.2 创建或打开消息队列

msgget：创建一个新队列或打开一个现有队列

创建队列时，需要初始化msqid_ds结构的下列成员：

5.3 操作消息队列

cmd：

上面3条命令也可用于信号量和共享存储
5.4 添加消息

msgsnd将新消息添加到队列尾端

每个消息由3部分组成：一个正的长整型类型的字段、一个非负的长度、实际数据字节（对应于长度）

struct mymesg{long mtype;/* 正的长整型类型字段 */char mtext[512];/* */};

复制代码

ICP_NOWAIT：类似于文件I/O的非阻塞I/O标准
- 若消息队列已满（数量或字节总数达到限制）

当msgsnd返回成功时，消息队列相关的msqid_ds结构会随之更新
5.5 获取消息

msgrcv：从队列中取消息（并不一定要以先进先出的顺序取消息，也可以按类型字段取消息）
- nbytes：指定数据缓冲区的长度
- type：欲获取的消息类型
  flag
  - IPC_NOWAIT：可使操作不阻塞
    - 当队列中无消息时

msgrcv成功执行时，内核会更新与该消息队列相关的msgid_ds结构
6.信号量

信号量是一个计数器，用于为多个进程提供对共享数据对象的访问
为了正确实现信号量，信号量值的测试及减1操作应当是原子操作。为此，信号量通常是在内核中实现的
常用的信号量形式被称为二元信号量，它控制单个资源，其初始值为1。但是一般而言，信号量的初值可以是任意一个正值，该值表明有多少个共享资源单位可供共享应用
下面的特性使得XSI信号量更复杂：

6.1 信号量的相关结构

内核为每个信号量集合维护着一个semid_ds结构

struct semid_ds{struct ipc_perm sem_perm;unsignedshort sem_nsems;/* 集合中的信号量数目 */
time_t sem_otime;/* 最后一次调用semop()的时间 */
time_t sem_ctime;/* 最后一次改变的时间 */...};

复制代码

每个信号量由一个无名结构表示，它至少包含下列成员：

struct{unsignedshort semval;/* 信号量的值，总是>=0 */
pid_t sempid;/* 最后一个操作信号量的进程ID */unsignedshort semncnt;/* 等待 semval>curval 的进程数 */unsignedshort semzcnt;/* 等待 semval==0 的进程数 */...};

复制代码

下图是影响信号量集合的系统限制；

6.2 获得信号量

nsems：该信号量集合中的信号量数
flag：

创建队列时，需要初始化semid_ds结构的下列成员：

6.3 操作信号量

cmd：命令
semun：可选参数，是否使用取决于命令cmd，如果使用则类型是联合结构semun
1. union semun{int val;/* for SETVAL */struct semid_ds *buf;/* for ICP_STAT and IPC_SET */unsignedshort*array;/* for GETALL and SETALL */};
复制代码

函数semop自动执行信号量集合上的操作数组：

struct sembuf{unsignedshort sem_num;/* 信号量集合中的某个信号量 */short sem_op;/* 操作 */short sem_flg;/* IPC_NOWAIT，SEM_UNDO */};

复制代码

这对应于进程释放的占用的资源数。sem_op值会加到该信号量的值上

则表示要获取由该信号量控制的资源

信号量的值

如果信号量的值小于sem_op的绝对值
- 若未指定IPC_NOWAIT，则该信号量的semncnt增加1，然后调用进程被挂起直到下列事件之一发生

则表示调用进程希望等待到信号量的值变为0

信号量的值

如果信号量的值非0，则：
- 若未指定IPC_NOWAIT，则该信号量的semncnt增加1，然后调用进程被挂起直到下列事件之一发生

该函数具有原子性，它或者执行了数组中的所有操作，或者一个也不做
exit时的信号量调整

如果在进程终止时，它占用了经由信号量分配的资源，那么就会成为一个问题。无论何时只要为信号量操作指定了SEM_UNDO标志，然后分配资源(sem_op值小于0)，那么内核就会记住对于该特定信号量，分配给调用进程多少资源（sem_op的绝对值）。当该进程终止时，无论自愿或不自愿，内核都将检验该进程是否还有尚未处理的信号量调整值。如果有，则按调整值对相应信号量值进行处理
如果用带SETVAL或SETALL命令的semctl设置一个信号量的值，则在所有进程中，该信号量的调整值都将设置为0
7.共享存储

共享存储允许2个或多个进程共享一个给定的存储区
因为数据不需要在客户进程和服务器进程之间复制，所以这是最快的一种IPC
使用共享存储要注意的是：进程在往共享存储写完成之前，读进程不应该去取数据。通常，信号量用于同步共享存储访问

mmap就是共享存储的一种形式，但是XSI共享存储与其区别在于，XSI共享存储没有相关文件。XSI共享存储段是内存的匿名段

7.1 共享存储的内核结构

内核为每个共享存储段维护着一个结构，至少包含以下成员：

struct shmid_ds{struct ipc_perm shm_perm;
size_t shm_segsz;/* 共享存储段的字节大小 */
pid_t shm_lpid;/* 最后调用shmop()的进程ID */
pid_t shm_cpid;/* 创建该共享存储段的进程ID */
shmatt_t shm_nattch;/* 当前访问计数 */
time_t shm_atime;/* 最后一次attach的时间 */
time_t shm_dtime;/* 最后一次detach的时间 */
time_t shm_ctime;/* 最后一次change的时间 */...};

复制代码

下图为影响共享存储的系统限制：

7.2 创建或获得共享存储

size：共享存储段的长度，单位是字节。实现通常将其向上取为系统页长的整倍数。但是，如果指定的值不是系统页长的整倍数，那么最后一页的余下部分是不可使用的

创建一个新共享存储段时，初始化shmid_ds结构的下列成员：

7.3 操作共享存储

7.4 与共享存储段连接

可以调用shmat将共享存储段连接到进程的地址空间中

addr：共享存储段连接到进程的该地址
flag

如果函数成功，内核会将与该共享存储段相关的shmid_ds结构中的shm_nattch计数器值加1
7.5 与共享存储段分离

下列函数可以与共享存储段分离。该调用并不从系统中删除其标识符以及其相关的数据结构。该标识符仍然存在，直到某个进程调用shmctl并使用IPC_RMID命令特地删除它为止

如果函数成功，共享存储段相关的shmid_ds结构中的shm_nattch计数器值减1
进程连接共享存储段的位置

内核将以地址0连接共享存储段放在什么位置上与系统密切相关，下列程序可以进行测试：

#include "apue.h"
#include <sys/shm.h>
#define ARRAY_SIZE 40000
#define MALLOC_SIZE 100000
#define SHM_SIZE 100000
#define SHM_MODE 0600 /* user read/write */
char array[ARRAY_SIZE]; /* uninitialized data = bss */
int
main(void)
{
int shmid;
char *ptr, *shmptr;
printf("array[] from %p to %p\n", (void *)&array[0],
(void *)&array[ARRAY_SIZE]);
printf("stack around %p\n", (void *)&shmid);
if ((ptr = malloc(MALLOC_SIZE)) == NULL)
err_sys("malloc error");
printf("malloced from %p to %p\n", (void *)ptr,
(void *)ptr+MALLOC_SIZE);
if ((shmid = shmget(IPC_PRIVATE, SHM_SIZE, SHM_MODE)) < 0)
err_sys("shmget error");
if ((shmptr = shmat(shmid, 0, 0)) == (void *)-1)
err_sys("shmat error");
printf("shared memory attached from %p to %p\n", (void *)shmptr,
(void *)shmptr+SHM_SIZE);
if (shmctl(shmid, IPC_RMID, 0) < 0)
err_sys("shmctl error");
exit(0);
}

复制代码

8.POSIX信号量

POSIX信号量接口意在解决XSI信号量接口的几个缺陷：

更高性能

使用更简单

删除时表现更完美

POSIX信号量有2种形式：命名的和未命名的。差异在于创建和销毁的形式上

未命名信号量

命名信号量

8.1 创建或获取命名信号量

使用现有的命名信号量时，仅指定2个参数：
创建新的命名信号量

为了移植性，信号量的命名应该遵循下列规则：

8.2 关闭释放信号量

如果进程没有首先调用sem_close而退出，那么内核将自动关闭任何打开的信号量
调用该函数，或者内核自动关闭都不会影响信号量值的状态
8.3 销毁命名信号量

该函数删除信号量的名字。如果没有打开的信号量引用，则该信号量会被销毁。否则，销毁将延迟到最后一个打开的引用关闭
8.4 调节信号量的值

1）减1

不像XSI信号量，我们只能通过一个函数调用来调节POSIX信号量的值

sem_wait函数

sem_trywait函数

函数sem_timewait可以选择阻塞一段时间

tsptr：绝对时间，超时是基于CLOCK_REALTIME时钟的
如果信号量可以立即减1，那么超时值就不重要了，此时即使指定的是过去的某个时间，操作依然会成功
如果超时将返回-1，并且将errno置为ETIMEDOUT
2）增1

8.5 创建未命名信号量

pshared：表明是否在多个进程中使用信号量
sem：未命名信号量，传入其地址，当函数调用返回后，这个未命名信号量会被初始化（如果要在2个进程之间使用信号量，需要确保该参数指向个进程之间共享的内存范围）value：初始值

8.6 销毁未命名信号量

该函数调用后，不能再使用任何带有sem的信号量函数，除非通过调用sem_init重新初始化
8.7 检索未命名信号量的值

注意，我们试图要使用刚读出来的值时，信号量的值可能已经改变。除非使用额外的同步机制来避免这种竞争，否则该函数只能用于测试

Mac OS X 10.6.8不支持该函数

		自动登录	找回密码
密码			立即注册

UNIX环境高级编程

本帖子中包含更多资源