1、进程和程序
程序：运行的程序，不占用系统资源。
进程：活跃的程序，会占用系统资源，在内存中执行。
同一个程序可以加载为不同的进程
2、并发：在操作系统中，一个时间段中有多个进程都处于启动到运行完毕的状态，但，任何一个时刻点上仍有一个进程在运行。
时钟中断：在多道程序设计模式中使用，三个程序同时进行，cpu设置一个时间，每隔一段时间给程序1使用，另一段时间给程序2使用
单道程序设计模型：所有进程一个一个排队执行，若A阻塞，B只能等待，即使CPU处于空闲状态。
多道程序设计模型:多个进程同时进行
3、程序进入CPU，进入的是一个二进制的指令，经过预处理，编译，汇编，链接，城二进制。
4、mmu的基本工作原理
mmu位于CPU内部，主要用处有两个：
①把虚拟地址放到物理地址上。完成虚拟内存和物理内存的映射
②设置修改内存的访问级别 (内核区和用户区)
产生进程的时候，或者运行程序的时候生成虚拟空间，一个四个G的虚拟空间，0-3G是用户区，3-4G是内核区。
所有的程序， mmu都转化时都转换为物理内存的时候都是4k
进程是独立的，两个进程的物理内存是不同的，为每个进程分配独立的用户区，内核区不需要再分配了，因为两个进程公用一个内核区
5、PCB内核控制块，或进程描述符 描述进程的状态
我们知道，每个进程在内核中都有一个进程控制块（PCB）来维护进程相关的信息，Linux内核的进程控制块是task_struct结构体。
/usr/src/linux-headers-3.16.0-30/include/linux/sched.h文件中可以查看struct task_struct 结构体定义。其内部成员有很多，我们重点掌握以下部分即可：
* 进程id。系统中每个进程有唯一的id，在C语言中用pid_t类型表示，其实就是一个非负整数。
* 进程的状态，有就绪、运行、挂起、停止等状态。
* 进程切换时需要保存和恢复的一些CPU寄存器。
* 描述虚拟地址空间的信息。
* 描述控制终端的信息。
* 当前工作目录（Current Working Directory）。
* umask掩码。
* 文件描述符表，包含很多指向file结构体的指针。
* 和信号相关的信息。
* 用户id和组id。
* 会话（Session）和进程组。
* 进程可以使用的资源上限（Resource Limit）。
6、umask掩码：
mask是用来指定"目前用户在新建文件或者目录时候的权限默认值。
比如说默认的是777就是drwxrwxrwx，mask掩码的值是022，就是减少所属组，other用户的写权力，r、w、x分别对应4、2、1。
7、把功能相似的进程放到一个组里 就是进程组、会话统一管理进程组。
8、环境变量
是指在操作系统中用来指定操作系统运行环境的一些参数。通常具备以下特征：
（1）① 字符串(本质) ② 有统一的格式：名=值[:值] ③ 值用来描述进程环境信息。
（2）存储形式：与命令行参数类似。char *[]数组，数组名environ，内部存储字符串，NULL作为哨兵结尾。
（3）使用形式：与命令行参数类似。
（4）环境变量和命令行参数在一起，用户区高于stack的地方
（5）引入环境变量表必须声明环境变量：extern char**environ
（6）打印当前进程的所有环境变量：
#inlcude <stdio.h>
extern char ** environ
void main()
{
int i = 0;
for(i = 0;environ[i];i++)
{
printf("%s\n",environ[i]);
}
}
9、常见的环境变量：
PATH：
可执行文件的搜索路径。ls命令也是一个程序，执行它不需要提供完整的路径名/bin/ls，然而通常我们执行当前目录下的程序a.out却需要提供完整的路径名./a.out，这是因为PATH环境变量的值里面包含了ls命令所在的目录/bin，却不包含a.out所在的目录。PATH环境变量的值可以包含多个目录，用:号隔开。在Shell中用echo命令可以查看这个环境变量的值：
$ echo $PATH
SHELL：
当前Shell，它的值通常是/bin/bash。
TERM：
当前终端类型，在图形界面终端下它的值通常是xterm，终端类型决定了一些程序的输出显示方式，比如图形界面终端可以显示汉字，而字符终端一般不行。
LANG：
语言和locale，决定了字符编码以及时间、货币等信息的显示格式。
HOME：
当前用户主目录的路径，很多程序需要在主目录下保存配置文件，使得每个用户在运行该程序时都有自己的一套配置。
10、环境变量操作函数
getenv：
函数获取环境变量值
char *getenv(const char *name); 成功：返回环境变量的值；失败：NULL
setenv函数：
设置环境变量的值
int setenv(const char *name, const char *value, int overwrite); 成功：0；失败：-1
参数overwrite取值： 1：覆盖原环境变量 0：不覆盖。(该参数常用于设置新环境变量，如：ABC = haha-day-night)
unsetenv函数：
删除环境变量name的定义
int unsetenv(const char *name); 成功：0；失败：-1
注意事项：name不存在仍返回0(成功)，当name命名为"ABC="时则会出错。
11、创建单个子进程：
运行一个应用程序
可以通过函数fork来创建一个子进程
pid_t fork(void); 失败返回-1；成功返回：① 父进程返回子进程的ID(非负) ②子进程返回 0
pid_t类型表示进程ID，但为了表示-1，它是有符号整型。(0不是有效进程ID，init最小，为1)
注意返回值，不是fork函数能返回两个值，而是fork后，fork函数变为两个，父子需【各自】返回一个。
#include<unistd.h>
int main()
{
pid_t pid;
printf("===============\n");
pid = fork();
if(pid == -1)
{
perror("fork error");
exit(1);
}
else if(pid == 0)
{
printf("i am child pid = %u,ppid = %u\n",getpid(),getppid());
}
else
{
printf("i am parentpid = %u,ppid = %u\n",getpid(),getppid());
sleep(1);
}
printf("----------------------------------\n");
结果为：
i am parentpid = 54211,ppid = 54131 //父线程的ppid是 bash
i am child pid = 54212,ppid = 54211 //子线程的ppid是父线程的id
12、循环创建n个子进程
int i = 0;
pid_t pid;
int n;
printf("===============\n");
for(i = 0;i<n;i++)
{
pid = fork();
if(pid == -1)
{
perror("fork error");
exit(1);
}
else if(pid == 0)
{
break;
}
}
if (i<n)
{
printf("i am %d childr pid = %u\n",i+1,getpid());
}
else
{
sleep(i);
printf("I am parent\n");
}
不加sleep输出的顺序不一定，shell进程是父进程的父进程，父进程return0 后就是进行完毕，shell会抢用终端,保证shell的进程是最后一个就行。
13、父子进程共享：
父子进程fork之后，那些是相同的，那些是不同的
父子相同处: 用户区、用户ID、宿主目录、进程工作目录、信号处理方式…
父子不同处: 1.进程ID 2.fork返回值 3.父进程ID 4.进程运行时间 5.闹钟(定时器) 6.未决信号集
似乎，子进程复制了父进程0-3G用户空间内容，以及父进程的PCB，但pid不同。真的每fork一个子进程都要将父进程的0-3G地址空间完全拷贝一份，然后在映射至物理内存吗？
当然不是!父子进程间遵循 读时共享写时复制 的原则。
父进程创建了1个全局变量，int a = 55；
在子进程中修改a = 100;在子进程中输出就是100，在父进程中还是55
fork后谁先执行谁后执行不确定，取决于内核所使用的调度算法
【重点】：父子进程共享：1. 文件描述符(打开文件的结构体) 2. mmap建立的映射区 (进程间通信详解)
14、父子进程中使用gdb调试
gdb调试
使用gdb调试的时候，gdb只能跟踪一个进程。可以在fork函数调用之前，通 过指令设置gdb调试工具跟踪父进程或者是跟踪子进程。默认跟踪父进程。
set follow-fork-mode child 命令设置gdb在fork之后跟踪子进程。
set follow-fork-mode parent 设置跟踪父进程。
注意，一定要在fork函数调用之前设置才有效。
15、exec函数族：
1、fork创建子进程后执行的是和父进程相同的程序（但有可能执行不同的代码分支），子进程往往要调用一种exec函数以执行另一个程序。当进程调用一种exec函数时，该进程的用户空间代码和数据完全被新程序替换，从新程序的启动例程(新的程序main函数的那个函数)开始执行。调用exec并不创建新进程，所以调用exec前后该进程的id并未改变。
2、将当前进程的.text、.data替换为所要加载的程序的.text、.data，然后让进程从新的.text第一条指令开始执行，但进程ID不变，换核不换壳。
其实有六种以exec开头的函数，统称exec函数：
int execl(const char *path, const char *arg, ...);
int execlp(const char *file, const char *arg, ...);
int execle(const char *path, const char *arg, ..., char *const envp[]);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execve(const char *path, char *const argv[], char *const envp[]);
3、常用的三个execlp、execl、execv
①execlp l:list path
加载一个进程，借助PATH环境变量
int execlp(const char *file, const char *arg, …); 成功：无返回；失败：-1
参数1：要加载的程序的名字。该函数需要配合PATH环境变量来使用，当PATH 中所有目录搜索后没有参数1则出错返回。第二个参数用来传argv0 可执行程序的名字 变参 参数个数和类型都不固定
该函数通常用来调用系统程序。如：ls、date、cp、cat等命令。
pid_t pid;
pid = fork();
if(pid == -1)
{
perror("fork error");
exit(1);
}
else if(pid > 0)
{
sleep(1);
printf("parent");
}
else
{
execlp("ls","ls","-l",NULL);
}
输出结果和ls -l 一样
②execl函数：
加载一个进程， 通过 路径+程序名 来加载。
int execl(const char *path, const char *arg, …); 成功：无返回；失败：-1
对比execlp，如加载"ls"命令带有-l，-F参数
execlp(“ls”, “ls”, “-l”, “-F”, NULL); 使用程序名在PATH中搜索。
execl("/bin/ls", “ls”, “-l”, “-F”, NULL); 使用参数1给出的绝对路径搜索。
或者自己写了一个程序 test是你编译生成的名字
execl("./test",“test”,NULL)
③execv函数
int execv(const char *path, char *const argv[]);
自定义一个数组
char *argv[] = {“ls”,"-l","-a","-h",NULL};
execv("/bin/ls",argv);
16、dup2函数复习
dup2(fd1,fd2);把fd1指向的内容赋值给fd2，让fd2也指向这个内容， dup2(fd,STDOUT_FILENO);STDOUT_FILENO是标准输出
exec函数组没用成功返回值，只有失败返回值，成功之后就回去执行那个程序，不会再回到主函数中
exec函数一旦调用成功即执行新的程序，不返回。只有失败才返回，错误值-1。所以通常我们直接在exec函数调用后直接调用perror()和exit()，无需if判断。
将当前系统中的进程信息，打印到文件中
int fd;
fd = open("ps.out",O_WRONLY|O_TRUNC|O_CREAT,0644);
if(fd<0)
{
perror("open ps.out error");
exit(1);
}
dup2(fd,STDOUT_FILENO);
execlp("ps","ps","ax",NULL);
perror("exec erro");
exit(1);
17、僵尸进程和孤儿进程
孤儿进程: 父进程先于子进程结束，则子进程成为孤儿进程，子进程的父进程成为init进程，称为init进程领养孤儿进程。
子进程是一个while循环的函数，父进程只打印一句话，父进程就会先于子进程结束，子进程就变成了孤儿进程，就会进入Init进程，他们的进程ID就是0或者1704
僵尸进程: 进程终止，父进程尚未回收，子进程残留资源（PCB）存放于内核中，变成僵尸（Zombie）进程。
子进程打印一句话，休眠十秒后死亡，父进程循环，子进程死了后父进程没有进行收尸，就会把pcb存入内核，而且无法用kill清除。
18、wait
一个进程在终止时会关闭所有文件描述符，释放在用户空间分配的内存，但它的PCB还保留着，内核在其中保存了一些信息：如果是正常终止则保存着退出状态，如果是异常终止则保存着导致该进程终止的信号是哪个。这个进程的父进程可以调用wait或waitpid获取这些信息，然后彻底清除掉这个进程。我们知道一个进程的退出状态可以在Shell中用特殊变量$?查看，因为Shell是它的父进程，当它终止时Shell调用wait或waitpid得到它的退出状态同时彻底清除掉这个进程。
父进程调用wait函数可以回收子进程终止信息。该函数有三个功能：
① 阻塞等待子进程退出
② 回收子进程残留资源
③ 获取子进程结束状态(退出原因)。
pid_t wait(int *status); 成功：清理掉的子进程ID；失败：-1 (没有子进程)
wpid = wait(NULL);正常参数是可以打印出子进程死亡信息
会阻塞，子进程死亡之前，父进程不会进行，子进程死亡后，会自动回收
可使用wait函数传出参数status来保存进程的退出状态。借助宏函数来进一步判断进程终止的具体原因。宏函数可分为如下三组：
- WIFEXITED(status) 为非0 → 进程正常结束
WEXITSTATUS(status) 如上宏为真，使用此宏 → 获取进程退出状态 (exit的参数) -
WIFSIGNALED(status) 为非0 → 进程异常终止 WTERMSIG(status) 如上宏为真，使用此宏 → 取得使进程终止的那个信号的编号。 -
WIFSTOPPED(status) 为非0 → 进程处于暂停状态 WSTOPSIG(status) 如上宏为真，使用此宏 → 取得使进程暂停的那个信号的编号。 WIFCONTINUED(status) 为真 → 进程暂停后已经继续运行。
pid_t pid;
pid_t wpid;
pid = fork();
if(pid == 0)
{
printf("sssssss\n");
exit(76);
}
else if(pid>0)
{
int status;
wpid = wait(&status);
if(wpid == -1)
{
perror("wait error");
exit(1);
}
if(WIFEXITED(status))
printf("child exit with %d\n",WEXITSTATUS(status));
}
正常退出就会返回76
if(WIFSIGNALED(status))
{
printf("child killed by %d\n",WTERMSIG(status));
}
在另一个终端杀死进程，就会犯回错误 kill -num +ID num是信号编号，返回的值也是这个编号
19、waitip
作用同wait，但可指定pid进程清理，可以不阻塞。
pid_t waitpid(pid_t pid, int *status, in options); 成功：返回清理掉的子进程ID；失败：-1(无子进程)
特殊参数和返回情况：
参数pid：
> 0 回收指定ID的子进程
-1 回收任意子进程（相当于wait）
0 回收和当前调用waitpid一个组的所有子进程
<-1 回收指定进程组内的任意子进程
返回0：参3为WNOHANG，且子进程正在运行。
注意：一次wait或waitpid调用只能清理一个子进程，清理多个子进程应使用循环
wait和waitip都是只能回收一个进程，想要回收多个就要加循环
全部回收
while(wait(NULL))
;
while(1);
int i, n = 5;
pid_t pid,p;
for(i = 0;i<n;i++)
{
pid = fork();
if(pid == 0)
{
break;
}
else if(i == 3)
{
p = pid;
}
}
if(i == n)
{
sleep(n);
printf("i am parent%d\n",getpid());
// while(wait(NULL)) //用wait全部删除
// ;
// waitpid(p,NULL,0);//阻塞式
while(waitpid(-1,NULL,WNOHANG));//全部回收
while(1);
}
else
{
sleep(i);
printf("i am %dth child,pid = %d,gpid = %d\n",i+1,getpid(),getgid());
}
WNOHANG 看子进程是否结束，结束就回收，不结束就返回。成功返回pid，失败返回-1，返回0时代表子进程尚未结束
do
{
wpid = while(waitpid(-1,NULL,WNOHANG))；
if(wpid>0)
{
n--;
}
}while(n>0); 子进程没结束返回0
杀死父进程僵尸进程也会被解决
20、管道
进程间通信 IPC方法
文件 目录 符号链接 是文件
套接字，块设备，字符设备，管道不占磁盘空间，就是伪文件
管道是一种最基本的IPC机制，作用于有血缘关系的进程之间，完成数据传递。调用pipe系统函数即可创建一个管道。有如下特质：
1. 其本质是一个伪文件(实为内核缓冲区)
2. 由两个文件描述符引用，一个表示读端，一个表示写端。
3. 规定数据从管道的写端流入管道，从读端流出。
管道的原理: 管道实为内核使用环形队列机制，借助内核缓冲区(4k)实现。
管道的局限性：
① 数据自己读不能自己写。
② 数据一旦被读走，便不在管道中存在，不可反复读取。
③ 由于管道采用半双工通信方式。因此，数据只能在一个方向上流动。
④ 只能在有公共祖先的进程间使用管道。
常见的通信方式有，单工通信、半双工通信、全双工通信。
pipe函数
创建管道
int pipe(int pipefd[2]); 成功：0；失败：-1，设置errno
函数调用成功返回r/w两个文件描述符。无需open，但需手动close。规定：fd[0] → r； fd[1] → w，就像0对应标准输入，1对应标准输出一样。向管道文件读写数据其实是在读写内核缓冲区。
int fd[2];
int ret = pipe(fd);
pid_t pid;
if(ret == -1)
{
perror("pipe error");
exit(1);
}
pid = fork();
if(pid == -1)
{
perror("pipe error");
exit(1);
}
else if(pid == 0)
{
// zi du
close(fd[1]);
char buf[1024];
int ret = read(fd[0],buf,sizeof(buf));
if(ret == 0)
{
printf("---------\n");
}
write(STDOUT_FILENO,buf,ret);
}
else
{
close(fd[0]);
write(fd[1],"hello pipe\n",strlen("hello pipe\n"));
}
常用的集中进程间通信：
管道 使用简单 具体看上一节
FIFO 命名管道，解决非血缘关系
信号：开销小，传递固定少量信息
共享内存：非血缘之间，和管道的区别就是可以反复读取
本地套接字：网络编程介绍
管道：
读管道：分为两种情况： 管道中有数据：read返回实际读到的字节数
管道中无数据：写端关闭，read返回0
仍有写端，阻塞等待
写管道：读端关闭：程序异常结束
有读端：管道未满，写数据，返回写入字节数
管道已满，阻塞
可以进行父子间通信和兄弟之间的通信
ulimit -a 查看管道的权限。
21、通过文件进行父子间进程通信
int main(void)
{
int fd1, fd2; pid_t pid;
char buf[1024];
char *str = "---------test for shared fd in parent child process-----\n";
pid = fork();
if (pid < 0) {
perror("fork error");
exit(1);
} else if (pid == 0) {
fd1 = open("test.txt", O_RDWR);
if (fd1 < 0) {
perror("open error");
exit(1);
}
write(fd1, str, strlen(str));
printf("child wrote over...\n");
} else {
fd2 = open("test.txt", O_RDWR);
if (fd2 < 0) {
perror("open error");
exit(1);
}
sleep(1); //保证子进程写入数据
int len = read(fd2, buf, sizeof(buf));
write(STDOUT_FILENO, buf, len);
wait(NULL);
}
return 0;
}
22、非血缘关系之间也可以进行通信
mmap函数介绍：
void *mmap(void *addr, size_t length, int prot, int flags,
int fd, off_t offset);
返回：成功：返回创建的映射区首地址；失败：MAP_FAILED宏
参数：
addr: 建立映射区的首地址，由Linux内核指定。使用时，直接传递NULL
length： 欲创建映射区的大小
prot： 映射区权限PROT_READ、PROT_WRITE、PROT_READ|PROT_WRITE
flags： 标志位参数(常用于设定更新物理区域、设置共享、创建匿名映射区)
MAP_SHARED: 会将映射区所做的操作反映到物理设备（磁盘）上。
MAP_PRIVATE: 映射区所做的修改不会反映到物理设备。
fd：用来建立映射区的文件描述符
offset： 映射文件的偏移(4k的整数倍)
用mmap实现建立映射内存：：
#include<stdio.h>
#include<fcntl.h>
#include<unistd.h>
#include<string.h>
#include<stdlib.h>
#include<sys/mman.h>
int main(void)
{
char *p = NULL;
int fd = open("mytest.txt",O_CREAT|O_RDWR,0644);
if(fd<0)
{
perror("open errpr");
exit(1);
}
int len = ftruncate(fd,4); //拓展文件大小的，第一个参数是文件描述符，第二个参数是想要拓展多大
if(len == -1)
{
perror("ftruncate");
exit(1);
}
p = mmap(NULL,4,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
if(p == MAP_FAILED)
{
perror("mmap error");
exit(1);
}
strcpy(p,"abc");//xie shu ju
int ret = munmap(p,4);
if(ret == -1)
{
perror("munmap error");
exit(1);
}
close(fd);
}
mmap使用注意事项：
1、不能创建一个为0的映射区
2、不允许才最mmap的指针自加或自减，会改变原来的首地址，后面的munmap不可用
3、 ①创建映射区的权限小于等于打开文件的权限
②映射区创建过程中隐含一次读操作
4、文件的偏移量(mmap最后一个参数只能是4k的整数倍)
5、fd提前关闭对映射区没有影响
1. 可以open的时候O_CREAT一个新文件来创建映射区吗?
2. 如果open时O_RDONLY, mmap时PROT参数指定PROT_READ|PROT_WRITE会怎样？
3. 文件描述符先关闭，对mmap映射有没有影响？
4. 如果文件偏移量为1000会怎样？
5. 对mem越界操作会怎样？
6. 如果mem++，munmap可否成功？
7. mmap什么情况下会调用失败？
8. 如果不检测mmap的返回值，会怎样？
1.创建映射区的过程中，隐含着一次对映射文件的读操作。
2.当MAP_SHARED时，要求：映射区的权限应 <=文件打开的权限(出于对映射区的保护)。而MAP_PRIVATE则无所谓，因为mmap中的权限是对内存的限制。
3.映射区的释放与文件关闭无关。只要映射建立成功，文件可以立即关闭。
4.特别注意，当映射文件大小为0时，不能创建映射区。所以：用于映射的文件必须要有实际大小！！ mmap使用时常常会出现总线错误，通常是由于共享文件存储空间大小引起的。
5.munmap传入的地址一定是mmap的返回地址。坚决杜绝指针++操作。
6.如果文件偏移量必须为4K的整数倍
7.mmap创建映射区出错概率非常高，一定要检查返回值，确保映射区建立成功再进行后续操作。
mmap父子进程间通信：
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<fcntl.h>
#include<sys/mman.h>
#include<sys/wait.h>
int var = 100;
int main()
{
int *p;
pid_t pid;
int fd;
fd = open("temp",O_RDWR|O_CREAT|O_TRUNC,0644);
if(fd<0)
{
perror("open error");
exit(1);
}
unlink("temp");
ftruncate(fd,4);
p = (int *)mmap(NULL,4,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
if(p == MAP_FAILED)
{
perror("mmap error");
exit(1);
}
close(fd);
pid = fork();
if(pid == 0)
{
*p = 2000;
var = 1000;
printf("child,*p = %d,var = %d\n",*p,var);
}
else
{
sleep(1);
printf("Parent.*p = %d,var = %d\n",*p,var);
wait(NULL);
int ret = munmap(p,4);
if(ret == -1)
{
perror("munmap error");
exit(1);
}
}
unlink("temp");删除文件所有的硬链接，当占用这个文件的进程结束时才会删除这个文件
p = (int *)mmap(NULL,4,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0); 参数改为PRIVATE不会共享
MAP_PRIVATE: (私有映射) 父子进程各自独占映射区；
MAP_SHARED: (共享映射) 父子进程共享映射区；
练习：父进程创建映射区，然后fork子进程，子进程修改映射区内容，而后，父进程读取映射区内容，查验是否共享。
不共享
23匿名映射区
匿名映射
通过使用我们发现，使用映射区来完成文件读写操作十分方便，父子进程间通信也较容易。但缺陷是，每次创建映射区一定要依赖一个文件才能实现。通常为了建立映射区要open一个temp文件，创建好了再unlink、close掉，比较麻烦。 可以直接使用匿名映射来代替。其实Linux系统给我们提供了创建匿名映射区的方法，无需依赖一个文件即可创建映射区。同样需要借助标志位参数flags来指定。
使用MAP_ANONYMOUS (或MAP_ANON)， 如:
int *p = mmap(NULL, 4, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0);
“4"随意举例，该位置表大小，可依实际需要填写。
需注意的是，MAP_ANONYMOUS和MAP_ANON这两个宏是Linux操作系统特有的宏。在类Unix系统中如无该宏定义，可使用如下两步来完成匿名映射区的建立。
① fd = open(”/dev/zero", O_RDWR);
② p = mmap(NULL, size, PROT_READ|PROT_WRITE, MMAP_SHARED, fd, 0);
mmp无血缘关系之间通信
代码看/root/Liunx/2/3Days/Mmap
24号的基本概念和机制
1、基本属性 软中断
2、信号的特质：由于信号是通过软件方法实现，其实现手段导致信号有很强的延时性。但对于用户来说，这个延迟时间非常短，不易察觉。
3、每个进程收到的所有信号，都是由内核负责发送的，内核处理。
4、产生信号的方法：
1. 按键产生，如：Ctrl+c、Ctrl+z、Ctrl+
2. 系统调用产生，如：kill、raise、abort
3. 软件条件产生，如：定时器alarm
4. 硬件异常产生，如：非法访问内存(段错误)、除0(浮点数例外)、内存对齐出错(总线错误)
5. 命令产生，如：kill命令
递达：递送并且到达进程。 瞬时的
未决：产生和递达之间的状态。主要由于阻塞(屏蔽)导致该状态。
信号产生被阻塞了，不能递达就叫阻塞态Linux内核中对阻塞态有一个机制，这个描述他的机制对应一个集合，叫阻塞信号集(信号屏蔽字)，相互呼应的叫未决信号集。
pcb本质式结构体 里面有两个主要成员，未决信号集合阻塞信号集
集合这种数据结构：不重复但是无序。
在未决信号集 里面存数存的是0 0 0 1 0 0 ，对应信号编号，0 1 对应信号的状态，信号触发 由0变成1
阻塞信号集中 0变成1 就是把信号屏蔽掉，阻塞信号集影响未决信号集。
信号的处理方式:
1. 执行默认动作 每一个信号有自己的默认动作
2. 忽略(丢弃) 不是指不处理信号，处理了忽略掉
3. 捕捉(调用户处理函数) 不执行默认的动作，完成仔细想做的
Linux内核的进程控制块PCB是一个结构体，task_struct, 除了包含进程id，状态，工作目录，用户id，组id，文件描述符表，还包含了信号相关的信息，主要指阻塞信号集和未决信号集。
阻塞信号集(信号屏蔽字)： 将某些信号加入集合，对他们设置屏蔽，当屏蔽x信号后，再收到该信号，该信号的处理将推后(解除屏蔽后)
未决信号集:
信号产生，未决信号集中描述该信号的位立刻翻转为1，表信号处于未决状态。当信号被处理对应位翻转回为0。这一时刻往往非常短暂。
信号产生后由于某些原因(主要是阻塞)不能抵达。这类信号的集合称之为未决信号集。在屏蔽解除前，信号一直处于未决状态。
5、信号的四要素
1. 编号 2. 名称 3. 事件 4. 默认处理动作
kill -l 查看信号 34-64实时信号，嵌入式开发中驱动开发用的到
1-31普通信号
可通过man 7 signal查看帮助文档获取。也可查看/usr/src/linux-headers-3.16.0-30/arch/s390/include/uapi/asm/signal.h
Signal Value Action Comment
────────────────────────────────────────────
SIGHUP 1 Term Hangup detected on controlling terminal or death of controlling process
SIGINT 2 Term Interrupt from keyboard
SIGQUIT 3 Core Quit from keyboard
SIGILL 4 Core Illegal Instruction
SIGFPE 8 Core Floating point exception
SIGKILL 9 Term Kill signal
SIGSEGV 11 Core Invalid memory reference
SIGPIPE 13 Term Broken pipe: write to pipe with no readers
SIGALRM 14 Term Timer signal from alarm(2)
SIGTERM 15 Term Termination signal
SIGUSR1 30,10,16 Term User-defined signal 1
SIGUSR2 31,12,17 Term User-defined signal 2
SIGCHLD 20,17,18 Ign Child stopped or terminated
SIGCONT 19,18,25 Cont Continue if stopped
SIGSTOP 17,19,23 Stop Stop process
SIGTSTP 18,20,24 Stop Stop typed at terminal
SIGTTIN 21,21,26 Stop Terminal input for background process
SIGTTOU 22,22,27 Stop Terminal output for background process
The signals SIGKILL and SIGSTOP cannot be caught, blocked, or ignored.
在标准信号中，有一些信号是有三个“Value”，第一个值通常对alpha和sparc架构有效，中间值针对x86、arm和其他架构，最后一个应用于mips架构。一个‘-’表示在对应架构上尚未定义该信号。
不同的操作系统定义了不同的系统信号。因此有些信号出现在Unix系统内，也出现在Linux中，而有的信号出现在FreeBSD或Mac OS中却没有出现在Linux下。这里我们只研究Linux系统中的信号。
6、信号的默认动作
Term：终止进程
Ign： 忽略信号 (默认即时对该种信号忽略操作)
Core：终止进程，生成Core文件。(查验进程死亡原因， 用于gdb调试)
Stop：停止（暂停）进程
Cont：继续运行进程
注意从man 7 signal帮助文档中可看到 : The signals SIGKILL and SIGSTOP cannot be caught, blocked, or ignored.
这里特别强调了9) SIGKILL 和19) SIGSTOP信号，不允许忽略和捕捉，只能执行默认动作。甚至不能将其设置为阻塞。
另外需清楚，只有每个信号所对应的事件发生了，该信号才会被递送(但不一定递达)，不应乱发信号！！
7、Linux常规信号一览表
- SIGHUP: 当用户退出shell时，由该shell启动的所有进程将收到这个信号，默认动作为终止进程
- SIGINT：当用户按下了<Ctrl+C>组合键时，用户终端向正在运行中的由该终端启动的程序发出此信号。默认动
作为终止进程。 - SIGQUIT：当用户按下<ctrl+>组合键时产生该信号，用户终端向正在运行中的由该终端启动的程序发出些信
号。默认动作为终止进程。 - SIGILL：CPU检测到某进程执行了非法指令。默认动作为终止进程并产生core文件
- SIGTRAP：该信号由断点指令或其他 trap指令产生。默认动作为终止里程 并产生core文件。
- SIGABRT: 调用abort函数时产生该信号。默认动作为终止进程并产生core文件。
- SIGBUS：非法访问内存地址，包括内存对齐出错，默认动作为终止进程并产生core文件。
- SIGFPE：在发生致命的运算错误时发出。不仅包括浮点运算错误，还包括溢出及除数为0等所有的算法错误。默认动作为终止进程并产生core文件。
- SIGKILL：无条件终止进程。本信号不能被忽略，处理和阻塞。默认动作为终止进程。它向系统管理员提供了可以杀死任何进程的方法。
- SIGUSE1：用户定义 的信号。即程序员可以在程序中定义并使用该信号。默认动作为终止进程。
- SIGSEGV：指示进程进行了无效内存访问。默认动作为终止进程并产生core文件。
- SIGUSR2：另外一个用户自定义信号，程序员可以在程序中定义并使用该信号。默认动作为终止进程。
- SIGPIPE：Broken pipe向一个没有读端的管道写数据。默认动作为终止进程。
- SIGALRM: 定时器超时，超时的时间 由系统调用alarm设置。默认动作为终止进程。
- SIGTERM：程序结束信号，与SIGKILL不同的是，该信号可以被阻塞和终止。通常用来要示程序正常退出。执行shell命令Kill时，缺省产生这个信号。默认动作为终止进程。
- SIGSTKFLT：Linux早期版本出现的信号，现仍保留向后兼容。默认动作为终止进程。
- SIGCHLD：子进程结束时，父进程会收到这个信号。默认动作为忽略这个信号。
- SIGCONT：如果进程已停止，则使其继续运行。默认动作为继续/忽略。
- SIGSTOP：停止进程的执行。信号不能被忽略，处理和阻塞。默认动作为暂停进程。
- SIGTSTP：停止终端交互进程的运行。按下<ctrl+z>组合键时发出这个信号。默认动作为暂停进程。
- SIGTTIN：后台进程读终端控制台。默认动作为暂停进程。
- SIGTTOU: 该信号类似于SIGTTIN，在后台进程要向终端输出数据时发生。默认动作为暂停进程。
- SIGURG：套接字上有紧急数据时，向当前正在运行的进程发出些信号，报告有紧急数据到达。如网络带外数据到达，默认动作为忽略该信号。
- SIGXCPU：进程执行时间超过了分配给该进程的CPU时间 ，系统产生该信号并发送给该进程。默认动作为终止进程。
- SIGXFSZ：超过文件的最大长度设置。默认动作为终止进程。
- SIGVTALRM：虚拟时钟超时时产生该信号。类似于SIGALRM，但是该信号只计算该进程占用CPU的使用时间。默认动作为终止进程。
- SGIPROF：类似于SIGVTALRM，它不公包括该进程占用CPU时间还包括执行系统调用时间。默认动作为终止进程。
- SIGWINCH：窗口变化大小时发出。默认动作为忽略该信号。
- SIGIO：此信号向进程指示发出了一个异步IO事件。默认动作为忽略。
- SIGPWR：关机。默认动作为终止进程。
- SIGSYS：无效的系统调用。默认动作为终止进程并产生core文件。
- SIGRTMIN ～ (64) SIGRTMAX：LINUX的实时信号，它们没有固定的含义（可以由用户自定义）。所有的实时信号的默认动作都为终止进程
25、kill
终端按键产生信号
Ctrl + c → 2) SIGINT（终止/中断） “INT” ----Interrupt
Ctrl + z → 20) SIGTSTP（暂停/停止） “T” ----Terminal 终端。
Ctrl + \ → 3) SIGQUIT（退出）
硬件异常产生信号
除0操作 → 8) SIGFPE (浮点数例外) “F” -----float 浮点数。
非法访问内存 → 11) SIGSEGV (段错误)
总线错误 → 7) SIGBUS
kill函数/命令产生信号:
kill命令产生信号：kill -SIGKILL pid
kill函数：给指定进程发送指定信号(不一定杀死)
int kill(pid_t pid, int sig); 成功：0；失败：-1 (ID非法，信号非法，普通用户杀init进程等权级问题)，设置errno
sig：不推荐直接使用数字，应使用宏名，因为不同操作系统信号编号可能不同，但名称一致。
pid > 0: 发送信号给指定的进程。
pid = 0; 自己的进程组所有进程全部kill
pid < 0: 取|pid|发给对应进程组。 指定一个进程组所有进程全部kill
pid = -1：发送给进程有权限发送的系统中所有进程。千万不要kill-1，kill完黑屏，
进程组：每个进程都属于一个进程组，进程组是一个或多个进程集合，他们相互关联，共同完成一个实体任务，每个进程组都有一个进程组长，默认进程组ID与进程组长ID相同。
权限保护：super用户(root)可以发送信号给任意用户，普通用户是不能向系统用户发送信号的。 kill -9 (root用户的pid) 是不可以的。同样，普通用户也不能向其他普通用户发送信号，终止其进程。 只能向自己创建的进程发送信号。普通用户基本规则是：发送者实际或有效用户ID == 接收者实际或有效用户ID
练习：循环创建5个子进程，任一子进程用kill函数终止其父进程。
pid_t pid,wpid;
int i;
for(i = 0;i<5;i++)
{
pid = fork();
if(pid == 0)
{
break;
}
if(i == 2)
{
wpid = pid;
}
}
if(i<5)
{
while(1)
{
printf("In Child i = %d id: %d\n",i,getpid());
sleep(1);
}
}
else
{
sleep(1);
kill(wpid,SIGKILL);
while(1);
}
当使用cat|cat|cat|时
使用kill -9 加进程Id的时候，也会全部删除，因为管道的原因，第一个删除了，第二个管道的写端没有了，所以就都没了
当kill -9 -进程ID时，杀死会有提示
26、alarm
raise函数和abort函数：
raise 函数：给当前进程发送指定信号(自己给自己发) raise(signo) == kill(getpid(), signo);
int raise(int sig); 成功：0，失败非0值
abort 函数：给自己发送异常终止信号 6) SIGABRT 信号，终止并产生core文件
void abort(void); 该函数无返回
alarm：
设置定时器(闹钟)。在指定seconds后，内核会给当前进程发送14）SIGALRM信号。进程收到该信号，默认动作终止。
每个进程都有且只有唯一个定时器。
unsigned int alarm(unsigned int seconds); 返回0或剩余的秒数，无失败。
常用：取消定时器alarm(0)，返回旧闹钟余下秒数。
例：alarm(5) → 3sec → alarm(4) → 5sec → alarm(5) → alarm(0) 相当于取消闹钟
定时，与进程状态无关(自然定时法)！就绪、运行、挂起(阻塞、暂停)、终止、僵尸…无论进程处于何种状态，alarm都计时。
练习：编写程序，测试你使用的计算机1秒钟能数多少个数。
#include<stdio.h>
#include<unistd.h>
int main(void)
{
int i;
alarm(1);
for(i == 0;;i++)
{
printf("%d\n",i);
}
return 0;
}
使用time命令查看程序执行的时间。 程序运行的瓶颈在于IO，优化程序，首选优化IO。
real:真实消耗时间
usr：在usr区中的时间
sys：在内核区的时间
time ./a.out >out 输出中定向到out文件中
实际执行时间 = 系统时间 + 用户时间 + 等待时间
27、setitimer函数
设置定时器(闹钟)。 可代替alarm函数。精度微秒us，可以实现周期定时。
int setitimer(int which, const struct itimerval *new_value, struct itimerval *old_value); 成功：0；失败：-1，设置errno
参数：which：指定定时方式
① 自然定时：ITIMER_REAL → 14）SIGLARM 计算自然时间
② 虚拟空间计时(用户空间)：ITIMER_VIRTUAL → 26）SIGVTALRM 只计算进程占用cpu的时间
③ 运行时计时(用户+内核)：ITIMER_PROF → 27）SIGPROF 计算占用cpu及执行系统调用的时间。
练习: 使用setitimer函数实现alarm函数，重复计算机1秒数数程序。
struct itimerval {
struct timeval it_interval; 下一次时钟的值
struct timeval it_value; 当前的值
};
struct timeval {
time_t tv_sec; /* seconds */
suseconds_t tv_usec; /* microseconds */
};
unsigned int my_alarm(unsigned int sec)
{
struct itimerval it, oldit;
int ret;
it.it_value.tv_sec = sec;
it.it_value.tv_usec = 0; 吧
it.it_interval.tv_sec = 0;
it.it_interval.tv_usec = 0;
ret = setitimer(ITIMER_REAL, &it, &oldit);
if (ret == -1) {
perror("setitimer");
exit(1);
}
return oldit.it_value.tv_sec;
}
int main(void)
{
int i;
my_alarm(1); //alarm(sec);
for(i = 0; ; i++)
printf("%d\n", i);
return 0;
}
28、signal捕捉信号
内核帮忙捕捉信号，内核帮助我们调用
信号捕捉函数是一个回调函数
拓展练习，结合man page编写程序，测试it_interval、it_value这两个参数的作用。
提示： it_interval：用来设定两次定时任务之间间隔的时间。
it_value：定时的时长
两个参数都设置为0，即清0操作。
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <signal.h>
void funcl()
{
int i;
for(i = 0;i<3;i++)
{
printf("%d\n",i);
}
}
unsigned int my_alarm(unsigned int sec)
{
struct itimerval it, oldit;
int ret;
it.it_value.tv_sec = sec;
it.it_value.tv_usec = 0;
it.it_interval.tv_sec = 1;
it.it_interval.tv_usec = 0;
ret = setitimer(ITIMER_REAL, &it, &oldit);
if (ret == -1) {
perror("setitimer");
exit(1);
}
return oldit.it_value.tv_sec;
}
int main(void)
{
int i;
signal(SIGALRM,funcl);
my_alarm(1); //alarm(sec);
while(1);
return 0;
}
29、信号集操作函数
信号集操作函数
系统函数不会直接去进行位操作
sigset_t set; // typedef unsigned long sigset_t; 八字节信号集
int sigemptyset(sigset_t *set); 将某个信号集清0 成功：0；失败：-1
int sigfillset(sigset_t *set); 将某个信号集置1 成功：0；失败：-1
int sigaddset(sigset_t *set, int signum); 将某个信号加入信号集 成功：0；失败：-1
int sigdelset(sigset_t *set, int signum); 将某个信号清出信号集 成功：0；失败：-1
int sigismember(const sigset_t *set, int signum);判断某个信号是否在信号集中 返回值：在集合：1；不在：0；出错：-1
sigset_t类型的本质是位图。但不应该直接使用位操作，而应该使用上述函数，保证跨系统操作有效。
对比认知select 函数。
sigprocmask函数 用来操作阻塞信号集
用来屏蔽信号、解除屏蔽也使用该函数。其本质，读取或修改进程的信号屏蔽字(PCB中)
严格注意，屏蔽信号：只是将信号处理延后执行(延至解除屏蔽)；而忽略表示将信号丢处理。
int sigprocmask(int how, const sigset_t *set, sigset_t *oldset); 成功：0；失败：-1，设置errno
参数：
set：传入参数，是一个位图，set中哪位置1，就表示当前进程屏蔽哪个信号。
oldset：传出参数，保存旧的信号屏蔽集。
how参数取值： 假设当前的信号屏蔽字为mask
1.SIG_BLOCK: 当how设置为此值，set表示需要屏蔽的信号。相当于 mask = mask|set
2.SIG_UNBLOCK: 当how设置为此，set表示需要解除屏蔽的信号。相当于 mask = mask & ~set
3.SIG_SETMASK: 当how设置为此，set表示用于替代原始屏蔽及的新屏蔽集。相当于 mask = set若，调用sigprocmask解除了对当前若干个信号的阻塞，则在sigprocmask返回前，至少将其中一个信号递达。
sigpending函数
读取当前进程的未决信号集
int sigpending(sigset_t *set); set传出参数。 返回值：成功：0；失败：-1，设置errno
练习：编写程序。把所有常规信号的未决状态打印至屏幕。
#include<stdio.h>
#include<signal.h>
#include<stdlib.h>
#include<unistd.h>
void printpending(sigset_t *pend)
{
int i;
for(i =1;i<32;i++)
{
if(sigismember(pend,i) == 1)
{
putchar('1');
}
else
{
putchar('0');
}
}
printf("\n");
}
int main()
{
sigset_t myset,pend,oldset;
sigemptyset(&myset);
sigaddset(&myset,SIGQUIT);
//sigaddset(&myset,SIGINT);
//sigaddset(&myset,SIGTSTP);
sigaddset(&myset,SIGSEGV);
sigaddset(&myset,SIGKILL);
sigprocmask(SIG_BLOCK,&myset,&oldset);
while(1)
{
sigpending(&pend);
printpending(&pend);
sleep(1);
}
return 0;
处理信号的函数返回值必须为void 参数必须为int
30、sigaction函数注册信号捕捉
修改信号处理动作（通常在Linux用其来注册一个信号的捕捉函数）
int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact); 成功：0；失败：-1，设置errno
参数：
act：传入参数，新的处理方式。
oldact：传出参数，旧的处理方式。
struct sigaction结构体：
struct sigaction {
void (*sa_handler)(int);
void (*sa_sigaction)(int, siginfo_t *, void *);
sigset_t sa_mask;
int sa_flags;
void (*sa_restorer)(void);
};
sa_restorer：该元素是过时的，不应该使用，POSIX.1标准将不指定该元素。(弃用)
sa_sigaction：当sa_flags被指定为SA_SIGINFO标志时，使用该信号处理程序。(很少使用)
重点掌握：
① sa_handler：指定信号捕捉后的处理函数名(即注册函数)。也可赋值为SIG_IGN表忽略 或 SIG_DFL表执行默认动作
② sa_mask: 调用信号处理函数时，所要屏蔽的信号集合(信号屏蔽字)。注意：仅在处理函数被调用期间屏蔽生效，是临时性设置。
③ sa_flags：通常设置为0，表使用默认属性。 当处理信号时，这个信号又来了，就等这个处理完了在处理这个
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<signal.h>
void docatch(int signo)
{
printf("%d signal is catched\n",signo);
}
int main()
{
struct sigaction act;
act.sa_handler = docatch;
sigemptyset(&act.sa_mask );
sigaddset(&act.sa_mask,SIGQUIT);
act.sa_flags = 0;设置成默认属性，展示屏蔽本信号
int ret = sigaction(SIGINT,&act,NULL);
if(ret <0)
{
perror("ssigaction error");
exit(1);
}
while(1);
}
信号捕捉特性
1.进程正常运行时，默认PCB中有一个信号屏蔽字，假定为☆，它决定了进程自动屏蔽哪些信号。当注册了某个信号捕捉函数，捕捉到该信号以后，要调用该函数。而该函数有可能执行很长时间，在这期间所屏蔽的信号不由☆来指定。而是用sa_mask来指定。调用完信号处理函数，再恢复为☆。
2.XXX信号捕捉函数执行期间，XXX信号自动被屏蔽。
31、pouse函数
pause函数
当一个函数被捕捉，并且一个信号捕捉返回函数返回时才会return
调用该函数可以造成进程主动挂起，等待信号唤醒。调用该系统调用的进程将处于阻塞状态(主动放弃cpu) 直到有信号递达将其唤醒。
int pause(void); 返回值：-1 并设置errno为EINTR
返回值：
① 如果信号的默认处理动作是终止进程，则进程终止，pause函数么有机会返回。
② 如果信号的默认处理动作是忽略，进程继续处于挂起状态，pause函数不返回。
③ 如果信号的处理动作是捕捉，则【调用完信号处理函数之后，pause返回-1】
errno设置为EINTR，表示“被信号中断”。想想我们还有哪个函数只有出错返回值。
④ pause收到的信号不能被屏蔽，如果被屏蔽，那么pause就不能被唤醒。
使用pause和alarm来实现sleep函数。
正常： 10后闹铃将我唤醒，这时额外设置alarm(0)取消闹铃，不会出错。
异常： 5分钟，被其他事物吵醒，alarm(0)取消闹铃防止打扰。
#include<stdio.h>
#include<unistd.h>
#include<signal.h>
#include<stdlib.h>
#include<errno.h>
void func(int signo)
{
;
}
unsigned int mysleep(unsigned int seconds)
{
struct sigaction act,oldact;
act.sa_handler = func;
act.sa_flags = 0;
sigemptyset(&act.sa_mask);
sigaction (SIGALRM,&act,&oldact);
// signal(SIGALRM,func);
alarm(seconds);
int ret = pause();
if(ret == -1 && errno == EINTR)
{
printf("pasuse success\n");
}
ret = alarm(0);
sigaction(SIGALRM,&oldact,NULL); //恢复SiGALAM原有的处理方式
return ret;
}
int main()
{
while(1)
{
mysleep(3);
printf("-0-0-0-0-0-\n");
}
}
32、时序竞态产生
当程序运行时，突然失去CPU,当CPU出现时，挂起就不会再被唤醒
解决方法： 以通过设置屏蔽SIGALRM的方法来控制程序执行逻辑，但无论如何设置，程序都有可能在“解除信号屏蔽”与“挂起等待信号”这个两个操作间隙失去cpu资源。除非将这两步骤合并成一个“原子操作”。sigsuspend函数具备这个功能。在对时序要求严格的场合下都应该使用sigsuspend替换pause。
int sigsuspend(const sigset_t *mask); 挂起等待信号。
sigsuspend函数调用期间，进程信号屏蔽字由其参数mask指定。
可将某个信号（如SIGALRM）从临时信号屏蔽字mask中删除，这样在调用sigsuspend时将解除对该信号的屏蔽，然后挂起等待，当sigsuspend返回时，进程的信号屏蔽字恢复为原来的值。如果原来对该信号是屏蔽态，sigsuspend函数返回后仍然屏蔽该信号。
改进版mysleep：
#include<stdio.h>
#include<unistd.h>
#include<signal.h>
#include<stdlib.h>
#include<errno.h>
void func(int signo)
{
;
}
unsigned int mysleep(unsigned int seconds)
{
struct sigaction act,oldact; //sigaction使用的宏
sigset_t newmask,oldmask ,suspmask;
act.sa_handler = func; //宏里面结构体赋值
act.sa_flags = 0;
sigemptyset(&act.sa_mask);
sigaction (SIGALRM,&act,&oldact);//信号绑定
sigemptyset(&newmask);
sigaddset(&newmask,SIGALRM);
sigprocmask(SIG_BLOCK,&newmask,&oldmask);//以上三步，在原有内核中的信号屏蔽字中屏蔽SIGNALRM信号
alarm(seconds);
suspmask = oldmask;
sigdelset(&suspmask,SIGALRM); //这两步相当于把SIGNALRM信号打开
sigsuspend(&suspmask); //使用这个函数可以无缝对接，防止cpu不见，这个函数期间使用的是自己的信号屏蔽字
int ret = alarm(0);
sigaction(SIGALRM,&oldact,NULL);
return ret;
}
int main()
{
while(1)
{
mysleep(3);
printf("-0-0-0-0-0-\n");
}
}
总结
竞态条件，跟系统负载有很紧密的关系，体现出信号的不可靠性。系统负载越严重，信号不可靠性越强。
不可靠由其实现原理所致。信号是通过软件方式实现(跟内核调度高度依赖，延时性强)，每次系统调用结束后，或中断处理处理结束后，需通过扫描PCB中的未决信号集，来判断是否应处理某个信号。当系统负载过重时，会出现时序混乱。
这种意外情况只能在编写程序过程中，提早预见，主动规避，而无法通过gdb程序调试等其他手段弥补。且由于该错误不具规律性，后期捕捉和重现十分困难。
33、全局变量异步i/o
分析如下父子进程交替数数程序。当捕捉函数里面的sleep取消，程序即会出现问题。请分析原因。
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <stdlib.h>
int n = 0, flag = 0;
void sys_err(char *str)
{
perror(str);
exit(1);
}
void do_sig_child(int num)
{
printf("I am child %d\t%d\n", getpid(), n);
n += 2;
flag = 1;
sleep(1);
}
void do_sig_parent(int num)
{
printf("I am parent %d\t%d\n", getpid(), n);
n += 2;
flag = 1;
sleep(1);
}
int main(void)
{
pid_t pid;
struct sigaction act;
if ((pid = fork()) < 0)
sys_err("fork");
else if (pid > 0) {
n = 1;
sleep(1);
act.sa_handler = do_sig_parent;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
sigaction(SIGUSR2, &act, NULL); //注册自己的信号捕捉函数 父使用SIGUSR2信号
do_sig_parent(0);
while (1) {
/* wait for signal */;
if (flag == 1) { //父进程数数完成
kill(pid, SIGUSR1);
flag = 0; //标志已经给子进程发送完信号
}
}
} else if (pid == 0) {
n = 2;
act.sa_handler = do_sig_child;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
sigaction(SIGUSR1, &act, NULL);
while (1) {
/* waiting for a signal */;
if (flag == 1) {
kill(getppid(), SIGUSR2);
flag = 0;
}
}
}
return 0;
}
当你不加sleep的时候会出问题
示例中，通过flag变量标记程序实行进度。flag置1表示数数完成。flag置0表示给对方发送信号完成。
问题出现的位置，在父子进程kill函数之后需要紧接着调用 flag，将其置0，标记信号已经发送。但，在这期间很有可能被kernel调度，失去执行权利，而对方获取了执行时间，通过发送信号回调捕捉函数，从而修改了全局的flag。
如何解决该问题呢？可以使用后续课程讲到的“锁”机制。当操作全局变量的时候，通过加锁、解锁来解决该问题。
现阶段，我们在编程期间如若使用全局变量，应在主观上注意全局变量的异步IO可能造成的问题。
34、可/不可重入函数
一个函数在被调用执行期间(尚未调用结束)，由于某种时序又被重复调用，称之为“重入”。根据函数实现的方法可分为“可重入函数”和“不可重入函数”两种。看如下时序。
看 word文档
显然，insert函数是不可重入函数，重入调用，会导致意外结果呈现。究其原因，是该函数内部实现使用了全局变量。
注意事项
1.定义可重入函数，函数内不能含有全局变量及static变量，不能使用malloc、free
2.信号捕捉函数应设计为可重入函数
3.信号处理程序可以调用的可重入函数可参阅man 7 signal
4.没有包含在上述列表中的函数大多是不可重入的，其原因为：
a)使用静态数据结构
b)调用了malloc或free
c)是标准I/O函数
35、捕捉SIGHLD信号
SIGCHLD的产生条件
子进程终止时
子进程接收到SIGSTOP信号停止时
子进程处在停止态，接受到SIGCONT后唤醒时
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <signal.h>
void sys_err(char *str)
{
perror(str);
exit(1);
}
void do_sig_child(int signo)
{
int status; pid_t pid;
while ((pid = waitpid(0, &status, WNOHANG)) > 0) { //不能用if只能用while
if (WIFEXITED(status))
printf("child %d exit %d\n", pid, WEXITSTATUS(status));
else if (WIFSIGNALED(status))
printf("child %d cancel signal %d\n", pid, WTERMSIG(status));
}
}
int main(void)
{
pid_t pid; int i;
for (i = 0; i < 10; i++) {
if ((pid = fork()) == 0)
break;
else if (pid < 0)
sys_err("fork");
}
if (pid == 0) {
int n = 1;
while (n--) {
printf("child ID %d\n", getpid());
sleep(1);
}
return i+1;
} else if (pid > 0) {
//进行SIGHLD阻塞，防止还没注册完子进程死亡
struct sigaction act;
act.sa_handler = do_sig_child;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
sigaction(SIGCHLD, &act, NULL);
//解除对SIGCJLD的阻塞
while (1) {
printf("Parent ID %d\n", getpid());
sleep(1);
}
}
return 0;
}
vi 加要写的文件 +行号 ，直接跳到要执行的位置
SIGCHLD信号注意问题
1.子进程继承了父进程的信号屏蔽字和信号处理动作，但子进程没有继承未决信号集spending。
2.注意注册信号捕捉函数的位置。
3.应该在fork之前，阻塞SIGCHLD信号。注册完捕捉函数后解除阻塞。
子进程结束status处理方式
pid_t waitpid(pid_t pid, int *status, int options)
options
WNOHANG
没有子进程结束，立即返回
WUNTRACED
如果子进程由于被停止产生的SIGCHLD，waitpid则立即返回
WCONTINUED
如果子进程由于被SIGCONT唤醒而产生的SIGCHLD，waitpid则立即返回
获取status
WIFEXITED(status)
子进程正常exit终止，返回真
WEXITSTATUS(status)返回子进程正常退出值
WIFSIGNALED(status)
子进程被信号终止，返回真
WTERMSIG(status)返回终止子进程的信号值
WIFSTOPPED(status)
子进程被停止，返回真
WSTOPSIG(status)返回停止子进程的信号值
WIFCONTINUED(status)
36、信号传参：
发送信号传参
sigqueue函数对应kill函数，但可在向指定进程发送信号的同时携带参数
int sigqueue(pid_t pid, int sig, const union sigval value);成功：0；失败：-1，设置errno
union sigval {
int sival_int;
void *sival_ptr;
};
向指定进程发送指定信号的同时，携带数据。但，如传地址，需注意，不同进程之间虚拟地址空间各自独立，将当前进程地址传递给另一进程没有实际意义。
捕捉函数传参
int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
struct sigaction {
void (*sa_handler)(int);
void (*sa_sigaction)(int, siginfo_t *, void *);
sigset_t sa_mask;
int sa_flags;
void (*sa_restorer)(void);
};
当注册信号捕捉函数，希望获取更多信号相关信息，不应使用sa_handler而应该使用sa_sigaction。但此时的sa_flags必须指定为SA_SIGINFO。siginfo_t是一个成员十分丰富的结构体类型，可以携带各种与信号相关的数据。
37、中断系统调用
中断系统调用
系统调用可分为两类：慢速系统调用和其他系统调用。
1.慢速系统调用：可能会使进程永远阻塞的一类。如果在阻塞期间收到一个信号，该系统调用就被中断,不再继续执行(早期)；也可以设定系统调用是否重启。如，read、write、pause、wait…
2.其他系统调用：getpid、getppid、fork…
慢速系统调用被信号打断的这种情况就是中断系统调用
结合pause，回顾慢速系统调用：
慢速系统调用被中断的相关行为，实际上就是pause的行为： 如，read
① 想中断pause，信号不能被屏蔽。
② 信号的处理方式必须是捕捉 (默认、忽略都不可以)
③ 中断后返回-1， 设置errno为EINTR(表“被信号中断”)
sa_flags在sigaction的参数中:
可修改sa_flags参数来设置被信号中断后系统调用是否重启。SA_INTERRURT不重启。 SA_RESTART重启。
扩展了解：
sa_flags还有很多可选参数，适用于不同情况。如：捕捉到信号后，在执行捕捉函数期间，不希望自动阻塞该信号，可将sa_flags设置为SA_NODEFER，除非sa_mask中包含该信号。
37、终端 所有输入输出设备统称为终端
linux中的终端是虚拟终端
终端：
在UNIX系统中，用户通过终端登录系统后得到一个Shell进程，这个终端成为Shell进程的控制终端（Controlling Terminal），进程中，控制终端是保存在PCB中的信息，而fork会复制PCB中的信息，因此由Shell进程启动的其它进程的控制终端也是这个终端。默认情况下（没有重定向），每个进程的标准输入、标准输出和标准错误输出都指向控制终端，进程从标准输入读也就是读用户的键盘输入，进程往标准输出或标准错误输出写也就是输出到显示器上。信号中还讲过，在控制终端输入一些特殊的控制键可以给前台进程发信号，例如Ctrl-C表示SIGINT，Ctrl-\表示SIGQUIT。
Alt + Ctrl + F1、F2、F3、F4、F5、F6 字符终端 pts (pseudo terminal slave) 指伪终端。
Alt + F7 图形终端
SSH、Telnet… 网络终端
终端的启动流程：
文件与I/O中讲过，每个进程都可以通过一个特殊的设备文件/dev/tty访问它的控制终端。事实上每个终端设备都对应一个不同的设备文件，/dev/tty提供了一个通用的接口，一个进程要访问它的控制终端既可以通过/dev/tty也可以通过该终端设备所对应的设备文件来访问。ttyname函数可以由文件描述符查出对应的文件名，该文件描述符必须指向一个终端设备而不能是任意文件。
简单来说，一个Linux系统启动，大致经历如下的步骤：
init(第一个进程) --> fork --> exec --> getty(启动终端) --> 用户输入帐号 --> login --> 输入密码 --> exec --> bash
硬件驱动程序负责读写实际的硬件设备，比如从键盘读入字符和把字符输出到显示器，线路规程像一个过滤器，对于某些特殊字符并不是让它直接通过，而是做特殊处理，比如在键盘上按下Ctrl-z，对应的字符并不会被用户程序的read读到，而是被线路规程截获，解释成SIGTSTP信号发给前台进程，通常会使该进程停止。线路规程应该过滤哪些字符和做哪些特殊处理是可以配置的。
终端设备模块
line disciline: 线路规程，用来过滤键盘输入的内容。
tyname函数
由文件描述符查出对应的文件名
char *ttyname(int fd); 成功：终端名；失败：NULL，设置errno
下面我们借助ttyname函数，通过实验看一下各种不同的终端所对应的设备文件名。
#include <unistd.h>
#include <stdio.h>
int main(void)
{
printf(“fd 0: %s\n”, ttyname(0));
printf(“fd 1: %s\n”, ttyname(1));
printf(“fd 2: %s\n”, ttyname(2));
return 0;
}
38进程组
概念和特性
进程组，也称之为作业。BSD于1980年前后向Unix中增加的一个新特性。代表一个或多个进程的集合。每个进程都属于一个进程组。在waitpid函数和kill函数的参数中都曾使用到。操作系统设计的进程组的概念，是为了简化对多个进程的管理。
当父进程，创建子进程的时候，默认子进程与父进程属于同一进程组。进程组ID第一个进程ID(组长进程)。所以，组长进程标识：其进程组ID其进程ID
可以使用kill -SIGKILL -进程组ID(负的)来将整个进程组内的进程全部杀死。
组长进程可以创建一个进程组，创建该进程组中的进程，然后终止。只要进程组中有一个进程存在，进程组就存在，与组长进程是否终止无关。
进程组生存期：进程组创建到最后一个进程离开(终止或转移到另一个进程组)。
一个进程可以为自己或子进程设置进程组ID
进程组操作函数
getpgrp函数
获取当前进程的进程组ID
pid_t getpgrp(void); 总是返回调用者的进程组ID
getpgid函数
获取指定进程的进程组ID
pid_t getpgid(pid_t pid); 成功：0；失败：-1，设置errno
如果pid = 0，那么该函数作用和getpgrp一样。
练习：查看进程对应的进程组ID
setpgid函数 可以给自己设
改变进程默认所属的进程组。通常可用来加入一个现有的进程组或创建一个新进程组。
int setpgid(pid_t pid, pid_t pgid); 成功：0；失败：-1，设置errno
将参1对应的进程，加入参2对应的进程组中。
注意：
- 如改变子进程为新的组，应fork后，exec前。
- 权级问题。非root进程只能改变自己创建的子进程，或有权限操作的进程
练习：修改子进程的进程组ID
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(void)
{
pid_t pid;
if ((pid = fork()) < 0) {
perror("fork");
exit(1);
} else if (pid == 0) {
printf("child PID == %d\n",getpid());
printf("child Group ID == %d\n",getpgid(0)); // 返回组id
//printf("child Group ID == %d\n",getpgrp()); // 返回组id
sleep(7);
printf("----Group ID of child is changed to %d\n",getpgid(0));
exit(0);
} else if (pid > 0) {
sleep(1);
setpgid(pid,pid); //让子进程自立门户,成为进程组组长,以它的pid为进程组id
sleep(13);
printf("\n");
printf("parent PID == %d\n", getpid());
printf("parent's parent process PID == %d\n", getppid());
printf("parent Group ID == %d\n", getpgid(0));
sleep(5);
setpgid(getpid(),getppid()); // 改变父进程的组id为父进程的父进程
printf("\n----Group ID of parent is changed to %d\n",getpgid(0));
while(1);
}
return 0;
}
39、创建会话:进程组的集合
创建一个会话需要注意以下6点注意事项：
1.调用进程不能是进程组组长，该进程变成新会话首进程(session header)
2.该进程成为一个新进程组的组长进程。
3.需有root权限(ubuntu不需要)
4.新会话丢弃原有的控制终端，该会话没有控制终端
5.该调用进程是组长进程，则出错返回
6.建立新会话时，先调用fork, 父进程终止，子进程调用setsid
getsid函数
获取进程所属的会话ID
pid_t getsid(pid_t pid); 成功：返回调用进程的会话ID；失败：-1，设置errno
pid为0表示察看当前进程session ID
ps ajx命令查看系统中的进程。参数a表示不仅列当前用户的进程，也列出所有其他用户的进程，参数x表示不仅列有控制终端的进程，也列出所有无控制终端的进程，参数j表示列出与作业控制相关的信息。
组长进程不能成为新会话首进程，新会话首进程必定会成为组长进程。
setsid函数
创建一个会话，并以自己的ID设置进程组ID，同时也是新会话的ID。
pid_t setsid(void); 成功：返回调用进程的会话ID；失败：-1，设置errno
调用了setsid函数的进程，既是新的会长，也是新的组长。
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(void)
{
pid_t pid;
if ((pid = fork())<0) {
perror("fork");
exit(1);
} else if (pid == 0) {
printf("child process PID is %d\n", getpid());
printf("Group ID of child is %d\n", getpgid(0));
printf("Session ID of child is %d\n", getsid(0));
sleep(10);
setsid(); //子进程非组长进程，故其成为新会话首进程，且成为组长进程。该进程组id即为会话进程
printf("Changed:\n");
printf("child process PID is %d\n", getpid());
printf("Group ID of child is %d\n", getpgid(0));
printf("Session ID of child is %d\n", getsid(0));
sleep(20);
exit(0);
}
return 0;
}
40守护进程：
什么是守护进程：
Daemon(精灵)进程，是Linux中的后台服务进程，通常独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。一般采用以d结尾的名字。
Linux后台的一些系统服务进程，没有控制终端，不能直接和用户交互。不受用户登录、注销的影响，一直在运行着，他们都是守护进程。如：预读入缓输出机制的实现；ftp服务器；nfs服务器等。
创建守护进程，最关键的一步是调用setsid函数创建一个新的Session，并成为Session Leader。
创建守护进程模型
1.创建子进程，父进程退出
所有工作在子进程中进行形式上脱离了控制终端
2.在子进程中创建新会话
setsid()函数
使子进程完全独立出来，脱离控制
3.改变当前目录为根目录
chdir()函数
防止占用可卸载的文件系统
也可以换成其它路径
4.重设文件权限掩码
umask()函数
防止继承的文件创建屏蔽字拒绝某些权限
增加守护进程灵活性
5.关闭文件描述符
继承的打开文件不会用到，浪费系统资源，无法卸载
6.开始执行守护进程核心工作
7 kill加进程号就可以杀死守护进程
守护进程退出处理程序模型
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
void daemonize(void)
{
pid_t pid;
/*
* * 成为一个新会话的首进程，失去控制终端
* */
if ((pid = fork()) < 0) {
perror("fork");
exit(1);
} else if (pid != 0) /* parent */
exit(0);
setsid();
/*
* * 改变当前工作目录到/目录下.
* */
if (chdir("/") < 0) {
perror("chdir");
exit(1);
}
/* 设置umask为0 */
umask(0);
/*
* * 重定向0，1，2文件描述符到 /dev/null，因为已经失去控制终端，再操作0，1，2没有意义.
* */
close(0); close(STDIN_FILENO)
open("/dev/null", O_RDWR); open("dev/null",O_RDWR)
dup2(0, 1); dup2(0,STDOUT_FIENO)
dup2(0, 2); dup2(0,STDERR_FILENO)
}
int main(void)
{
daemonize();
while(1); /* 在此循环中可以实现守护进程的核心工作 */
}
vi .bashrc 可以将程序更改成开关机也不关的守护进程
41、线程基本概念
什么是线程：Linux中线程是依托于进程才实现的。Linux使用线程和进程区别不大
LWP：light weight process 轻量级的进程，本质仍是进程(在Linux环境下)
进程：独立地址空间，拥有PCB
线程：也有PCB，但没有独立的地址空间(共享) 与调用线程的进程共享进程地址空间
区别：在于是否共享地址空间。 独居(进程)；合租(线程)。
Linux下： 线程：最小的执行单位
进程：最小分配资源单位，可看成是只有一个线程的进程。
线程内核实现原理：
1. 轻量级进程(light-weight process)，也有PCB，创建线程使用的底层函数 和进程一样，都是clone。
2. 从内核里看进程和线程是一样的，都有各自不同的PCB，但是PCB中指向内存资源的三级页表是相同的。
3. 进程可以蜕变成线程。
4. 线程可看做寄存器和栈的集合。
5. 三级页表（映射）：
一个进程，进程里虚拟地址空间有个元素，是一个指针，指针指向一个页目录，页目录也有一个页表，页表里有一个指针指向一个物理页面,物理页面里面是内存单元，借助mmu实现物理和虚拟地址的转化
哪怕进程变为线程，线程和进程的三级页表是相同的
6、线程在执行的过程当中，执行的主要依据事函数调用：
每个函数消耗的地址空间放在哪 在栈上面。
7、栈有两个指针，ebp，esp(两个寄存器，每个只有一个)，一开始开两个 重合，要分配的时候分开，形成的叫栈帧，每个函数有自己的栈帧空间。每次创建空间，都是用这两个寄存器。
栈帧 存放局部变量，临时值。
8、内核区也有一片栈空间，叫内核栈，主要保留寄存器的值，当进程在切换的时候保存寄存器的值，所以线程也要有自己的线内核栈空间。
9、查看lwp号，LinuxCPU划分时间轮片给线程的依据，如何查看线程的依 据ps -Lf PID可以查看进程下面有哪些进程。
LWP线程号 用线程ID来区分那个线程。
10、对于进程来说，相同的地址(同一个虚拟地址)在不同的进程中，反复使用而不冲突。原因是他们虽虚拟址一样，但，页目录、页表、物理页面各不相同。相同的虚拟址，映射到不同的物理页面内存单元，最终访问不同的物理页面。
但！线程不同！两个线程具有各自独立的PCB，但共享同一个页目录，也就共享同一个页表和物理页面。所以两个PCB共享一个地址空间。
实际上，无论是创建进程的fork，还是创建线程的pthread_create，底层实现都是调用同一个内核函数clone。
如果复制对方的地址空间，那么就产出一个“进程”；如果共享对方的地址空间，就产生一个“线程”。
因此：Linux内核是不区分进程和线程的。只在用户层面上进行区分。所以，线程所有操作函数 pthread_* 是库函数，而非系统调用。
42、线程优缺点和共享资源
线程共享资源
1.文件描述符表
2.每种信号的处理方式 尽量不要把信号和线程联系起来
3.当前工作目录
4.用户ID和组ID
5.内存地址空间 (.text/.data/.bss/heap/共享库)
线程非共享资源
1.线程id
2.处理器现场和栈指针(内核栈)
3.独立的栈空间(用户空间栈)
4.errno变量
5.信号屏蔽字
6.调度优先级
线程优、缺点
优点： 1. 提高程序并发性 2. 开销小 3. 数据通信、共享数据方便 可以使用全局变量
缺点： 1. 库函数，不稳定 2. 调试、编写困难、gdb不支持 3. 对信号支持不好
优点相对突出，缺点均不是硬伤。Linux下由于实现方法导致进程、线程差别不是很大。
43、创建线程
pthread_self函数
获取线程ID。其作用对应进程中 getpid() 函数。
pthread_t pthread_self(void); 返回值：成功：0； 失败：无！
线程ID：pthread_t类型，本质：在Linux下为无符号整数(%lu)，其他系统中可能是结构体实现
线程ID是进程内部，识别标志。(两个进程间，线程ID允许相同)
注意：不应使用全局变量 pthread_t tid，在子线程中通过pthread_create传出参数来获取线程ID，而应使用pthread_self。
pthread_t typedef unsigned long int pthread_t; 永远不会失败 编译线程时 需要 gcc -lpthread。
pthread_create创建一个线程
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
传出线程ID
线程属性，NULL
函数指针，指向线程主函数(线程体)，该函数运行结束，则线程结束。
线程主函数执行期间所使用的参数
成功返回0，失败直接返回errornumber
在一个线程中调用pthread_create()创建新的线程后，当前线程从pthread_create()返回继续往下执行，而新的线程所执行的代码由我们传给pthread_create的函数指针start_routine决定。start_routine函数接收一个参数，是通过pthread_create的arg参数传递给它的，该参数的类型为void *，这个指针按什么类型解释由调用者自己定义。start_routine的返回值类型也是void *，这个指针的含义同样由调用者自己定义。start_routine返回时，这个线程就退出了，其它线程可以调用pthread_join得到start_routine的返回值，类似于父进程调用wait(2)得到子进程的退出状态，稍后详细介绍pthread_join。
pthread_create成功返回后，新创建的线程的id被填写到thread参数所指向的内存单元。我们知道进程id的类型是pid_t，每个进程的id在整个系统中是唯一的，调用getpid(2)可以获得当前进程的id，是一个正整数值。线程id的类型是thread_t，它只在当前进程中保证是唯一的，在不同的系统中thread_t这个类型有不同的实现，它可能是一个整数值，也可能是一个结构体，也可能是一个地址，所以不能简单地当成整数用printf打印，调用pthread_self(3)可以获得当前线程的id。
attr参数表示线程属性，本节不深入讨论线程属性，所有代码例子都传NULL给attr参数。
创建线程实例：
#include<stdio.h>
#include<pthread.h>
#include<stdlib.h>
#include<unistd.h>
void *thread_func(void *arg)
{
printf("In thread id = %lu,pid =%u\n",pthread_self(),getpid());
return NULL;
}
int main()
{
pthread_t tid;
int ret;
printf("In main1 id = %lu,pid = %u\n",pthread_self(),getpid());
ret = pthread_create(&tid,NULL,thread_func,NULL);
if(ret != 0)
{
fprintf(stderr,"error is %s\n",strerror(ret));//stderr标准错误
printf("pthread_create error\n");
exit(1);
}
printf("In man2 id = %lu,pid = %u\n",pthread_self(),getpid());
sleep(1);
return 0;
}
sleep很重要，不加的话，不会显示线程函数的东西
char *strerror(int errnum) 对应string.h
fprintf int fprintf(FILE *stream, const char *format, ...);
07)循环创建多个线程
子线程不会创建子线程
#include<stdio.h>
#include<pthread.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
void *thread_func(void *arg)
{
int i = (int)arg;
sleep(i);
printf("%d thread id = %lu,pid =%u\n",i,pthread_self(),getpid());
return NULL;
}
int main()
{
pthread_t tid;
int ret;
int i;
for(i = 0;i<5;i++)
{
ret = pthread_create(&tid,NULL,thread_func,(void *)i);
if(ret != 0)
{
fprintf(stderr,"error is %s\n",strerror(ret));
printf("pthread_create error\n");
exit(1);
}
}
sleep(i);
return 0;
}
将pthread_create函数参4修改为(void *)&i, 将线程主函数内改为 i=*((int *)arg) 是否可以?
不可以。这样传递是地址传递，在++的过程中，主控线程来不及输出，不一定输出哪个
64位操作系统 void * 八字节，int4位，低向高转，补0，从高位补，高向低转截断，从高位截，截的全是0，所以不影响
44、线程共享全局变量
进程之间不共享，自己写程序设计
45、线程退出
pthread_exit函数
将单个线程退出
void pthread_exit(void *retval); 参数：retval表示线程退出状态，通常传NULL
将第一个代码
sleep(1);
return 0;
换成：pthread_exit(NULL); 也能打印
他退出的是主控线程，那必须等所有线程执行完毕才退出
换成这个的时候：将pthread_create函数参4修改为(void )&i, 将线程主函数内改为 i=((int *)arg)，会输出6个，但也不对
线程读i的一刹那，i是啥取回来就是啥，所以还不对
不要用这个方法
思考：使用exit将指定线程退出，可以吗？ 【pthrd_exit.c】
结论：线程中，禁止使用exit函数，会导致进程内所有线程全部退出。
在不添加sleep控制输出顺序的情况下。pthread_create在循环中，几乎瞬间创建5个线程，但只有第1个线程有机会输出（或者第2个也有，也可能没有，取决于内核调度）如果第3个线程执行了exit，将整个进程退出了，所以全部线程退出了。
所以，多线程环境中，应尽量少用，或者不使用exit函数，取而代之使用pthread_exit函数，将单个线程退出。任何线程里exit导致进程退出，其他线程未工作结束，主控线程退出时不能return或exit。
另注意，pthread_exit或者return返回的指针所指向的内存单元必须是全局的或者是用malloc分配的，不能在线程函数的栈上分配，因为当其它线程得到这个返回指针时线程函数已经退出了。
【练习】：编写多线程程序，总结exit、return、pthread_exit各自退出效果。
return：返回到调用者那里去。
pthread_exit()：将调用该函数的线程退出
exit: 将进程退出。
46、pthread_join、阻塞等待线程退出，获取线程推出状态
pthread_join(pthread_t thread,void **retval)
参数：thread：线程ID（注意：不是指针）；retval：存储线程结束状态
waitpid(pid,&status),进程结束返回的是一个整形，所以接收进程结束返回状态是一个int *
而pthread_exit返回的是一个void *类型，所以接收返回类型就是一个void **类型
#include<stdio.h>
#include<pthread.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
typedef struct
{
char ch;
int var;
char str[64];
}exit_t;
void *thread_func(void *arg)
{
exit_t *retvar = (exit_t *)malloc(sizeof(exit_t));
retvar->ch = 'm';
retvar->var = 200;
strcpy(retvar->str,"my thread\n");
pthread_exit((void *)retvar);
}
int main()
{
pthread_t tid;
int ret;
exit_t *retval;
int i;
for(i = 0;i<5;i++)
{
ret = pthread_create(&tid,NULL,thread_func,(void *)i);
if(ret != 0)
{
fprintf(stderr,"error is %s\n",strerror(ret));
exit(1);
}
}
pthread_join(tid,(void **)&retval);
printf("ch = %c,var = %d,str = %s\n",retval->ch,retval->var,retval->str);
}
12)循环回收
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
int var = 100;
void *tfn(void *arg)
{
int i;
i = (int)arg;
sleep(i);
if (i == 1) {
var = 333;
printf("var = %d\n", var);
return (void *)var;
} else if (i == 3) {
var = 777;
printf("I'm %dth pthread, pthread_id = %lu\n var = %d\n", i+1, pthread_self(), var);
pthread_exit((void *)var);
} else {
printf("I'm %dth pthread, pthread_id = %lu\n var = %d\n", i+1, pthread_self(), var);
pthread_exit((void *)var);
}
return NULL;
}
int main(void)
{
pthread_t tid[5];
int i;
int *ret[5];
for (i = 0; i < 5; i++)
pthread_create(&tid[i], NULL, tfn, (void *)i);
for (i = 0; i < 5; i++) {
pthread_join(tid[i], (void **)&ret[i]);
printf("-------%d 's ret = %d\n", i, (int)ret[i]);
}
printf("I'm main pthread tid = %lu\t var = %d\n", pthread_self(), var);
sleep(i);
return 0;
}
兄弟之间也可以回收，回收的参数也可以不指定。
46、线程分离
int pthread_detach(pthread_t thread); 成功：0；失败：错误号
线程分离状态：指定该状态，线程主动与主控线程断开关系。线程结束后，其退出状态不由其他线程获取，而直接自己自动释放。网络、多线程服务器常用。
进程若有该机制，将不会产生僵尸进程。僵尸进程的产生主要由于进程死后，大部分资源被释放，一点残留资源仍存于系统中，导致内核认为该进程仍存在。
也可使用 pthread_create函数参2(线程属性)来设置线程分离。
使用pthread_detach函数实现线程分离
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>
void *tfn(void *arg)
{
int n = 3;
while (n--) {
printf("thread count %d\n", n);
sleep(1);
}
//return (void *)1;
pthread_exit((void *)1);
}
int main(void)
{
pthread_t tid;
void *tret;
int err;
#if 1
pthread_attr_t attr; /*通过线程属性来设置游离态*/
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
pthread_create(&tid, &attr, tfn, NULL);
#else
pthread_create(&tid, NULL, tfn, NULL);
pthread_detach(tid); //让线程分离 ----自动退出,无系统残留资源
#endif
while (1) {
err = pthread_join(tid, &tret);
printf("-------------err= %d\n", err);
if (err != 0)
fprintf(stderr, "thread_join error: %s\n", strerror(err));
else
fprintf(stderr, "thread exit code %d\n", (int)tret);
sleep(1);
}
return 0;
}
一般情况下，线程终止后，其终止状态一直保留到其它线程调用pthread_join获取它的状态为止。但是线程也可以被置为detach状态，这样的线程一旦终止就立刻回收它占用的所有资源，而不保留终止状态。不能对一个已经处于detach状态的线程调用pthread_join，这样的调用将返回EINVAL错误。也就是说，如果已经对一个线程调用了pthread_detach就不能再调用pthread_join了。
47、杀死进程
pthread_cancel函数
杀死(取消)线程 其作用，对应进程中 kill() 函数。
int pthread_cancel(pthread_t thread); 成功：0；失败：错误号
【注意】：线程的取消并不是实时的，而有一定的延时。需要等待线程到达某个取消点(检查点)。
类似于玩游戏存档，必须到达指定的场所(存档点，如：客栈、仓库、城里等)才能存储进度。杀死线程也不是立刻就能完成，必须要到达取消点。
取消点：是线程检查是否被取消，并按请求进行动作的一个位置。通常是一些系统调用creat，open，pause，close，read，write… 执行命令man 7 pthreads可以查看具备这些取消点的系统调用列表。也可参阅 APUE.12.7 取消选项小节。
可粗略认为一个系统调用(进入内核)即为一个取消点。如线程中没有取消点，可以通过调用pthreestcancel函数自行设置一个取消点。
被取消的线程， 退出值定义在Linux的pthread库中。常数PTHREAD_CANCELED的值是-1。可在头文件pthread.h中找到它的定义：#define PTHREAD_CANCELED ((void *) -1)。因此当我们对一个已经被取消的线程使用pthread_join回收时，得到的返回值为-1。
终止线程方式
总结：终止某个线程而不终止整个进程，有三种方法：
1.从线程主函数return。这种方法对主控线程不适用，从main函数return相当于调用exit。
2.一个线程可以调用pthread_cancel终止同一进程中的另一个线程。
线程可以调用pthread_exit终止自己
pthread_equal函数
比较两个线程ID是否相等。
int pthread_equal(pthread_t t1, pthread_t t2);
有可能Linux在未来线程ID pthread_t 类型被修改为结构体实现。
48、控制原语对比
控制原语对比
进程 线程
fork pthread_create
exit pthread_exit
wait pthread_join
kill pthread_cancel
getpid pthread_self 命名空间
49、设置属性、线程属性
本节作为指引性介绍，linux下线程的属性是可以根据实际项目需要，进行设置，之前我们讨论的线程都是采用线程的默认属性，默认属性已经可以解决绝大多数开发时遇到的问题。如我们对程序的性能提出更高的要求那么需要设置线程属性，比如可以通过设置线程栈的大小来降低内存的使用，增加最大线程个数。
typedef struct
{
int etachstate; //线程的分离状态
int schedpolicy; //线程调度策略
struct sched_param schedparam; //线程的调度参数
int inheritsched; //线程的继承性
int scope; //线程的作用域
size_t guardsize; //线程栈末尾的警戒缓冲区大小
int stackaddr_set; //线程的栈设置
void* stackaddr; //线程栈的位置
size_t stacksize; //线程栈的大小
} pthread_attr_t;
主要结构体成员：
1. 线程分离状态
2. 线程栈大小（默认平均分配）
3. 线程栈警戒缓冲区大小（位于栈末尾） 参 APUE.12.3 线程属性
属性值不能直接设置，须使用相关函数进行操作，初始化的函数为pthread_attr_init，这个函数必须在pthread_create函数之前调用。之后须用pthread_attr_destroy函数来释放资源。
线程属性主要包括如下属性：作用域（scope）、栈尺寸（stack size）、栈地址（stack address）、优先级（priority）、分离的状态（detached state）、调度策略和参数（scheduling policy and parameters）。默认的属性为非绑定、非分离、缺省的堆栈、与父进程同样级别的优先级。
线程属性初始化
注意：应先初始化线程属性，再pthread_create创建线程
初始化线程属性
int pthread_attr_init(pthread_attr_t *attr); 成功：0；失败：错误号
销毁线程属性所占用的资源
int pthread_attr_destroy(pthread_attr_t *attr); 成功：0；失败：错误号
线程的分离状态:
线程的分离状态决定一个线程以什么样的方式来终止自己。
非分离状态：线程的默认属性是非分离状态，这种情况下，原有的线程等待创建的线程结束。只有当pthread_join()函数返回时，创建的线程才算终止，才能释放自己占用的系统资源。
分离状态：分离线程没有被其他的线程所等待，自己运行结束了，线程也就终止了，马上释放系统资源。应该根据自己的需要，选择适当的分离状态。
线程分离状态的函数：
设置线程属性，分离or非分离
int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
获取程属性，分离or非分离
int pthread_attr_getdetachstate(pthread_attr_t *attr, int *detachstate);
参数： attr：已初始化的线程属性
detachstate：
PTHREAD_CREATE_DETACHED（分离线程）
PTHREAD _CREATE_JOINABLE（非分离线程）
这里要注意的一点是，如果设置一个线程为分离线程，而这个线程运行又非常快，它很可能在pthread_create函数返回之前就终止了，它终止以后就可能将线程号和系统资源移交给其他的线程使用，这样调用pthread_create的线程就得到了错误的线程号。要避免这种情况可以采取一定的同步措施，最简单的方法之一是可以在被创建的线程里调用pthread_cond_timedwait函数，让这个线程等待一会儿，留出足够的时间让函数pthread_create返回。设置一段等待时间，是在多线程编程里常用的方法。但是注意不要使用诸如wait()之类的函数，它们是使整个进程睡眠，并不能解决线程同步的问题。
线程的栈地址:
POSIX.1定义了两个常量_POSIX_THREAD_ATTR_STACKADDR 和_POSIX_THREAD_ATTR_STACKSIZE检测系统是否支持栈属性。也可以给sysconf函数传递_SC_THREAD_ATTR_STACKADDR或 _SC_THREAD_ATTR_STACKSIZE来进行检测。
当进程栈地址空间不够用时，指定新建线程使用由malloc分配的空间作为自己的栈空间。通过pthread_attr_setstack和pthread_attr_getstack两个函数分别设置和获取线程的栈地址。
int pthread_attr_setstack(pthread_attr_t *attr, void *stackaddr, size_t stacksize); 成功：0；失败：错误号
int pthread_attr_getstack(pthread_attr_t *attr, void **stackaddr, size_t *stacksize); 成功：0；失败：错误号
参数：
attr：指向一个线程属性的指针
stackaddr：返回获取的栈地址
stacksize：返回获取的栈大小
线程的栈大小:
当系统中有很多线程时，可能需要减小每个线程栈的默认大小，防止进程的地址空间不够用，当线程调用的函数会分配很大的局部变量或者函数调用层次很深时，可能需要增大线程栈的默认大小。
函数pthread_attr_getstacksize和 pthread_attr_setstacksize提供设置。
int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize); 成功：0；失败：错误号
int pthread_attr_getstacksize(pthread_attr_t *attr, size_t *stacksize); 成功：0；失败：错误号
参数：
attr：指向一个线程属性的指针
stacksize：返回线程的堆栈大小
线程属性控制示例
NPTL
1.察看当前pthread库版本getconf GNU_LIBPTHREAD_VERSION
2.NPTL实现机制(POSIX)，Native POSIX Thread Library
3.使用线程库时gcc指定 –lpthread
#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#define SIZE 0x10000
void *th_fun(void *arg)
{
while (1)
sleep(1);
}
int main(void)
{
pthread_t tid;
int err, detachstate, i = 1;
pthread_attr_t attr;
size_t stacksize; //typedef size_t unsigned int
void *stackaddr;
pthread_attr_init(&attr);
pthread_attr_getstack(&attr, &stackaddr, &stacksize);
pthread_attr_getdetachstate(&attr, &detachstate);
if (detachstate == PTHREAD_CREATE_DETACHED) //默认是分离态
printf("thread detached\n");
else if (detachstate == PTHREAD_CREATE_JOINABLE) //默认时非分离
printf("thread join\n");
else
printf("thread un known\n");
/* 设置线程分离属性 */
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
while (1) {
/* 在堆上申请内存,指定线程栈的起始地址和大小 */
stackaddr = malloc(SIZE);
if (stackaddr == NULL) {
perror("malloc");
exit(1);
}
stacksize = SIZE;
pthread_attr_setstack(&attr, stackaddr, stacksize); //借助线程的属性,修改线程栈空间大小
err = pthread_create(&tid, &attr, th_fun, NULL);
if (err != 0) {
printf("%s\n", strerror(err));
exit(1);
}
printf("%d\n", i++);
}
pthread_attr_destroy(&attr);
return 0;
}
50、注意事项
线程使用注意事项
1.主线程退出其他线程不退出，主线程应调用pthread_exit
2.避免僵尸线程
pthread_join
pthread_detach
pthread_create指定分离属性
被join线程可能在join函数返回前就释放完自己的所有内存资源，所以不应当返回被回收线程栈中的值;
3.malloc和mmap申请的内存可以被其他线程释放
4.应避免在多线程模型中调用fork除非，马上exec，子进程中只有调用fork的线程存在，其他线程在子进程中均pthread_exit
5.信号的复杂语义很难和多线程共存，应避免在多线程引入信号机制
51、线程同步
同步概念：
同步即协同步调，按预定的先后次序运行。
线程同步，指一个线程发出某一功能调用时，在没有得到结果之前，该调用不返回。同时其它线程为保证数据一致性，不能调用该功能。
举例1： 银行存款 5000。柜台，折：取3000；提款机，卡：取 3000。剩余：2000
举例2： 内存中100字节，线程T1欲填入全1， 线程T2欲填入全0。但如果T1执行了50个字节失去cpu，T2执行，会将T1写过的内容覆盖。当T1再次获得cpu继续 从失去cpu的位置向后写入1，当执行结束，内存中的100字节，既不是全1，也不是全0。
产生的现象叫做“与时间有关的错误”(time related)。为了避免这种数据混乱，线程需要同步。
“同步”的目的，是为了避免数据混乱，解决与时间有关的错误。实际上，不仅线程间需要同步，进程间、信号间等等都需要同步机制。
因此，所有“多个控制流，共同操作一个共享资源”的情况，都需要同步。
数据混乱原因：
1. 资源共享（独享资源则不会）
2. 调度随机（意味着数据访问会出现竞争）
3. 线程间缺乏必要的同步机制。
以上3点中，前两点不能改变，欲提高效率，传递数据，资源必须共享。只要共享资源，就一定会出现竞争。只要存在竞争关系，数据就很容易出现混乱。
所以只能从第三点着手解决。使多个线程在访问共享资源的时候，出现互斥。
52、互斥量函数mutex
初始化完成取值1，加锁成功0，解锁成功变为1
互斥量mutex
Linux中提供一把互斥锁mutex（也称之为互斥量）。
每个线程在对资源操作前都尝试先加锁，成功加锁才能操作，操作结束解锁。
资源还是共享的，线程间也还是竞争的，
但通过“锁”就将资源的访问变成互斥操作，而后与时间有关的错误也不会再产生了。
但，应注意：同一时刻，只能有一个线程持有该锁。
当A线程对某个全局变量加锁访问，B在访问前尝试加锁，拿不到锁，B阻塞。C线程不去加锁，而直接访问该全局变量，依然能够访问，但会出现数据混乱。
所以，互斥锁实质上是操作系统提供的一把“建议锁”（又称“协同锁”），建议程序中有多线程访问共享资源的时候使用该机制。但，并没有强制限定。
因此，即使有了mutex，如果有线程不按规则来访问数据，依然会造成数据混乱。
主要应用函数：
pthread_mutex_init函数
pthread_mutex_destroy函数
pthread_mutex_lock函数
pthread_mutex_trylock函数 不阻塞，如果返回失败直接返回
pthread_mutex_unlock函数
以上5个函数的返回值都是：成功返回0， 失败返回错误号。
pthread_mutex_t 类型，其本质是一个结构体。为简化理解，应用时可忽略其实现细节，简单当成整数看待。
pthread_mutex_t mutex; 变量mutex只有两种取值1、0。
pthread_mutex_init函数
初始化一个互斥锁(互斥量) —> 初值可看作1
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
参1：传出参数，调用时应传 &mutex
restrict关键字：只用于限制指针，告诉编译器，所有修改该指针指向内存中内容的操作，只能通过本指针完成。不能通过除本指针以外的其他变量或指针修改
参2：互斥量属性。是一个传入参数，通常传NULL，选用默认属性(线程间共享)。 参APUE.12.4同步属性
1.静态初始化：如果互斥锁 mutex 是静态分配的（定义在全局，或加了static关键字修饰），可以直接使用宏进行初始化。e.g. pthead_mutex_t muetx = PTHREAD_MUTEX_INITIALIZER;
2.动态初始化：局部变量应采用动态初始化。e.g. pthread_mutex_init(&mutex, NULL)
pthread_mutex_destroy函数
销毁一个互斥锁
int pthread_mutex_destroy(pthread_mutex_t *mutex);
pthread_mutex_lock函数
加锁。可理解为将mutex–（或-1）
int pthread_mutex_lock(pthread_mutex_t *mutex);
pthread_mutex_unlock函数
解锁。可理解为将mutex ++（或+1）
int pthread_mutex_unlock(pthread_mutex_t *mutex);
pthread_mutex_trylock函数
尝试加锁
int pthread_mutex_trylock(pthread_mutex_t *mutex);
加锁与解锁
lock与unlock：
lock尝试加锁，如果加锁不成功，线程阻塞，阻塞到持有该互斥量的其他线程解锁为止。
unlock主动解锁函数，同时将阻塞在该锁上的所有线程全部唤醒，至于哪个线程先被唤醒，取决于优先级、调度。默认：先阻塞、先唤醒。
例如：T1 T2 T3 T4 使用一把mutex锁。T1加锁成功，其他线程均阻塞，直至T1解锁。T1解锁后，T2 T3 T4均被唤醒，并自动再次尝试加锁。
可假想mutex锁 init成功初值为1。 lock 功能是将mutex–。 unlock将mutex++
lock与trylock：
lock加锁失败会阻塞，等待锁释放。
trylock加锁失败直接返回错误号（如：EBUSY），不阻塞。
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
pthread_mutex_t mutex;
void *tfn(void *arg)
{
srand(time(NULL));
while (1) {
pthread_mutex_lock(&mutex);
printf("hello ");
sleep(rand() % 3); /*模拟长时间操作共享资源，导致cpu易主，产生与时间有关的错误*/
printf("world\n");
pthread_mutex_ulock(&mutex);
sleep(rand() % 3);
}
return NULL;
}
int main(void)
{
int flag = 5;
pthread_t tid;
srand(time(NULL));
pthread_mutex_init(&mutex,NULL);
pthread_create(&tid, NULL, tfn, NULL);
while (flag--) {
pthread_mutex_lock(&mutex);
printf("HELLO ");
sleep(rand() % 3);
printf("WORLD\n");
pthread_mutex_unlock(&mutex);
sleep(rand() % 3);
}
pthread_join(tid, NULL);
pthread_mutex_destroy(&mutex);
return 0;
}共同操作的共享数据是标准输出
【练习】：修改该程序，使用mutex互斥锁进行同步。
1.定义全局互斥量，初始化init(&m, NULL)互斥量，添加对应的destry
2.两个线程while中，两次printf前后，分别加lock和unlock
3.将unlock挪至第二个sleep后，发现交替现象很难出现。
线程在操作完共享资源后本应该立即解锁，但修改后，线程抱着锁睡眠。睡醒解锁后又立即加锁，这两个库函数本身不会阻塞。
所以在这两行代码之间失去cpu的概率很小。因此，另外一个线程很难得到加锁的机会。
4.main 中加flag = 5 将flg在while中-- 这时，主线程输出5次后试图销毁锁，但子线程未将锁释放，无法完成。因为子线程是死循环
main中加pthread_cancel()将子线程取消。
5、如果不小心将解锁的unlock写成了lock那么将会遇到只会输出一遍父子线程。
结论：
在访问共享资源前加锁，访问结束后立即解锁。锁的“粒度”应越小越好。
53、死锁
死锁
1. 线程试图对同一个互斥量A加锁两次。
2. 线程1拥有A锁，请求获得B锁；线程2拥有B锁，请求获得A锁。用trylock，不阻塞，不成功的话，释放自己占有的锁
3、震荡，哲学家吃饭原理；
54、读写锁
1.读写锁是“写模式加锁”时， 解锁前，所有对该锁加锁的线程都会被阻塞。
2.读写锁是“读模式加锁”时， 如果线程以读模式对其加锁会成功；如果线程以写模式加锁会阻塞。
3.读写锁是“读模式加锁”时， 既有试图以写模式加锁的线程，也有试图以读模式加锁的线程。那么读写锁会阻塞随后的读模式锁请求。优先满足写模式锁。读锁、写锁并行阻塞，写锁优先级高
读写锁也叫共享-独占锁。当读写锁以读模式锁住时，它是以共享模式锁住的；当它以写模式锁住时，它是以独占模式锁住的。写独占、读共享。
读写锁非常适合于对数据结构读的次数远大于写的情况。
主要应用函数：
pthread_rwlock_init函数
pthread_rwlock_destroy函数
pthread_rwlock_rdlock函数
pthread_rwlock_wrlock函数
pthread_rwlock_tryrdlock函数
pthread_rwlock_trywrlock函数
pthread_rwlock_unlock函数
以上7 个函数的返回值都是：成功返回0， 失败直接返回错误号。
pthread_rwlock_t类型 用于定义一个读写锁变量。
pthread_rwlock_t rwlock;
pthread_rwlock_init函数
初始化一把读写锁
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);
参2：attr表读写锁属性，通常使用默认属性，传NULL即可。
pthread_rwlock_destroy函数
销毁一把读写锁
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
pthread_rwlock_rdlock函数
以读方式请求读写锁。（常简称为：请求读锁）
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
pthread_rwlock_wrlock函数
以写方式请求读写锁。（常简称为：请求写锁）
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
pthread_rwlock_unlock函数
解锁
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
pthread_rwlock_tryrdlock函数
非阻塞以读方式请求读写锁（非阻塞请求读锁）
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
pthread_rwlock_trywrlock函数
非阻塞以写方式请求读写锁（非阻塞请求写锁）
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
int counter;
pthread_rwlock_t rwlock;
/* 3个线程不定时写同一全局资源，5个线程不定时读同一全局资源 */
void *th_write(void *arg)
{
int t, i = (int)arg;
while (1) {
pthread_rwlock_wrlock(&rwlock);
t = counter;
usleep(1000);
printf("=======write %d: %lu: counter=%d ++counter=%d\n", i, pthread_self(), t, ++counter);
pthread_rwlock_unlock(&rwlock);
usleep(10000);
}
return NULL;
}
void *th_read(void *arg)
{
int i = (int)arg;
while (1) {
pthread_rwlock_rdlock(&rwlock);
printf("----------------------------read %d: %lu: %d\n", i, pthread_self(), counter);
pthread_rwlock_unlock(&rwlock);
usleep(2000);
}
return NULL;
}
int main(void)
{
int i;
pthread_t tid[8];
pthread_rwlock_init(&rwlock, NULL);
for (i = 0; i < 3; i++)
pthread_create(&tid[i], NULL, th_write, (void *)i);
for (i = 0; i < 5; i++)
pthread_create(&tid[i+3], NULL, th_read, (void *)i);
for (i = 0; i < 8; i++)
pthread_join(tid[i], NULL);
pthread_rwlock_destroy(&rwlock);
return 0;
}
55、条件变量
条件变量本身不是锁！但它也可以造成线程阻塞。通常与互斥锁配合使用。给多线程提供一个会合的场所。
主要应用函数：
pthread_cond_init函数
pthread_cond_destroy函数
pthread_cond_wait函数
pthread_cond_timedwait函数
pthread_cond_signal函数
pthread_cond_broadcast函数
以上6 个函数的返回值都是：成功返回0， 失败直接返回错误号。
pthread_cond_t类型 用于定义条件变量
pthread_cond_t cond;
pthread_cond_init函数
初始化一个条件变量
int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);
参2：attr表条件变量属性，通常为默认值，传NULL即可
也可以使用静态初始化的方法，初始化条件变量：
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_cond_destroy函数
销毁一个条件变量
int pthread_cond_destroy(pthread_cond_t *cond);
pthread_cond_wait函数
阻塞等待一个条件变量
pthread_cond_signal函数
唤醒至少一个阻塞在条件变量上的线程
int pthread_cond_signal(pthread_cond_t *cond);
pthread_cond_broadcast函数
唤醒全部阻塞在条件变量上的线程
int pthread_cond_broadcast(pthread_cond_t *cond);
生产者消费者条件变量模型
线程同步典型的案例即为生产者消费者模型，而借助条件变量来实现这一模型，是比较常见的一种方法。假定有两个线程，一个模拟生产者行为，一个模拟消费者行为。两个线程同时操作一个共享资源（一般称之为汇聚），生产向其中添加产品，消费者从中消费掉产品。
看如下示例，使用条件变量模拟生产者、消费者问题：
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
struct msg {
struct msg *next;
int num;
};
struct msg *head;
pthread_cond_t has_product = PTHREAD_COND_INITIALIZER;//静态初始化，init方式是动态初始化
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
void *consumer(void *p)
{
struct msg *mp;
for (;;) {
pthread_mutex_lock(&lock);
while (head == NULL) { //头指针为空,说明没有节点 可以为if吗，不能，被唤醒的有多个，只会有一个抢到锁，其他的么抢到的应该继续阻塞
pthread_cond_wait(&has_product, &lock);
}
mp = head;
head = mp->next; //模拟消费掉一个产品
pthread_mutex_unlock(&lock);
printf("-Consume ---%d\n", mp->num);
free(mp);
sleep(rand() % 5);
}
}
void *producer(void *p)
{
struct msg *mp;
while (1) {
mp = malloc(sizeof(struct msg));
mp->num = rand() % 1000 + 1; //模拟生产一个产品
printf("-Produce ---%d\n", mp->num);
pthread_mutex_lock(&lock);
mp->next = head;
head = mp;
pthread_mutex_unlock(&lock);
pthread_cond_signal(&has_product); //将等待在该条件变量上的一个线程唤醒
sleep(rand() % 5);
}
}
int main(int argc, char *argv[])
{
pthread_t pid, cid;
srand(time(NULL));
pthread_create(&pid, NULL, producer, NULL);
pthread_create(&cid, NULL, consumer, NULL);
pthread_join(pid, NULL);
pthread_join(cid, NULL);
return 0;
} 【conditionVar_product_consumer.c】
条件变量的优点：
相较于mutex而言，条件变量可以减少竞争。
如直接使用mutex，除了生产者、消费者之间要竞争互斥量以外，消费者之间也需要竞争互斥量，但如果汇聚（链表）中没有数据，消费者之间竞争互斥锁是无意义的。有了条件变量机制以后，只有生产者完成生产，才会引起消费者之间的竞争。提高了程序效率。
gg = G 排版
56、条件变量的优点
较于mutex而言，条件变量可以减少竞争。
如直接使用mutex，除了生产者、消费者之间要竞争互斥量以外，消费者之间也需要竞争互斥量，但如果汇聚（链表）中没有数据，消费者之间竞争互斥锁是无意义的。有了条件变量机制以后，只有生产者完成生产，才会引起消费者之间的竞争。提高了程序效率。
pthread_cond_wait三个参数
int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);
函数作用：
1.阻塞等待条件变量cond（参1）满足
2.释放已掌握的互斥锁（解锁互斥量）相当于pthread_mutex_unlock(&mutex);
1.2.两步为一个原子操作。
3.当被唤醒，pthread_cond_wait函数返回时，解除阻塞并重新申请获取互斥锁pthread_mutex_lock(&mutex);
pthread_cond_timedwait函数
限时等待一个条件变量
int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t restrict mutex, const struct timespec restrict abstime);
参3： 参看man sem_timedwait函数，查看struct timespec结构体。
struct timespec {
time_t tv_sec; / seconds / 秒
long tv_nsec; / nanosecondes/ 纳秒
}
形参abstime：绝对时间。
如：time(NULL)返回的就是绝对时间。而alarm(1)是相对时间，相对当前时间定时1秒钟。
struct timespec t = {1, 0};
pthread_cond_timedwait (&cond, &mutex, &t); 只能定时到 1970年1月1日 00:00:01秒(早已经过去)
正确用法：
time_t cur = time(NULL); 获取当前时间。
struct timespec t; 定义timespec 结构体变量t
t.tv_sec = cur+1; 定时1秒
pthread_cond_timedwait (&cond, &mutex, &t); 传参 参APUE.11.6线程同步条件变量小节
在讲解setitimer函数时我们还提到另外一种时间类型：
struct timeval {
time_t tv_sec; /* seconds / 秒
suseconds_t tv_usec; / microseconds */ 微秒
};
57、 信号量
信号量
进化版的互斥锁（1 --> N）
由于互斥锁的粒度比较大，如果我们希望在多个线程间对某一对象的部分数据进行共享，使用互斥锁是没有办法实现的，只能将整个数据对象锁住。这样虽然达到了多线程操作共享数据时保证数据正确性的目的，却无形中导致线程的并发性下降。线程从并行执行，变成了串行执行。与直接使用单进程无异。
信号量，是相对折中的一种处理方式，既能保证同步，数据不混乱，又能提高线程并发。
主要应用函数：
sem_init函数
sem_destroy函数
sem_wait函数
sem_trywait函数
sem_timedwait函数
sem_post函数
以上6 个函数的返回值都是：成功返回0， 失败返回-1，同时设置errno。(注意，它们没有pthread前缀)
sem_t类型，本质仍是结构体。但应用期间可简单看作为整数，忽略实现细节（类似于使用文件描述符）。
sem_t sem; 规定信号量sem不能 < 0。头文件 <semaphore.h>
信号量基本操作：
sem_wait: 1. 信号量大于0，则信号量-- （类比pthread_mutex_lock）
| 2. 信号量等于0，造成线程阻塞
对应
|
sem_post： 将信号量++，同时唤醒阻塞在信号量上的线程 （类比pthread_mutex_unlock）
但，由于sem_t的实现对用户隐藏，所以所谓的++、–操作只能通过函数来实现，而不能直接++、–符号。
信号量的初值，决定了占用信号量的线程的个数。
em_init函数
初始化一个信号量
int sem_init(sem_t *sem, int pshared, unsigned int value);
参1：sem信号量
参2：pshared取0用于线程间；取非0（一般为1）用于进程间
参3：value指定信号量初值
sem_destroy函数
销毁一个信号量
int sem_destroy(sem_t *sem);
sem_wait函数
给信号量加锁 –
int sem_wait(sem_t *sem);
sem_post函数
给信号量解锁 ++
int sem_post(sem_t *sem);
sem_trywait函数
尝试对信号量加锁 – (与sem_wait的区别类比lock和trylock)
int sem_trywait(sem_t *sem);
sem_timedwait函数
限时尝试对信号量加锁 –
int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);
参2：abs_timeout采用的是绝对时间。
定时1秒：
time_t cur = time(NULL); 获取当前时间。
struct timespec t; 定义timespec 结构体变量t
t.tv_sec = cur+1; 定时1秒
t.tv_nsec = t.tv_sec +100;
sem_timedwait(&sem, &t); 传参
生产者消费者信号量模型
【练习】：使用信号量完成线程间同步，模拟生产者，消费者问题。 【sem_product_consumer.c】
分析：
规定： 如果□中有数据，生产者不能生产，只能阻塞。
如果□中没有数据，消费者不能消费，只能等待数据。
定义两个信号量：S满 = 0， S空 = 1 （S满代表满格的信号量，S空表示空格的信号量，程序起始，格子一定为空）
所以有： T生产者主函数 { T消费者主函数 {
sem_wait(S空); sem_wait(S满);
生产… 消费…
sem_post(S满); sem_post(S空);
} }
假设： 线程到达的顺序是:T生、T生、T消。
那么： T生1 到达，将S空-1，生产，将S满+1
T生2 到达，S空已经为0， 阻塞
T消 到达，将S满-1，消费，将S空+1
三个线程到达的顺序是：T生1、T生2、T消。而执行的顺序是T生1、T消、T生2
这里，S空 表示空格子的总数，代表可占用信号量的线程总数–>1。其实这样的话，信号量就等同于互斥锁。
但，如果S空=2、3、4……就不一样了，该信号量同时可以由多个线程占用，不再是互斥的形式。因此我们说信号量是互斥锁的加强版。
/信号量实现 生产者 消费者问题/
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <stdio.h>
#include <semaphore.h>
#define NUM 5
int queue[NUM]; //全局数组实现环形队列
sem_t blank_number, product_number; //空格子信号量, 产品信号量
void *producer(void *arg)
{
int i = 0;
while (1) {
sem_wait(&blank_number); //生产者将空格子数--,为0则阻塞等待
queue[i] = rand() % 1000 + 1; //生产一个产品
printf("----Produce---%d\n", queue[i]);
sem_post(&product_number); //将产品数++
i = (i+1) % NUM; //借助下标实现环形
sleep(rand()%3);
}
}
void *consumer(void *arg)
{
int i = 0;
while (1) {
sem_wait(&product_number); //消费者将产品数--,为0则阻塞等待
printf("-Consume---%d\n", queue[i]);
queue[i] = 0; //消费一个产品
sem_post(&blank_number); //消费掉以后,将空格子数++
i = (i+1) % NUM;
sleep(rand()%3);
}
}
int main(int argc, char *argv[])
{
pthread_t pid, cid;
sem_init(&blank_number, 0, NUM); //初始化空格子信号量为5
sem_init(&product_number, 0, 0); //产品数为0
pthread_create(&pid, NULL, producer, NULL);
pthread_create(&cid, NULL, consumer, NULL);
pthread_join(pid, NULL);
pthread_join(cid, NULL);
sem_destroy(&blank_number);
sem_destroy(&product_number);
return 0;
}
【推演练习】： 理解上述模型，推演，如果是两个消费者，一个生产者，是怎么样的情况。
【作业】：结合生产者消费者信号量模型，揣摩sem_timedwait函数作用。编程实现，一个线程读用户输入， 另一个线程打印“hello world”。如果用户无输入，则每隔5秒向屏幕打印一个“hello world”；如果用户有输入，立刻打印“hello world”到屏幕。
58、进程间同步
信号量和互斥量都可以
互斥量mutex
进程间也可以使用互斥锁，来达到同步的目的。但应在pthread_mutex_init初始化之前，修改其属性为进程间共享。mutex的属性修改函数主要有以下几个。
主要应用函数：
pthread_mutexattr_t mattr 类型： 用于定义mutex锁的【属性】
pthread_mutexattr_init函数： 初始化一个mutex属性对象
int pthread_mutexattr_init(pthread_mutexattr_t *attr);
pthread_mutexattr_destroy函数： 销毁mutex属性对象 (而非销毁锁)
int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);
pthread_mutexattr_setpshared函数： 修改mutex属性。
int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int pshared);
参2：pshared取值：
线程锁：PTHREAD_PROCESS_PRIVATE (mutex的默认属性即为线程锁，进程间私有)
进程锁：PTHREAD_PROCESS_SHARED
进程间mutex示例
进程间使用mutex来实现同步：
#include <fcntl.h>
#include <pthread.h>
#include <sys/mman.h>
#include <sys/wait.h>
struct mt {
int num;
pthread_mutex_t mutex;
pthread_mutexattr_t mutexattr;
};
int main(void)
{
int fd, i;
struct mt *mm;
pid_t pid;
fd = open("mt_test", O_CREAT | O_RDWR, 0777);
ftruncate(fd, sizeof(*mm));
mm = mmap(NULL, sizeof(*mm), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
close(fd);
unlink("mt_test");
//mm = mmap(NULL, sizeof(*mm), PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANON, -1, 0);
memset(mm, 0, sizeof(*mm));
pthread_mutexattr_init(&mm->mutexattr); //初始化mutex属性对象
pthread_mutexattr_setpshared(&mm->mutexattr, PTHREAD_PROCESS_SHARED); //修改属性为进程间共享
pthread_mutex_init(&mm->mutex, &mm->mutexattr); //初始化一把mutex琐
pid = fork();
if (pid == 0) {
for (i = 0; i < 10; i++) {
pthread_mutex_lock(&mm->mutex);
(mm->num)++;
printf("-child----num++ %d\n", mm->num);
pthread_mutex_unlock(&mm->mutex);
sleep(1);
}
} else if (pid > 0) {
for ( i = 0; i < 10; i++) {
sleep(1);
pthread_mutex_lock(&mm->mutex);
mm->num += 2;
printf("-parent---num+=2 %d\n", mm->num);
pthread_mutex_unlock(&mm->mutex);
}
wait(NULL);
}
pthread_mutexattr_destroy(&mm->mutexattr); //销毁mutex属性对象
pthread_mutex_destroy(&mm->mutex); //销毁mutex
munmap(mm,sizeof(*mm)); //释放映射区
return 0;
}
59、文件锁
fcntl 修改一个已经打开文件的属性
可以修改阻塞非阻塞
用F_GETFl和F_SETFL获取和设置文件标记，文件标记包含可读可写等，是否创建等等
都保存在文件的位图中，每一位代表一个属性
想要更改一个属性
int flag = fcnt1();
flag |= O_BLOCK
fcntl(fd,SETFL,flag)
借助 fcntl函数来实现锁机制。 操作文件的进程没有获得锁时，可以打开，但无法执行read、write操作。
fcntl函数： 获取、设置文件访问控制属性。
int fcntl(int fd, int cmd, … /* arg */ );
参2：
F_SETLK (struct flock *) 设置文件锁（trylock）
F_SETLKW (struct flock *) 设置文件锁（lock）W --> wait
F_GETLK (struct flock *) 获取文件锁
参3：
struct flock {
…
short l_type; 锁的类型：F_RDLCK 、F_WRLCK 、F_UNLCK
short l_whence; 偏移位置：SEEK_SET、SEEK_CUR、SEEK_END
off_t l_start; 起始偏移：1000
off_t l_len; 长度：0表示整个文件加锁
pid_t l_pid; 持有该锁的进程ID：(F_GETLK only)
…
}；
进程间文件锁示例
多个进程对加锁文件进行访问：
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
void sys_err(char *str)
{
perror(str); exit(1);
}
int main(int argc, char *argv[])
{
int fd;
struct flock f_lock;
if (argc < 2) {
printf("./a.out filename\n"); exit(1);
}
if ((fd = open(argv[1], O_RDWR)) < 0)
sys_err("open");
//f_lock.l_type = F_WRLCK; /*选用写琐*/
f_lock.l_type = F_RDLCK; /*选用读琐*/
f_lock.l_whence = SEEK_SET;
f_lock.l_start = 0;
f_lock.l_len = 0; /* 0表示整个文件加锁 */
fcntl(fd, F_SETLKW, &f_lock);
printf("get flock\n");
sleep(10);
f_lock.l_type = F_UNLCK;
fcntl(fd, F_SETLKW, &f_lock);
printf("un flock\n");
close(fd); return 0;
} 【file_lock.c】
依然遵循“读共享、写独占”特性。但！如若进程不加锁直接操作文件，依然可访问成功，但数据势必会出现混乱。
【思考】：多线程中，可以使用文件锁吗？
多线程间共享文件描述符，而给文件加锁，是通过修改文件描述符所指向的文件结构体中的成员变量来实现的。因此，多线程中无法使用文件锁。
读写锁应用在线程间，文件锁应用在进程间。
60、哲学家用餐模型分析
多线程版：
选用互斥锁mutex，如创建5个， pthread_mutex_t m[5];
模型抽象：
5个哲学家 --> 5个线程； 5支筷子 --> 5把互斥锁 int left(左手)， right(右手)
5个哲学家使用相同的逻辑，可通用一个线程主函数，void *tfn(void *arg)，使用参数来表示线程编号：int i = (int)arg;
哲学家线程根据编号知道自己是第几个哲学家，而后选定锁，锁住，吃饭。否则哲学家thinking。
A B C D E
5支筷子，在逻辑上形成环： 0 1 2 3 4 分别对应5个哲学家：
所以有：
if(i == 4)
left = i, right = 0;
else
left = i, right = i+1;
振荡：如果每个人都攥着自己左手的锁，尝试去拿右手锁，拿不到则将锁释放。过会儿五个人又同时再攥着左手锁尝试拿右手锁，依然拿不到。如此往复形成另外一种极端死锁的现象——振荡。
避免振荡现象：只需5个人中，任意一个人，拿锁的方向与其他人相逆即可(如：E，原来：左：4，右：0 现在：左：0， 右：4)。
所以以上if else语句应改为：
if(i == 4)
left = 0, right = i;
else
left = i, right = i+1;
而后， 首先应让哲学家尝试加左手锁：
while {
pthread_mutex_lock(&m[left]); 如果加锁成功，函数返回再加右手锁，
如果失败，应立即释放左手锁，等待。
若，左右手都加锁成功 --> 吃 --> 吃完 --> 释放锁（应先释放右手、再释放左手，是加锁顺序的逆序）
}
主线程(main)中，初始化5把锁，销毁5把锁，创建5个线程（并将i传递给线程主函数），回收5个线程。
避免死锁的方法：
1. 当得不到所有所需资源时，放弃已经获得的资源，等待。
2. 保证资源的获取顺序，要求每个线程获取资源的顺序一致。如：A获取顺序1、2、3；B顺序应也是1、2、3。若B为3、2、1则易出现死锁现象。
多进程版
相较于多线程需注意问题：
需注意如何共享信号量 (注意：坚决不能使用全局变量 sem_t s[5])
实现：
main函数中：
循环 sem_init(&s[i], 0, 1); 将信号量初值设为1，信号量变为互斥锁。
循环 sem_destroy(&s[i]);
循环 创建 5 个子进程。 if(i < 5) 中完成子进程的代码逻辑。
循环 回收 5 个子进程。
子进程中：
if(i == 4)
left = 0, right == 4;
else
left = i, right = i+1;
while (1) {
使用 sem_wait(&s[left]) 锁左手，尝试锁右手，若成功 --> 吃； 若不成功 --> 将左手锁释放。
吃完后， 先释放右手锁，再释放左手锁。
}
【重点注意】：
直接将sem_t s[5]放在全局位置，试图用于子进程间共享是错误的！应将其定义放置与mmap共享映射区中。main中：
sem_t *s = mmap(NULL, sizeof(sem_t) * 5, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANON， -1， 0);
使用方式：将s当成数组首地址看待，与使用数组s[5]没有差异。
383
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
