Linux系统编程——进程的学习

Linux系统编程学习相关博文

1. Linux系统编程——文件编程的学习
2. Linux系统编程——进程间通信的学习
3. Linux系统编程——线程的学习
4. Linux系统编程——网络编程的学习

一、相关概述

常规学习Linux系统编程的内容是复杂且繁多的，不推荐刚开始接触代码的朋友去学习，所以介绍Linux系统编程的目的主要是以应用开发为主。

1. 什么是程序，什么是进程，有什么区别？

1. 程序是静态的概念，gcc xxx.c -o pro 磁盘中生成pro文件，叫做程序
2. 进程是程序的一次运行活动，通俗点讲就是程序跑起来了，系统中就多了一个进程

2. 如何查看系统中有哪些进程？

1. 使用ps指令查看
   实际工作中，配合grep来查找程序中是否存在某一个进程
2. 使用top指令查看，类似windows任务管理器

3. 什么是进程标识符？

1. 每个进程都有一个非负整数表示的唯一ID，叫做pid，类似身份证
2. pid = 0/1/2是三个特殊的进程ID，它们的进程id一定是唯一的

	1) Pid = 0，交换进程(swapper)
		作用——进程调度
	2) Pid = 1，init进程
		作用1. 系统初始化
		作用2. 托管孤儿进程
		作用3. 原始父进程
	3) Pid = 2，守护进程
		作用——系统初始化

4. 什么叫父进程，什么叫子进程？

进程A创建了进程B，那么A叫做父进程，B叫做子进程，父子进程是相对的概念，理解为现实中的父子关系

5. C程序的存储空间是如何分配？

(头)命令行参数和环境变量：例如argc，argv
栈：函数调用以及函数的一些局部变量产生的信息放到栈里面
堆：malloc申请空间在堆里面申请
bss段：在函数外，未被初始化的叫做bss段
数据段：初始化过的叫做数据段
(尾)代码段：在程序中，一些if，else，switch，for等等都是属于代码段

6. fork函数创建子进程的目的

1. 一个父进程希望复制自己，使父、子进程同时执行不同的代码段。这在网络服务进程中是最常见的——父进程等待客户端的服务请求。当这种请求到达时，父进程调用fork，使子进程处理此请求。父进程则继续等待下一个服务请求到达
2. 一个进程要执行一个不同的程序。这对shell是常见的情况。在这种情况下，子进程从fork返回后立即调用exec

7. vfork函数也可以创建进程，与fork函数有什么区别？

1. 关键区别一：vfork直接使用父进程存储空间，不拷贝
2. 关键区别二：vfork保证子进程先运行，当子进程调用exit退出后，父进程才执行

8. 进程退出情况

1. 正常退出

	1) Main函数调用return     
	2) 进程调用exit0，标准c库 
	3) 进程调用_exit()或者_Exit0()，属于系统调用

补充：
	1) 进程最后一个线程返回
	2) 最后一个线程调用pthread_exit

2. 异常退出

	1) 调用abort
	2) 当进程收到某些信号时，如ctrl+C
	3) 最后一个线程对取消（cancellation）请求做出响应

3. 不管进程如何终止，最后都会执行内核中的同一段代码。这段代码为相应进程关闭所有打开描述符，释放它所使用的存储器

4. 上述任意一种终止情形，我们都希望终止进程能够通知其父进程它是如何终止的。对于三个终止函数 (exit、_exit和_Exit)，实现这一点的方法是，将其退出状态 (exit status)作为参数传送给函数。在异常终止情况下，内核(不是进程本身)产生一个指示其异常终止原因的终止状态(termination status)。在任意一种情况下，该终止进程的父进程都能用wait或waitpid函数取得其终止状态

9. 为什么要等待子进程退出？

1. 父进程要等待子进程退出并收集子进程的退出状态
2. 子进程退出状态不被收集，子进程变成僵死进程（僵尸进程）

10. 什么是孤儿进程？

1. 父进程如果不等待子进程退出，在子进程之前就结束了自己的"生命"，此时子进程叫做孤儿进程
2. Linux避免系统存在过多孤儿进程，init进程收留孤儿进程，变成孤儿进程的父进程

11. 为什么要用exec族函数，有什么作用？

我们用fork函数创建新进程后，经常会在新进程中调用exec函数去执行另外一个程序。当进程调用exec函数，该进程被完全替换为新程序。调用exec函数并不创建新进程，所以前后进程的ID并没有改变

