Linux之进程控制详解

进程控制

进程创建

进程创建的最常见的两种场景：

1、命令行启动命令(程序、指令等)

2、通过程序自身fork出来子进程

fork函数初识

在linux中fork函数时非常重要的函数，fork创建子进程是以父进程为"模板"的，很多数据代码继承父进程，它从已存在进程中创建一个新进程。新进程为子进程，而原进程为父进程。

#include<iostream>
#include<unistd.h>
#include<sys/types.h>
using namespace std;
int main()
{
    cout<<"I am a process: "<<getpid()<<endl;
    pid_t id = fork();
    if(id < 0)
    {
        cerr<<"fork error"<<endl;
        return 1;
    }
    else if(id == 0)
    {
        //child
        cout<<"I am son ："<<getpid()<<endl;
        sleep(5);
    }
    else
    {
        //parent
        cout<<"I am father"<<getpid()<<" My son pid："<<id<<endl;
        sleep(5);
    }
    return 0;
}

返回值：子进程中返回0，父进程返回子进程id，出错返回-1

为什么是这样呢？任何孩子都有唯一的父亲，一个父亲可能有多个孩子，父亲需要标识孩子。所以子进程中返回0，父进程返回子进程id

进程调用fork，当控制转移到内核中的fork代码后，内核做：

• 分配新的内存块和内核数据结构给子进程
• 将父进程部分数据结构内容拷贝至子进程

将父进程的PCB、地址空间、页表的相关内容拷贝给子进程，但并不是所有都拷贝，比如pid

• 添加子进程到系统进程列表当中
• fork返回，开始调度器调度

fork函数返回值

子进程返回0

父进程返回的是子进程的pid

为什么会有两个返回值呢？

fork之后会进入内核，fork函数的实现进行申请内存构建数据结构PCB，虚拟内存，页表，最后将当前新进程设置为R状态，放置进调度列表中，此时进程已经创建成功了，父子进程共享代码，fork函数的最后一个代码是返回一个值，return ret这个代码父子进程都会执行一次，所以会有两个返回值

在返回时，将函数的返回值返回给变量，发生了写时拷贝，一个变量名但是内容是不同的，本质父子页表映射数据到了不同的内存区域

写时拷贝

在不写入的情况下，父子进程共享代码和数据：

#include<stdio.h>
#include<unistd.h>
int main()
{
    const char *str = "hello world";
    fork();
    while(1)
    {
        printf("ppid:%d,pid: %d,str: %s\n",getppid(),getpid(),str);
        sleep(1);
    }
    return 0;
}

可以看到代码每次执行了两次，其实是两个进程在执行

其中，默认情况下，父子进程共享代码，但是数据是各自私有一份的

代码共享：所有代码共享，因为程序计数器的原因，一般都是从fork之后开始执行，那么为什么代码要共享呢？因为代码是不可以被修改的，所以各自私有浪费空间。为什么数据要私有一份呢？因为进程之间具有独立性，如果父进程正在执行，子进程将父进程的数据改了，那就影响到了父进程。

为什么要有写时拷贝？

一个进程当中数据是有很多的，不是所有的数据都是立马使用的，并且不是所有的数据都需要进行拷贝，但是父子进程之间要独立的话，就必须将数据全部拷贝，但是这样有一个问题：把本来可以在之后拷贝的，甚至不需要拷贝的数据都拷贝了，浪费了时间和空间。fork时，创建数据结构，如果还要将数据拷贝一份，fork效率的降低。fork本身就是向系统要更多的资源，要更多的资源和要更少的资源哪一个会更容易导致fork失败呢？当然是要更多的资源

所以通常，**父子代码共享，父子再不写入时，数据也是共享的，当任意一方试图写入，便以写时拷贝的方式各自一份副本。**写时拷贝的识别，操作，是由OS完成

数据10M，写入的时候是1M，发生写时拷贝，是拷贝10M还是1M？答案是拷贝1M

fork常规用法

• 一个父进程希望复制自己，使父子进程同时执行不同的代码段。例如，父进程等待客户端请求，生成子进程来处理请求。
• 一个进程要执行一个不同的程序。例如子进程从fork返回后，调用exec函数。

fork调用失败的原因

• 系统中有太多的进程
• 实际用户的进程数超过了限制

总结：如何理解子进程创建？如何理解fork？

本质是系统多了一个进程，子进程要以父进程为模板(并不是将所有东西都拷贝给子进程，比如PID是不需要拷贝的)

进程终止

进程退出场景

• 代码跑完了，结果是对的
• 代码跑完了，结果是不对的
• 代码没跑完，程序退出了(代码异常终止)

