【C/C++】Linux多进程开发

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

提示：这里可以添加本文要记录的大概内容：

---

---

提示：以下是本篇文章正文内容，下面案例可供参考

2.1 进程概述

并行与并发

2.2 进程状态及其转换

三态

五态

1.进程相关命令

man ps //查看ps
tty //当前所属终端

◼ 查看进程
ps aux / ajx （ajx:更多的信息（父进程ID，进程组ID））

a：显示终端上的所有进程，包括其他用户的进程
u：显示进程的详细信息
x：显示没有控制终端的进程
j：列出与作业控制相关的信息

◼ STAT参数意义：

D 不可中断 Uninterruptible（usually IO）
R 正在运行，或在队列中的进程
S(大写) 处于休眠状态
T 停止或被追踪
Z 僵尸进程
W 进入内存交换（从内核2.6开始无效）
X 死掉的进程
< 高优先级
N 低优先级
s 包含子进程
+ 位于前台的进程组

◼ 实时显示进程动态
top / top -d 2 //两秒更新一次

可以在使用 top 命令时加上 -d 来指定显示信息更新的时间间隔，在 top 命令
执行后，可以按以下按键对显示的结果进行排序：
⚫ M 根据内存使用量排序
⚫ P 根据 CPU 占有率排序
⚫ T 根据进程运行时间长短排序
⚫ U 根据用户名来筛选进程 
⚫ K 输入指定的 PID 杀死进程

◼ 杀死进程

kill [-signal] pid
kill –l 列出所有信号

kill –SIGKILL 进程ID
kill -9 进程ID //强制kill进程

killall name 根据进程名杀死进程

./a.out //默认前台运行，当前终端阻塞，不能输入
./a.out & //在后台运行

03 / 进程号和相关函数

◼ 每个进程都由进程号来标识，其类型为 pid_t（整型），进程号的范围：0～32767。
进程号总是唯一的，但可以重用。当一个进程终止后，其进程号就可以再次使用。
◼ 任何进程（除 init 进程）都是由另一个进程创建，该进程称为被创建进程的父进程，
对应的进程号称为父进程号（PPID）。
◼ 进程组是一个或多个进程的集合。他们之间相互关联，进程组可以接收同一终端的各
种信号，关联的进程有一个进程组号（PGID）。默认情况下，当前的进程号会当做当
前的进程组号。
◼ 进程号和进程组相关函数：
⚫ pid_t getpid(void); //当前进程ID
⚫ pid_t getppid(void);//当前进程父进程ID
⚫ pid_t getpgid(pid_t pid);//进程组ID，若没有参数，默认当前

2.3 进程创建

/*
    #include <sys/types.h>
    #include <unistd.h>

    pid_t fork(void);
    //用于创建子进程
        返回值：
            fork的返回值会返回两次，一次是在父进程中，一次在子进程中
            通过fork的返回值可以区分父进程和子进程:
                在父进程返回子进程的ID；
                在子进程中返回0；
            创建子进程失败失败，父进程返回-1，并设置errno


*/
 #include <sys/types.h>
#include <unistd.h>
#include<stdio.h>
int main(){
   
    //创建子进程
    pid_t pid=fork();

    //判断父进程还是子进程
    if(pid>0){
   
        printf("pid:%d\n",pid);
        //如果大于0，返回的是创建子进程的父进程
        printf("i am parent process,pid :%d,ppid:%d\n",getpid(),getppid());
    }else if(pid==0){
   
        //当前是子进程
        printf("i am child process,pid :%d,ppid:%d\n",getpid(),getppid());
    }
    //for循环测试
    for(int i=0;i<3;i++){
   
        printf("i:%d,pid:%d\n",i,getpid());
        sleep(1);
    }
    return 0;
}
/*
    fork()原理：
        读时共享：
        写时拷贝：写操作的时候才复制一个新的物理地址空间，
                并开辟新的物理内存存储；
*/

---

2.4父子进程的虚拟地址空间情况

父进程的栈空间的pid是子进程ID（10089），子进程栈空间的pid为0

父子进行分别运行在不同的内存空间，用户区相同的数据之间无联系

---

2.5父子进程关系及GDB多进程调试

设置调试模式：set detach-on-fork [on | off]
默认为 on，表示调试当前进程的时候，其它的进程继续运行，如果为 off，调试当前进程的时候，其它进程被 GDB 挂起

查看调试的进程：info inferiors
切换当前调试的进程：inferior id
使进程脱离 GDB 调试：detach inferiors id

切换调试进程后按c ,开始调试进程

---