12. wait和waitpid的区别

waip使调用者阻塞，waitpid有一个选项，可以使调用者不阻塞

二、进程API

在Linux系统中，操作系统提供了一系列的API，详细看下图

获取自身的进程标识符		getpid()
获取父进程的进程标识符	getppid()
创建一个进程		fork() / vfork()
进程退出			exit() / _exit() / _Exit()
父进程等待子进程退出并收集子进程的退出状态		wait() / waitpid()
exec族函数		execl() / execlp() / execv() / execvp()
运行指令			system()
获取运行指令后的输出结果		popen()

三、API介绍

1. getpid函数

#include 
#include 

pid_t getpid(void);

1. 函数功能：获取进程ID
2. 返回值：返回调用进程的进程ID

2. getppid函数

#include 
#include 

pid_t getppid(void);

1. 函数功能：获取父进程ID.
2. 返回值：返回调用进程的父进程ID

3. fork函数

#include 

pid_t fork(void);

1. 函数功能：创建子进程，父、子进程运行顺序由自己争抢
2. 返回值：如果成功，则在父进程中返回子进程的PID，并在子进程中返回0。如果失败，在父进程中返回-1，不创建子进程，并适当设置errno

4. vfork函数

#include 
#include 

pid_t vfork(void);

1. 函数功能：创建子进程，子进程先运行，子进程退出后父进程再运行
2. 返回值：如果成功，则在父进程中返回子进程的PID，并在子进程中返回0。如果失败，在父进程中返回-1，不创建子进程，并适当设置errno

5. exit函数

#include 

void exit(int status);

1. 函数功能：使进程退出，并返回退出时的状态
2. 形参说明：
status：退出状态

6. _exit函数

#include 

void _exit(int status);

1. 函数功能：使进程退出，并返回退出时的状态
2. 形参说明：
status：退出状态

7. _Exit函数

#include 

void _Exit(int status);

1. 函数功能：使进程退出，并返回退出时的状态
2. 形参说明：
status：退出状态

8. wait函数

#include 
#include 

pid_t wait(int *status);

1. 函数功能：使父进程进入阻塞状态，等待子进程退出后父进程再运行，获取子进程退出时的状态
2. 形参说明：
status：一个整型数指针
		空：不关心退出状态
		非空：子进程退出状态放在它所指向的地址中
3. 返回值：如果成功，返回终止子进程的进程ID，如果出错，则返回-1

9. waitpid函数

#include 
#include 

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

1. 函数功能：在wait函数功能的前提下，增加了pid，options两个形参设置函数的工作模式，获取子进程退出时的状态
2. 形参说明：
pid：作用解释如下
	pid = -1	等待任一子进程。就这一方面而言，waitpid与wait等效。
	pid > 0		等待其进程ID与pid相等的子进程。
	pid = 0		等待其组ID等于调用进程组ID的任一子进程。
	pid < -1	等待其组ID等于pid绝对值的任一子进程。
status：一个整型数指针
		空：不关心退出状态
		非空：子进程退出状态放在它所指向的地址中
options：WCONTINUED	————若实现支持作业控制，那么由皮带指定的任一子进程在暂停后已经继续，但其状态尚未报告，则返回其状态
		 WNOHANG	————若由pid指定的子进程并不是立即可用的，则waitpid不阻塞，此时其返回值为0
		 WUNTRACED	————若某实现支持作业控制，而由pid指定的任一子进程已处于暂停状态，并且其状态自暂停以来还未报告过，则返回其状态。WIFSTOPPED宏确定返回值是否对应于一个暂停子进程
3. 返回值：返回状态发生变化的子进程的进程ID;如果指定了WNOHANG，并且存在一个或多个由pid指定的子，但尚未改变状态，则返回0。如果出现错误，则返回-1

检查wait和waitpid所返回的终止状态的宏

宏	说明
WIFEXITED(status)	若为正常终止子进程返回的状态，则为真。对于这种情况可执行WEXITSTATUS(status)。取子进程传送给exit,_exit或_Exit参数的低8位
WIFSIGNALED(status)	若为异常终止子进程返回的状态，则为真(接到一个不捕捉的信号),对于这种情况，可执行WTERMSIG(status)，取使子进程终止的信号编号。另外，有些实现(非Single UNIX Specification)定义宏WCOREDUMP(status，若已产生终止进程的core文件，则它返回真
WIFSTOPPED(status)	若为当前暂停子进程的返回的状态，则为真。对于这种情况,可执行WSTOPSIG(status)，取使子进程暂停的信号编号
WIFCONTINUED(status)	若在作业控制暂停后已经继续的子进程返回了状态，则为真

10. exec族函数

execle，execvpe两个函数这里不做介绍
exec族函数详细介绍博文

#include 

extern char **environ;

int execl(const char *path, const char *arg, ...);
int execlp(const char *file, const char *arg, ...);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);