上面的退出场景已经包括了所有的场景，情况1和情况2是用退出码进行标识的，情况3是发生了异常，会有退出原因

进程常见退出方法

main函数返回

main函数退出的时候，return的那个数字叫做进程的退出码，怎么查看进程的退出码呢？

echo $?

这个命令是查看最近一个进程的退出码

为什么main函数的return一般写成0呢？0在函数设计中，一般代表正确，非零代表出错。这里的return是给系统看，确认进程的执行结果是否正确，退出码可以人为的定义，也可以使用系统的错误码list，那么非零到底是什么意思呢？当程序运行失败的时候，我们最关心的是为什么失败？失败原因，计算机不擅长处理，擅长处理整数类型的数据，所以退出码都是整数类型的，但是我们人又擅长字符串的描述，所以就有错误码和字符串的映射：

#include<stdio.h>
#include<string.h>
int main()
{
    for(int i = 0;i<200;i++)
    {
        printf("%d:%s\n",i,strerror(i));
    }
    return 0;
}

进程非正常结束：野指针，除0，越界…，退出码无意义

exit

exit和return有什么区别呢？

exit：终止整个进程，任何地方调用，都会终止

return：终止函数，如果是main函数return，代表终止进程

#include<stdlib.h>
int main()
{
    exit(1);
}

exit的参数就是进程的退出码

#include<stdlib.h>
int exe()
{
    exit(12);
}
int main()
{
    exe();
    cout<<"haha"<<endl;
}

进入exe函数，调用exit函数，此时直接就将进程终止了，并不会再去执行下面的语句了。

_exit

exit和_exit几乎一模一样，区别在于exit是库函数，_exit是系统调用，exit在退出程序时会刷新缓冲区，而_exit在退出时不会刷新缓冲区。

int main()
{
    cout<<"haha";//写入缓冲区
    exit();
}

会刷新缓冲区

int main()
{
    cout<<"haha";//写入缓冲区
    _exit();
}

不会刷新缓冲区

站在OS角度，如何理解进程终止？

进程终止的核心思想就是归还资源：

1、"释放"曾经为了管理进程所维护的所有的数据结构对象。

2、释放程序代码和数据占用的内存空间。

3、取消曾经该进程的链接关系(比如和它和它的父进程之间的链接关系)

上面提到了两个释放，所谓第一个释放不是真的把数据结构对象销毁，而是设置为不用状态，然后保存起来，如果不用的对象多了，就有一个"数据结构的池"

第二个释放不是代码和数据清空，而是把内存设置为无效就可以了

实际上我们每次申请空间是比较耗时的，由于所申请内存块的大小不定，当频繁使用时会造成大量的内存碎片并进而降低性能。 内存池则是在真正使用内存之前，先申请分配一定数量的、大小相等(一般情况下)的内存块留作备用。当有新的内存需求时，就从内存池中分出一部分内存块，若内存块不够再继续申请新的内存。这样做的一个显著优点是，使得内存分配效率得到提升。而数据结构池就是，当一个进程创建时有task_struct，mm_struct等各种数据结构变量，而我们在申请这些内存时，每次都要将这块内存强转为(task_struct*)，(mm_struct*)，这样时间效率肯定不好，所以就有一个数据结构池，这里面是一些无效的pcb以及mm_struct，他们处于一个废弃队列当中，当创建进程需要内存时，就将这里的内存提取出去。

进程等待

我们首先将子进程创建出来：

int main()
{
    pid_t id = fork();
    if(id == 0)
    {
        while(1)
        {
            sleep(1);
            cout<<"child..."<<endl;
        }
        exit(0);//终止
    }
    else
    {
        while(1)
        {
            sleep(1);
            cout<<"father..."<<endl;
        }
    }
    cout<<"hello world"<<endl;
}

子进程被创建出来，谁先运行，是由调度器说了算的，那么谁先退出呢？一般而言，我们通常要让子进程先退出，为什么呢？因为父进程可以很容易对子进程进行管理(垃圾回收)，如果父进程退出，子进程就成孤儿进程了，由操作系统领养，创建子进程出来是为了处理业务的，需要让父进程拿到子进程执行的结果

一般子进程是需要被父进程等待的，父进程等待的意义就是垃圾回收以及拿到子进程执行的结果

为什么要等待？

1.回收僵尸，解决内存泄漏

2.需要获取子进程的运行结束状态

3.尽量父进程要晚于子进程退出，可以规范化进行资源回收 - 编程策略

进程等待的方法

wait方法

