【Linux】六、进程控制

进程创建

fork函数的认识

#include

pid_t fork(void)

#include 
#include 
 
int main()
{
    printf("我是父进程！\n");
    pid_t id = fork();
    if(id < 0)
    {
        printf("创建子进程失败\n");
        return 1;
    }
    else if
    {
        //子进程
        while(1)
        {
            printf("我是子进程：pid: %d, ppid: %d\n",getpid(),getppid());
            sleep(1);
        }
    }
    else
    {
        //父进程
        while(1)
        {
            printf("我是子进程：pid: %d, ppid: %d\n",getpid(),getppid());
            sleep(1);
        }
    }
    return 0;
}

请描述一下，fork创建子进程，操作系统都做了什么？

fork创建子进程就是系统里多了一个进程，也就是进程=内核数据结构+进程代码和数据；一般从磁盘中来，也就是C\C++程序加载后的结果；分配新的内存块和内核数据结构给子进程；将父进程部分数据结构内容拷贝到到子进程；添加子进程到系统进程列表当中，fork返回开始调度器调度；

创建子进程给子进程分配对应的内核结构，理论上子进程也要有自己的代码和数据，但是一般子进程没有加载的过程，也就是说子进程没有自己的代码和数据，所以子进程只能使用父进程的代码和数据；

代码：都是不可以被写的，只能读取，所以父子进程共享没有问题；

数据：可能被修改，所以必须分离；

当想要修改数据时，有两种方案

1、创建进程时，就直接拷贝分离，也就是将父进程给子进程拷贝一份，但这样做有一个问题，可能拷贝子进程根本不会用到的数据空间，即使用到了也就是读取；

#include 
#include 
 
int main()
{
    char *str = "aaa";
    char *str1 = "aaa";
 
    printf("%p\n", str);
    printf("%p\n", str1);
    return 0;
}

此时打印出来的结果地址是相同的，编译器编译程序的时候都知道使用这种方式节省空间，所以操作系统在创建子进程的时候，不需要将不会被访问的或者只会读取的数据，拷贝出一份；那么什么样的数据值的被拷贝呢？将来会被父或子进程写入的数据；一般来说，即便是操作系统也无法提前知道哪些空间可能会被写入，并且即便是提前拷贝了可能也不会立刻使用，所以操作系统选择了写时拷贝技术将父子进程的数据进行分离；

2、写时拷贝；

fork之后是所有的代码共享，不是fork之后的代码共享；

原因：首先，当代吗进行汇编后，会有很多行代码，而且每行代码加载到内存后都有对应的地址；其次，因为进程随时可能被中断（可能没有执行完），下次回来，还必须从之前的位置继续运行，就要求CPU必须随时记录下当前进程执行的位置，所以，CPU内有对应的寄存器数据，用来记录当前进程执行的位置，寄存器叫做EIP，也叫做pc（point code）指针，程序计数器；寄存器在CPU内只有一份，但是寄存器的数据，可以有很多份，而这个数据也就是上下文数据，而这个上下文数据，通过写时拷贝给子进程，父子进程各自调度，各自会修改自己的EIP，但是此时子进程已经认为自己的EIP起始值就是fork之后的代码；

因为有写时拷贝，所以父子进程得以彻底分离，完成了进程独立性的技术保证，是一种延时申请技术，可以提高整机内存的使用率；

fork 的常规用法

一个父进程希望子进程复制自己，是父子进程执行同一份代码的不同区域；

父进程和子进程执行完全不同的代码；

一般而言父子进程实际使用时，像现实一样希望子承父业，或者父子从事不同的行业；

fork失败的原因

系统中有太多的进程；（内存不足）

实际用户的进程数超过了限制；（一般普通用户的进程数是有限制的）几百几千进程；

进程终止 

进程终止时操作系统做了什么？

释放进程申请的相关数据结构和对应的代码和数据；本质就是释放系统资源；内存或CPU等；

