Linux系统编程——进程控制

在学习Linux系统编程总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。

09-linux-day05(进程控制)

目录：
一、学习目标
二、进程
1、进程和程序
2、单道和多道程序设计
3、进程的状态转化
4、MMU 的作用
5、PCB的概念
6、获取环境变量
7、进程控制函数fork
8、fork创建子进程
9、进程控制的命令
10、创建n个子进程
11、循环创建n个子进程控制顺序
12、父子进程共享的内容
13、父子进程不共享全局变量
14、execlp函数介绍
15、exec函数规律
16、exel实现自定义程序
17、孤儿进程与僵尸进程
18、wait函数简单使用和说明
19、wait回收并且查看死亡原因
20、waitpid回收子进程
21、用wait回收多个子进程
22、waitpid回收多个子进程

一、学习目标

1、了解进程相关的概念

2、掌握fork/getpid/getppid函数的使用

3、熟练掌握ps/kill命令的使用

4、熟练掌握execl/execlp函数的使用

5、说出什么是孤儿进程什么是僵尸进程

6、熟练掌握wait函数的使用

7、熟练掌握waitpid函数的使用

二、进程

1、进程和程序

什么是程序？编译好的二进制文件。

什么是进程？运行着的程序。

　　站在程序员的角度：运行一系列指令的过程。

　　站在操作系统角度：分配系统资源的基本单位。

区别：

　　程序占用磁盘，不占用系统资源。

　　进程占用系统资源。

　　一个程序对应多个进程，一个进程对应一个程序。

 　　程序没有生命周期，进程有生命周期。

2、单道和多道程序设计

3、进程的状态转化

进程的状态切换

4、MMU 的作用

》MMU作用：1）虚拟内存和物理内存的映射；2）修改内存访问级别

用户空间映射到物理内存是独立的。

5、PCB的概念

Linux内核的进程控制块是task_struct结构体。

查找结构体：

> sudo grep -rn "struct task_struct {" /usr/

