1. 程序
- 程序是包含一系列信息的文件，这些信息描述了如何在运行时创建一个进程：
- 二进制格式标识：每个程序文件都包含用于描述可执行文件格式的元信息。内核利用此信息来解
释文件中的其他信息。（ELF可执行连接格式） - 机器语言指令：对程序算法进行编码。
- 程序入口地址：标识程序开始执行时的起始指令位置。
- 数据：程序文件包含的变量初始值和程序使用的字面量值（比如字符串）。
- 符号表及重定位表：描述程序中函数和变量的位置及名称。这些表格有多重用途，其中包括调试
和运行时的符号解析（动态链接）。 - 共享库和动态链接信息：程序文件所包含的一些字段，列出了程序运行时需要使用的共享库，以
及加载共享库的动态连接器的路径名。 - 其他信息：程序文件还包含许多其他信息，用以描述如何创建进程。
2. 进程
- 进程是正在运行的程序的实例。是一个具有一定独立功能的程序关于某个数据集合的 一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是 基本的分配单元，也是基本的执行单元。
- 可以用一个程序来创建多个进程，进程是由内核定义的抽象实体，并为该实体分配用 以执行程序的各项系统资源。从内核的角度看，进程由用户内存空间和一系列内核数 据结构组成，其中用户内存空间包含了程序代码及代码所使用的变量，而内核数据结 构则用于维护进程状态信息。记录在内核数据结构中的信息包括许多与进程相关的标 识号（IDs)、虚拟内存表、打开文件的描述符表、信号传递及处理的有关信息、进 程资源使用及限制、当前工作目录和大量的其他信息。
3. 多程序设计
- 单道程序，即在计算机内存中只允许一个的程序运行。
多道程序设计技术是在计算机内存中同时存放几道相互独立的程序，使它们在管理程 序控制下，相互穿插运行，两个或两个以上程序在计算机系统中同处于开始到结束之 间的状态，这些程序共享计算机系统资源。引入多道程序设计技术的根本目的是为了 提高CPU的利用率。 - 对于一个单CPU系统来说，程序同时处于运行状态只是一种宏观上的概念，他们虽 然都已经开始运行，但就微观而言，任意时刻，CPU上运行的程序只有一个。 在多道程序设计模型中，多个进程轮流使用CPU。而当下常见CPU为纳秒级，1秒 可以执行大约10亿条指令。由于人眼的反应速度是毫秒级，所以看似同时在运行。
4. 时间片
- 时间片（timeslice)又称为“量子（quantum)“或“处理器片（processor slice)”
是操作系统分配给每个正在运行的进程微观上的一段CPU时间。事实上，虽然一台计 算机通常可能有多个CPU,但是同一个CPU永远不可能真正地同时运行多个任务。在 只考虑一个CPU的情况下，这些进程“看起来像”同时运行的，实则是轮番穿插地运行， 由于时间片通常很短（在Linux上为5ms-800ms),用户不会感觉到。 - 时间片由操作系统内核的调度程序分配给每个进程。首先，内核会给每个进程分配相等 的初始时间片，然后每个进程轮番地执行相应的时间，当所有进程都处于时间片耗尽的 状态时，内核会重新为每个进程计算并分配时间片，如此往复。
5. 并行和并发
- 并行（parallel):指在同一时刻，有多条指令在多个处理器上同时执行。
- 并发（concurrency):指在同一时刻只能有一条指令执行，但多个进程指令被快速的 轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的， 只是把时间分成若干段，使多个进程快速交替的执行。
- 并发是两个队列交替使用一台咖啡机。
并行是两个队列同时使用两台咖啡机。
6. 进程控制块
- 为了管理进程，内核必须对每个进程所做的事情进行清楚的描述。内核为每个进程分 配一个 PCB(Processing Control Block)进程控制块，维护进程相关的信息， Linux 内核的进程控制块是 task_struct结构体。
- 在/usr/src/linux-headers-xxx/include/linux/sched.h文件中可以查看 struct task_struct结构体定义。其内部成员有很多，我们只需要掌握以下 部分即可：
- 进程id:系统中每个进程有唯一的id,用pid_t类型表示，其实就是一个非负整数
- 进程的状态：有就绪、运行、挂起、停止等状态
- 进程切换时需要保存和恢复的一些CPU寄存器
- 描述虚拟地址空间的信息
- 描述控制终端的信息
- 当前工作目录（Current Working Directory)
- umask 掩码
- 文件描述符表，包含很多指向 file 结构体的指针和信号相关的信息
- 用户 id 和组 id
- 会话（Session)和进程组
- 进程可以使用的资源上限（Resource Limit) ulimit -a
7. 进程的状态
进程状态反映进程执行过程的变化。这些状态随着进程的执行和外界条件的变化而转换。
三态模型中，进程状态分为三个基本状态，即就绪态，运行态，阻塞态。
在五态模型中，进程分为新建态、就绪态，运行态，阻塞态，终止态。
- 运行态：进程占有处理器正在运行
- 就绪态：进程具备运行条件，等待系统分配处理器以便运行。当进程已分配到除CPU以外的所有必要资源后，只要再获得CPU,便可立即执行。在一个系统中处于就绪状态的进程可能有多个，通常将它们排成一个队列，称为就绪队列
- 阻塞态：又称为等待（wait)态或睡眠（sleep)态，指进程不具备运行条件，正在等待某个事件的完成
- 新建态：进程刚被创建时的状态，尚未进入就绪队列
- 终止态：进程完成任务到达正常结束点，或出现无法克服的错误而异常终止，或被操作系统及有终止权的进程所终止时所处的状态。进入终止态的进程以后不再执行，但依然保留在操作系统中等待善后。一旦其他进程完成了对终止态进程的信息抽取之后，操作系统将删除该进程。
查看进程
ps aux / ajx
a:显示终端上的所有进程，包括其他用户的进程
u:显示进程的详细信息
x:显示没有控制终端的进程
j:列出与作业控制相关的信息
STAT参数意义：
D 不可中断 Uninterruptible(usually IO)
R 正在运行，或在队列中的进程
S (大写）处于休眠状态
I 停止或被追踪
Z 僵尸进程
W 进入内存交换（从内核2.6开始无效）
X 死掉的进程
< 高优先级
N 低优先级
s 包含子进程
+ 位于前台的进程组
实时显示进程动态
top
可以在使用top命令时加上-d来指定显示信息更新的时间间隔，在top命令
执行后，可以按以下按键对显示的结果进行排序：
M根据内存使用量排序
P根据CPU占有率排序
T根据进程运行时间长短排序
U根据用户名来筛选进程
K输入指定的PID杀死进程
杀死进程
./a.out & 后台运行
kill [-signal] pid
ki11-l 列出所有信号
kill -SIGKILL 进程ID
kill -9 进程ID
killall name 根据进程名杀死进程
8. 进程号和相关函数
1. 每个进程都由进程号来标识，其类型为pid_t(整型）,进程号的范围：0~32767。进程号总是唯一的，但可以重用。当一个进程终止后，其进程号就可以再次使用。
2. 任何进程（除init进程）都是由另一个进程创建，该进程称为被创建进程的父进程，对应的进程号称为父进程号（PPID)。
3. 进程组是一个或多个进程的集合。他们之间相互关联，进程组可以接收同一终端的各种信号，关联的进程有一个进程组号（PGID)。默认情况下，当前的进程号会当做当前的进程组号。
4. 进程号和进程组相关函数：
pid_t getpid(void);
pid_t getppid ( void );
pid_t getpgid(pid_t pid);
9. 创建进程
-
系统允许一个进程创建新进程，新进程即为子进程，子进程还可以创建新的子进程，形成进程树结构模型。
-
#include <sys/types.h>
#include <unistd.h>
pid_t fork(void);//用于创建子进程
-
返回值：
成功：子进程中返回0,父进程中返回子进程的id
失败：返回-1 -
区分父进程和子进程：通过fork的返回值
-
在父进程中返回-1，表示创建子进程失败，并设置errno
-
失败的两个主要原因：
- 当前系统的进程数已经达到了系统规定的上限，这时errno的值被设置为EAGAIN
- 系统内存不足，这时errno的值被设置为ENOMEM
10. 父子进程的虚拟地址空间
-
fork()以后，子进程的用户区数据和父进程一样。内核区也会拷贝过来，但是pid不一样
-
Linux 的 fork() 使用是通过写时拷贝实现。写时拷贝是一种可以推迟甚至避免拷贝数据的技术。内核并不复制整个进程的地址空间，而是让父子进程共享同一个地址空间。只有在写入时才会复制地址空间（重新开辟一块内存），从而使各个进程拥有自己的地址空间。即资源的复制只有在写入时才会进行，在此之前，只有以只读的方式进行。
fork() 之后的父子进程共享文件，此时的 fork() 产生的子进程与父进程相同的文件描述符指向相同的文件表，引用计数增加，共享文件偏移指针。
-
首先父进程执行到fork时会创建子进程，fork后会给父子进程分别返回一个pid号（父进程fork后返回的pid号为子进程的pid=10089,而返回给子进程的pid号为0。注意，该代码第二行的pid是由fork创建后返回的pid，并不是该进程本身的pid，这点容易搞混，最好改一下命名如r_pid好一些），此时系统会将父进程的用户去数据和内核区拷贝过来生成一段新的虚拟地址空间供子进程使用，然后父进程开始继续执行if()判断，此时子进程是在父进程fork()后创造出来的，因此子进程只会执行fork()之后的语句，即也进行if()判断。但不同的是父进程是通过栈空间返回的pid号为大于0的值，而子进程通过栈空间返回的pid号为等于0的值。因此父子进程执行的if条件语句并不相同。
（实际更精准的说，Linux的fork()函数是通过写时拷贝来实现的，即fork后内核实际并不复制整个父进程的地址空间，而是让父子进程以只读的方式共享一个地址空间，只有在写入操作时才会进行资源的复制操作）
11. GBD多进程调试
- 使用GDB调试的时候，GDB默认只能跟踪一个进程，可以在fork函数调用之前，通过指令设置GDB调试工具跟踪父进程或者是跟踪子进程，默认跟踪父进程。
设置调试父进程或者子进程：set follow-fork-mode[parent(默认）|child]
- 设置调试模式：set detach-on-fork [on | off]
默认为on,表示调试当前进程的时候，其它的进程继续运行，如果为off,调试当前进
程的时候，其它进程被GDB挂起。
查看调试的进程：info inferiors
切换当前调试的进程：inferior id
使进程脱离GDB调试：detach inferiors id
-
父子进程之间的关系：
区别：-
fork()函数的返回值不同
父进程中：>0返回的子进程的ID
子进程中：=0 -
pcb中的一些数据
当前的进程的id pid
当前的进程的父进程的id ppid
信号集
共同点：
某些状态下：子进程刚被创建出来，还没有执行任何的写数据的操作
-用户区的数据
-文件描述符表 -
父子进程对变量是不是共享的？
- 刚开始的时候，是一样的，共享的。如果修改了数据，不共享了。
- 读时共享，写时拷贝。
12. exec函数族
-
exec函数族的作用是根据指定的文件名找到可执行文件，并用它来取代调用进程的内容，换句话说，就是在调用进程内部执行一个可执行文件。
exec函数族的函数执行成功后不会返回，因为调用进程的实体，包括代码段，数据段和堆栈等都已经被新的内容取代，留下进程ID等一些表面上的信息仍保持原样，颇有些神似“三十六计”中的“金蝉脱壳”。看上去还是旧的躯壳，却已经注入了新的灵魂。只有调用失败了，它们才会返回-1,从原程序的调用点接着往下执行。
//unistd.h
int execl (const char *path, const char *arg, .../* (char *) NULL */);
path:需要指定的执行文件的路径或名称
arg:执行可执行程序所需参数
第一个参数没有什么作用，一般写执行程序名称
从第二个参数开始往后，就是程序执行所需要的的参数列表。
参数最后需要以NULL结束（哨兵）
仅当调用错误返回-1并设置errno，调用成功无返回值
int execlp (const char *file, const char *arg, ... /* (char *) NULL */);
int execle (const char *path, const char *arg, .../*(char *) NULL, char *const envp [ ] */);
int execv (const char * path , char * const argv [ ] ) ;
int execvp (const char * file , char * const argv [ ] ) ;
int execvpe (const char *file, char *const argv[], char *const envp[]);
int execve (const char * filename , char * const argv [ ] , char * const envp [ ] ) ;
1(list)
参数地址列表，以空指针结尾
v(vector)
存有各参数地址的指针数组的地址
p (path )
按PATH环境变量指定的目录搜索可执行文件
e(environment)存有环境变量字符串地址的指针数组的地址
/*
#include <unistd.h>
int execl(const char *path, const char *arg, ...);
- 参数：
- path:需要指定的执行的文件的路径或者名称
a.out /home/nowcoder/a.out 推荐使用绝对路径
./a.out hello world
- arg:是执行可执行文件所需要的参数列表
第一个参数一般没有什么作用，为了方便，一般写的是执行的程序的名称
从第二个参数开始往后，就是程序执行所需要的的参数列表。
参数最后需要以NULL结束（哨兵）
- 返回值：
只有当调用失败，才会有返回值，返回-1，并且设置errno
如果调用成功，没有返回值。
*/
#include <unistd.h>
#include <stdio.h>
int main() {
// 创建一个子进程，在子进程中执行exec函数族中的函数
pid_t pid = fork();
if(pid > 0) {
// 父进程
printf("i am parent process, pid : %d\n",getpid());
sleep(1);
}else if(pid == 0) {
// 子进程
// execl("hello","hello",NULL);
execl("/bin/ps", "ps", "aux", NULL);
perror("execl");
printf("i am child process, pid : %d\n", getpid());
}
for(int i = 0; i < 3; i++) {
printf("i = %d, pid = %d\n", i, getpid());
}
return 0;
}
/*
#include <unistd.h>
int execlp(const char *file, const char *arg, ... );
- 会到环境变量中查找指定的可执行文件，如果找到了就执行，找不到就执行不成功。
- 参数：
- file:需要执行的可执行文件的文件名
a.out
ps
- arg:是执行可执行文件所需要的参数列表
第一个参数一般没有什么作用，为了方便，一般写的是执行的程序的名称
从第二个参数开始往后，就是程序执行所需要的的参数列表。
参数最后需要以NULL结束（哨兵）
- 返回值：
只有当调用失败，才会有返回值，返回-1，并且设置errno
如果调用成功，没有返回值。
int execv(const char *path, char *const argv[]);
argv是需要的参数的一个字符串数组
char * argv[] = {"ps", "aux", NULL};
execv("/bin/ps", argv);
int execve(const char *filename, char *const argv[], char *const envp[]);
char * envp[] = {"/home/nowcoder", "/home/bbb", "/home/aaa"};
*/
#include <unistd.h>
#include <stdio.h>
int main() {
// 创建一个子进程，在子进程中执行exec函数族中的函数
pid_t pid = fork();
if(pid > 0) {
// 父进程
printf("i am parent process, pid : %d\n",getpid());
sleep(1);
}else if(pid == 0) {
// 子进程
execlp("ps", "ps", "aux", NULL);
printf("i am child process, pid : %d\n", getpid());
}
for(int i = 0; i < 3; i++) {
printf("i = %d, pid = %d\n", i, getpid());
}
return 0;
}
13. 进程控制
1. 进程退出
#include <stdlib.h>
void exit (int status);
#include <unistd.h>
void _exit(int status);//系统函数不会刷新缓冲区
status：进程退出时的状态信息
2. 孤儿进程
- 父进程运行结束，但子进程还在运行（未运行结束）,这样的子进程就称为孤儿进程(Orphan Process)。
- 每当出现一个孤儿进程的时候，内核就把孤儿进程的父进程设置为init进程号为1,而init进程会循环地 wait()它的已经退出的子进程。这样，当一个孤儿进程凄凉地结束了其生命周期的时候，init进程就会代表党和政府出面处理它的一切善后工作。因此孤儿进程并不会有什么危害。
3. 僵尸进程
- 每个子进程结束之后，都会释放自己地址空间中的用户区数据，内核区的PCB没有办法自己释放掉，需要父进程去释放。
- 进程终止时，父进程尚未回收，子进程残留资源（PCB)存放于内核中，变成僵尸(Zombie)进程。
- 僵尸进程不能被
kill -9杀死。
这样就会导致一个问题，如果父进程不调用wait()或waitpid()的话，那么保留的那段信息就不会释放，其进程号就会一直被占用，但是系统所能使用的进程号是有限的，如果大量的产生僵尸进程，将因为没有可用的进程号而导致系统不能产生新的进程，此即为僵尸进程的危害，应当避免。
4. 进程回收
- 在每个进程退出的时候，内核释放该进程所有的资源、包括打开的文件、占用的内存等。但是仍然为其保留一定的信息，这些信息主要主要指进程控制块PCB的信息(包括进程号、退出状态、运行时间等）。
- 父进程可以通过调用wait或waitpid得到它的退出状态同时彻底清除掉这个进程。wait()和waitpid()函数的功能一样，区别在于，wait()函数会阻塞，waitpid()可以设置不阻塞，waitpid()还可以指定等待哪个子进程结束。
- 注意：一次wait或waitpid调用只能清理一个子进程，清理多个子进程应使用循环。
5. wait()函数
/*
#include <sys/types.h>
#include <sys/wait.h>
pid_t wait(int *wstatus);
功能：等待任意一个子进程结束，如果任意一个子进程结束了，次函数会回收子进程的资源。
参数：int *wstatus
进程退出时的状态信息，传入的是一个int类型的地址，传出参数。
返回值：
- 成功：返回被回收的子进程的id
- 失败：-1 (所有的子进程都结束，调用函数失败)
调用wait函数的进程会被挂起（阻塞），直到它的一个子进程退出或者收到一个不能被忽略的信号时才被唤醒（相当于继续往下执行）
如果没有子进程了，函数立刻返回，返回-1；如果子进程都已经结束了，也会立即返回，返回-1.
*/
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main() {
// 有一个父进程，创建5个子进程（兄弟）
pid_t pid;
// 创建5个子进程
for(int i = 0; i < 5; i++) {
pid = fork();
if(pid == 0) {
break;
}
}
if(pid > 0) {// 父进程
while(1) {
printf("parent, pid = %d\n", getpid());
// int ret = wait(NULL);
int st;
int ret = wait(&st);
if(ret == -1) {
break;
}
if(WIFEXITED(st)) { // 是不是正常退出
printf("退出的状态码：%d\n", WEXITSTATUS(st));
}
if(WIFSIGNALED(st)) { // 是不是异常终止
printf("被哪个信号干掉了：%d\n", WTERMSIG(st));
}
printf("child die, pid = %d\n", ret);
sleep(1);
}
}
else if (pid == 0){// 子进程
while(1)
{
printf("child, pid = %d\n",getpid());
sleep(1);
}
exit(0);
}
return 0; // exit(0)
}
6. waitpid()函数
/*
#include <sys/types.h>
#include <sys/wait.h>
pid_t waitpid(pid_t pid, int *wstatus, int options);
功能：回收指定进程号的子进程，可以设置是否阻塞。
参数：
- pid:
pid > 0 : 某个子进程的pid
pid = 0 : 回收当前进程组的所有子进程
pid = -1 : 回收所有的子进程，相当于 wait() （最常用）
pid < -1 : 某个进程组的组id的绝对值，回收指定进程组中的子进程
- options：设置阻塞或者非阻塞
0 : 阻塞
WNOHANG : 非阻塞
- 返回值：
> 0 : 返回子进程的id
= 0 : options=WNOHANG, 表示还有子进程或者
= -1 ：错误，或者没有子进程了
*/
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main() {
// 有一个父进程，创建5个子进程（兄弟）
pid_t pid;
// 创建5个子进程
for(int i = 0; i < 5; i++) {
pid = fork();
if(pid == 0) {
break;
}
}
if(pid > 0) {
// 父进程
while(1) {
printf("parent, pid = %d\n", getpid());
sleep(1);
int st;
// int ret = waitpid(-1, &st, 0);
int ret = waitpid(-1, &st, WNOHANG);
if(ret == -1) {
break;
} else if(ret == 0) {
// 说明还有子进程存在
continue;
} else if(ret > 0) {
if(WIFEXITED(st)) {
// 是不是正常退出
printf("退出的状态码：%d\n", WEXITSTATUS(st));
}
if(WIFSIGNALED(st)) {
// 是不是异常终止
printf("被哪个信号干掉了：%d\n", WTERMSIG(st));
}
printf("child die, pid = %d\n", ret);
}
}
} else if (pid == 0){
// 子进程
while(1) {
printf("child, pid = %d\n",getpid());
sleep(1);
}
exit(0);
}
return 0;
}
14. 进程间通信
1. 概念
- 进程是一个独立的资源分配单元，不同进程（这里所说的进程通常指的是用户进程）之间的资源是独立的，没有关联，不能在一个进程中直接访问另一个进程的资源。
但是，进程不是孤立的，不同的进程需要进行信息的交互和状态的传递等，因此需要进程间通信（IPC:Inter Processes Communication)。 - 进程间通信的目的：
数据传输：一个进程需要将它的数据发送给另一个进程。
通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。
资源共享：多个进程之间共享同样的资源。为了做到这一点，需要内核提供互斥和同步机制。
进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程）,此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。
2. linux进程间通信方式
3. 管道–匿名管道
-
管道概念
- 管道也叫无名（匿名）管道，它是是UNIX系统IPC(进程间通信）的最古老形式， 所有的UNIX系统都支持这种通信机制。
- 统计一个目录中文件的数目命令：ls|wc-l,为了执行该命令，she11创建了两 个进程来分别执行ls和wc。
-
管道特点
-
管道其实是一个在内核内存中维护的缓冲器，这个缓冲器的存储能力是有限的，不同的操作系统大小不一定相同。
-
管道拥有文件的特质：读操作、写操作，匿名管道没有文件实体，有名管道有文件实体，但不存储数据。可以按照操作文件的方式对管道进行操作。
-
一个管道是一个字节流，使用管道时不存在消息或者消息边界的概念，从管道读取数据的进程可以读取任意大小的数据块，而不管写入进程写入管道的数据块的大小是多少。
-
通过管道传递的数据是顺序的，从管道中读取出来的字节的顺序和它们被写入管道的顺序是完全一样的。
-
在管道中的数据的传递方向是单向的，一端用于写入，一端用于读取，管道是半双工的
-
从管道读数据是一次性操作，数据一旦被读走，它就从管道中被抛弃，释放空间以便写
更多的数据，在管道中无法使用1seek()来随机的访问数据。 -
匿名管道只能在具有公共祖先的进程（父进程与子进程，或者两个兄弟进程，具有亲缘关系）之间使用。
-
-
fork出的进程文件描述符相同
-
管道是一个环形队列
-
一般是单向的
-
-
创建匿名管道
#include <unistd.h>
int pipe(int pipefd[2]); -
查看管道缓冲大小命令
ulimit -a -
查看管道缓冲大小函数
#include <unistd.h>
long fpathconf (int fd, int name);
/*
#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;
}
- fpathconf获取管道的大小
#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()
子进程将标准输出重定向到管道的写端。dup2
#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.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, sizeof(buf));
}
}
else if (pid == 0)
{
//子进程
close(fd[0]);
dup2(fd[1], STDOUT_FILENO);
execlp("ps", "ps", "aux", NULL);
perror("execlp");
exit(0);
}
else
{
perror("fork");
exit(0);
}
}
8. 管道的读写特点
-
使用管道注意事项：需要注意以下几种特殊的情况（假设都是阻塞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;
}
4. 有名管道的使用
-
匿名管道，由于没有名字，只能用于亲缘关系的进程间通信。为了克服这个缺点，提出了有名管道（FIFO),也叫命名管道、FIFO文件。
-
有名管道（FIFO)不同于匿名管道之处在于它提供了一个路径名与之关联，以FIFO
的文件形式存在于文件系统中，并且其打开方式与打开一个普通文件是一样的，这样即使与FIFO的创建进程不存在亲缘关系的进程，只要可以访问该路径，就能够彼此通过FIFO相互通信，因此，通过FIFO不相关的进程也能交换数据。 -
一旦打开了FIFO,就能在它上面使用与操作匿名管道和其他文件的系统调用一样的 I/0系统调用了（如read()、write()和close())。与管道一样，FIFO也有一 个写入端和读取端，并且从管道中读取数据的顺序与写入的顺序是一样的。FIFO的 名称也由此而来：先入先出
-
有名管道（FIFO)和匿名管道（pipe)有一些特点是相同的，不一样的地方在于：
1. FIFO在文件系统中作为一个特殊文件存在，但FIFO中的内容却存放在内存中。
2. 当使用FIFO的进程退出后，FIFO文件将继续保存在文件系统中以便以后使用。
3. FIFO有名字，不相关的进程可以通过打开有名管道进行通信。 -
有名管道的使用
- 通过命令创建有名管道
mkfifo 名字 - 通过函数创建有名管道
#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char *pathname, mode_t mode);
- 通过命令创建有名管道
-
一旦使用mkfifo创建了一个FIFO,就可以使用open打开它，常见的文件
I/O函数都可用于fifo。如：close、read、write、unlink等。 -
FIFO严格遵循先进先出（First in First out),对管道及FIFO的读总是
从开始处返回数据，对它们的写则把数据添加到末尾。它们不支持诸如lseek()等文件定位操作 -
有名管道的注意事项：
1.一个为只读而打开一个管道的进程会阻塞，直到另外一个进程为只写打开管道
2.一个为只写而打开一个管道的进程会阻塞，直到另外一个进程为只读打开管道 -
总结
读管道：
管道中有数据，read返回实际读到的字节数
管道中无数据：
管道写端被全部关闭，read返回，(相当于读到文件末尾）
写端没有全部被关闭，read阻塞等待写管道：
管道读端被全部关闭，进行异常终止（收到一个SIGPIPE信号）
管道读端没有全部关闭：
管道已经满了，write会阻塞
管道没有满，write将数据写入，并返回实际写入的字节数。 -
案例：管道双向通信
#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;
}
#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;
}
5. 内存映射
-
内存映射（Memory-mapped I/O)是将磁盘文件的数据映射到内存，用户通过修改内存就能修改磁盘文件。
-
-
相关系统调用
#include <sys/mman.h>
void *mmap (void *addr, size_t length, int prot, int flags,
int fd, off_t offset);//将文件或设备映射到内存中
*addr:NULL由内核指定
length：要映射的数据的长度，这个值不能为0，建议使用文件长度，如果比内存分页大小小，那么length为内存分页的大小
获取文件长度：stat lseek
prot：对申请内存映射区的操作权限
PROT_EXEC执行
PROT_READ读
PROT WRITE写
PROT_NONE无权限
flags：
int munmap(void*addr,size_t length);//返回创建内存的首地址
//释放内存映射
//释放内存的大小
#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;
}
-
内存映射的注意事项
1.如果对mmap的返回值(ptr)做++操作(ptr++), munmap是否能够成功?
void * ptr = mmap(…);
ptr++; 可以对其进行++操作
munmap(ptr, len); // 错误,要保存地址2.如果open时O_RDONLY, mmap时prot参数指定PROT_READ | PROT_WRITE会怎样?
错误，返回MAP_FAILED
open()函数中的权限建议和prot参数的权限保持一致。3.如果文件偏移量为1000会怎样?
偏移量必须是4K的整数倍，返回MAP_FAILED4.mmap什么情况下会调用失败?
- 第二个参数：length = 0
- 第三个参数：prot
- 只指定了写权限
- prot PROT_READ | PROT_WRITE
第5个参数fd 通过open函数时指定的 O_RDONLY / O_WRONLY
5.可以open的时候O_CREAT一个新文件来创建映射区吗?
- 可以的，但是创建的文件的大小如果为0的话，肯定不行
- 可以对新的文件进行扩展
- lseek()
- truncate()
6.mmap后关闭文件描述符，对mmap映射有没有影响？
int fd = open(“XXX”);
mmap(,fd,0);
close(fd);
映射区还存在，创建映射区的fd被关闭，没有任何影响。7.对ptr越界操作会怎样？
void * ptr = mmap(NULL, 100,);
4K
越界操作操作的是非法的内存 -> 段错误 -
内存映射实现文件复制
// 使用内存映射实现文件拷贝的功能
/*
思路：
1.对原始的文件进行内存映射
2.创建一个新文件（拓展该文件）
3.把新文件的数据映射到内存中
4.通过内存拷贝将第一个文件的内存数据拷贝到新的文件内存中
5.释放资源
*/
#include <stdio.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
int main() {
// 1.对原始的文件进行内存映射
int fd = open("english.txt", O_RDWR);
if(fd == -1) {
perror("open");
exit(0);
}
// 获取原始文件的大小
int len = lseek(fd, 0, SEEK_END);
// 2.创建一个新文件（拓展该文件）
int fd1 = open("cpy.txt", O_RDWR | O_CREAT, 0664);
if(fd1 == -1) {
perror("open");
exit(0);
}
// 对新创建的文件进行拓展
truncate("cpy.txt", len);
write(fd1, " ", 1);
// 3.分别做内存映射
void * ptr = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
void * ptr1 = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd1, 0);
if(ptr == MAP_FAILED) {
perror("mmap");
exit(0);
}
if(ptr1 == MAP_FAILED) {
perror("mmap");
exit(0);
}
// 内存拷贝
memcpy(ptr1, ptr, len);
// 释放资源
munmap(ptr1, len);
munmap(ptr, len);
close(fd1);
close(fd);
return 0;
}
6. 匿名映射，不需要文件实体进行内存映射
/*
匿名映射：不需要文件实体进程一个内存映射
*/
#include<stdio.h>
#include<sys / mman.h>
#include<sys / types.h>
#include<sys / stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<string.h>
#include<stdlib.h>
#include<sys / wait.h>
int main()
{
// 1.创建匿名内存映射区
int len = 4096;
void *ptr = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
if (ptr == MAP_FAILED)
{
perror("mmap");
exit(0);
}
// 父子进程间通信
pid_t pid = fork();
if (pid > 0)
{
// 父进程
strcpy((char *)ptr, "hello, world");
wait(NULL);
}
else if (pid == 0)
{
// 子进程
sleep(1);
printf("%s\n", (char *)ptr);
}
// 释放内存映射区
int ret = munmap(ptr, len);
if (ret == -1)
{
perror("munmap");
exit(0);
}
return 0;
}
5. 信号
-
概念
- 信号是Linux进程间通信的最古老的方式之一，是事件发生时对进程的通知机制，有时也称之为软件中断，它是在软件层次上对中断机制的一种模拟，是一种异步通信的方式。信号可以导致一个正在运行的进程被另一个正在运行的异步进程中断，转而处理某一个突发事件。
- 发往进程的诸多信号，通常都是源于内核。引发内核为进程产生信号的各类事件如下：
- 对于前台进程，用户可以通过输入特殊的终端字符来给它发送信号。比如输入Ctr1+C通常会给进程发送一个中断信号。
- 硬件发生异常，即硬件检测到一个错误条件并通知内核，随即再由内核发送相应信号给相关进程。比如执行一条异常的机器语言指令，诸如被0除，或者引用了无法访问的内存区域。
- 系统状态变化，比如 alarm 定时器到期将引起 SIGALRM 信号，进程执行的 CPU时间超限，或者该进程的某个子进程退出。
- 运行kill命令或调用ki11函数
- 使用信号的两个主要目的是：
让进程知道已经发生了一个特定的事情。
强迫进程执行它自己代码中的信号处理程序。 - 信号的特点：
简单
不能携带大量信息
满足某个特定条件才发送
优先级比较高 - 查看系统定义的信号列表：kill-1
- 前31个信号为常规信号，其余为实时信号。
-
信号
-
信号的五种默认处理动作
查看信号的详细信息：man 7 signal
五种默认处理动作
Term终止进程
Ign当前进程忽略掉这个信号
Core终止进程，并生成一个Core文件
Stop暂停当前进程
Cont继续执行当前被暂停的进程
信号的几种状态：产生、未决、递达
SIGKILL 和 SIGSTOP 信号不能被捕捉、阻塞或者忽略，只能执行默认动作。
-
信号相关的函数
int kill(pid_t pid, int sig);
int raise(int sig);
void abort(void);
unsigned int alarm(unsigned int seconds);
int setitimer(int which, const struct itimerval *new_val,struct itimerval *old_value);
/*
#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;
}
5. alarm函数
/*
#include<unistd.h>
unsignedintalarm(unsignedintseconds);
-功能：设置定时器（闹钟）。函数调用，开始倒计时，当倒计时为0的时候，
函数会给当前的进程发送一个信号：SIGALARM
-参数：
seconds:倒计时的时长，单位：秒。如果参数为0，定时器无效（不进行倒计时，不发信号）。
取消一个定时器，通过alarm(0)。
-返回值：
-之前没有定时器，返回0
-之前有定时器，返回之前的定时器剩余的时间
-SIGALARM：默认终止当前的进程，每一个进程都有且只有唯一的一个定时器。
alarm(10);->返回0
过了1秒
alarm(5);->返回9
alarm(100)->该函数是不阻塞的
*/
#include<stdio.h>
#include<unistd.h>
int main()
{
int seconds=alarm(5);
printf("seconds=%d\n",seconds);//0
sleep(2);
seconds=alarm(2);//不阻塞
printf("seconds=%d\n",seconds);//3
while(1)
{
}
return0;
}
案例
案例：计算机一秒可以算数
```
//1秒钟电脑能数多少个数？
#include<stdio.h>
#include<unistd.h>
/*
实际的时间=内核时间+用户时间+消耗的时间
进行文件IO操作的时候比较浪费时间
定时器，与进程的状态无关（自然定时法）。无论进程处于什么状态，alarm都会计时。
*/
int main()
{
alarm(1);
int i=0;
while(1)
{
printf("%i\n",i++);
}
return 0;
}
- 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=set itimer(ITIMER_REAL,&new_value,NULL);//非阻塞的
printf("定时器开始了...\n");
if(ret==-1)
{
perror("setitimer");
exit(0);
}
getchar();
return0;
}
- signal信号捕捉
/*
int sigaction(int signum,const struct sigaction*act,
struct sigaction*oldact);
#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，设置错误号
SIGKILLSIGSTOP不能被捕捉，不能被忽略。
*/
#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;
}
6. 信号集
- 许多信号相关的系统调用都需要能表示一组不同的信号，多个信号可使用一个称之为信号集的数据结构来表示，其系统数据类型为sigset_t。
- 在PCB中有两个非常重要的信号集。一个称之为“阻塞信号集”，另一个称之为
“未决信号集”。这两个信号集都是内核使用位图机制来实现的。但操作系统不允许我们直接对这两个信号集进行位操作。而需自定义另外一个集合，借助信号集操作函数来对PCB中的这两个信号集进行修改。
- 信号的“未决”是一种状态，指的是从信号的产生到信号被处理前的这一段时间。
- 信号的“阻塞”是一个开关动作，指的是阻止信号被处理，但不是阻止信号产生。
- 信号的阻塞就是让系统暂时保留信号留待以后发送。由于另外有办法让系统忽略信号，所以一般情况下信号的阻塞只是暂时的，只是为了防止信号打断敏感的操作。
- 阻塞信号集和未决信号集
- 用户通过键盘 Ctrl + C, 产生2号信号SIGINT (信号被创建)
- 信号产生但是没有被处理 （未决）
- 在内核中将所有的没有被处理的信号存储在一个集合中 （未决信号集）
- SIGINT信号状态被存储在第二个标志位上
- 这个标志位的值为0， 说明信号不是未决状态
- 这个标志位的值为1， 说明信号处于未决状态
- 这个未决状态的信号，需要被处理，处理之前需要和另一个信号集（阻塞信号集），进行比较
- 阻塞信号集默认不阻塞任何的信号
- 如果想要阻塞某些信号需要用户调用系统的API - 在处理的时候和阻塞信号集中的标志位进行查询，看是不是对该信号设置阻塞了
- 如果没有阻塞，这个信号就被处理
- 如果阻塞了，这个信号就继续处于未决状态，直到阻塞解除，这个信号就被处理 - 信号集相关函数
int sigemptyset(sigset_t*set);
int sigfillset(sigset_t*set);
int sigaddset(sigset_t*set,int signum);
int sigdelset(sigset_t*set,int signum);
int sigismember(constsigset_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>
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;
}
- sigpromask函数
/*
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,传出参数，保存的是内核中的未决信号集中的信息。
*/
#include<stdio.h>
#include<signal.h>
#include<stdlib.h>
#include<unistd.h>
int main()
{
// 设置2、3号信号阻塞
sigset_t set;
sigemptyset(&set);
// 将2号和3号信号添加到信号集中
sigaddset(&set, SIGINT);
sigaddset(&set, SIGQUIT);
// 修改内核中的阻塞信号集
sigprocmask(SIG_BLOCK, &set, NULL);
int num = 0;
while (1)
{
num++;
// 获取当前的未决信号集的数据
sigset_t pendingset;
sigemptyset(&pendingset);
sigpending(&pendingset);
// 遍历前32位
for (int i = 1; i <= 31; i++)
{
if (sigismember(&pendingset, i) == 1)
{
printf("1");
}
else if (sigismember(&pendingset, i) == 0)
{
printf("0");
}
else
{
perror("sigismember");
exit(0);
}
}
printf("\n");
sleep(1);
if (num == 10)
{
// 解除阻塞
sigprocmask(SIG_UNBLOCK, &set, NULL);
}
}
return 0;
}
- sigaction函数 信号捕捉函数
#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;
}
- 内核实现信号捕捉的过程
- SIGCHLD信号
SIGCHLD信号产生的条件
子进程终止时
子进程接收到SIGSTOP信号停止时
子进程处在停止态，接受到SIGCONT后唤醒时
以上三种条件都会给父进程发送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;
}
7. 共享内存 效率最高的一种进程间通信方式
- 概念
共享内存允许两个或者多个进程共享物理内存的同一块区域（通常被称为段）。由于一个共享内存段会称为一个进程用户空间的一部分，因此这种IPC机制无需内核介入。所有需要做的就是让一个进程将数据复制进共享内存中，并且这部分数据会对其他所有共享同一个段的进程可用。
与管道等要求发送进程将数据从用户空间的缓冲区复制进内核内存和接收进程将数据从内核内存复制进用户空间的缓冲区的做法相比，这种IPC技术的速度更快。
- 使用步骤
- 调用shmget() 创建一个新共享内存段或取得一个既有共享内存段的标识符（即由其他进程创建的共享内存段）。这个调用将返回后续调用中需要用到的共享内存标识符。
- 使用shmat() 来附上共享内存段，即使该段成为调用进程的虚拟内存的一部分。
- 此刻在程序中可以像对待其他可用内存那样对待这个共享内存段。为引用这块共享内存，程序需要使用由shmat() 调用返回的addr值，它是一个指向进程的虚拟地址空间中该共享内存段的起点的指针。
- 调用shmdt() 来分离共享内存段。在这个调用之后，进程就无法再引用这块共享内存了。这一步是可选的，并且在进程终止时会自动完成这一步。
- 调用shmct1() 来删除共享内存段。只有当当前所有附加内存段的进程都与之分离之后内存段才会销毁。只有一个进程需要执行这一步。
- 相关函数
1. int shmget(key_t key, size_t size, int shmflg);
2. void *shmat(int shmid, const void *shmaddr, int shmflg);
3. int shmdt(const void *shmaddr);
4. int shmctl(int shmid, int cmd, struct shmid_ds *buf);
5. key_t ftok(const char *pathname, int proj_id);
共享内存相关的函数
#include<sys / ipc.h>
#include<sys / shm.h>
int shmget(key_t key, size_t size, int shmflg);
- 功能：创建一个新的共享内存段，或者获取一个既有的共享内存段的标识。
新创建的内存段中的数据都会被初始化为0
- 参数：
- key : key_t类型是一个整形，通过这个找到或者创建一个共享内存。
一般使用16进制表示，非0值
- size : 共享内存的大小
- shmflg : 属性
- 访问权限
- 附加属性：创建 / 判断共享内存是不是存在
- 创建：IPC_CREAT
- 判断共享内存是否存在： IPC_EXCL, 需要和IPC_CREAT一起使用
IPC_CREAT | IPC_EXCL | 0664
- 返回值：
失败： - 1 并设置错误号
成功： > 0 返回共享内存的引用的ID，后面操作共享内存都是通过这个值。
void *shmat(int shmid, const void *shmaddr, int shmflg);
- 功能：和当前的进程进行关联
- 参数：
- shmid : 共享内存的标识（ID）, 由shmget返回值获取
- shmaddr : 申请的共享内存的起始地址，指定NULL，内核指定
- shmflg : 对共享内存的操作
- 读 ： SHM_RDONLY, 必须要有读权限
- 读写： 0
- 返回值：
成功：返回共享内存的首（起始）地址。 失败(void *) - 1
int shmdt(const void *shmaddr);
- 功能：解除当前进程和共享内存的关联
- 参数：
shmaddr：共享内存的首地址
- 返回值：成功 0， 失败 - 1
int shmctl(int shmid, int cmd, struct shmid_ds *buf);
- 功能：对共享内存进行操作。删除共享内存，共享内存要删除才会消失，创建共享内存的进行被销毁了对共享内存是没有任何影响。
- 参数：
- shmid : 共享内存的ID
- cmd : 要做的操作
- IPC_STAT : 获取共享内存的当前的状态
- IPC_SET : 设置共享内存的状态
- IPC_RMID : 标记共享内存被销毁
- buf：需要设置或者获取的共享内存的属性信息
- IPC_STAT : buf存储数据
- IPC_SET : buf中需要初始化数据，设置到内核中
- IPC_RMID : 没有用，NULL
key_t ftok(const char *pathname, int proj_id);
- 功能：根据指定的路径名，和int值，生成一个共享内存的key
- 参数：
- pathname : 指定一个存在的路径
/ home / nowcoder / Linux / a.txt
/
- proj_id : int类型的值，但是这系统调用只会使用其中的1个字节
范围 ： 0 - 255 一般指定一个字符 'a'
问题1：操作系统如何知道一块共享内存被多少个进程关联？
- 共享内存维护了一个结构体struct shmid_ds 这个结构体中有一个成员 shm_nattch
- shm_nattach 记录了关联的进程个数
问题2：可不可以对共享内存进行多次删除 shmctl
- 可以的
- 因为shmctl 标记删除共享内存，不是直接删除
- 什么时候真正删除呢 ?
当和共享内存关联的进程数为0的时候，就真正被删除
- 当共享内存的key为0的时候，表示共享内存被标记删除了
如果一个进程和共享内存取消关联，那么这个进程就不能继续操作这个共享内存。也不能进行关联。
共享内存和内存映射的区别
1.共享内存可以直接创建，内存映射需要磁盘文件（匿名映射除外）
2.共享内存效率更高
3.内存
所有的进程操作的是同一块共享内存。
内存映射，每个进程在自己的虚拟地址空间中有一个独立的内存。
4.数据安全
- 进程突然退出
共享内存还存在
内存映射区消失
- 运行进程的电脑死机，宕机了
数据存在在共享内存中，没有了
内存映射区的数据 ，由于磁盘文件中的数据还在，所以内存映射区的数据还存在。
5.生命周期
- 内存映射区：进程退出，内存映射区销毁
- 共享内存：进程退出，共享内存还在，标记删除（所有的关联的进程数为0），或者关机
如果一个进程退出，会自动和共享内存进行取消关联。
- 使用案例
//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;
}
- 共享内存操作命令
ipcs 用法
ipcs-a//打印当前系统中所有的进程间通信方式的信息
ipcs-m//打印出使用共享内存进行进程间通信的信息
ipcs-q//打印出使用消息队列进行进程间通信的信息
ipcs-s//打印出使用信号进行进程间通信的信息
ipcrm用法
ipcrm -M shmkey//移除用shmkey创建的共享内存段
ipcrm -m shiild//移除用shmid标识的共享内存段
ipcrm -Q msgkey//移除用msqkey创建的消息队列
ipcrm -q msqid//移除用msqid标识的消息队列
ipcrm -s semkey//移除用semkey创建的信号
ipcrm -s semid//移除用semid标识的信号
8. 守护进程
- 终端
- 在UNIX系统中，用户通过终端登录系统后得到一个she11进程，这个终端成为shell进程的控制终端（Controlling Terminal),进程中，控制终端是保存在PCB中的信息，而fork()会复制PCB中的信息，因此由shell进程启动的其它进程的控制终端也是这个终端。
- 默认情况下（没有重定向）,每个进程的标准输入、标准输出和标准错误输出都指向控制终端，进程从标准输入读也就是读用户的键盘输入，进程往标准输出或标准错误输出写也就是输出到显示器上。
- 在控制终端输入一些特殊的控制键可以给前台进程发信号，例如ctrl+C会产生 SIGINT 信号，Ctrl + \ 会产生 SIGQUIT 信号。
- 进程组
- 进程组和会话在进程之间形成了一种两级层次关系：进程组是一组相关进程的集合，会话是一组相关进程组的集合。进程组合会话是为支持she11作业控制而定义的抽象概念，用户通过 shell 能够交互式地在前台或后台运行命令。
- 进行组由一个或多个共享同一进程组标识符（PGID)的进程组成。一个进程组拥有一个进程组首进程，该进程是创建该组的进程，其进程ID为该进程组的ID,新进程会继承其父进程所属的进程组ID。
- 进程组拥有一个生命周期，其开始时间为首进程创建组的时刻，结束时间为最后一个成员进程退出组的时刻。一个进程可能会因为终止而退出进程组，也可能会因为加入了另外一个进程组而退出进程组。进程组首进程无需是最后一个离开进程组的成员。
- 会话
- 会话是一组进程组的集合。会话首进程是创建该新会话的进程，其进程ID会成为会话 ID。新进程会继承其父进程的会话 ID。
- 一个会话中的所有进程共享单个控制终端。控制终端会在会话首进程首次打开一个终端设备时被建立。一个终端最多可能会成为一个会话的控制终端。
- 在任一时刻，会话中的其中一个进程组会成为终端的前台进程组，其他进程组会成为后台进程组。只有前台进程组中的进程才能从控制终端中读取输入。当用户在控制终端中输入终端字符生成信号后，该信号会被发送到前台进程组中的所有成员。
- 当控制终端的连接建立起来之后，会话首进程会成为该终端的控制进程。
- 进程组、会话、控制终端的关系
- 进程组、绘画操作函数
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 - 守护进程
- 守护进程（Daemon Process),也就是通常说的Daemon进程（精灵进程）,是Linux 中的后台服务进程。它是一个生存期较长的进程，通常独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。一般采用以 d 结尾的名字。
- 守护进程具备下列特征：
1. 生命周期很长，守护进程会在系统启动的时候被创建并一直运行直至系统被关闭。
2. 它在后台运行并且不拥有控制终端。没有控制终端确保了内核永远不会为守护进程自动生成任何控制信号以及终端相关的信号（如SIGINT、SIGQUIT)。
3. Linux 的大多数服务器就是用守护进程实现的。比如，Internet服务器inetd,Web服务器httpd等。
- 守护进程的创建步骤
1. 执行一个fork(),之后父进程退出，子进程继续执行。//避免重复会话id
2. 子进程调用 setsid()开启一个新会话。//脱离控制终端
3. 清除进程的 umask 以确保当守护进程创建文件和目录时拥有所需的权限。
4. 修改进程的当前工作目录，通常会改为根目录（/)。
5. 关闭守护进程从其父进程继承而来的所有打开着的文件描述符。
6. 在关闭了文件描述符0、1、2之后，守护进程通常会打开/dev/nu11并使用dup2()使所有这些描述符指向这个设备。
7. 核心业务逻辑
- 案例
/*
写一个守护进程，每隔2s获取一下系统时间，将这个时间写入到磁盘文件中。
*/
#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/time.h>
#include <signal.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>
void work(int num)
{
// 捕捉到信号之后，获取系统时间，写入磁盘文件
time_t tm = time(NULL);
struct tm *loc = localtime(&tm);
// char buf[1024];
// sprintf(buf, "%d-%d-%d %d:%d:%d\n",loc->tm_year,loc->tm_mon
// ,loc->tm_mday, loc->tm_hour, loc->tm_min, loc->tm_sec);
// printf("%s\n", buf);
char *str = asctime(loc);
int fd = open("time.txt", O_RDWR | O_CREAT | O_APPEND, 0664);
write(fd, str, strlen(str));
close(fd);
}
int main()
{
// 1.创建子进程，退出父进程
pid_t pid = fork();
if (pid > 0)
{
exit(0);
}
// 2.将子进程重新创建一个会话
setsid();
// 3.设置掩码
umask(022);
// 4.更改工作目录
chdir("/home/nowcoder/");
// 5. 关闭、重定向文件描述符
int fd = open("/dev/null", O_RDWR);
dup2(fd, STDIN_FILENO);
dup2(fd, STDOUT_FILENO);
dup2(fd, STDERR_FILENO);
// 6.业务逻辑
// 捕捉定时信号
struct sigaction act;
act.sa_flags = 0;
act.sa_handler = work;
sigemptyset(&act.sa_mask);
sigaction(SIGALRM, &act, NULL);
struct itimerval val;
val.it_value.tv_sec = 2;
val.it_value.tv_usec = 0;
val.it_interval.tv_sec = 2;
val.it_interval.tv_usec = 0;
// 创建定时器
setitimer(ITIMER_REAL, &val, NULL);
// 不让进程结束
while (1)
{
sleep(10);
}
return 0;
}
扫一扫
433
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