等待任意一个子进程，当子进程退出，wait就可以返回。

#include<sys/types.h>
#include<sys/wait.h>
pid_t wait(int*status);

返回值：

成功返回被等待进程pid，失败返回-1。

参数：

输出型参数，获取子进程退出状态,不关心则可以设置成为NULL

int main()
{
     pid_t id = fork();
     if(id < 0)
     {
         perror("fork");
         return 1;
     }
     else if(id == 0)
     {
         //child
         int count = 5;
         while(count)
         {
             printf("child is runing: %d\n,ppid:%d,pid: %d\n",count--,getppid(),getpid());
             sleep(1);
         }
         exit(0);
     }
     else
     {
         //father
         printf("father is waiting...\n");
         pid_t ret = wait(NULL);
         printf("father is wait done,ret: %d\n",ret);
     }
    	return 0;
 } 

可以看到父进程等待成功了

我们来演示一下子进程变成僵尸进程后被父进程回收的过程：

我们首先让子进程五秒后退出，父进程先睡眠不进行处理，查看子进程被回收的过程：

int main()
{
     pid_t id = fork();
     if(id < 0)
     {
         perror("fork");
         return 1;
     }
     else if(id == 0)
     {
         //child
         int count = 5;
         while(count)
         {
             printf("child is runing: %d\n,ppid:%d,pid: %d\n",count--,getppid(),getpid());
             sleep(1);
         }
         exit(0);
     }
     else
     {
         //father
         printf("father is waiting...\n");
         sleep(8);
         pid_t ret = wait(NULL);
         sleep(3);
         printf("father is wait done,ret: %d\n",ret);
     }
    	return 0;
 } 

我们用一个脚本来监视进程的状态：

while :; do echo "####################"; ps ajx | head -1 && ps ajx | grep mytest | grep -v grep; echo "####################"; sleep 1; done

可以看到红色框圈出来的多了进程，然后之后几秒后，此时子进程退出，父进程处于睡眠状态，一直没有处理它，子进程变成了Z状态，故父进程睡眠结束后调用wait处理子进程，然后子进程彻底被杀死。

上面只是为了演示，但是实际中我们这样写就行：

int main()
{
    pid_t id = fork();
    if(id == 0)
    {
        int count = 0;
        while(1)
        {
            sleep(1);
            cout<<"child..."<<count<<endl;
            if(count>=15)
            {
                break;
            }
            count++;
        }
        exit(0);//终止
    }
    else
    {
        cout<<"father before..."<<endl;
        wait(NULL);//阻塞等待，等待子进程退出
        cout<<"father after..."<<endl;
    }
}

子进程退出父进程回收后继续做自己的事情就可以了。下面看另外一种方法：

waitpid方法

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

参数：

pid：
Pid=-1,等待任一个子进程。与wait等效。
Pid>0.等待其进程ID与pid相等的子进程。
status:
WIFEXITED(status): 若为正常终止子进程返回的状态，则为真。（查看进程是否是正常退出）
WEXITSTATUS(status): 若WIFEXITED非零，提取子进程退出码。（查看进程的退出码）
options:
WNOHANG: 若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束，则返回该子进程的ID。options设置成0时是阻塞式等待

返回值：

当正常返回的时候waitpid返回收集到的子进程的进程ID；
如果设置了选项WNOHANG,而调用中waitpid发现没有已退出的子进程可收集,则返回0；
如果调用中出错,则返回-1,这时errno会被设置成相应的值以指示错误所在；

WNOHANG是什么我们后面说，下面看这样一个程序：

#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
int main()
{
    pid_t id = fork();
    if(id<0)
    {
        perror("fork error!\n");
        return 1;
    }
    if(id == 0)
    {
        //child
        int count = 0;
        while(count<10)
        {
            printf("child [%d] is running...\n",getpid());
            sleep(1);
            count++;
        }
        exit(0);
    }
    printf("father wait before!\n");
    pid_t ret = waitpid(id,NULL,0);
    if(ret > 0)//等待成功
    {
        printf("wait success!\n");
    }
    else
    {
        printf("wait failed!\n");
    }
    printf("father wait after!\n"); 
}

当我们waitpid这样传参时其实这里的waitpid和wait的作用一样的，不一样的就是参数不同，我们来看看waitpid的第二个参数status：

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

status：是一个整形指针，其实在传参的时候，该参数是一个输出型参数

int st = 0;
waitpid(pid,&st,0);//开始等待，子进程退出，操作系统就会从进程PCB中读取退出信息，保存在status指向的变量中

