linux 应用开发笔记---【进程】

1.进程的概念：

何为进程：

进程是一个应用程序的实例。也就是系统中真正运行的应用程序，程序一旦运行就是进程，进程是一个动态过程，它是程序的一次运行结果，而非静态文件

进程的生命周期：? ?从程序启动到程序退出的这段时间

进程号（process ID）：

Linux系统下的每一个进程都要一个进程号（PID）,进程号是一个正数，用于唯一标识系统中的某一个进程

pid_t getpid(void);


获取该进程的pid号

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
int main(void)
{
        pid_t pid = getpid();
        printf("本进程的 PID 为: %d\n", pid);
        exit(0);
}

运行结果：

pid_t getppid(void);


获取父进程的进程号

运行main()函数之前会有一段引导代码函数，这段代码并不需要我们自己编写，而是在编译，链接我们的应用程序的时候由链接器将这段引导代码链接到我们的链接程序中，构成最终的可执行文件，也就是最后的程序

exit()和_exit()的区别;

1.exit()是库函数，_exit()它是一个系统调用

2.exit()是会调用_exit()以及刷新文件缓存区，确保缓存区的内容保存回到文件，_exit()会直接关闭进程，可能会导致文件的丢失

2.进程的环境变量

每个进程都有一个与其相关的环境变量，环境变量以字符串的形式存储在一个字符串组列表【名称 = 值】

可以使用 export 添加环境变量? ? ?export -n 删除环境变量

char *getenv(const char *name);


获取进程的环境变量

3.添加/删除/修改环境变量

putenv()函数可以向进程的环境变量数组添加一个新的环境变量，或者修改一个已经存在的环境变量的数值

int putenv(char *string);

int setenv(const char *name, const char *value, int overwrite);

name：需要添加或修改的环境变量名称

value：环境变量的值

overwrite:当为0的时候，也就不会改变当前的环境变量的数值     
当不为0的时候，若name的环境变量不变，则添加。若存在，则覆盖

移除name标识的环境变量

int unsetenv(const char *name);

int clearenv(void);

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(void)
{
        pid_t pid;
        int fd;
        int i;
        fd = open("./test.txt", O_RDWR | O_TRUNC);
        if (0 > fd) {
                perror("open error");
                exit(-1);
        }
        pid = fork();
        switch (pid) {
                case -1:
                        perror("fork error");
                        close(fd);
                        exit(-1);
                case 0:
                        /* 子进程 */
                        for (i = 0; i < 4; i++) //循环写入 4 次
                        write(fd, "1122", 4);
                        close(fd);
                        _exit(0);
        default:
        /* 父进程 */
                for (i = 0; i < 4; i++) //循环写入 4 次
                write(fd, "AABB", 4);
                close(fd);
                exit(0);
        }
}

?vfork()函数

pid_t vfork(void);

• vfork创建新进程的主要目的在于调用exec函数执行另外的一个新程序，在没调用exec或exit之前，子进程的运行是与父进程共享数据段的；
• vfork调用中，子进程先运行，父进程挂起，直到子进程调用exec或者exit，在这以后，父子进程的执行顺序不再被限制。
• vfork本身就是为exec()而生，因为之前的fork()去拷贝父进程的进程环境，在调用exec()后显得毫无作用，且低效，所以共享才更合适。

5.父子进程的竞争关系?

当父进程中使用fork()创建了子进程，两者都会被系统调度正常运行，但是谁率先访问，确是不确定的

6.进程的终止

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(void)
{
        printf("Hello World!");
        switch (fork()) {
                case -1:
                        perror("fork error");
                        exit(-1);
                case 0:
                /* 子进程 */
                        exit(0);
                default:
                /* 父进程 */
                        exit(0);
        }
}

上述代码printf将数据放入到缓冲区，然后创建子进程会复制缓冲区的内容，所以子父进程调用exit(0)的时候，就都会刷新缓冲区显示字符串，所以就会显示两次

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(void)
{
        printf("Hello World!\n");
        switch (fork()) {
                case -1:
                        perror("fork error");
                        exit(-1);
                case 0:
                /* 子进程 */
                        exit(0);
                default:
                /* 父进程 */
                        exit(0);
        }
}

给printf后面加入了\n,因为标准输出设备采用的是行缓冲的方式?，当读取到\n的时候，会读取缓冲区的内容，因为缓冲区没有数据了，所以子进程无法读取数据，所以只打印一遍

在子进程中最好不要去使用exit(0),因为会刷新缓冲区，导致父进程出现问题，使用_exit(0)才合适

?7.监视子进程

1.wait()函数

pid_t wait(int *status);



当status不为空：


? WIFEXITED(status)：如果子进程正常终止，则返回 true；
? WEXITSTATUS(status)：返回子进程退出状态，是一个数值，其实就是子进程调用_exit()或 exit()
时指定的退出状态；wait()获取得到的 status 参数并不是调用_exit()或 exit()时指定的状态，可通过
WEXITSTATUS 宏转换；
? WIFSIGNALED(status)：如果子进程被信号终止，则返回 true；
? WTERMSIG(status)：返回导致子进程终止的信号编号。如果子进程是被信号所终止，则可以通过
此宏获取终止子进程的信号；
? WCOREDUMP(status)：如果子进程终止时产生了核心转储文件，则返回 true；

1.等待任意子进程的结束，然后回收子进程的终止状态信息,但是调用wait()一次只可以运行一次，也就是只能回收一个子进程

2.当所有的子进程都在运行中，则wait()会一直阻塞等待，直到某一个子进程的结束

2.waitpid()函数

pid_t waitpid(pid_t pid, int *status, int options);