1. 函数功能：在进程里执行一个不同的程序。子进程从fork返回后调用立即调用exec函数
2. 形参说明：
path：可执行文件的路径名字
arg：可执行程序所带的参数，第一个参数为可执行文件名字，没有带路径且arg必须以NULL结束
file：如果参数file中包含/，则就将其视为路径名，否则就按PATH环境变量，在它所指定的各目录中搜寻可执行文件
argv：与execl类函数不同，execv类函数是将需要写入的参数提前写进数组里边，然后将数组的地址做为函数的参数
3. 返回值：exec()函数只在发生错误时返回，设置errno并返回-1表示错误，随后回到原程序接着往下执行。成功时不返回原程序

11. syetem函数

#include 

int system(const char *command);

1. 函数功能：运行指令
2. 形参说明：
command：需要执行的命令
3. 返回值：如果出现错误，返回值为-1，否则返回命令的状态。system()不会影响任何其他子进程的等待状态

12. popen函数

popen函数详细介绍博文

#include 

FILE *popen(const char *command, const char *type);

1. 函数功能：将运行的指令结果存放于一个文件，并以写入或读取方式打开该文件
2. 形参说明：
command：需要执行的命令
type：只能是读或者写中的一种，得到的返回值（标准 I/O 流）也具有和 type 相应的只读或只写类型。如果 type 是 “r” 则文件指针连接到 command 的标准输出；如果 type 是 “w” 则文件指针连接到 command 的标准输入
3. 返回值：成功，返回一个打开文件的指针，失败，返回NULL。具体错误要根据errno判断

13. pclose

#include 

int pclose(FILE *stream);

1. 函数功能：关闭打开的文件指针
2. 形参说明：
stream：需要关闭的文件指针
3. 返回值：返回错误或检测到其他错误，返回-1

四、API的使用例子

1. fork函数

#include 

#include 
#include 

int main()
{
    pid_t pid;

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

    if(pid > 0){  //pid > 0为父进程
        while(1){
            printf("this is father print, pid is %d\n", getpid()); //打印父进程的pid
            sleep(1);
        }
    }
    else if(pid == 0){ //pid = 0为子进程
        while(1){
            printf("this is child print, pid is %d\n", getpid()); //打印子进程的pid
            sleep(1);
        }
    }

    return 0;
}

2. vfork函数

#include 
#include 

#include 
#include 

int main()
{
    int cnt = 0;

    pid_t pid;

    pid = vfork(); //创建子进程

    if(pid > 0){ //pid > 0为父进程
        while(1){
            printf("this is father print, pid is %d\n", getpid()); //打印父进程的pid
            sleep(1);
            printf("cnt = %d\n", cnt); //打印cnt的值
        }
    }
    else if(pid == 0){ //pid > 0为父进程
        while(1){
            printf("this is child print, pid is %d\n", getpid()); //打印子进程的pid
            sleep(1);

            if(++cnt == 3){ //当cnt = 3时子进程退出
                exit(0);
            }
        }
    }

    return 0;
}

3. wait函数

#include 
#include 

#include 
#include 

int main()
{
    int cnt = 0;
    int status = 10;

    pid_t pid;

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

    if(pid > 0){  //pid > 0为父进程
        wait(&status); //父进程等待子进程退出并收集子进程的退出状态
        printf("child quit, get child status = %d\n", WEXITSTATUS(status)); //直接打印status值显示的是不正常的值，需要使用WEXITSTATUS宏获取子进程的退出状态

        while(1){
            printf("this is father print, pid = %d\n", getpid()); //打印父进程的pid
            sleep(1);
        }
    }
    else if(pid == 0){ //pid = 0为子进程
        while(1){
            printf("this is child print, pid = %d\n",getpid()); //打印子进程的pid
            sleep(1);
            if(++cnt == 3){ //cnt = 3时子进程退出
                exit(3); //子进程退出，并返回退出状态
            }
        }
    }

    return 0;
}

4. waitpid函数

#include 
#include 

#include 
#include 