返回之后，st中就保存的是进程退出的信息，int是32bit，而这个int当中就要保存这些信息：是否正常退出，退出码是多少，退出信号是多少，操作系统会根据该参数，将子进程的退出信息反馈给父进程。
status不能简单的当作整形来看待，可以当作位图来看待，具体细节如下图（只研究status低16比特
位）：

那么为什么需要用status让父进程知道子进程的退出信息呢？是否可以通过设置全局变量，子进程如果退出将该全局变量改了，以这样的方式告知父进程子进程的退出码？这样绝对是不行的，因为写时拷贝，子进程在修改全局变量时，会发生写时拷贝，父进程和子进程指向的变量不是同一块内容。

在waitpid中拿到的status的值，是从哪里拿到的呢？答案是从子进程的task_struct中拿到的

一般进程提前终止，本质是该进程收到了OS的信号，进程先关心的是信号的内容，status指向的变量的低7位表示的是终止信号，正常终止的话，没有收到任何退出信号，此时才去关心结果对还是不对(退出码)

完整的等待过程：

#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
int main()
{
    pid_t id = fork();
    if(id<0)
    {
        perror("fork error!\n");
        return 1;
    }
    if(id == 0)
    {
        //child
        int count = 0;
        while(count<10)
        {
            printf("child [%d] is running...\n",getpid());
            sleep(1);
            count++;
        }
        exit(0);
    }
    printf("father wait before!\n");
    int st = 0;
    pid_t ret = waitpid(id,&st,0);
    if(ret > 0)
    {
        printf("wait success!\n");
        printf("st:%d\n",st);
        printf("child exit signal:%d\n",st&0x7F);//获取低7位
        printf("child exit code:%d\n",(st>>8)&0xff);//获取高八位退出码
        if(st & 0x7F)//如果终止信号不为0 
        {
        	printf("child run error!\n");   
        }
        else
        {
            //终止信号为0，进程正常退出
            int code = ((st>>8)&0xff);//退出码
            if(code)//如果退出码不为0
            {
                printf("child run success,but result is not right!:code ：%d",code);
            }
            else
            {
                printf("child run success,result is right!:code ：%d",code);
            }
        }
    }
    else
    {
        printf("wait failed!\n");
    }
    printf("father wait after!\n");
    
}

上面的代码就是进程完整等待的过程。

但是这样拿到退出码和信号比较麻烦，实际上系统上提供了这么两个宏可以帮我们干上面的检测：

• WIFEXITED(status): 若为正常终止子进程返回的状态，则为真。（查看进程是否是正常退出）

这个检测的相当于是!(status & 0x7F)

• WEXITSTATUS(status): 若WIFEXITED非零，提取子进程退出码。（查看进程的退出码）

这个检测的相当于是(st>>8) & 0xff。

所以我们可以将上面的代码换成下面这种：

#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
int main()
{
    pid_t id = fork();
    if(id<0)
    {
        perror("fork error!\n");
        return 1;
    }
    if(id == 0)
    {
        //child
        int count = 0;
        while(count<10)
        {
            printf("child [%d] is running...\n",getpid());
            sleep(1);
            count++;
        }
        exit(0);
    }
    printf("father wait before!\n");
    int st = 0;
    pid_t ret = waitpid(id,&st,0);
    if(ret > 0)
    {
    	if(WIFEXITED(st))
        {
            printf("exit code : %d\n",WEXITSTATUS(st));//退出码
        }
        else
        {
            printf("child exit error\n");
        }
    }
}

第一个参数pid：

Pid=-1,等待任一个子进程。与wait等效。
Pid>0.等待其进程ID与pid相等的子进程。

第三个参数options：

WNOHANG: 若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束，则返回该子进程的ID。

将WNOHANG作为第三个参数传给waitpid时称为非阻塞式等待，如果传0则为阻塞式等待。

什么意思呢？举个例子：

比如说你和你同学约好一起出去玩，你到达约定的地点后，发现你同学还没有来，于是你打电话问你同学在哪呢，然后你同学说马上就来，过了一分钟，你同学还没来，于是你又打了一个电话，你同学说马上就来，过了一会，你又给你同学打了电话，他说到了，于是你挂了电话见到了他。

在这个例子当中你每次打电话询问你同学的状态，通过多次打电话(非阻塞轮询方案)检测它的进度，每次打电话就相当于一次waitpid函数调用，这叫非阻塞式等待，如果你刚开始打通电话不挂断，一直等到见到你同学才挂断，这种情景叫做阻塞式等待。我们在C语言，C++中所调用的函数，全部都是阻塞函数：调用->执行->返回->结束，因为都是单执行流，简单一些，这种方式调用方都在等，什么事情都没有做。

