第二章 Linux 多进程开发
- 2.6 进程间通信
- 2.6.1 匿名管道
- 2.6.2 有名管道
- 2.6.3 内存映射
- 2.6.4 信号
- 2.6.5 共享内存
- 2.7 守护进程
网络编程系列文章：
第1章 Linux系统编程入门（上）
第1章 Linux系统编程入门（下）
第2章 Linux多进程开发（上）
第2章 Linux多进程开发（下）
第3章 Linux多线程开发
第4章 Linux网络编程
- 4.1 网络基础
- 4.2 socket 通信基础
- 4.3 TCP套接字通信
- 4.4 IO多路复用
- 4.5 UDP 通信
第5章 Web服务器
2.6 进程间通信
（1）进程间通讯概念
- 进程是一个独立的资源分配单元，不同进程（这里所说的进程通常指的是用户进程）之间的资源是独立的，没有关联，不能在一个进程中直接访问另一个进程的资源。
- 但是，进程不是孤立的，不同的进程需要进行信息的交互和状态的传递等，因此需要进程间通信(
IPC：Inter Processes Communication)。 - 进程间通信的目的：
- 数据传输：一个进程需要将它的数据发送给另一个进程。
- 通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。
- 资源共享：多个进程之间共享同样的资源。为了做到这一点，需要内核提供 互斥 和 同步机制。
- 进程控制：有些进程希望完全控制另一个进程的执行（如
Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。
（2）Linux 进程间通信的方式
- 管道的特点 🌟
-
管道其实是一个在 内核内存 中维护的缓冲器，这个缓冲器的存储能力是有限的，不同的操作系统大小不一定相同。
-
管道拥有文件的特质：读操作、写操作，匿名管道没有文件实体，有名管道有文件实体， 但不存储数据。可以按照操作文件的方式对管道进行操作。
-
一个管道是一个字节流，使用管道时 不存在消息或者消息边界 的概念，从管道读取数据的进程可以读取任意大小的数据块，而不管写入进程写入管道的数据块的大小是多少。
-
通过管道传递的数据是顺序的，从管道中读取出来的字节的顺序和它们被写入管道的顺序是完全一样的。
-
在管道中的数据的传递方向是单向的，一端用于写入，一端用于读取，管道是半双工的（例如：对讲机，发送和接收不能同时进行）。
-
从管道读数据是一次性操作，数据一旦被读走，它就从管道中被抛弃，释放空间以便写更多的数据，在管道中无法使用
lseek()来随机的访问数据。 -
**匿名管道 ** 只能在具有公共祖先的进程（父进程与子进程，或者两个兄弟进程，具有 亲缘关系）之间使用。
-
为什么可以使用管道进行进程间通信
-
管道的数据结构
- 环形队列（逻辑实现）
2.6.1 匿名管道
-
管道 也叫 无名（匿名）管道，它是是 UNIX 系统
IPC（进程间通信）的最古老形式， 所有的 UNIX 系统都支持这种通信机制。 (管道 默认就是匿名管道) -
统计一个目录中文件的数目命令：
ls | wc –l，为了执行该命令，shell 创建了两个进程来分别执行ls和wc。（中间的竖线就是管道）
-
匿名管道的使用
-
创建匿名管道
#include <unistd.h> int pipe(int pipefd[2]); /* 功能：创建一个匿名管道，用来进程间通信。 参数：int pipefd[2] 这个数组是一个传出参数。 pipefd[0] 对应的是管道的读端 pipefd[1] 对应的是管道的写端 返回值： 成功 0 失败 -1 管道默认是阻塞的：如果管道中没有数据，read阻塞，如果管道满了，write阻塞 注意：匿名管道只能用于具有关系的进程之间的通信（父子进程，兄弟进程） */// 子进程不断发送数据给父进程，父进程不断读取到数据输出 #include <unistd.h> #include <sys/types.h> #include <stdio.h> #include <stdlib.h> #include <string.h> int main() { // 在fork之前创建管道 int pipefd[2]; int ret = pipe(pipefd); if(ret == -1) { perror("pipe"); exit(0); // 退出进程 } // 创建子进程 pid_t pid = fork(); if(pid > 0) { // 父进程 printf("i am parent process, pid : %d\n", getpid()); // 关闭写端 close(pipefd[1]); // 从管道的读取端读取数据 char buf[1024] = {0}; while(1) { int len = read(pipefd[0], buf, sizeof(buf)); printf("parent recv : %s, pid : %d\n", buf, getpid()); // 向管道中写入数据 //char * str = "hello,i am parent"; //write(pipefd[1], str, strlen(str)); //sleep(1); } } else if(pid == 0){ // 子进程 printf("i am child process, pid : %d\n", getpid()); // 关闭读端 close(pipefd[0]); char buf[1024] = {0}; while(1) { // 向管道中写入数据 char * str = "hello,i am child"; write(pipefd[1], str, strlen(str)); sleep(1); //由于写的很快，暂停一下（便于观察） // int len = read(pipefd[0], buf, sizeof(buf)); // printf("child recv : %s, pid : %d\n", buf, getpid()); // bzero(buf, 1024); } } return 0; } -
查看管道缓冲大小命令
ulimit –a -
查看管道缓冲大小函数
#include <unistd.h> long fpathconf(int fd, int name);#include <unistd.h> #include <sys/types.h> #include <stdio.h> #include <stdlib.h> #include <string.h> int main() { int pipefd[2]; int ret = pipe(pipefd); // 获取管道的大小 long size = fpathconf(pipefd[0], _PC_PIPE_BUF); printf("pipe size : %ld\n", size); return 0; }
-
-
匿名管道的使用
/* 实现 ps aux | grep xxx 父子进程间通信 子进程： ps aux, 子进程结束后，将数据发送给父进程 父进程：获取到数据，过滤 pipe() execlp() 子进程将标准输出 stdout_fileno 重定向到管道的写端。 dup2 */ #include <unistd.h> #include <sys/types.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <wait.h> int main() { // 创建一个管道 int fd[2]; int ret = pipe(fd); if(ret == -1) { perror("pipe"); exit(0); } // 创建子进程 pid_t pid = fork(); if(pid > 0) { // 父进程 // 关闭写端 close(fd[1]); // 从管道中读取 char buf[1024] = {0}; int len = -1; while((len = read(fd[0], buf, sizeof(buf) - 1)) > 0) { // 过滤数据输出 printf("%s", buf); memset(buf, 0, 1024);//清空buf中的内容 } wait(NULL); } else if(pid == 0) { // 子进程 // 关闭读端 close(fd[0]); // 文件描述符的重定向 stdout_fileno -> fd[1] dup2(fd[1], STDOUT_FILENO); // 执行 ps aux execlp("ps", "ps", "aux", NULL); perror("execlp"); exit(0); } else { perror("fork"); exit(0); } return 0; }
管道的读写特点：
使用管道时，需要注意以下几种特殊的情况（假设都是 阻塞 I/O操作）
-
所有的指向管道 写端 的文件描述符都关闭了（管道写端引用计数为
0），有进程从管道的读端读数据，那么管道中剩余的数据被读取以后，再次read会返回0，就像读到文件末尾一样。 -
如果有指向管道 写端 的文件描述符没有关闭（管道的 写端引用计数大于
0），而持有管道写端的进程也没有往管道中写数据，这个时候有进程从管道中读取数据，那么管道中剩余的数据被读取后，再次read会 阻塞，直到管道中有数据可以读了才读取数据并返回。 -
如果所有指向管道 读端 的文件描述符都关闭了（管道的读端引用计数为
0），这个时候有进程向管道中写数据，那么该进程会收到一个信号SIGPIPE(管道破裂信号), 通常会导致进程异常终止。 -
如果有指向管道 读端 的文件描述符没有关闭（管道的读端引用计数大于
0），而持有管道读端的进程也没有从管道中读数据，这时有进程向管道中写数据，那么在管道被写满的时候再次write会 阻塞，直到管道中有空位置才能再次写入数据并返回。
总结：
读管道：
- 管道中有数据，
read返回实际读到的字节数。- 管道中无数据：
- 写端被全部关闭，
read返回0（相当于读到文件的末尾）
- 写端没有完全关闭，read阻塞等待
**写管道**：
- 管道读端全部被关闭，进程异常终止（进程收到 `SIGPIPE` 信号）
- 管道读端没有全部关闭：
- 管道已满，`write` 阻塞
- 管道没有满，`write` 将数据写入，并返回实际写入的字节数
设置管道非阻塞
#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
/*
设置管道非阻塞
int flags = fcntl(fd[0], F_GETFL); // 获取原来的flag
flags |= O_NONBLOCK; // 修改flag的值
fcntl(fd[0], F_SETFL, flags); // 设置新的flag
*/
int main() {
// 在fork之前创建管道
int pipefd[2];
int ret = pipe(pipefd);
if(ret == -1) {
perror("pipe");
exit(0);
}
// 创建子进程
pid_t pid = fork();
if(pid > 0) {
// 父进程
printf("i am parent process, pid : %d\n", getpid());
// 关闭写端
close(pipefd[1]);
// 从管道的读取端读取数据
char buf[1024] = {0};
int flags = fcntl(pipefd[0], F_GETFL); // 获取原来的flag
flags |= O_NONBLOCK; // 修改flag的值
fcntl(pipefd[0], F_SETFL, flags); // 设置新的flag
while(1) {
int len = read(pipefd[0], buf, sizeof(buf));
printf("len : %d\n", len);
printf("parent recv : %s, pid : %d\n", buf, getpid());
memset(buf, 0, 1024); //清空数组
sleep(1);
}
} else if(pid == 0){
// 子进程
printf("i am child process, pid : %d\n", getpid());
// 关闭读端
close(pipefd[0]);
char buf[1024] = {0};
while(1) {
// 向管道中写入数据
char * str = "hello,i am child";
write(pipefd[1], str, strlen(str));
sleep(5);
}
}
return 0;
}
2.6.2 有名管道
-
匿名管道，由于没有名字，只能用于 亲缘关系 的进程间通信。为了克服这个缺点，提出了有名管道（
FIFO），也叫命名管道、FIFO文件。 -
有名管道（FIFO）不同于匿名管道之处在于它提供了一个 路径名 与之关联，以 FIFO 的文件形式存在于文件系统中，并且其打开方式与打开一个普通文件是一样的，这样即使与 FIFO 的创建进程不存在亲缘关系的进程，只要可以访问该路径，就能够彼此 通过 FIFO 相互通信，因此，通过 FIFO 不相关的进程也能交换数据。
-
一旦打开了 FIFO，就能在它上面使用与操作匿名管道和其他文件的系统调用一样的 I/O系统调用了（如
read()、write()和close()）。与管道一样，FIFO 也有一 个 写入端 和 读取端 ，并且从管道中读取数据的顺序与写入的顺序是一样的。FIFO 的 名称也由此而来：先入先出。 -
有名管道（
FIFO) 和 匿名管道（pipe）有一些特点是相同的，不一样的地方在于：- FIFO 在文件系统中作为一个特殊文件存在，但 FIFO 中的内容却存放在 内存 中。
- 当使用 FIFO 的进程退出后，FIFO 文件 将继续保存在文件系统中以便以后使用。
- FIFO 有名字，不相关的进程可以通过打开 有名管道 进行通信。
-
有名管道的使用
-
a. 通过命令创建有名管道
mkfifo 名字
-
b. 通过函数创建有名管道
#include <sys/types.h> #include <sys/stat.h> int mkfifo(const char *pathname, mode_t mode); /* 参数： - pathname: 管道名称的路径 - mode: 文件的权限 和 open 的 mode 是一样的, 是一个八进制的数 返回值：成功返回0，失败返回-1，并设置错误号 */ -
一旦使用
mkfifo创建了一个FIFO，就可以使用open打开它，常见的文件 I/O 函数都可用于fifo。如：close、read、write、unlink等。 -
FIFO 严格遵循先进先出（
First in First out），对管道及 FIFO 的读总是从开始处返回数据，对它们的写则把数据添加到末尾。它们不支持诸如lseek()等文件定位操作。
-
-
例1：
-
新建
write.c文件，向管道内写数据#include <stdio.h> #include <sys/types.h> #include <sys/stat.h> #include <stdlib.h> #include <unistd.h> #include <fcntl.h> #include <string.h> // 向管道中写数据 /* 有名管道的注意事项： 1.一个为只读而打开一个管道的进程会阻塞，直到另外一个进程为只写打开管道 2.一个为只写而打开一个管道的进程会阻塞，直到另外一个进程为只读打开管道 读管道： 管道中有数据，read返回实际读到的字节数 管道中无数据： 管道写端被全部关闭，read返回0，（相当于读到文件末尾） 写端没有全部被关闭，read阻塞等待 写管道： 管道读端被全部关闭，进行异常终止（收到一个SIGPIPE信号） 管道读端没有全部关闭： 管道已经满了，write会阻塞 管道没有满，write将数据写入，并返回实际写入的字节数。 */ int main() { // 1.判断文件是否存在 int ret = access("test", F_OK); if(ret == -1) { printf("管道不存在，创建管道\n"); // 2.创建管道文件 ret = mkfifo("test", 0664); if(ret == -1) { perror("mkfifo"); exit(0); } } // 3.以只写的方式打开管道，得到文件描述符 int fd = open("test", O_WRONLY); if(fd == -1) { perror("open"); exit(0); } // 写数据 for(int i = 0; i < 100; i++) { char buf[1024]; sprintf(buf, "hello, %d\n", i); printf("write data : %s\n", buf); write(fd, buf, strlen(buf)); sleep(1); } close(fd); return 0; } -
新建
read.c文件，从管道内读数据#include <stdio.h> #include <sys/types.h> #include <sys/stat.h> #include <stdlib.h> #include <unistd.h> #include <fcntl.h> // 从管道中读取数据 int main() { // 1.打开管道文件 int fd = open("test", O_RDONLY); if(fd == -1) { perror("open"); exit(0); } // 读数据 while(1) { char buf[1024] = {0}; int len = read(fd, buf, sizeof(buf)); if(len == 0) { printf("写端断开连接了...\n"); break; } printf("recv buf : %s\n", buf); } close(fd); return 0; }
-
-
例2：
-
新建
chatA.c文件#include <stdio.h> #include <unistd.h> #include <sys/types.h> #include <sys/stat.h> #include <stdlib.h> #include <fcntl.h> #include <string.h> int main() { // 1.判断有名管道文件是否存在 int ret = access("fifo1", F_OK); if(ret == -1) { // 文件不存在 printf("管道不存在，创建对应的有名管道\n"); ret = mkfifo("fifo1", 0664); if(ret == -1) { perror("mkfifo"); exit(0); // 正常退出 } } ret = access("fifo2", F_OK); if(ret == -1) { // 文件不存在 printf("管道不存在，创建对应的有名管道\n"); ret = mkfifo("fifo2", 0664); if(ret == -1) { perror("mkfifo"); exit(0); } } // 2.以只写的方式打开管道fifo1 int fdw = open("fifo1", O_WRONLY); //文件描述符 if(fdw == -1) { perror("open"); exit(0); } printf("打开管道fifo1成功，等待写入...\n"); // 3.以只读的方式打开管道fifo2 int fdr = open("fifo2", O_RDONLY); if(fdr == -1) { perror("open"); exit(0); } printf("打开管道fifo2成功，等待读取...\n"); char buf[128]; // 4.循环的写读数据 while(1) { memset(buf, 0, 128); // 获取标准输入的数据 fgets(buf, 128, stdin); // 写数据 ret = write(fdw, buf, strlen(buf)); if(ret == -1) { perror("write"); exit(0); } // 5.读管道数据 memset(buf, 0, 128); ret = read(fdr, buf, 128); if(ret <= 0) { perror("read"); break; } printf("buf: %s\n", buf); } // 6.关闭文件描述符 close(fdr); close(fdw); return 0; } -
新建
chatB.c文件#include <stdio.h> #include <unistd.h> #include <sys/types.h> #include <sys/stat.h> #include <stdlib.h> #include <fcntl.h> #include <string.h> int main() { // 1.判断有名管道文件是否存在 int ret = access("fifo1", F_OK); if(ret == -1) { // 文件不存在 printf("管道不存在，创建对应的有名管道\n"); ret = mkfifo("fifo1", 0664); if(ret == -1) { perror("mkfifo"); exit(0); } } ret = access("fifo2", F_OK); if(ret == -1) { // 文件不存在 printf("管道不存在，创建对应的有名管道\n"); ret = mkfifo("fifo2", 0664); if(ret == -1) { perror("mkfifo"); exit(0); } } // 2.以只读的方式打开管道fifo1 int fdr = open("fifo1", O_RDONLY); if(fdr == -1) { perror("open"); exit(0); } printf("打开管道fifo1成功，等待读取...\n"); // 3.以只写的方式打开管道fifo2 int fdw = open("fifo2", O_WRONLY); if(fdw == -1) { perror("open"); exit(0); } printf("打开管道fifo2成功，等待写入...\n"); char buf[128]; // 4.循环的读写数据 while(1) { // 5.读管道数据 memset(buf, 0, 128); ret = read(fdr, buf, 128); if(ret <= 0) { perror("read"); break; } printf("buf: %s\n", buf); memset(buf, 0, 128); // 获取标准输入的数据 fgets(buf, 128, stdin); // 写数据 ret = write(fdw, buf, strlen(buf)); if(ret == -1) { perror("write"); exit(0); } } // 6.关闭文件描述符 close(fdr); close(fdw); return 0; }
-
2.6.3 内存映射
-
内存映射（
Memory-mapped I/O）是将 磁盘文件的数据 映射到 内存，用户通过 修改内存 就能修改磁盘文件。(效率比较高)
-
内存映射相关系统调用
/* #include <sys/mman.h> void *mmap(void *addr, size_t length, int prot, int flags,int fd, off_t offset); - 功能：将一个文件或者设备的数据映射到内存中 - 参数： - void *addr: NULL, 由内核指定 - length : 要映射的数据的长度，这个值不能为0。建议使用文件的长度。 获取文件的长度：stat / lseek。长度大小为页的整数倍。 - prot : 对申请的内存映射区的操作权限 -PROT_EXEC ：可执行的权限 -PROT_READ ：读权限 -PROT_WRITE ：写权限 -PROT_NONE ：没有权限 要操作映射内存，必须要有读的权限。 PROT_READ、PROT_READ|PROT_WRITE - flags : - MAP_SHARED : 映射区的数据会自动和磁盘文件进行同步，进程间通信，必须要设置这个选项 - MAP_PRIVATE ：不同步，内存映射区的数据改变了，对原来的文件不会修改，会重新创建一个新的文件。（copy on write） - fd: 需要映射的那个文件的文件描述符 - 通过open得到，open的是一个磁盘文件 - 注意：文件的大小不能为0，open指定的权限不能和prot参数有冲突。 prot: PROT_READ open:只读/读写 prot: PROT_READ | PROT_WRITE open:读写 - offset：偏移量，一般不用。必须指定的是4k的整数倍，0表示不偏移。 - 返回值：返回创建的内存的首地址 失败返回MAP_FAILED，(void *) -1 int munmap(void *addr, size_t length); - 功能：释放内存映射 - 参数： - addr : 要释放的内存的首地址 - length : 要释放的内存的大小，要和mmap函数中的length参数的值一样。 */ /* 使用内存映射实现进程间通信： 1.有关系的进程（父子进程） - 还没有子进程的时候 - 通过唯一的父进程，先创建内存映射区 - 有了内存映射区以后，创建子进程 - 父子进程共享创建的内存映射区 2.没有关系的进程间通信 - 准备一个大小不是0的磁盘文件 - 进程1 通过磁盘文件创建内存映射区 - 得到一个操作这块内存的指针 - 进程2 通过磁盘文件创建内存映射区 - 得到一个操作这块内存的指针 - 使用内存映射区通信 注意：内存映射区通信，是非阻塞。 */ #include <stdio.h> #include <sys/mman.h> #include <fcntl.h> #include <sys/types.h> #include <unistd.h> #include <string.h> #include <stdlib.h> #include <wait.h> int main() { // 1.打开一个文件 int fd = open("test.txt", O_RDWR); int size = lseek(fd, 0, SEEK_END); // 获取文件的大小 // 2.创建内存映射区 void *ptr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); if(ptr == MAP_FAILED) { perror("mmap"); exit(0); } // 3.创建子进程 pid_t pid = fork(); if(pid > 0) { wait(NULL);//等待回收子进程 // 父进程 char buf[64]; strcpy(buf, (char *)ptr); printf("read data : %s\n", buf); }else if(pid == 0){ // 子进程 strcpy((char *)ptr, "nihao a, son!!!"); } // 关闭内存映射区 munmap(ptr, size); return 0; }
思考问题
① 如果对
mmap的返回值(ptr) 做++操作(ptr++),munmap是否能够成功?
void * ptr = mmap(...);
ptr++; 可以对其进行++操作munmap(ptr, len);// 错误, 要用首地址，或者提前保存首地址② 如果
open时O_RDONLY,mmap时prot参数指定PROT_READ | PROT_WRITE会怎样?
- 错误，返回
MAP_FAILEDopen()函数中的权限建议和prot参数的权限 保持一致 (prot参数的权限<=open的权限)。③ 如果文件偏移量为1000会怎样?
- 偏移量必须是
4K的整数倍，返回MAP_FAILED④
mmap什么情况下会调用失败?
- 第二个参数：
length = 0- 第三个参数：
prot
- 只指定了 写权限
prot PROT_READ | PROT_WRITE
第5个参数fd通过open函数时指定的O_RDONLY / O_WRONLY⑤ 可以
open的时候O_CREAT一个新文件来创建映射区吗?
- 可以的，但是创建的文件的大小如果为
0的话，肯定不行- 可以对新的文件进行扩展
lseek()truncate()⑥
mmap后关闭文件描述符，对mmap映射有没有影响？int fd = open("XXX"); mmap(,,,,fd,0); close(fd); //映射区还存在，创建映射区的fd被关闭，没有任何影响。⑦ 对
ptr越界操作会怎样？
void * ptr = mmap(NULL, 100, ,,,,);4K- 越界操作操作的是非法的内存 -> 段错误
2.6.4 信号
-
信号的概念
-
信号是 Linux 进程间通信的最古老的方式之一，是事件发生时对进程的通知机制，有时也称之为软件中断，它是在软件层次上对中断机制的一种模拟，是一种 异步通信 的方式。信号可以导致一个正在运行的进程被另一个正在运行的异步进程中断，转而处理某一个突发事件。
-
发往进程的诸多信号，通常都是源于 内核 。引发内核 为进程产生信号的各类事件如下：
- 对于前台进程，用户可以通过输入特殊的终端字符来给它发送信号。比如输入
Ctrl+C通常会给进程发送一个中断信号。 - 硬件发生异常，即硬件检测到一个错误条件并通知 内核，随即再由内核发送相应信号给相关进程。比如执行一条异常的机器语言指令，诸如被
0除，或者引用了无法访问的内存区域。 - 系统状态变化，比如
alarm定时器 到期将引起SIGALRM信号，进程执行的 CPU 时间超限，或者该进程的某个子进程退出。 - 运行
kill命令 或 调用kill函数。
- 对于前台进程，用户可以通过输入特殊的终端字符来给它发送信号。比如输入
-
使用信号的两个主要目的是：
- 让进程知道已经发生了一个特定的事情。
- 强迫进程执行它自己代码中的信号处理程序。
-
信号的特点：
- 简单
- 不能携带大量信息
- 满足某个特定条件才发送
- 优先级比较高
-
查看系统定义的信号列表：
kill -l-
前 31 个信号为常规信号，其余为实时信号。
-
-
-
Linux 信号一览表
- 下面 红色标识 的是一定要掌握的！
- 下面 红色标识 的是一定要掌握的！
-
信号的 5 种默认处理动作
-
查看信号的详细信息：
man 7 signal
-
信号的 5 中默认处理动作
Term终止进程Ign当前进程忽略掉这个信号Core终止进程，并生成一个Core文件 (保存进程异常退出的错误信息)Stop暂停当前进程Cont继续执行当前被暂停的进程
-
信号的几种状态：产生、未决 (未达)、递达
-
SIGKILL和SIGSTOP信号不能被 捕捉、阻塞 或者 忽略，只能执行默认动作。
-
-
信号相关的函数
int kill(pid_t pid, int sig); // 给任何的进程或者进程组pid, 发送任何的信号 sig int raise(int sig); // 给当前进程发送信号 void abort(void); // 发送SIGABRT信号给当前的进程，杀死当前进程 unsigned int alarm(unsigned int seconds); //设置定时器（闹钟），单位：秒 int setitimer(int which, const struct itimerval *new_val, struct itimerval *old_value); //设置定时器（闹钟），单位：微妙 us示例：
-
kill、raise、abort/* #include <sys/types.h> #include <signal.h> int kill(pid_t pid, int sig); - 功能：给任何的进程或者进程组pid, 发送任何的信号 sig - 参数： - pid ： > 0 : 将信号发送给指定的进程 = 0 : 将信号发送给当前的进程组 = -1 : 将信号发送给每一个有权限接收这个信号的进程 < -1 : 这个pid=某个进程组的ID取反 （-12345） - sig : 需要发送的信号的编号或者是宏值，0表示不发送任何信号 kill(getppid(), 9); kill(getpid(), 9); int raise(int sig); - 功能：给当前进程发送信号 - 参数： - sig : 要发送的信号 - 返回值： - 成功 0 - 失败 非0 kill(getpid(), sig); void abort(void); - 功能： 发送SIGABRT信号给当前的进程，杀死当前进程 kill(getpid(), SIGABRT); */ #include <stdio.h> #include <sys/types.h> #include <signal.h> #include <unistd.h> int main() { pid_t pid = fork(); if(pid == 0) { // 子进程 int i = 0; for(i = 0; i < 5; i++) { printf("child process\n"); sleep(1); } } else if(pid > 0) { // 父进程 printf("parent process\n"); sleep(2); printf("kill child process now\n"); kill(pid, SIGINT); } return 0; } -
定时器
alarm/* #include <unistd.h> unsigned int alarm(unsigned int seconds); - 功能：设置定时器（闹钟）。函数调用，开始倒计时，当倒计时为0的时候， 函数会给当前的进程发送一个信号：SIGALRM - 参数： seconds: 倒计时的时长，单位：秒。如果参数为0，定时器无效（不进行倒计时，不发信号）。 取消一个定时器，通过alarm(0)。 - 返回值： - 之前没有定时器，返回0 - 之前有定时器，返回之前的定时器剩余的时间 - SIGALRM ：默认终止当前的进程，每一个进程都有且只有唯一的一个定时器。 alarm(10); -> 返回0 过了1秒 alarm(5); -> 返回9 alarm(100) -> 该函数是不阻塞的 */ #include <stdio.h> #include <unistd.h> int main() { int seconds = alarm(5); printf("seconds = %d\n", seconds); // 0 sleep(2); seconds = alarm(2); // 不阻塞 printf("seconds = %d\n", seconds); // 3 while(1) { } return 0; }1秒钟电脑能数多少个数？#include <stdio.h> #include <unistd.h> int main() { alarm(1); int i = 0; while(1) { printf("%i\n", i++); } return 0; }-
实际的时间 = 内核时间(系统调用) + 用户时间(普通代码执行) + 消耗的时间(I/O等)
-
进行文件 IO操作 的时候比较浪费时间
定时器，与进程的状态无关（自然定时法）。无论进程处于什么状态，
alarm都会计时。 -
-
定时器
setitimer/* #include <sys/time.h> int setitimer(int which, const struct itimerval *new_value, struct itimerval *old_value); - 功能：设置定时器（闹钟）。可以替代alarm函数。精度微妙us，可以实现周期性定时 - 参数： - which : 定时器以什么时间计时 ITIMER_REAL: 真实时间，时间到达，发送 SIGALRM (常用) ITIMER_VIRTUAL: 用户时间，时间到达，发送 SIGVTALRM ITIMER_PROF: 以该进程在用户态和内核态下所消耗的时间来计算，时间到达，发送 SIGPROF - new_value: 设置定时器的属性 struct itimerval { // 定时器的结构体 struct timeval it_interval; // 每个阶段的时间，间隔时间 struct timeval it_value; // 延迟多长时间执行定时器 }; struct timeval { // 时间的结构体 time_t tv_sec; // 秒数 suseconds_t tv_usec; // 微秒 }; 过10秒后，每个2秒定时一次 - old_value ：记录上一次的定时的时间参数，一般不使用，指定NULL - 返回值： 成功 0 失败 -1 并设置错误号 */ #include <sys/time.h> #include <stdio.h> #include <stdlib.h> // 过3秒以后，每隔2秒钟定时一次 int main() { struct itimerval new_value; // 设置间隔的时间 new_value.it_interval.tv_sec = 2; // 秒数 new_value.it_interval.tv_usec = 0; // 微秒 // 设置延迟的时间,3秒之后开始第一次定时 new_value.it_value.tv_sec = 3; new_value.it_value.tv_usec = 0; int ret = setitimer(ITIMER_REAL, &new_value, NULL); // 非阻塞的 printf("定时器开始了...\n"); // 立马会运行该句子 if(ret == -1) { perror("setitimer"); exit(0); } getchar(); //获取键盘录入 return 0; } -
信号捕捉函数/信号处理
//信号捕捉函数 sighandler_t signal(int signum, sighandler_t handler); int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact); // 检查或者改变信号的处理。信号捕捉-
signal示例：/* #include <signal.h> typedef void (*sighandler_t)(int); sighandler_t signal(int signum, sighandler_t handler); - 功能：设置某个信号的捕捉行为 - 参数： - signum: 要捕捉的信号 - handler: 捕捉到信号要如何处理 - SIG_IGN ： 忽略信号 - SIG_DFL ： 使用信号默认的行为 - 回调函数 : 这个函数是内核调用，程序员只负责写，捕捉到信号后如何去处理信号。 回调函数： - 需要程序员实现，提前准备好的，函数的类型根据实际需求，看函数指针的定义 - 不是程序员调用，而是当信号产生，由内核调用 - 函数指针是实现回调的手段，函数实现之后，将函数名放到函数指针的位置就可以了。 - 返回值： 成功，返回上一次注册的信号处理函数（回调函数）的地址。第一次调用返回NULL 失败，返回SIG_ERR，设置错误号 SIGKILL SIGSTOP不能被捕捉，不能被忽略。 */ #include <sys/time.h> #include <stdio.h> #include <stdlib.h> #include <signal.h> void myalarm(int num) { printf("捕捉到了信号的编号是：%d\n", num); printf("xxxxxxx\n"); } // 过3秒以后，每隔2秒钟定时一次 int main() { // 注册信号捕捉 // signal(SIGALRM, SIG_IGN); // signal(SIGALRM, SIG_DFL); // void (*sighandler_t)(int); 函数指针，int类型的参数表示捕捉到的信号的值。 signal(SIGALRM, myalarm); struct itimerval new_value; // 设置间隔的时间 new_value.it_interval.tv_sec = 2; new_value.it_interval.tv_usec = 0; // 设置延迟的时间,3秒之后开始第一次定时 new_value.it_value.tv_sec = 3; new_value.it_value.tv_usec = 0; int ret = setitimer(ITIMER_REAL, &new_value, NULL); // 非阻塞的 printf("定时器开始了...\n"); if(ret == -1) { perror("setitimer"); exit(0); } getchar(); return 0; } -
sigaction示例：/* #include <signal.h> int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact); - 功能：检查或者改变信号的处理。信号捕捉 - 参数： - signum : 需要捕捉的信号的编号或者宏值（信号的名称） - act ：捕捉到信号之后的处理动作 - oldact : 上一次对信号捕捉相关的设置，一般不使用，传递NULL - 返回值： 成功 0 失败 -1 struct sigaction { // 函数指针，指向的函数就是信号捕捉到之后的处理函数 void (*sa_handler)(int); // 不常用 void (*sa_sigaction)(int, siginfo_t *, void *); // 临时阻塞信号集，在信号捕捉函数执行过程中，临时阻塞某些信号。 sigset_t sa_mask; // 使用哪一个信号处理对捕捉到的信号进行处理 // 这个值可以是0，表示使用sa_handler,也可以是SA_SIGINFO表示使用sa_sigaction int sa_flags; // 被废弃掉了 void (*sa_restorer)(void); }; */ #include <sys/time.h> #include <stdio.h> #include <stdlib.h> #include <signal.h> // 回调函数 void myalarm(int num) { printf("捕捉到了信号的编号是：%d\n", num); printf("xxxxxxx\n"); } // 过3秒以后，每隔2秒钟定时一次 int main() { struct sigaction act; act.sa_flags = 0; act.sa_handler = myalarm; sigemptyset(&act.sa_mask); // 清空临时阻塞信号集 // 注册信号捕捉 sigaction(SIGALRM, &act, NULL); struct itimerval new_value; // 设置间隔的时间 new_value.it_interval.tv_sec = 2; new_value.it_interval.tv_usec = 0; // 设置延迟的时间,3秒之后开始第一次定时 new_value.it_value.tv_sec = 3; new_value.it_value.tv_usec = 0; int ret = setitimer(ITIMER_REAL, &new_value, NULL); // 非阻塞的 printf("定时器开始了...\n"); if(ret == -1) { perror("setitimer"); exit(0); } // getchar(); while(1); return 0; }尽量使用
sigaction。
-
-
内核实现信号捕捉的过程
-
信号集
-
许多信号相关的 系统调用 都需要能表示一组不同的信号，多个信号可使用一个称之为信号集的数据结构来表示，其系统数据类型为
sigset_t。 -
在 PCB 中有两个非常重要的信号集。一个称之为 “阻塞信号集 ”（阻塞信号递达），另一个称之为 “ 未决信号集“ 。这两个信号集都是 内核 使用位图机制 来实现的。但操作系统不允许我们直接对这两个信号集进行位操作。而需自定义另外一个集合，借助信号集操作函数来对 PCB 中的这两个信号集进行修改。
- 信号的 “未决" 是一种状态，指的是从信号的产生到信号被处理前的这一段时间。
- 信号的 “阻塞 " 是一个开关动作，指的是 阻止信号被处理，但不是阻止信号产生。
- 信号的 阻塞 就是让系统暂时保留信号留待以后发送。由于另外有办法让系统忽略信号，所以一般情况下信号的阻塞只是暂时的，只是为了防止信号打断敏感的操作。
未决信号机 和 阻塞信号集
-
用户通过键盘
Ctrl + C, 产生2号信号SIGINT(信号被创建) -
信号产生但是没有被处理 （未决）
-
在内核中将所有的没有被处理的信号存储在一个集合中 （未决信号集）
-
SIGINT信号状态被存储在第二个标志位上- 这个标志位的值为
0， 说明信号不是未决状态 - 标志位的值为
1， 说明信号处于未决状态
- 这个标志位的值为
-
-
这个未决状态的信号，需要被处理，处理之前需要和另一个信号集（阻塞信号集），进行比较
-
阻塞信号集默认不阻塞任何的信号
-
如果想要阻塞某些信号需要用户 调用 系统的API
-
-
在处理的时候和阻塞信号集中的标志位进行查询，看是不是对该信号设置阻塞了
-
如果没有阻塞，这个信号就被处理
-
如果阻塞了，这个信号就继续处于未决状态，直到 阻塞解除，这个信号就被处理
-
-
-
信号集相关的函数
//自定义的信号集的操作 int sigemptyset(sigset_t *set); // 清空信号集中的数据 int sigfillset(sigset_t *set); // 将信号集中的所有的标志位置为 1 int sigaddset(sigset_t *set, int signum); // 设置信号集中的某一个信号对应的标志位为 1 int sigdelset(sigset_t *set, int signum); // 设置信号集中的某一个信号对应的标志位为 0 int sigismember(const sigset_t *set, int signum); // 判断某个信号是否阻塞 // 内核信号集操作 int sigprocmask(int how, const sigset_t *set, sigset_t *oldset); //将自定义信号集中的数据设置到内核中（设置阻塞，解除阻塞，替换） int sigpending(sigset_t *set); // 获取内核中的未决信号集-
示例：
-
对 自定义的信号集 进行操作
/* 以下信号集相关的函数都是对自定义的信号集进行操作。 int sigemptyset(sigset_t *set); - 功能：清空信号集中的数据,将信号集中的所有的标志位置为0 - 参数：set,传出参数，需要操作的信号集 - 返回值：成功返回0， 失败返回-1 int sigfillset(sigset_t *set); - 功能：将信号集中的所有的标志位置为 1 - 参数：set,传出参数，需要操作的信号集 - 返回值：成功返回0， 失败返回-1 int sigaddset(sigset_t *set, int signum); - 功能：设置信号集中的某一个信号对应的标志位为 1，表示阻塞这个信号 - 参数： - set：传出参数，需要操作的信号集 - signum：需要设置阻塞的那个信号 - 返回值：成功返回0， 失败返回-1 int sigdelset(sigset_t *set, int signum); - 功能：设置信号集中的某一个信号对应的标志位为0，表示不阻塞这个信号 - 参数： - set：传出参数，需要操作的信号集 - signum：需要设置不阻塞的那个信号 - 返回值：成功返回0， 失败返回-1 int sigismember(const sigset_t *set, int signum); - 功能：判断某个信号是否阻塞 - 参数： - set：需要操作的信号集 - signum：需要判断的那个信号 - 返回值： 1 ： signum被阻塞 0 ： signum不阻塞 -1 ： 失败 */ #include <signal.h> #include <stdio.h> #include <bits/types/sigset_t.h> int main() { // 创建一个信号集 sigset_t set; // 清空信号集的内容 sigemptyset(&set); // 判断 SIGINT 是否在信号集 set 里 int ret = sigismember(&set, SIGINT); if(ret == 0) { printf("SIGINT 不阻塞\n"); } else if(ret == 1) { printf("SIGINT 阻塞\n"); } // 添加几个信号到信号集中 sigaddset(&set, SIGINT); sigaddset(&set, SIGQUIT); // 判断SIGINT是否在信号集中 ret = sigismember(&set, SIGINT); if(ret == 0) { printf("SIGINT 不阻塞\n"); } else if(ret == 1) { printf("SIGINT 阻塞\n"); } // 判断SIGQUIT是否在信号集中 ret = sigismember(&set, SIGQUIT); if(ret == 0) { printf("SIGQUIT 不阻塞\n"); } else if(ret == 1) { printf("SIGQUIT 阻塞\n"); } // 从信号集中删除一个信号 sigdelset(&set, SIGQUIT); // 判断SIGQUIT是否在信号集中 ret = sigismember(&set, SIGQUIT); if(ret == 0) { printf("SIGQUIT 不阻塞\n"); } else if(ret == 1) { printf("SIGQUIT 阻塞\n"); } return 0; } -
调用 系统的API ，对系统 内核信号集 操作
/* int sigprocmask(int how, const sigset_t *set, sigset_t *oldset); - 功能：将自定义信号集中的数据设置到内核中（设置阻塞，解除阻塞，替换） - 参数： - how : 如何对内核阻塞信号集进行处理 SIG_BLOCK: 将用户设置的阻塞信号集添加到内核中，内核中原来的数据不变 假设内核中默认的阻塞信号集是mask， mask | set SIG_UNBLOCK: 根据用户设置的数据，对内核中的数据进行解除阻塞 mask &= ~set SIG_SETMASK:覆盖内核中原来的值 - set ：已经初始化好的用户自定义的信号集 - oldset : 保存设置之前的内核中的阻塞信号集的状态，可以是 NULL - 返回值： 成功：0 失败：-1 设置错误号：EFAULT、EINVAL int sigpending(sigset_t *set); - 功能：获取内核中的未决信号集 - 参数：set,传出参数，保存的是内核中的未决信号集中的信息。 */ // 编写一个程序，把所有的常规信号（1-31）的未决状态打印到屏幕 // 设置某些信号是阻塞的，通过键盘产生这些信号 #include <stdio.h> #include <signal.h> #include <stdlib.h> #include <unistd.h> #include <bits/types/sigset_t.h> int main() { // 设置2、3号信号阻塞 sigset_t set; sigemptyset(&set); // 将2号和3号信号添加到信号集中 sigaddset(&set, SIGINT); sigaddset(&set, SIGQUIT); // 修改内核中的阻塞信号集 sigprocmask(SIG_BLOCK, &set, NULL); int num = 0; while(1) { num++; // 获取当前的未决信号集的数据 sigset_t pendingset; sigemptyset(&pendingset); sigpending(&pendingset); // 遍历前32位 for(int i = 1; i <= 31; i++) { if(sigismember(&pendingset, i) == 1) { printf("1"); }else if(sigismember(&pendingset, i) == 0) { printf("0"); }else { perror("sigismember"); exit(0); } } printf("\n"); sleep(1); if(num == 10) { // 解除阻塞 sigprocmask(SIG_UNBLOCK, &set, NULL); } } return 0; }
-
-
-
SIGCHLD信号-
SIGCHLD信号产生的条件- 子进程终止时
- 子进程接收到
SIGSTOP信号停止时 - 子进程处在停止态，接受到
SIGCONT后唤醒时
-
以上三种条件都会给父进程发送
SIGCHLD信号，父进程 默认会忽略该信号/* SIGCHLD信号产生的3个条件： 1.子进程结束 2.子进程暂停了 3.子进程继续运行 都会给父进程发送该信号，父进程默认忽略该信号。 使用SIGCHLD信号解决僵尸进程的问题。 */ #include <stdio.h> #include <unistd.h> #include <sys/types.h> #include <sys/stat.h> #include <signal.h> #include <sys/wait.h> void myFun(int num) { printf("捕捉到的信号 ：%d\n", num); // 回收子进程PCB的资源 // while(1) { // wait(NULL); // } while(1) { int ret = waitpid(-1, NULL, WNOHANG); // 一次只能回收一个子进程资源 if(ret > 0) { printf("child die , pid = %d\n", ret); } else if(ret == 0) { // 说明还有子进程或者 break; } else if(ret == -1) { // 没有子进程 break; } } } int main() { // 提前设置好阻塞信号集，阻塞SIGCHLD，因为有可能子进程很快结束，父进程还没有注册完信号捕捉 sigset_t set; sigemptyset(&set); sigaddset(&set, SIGCHLD); sigprocmask(SIG_BLOCK, &set, NULL); // 创建一些子进程 pid_t pid; for(int i = 0; i < 20; i++) { pid = fork(); if(pid == 0) { break; } } if(pid > 0) { // 父进程 // 捕捉子进程死亡时发送的SIGCHLD信号 struct sigaction act; act.sa_flags = 0; act.sa_handler = myFun; sigemptyset(&act.sa_mask); sigaction(SIGCHLD, &act, NULL); // 注册完信号捕捉以后，解除阻塞 sigprocmask(SIG_UNBLOCK, &set, NULL); while(1) { printf("parent process pid : %d\n", getpid()); sleep(2); } } else if( pid == 0) { // 子进程 printf("child process pid : %d\n", getpid()); } return 0; }
-
2.6.5 共享内存
-
共享内存允许两个或者多个进程共享 物理内存的同一块区域（通常被称为 段）。由于一个 共享内存段会称为一个进程 用户空间 的一部分，因此这种 IPC 机制 无需内核介入。所有需要做的就是让一个进程将数据复制进共享内存中，并且这部分数据会对其他所有共享同一个段的进程可用。
-
与 管道 等要求 发送进程 将数据从 用户空间的缓冲区 复制进 内核内存 和 接收进程 将数据从 内核内存 复制进 用户空间的缓冲区 的做法相比，这种 IPC 技术的速度更快。
**共享内存 **比 内存映射的效率高，内存映射虽然直接操作内存，但要把数据同步到内存当中，通过文件进行进程间通信。
共享内存 和 **内存映射 **的区别
共享内存 可以直接创建，内存映射 需要 磁盘文件（匿名映射除外）
共享内存效果更高
内存
- 所有的进程操作的是 同一块共享内存。
- 内存映射，每个进程在自己的虚拟地址空间中有一个独立的内存。
数据安全
- 进程突然退出
- 共享内存还存在
- 内存映射区消失
- 运行进程的电脑死机，宕机了
- 数据存在在共享内存中，没有了
- 内存映射区的数据 ，由于磁盘文件中的数据还在，所以内存映射区的数据还存在
生命周期
内存映射区：进程退出，内存映射区销毁
共享内存：进程退出，共享内存还在，标记删除（所有的关联的进程数为
0），或者关机
如果一个进程退出，会自动和共享内存进行取消关联。
-
共享内存使用步骤
-
调用
shmget()创建 一个 新共享内存段 或 取得 一个既有共享内存段的 标识符（即由其他进程创建的共享内存段）。这个调用将返回后续调用中需要用到的 共享内存标识符。 -
使用
shmat()来 附上 共享内存段，即使 该段 ，成为调用进程的 虚拟内存的一部分。 -
此刻在程序中可以像对待其他可用内存那样对待这个共享内存段。为引用这块共享内存，程序需要使用由
shmat()调用返回的addr值，它是一个指向进程的虚拟地址空间中该共享内存段的起点的指针。 -
调用
shmdt()来 分离 共享内存段。在这个调用之后，进程就无法再引用这块共享内存了。这一步是可选的，并且在进程终止时会自动完成这一步。 -
调用
shmctl()来 删除 共享内存段。只有当当前所有附加内存段的进程都与之分离之后内存段才会销毁。只有一个进程需要执行这一步。
-
-
共享内存操作函数
int shmget(key_t key, size_t size, int shmflg); void *shmat(int shmid, const void *shmaddr, int shmflg); int shmdt(const void *shmaddr); int shmctl(int shmid, int cmd, struct shmid_ds *buf); key_t ftok(const char * int proj_id); -
int shmget(key_t key, size_t size, int shmflg);- 功能： 创建 一个新的共享内存段，或者 取得 一个既有的共享内存段的标识。新创建的内存段中的数据都会被初始化为
0 - 参数：
key:key_t类型是一个整形，通过这个找到或者创建一个共享内存。
一般使用16进制表示，非0值size: 共享内存的大小shmflg: 属性- 访问权限
- 附加属性：创建/判断共享内存是不是存在
- 创建：
IPC_CREAT - 判断共享内存是否存在：
IPC_EXCL, 需要和IPC_CREAT一起使用
IPC_CREAT | IPC_EXCL | 0664
- 创建：
- 返回值：
失败：-1并设置错误号
成功：>0返回共享内存的 引用的ID，后面操作共享内存都是通过这个值。
- 功能： 创建 一个新的共享内存段，或者 取得 一个既有的共享内存段的标识。新创建的内存段中的数据都会被初始化为
-
void *shmat(int shmid, const void *shmaddr, int shmflg);- 功能：和当前的进程进行 关联
- 参数：
shmid: 共享内存的标识（ID）,由shmget返回值获取shmaddr: 申请的共享内存的 起始地址，指定NULL，内核指定shmflg: 对共享内存的操作- 读 ：
SHM_RDONLY, 必须要有读权限 - 读写：
0
- 读 ：
- 返回值：
成功：返回共享内存的首（起始）地址。 失败(void *) -1
-
int shmdt(const void *shmaddr);- 功能：解除 当前进程和共享内存的关联
- 参数：
shmaddr：共享内存的首地址 - 返回值：成功
0， 失败-1
-
int shmctl(int shmid, int cmd, struct shmid_ds *buf);- 功能：对共享内存进行操作。删除 共享内存，共享内存要删除才会消失，创建共享内存的进行被销毁了对共享内存是没有任何影响。
- 参数：
shmid: 共享内存的IDcmd: 要做的操作IPC_STAT: 获取 共享内存的当前的状态IPC_SET: 设置 共享内存的状态IPC_RMID: 标记 共享内存 被销毁
buf：需要设置或者获取的共享内存的属性信息IPC_STAT:buf存储数据IPC_SET:buf中需要初始化数据，设置到内核中IPC_RMID: 没有用，NULL
-
key_t ftok(const char *pathname, int proj_id);- 功能：根据指定的路径名，和int值，生成 一个共享内存的
key - 参数：
pathname:指定一个存在的路径
/home/rmzh/Linux/a.txt
/proj_id:int类型的值，但是这系统调用只会使用其中的1个字节 (8位)
范围 ：0-255一般指定一个字符'a'
- 功能：根据指定的路径名，和int值，生成 一个共享内存的
举例：
-
新建
write.c文件#include <stdio.h> #include <sys/ipc.h> #include <sys/shm.h> #include <string.h> int main() { // 1.创建一个共享内存 int shmid = shmget(100, 4096, IPC_CREAT|0664); printf("shmid : %d\n", shmid); // 2.和当前进程进行关联 void * ptr = shmat(shmid, NULL, 0); char * str = "helloworld"; // 3.写数据 memcpy(ptr, str, strlen(str) + 1); printf("按任意键继续\n"); getchar(); // 4.解除关联 shmdt(ptr); // 5.删除共享内存 shmctl(shmid, IPC_RMID, NULL); return 0; } -
新建
read.c文件#include <stdio.h> #include <sys/ipc.h> #include <sys/shm.h> #include <string.h> int main() { // 1.获取一个共享内存 int shmid = shmget(100, 0, IPC_CREAT); printf("shmid : %d\n", shmid); // 2.和当前进程进行关联 void * ptr = shmat(shmid, NULL, 0); // 3.读数据 printf("%s\n", (char *)ptr); printf("按任意键继续\n"); getchar(); // 4.解除关联 shmdt(ptr); // 5.删除共享内存 shmctl(shmid, IPC_RMID, NULL); return 0; }问题1：操作系统如何知道一块共享内存被多少个进程关联？
- 共享内存维护了一个结构体
struct shmid_ds这个结构体中有一个成员shm_nattchshm_nattach记录了关联的进程个数
问题2：可不可以对共享内存进行多次删除
shmctl- 可以的
- 因为
shmctl标记删除 共享内存，不是直接删除 - 什么时候真正删除呢?
- 当和共享内存关联的进程数为
0的时候，就 真正被删除。
- 当和共享内存关联的进程数为
- 当共享内存的
key为0的时候，表示共享内存被 标记删除 了- 如果一个进程和共享内存取消关联，那么这个进程就不能继续操作这个共享内存。也不能进行关联。
- 共享内存维护了一个结构体
-
共享内存操作命令
-
ipcs 用法
ipcs -a// 打印当前系统中 所有 的进程间通信方式的信息ipcs -m// 打印出使用 共享内存 进行进程间通信的信息ipcs -q// 打印出使用 消息队列 进行进程间通信的信息ipcs -s// 打印出使用 **信号 **进行进程间通信的信息
-
ipcrm 用法
ipcrm -M shmkey// 移除用shmkey创建的共享内存段ipcrm -m shmid// 移除用shmid标识的共享内存段ipcrm -Q msgkey// 移除用msqkey创建的消息队列ipcrm -q msqid// 移除用msqid标识的消息队列ipcrm -S semkey// 移除用semkey创建的信号ipcrm -s semid// 移除用semid标识的信号
-
2.7 守护进程
（1）终端
- 在 UNIX 系统中，用户通过 终端 登录系统 后得到一个
shell 进程，这个终端成为 shell 进程的 控制终端（Controlling Terminal），进程中，控制终端 是保存在 PCB 中的信息，而fork()会复制 PCB 中的信息，因此由shell 进程启动的其它进程 的控制终端也是这个终端。 - 默认情况下（没有重定向），每个进程的 标准输入 、 标准输出 和 标准错误 输出都指向 控制终端，进程从标准输入读也就是读用户的键盘输入，进程往标准输出或标准错误输出写也就是输出到显示器上。
- 在控制终端输入一些特殊的控制键可以给前台进程发信号，例如
Ctrl + C会产生SIGINT信号，Ctrl +会产生SIGQUIT信号。
（2）进程组
- 进程组 和 会话 在进程之间形成了一种两级层次关系：进程组 是一组 相关进程的集合，会话 是一组 相关进程组的集合。进程组和会话是为支持
shell作业控制 而定义的抽象概念，用户通过shell能够交互式地在 前台 或 后台 运行命令。 - 进行组 由一个或多个共享同一进程组标识符（
PGID）的进程组成。一个进程组拥有一个 进程组首进程，该进程是创建该组的进程，其进程 ID 为该进程组的 ID ，新进程会继承其父进程所属的进程组 ID 。 - 进程组拥有一个生命周期，其开始时间为 首进程 创建组的时刻，结束时间为最后一个成员进程 退出组的时刻。一个进程可能会因为终止而退出进程组，也可能会因为加入了另外一个进程组而退出进程组。进程组首进程无需是最后一个离开进程组的成员。
（3）会话
- 会话 是 一组进程组 的集合。会话首进程 是创建该新会话的进程，其进程 ID 会成为 会话 ID 。新进程会继承其父进程的会话 ID 。
- 一个会话中的所有进程 共享单个 控制终端。控制终端 会在 会话首进程 首次打开一个终端设备时被建立。一个终端最多可能会成为一个会话的控制终端。
- 在任一时刻，会话 中的其中一个进程组会成为 终端 的 前台进程组，其他进程组会成为 后台进程组。只有前台进程组中的进程才能从 控制终端 中读取输入。当用户在控制终端中输入终端字符生成信号后，该信号会被发送到前台进程组中的所有成员。
- 当 控制终端 的连接建立起来之后，会话首进程 会成为该终端的 控制进程。
（4）进程组、会话、控制终端之间的关系
find / 2 > /dev/null | wc l & # `&` 是后台运行
sort < longlist | uniq c # 前台运行
（5）进程组、会话操作函数
pid_t getpgrp(void); // 获取调用进程的进程组ID。
pid_t getpgid(pid_t pid); // 获取指定进程的进程组ID。
int setpgid(pid_t pid, pid_t pgid); // 设置指定进程的进程组ID
pid_t getsid(pid_t pid); // 获取指定进程所属的会话ID。
pid_t setsid(void); // 创建一个新的会话，并返回新会话的ID。
（6）守护进程
- 守护进程（
Daemon Process），也就是通常说的Daemon 进程（精灵进程），是Linux 中的 后台服务进程。它是一个生存期较长的进程，通常独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。一般采用以d结尾的名字。 - 守护进程具备下列特征：
- 生命周期很长，守护进程会在系统启动的时候被创建并一直运行直至系统被关闭。
- 它在后台运行并且不拥有 控制终端。没有控制终端确保了内核永远不会为守护进程自动生成任何控制信号以及终端相关的信号（如
SIGINT、SIGQUIT）。
- Linux 的大多数服务器就是用守护进程实现的。比如， Internet 服务器
inetd，Web 服务器httpd等。
（7）守护进程的创建步骤
- 执行一个
fork()，之后父进程退出，子进程继续执行。⭐️ - 子进程调用
setsid()开启一个新会话。⭐️ - 清除进程的
umask（掩码）以确保当守护进程创建文件和目录时拥有所需的权限。 - 修改进程的当前工作目录，通常会改为根目录（
/）。 - 关闭守护进程从其父进程继承而来的所有打开着的文件描述符。
- 在关闭了文件描述符
0、1、2之后，守护进程通常会打开/dev/null并使用dup2()使所有这些描述符指向这个设备。 - 核心业务逻辑 ⭐️
/*
写一个守护进程，每隔2s获取一下系统时间，将这个时间写入到磁盘文件中。
*/
#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/time.h>
#include <signal.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>
void work(int num) {
// 捕捉到信号之后，获取系统时间，写入磁盘文件
time_t tm = time(NULL);
struct tm * loc = localtime(&tm);
// char buf[1024];
// sprintf(buf, "%d-%d-%d %d:%d:%d\n",loc->tm_year,loc->tm_mon
// ,loc->tm_mday, loc->tm_hour, loc->tm_min, loc->tm_sec);
// printf("%s\n", buf);
// 写入磁盘文件
char * str = asctime(loc);
int fd = open("time.txt", O_RDWR | O_CREAT | O_APPEND, 0664);
write(fd ,str, strlen(str));
close(fd);
}
int main() {
// 1.创建子进程，退出父进程
pid_t pid = fork();
if(pid > 0) {
exit(0);
}
// 2.将子进程重新创建一个会话，以脱离原先的控制终端
setsid();
// 3.设置掩码（可有可无）
umask(022);
// 4.更改工作目录（可有可无）
chdir("/home/nowcoder/");
// 5. 关闭、重定向文件描述符
int fd = open("/dev/null", O_RDWR); // null设备会忽略掉所有数据，就不会往终端输出信息
dup2(fd, STDIN_FILENO); // 标准输入
dup2(fd, STDOUT_FILENO); // 标准输出
dup2(fd, STDERR_FILENO); // 标准错误
// 6.业务逻辑，核心处理
// 捕捉定时信号
struct sigaction act;
act.sa_flags = 0;
act.sa_handler = work; // 函数指针
sigemptyset(&act.sa_mask); // 清空掩码
sigaction(SIGALRM, &act, NULL); //注册信号捕捉
struct itimerval val;
val.it_value.tv_sec = 2;
val.it_value.tv_usec = 0;
val.it_interval.tv_sec = 2;
val.it_interval.tv_usec = 0;
// 创建定时器
setitimer(ITIMER_REAL, &val, NULL);
// 不让进程结束
while(1) {
sleep(10);
}
return 0;
}