进程终止的常见方式？

代码跑完，结果正确；

代码跑完，结果不正确；（代码中的逻辑有问题）

代码没跑完，程序崩溃了；（信号部分）

main函数的返回值？main返回值的意义是什么？return 0的含义是什么？为什么总是 0 ？

#include 
 
int main()
{
    
    return 0;
}

 return后面的返回值并不是总是0的；

main的返回值是进程的退出码；

return 0 表示的是进程的运行结果正确，当运行结果不正确的时候返回值是非0；

使用 echo $？ 可以获取最近一次进程返回的退出码；

返回值的意义是返回给上一级进程，用来评判进程执行结果用的；例；

#include 
#include 
 
int sum(int top)
{
    int s=0;
    for(int i=1;i<=top;i++)
    {
        s+=i;
    }
    
    return s;
}
 
int main()
{
    int ret=0;
    int res=sum(100);
    if(res!=5050)
    {
        ret=1;//代码运行结果不正确；
    }
    return ret;
}

可以通过对返回值做判断来判断自己的程序运行结果正确还是不正确；

如果程序结果正确了就不会关心为什么正确了，但是如果结果不正确，就会关心结果为什么不正确，非0值有无数个，不同的非0值可以表述不同的错误原因；从而给程序在运行结束后在结果不正确时，方便定位错误的原因细节；

退出码除了返回给上一级进程，还有一个就是可以通过退出码快速定位错误原因；

又因为自己定义的退出码系统并不能识别，所以需要用到一个接口，将退出码转化成字符串描述的错误原因； #include strerror();

#include 
#include 
#include 
 
int sum(int top)
{
    int s=0;
    for(int i=1;i<=top;i++)
    {
        s+=i;
    }
    
    return s;
}
 
int main()
{
    for(int number=0;number<100;number++)
    {
        printf("%d: %s\n",number,strerror(number));
    }
}

最终打印出134个退出码和字符串；

我们自己可以使用这些退出码和含义，但是如果想要自己定义也可以自己设计一套退出方案；如果创建一个子进程怎么才能知道它是否运行完，运行的怎么样，就需要用到退出码；

程序崩溃的会后，退出码无意义，一般而言退出码对应的return 语句没有被执行；

用代码如何终止进程？什么是一个正确的终止？

1、return 语句，就是终止进程，return+退出码；注意，只有main函数中的return可以返回退出码；

#include 
#include 
#include 
 