而非阻塞等待是一种基于非阻塞接口的轮询方案：

在非阻塞等待当中，wait失败有两种说法：

1.并不是真的失败了，仅仅是对方的状态没有达到预期

2.真的失败了

非阻塞等待的三种状态：

1.失败：子进程还没有退出，下次在检测

2.成功：子进程退出，已经返回

3.失败：真正的等待失败

非阻塞式等待：

#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
int main()
{
    pid_t id = fork();
    if(id<0)
    {
        perror("fork error!\n");
        return 1;
    }
    if(id == 0)
    {
        //child
        int count = 0;
        while(count<10)
        {
            printf("child [%d] is running...\n",getpid());
            sleep(1);
            count++;
        }
        exit(0);
    }
    printf("father wait before!\n");
    int status = 0;
    while(1)
    {
        pid_t ret = waitpid(id,&status,WNOHANG);
        if(ret == 0)//id指定的子进程没有结束
        {
            printf("wait next!\n");
            printf("father do other things\n");
        }
        else if(ret > 0)
        {
            printf("wait success,ret:%d,code:%d\n",ret,WEXITSTATUS(status));
        }
        else
        {
            printf("wait failed!\n");
            break;
        }
    }
}

如何理解阻塞等待？

父进程在等，子进程跑代码，如何理解进程在等？将当前进程放入等待队列，并将进程状态设置为非R状态，当期待的事件发生时，唤醒进程，将该进程从等待队列拿出到运行队列，将该进程状态设置成R状态

总结：

• 进程等待是什么？

是父进程通过wait等系统调用，用来等待子进程状态的一种现象，是必须的

• 为什么要进程等待？

1、防止子进程发生僵尸问题，进而产生内存泄漏 2、读取子进程状态

• 怎么进行进程等待？

wait/waitpid，status(signal,exit code)，status指向的变量的低16位表示了子进程是否正常退出，如果正常退出退出码是什么，异常退出，则它的终止信号是啥。

进程程序替换

替换原理

fork创建子进程无非两个作用：

1、想让子进程执行父进程代码的一部分(富二代子承父业)

2、想让子进程执行和父进程完全不同的事情(富二代创业)

前面我们说的都是第一种，那么当我们想要进行第二种时，就需要进程替换，在进程替换时，代码也要发生写时拷贝，不进行进程替换时父子代码是共享的

进程替换有没有创建新的进程呢？

不算创建了新进程，因为PCB没有被重新创建，PID不会发生变化

进程替换是将磁盘上的程序替换给子进程，怎么替换呢？本质上用该程序的代码和数据替换，修改页表的映射。完成进程替换的过程并不是我们自己做的，而是操作系统做的，操作系统提供了下面的接口，下面是替换函数：

替换函数

其实有六种以exec开头的函数,统称exec函数：

#include <unistd.h>
int execl(const char *path, const char *arg, ...);//...是可变参数
int execlp(const char *file, const char *arg, ...);
int execle(const char *path, const char *arg, ...,char *const envp[]);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execve(const char *path, char *const argv[], char *const envp[]);

命名理解

l(list) : 表示参数采用列表
v(vector) : 参数用数组
p(path) : 有p自动搜索环境变量PATH
e(env) : 表示自己维护环境变量

void myfun(char *arg1,char *arg2,char *arg3);//列表式传参
myfun(a1,a2,a3);//list
void myfun(char *arg[]);//非列表式的传参
char *arg[] = {a1,a2,a3};
myfun(arg);

参数命名中有l的需要一个一个进行传参，有v的需要将参数放入数组，通过数组传参

有p的第一个参数是file，而不带p的第一个参数是path，有p自动去环境变量PATH中搜索：传参时可以直接传想要使用的命令，不需要传路径，会自动搜索，只需要告诉执行的命令是谁

没有p的需要传路径

execl

第一个参数是你要执行哪个程序(需要带路径)，因为执行程序需要直到你在哪，你是谁，第二个是要执行的程序名，命令行怎么执行，传入什么选项，你就可以在这里直接按照顺序填写参数，命令行上怎么写，这里就怎么写，这种传参方式叫做list方式，最后必须以NULL结尾，告知execl传参结束

#include<stdio.h>
#include<unistd.h>
int main()
{
    execl("/usr/bin/ps","ps","-e","-l","-f",NULL);
    return 0;
}

可以看到通过我们自己写的程序运行了ps命令：

函数的第一个参数代表你要执行谁，第二个参数是你在命令行怎么调用执行，在后面的参数中你就怎么传递。