? 如果 pid 大于 0，表示等待进程号为 pid 的子进程；
? 如果 pid 等于 0，则等待与调用进程（父进程）同一个进程组的所有子进程；
? 如果 pid 小于-1，则会等待进程组标识符与 pid 绝对值相等的所有子进程；
? 如果 pid 等于-1，则等待任意子进程。wait(&status)与 waitpid(-1, &status, 0)等价。



? WNOHANG：如果子进程没有发生状态改变（终止、暂停），则立即返回，也就是执行非阻塞等
待，可以实现轮训 poll，通过返回值可以判断是否有子进程发生状态改变，若返回值等于 0 表示没
有发生改变。
? WUNTRACED：除了返回终止的子进程的状态信息外，还返回因信号而停止（暂停运行）的子进
程状态信息；
? WCONTINUED：返回那些因收到 SIGCONT 信号而恢复运行的子进程的状态信息。
从以上的介绍可知，waitpid()在功能上要强于 wait()函数，它弥补了 wait()函数所带来的一些限制，具体
在实际的编程使用当中，可根据自己的需求进行选择。

3.waitid()函数

man 2 waitid    自行查看

8.僵尸进程与孤儿进程

1.孤儿进程

父进程先于子进程结束，此时子进程就变成一个“孤儿”，所有的孤儿进程多自动成为init()【进程号为1】的子进程，当成“养父”

2.僵尸进程

进程结束之后，通常需要其父进程收尸，也就是，子进程先于父进程结束，此时父进程还没有来得及去调用 wait()...等收尸函数，子进程就变成了“僵尸状态”，紧接着，要么是父进程去调用wait（）函数去收尸，当父进程没有去调用，且父进程结束了，则“养父”init进程会自动调用wait()，结束僵尸进程

僵尸进程无法通过信号杀死【SIGKILL也不行】，如果父进程没有及时的清理掉僵尸进程，则会阻碍新的进程的创建，毕竟内存有限

SIGCHLD信号

1.当父进程在某个子进程终止时，父进程会受到SIGCHLD信号

2.当父进程的某个子进程因收到信号而停止或恢复时，内核也可能向父进程发送信号，因为子进程的终止是异步事件，因为父进程是之前无法得知，但是父进程却不能一直调用wait()去阻塞等待，但是不可能一直等待。

所以，当子进程的状态改变的时候，父进程会收到SIGCHLD信号，去捕获，绑定信号函数

当调用信号处理函数的时候，会暂时将当前真正处理的信号添加到信号掩码中，当SIGCHLD正在为一个已经终止的子进程收尸的时候，如果此时有两个子进程结束了，也就是产生了两个SIGCHLD信号，但是一次的SIGCHLD的信号会被丢失，也就是说，父进程最终也只能接收一次SIGCHLD信号，那么会一个被漏掉

解决方法：在 SIGCHLD 信号处理函数中循环以非阻塞方式来调用 waitpid()，直至再无其它终止的子进程需要处理为止

while (waitpid(-1, NULL, WNOHANG) > 0)
continue;

9.执行新程序【联系vfork】

execve()函数

int execve(const char *filename, char *const argv[], char *const envp[]);



filename：参数 filename 指向需要载入当前进程空间的新程序的路径名，既可以是绝对路径、也可以是
相对路径。
argv：参数 argv 则指定了传递给新程序的命令行参数。是一个字符串数组，该数组对应于 main(int argc, 
char *argv[])函数的第二个参数 argv，且格式也与之相同，是由字符串指针所组成的数组，以 NULL 结束。
argv[0]对应的便是新程序自身路径名。
envp：参数 envp 也是一个字符串指针数组，指定了新程序的环境变量列表，参数 envp 其实对应于新程
序的 environ 数组，同样也是以 NULL 结束，所指向的字符串格式为 name=value

10.进程状态与关系

? 每个进程必定属于某一个进程组、且只能属于一个进程组

? 每一个进程组有一个组长进程，组长进程的 ID 就等于进程组 ID

? 在组长进程的 ID 前面加上一个负号即是操作进程组

? 组长进程不能再创建新的进程组

? 只要进程组中还存在一个进程，则该进程组就存在，这与其组长进程是否终止无关

? 一个进程组可以包含一个或多个进程，进程组的生命周期从被创建开始，到其内所有进程终止或离开该进程组

? 默认情况下，新创建的进程会继承父进程的进程组 ID

pid_t getpgid(pid_t pid);
pid_t getpgrp(void);




pid为0，则表示获取调用者进程的进程组

加入一个现有的进程组或创建一个新的进程组





int setpgid(pid_t pid, pid_t pgid);
int setpgrp(void);

#include <unistd.h>

int pipe(int pipefd[2]);     一个读，一个写

pipefd[1]   写
pipefd[0]   读


成功返回0,失败返回-1



先调用pipe创建匿名管道，然后fork子进程，子进程继承了两个文件描述符，子进程和父进程就实现了文件共享，实现进程间的通信

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
int main(void)
{
        int piped[2] = {0};
        if(-1 == pipe(piped))
        {
                perror("pipe error");
                exit(0);
        }
        switch (fork())
        {
                case -1:
                        perror("error");
                        exit(-1);
                case 0:
                        {
                        char redbuf[64] = {0};
                        close(piped[1]);

                        while (1)
                        {
                                read(piped[0],redbuf,sizeof(redbuf));
                                printf("%s\n",redbuf);
                                memset(redbuf,0x0,sizeof(redbuf));
                        }
                        _exit(0);
                        }
                default:
                        close(piped[0]);
                        while(1)
                        {
                                write(piped[1],"hello world", 11);
                                sleep(1);
                        }
                        break;
                        

        }
}