技巧：光标停留在{上，按%，可以到结构体的结尾。（400多行）

查看进程的资源上限：

>ulimit -a

6、获取环境变量

查看所有的环境变量：（写法：key=value，且等号两端不能有空格）

>env

常见的环境变量：

>echo $HOME

>echo $PATH

》getenv函数——获取环境变量

man 2 getenv

char *getenv(const char *name);

>touch getenv.c

>vi getenv.c

#include<stdio.h>
#include<stdlib.h>

int main()
{
    printf("homepath is [%s]
", getenv("HOME"));
    return 0;
}

>make

>./getenv

》setenv函数——设置环境变量的值

man 2 setenv

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

　　参数overwrite取值：1-覆盖原环境变量；0-不覆盖（该参数常用于设置新环境变量。）

一般配置（.bashrc）文件!（如：export key=val;）

》unsetenv函数——删除环境变量name的定义

man 2 unsetenv

int unsetenv(const char *name);

　　注意事项：name不存在仍返回0（成功），当name命名为“ABC=”时则会出错!

7、进程控制函数fork

>touch fork.c

>vi fork.c

#include<stdio.h>
#include<unistd.h>

int main()
{
    printf("Begin ....
");//此处缺少“
”结果会不一样，这是由于printf有缓冲区机制，往屏幕上输出，会有行缓冲
    pid_t pid = fork();
    printf("End ....
");
    return 0;
}

>make

>./fork

（可以知道结束了两个进程。）

》getpid获得当前进程的PID和进程ID，，getppid——获得当前进程父进程的ID

man getpid

pid_t getpid(void);

pid_t getppid(void);

8、fork创建子进程

>vi fork.c

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>

int main()
{
    printf("Begin ....
");
    pid_t pid = fork();
    if(pid < 0){
        perror("fork err");
        exit(1);
    }
    if(pid == 0){
        //子进程
        printf("I am a child,pid = %d,ppid = %d
",getpid(), getppid());
    }
    else if(pid > 0){
        //父进程的逻辑
        printf("childpid=%d,self=%d,ppid=%d
",pid,getpid(),getppid());
        sleep(1);//让父进程等待一段时间，再死去。
    }
    
    printf("End ....
");
    return 0;
}

>make

>./fork

9、进程控制的命令

>vi fork.c

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>

int main()
{
    printf("Begin ....
");
    pid_t pid = fork();
    if(pid < 0){
        perror("fork err");
        exit(1);
    }
    if(pid == 0){
        //子进程
        printf("I am a child,pid = %d,ppid = %d
",getpid(), getppid());
        while(1){
            printf("I am a child
");
            sleep(1);
        }
    }
    else if(pid > 0){
        //父进程的逻辑
        printf("childpid=%d,self=%d,ppid=%d
",pid,getpid(),getppid());
        while(1){
            sleep(1);
        }
    }
    
    printf("End ....
");
    return 0;
}

>make

>./fork

让子进程一直保持运行，打开另一个终端查看PPID和PID分析：

》ps aux——查看进程相关信息的指令

》ps ajx——可以查看更多进程相关的信息，从而追溯进程之间的血缘关系

可以看到PPID、PID，可以看出shell进程是所有进程的父亲，继续追溯，可以看到最终父进程是init

（init进程是所有进程的祖先！）

>kill -9 2890

>ps ajx

杀死了父进程，init成为子进程2891新的父亲。

>kill 2891

杀死子进程

》kill指令——给进程发送一个信号

　　kill -l 查看信号相关的信息

　　SIGKILL 9号信号

　　kill -9 pid——杀死进程

10、创建n个子进程

需求：让父进程创建n个子进程

>touch nfork.c

>vi nfork.c

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>

int main()
{
    int n = 5;
    int i = 0;
    pid_t pid = 0;
    for(i = 0; i < 5; i++){//父进程循环结束
        pid = fork();
        if(pid == 0){
            //son
            printf("I am child, pid=%d,ppid=%d
",getpid(),getppid());
            //break;//子进程退出循环的接口
        }
        else if(pid > 0){
            //father
            printf("I am father, pid=%d,ppid=%d
",getpid(),getppid());
        }
    }
    while(1){
        sleep(1);
    }
    return 0;
}

>gcc nfork.c

>./a.out

>ps aux | grep a.out |grep -v grep | wc -l

（创建了32个进程！）

11、循环创建n个子进程控制顺序

》需求：精确控制各个子进程

>touch nfork1.c

>vi nfork1.c

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>

int main()
{
    int n = 5;
    int i = 0;
    pid_t pid = 0;
    for(i = 0; i < 5; i++){//父进程循环结束
        pid = fork();
        if(pid == 0){
            //son
            printf("I am child, pid=%d,ppid=%d
",getpid(),getppid());
            break;//子进程退出循环的接口
        }
        else if(pid > 0){
            //father
            //printf("I am father, pid=%d,ppid=%d
",getpid(),getppid());
        }
    }
    
    sleep(i);
    if(i < 5){
        printf("I am child, will exit,pid=%d,ppid=%d
",getpid(),getppid());
    }
    else{
        //father
        printf("I am parent, will out,pid=%d,ppid=%d
",getpid(),getppid());
    }
    
    return 0;
}

>gcc nfork1.c

>./a.out

（创建了5个进程！）

12、父子进程共享的内容

13、父子进程不共享全局变量

>touch shared.c

>vi shared.c

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>

int var = 100;

int main()
{
    pid_t pid = fork();
    if(pid == 0){
        //son
        printf("var = %d,child,pid=%d,ppid=%d
",var,getpid(),getppid());
        var = 1001;
        printf("var = %d,child,pid=%d,ppid=%d
",var,getpid(),getppid());
    }
    else if(pid > 0){
        //parent
        sleep(1);//保证子进程能够修改var的值成功
        printf("var = %d,parent,pid=%d,ppid=%d
",var,getpid(),getppid());
    }
    
    return 0;
}

（让子进程改，看结果）

>gcc shared.c

>./a.out

（让父进程改，看结果）

>vi shared.c

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>

int var = 100;

int main()
{
    pid_t pid = fork();
    if(pid == 0){
        //son
        printf("var = %d,child,pid=%d,ppid=%d
",var,getpid(),getppid());
        var = 1001;
        printf("var = %d,child,pid=%d,ppid=%d
",var,getpid(),getppid());
        sleep(3);
        printf("var = %d,child,pid=%d,ppid=%d
",var,getpid(),getppid());
    }
    else if(pid > 0){
        //parent
        sleep(1);//保证子进程能够修改var的值成功
        printf("var = %d,parent,pid=%d,ppid=%d
",var,getpid(),getppid());
        var = 2000;
        printf("var = %d,parent,pid=%d,ppid=%d
",var,getpid(),getppid());
    }
    
    return 0;
}

>gcc shared.c

>./a.out

》结论：即使是全局变量，父子进程也不共享。（读时共享，写时复制。）

14、execlp函数介绍

>man execl

》execl作用：执行其他程序

int execl(const char *path,const char *arg,...) /*(char *)NULL*/

》exelp作用：执行程序的时候，使用PATH环境变量，执行的程序可以不用加路径

int execlp(const char *file,const char *arg,...) /*(char *)NULL */

　　file 要执行的程序

　　arg 参数列表

　　参数列表最后需要一个NULL作为结尾（哨兵）

　　返回值：只有失败才返回

>touch execl.c

>vi execl.c

#include<stdio.h>
#include<unistd.h>

int main()
{
    //int execlp(const char *file,const char *arg,...) /*(char *)NULL */
    execlp("ls", "ls", "-l", "--color=auto",NULL);//如果使其执行错误，返回，把第一个ls改为非法的lsxxx
    //不需要判断返回值
    perror("exec err");
    return 0;
}

>gcc execl.c

>./a.out

>vi execl.c

#include<stdio.h>
#include<unistd.h>

int main()
{
    //int execlp(const char *file,const char *arg,...) /*(char *)NULL */
    //execlp("ls", "ls", "-l", "--color=auto",NULL);
    execl("/bin/ls", "ls", "-l", "--color=auto",NULL);
    //不需要判断返回值
    perror("exec err");
    printf("hello
");
    return 0;
}

>gcc execl.c

>./a.out

15、exec函数规律

16、exel实现自定义程序

>touch fpe.c

>vi fpe.c

#include<stdio.h>
#include<unistd.h>

int main()
{
    int a = 10;
    int b = a/0;
    return 0;
}

>make

>./fpe

（报错：浮点数例外(核心已转储)）

>touch execl.c

>vi execl.c

#include <stdio.h>
#include <unistd.h>

int main()
{
    execl("./fpe", "fpe", NULL);
    
    printf("bye bye!
");
    return 0;
}

>gcc execl.c

>./a.out

（报错：浮点数例外(核心已转储)）

17、孤儿进程与僵尸进程

》孤儿进程：父亲死了，子进程被init进程领养。

》僵尸进程：子进程死了，父进程没有回收子进程的资源（PCB）。

>touch orphan.c

>vi orphan.c

#include<stdio.h>
#include<unistd.h>

int main()
{
    pid_t pid = fork();
    if(pid == 0){
        //子进程
        while(1){
            printf("I am a child,pid=%d,ppid=%d
",getpid(), getppid());
            sleep(1);
        }
    }
    else if(pid > 0){
        //父进程的逻辑
        printf("I am parent,pid=%d,ppid=%d
",getpid(),getppid());
        sleep(5);
        printf("I am parent,I will die!
")
    }
    
    printf("End ....
");
    return 0;
}

>gcc orphan.c

>./a.out

（Ctrl+c无法结束子进程，因为子进程脱离shell，只能打开另一个终端，ps ajx查看pid，然后用kill -9 pid杀死）

>touch zoombie.c

>vi zoombie.c

#include<stdio.h>
#include<unistd.h>

int main()
{
    pid_t pid = fork();
    if(pid == 0){
        //子进程
        printf("I am child,pid=%d,ppid=%d
",getpid(), getppid());
        sleep(2);
        printf("I am child,I will die
");
    }
    else if(pid > 0){
        //父进程的逻辑
        while(1){
            printf("I am parent,pid=%d
",getpid());
            sleep(1);    
        }
    }
    return 0;
}

>gcc orphan.c

>./a.out

（打开另一个终端查看 >ps aux | grep a.out）

（如果想研究下，使用man ps查看，然后用/zombie定位到）

》如何回收僵尸进程资源？

杀死父亲，init领养，负责回收。

18、wait函数简单使用和说明

》wait作用：1）阻塞等待；2）回收子进程资源；3）知道子进程的死亡原因

man 2 wait

pid_t wait(int *status);

　　status 传出参数

　　返回值：成功返回终止的子进程ID，失败返回-1

子进程的死亡原因：

　　正常死亡 WIFEXITED

　　　　如果WIFEXITED为真，使用WEXITSTATUS得到退出状态。

　　非正常死亡WIFSIGNALED

　　　　如果WIFSIGNALED为真，使用WTERMSIG得到信号

19、wait回收并且查看死亡原因

>touch wait.c

>vi wait.c

#include<stdio.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>

int main()
{
    pid_t pid = fork();
    if(pid == 0){
        //子进程
        printf("I am child,I will die
");
        sleep(2);
        while(1){//迁怒，等待kill杀死，非正常死亡
            printf("I am child,guo lai da wo!
");
            sleep(1);
        }
        //正常死亡的两种情况
        //return 101;
        //exit(101);
    }
    else if(pid > 0){
        //父进程的逻辑
        printf("I am parent,wait for child die!
");
        int status;
        
        pid_t wpid = wait(&status);
        printf("wait ok,wpid=%d,pid=%d
",wpid,pid);
        if(WIFEXITED(status)){
            printf("child exit with %d
",WEXITSTATUS(status));
        }
        if(WIFSIGNALED(status)){
            printf("child killed by %d
",WTERMSIG(status));
        }
        while(1){
            sleep(1);    
        }
    }
    return 0;
}

>gcc wait.c

>./a.out

（打开另一个终端，使用ps aux|grep a.out查看pid，然后用kill -9 pid杀死子进程，原终端将会收到：child killed by 9；用kill pid杀死子进程，原终端将会收到：child killed by 15）

20、waitpid回收子进程

man waitpid

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

　　pid

　　　　<-1 组id

　　　　1 回收任意

　　　　0 回收和调用进程组id相同组内的子进程

　　　　>0 回收指定的pid

　　options

　　　　0与wait相同，也会阻塞

　　　　WNOHANG 如果当前没有子进程退出的，会立刻返回

　　返回值

　　　　如果设置了WNOHANG，那么如果没有子进程退出，返回0

　　　　　　如果有子进程退出，返回退出的pid

　　　　失败返回-1（没有子进程）

>touch waitpid.c

>vi waitpid.c

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

int main()
{
    pid_t pid = fork();
    if(pid == 0){
        //子进程
        printf("I am child,pid=%d
",getpid());
        sleep(2);
    }
    else if(pid > 0){
        //父进程的逻辑
        printf("I am parent,pid=%d
",getpid());
        
        int ret;
        while((ret = = waitpid(-1,NULL,WNOHANG)) == 0){
            sleep(1);
        }
        printf("ret = %d
",ret);
        ret = waitpid(-1,NULL,WNOHANG);
        if(ret < 0){
            perror("wait err");
        }
        while(1){
            sleep(1);
        }
    }
    return 0;
}

>gcc waitpid.c

>./a.out

21、用wait回收多个子进程

>touch nfork_wait.c

>vi nfork_wait.c

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

int main()
{
    int n = 5;
    int i = 0;
    pid_t pid;
    for(i = 0; i < 5; i++){
        pid = fork();
        if(pid == 0){
            printf("I am child,pid=%d
",getppid());
            break;
        }
    }
    sleep(i);
    if(i == 5){
        for(i = 0; i < 5; i++){
            pid_t wpid = wait(NULL);
            printf("wpid = %d
",wpid);
        }
        while(1){
            sleep(1);
        }
    }
    return 0;
}

>gcc nfork_wait.c

>./a.out

（打开另一个终端，使用ps aux|grep a.out查看pid，看回收是否成功）

22、waitpid回收多个子进程

>touch nfork_waitpid.c

>vi nfork_waitpid.c

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

int main()
{
    int n = 5;
    int i = 0;
    pid_t pid;
    for(i = 0; i < 5; i++){
        pid = fork();
        if(pid == 0){
            printf("I am child,pid=%d
",getppid());
            break;
        }
    }
    if(i == 5){
        //parent
        printf("I am parent!
");
        //如何使用waitpid回收？-1代表子进程都死了，都回收了
        while(1){
            pid_t wpid = waitpid(-1, NULL, WNOHANG);
            if(wpid == -1){
                break;
            }
            else if(wpid > 0){
                printf("waitpid wpid=%d
",wpid);
            }
        }
        while(1){
            sleep(1);
        }
    }
    if(i < 5){
        //sleep(i);
        printf("I am child,i = %d,pid=%d
",i,getpid());
    }
    return 0;
}

>gcc nfork_waitpid.c

>./a.out

（打开另一个终端，使用ps aux|grep a.out查看pid，看回收是否成功）

》作业

>touch fork_write.c

>vi fork_write.c

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

int main(int argc,char *argv[])
{
    if(argc != 2){
        printf("./a.out filename
");
        return -1;
    }
    int fd = open(argv[1],O_RDWR);
    if(fd < 0){
        perror("open err");
        exit(1);
    }
    pid_t pid = fork();
    if(pid == 0){
        //son
        write(fd,"hello
",6);
    }
    else if(pid > 0){
        //parent
        sleep(1);
        write(fd,"world
",6);
        wait(NULL);
    }
    
    return 0;
}

>touch 11

>make

>ls -lrt

>./fork_write 11

>cat 11

1 hello
2 world

（没有覆盖，说明写时共享文件描述符，读写位置一样，一个进程写了，读写位置改变了，另一个进程受影响，所以可以跟着写。）

在学习Linux系统编程总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。