接下来看下面的程序：

#include<stdio.h>
#include<unistd.h>
int main()
{
    printf("begin............................\n");
    execl("/usr/bin/ps","ls","-a","-l","-i",NULL);
    printf("hello world\n");
    return 0;
}

exec_cmd是自己写的可执行程序，./exec_cmd变成了进程，代码执行到execl，进行程序替换，用ls进程的代码和数据替换exec_cmd进程的代码和数据，执行ls进程

ls：系统的可执行程序

上面的代码输出结果是什么呢？

可以看到并不会打印hello world这句话，因为执行到execl，进行程序替换，用ls进程的代码和数据替换exec_cmd进程的代码和数据，执行ls进程

注意：

这些函数如果调用成功则加载新的程序从启动代码开始执行,不再返回。如果调用出错则返回-1，所以exec函数只有出错的返回值而没有成功的返回值，所以exec系列函数是没有返回值的，如果返回了，或者执行了后续的代码，一定是程序替换错了

举个例子，我们故意把程序替换写错：

#include<stdio.h>
#include<unistd.h>
int main()
{
    printf("begin............................\n");
    execl("/usr/bi/ps","ls","-a","-l","-i",NULL);
    printf("hello world\n");
    return 0;
}

此时就会返回去打印后面的语句了。

我们当然也可以让子进程去干程序替换这件事情：

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
int main()
{
    //execl("/usr/bin/ls", "ls",_"-a","-l"，"-i"，NULL);
	//execl("/usr/bin/top" , "top" ,NULL);
    pid_t id = fork();
    if(id<0)
    {
        perror("fork");
        return 1;
    }
    else if(id == 0)
    {
        //child
        printf("i am a child , pid:%d, ppid: %d\n",getpid(),getppid());
        execl("usr/bin/ps","ps",NULL);
        exit(1);
    }
    //father
    int status = 0;
    pid_t ret = waitpid(id,&status,0);//阻塞式等待
    if(ret > 0)
    {
        printf("wait success!\n");
        printf("exit code: %d,exit status: %d\n",(status>>8)&0xFF,status & 0x7F);
    }
    else{
        printf("wait failed!\n");
    }
    return 0;    
}

在这里子进程进行了程序替换，退出的进程其实就是ls程序

exec系列函数的理解

软件被加载进内存，需要加载器，一个软件加载到内存就成了进程，首先软件先运行起来变成进程，然后进程调用exec系列函数，就可以完成加载到内存的过程，exec可以理解成一种特殊的加载器

execv

传参以数组进行传参

#include<stdio.h>
#include<unistd.h>
int main()
{
    printf("begin............................\n");
    char *arg[] = {"ls","-a","-l","-i",NULL};
    execv("/usr/bin/ls",arg);
    printf("you should running here\n");
    return 0;
}

execvp

带v以及带p，参数用数组传，带p说明第一个参数不需要传路径，它会自动的去环境变量PATH里面去找可执行程序，所以传命令名字就行

#include<stdio.h>
#include<unistd.h>
int main()
{
    printf("begin............................\n");
    char *arg[] = {"ls","-a","-l","-i",NULL};
    execvp("ls",arg);
    printf("you should running here\n");
    return 0;
}

execlp

带l以及带p，参数用列表形式传，带p说明第一个参数不需要传路径，传命令名字就行

#include<stdio.h>
#include<unistd.h>
int main()
{
    printf("begin............................\n");
    execlp("ls","ls","-a","-l","-i",NULL);
    printf("you should running here\n");
    return 0;
}

elecle

带l和带e的，带e表示自己维护环境变量，传入默认的或者自定义的环境变量给目标可执行程序

在说明elecle函数之前，我们先想一个问题：

exec系列函数能调用系统程序，那么他能调用自己的程序吗？答案是可以的

我们首先自己写一个程序：

#include<stdio.h>
int main()
{
    int i = 0;
    int sum = 0;
    for(;i<=100;i++)
    {
        sum+=i;
    }
    printf("result[1~100] sum is:%d\n",sum);
    return 0;
}

Makefile的编写：

makefile默认只生成一个可执行程序，默认是自顶向下扫描makefile文件遇到的第一个目标

输入make bin命令 ，默认就生成bin

.PHONY:all
all:mytest mycmd
mytest:Test.c
    gcc -o $@ $^  
mycmd:mycmd.c
    gcc -o $@ $^
.PHONY:clean
clean:
    rm mytest mycmd

我们在Test.c中使用程序替换execl函数去执行我们写的程序：