2.6 exec函数族

◼ exec 函数族的作用是根据指定的文件名找到可执行文件，并用它来取代调用进程的
内容，换句话说，就是在调用进程内部执行一个可执行文件。

◼ exec 函数族的函数执行成功后不会返回，因为调用进程的实体，包括代码段，数据段
和堆栈等都已经被新的内容取代，只留下进程 ID 等一些表面上的信息仍保持原样，
颇有些神似“三十六计”中的“金蝉脱壳”。看上去还是旧的躯壳，却已经注入了新的灵魂。
只有调用失败了，它们才会返回-1，从原程序的调用点接着往下执行。

◼ int execl(const char *path, const char *arg, .../* (char  *) NULL */);
 ◼ 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[]);
 l(list)
 v(vector)
 p(path)
 e(environment)
参数地址列表，以空指针结尾
存有各参数地址的指针数组的地址
按 PATH 环境变量指定的目录搜索可执行文件
存有环境变量字符串地址的指针数组的地址

/*
    #include <unistd.h>
    int execl(const char *pathname, const char *arg, ...);
        pathname:需要执行的文件路径或名称，建议使用绝对路径 
        arg:执行可执行文件的参数列表
            第一个参数一般没有什么用，一般写的是执行程序的文件名称
            从第二个参数开始就是程序执行所需要的参数列表，
            最后需要以NULL结束（哨兵）
        返回值：
            只有调用失败才有返回值-1，设置errrno
            调用成功，没有返回值

*/
#include<stdio.h>
#include<unistd.h>
#include <sys/types.h>
int main(){
   

    //创建子进程
    pid_t pid = fork();

    if(pid>0){
   
        //父进程
        printf("parentProcess pid: %d\n",getpid());
        sleep(1);
    }else if (pid==0){
   
        //子进程
        //execl("a","a",NULL);
        execl("/bin/ps","ps","aux",NULL);//执行shell命令 ps aux
        printf("childProcess 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:文件名 
        arg:执行可执行文件的参数列表
            第一个参数一般没有什么用，一般写的是执行程序的文件名称
            从第二个参数开始就是程序执行所需要的参数列表，
            最后需要以NULL结束（哨兵）
        返回值：
            只有调用失败才有返回值-1，设置errrno
            调用成功，没有返回值

     int execv(const char *path, char *const argv[]);
        //char *arg[]={"ps","aux",NULL};
        //execv("/bin/ps",arg);

     int execve(const char *filename, char *const argv[], char *const envp[]);
        //char *envp[]={"/bin/ps","/home/xxx","/home/lll"} //依次查找可执行文件filename 
*/
#include<stdio.h>
#include<unistd.h>
#include <sys/types.h>
int main(){
   

    //创建子进程
    pid_t pid = fork();

    if(pid>0){
   
        //父进程
        printf("parentProcess pid: %d\n",getpid());
        sleep(1);
    }else if (pid==0){
   
        //子进程
        //execl("a","a",NULL);
        //execlp("ps","ps","aux",NULL);//执行shell命令 ps aux
        char *arg[]={
   "ps","aux",NULL};
        execv("/bin/ps",arg);
        printf("childProcess pid: %d\n",getpid());
    }

    for(int i=0;i<3;i++){
   
        printf("i=%d,pid=%d\n",i,getpid());
    }
    return 0;
}

---

2.7 进程退出，孤儿进程，僵尸进程

进程退出

孤儿进程

◼ 父进程运行结束，但子进程还在运行（未运行结束），这样的子进程就称为孤儿进程
（Orphan Process）。
◼ 每当出现一个孤儿进程的时候，内核就把孤儿进程的父进程设置为 init（pid为1） ，
而 init 进程会循环地 wait() 它的已经退出的子进程。
这样，当一个孤儿进程凄凉地结束了其生命周期的时候，
init 进程就会代表党和政府出面处理它的一切善后工作。
◼ 因此孤儿进程并不会有什么危害。

僵尸进程

◼ 每个进程结束之后, 都会释放自己地址空间中的用户区数据，内核区的 PCB 没有办法
自己释放掉，需要父进程去释放。
◼ 进程终止时，父进程尚未回收，子进程残留资源（PCB）存放于内核中，变成僵尸
（Zombie）进程。
◼ 僵尸进程不能被 kill -9 杀死，这样就会导致一个问题，如果父进程不调用 wait() 
或 waitpid() 的话，那么保留的那段信息就不会释放，其进程号就会一直被占用，
但是系统所能使用的进程号是有限的，如果大量的产生僵尸进程，将因为没有可用的进
程号而导致系统不能产生新的进程，此即为僵尸进程的危害，应当避免。

---

2.8 wait()函数

◼ 在每个进程退出的时候，内核释放该进程所有的资源、包括打开的文件、占用的内存等。但是仍然为其保留一定的信息，这些信息主要主要指进程控制块PCB的信息（包括进程号、退出状态、运行时间等）。
◼ 父进程可以通过调用wait或waitpid得到它的退出状态同时彻底清除掉这个进程。
◼ wait() 和 waitpid() 函数的功能一样，区别在于，wait() 函数会阻塞，
waitpid() 可以设置不阻塞，waitpid() 还可以指定等待哪个子进程结束。
◼ 注意：一次wait或waitpid调用只能清理一个子进程，清理多个子进程应使用循环。

退出信息相关宏函数

◼ WIFEXITED(status) 非0，进程正常退出
◼ WEXITSTATUS(status) 如果上宏为真，获取进程退出的状态（exit的参数）
◼ WIFSIGNALED(status) 非0，进程异常终止
◼ WTERMSIG(status) 如果上宏为真，获取使进程终止的信号编号
◼ WIFSTOPPED(status) 非0，进程处于暂停状态
◼ WSTOPSIG(status) 如果上宏为真，获取使进程暂停的信号的编号
◼ WIFCONTINUED(status) 非0，进程暂停后已经继续运行

/*
       #include <sys/types.h>
       #include <sys/wait.h>

       pid_t wait(int *wstatus);
        //等待一个子进程结束，如结束了，该函数会回收子进程的资源 
        int *wstatus 
            进程退出时的状态信息，传入的是int类型的地址，传出参数

        返回值
            成功：返回子进程的ID
            失败：-1（所有子进程回收完毕，函数调用失败）
    调用wait函数的进程会被挂起（阻塞），
    直到它的一个子进程退出或者收到一个不能被忽视的信号时被唤醒
    如果没有了子进程，函数立刻返回-1；如果在子进程都结束了，也会返回-1
*/
#include<stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include<unistd.h>
#include<stdlib.h>
int main(){
   
    //一个父进程，创建5个子进程
    pid_t pid;
/* //不止产生5个进程
    for(int i=0;i<5;i++){
        pid=fork();
    }
*/
    for(int i=0;i<5;i++){
   
        pid=fork();
        if(pid==0){
   //子进程
            break;
        }
    }

    if(pid>0){
   //父进程
        while (1){
   
            printf("parent,pid=%d; ",getpid());
            //int ret=wait(NULL);

            int s;
            int ret=wait(&s);

            if(ret==-1){
   
                break;
            }

            if(WIFEXITED(s)){
   
                //非0，进程正常退出
                printf("退出状态码：%d\n",WEXITSTATUS(s));
            }

            if(WIFSIGNALED(s)){
   
                //是不是异常终止
                printf("异常终止：%d\n",WEXITSTATUS(s));
            }
            printf("child die,pid=%d\n",ret);
            sleep(2);
        }

        
    }else if(pid==0){
   
        //子进程
        //while (1){
   
            printf("child,pid=%d\n",getpid());
            sleep(2);
        //}
        exit(0);
        
    }
    return 0;
}

---

2.9 waitpid()函数

ps ajx //查看个进程ID
	

/*
    #include <sys/types.h>
    #include <sys/wait.h>
    pid_t waitpid(pid_t pid, int *wstatus, int options);
        回收指定进程号的子进程，可以设置是否阻塞
        pid:
            >0,某个子进程的pid
            =0，回收当前进程组的所有子进程 
            -1，回收所有的子进程，相当于wait（最常用）
            <-1, 回收某个进程组的组ID的绝对值，回收指定进程组的子进程
        options:设置阻塞或非阻塞
            0：阻塞
            WNOHANG:非阻塞
        返回值
            >0:返回子线程ID
            =0：options=WNOHANG,表示还有子进程活着
            =-1；错误，或者没有子进程了


*/
#include<stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include<unistd.h>
#include<stdlib.h>
int main(){
   
    //一个父进程，创建5个子进程
    pid_t pid;
/* //不止产生5个进程
    for(int i=0;i<5;i++){
        pid=fork();
    }
*/
    for(int i=0;i<5;i++){
   
        pid=fork();
        if(pid==0){
   //子进程
            break;
        }
    }

    if(pid>0){
   //父进程
        while (1){
   
            printf("parent,pid=%d; ",getpid());
            //int ret=wait(NULL);
            sleep(2);
            int s;
            //int ret=waitpid(-1,&s,0);  //阻塞
            int ret=waitpid(-1,&s,WNOHANG);  //非阻塞

            if(ret==-1){
   
                break;
            }

            if(ret==0){
   //说明还有子进程存在
                continue;
            }else if(ret>0){
   
                if(WIFEXITED(s)){
   
                    //非0，进程正常退出
                    printf("退出状态码：%d\n",WEXITSTATUS(s));
                }

                if(WIFSIGNALED(s)){
   
                    //是不是异常终止
                    printf("异常终止：%d\n",WEXITSTATUS(s));
                }
                printf("child die,pid=%d\n",ret);
            }
         
        }

        
    }else if(pid==0){
   
        //子进程
        //while (1){
   
            printf("child,pid=%d\n",getpid());
            sleep(2);
        //}
        exit(0);
        
    }
    return 0;
}

---

2.10 进程间通信简介

01 /
进程间通讯概念

◼ 进程是一个独立的资源分配单元，不同进程（这里所说的进程通常指的是用户进程）之间
的资源是独立的，没有关联，不能在一个进程中直接访问另一个进程的资源。
◼ 但是，进程不是孤立的，不同的进程需要进行信息的交互和状态的传递等，因此需要进程
间通信( **IPC：Inter Processes Communication** )。
◼ 进程间通信的目的：
◼ 数据传输：一个进程需要将它的数据发送给另一个进程。
◼ 通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种
事件（如进程终止时要通知父进程）。
◼ 资源共享：多个进程之间共享同样的资源。为了做到这一点，需要内核提供互斥和同
步机制。
◼ 进程控制：有些进程希望完全控制另一个进程的执行（如 Debug 进程），此时控制
进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。

2.11 匿名管道概述

匿名管道

◼ 管道也叫无名（匿名）管道，它是是 UNIX 系统 IPC（进程间通信）的最古老形式，
所有的 UNIX 系统都支持这种通信机制。
◼ 统计一个目录中文件的数目命令：ls | wc –l，为了执行该命令，shell 创建了两
个进程来分别执行 ls 和 wc。

管道的特点

◼ 管道其实是一个在内核内存中维护的缓冲器，这个缓冲器的存储能力是有限的，不同的
操作系统大小不一定相同。
◼ 管道拥有文件的特质：读操作、写操作，匿名管道没有文件实体，有名管道有文件实体，
但不存储数据。可以按照操作文件的方式对管道进行操作。
◼ 一个管道是一个字节流，使用管道时不存在消息或者消息边界的概念，从管道读取数据
的进程可以读取任意大小的数据块，而不管写入进程写入管道的数据块的大小是多少。
◼ 通过管道传递的数据是顺序的，从管道中读取出来的字节的顺序和它们被写入管道的顺
序是完全一样的。
 ◼在管道中的数据的传递方向是单向的，一端用于写入，一端用于读取，管道是半双工的。
◼ 从管道读数据是一次性操作，数据一旦被读走，它就从管道中被抛弃，释放空间以便写
更多的数据，在管道中无法使用 lseek() 来随机的访问数据。
◼ 匿名管道只能在具有公共祖先的进程（父进程与子进程，或者两个兄弟进程，具有亲缘
关系）之间使用。

---

---

2.12 父子进程通过匿名管道通信

◼ 创建匿名管道
#include <unistd.h>
 int pipe(int pipefd[2]);
 ◼ 查看管道缓冲大小命令
ulimit –a
 ◼ 查看管道缓冲大小函数
#include <unistd.h>
 long fpathconf(int fd, int name);

/*
       #include <unistd.h>
        On Alpha, IA-64, MIPS, SuperH, and SPARC/SPARC64;
         see NOTES 
       struct fd_pair {
           long fd[2];
       };
       struct fd_pair pipe();

        On all other architectures 
       int pipe(int pipefd[2]);//创建一个匿名管道，用来进程间通信
            int pipefd[2] 数组是一个传出参数
                pipefd[0] 对应管道的读端
                pipefd[1] 对应管道的写端
            返回值：
                成功0；
                失败-1，设置errno

    tips:匿名管道只能用于具有关系的进程之间的通信，父子进程，兄弟进程;
        管道默认阻塞，空时read阻塞，满时write阻塞

*/
#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>


int main(){
   
    
    //在fork之前创建管道
    int pipefd[2];
    int ret=pipe(pipefd);
    if(ret==-1){
   
        perror("pipe");
        exit(0);
    }

    //查看管道大小
    long size=fpathconf(pipefd[0], _PC_PIPE_BUF);
    printf(<