int sum(int top)
{
    int s = 0;
    for(int i=1;i
    {
        s+=1;
    }
    
    return s;
}
 
int main()
{
    printf("hello world1\n");
    printf("hello world1\n");
    printf("hello world1\n");
    int res = sum(10);
    return 11;
    printf("hello world2\n");
    printf("hello world2\n");
    printf("hello world2\n");
    printf("hello world2\n");
}

运行后程序的退出码是11；首先return之后，后边的代码不执行，return之后，main函数返回11，被系统拿到，进而被父进程拿到；

2、exit函数#include    void exit(int status);

#include 
#include 
#include 
#include 
 
int sum(int top)
{
    int s = 0;
    for(int i=1;i
    {
        s+=1;
    }
    
    exit(222);
}
 
int main()
{
    printf("hello world1\n");
    printf("hello world1\n");
    printf("hello world1\n");
 
    int res = sum(10);
 
    exit(111);
 
    printf("hello world2\n");
    printf("hello world2\n");
    printf("hello world2\n");
    printf("hello world2\n");
}

代码运行后，如果sum函数中使用return返回sum值，退出码是111，但是当sum函数中使用exit函数，可以看见退出码是222；exit函数在代码的任何地方调用都表示直接终止；

3、_exit函数 #include      _exit(int status) 或 _Exit(int status)系统调用接口

#include 
#include 
#include 
#include 
 
int main()
{
    printf("can you see me?\n");
    sleep(3);
    exit(13);
}

此代码在执行时，如果将printf中的 \n 删除，将会sleep3秒后打印出里边的内容；exit函数不会直接终止，会将缓冲区中的内容打印出来后在退出；

但是将exit函数改为_exit函数，程序会直接退出；如图；

库函数VS系统接口

是层状结构，上面是库函数，下面是系统接口，库函数往上走就是语言、应用等；系统接口往下走就是操作系统；所以就可见exit是库函数，而_exit是系统调用，而exit函数就是调用_exit函数；可见，缓冲区一定不是操作系统维护的，是C标准库维护的；

进程等待

为什么要有进程等待？

1、子进程退出，父进程不管子进程，子进程就会进入僵尸状态，，就会导致内存泄漏；

2、父进程创建子进程，是要让子进程办事的，那么子进程把任务完成的怎么样？父进程需要关心吗？如果需要如何得知，如果不需要，该怎么处理？

子进程完成的情况就是代码跑完，结果正确；代码跑完结果不正确；代码没跑完；

父进程会等待子进程完成；

 进程等待的必要性

子进程退出，父进程如果不管不顾，就可能造成 ‘ 僵尸进程 ’ 的问题，进而造成内存泄漏。

另外，进程一旦变成僵尸状态，那就刀枪不入， “ 杀人不眨眼 ” 的 kill -9 也无能为力，因为谁也没有办法 杀死一个已经死去的进程。

最后，父进程派给子进程的任务完成的如何，我们需要知道。如，子进程运行完成，结果对还是不对， 或者是否正常退出。

父进程通过进程等待的方式，回收子进程资源，获取子进程退出信息；

 

如何进行等待，等待是什么？（操作）

wait函数（验证回收，回收僵尸进程的问题）

#include

#include

pid_t wait(int *status); 

#include 
 
int main()
{
    pid_t id = fork();
    if(id<0)
    {
        perror("fork");//直接打印出错的原因
        exit(1);//标识进程运行完毕，结果不正确；
    }
    else if(id==0)
    {
        //子进程
        int cnt = 5;
        while(cnt)
        {
            printf("cnt:%d , 我是子进程，pid:%d , ppid: %d \n",cnt,getpid(),getppid());
            sleep(1);
            cnt--;
        }
        
        exit(0);//终止子进程
    }
    else
    {
        //父进程
        while(1)
        {
            printf("cnt:%d , 我是父进程，pid:%d , ppid: %d \n",getpid(),getppid());
            sleep(1);//此代码子进程退出，父进程还在运行就会导致子进程僵尸状态
 
        }
        
    }
}

 此时代码运行后，子进程就会进入僵尸状态；

#include 
#include 
#include 
 
int main()
{
    pid_t id = fork();
    if(id<0)
    {
        perror("fork");//直接打印出错的原因
        exit(1);//标识进程运行完毕，结果不正确；
    }
    else if(id==0)
    {
        //子进程
        int cnt = 5;
        while(cnt)
        {
            printf("cnt:%d , 我是子进程，pid:%d , ppid: %d \n",cnt,getpid(),getppid());
            sleep(1);
            cnt--;
        }
        
        exit(0);//终止子进程
    }
    else
    {
        //父进程
        printf("cnt:%d , 我是父进程，pid:%d , ppid: %d \n",getpid(),getppid());
        sleep(7);
        pid_t ret=wait(NULL);//阻塞式的等待
        if(ret>0)
        {
            printf("等待子进程成功，ret :%d\n",ret);
        }
        
    }
}

运行程序后可以看到5s后子进程进入僵尸状态，再过2s后将是状态消失； 

waitpid函数 （获取子进程退出的状态）

#include

#include

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

options默认为0，表示阻塞等待；

status：输出型参数；标识子进程退出的结果，与wait中相同；

使用，int status=0;  waitpid(, &status,),系统会将status自动填充到status中；

waitpid(pid , NULL ,0)等价于wait（NULL）

#include 
#include 
#include 
 
int main()
{
    pid_t id = fork();
    if(id<0)
    {
        perror("fork");//直接打印出错的原因
        exit(1);//标识进程运行完毕，结果不正确；
    }
    else if(id==0)
    {
        //子进程
        int cnt = 5;
        while(cnt)
        {
            printf("cnt:%d , 我是子进程，pid:%d , ppid: %d \n",cnt,getpid(),getppid());
            sleep(1);
            cnt--;
        }
        
        exit(0);//终止子进程
    }
    else
    {
        //父进程
        printf("cnt:%d , 我是父进程，pid:%d , ppid: %d \n",getpid(),getppid());
        sleep(7);
        pid_t ret=waitpid(id,NULL,0);//阻塞式的等待
        if(ret>0)
        {
            printf("等待子进程成功，ret :%d\n",ret);
        }
        
    }
}

看到现象与wait上边的代码一致；

#include 
#include 
#include 
 
int main()
{
    pid_t id = fork();
    if(id<0)
    {
        perror("fork");//直接打印出错的原因
        exit(1);//标识进程运行完毕，结果不正确；
    }
    else if(id==0)
    {
        //子进程
        int cnt = 5;
        while(cnt)
        {
            printf("cnt:%d , 我是子进程，pid:%d , ppid: %d \n",cnt,getpid(),getppid());
            sleep(1);
            cnt--;
        }
        
        exit(100);//终止子进程
    }
    else
    {
        //父进程
        printf("cnt:%d , 我是父进程，pid:%d , ppid: %d \n",getpid(),getppid());
        sleep(7);
        int status = 0;
        pid_t ret=waitpid(id,&status,0);//阻塞式的等待
        if(ret>0)
        {
            printf("等待子进程成功，ret :%d, status:%d\n",ret,status);
        }
        
    }
}

按照常理这个代码的运行结果是status将会打印出100，但是真实的运行结果却不是这个数字，status的构成，status并不是按照整数来整体使用的，而是按照比特位的方式将32个比特位划分，目前只学习低16位；次低8位表示子进程退出时的退出码，使用下面的操作，就可以得到退出码；

if(ret>0)
{
    printf("等待子进程成功，ret :%d, 子进程退出码:%d\n",ret,(status>>8)&0xFF);
}

修改后运行代码就可以得到子进程的退出码也就是上面所说的100；

进程异常退出或者崩溃，本质是操作系统杀掉了进程，操作系统如何杀掉呢？本质是通过发送信号的方式；

进程在退出时有31个信号，这个信号使用低7个比特位表示进程收到的信号core dump标志后边再讲；

status & 0x7F 获取低7位； 

父进程通过wait或者waitpid可以拿到子进程的退出结果，为什么要用waitpid函数呢？直接全局变量不行吗？

因为进程具有独立性，那么数据就要发生写时拷贝，父进程无法拿到；

进程具有独立性，进程退出吗不也是子进程的数据吗？父进程怎么能拿到，wait和waitpid做了什么？

僵尸进程，至少要保留该进程的PCB信息，里边保留了子进程退出时的退出结果信息；

本质就是读取了子进程的task_struct结构；

wait和waitpid有权限吗？因为是系统调用，就是操作系统做的事情；本质是操作系统帮助拿子进程的退出结果；

只有子进程退出的时候，父进程才会调用waitpid函数进行返回；

waitpid和wait可以在目前的情况下让进程的退出具有一定的顺序性，就是子进程先退出然后父进程退出，可以让父进程进行更多的收尾工作；

waitpid参数：id>0等待指定的进程；id==0；id==-1,等待任意一个子进程退出；

上述代码在获取进程的退出码时还需要进行位操作，那么可不可以不适用位操作获取呢？

系统提供了宏，它的底层就是代码中的位操作；

将父进程中的代码改为

else
{
    int status=0;
    pid_t result = waitpid(id,&status,0);
    if(result > 0)
    {
        if(WIFEXITED(status))
        {
            printf("子进程的退出码：%d\n",WIFEXITED(status))
        }
        else 
        {
            printf("子进程退出异常：%d\n",WIFEXITED(status));
        }
    }
}

如果想要让父进程在等待期间去做一些其他的事情该怎么办？

options：默认为0，代表阻塞等待，当设置为WNOHONG是非阻塞；

options：WNOHANG选项，代表父进程非阻塞式等待；

Linux是C语言写的，系统调用接口是操作系统自己提供的接口，就是C语言函数，系统提供的一般大写的标记为其实就是一个宏；

可以理解为Wait No HANG，

一个概念：HANG住了，点开一个软件，长时间没有任何反应，就像是卡主不动了就叫做HANG住了，所谓的HANG住了就是这个进程没有被CPU调度；要么是在阻塞队列中，要么就是等待被调度；

阻塞等待和非阻塞等待：非阻塞等待就是如父进程通过调用waitpid来进行等待，如果子进程没有退出，这个waitpid系统调用立马返回；

进程阻塞，本质就是阻塞在系统函数的内部，在flag==0处挂起，后边的代码就不在执行了，当条件满足的时候，父进程被唤醒，是从if（flag==0 ）的后面唤醒，而不是重新执行waitpid函数；阻塞等待一般就是在内核中阻塞，等待被唤醒；

基于非阻塞调用的轮询检测方案；网络代码大部分是IO类的，不断面临阻塞与非阻塞状态；

非阻塞等待父进程代码；

else
{
    int quit = 0;
    while(!quit)
    {
        int status = 0;
        pid_t res = waitpid(-1,&status,WNOHANG);
        if(res > 0)
        {
            //等待成功 && 子进程退出
            printf("等待子进程退出成功，退出码：%d\n"，WEXITSTATUS(status));
            quit = 1;
        }
        else if(res == 0)
        {
            //等待成功 && 子进程未退出
            printf("子进程还在运行中，暂时没有退出\n");
        }
        else
        {
            //等待失败
            printf("wait失败\n");
        }
    }
}

此时就可以看到非阻塞等待的结果；

进程等待的使用；

#include 
#include 
#include 
#include 
 
typedef void (*handler_t)();//函数指针类型
std::vector<handler_t> handlers;//函数指针数组；
 
void fun_one()
{
    printf("这是一个临时任务！\n");
}
void fun_two()
{
    printf("这是一个临时任务！\n");
}
 
//设置对应的方法回调；
//以后想让父进程闲了执行任何方法的时候，只要向Load里面注册，就可以让父进程执行对应的方法；
 
void Load()
{
    handlers,push_back(fun_one);
    handlers,push_back(fun_two);
}
 
int main()
{
    pid_t id = fork();
    if(id==0)
    {
        int cnt = 5;
        while(cnt)
        {
            printf("我是子进程：%d\n",cnt--);
            sleep(1);
        }
        
        exit(1);
    }
    else
    {
        int quit=0;
        while(!quit)
        {
            int status = 0;
            pid_t res = waitpid(-1,&status,WNOHANG);
            if(res > 0)
            {
                //等待成功 && 子进程退出
                printf("等待子进程退出成功，退出码：%d\n"，WEXITSTATUS(status));
                quit = 1;
            }
            else if(res == 0)
            {
                //等待成功 && 子进程未退出
                printf("子进程还在运行中，暂时没有退出\n");
                if(handlers,empty()) Load();
                for(auto iter : handlers)
                {
                    //执行处理其他任务
                    iter();
                }
            }
            else
            {
                //等待失败
                printf("wait失败\n");
                quit=1;
            }
            sleep(1);
        }
    }
}

如果想要让父进程在等待的时候执行什么任务就在Load函数中加入即可；

 进程程序替换

概念+原理

fork（）之后父子各自执行父进程代码的一部分，父子代码共享，数据写时拷贝；如果子进程就想执行全新的程序怎么办？这时就可以使用进程的程序替换来完成此功能；

程序替换是通过特定的接口，加载磁盘上的一个权限的程序（代码和数据），加载到调用进程的地址空间中；让子进程执行其他程序；

原理

如果想要运行other.exe程序就需要将磁盘上的程序加载到内存，并与当前进程的页表重新建立映射，这个过程可以调用系统的接口来完成；

进程替换没有创建新的进程；

如何理解将程序放入内存中？这个过程就叫做加载，编译有编译器，链接有链接器，而对应的加载操作也有加载器；所谓的exec系列的函数本质就是如何加载程序的函数；

创建程序替换；

int execl(const char *path, const char *arg, ...);

在加载程序的第一步就是先找到程序，

函数中的path 是 路径+目标文件名；

... 是可变参数列表，函数可以传入多个不定个数的参数；

就像main函数的命令行参数，最后一个参数必须是NULL表示参数传递完毕；

不创建子进程

#include 
#include 
#incldue 
#include 
#include 
#include 
#include 
 
int main()
{
    printf("当前进程的开始代码\n");
    
    execl("/usr/bin/ls","--color==auto","ls","-l",NULL);
    exit(1);
 
    printf("当前进程的结束代码\n");
    return 0;
}

运行结果在execl函数的后边就会执行命令，ls -l命令；

execl是程序替换在运行函数成功后，会将当前进程的所有代码和数据都进行替换，包括已经执行的和没有执行的；一旦调用成功，后续所有的代码全都不会执行；

如果出错了就会返回-1；

为什么调用成功没有返回值？因为成功了就会将包括函数自身的代码都会被替换，所以就没有对应的返回值；

所以在execl函数后边接exit(1);

"--color==auto"会使输出的字符带颜色；

例如C++程序怎么与python或java语言所写的函数耦合，关键点就在这里；

创建子进程

#include 
#include 
#include 
 
int main()
{
    pid_t id = fork();
    if(id == 0)
    {
        //子进程
        //让子进程执行命令ls -a -l
        printf("子进程开始运行，pid:%d\n",getpid());
        execl("/use/bin/ls","ls","-a","-l",NULL);
        exit(1);
    }
    else
    {
        //父进程
        printf("父进程开始运行，pid：%d\n",getpid());
        int status = 0;
        pid_t id = waitpid(-1,&status,0);//阻塞等待；
        if(id>0)
        {
            printf("wait success,exit code:%d\n",WEXITSTATSU(status));
        }
    }
    return 0;
}

运行结果如图

为什么要创建子进程？

如果不创建子进程，那么退换的程序只能是父进程的，如果创建了子进程，那么替换的程序就是子进程，而不影响父进程；

为了不影响父进程；因为想让父进程聚焦在读取数据，解析数据，指派进程执行代码的功能；

在记载新程序之前，父子进程的代码和数据的关系是代码共享，数据写时拷贝；

当子进程加载新的程序的时候，就是一种写入；代码也会发生写时拷贝，也就是将父子的代码分离；此时父子进程的代码和数据就会彻底分离开；

execv

其中v可以看做是vector；

与execl只有传参方式的区别；

#include 
#include 
#include 
 
#define NUM 16
 
int main()
{
    pid_t id = fork();
    if(id == 0)
    {
        //子进程
        //让子进程执行命令ls -a -l
        printf("子进程开始运行，pid:%d\n",getpid());
        char *const _argv[NUM] = 
        {
        (char*)"ls",
        (char*)"-a",
        (char*)"-l",
        NULL
        };
        execv("/usr/bin/ls",_argv);
        exit(1);
    }
    else
    {
        //父进程
        printf("父进程开始运行，pid：%d\n",getpid());
        int status = 0;
        pid_t id = waitpid(-1,&status,0);//阻塞等待；
        if(id>0)
        {
            printf("wait success,exit code:%d\n",WEXITSTATSU(status));
        }
    }
    return 0;
}

execlp

要执行程序先找到程序；带路径才能找到，不带路径可以找到程序吗？

通过PATH环境变量可以找到程序，

此函数就是会自己在环境变量中查找，不用传入路径；

execlp("ls","ls","-a","-l",NULL);

前边的ls表示要找的程序，后边的ls表示要怎么执行这个程序；

execvp

与execlp函数的不同点就是传参方式不同；

execvp("ls",_argv);

execle

如何执行其他自己写的C++、二进制程序；

#include 
#include 
#include 
 
int main(int argc,char *argv[])
{
    if(argc != 2)
    {
        printf("can not execute!\n");
        exit(1);
    }
        
    if(strcmp(argv[1],"-a") == 0)
    {
        printf("hello a!\n");
    }
 
    else if(strcmo(argv[1],"-b") == 0)
    {
        printf("hello b!\n");
    }
    else
    {
        printf("default!\n");
    }
 
    return 0;
}

#include 
#include 
#include 
 
#define NUM 16
 
const char *myfile = "/zzz/111/222/myfile1";
//若此处使用路径 "./myfile" 也可以正常执行； 
 
int main()
{
    pid_t id = fork();
    if(id == 0)
    {
        //子进程
        //让子进程执行命令ls -a -l
        printf("子进程开始运行，pid:%d\n",getpid());
 
        execl(myfile,"myfile1","-a",NULL);
        exit(1);
    }
    else
    {
        //父进程
        printf("父进程开始运行，pid：%d\n",getpid());
        int status = 0;
        pid_t id = waitpid(-1,&status,0);//阻塞等待；
        if(id>0)
        {
            printf("wait success,exit code:%d\n",WEXITSTATSU(status));
        }
    }
    return 0;
}

如何执行其他语言的程序；

 test.py

#! /usr/bin/python3.6
 
print("hello Python\n");

test.sh

#! /usr/bin/bash
 
echo "hello shell!"

execlp函数的使用

execlp("python","python","test.py",NULL);

当Python加上可执行权限时

execlp("./test.py","test.py"，NULL);

exec系列的函数其实就是加载器的底层接口；

execle函数

使用

execle(myfile,"myfile","-a",NULL,);

首先获取环境变量

myfile1.c

#include 
#include 
#include 
 
int main(int argc,char *argv[])
{
    if(argc != 2)
    {
        printf("can not execute!\n");
        exit(1);
    }
        
    //MY_VAL:目前此环境变量并不存在；
    printf("获取环境变量：MY_VAL: %s\n",getenv("MY_VAL"));
 
    if(strcmp(argv[1],"-a") == 0)
    {
        printf("hello a!\n");
    }
 
    else if(strcmo(argv[1],"-b") == 0)
    {
        printf("hello b!\n");
    }
    else
    {
        printf("default!\n");
    }
 
    return 0;
}

exec.c

#include 
#include 
#include 
 
#define NUM 16
 
const char *myfile = "/zzz/111/222/myfile1";
//若此处使用路径 "./myfile" 也可以正常执行； 
 
int main()
{
    char *_env[NUM]=
    {
        (char*)"MY_VAL = 8877",//环境变量；
        NULL
    }
    pid_t id = fork();
    if(id == 0)
    {
        //子进程
        //让子进程执行命令ls -a -l
        printf("子进程开始运行，pid:%d\n",getpid());
 
        execle(myfile,"myfile1","-a",NULL,_env);
        exit(1);
    }
    else
    {
        //父进程
        printf("父进程开始运行，pid：%d\n",getpid());
        int status = 0;
        pid_t id = waitpid(-1,&status,0);//阻塞等待；
        if(id>0)
        {
            printf("wait success,exit code:%d\n",WEXITSTATSU(status));
        }
    }
    return 0;
}

此时就会将_env的环境变量传到myfile1中；

 execve函数是真正的系统调用函数，其他的几个函数都是间接的使用这个函数，是系统提供的基本封装，为了满足上层的不同应用场景；

简易的shell实现 

myshell.c

#include 
#include 
#include 
#include 
#include 
#include 
 
#define NUM 1024
#define SIZE 32
#define SEP " "
 
//保存打散之后的命令行字符串；
char *g_argv[SIZE];
//保存完整的命令行字符串；
char cmd_line[NUM];//定义一个大小是1024的缓冲区；
 
//shell 运行原理通过让子进程执行命令，父进程等待并且解析命令
//除了要执行系统的命令还要执行自己的命令，如果自己的命令崩溃那么不会影响父进程，使得父进程能够继续解析命令；
int main()
{
    //0、命令行解释器一定是一个常驻内存的进程，就是不退出；
    while (1)
    {
        //1、打印出提示信息
        //[zyl@123456host myshell]
        printf("[root@123456host myshell]# \n");//后边需要加\n ，否则数据在缓冲区内；
        fflush(stdout);//在输入命令时总是换行，与printf里的内容不在一行；
        memset(cmd_line, '\0', sizeof cmd_line);//sizeof可以不带圆括号；
 
        //2、获取用户的输入，输入的是各种命令和选项：ls -a -l -i
        if (fgets(cmd_line, sizeof cmd_line, stdin) == NULL)
        {
            continue;
        }
 
        cmd_line[strlen(cmd_line) - 1] = '\0';//由于在输入时输入了回车，所以在打印的时候也会打印处一行空行，
        //于是通过上边的这行代码将 \n 置为0；
 
        printf("echo: %s\n", cmd_line);
        //3、命令行字符串解析：将输入的命令 "ls -a -l -i" 转换成 "ls" "-a" "-l" "-i"
        g_argv[0] = strtok(cmd_line, SEP);//第一次调用，要传入原始字符
        int index = 1;
        if (strcmp(g_argv[0], "ls") == 0)//使得ls命令行带有颜色
        {
            g_argv[index++] = "--color=auto";
        }
        //while 先调用函数，然后赋值给g_argv，然后while检测g_argv中的值；
        while (g_argv[index] = strtok(NULL, SEP));//第二次，如果还要解析原始字符串，传入NULL；
 
        for (index = 0; g_argv[index]; index++)
        {
            printf("g_argv[%d]: %s\n", index, g_argv[index]);
        }
        //4、内置命令处理：让父进程自己执行的额命令，叫做内置命令（内建命令）；
        //本质就是shell中的函数调用；
        //如果没有第四步，那么执行任何命令都会运行execvp，那么在cd .. 的时候就会出现路径不发生变化的现象
        //只会使子进程的路径发生变化，已运行完就会退出；但是pwb打印出来的相当于是父进程的路径没有改变；
 
        if (strcmp(g_argv[0], "cd") == 0)//不想让子进程执行，希望使父进程执行命令，
        {
            //chdir函数更改当前的路径
            if (g_argv[1] != NULL)
            {
                chdir(g_argv[1]);
            }
            continue;
        }
        //5、fork()
        pid_t id = fork();
        if (id == 0)
        {
            //child
            printf("下面的功能让子进程进行！\n");
            execvp(g_argv[0],g_argv);
            exit(1);
        }
        int status = 0;
        pid_t ret = waitpid(id, &status, 0);
        if (ret > 0)
        {
            printf("exit code: %d\n", WEXITSTATUS(status));
        }
    }
    //
    return 0;
}

为什么要进行程序替换？

和应用场景有关，在一些场景下需要对程序进行替换；

 

shell执行的命令通常有两种：

1、第三方提供的对应的在磁盘中有具体的二进制文件的可执行程序（由子进程执行）；

2、shell内部，自己实现的方法，由自己（父进程）来执行；因为有些命令要影响shell本身的cd，export；