#include<stdio.h>
#include<unistd.h>
int main()
{
    printf("begin............................\n");
    execl("./mycmd","./mycmd",NULL);
    return 0;
}

可以看到我们成功的通过exec系列函数调用自己写的程序：

上面说的都是为了说明execle系统调用所做的铺垫，下面我们再来看execle：

我们在mycmd.c中获取一个环境变量myenv，而这个程序它本身是没有myenv这个环境变量的，所以我们就可以通过execle函数给我们写的程序将环境变量传过去：

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
int main()
{
    char *env[] = {"myenv = you_can_see_me!",NULL};//自定义环境变量
    printf("begin............................\n");
    execle("./mycmd","./mycmd",NULL,env);//调用该函数并将自定义的环境变量数据传给目标程序
    return 0;
}

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int i = 0;
    int sum = 0;
    for(;i<=100;i++)
    {
        sum+=i;
    }
    printf("result[1~100] sum is:%d\n",sum);
    printf("myenv: %s\n",getenv("myenv"));
    return 0;
}

我们运行mytest，发现完成的程序替换，而且将环境变量也传过去了。

我们man查看exec系列函数：

我们发现execve是和上面的函数分开的，本质上是因为，execve是最底层的系统调用，其他都是去调用它去完成的：

实际中，我们可以fork出子进程，让子进程去进行程序替换，替父进程完成事情：

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
int main()
{
    pid_t id = fork();
    if(id<0)
    {
        perror("fork error\n");
        return 1;
    }
    if(id == 0)
    {
        //child
        execl("usr/bin/ls","ls","-a","-l","-i",NULL);
        //如果返回则替换失败
        exit(-1);
    }
    
    pid_t ret = waitpid(id,NULL,0);
    if(ret > 0)
    {
        printf("wait success,cmd exit\n");
    }
    return 0;
}

父进程正常执行自己要干的事情，因为替换的是子进程，进程是有独立性的，所以，父进程是不受影响的！

总结：

1、什么是程序替换?

通过exec系列函数，让特定进程去加载磁盘中的其他程序，以达到运行的目的，期间不创建新的进程

2、为什么要程序替换?

子进程执行父进程的一部分代码，子进程自身新的程序的需求

3、如何程序替换？

我们讲解了6-7个函数可以进行程序替换

注意：exec系列函数只要返回了，就说明出错了

shell小程序的简单实现

讲解完程序替换，其实我们就可以实现一个简单的shell了，我们首先来说一下shell的运行原理：

shell运行原理：用户执行命令->shell解释器->fork()->子进程去执行命令(利用exec系列函数，OS做的)->shell->用户

我们发现shell运行原理就是用户执行命令，shell解释器创建子进程去执行命令，子进程将执行结构告诉shell，最后再反馈给用户，其实就是给上面的程序套了一层循环去创建子进程去执行命令：

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
int main()
{
    while(1)
    {
        pid_t id = fork();
        if(id<0)
        {
            perror("fork error\n");
            return 1;
        }
        if(id == 0)
        {
            //child
            execl("usr/bin/ls","ls","-a","-l","-i",NULL);
            //如果返回则替换失败
            exit(-1);
        }

        pid_t ret = waitpid(id,NULL,0);
        if(ret > 0)
        {
            printf("wait success,cmd exit\n");
        }
    }
    return 0;
}

下面我们来实现我们的myshell.c，首先我们登录主机后，会打印命令提示符(用户名@主机名 当前目录)提示符：

所以我们首先要干的就是打印这个命令提示符，然后我们需要获取用户输入的文本(需要我们解析) 比如：ls -a -l，然后父进程fork(子进程去执行)，然后父进程wait，我们需要重复的去做这些动作，需要用循环。

实际上获取主机名等信息都是有函数的：

int main()
{
    char name[32];
    gethostname(name,32);//获得主机名
    get_current_dir_name();
}

这里我们为了简单，就直接打印一个主机名：

const char* cmd_line = "[temp@VM-0-3-centos ~]#";

然后我们需要做的就是数据读取，C语言有一个fgets函数，我们可以这样读取数据：

fgets(cmd,SIZE,stdin);

cmd是保存输入命令的一个数组，大小自己决定即可，size是读取的字符个数，stream是从哪里读，这里需要注意的是，我们读取结束后最后一个字符是\n，所以需要将它置为\0

cmd[strlen(cmd)-1] = '\0';//标准输入会输入\n，将\n改为\0

接下来就要进行字符串数据分析，怎么分析呢？我们首先要把输入的字符串以空格为标志进行分割，然后放进一个字符指针数组，不了解strtok函数的可以去了解一下：