int main()
{
    int cnt = 0;
    int status = 10;

    pid_t pid;

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

    if(pid > 0){
        //wait(&status);
        waitpid(pid, &status, WNOHANG); //等待其进程ID与pid相等的子进程并获取它的退出状态，waitpid为非阻塞状态
        printf("child quit, get child status = %d\n", WEXITSTATUS(status)); //直接打印status值显示的是不正常的值，需要使用WEXITSTATUS宏获取子进程的退出状态

        while(1){
            printf("this is father print, pid = %d\n", getpid()); //打印父进程的pid
            sleep(1);
        }
    }
    else if(pid == 0){
        while(1){
            printf("this is child print, pid = %d\n",getpid()); //打印子进程的pid
            sleep(1);
            if(++cnt == 3){ //cnt = 3时子进程退出
                exit(3); //子进程退出，并返回退出状态
            }
        }
    }

    return 0;
}

5. exec族函数

1) execl函数

#include 
#include 
#include 

int main(void)
{
    printf("before execl\n");

    if(execl("/bin/ls", "ls", NULL, NULL) == -1) //输出ls指令，第一个NULL可以传参，结尾参数必须为NULL
    {
        printf("execl failed!\n");
        perror("why");
    }

    printf("after execl\n");

    return 0;
}

2) execlp函数

#include 
#include 
#include 

int main(void)
{
    printf("before execlp\n");

    if(execlp("ls", "ls", NULL, NULL) == -1) //输出ls指令，第一个NULL可以传参，结尾参数必须为NULL
    {
        printf("execl failed!\n");
        perror("why");
    }

    printf("after execlp\n");

    return 0;
}

3) execv函数

#include 
#include 
#include 

int main(void)
{
    printf("before execv****\n");

    char *argv[] = {"ps", "-l", NULL}; //将参数写进数组

    if(execv("/bin/ps", argv) == -1)
    {
        printf("execv failed!\n");
    }

    printf("after execv*****\n");

    return 0;
}

4) execvp函数

#include 
#include 
#include 

int main(void)
{
    printf("before execv****\n");

    char *argv[] = {"ps", "-l", NULL}; //将参数写进数组

    if(execv("ps", argv) == -1)
    {
        printf("execv failed!\n");
    }

    printf("after execv*****\n");

    return 0;
}

6. system函数

#include 
#include 
#include 

int main(void)
{
    printf("before system\n");

    if(system("ps -aux") == -1) //运行ps -aux指令
    {
        printf("execl failed!\n");
        perror("why");
    }

    printf("after system\n");

    return 0;
}

7. popen函数

#include 
#include 
#include 

int main()
{
    FILE *fp;

    char str[1024] = {0};

    fp = popen("ps", "r"); //以读取方式打开输出ps命令后的文件指针

    int n_read = fread(str, 1, 1024, fp); //把输出ps后的结果写进str

    printf("read %d byte, get content is\n%s", n_read, str); //打印输出ps后的结果

    pclose(fp); //关闭文件指针

    return 0;
}

五、学习感悟

1. fork函数调用一次，但返回两次，两次返回唯一的区别是子进程的返回值是0，而父进程的返回值是新子进程的进程ID。
2. 将子进程ID返回给父进程的理由是：因为一个进程的子进程可以有多个，而且没有一个函数可以获得所有子进程的进程ID。
3. fork使子进程得到返回值0的理由是：0是由内核交换进程使用，它不可能做为一个子进程的进程ID。
4. 调用fork函数后，子进程和父进程继续执行fork调用之后的指令。子进程是父进程的副本。例如，子进程获得父进程数据空间(即数据段)，堆和栈的副本。注意，这是子进程所拥有的副本。父、子进程不共享这些存储空间部分。父、子进程共享正文段(即代码段)
5. 由于在fork之后经常跟随着exec，所以现在的很多实现并不执行一个父进程数据段、堆和栈的完全复制。作为替代，使用了写时复制技术(即写时拷贝)。这些区域由父、子进程共享，而且内核将它们的访问权限改变为只读的。如果父、子进程中的任一个试图修改这些区域，则内核只为修改区域的那块内存制作一个副本，通俗点讲就是假如我们要修改一个变量的值，内核只会把我们要更改的变量拷贝一份出来，供我们在上面去修改，不会改变原来区域变量的值
6. 父进程调用waitpid函数在非阻塞情况下获取子进程终止状态( 子进程正常退出 )还是会令子进程变为僵尸进程