//字符串(命令行数据分析)
char* args[NUM];
args[0] = strtok(cmd," ");//字符串分割
int i = 1;
do{
     rgs[i] = strtok(NULL," ");
     if(args[i] == NULL)
     {
           break;
     }
     ++i;
}while(1);

然后就是创建子进程进行执行命令，子进程通过调用程序替换函数去执行命令，那么我们想一下我们用哪个函数呢？我们的命令是用数组存起来的，所以需要带v，那么就用execvp，并且不用传路径，传命令名就好，会自动去环境变量PATH里找：

pid_t id = fork();
if(id < 0)
{
     perror("fork error!\n");
     continue;
}
 //4.执行非内置命令
if(id == 0)
{
     //child
     execvp(args[0],args);
     exit(1);//替换失败了就直接退出
}
int status = 0;
pid_t ret = waitpid(id,&status,0);
if(ret>0)
{
    printf("status code :%d\n",(status>>8)&0xff);
}

总体的代码如下：

#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<stdlib.h>
#define SIZE 256
#define NUM 16
int main()
{
    char cmd[SIZE];//保存命令
    const char* cmd_line = "[temp@VM-0-3-centos ~]#";
    while(1)
    {
        cmd[0] = 0;//清空数据
        //memset(cmd,'\0',sizeof(cmd));
        printf("%s",cmd_line);
        //数据读取
        fgets(cmd,SIZE,stdin);
        //printf("%s",cmd);
        cmd[strlen(cmd)-1] = '\0';//标准输入会输入\n，将\n改为\0
        
        //字符串(命令行数据分析)
        char* args[NUM];
        args[0] = strtok(cmd," ");//字符串分割
        int i = 1;
        do{
            args[i] = strtok(NULL," ");
            if(args[i] == NULL)
            {
                break;
            }
            ++i;
        }while(1);
		//shell内的函数调用，内置命令
        pid_t id = fork();
        if(id < 0)
        {
            perror("fork error!\n");
            continue;
        }
        //4.执行非内置命令
        if(id == 0)
        {
            //child
            execvp(args[0],args);
            exit(1);//替换失败了就直接退出
        }
        int status = 0;
        pid_t ret = waitpid(id,&status,0);
        if(ret>0)
        {
            printf("status code :%d\n",(status>>8)&0xff);
        }
    }
    return 0;
}

上面的代码只是支持非内置命令，内置命令不可以，比如cd：

cd .. //回到上一路径

我们期望改的是父进程shell的当前路径，这里则是修改的是子进程的当前路径，子进程干完事就退出了，所以不能创建子进程执行cd，也不能让父进程通过程序替换去执行cd，因为执行了父进程会影响，所以需要系统接口来完成命令的执行。

有一个系统接口chdir是修改路径的：

修改成功返回0

如果想要支持cd命令，就需要在创建子进程前判断命令：

if(strcmp( args[0]，"cd" ) == 0 && chdir(args[1])== 0)//chdir修改当前路径
{
    continue;
}

这样就成功执行cd命令了

支持cd命令的shell：

#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<stdlib.h>
#define SIZE 256
#define NUM 16
int main()
{
    char cmd[SIZE];//保存命令
    const char* cmd_line = "[temp@VM-0-3-centos ~]#";
    while(1)
    {
        cmd[0] = 0;//清空数据
        //memset(cmd,'\0',sizeof(cmd));
        printf("%s",cmd_line);
        //数据读取
        fgets(cmd,SIZE,stdin);
        //printf("%s",cmd);
        cmd[strlen(cmd)-1] = '\0';//标准输入会输入\n，将\n改为\0
        
        //字符串(命令行数据分析)
        char* args[NUM];
        args[0] = strtok(cmd," ");//字符串分割
        int i = 1;
        do{
            args[i] = strtok(NULL," ");
            if(args[i] == NULL)
            {
                break;
            }
            ++i;
        }while(1);
        //3.判断命令
        if(strcmp( args[0],"cd" ) == 0 && chdir(args[1])== 0)//chdir修改当前路径
        {
            continue;
        }
		//shell内的函数调用，内置命令
        pid_t id = fork();
        if(id < 0)
        {
            perror("fork error!\n");
            continue;
        }
        //4.执行非内置命令
        if(id == 0)
        {
            //child
            execvp(args[0],args);
            exit(1);//替换失败了就直接退出
        }
        int status = 0;
        pid_t ret = waitpid(id,&status,0);
        if(ret>0)
        {
            printf("status code :%d\n",(status>>8)&0xff);
        }
    }
    return 0;
}