进程创建
进程创建的最常见的两种场景:
1.命令行启动命令(程序,指令等)
2.通过程序自身fork出来子进程
fork函数
fork在前面有讲过，关于fork的用法可以去前面看看。在这里接着往下讲:
fork创建子进程是以父进程为模板的，很多数据代码继承父进程，它从存在进程中创建一个新进程。新进程为子进程，而原进程为父进程。
fork函数也是一个系统调用接口，为当前进程创建子进程，子进程返回0，父进程返回子进程pid,出错返回-1。
进程调用fork函数，内核需要做什么?
- 给子进程分配内存空间,并为子进程创建PCB
- 将父进程部分数据结构内容(还有代码和数据暂时共享)拷贝至子进程
- 添加子进程到系统进程列表(运行队列)当中
- fork返回，开始CPU调度器调度
代码如下:
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
int main()
{
pid_t ret = fork();
if (ret < 0)
{
perror("fork");
return 1;
}
else if (ret == 0)// 子进程
{
printf("I am child-pid:%d, ppid:%d\n", getpid(), getppid());
sleep(1);
}
else if (ret > 0)// 父进程
{
printf("I am parent-pid:%d, ppid:%d\n", getpid(), getppid());
sleep(1);
}
sleep(1);
return 0;
}
运行结果
返回值:子进程返回0，父进程返回子进程id,出错返回-1
为什么有两个返回值?
fork之后会进入内核，fork函数的实现进行申请内存构建数据结构PCB,虚拟内存，页表，最后将当前进程设置为R状态，放置进调度列表中，此时进程已经创建成功,父子进程共享代码，fork函数的最后一个代码是返回一个值,return ret这个代码父子进程都会执行一次，所以会有两个返回值。
在返回时，将函数的返回值返回给变量,发生了写时拷贝,一个变量名但是内容是不相同的,本质父子页表映射数据到了不同的内存区域。
写时拷贝
通常情况下，父子进程共享一份代码，且数据也是共享的，当任意一方试图写入更改数据，那么者一份便要以写时拷贝的方式各自私有一份副本，写时拷贝的识别，操作等是由OS完成。
从图中可以看出,发生写时拷贝后，修改方将改变页表中对该份数据的映射关系,父子进程各自私有那一份数据，且权限由只读变成只写。
在不写入的情况下，父子进程共享代码和数据:
#include<stdio.h>
#include<unistd.h>
int main()
{
const char *str = "hello Linux!\n";
fork();
while(1)
{
printf("pid:%d,ppid: %d,str: %s\n",getpid(),getppid(),str);
sleep(1);
}
return 0;
}
运行结果
可以看到代码每次执行两次，其实是两个进程在执行。其中，默认情况下，父子进程共享代码，但是数据是各自私有一份的。
代码共享:所有代码共享，因为程序计数器的原因，一般都是从fork之后开始执行，那么为什么代码要共享?因为代码是不可以被修改的，所以各自私有浪费空间。为什么数据要私有一份？因为进程之间具有独立性，如果父进程正在执行，子进程将父进程的数据改了，那就影响到了父进程。
fork常规用法
- 一个父进程希望复制自己，使父子进程同时执行不同的代码段:父进程等待客户端请求，生成子进程来处理请求。
- 一个进程要执行一个不同的程序。例如子进程从fork返回后，调用exec函数。
fork调用失败的原因
- 系统中有太多进程
- 实际用户的进程数超过了限制
问题分析
- 为什么代码是共享？
代码是不能被修改的，各自私有是很浪费空间的，大多数情况下是共享的，但是在特殊情况下，代码也是会发生写时拷贝的,也就是进程的程序替换(后面详细讲)。
** 2.写时拷贝的作用?**
- 可以减少空间浪费，在双方都不对数据或代码进行修改的情况下，各自私有一根数据和代码是浪费空间的。
- 维护进程之间的独立性，虽然父子进程共享一份数据，但是父子中有一方对数据进行修改,那么就拷贝该份数据给修改方，改变修改方中页表对这份数据的映射关系，然后对数据进行修改，这样不管哪一方对数据进行修改都不会影响另一方，这样就做到了独立性。
** 3.写时拷贝是对所有数据进行拷贝嘛?**
答案是否定的。如果没有修改的数据进行拷贝，那么这样还是会造成空间浪费的，没有被修改的数据还是可以共享的，我们只需要将修改的那份数据进行写时拷贝即可。
进程终止
进程退出三种场景
- 代码运行完成，结果正确
代码没有任何错误，且代码逻辑正确
- 代码运行完成，结果不正确
代码运行过程中没有任何错误，但是代码逻辑存在问题,导致结果不正确
- 代码运行异常终止
代码运行过程中发生了例一些异常终止的错误，如:野指针访问，除零错误等
进程常见退出方法
正常终止
1.main函数返回退出码
main函数退出的时候，return的返回值就是进程的退出码。0在函数的设计中,一般代表是正确而非0就是错误的。
echo $?
实例演示:
int main()
{
return 0;
}
运行结果
为什么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;
}
** 2.调用exit函数**
exit:终止整个进程，任何地方调用，都会终止
return:终止函数，如果是main函数return ,代表终止进程
int main()
{
cout << "12345";
sleep(3);
exit(0);// 退出进程前前会执行用户定义的清理函数，且刷新缓冲区
return 0;
}
运行结果
调用exit函数，此时直接就讲进程终止了，并不会再去执行下面的语句了。
3.调用_exit函数
exit和_exit几乎一模一样，区别在于exit是库函数，_exit是系统调用，exit在退出程序时会刷新缓冲区,而_exit在退出时不会刷新缓冲区。
会刷新缓冲区
int main()
{
cout<<"123";//写入缓冲区
exit();
}
不会刷新缓冲区
int main()
{
cout<<"123";//写入缓冲区
_exit();
}
示意图:
**异常终止 **
- ctrl+C终止前台进程
- ctrl+C终止前台进程
站在OS角度，如何理解进程终止?
进程终止的核心思想就是归还资源：
1、"释放"曾经为了管理进程所维护的所有的数据结构对象。
2、释放程序代码和数据占用的内存空间。
3、取消曾经该进程的链接关系(比如和它和它的父进程之间的链接关系)
上面提到了两个释放，所谓第一个释放不是真的把数据结构对象销毁，而是设置为不用状态，然后保存起来，如果不用的对象多了，就有一个"数据结构的池"
第二个释放不是代码和数据清空，而是把内存设置为无效就可以了
实际上我们每次申请空间是比较耗时的，由于所申请内存块的大小不定，当频繁使用时会造成大量的内存碎片并进而降低性能。 内存池则是在真正使用内存之前，先申请分配一定数量的、大小相等(一般情况下)的内存块留作备用。当有新的内存需求时，就从内存池中分出一部分内存块，若内存块不够再继续申请新的内存。这样做的一个显著优点是，使得内存分配效率得到提升。而数据结构池就是，当一个进程创建时有task_struct，mm_struct等各种数据结构变量，而我们在申请这些内存时，每次都要将这块内存强转为(task_struct*)，(mm_struct*)，这样时间效率肯定不好，所以就有一个数据结构池，这里面是一些无效的pcb以及mm_struct，他们处于一个废弃队列当中，当创建进程需要内存时，就将这里的内存提取出去。
进程等待
进程等待的必要性:
- 子进程必须要比父进程先退出,否则会变成孤儿进程
- 父进程必须读取子进程的退出状态，回收子进程的资源。如果父进程不读取子进程退出状态,还不会是子进程资源，那么子进程将处于僵死状态，会造成内存泄漏
- 父进程派给子进程的任务完成的如何，得知子进程执行结果
进程等待的方法
wait方法
wait函数原型:
#include<sys/types.h>
#include<sys/wait.h>
pid_t wait(int* status);
返回值
返回值有两种，一种是等待进程的pid,另一种就是-1，等待成功返回等待进程的pid,等待失败就返回-1
参数
status是一个输出型参数,可以通过传地址获得进程退出状态,如果不想关心进程退出状态，就传NULL
实例演示
让子进程先运行5s,然后退出进程,子进程由S状态变为Z状态,父进程等待子进程,回收子进程资源后，子进程变为Z状态变为X状态,10秒回父进程退出
代码如下
#include <iostream>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/types.h>
int main()
{
pid_t ret= fork();
if (ret< 0){
cerr << "fork error" << endl;
}
else if (ret== 0){
// child
int count = 5;
while (count){
printf("child[%d]:I am running... count:%d\n", getpid(), count--);
sleep(1);
}
exit(1);
}
// parent
printf("father begins waiting...\n");
sleep(10);
pid_t id = wait(NULL);// 不关心子进程退出状态
printf("father finish waiting...\n");
if (id > 0){
printf("child success exited\n");
} else{
printf("child exit failed\n");
}
//父进程再活5秒
sleep(5);
return 0;
}
命令行监控脚本如下
while :; do ps axj | head -1 && ps axj | grep test | grep -v grep ; sleep 1; echo "############"; done
运行结果
子进程由S状态转变为Z状态
父进程等待子进程，回收子进程资源后，子进程变为Z状态变为X状态
waitpid方法
函数原型如下
pid_ t waitpid(pid_t pid, int *status, int options);
函数返回值
- 当正常返回的时候waitpid返回收集到的子进程的进程ID;
- 如果设置了选项WNOHANG,而调用中waitpid发现没有已退出的子进程可收集，则返回0；
- 如果调用中出错，则返回-1，这时errno会被设置成相应的值以指示错误所在；
参数
- pid
pid=-1时，可以等待任一个子进程,与wait等待
pid>0时，等待和pid相同的ID的子进程
- status
是一个输出型参数，不想关心进程退出状态就传NULL
WIFEXITED(status):若为正常终止子进程返回的状态，则为真(查看进程是否是正常退出)
**WEXITSTATUS（status):**若WIFEXITED非零,提取子进程退出码。(查看进程的退出码)
- options
WNOHANG:若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束,则返回该子进程的ID(可以进行基于阻塞等待的轮询访问)
0:阻塞等待(等待期间父进程不执行任何操作)
实例演示
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>
int main()
{
pid_t id=fork();
if(id==0)
{
int cnt=3;
while(cnt)
{
printf("child[%d] is running:cnt is:%d\n",getpid(),cnt);
cnt--;
sleep(1);
}
//exit(0);
exit(11);
}
printf("father wait begin!\n");
int status=0;
pid_t ret=waitpid(id,&status,0);
if(ret>0)
{
printf("father wait:%d,success,status exit code:%d.status exit signal:%d\n",ret,(status>>8)&0xFF,status&0x7F);
}
else{
printf("father wait failed!\n");
}
}
运行结果
正常跑完，结果正确
正常跑完，结果不正确
异常终止
获取子进程的status
- wait和waitpid中都有一个status参数,该参数是一个输出型参数,由操作系统来填充
- 如果该参数给NULL,那么代表不关心子进程的退出信息
** status的几种状态:(我们只研究status的低16位)**
看图可以知道，低7位代表的是终止信号，第8位时core dump标志，高八位是进程退出码（只有正常退出是这个退出码才有意义）
status的0-6位和8-15位有不同的意义。我们要先读取低7位的内容，如果是0，说明进程正常退出，那就获取高8位的内容，也就是进程退出码；如果不是0，那就说明进程是异常退出，此时不需要获取高八位的内容，此时的退出码是没有意义的。
实例演示
#include <iostream>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/types.h>
int main()
{
pid_t ret = fork();
if (ret < 0){
cerr << "fork error" << endl;
}
else if (ret == 0){
// child
int count = 5;
while (count){
printf("child[%d]:I am running... count:%d\n", getpid(), count--);
sleep(1);
}
exit(1);
}
// parent
printf("father begins waiting...\n");
int status;
pid_t id = wait(&status);// 从status中获取子进程退出的状态信息
printf("father finish waiting...\n");
if (id > 0 && (status&0x7f) == 0){
// 正常退出
printf("child success exited, exit code is:%d\n", (status>>8)&0xff);
}
else if (id > 0){
// 异常退出
printf("child exit failed,core dump is:%d,exit singal is:%d\n", (status&(1<<7)), status&0x7f);
}
else{
printf("father wait failed\n");
}
if (id > 0){
printf("child success exited\n");
} else{
printf("child exit failed\n");
}
return 0;
}
代码运行结果如下
阻塞等待和非阻塞等待
操控者： 操作系统
阻塞的本质： 父进程从运行队列放入到了等待队列，也就是把父进程的PCB由R状态变成S状态，这段时间不可被CPU调度器调度
等待结束的本质： 父进程从等待队列放入到了运行队列，也就是把父进程的PCB由S状态变成R状态，可以由CPU调度器调度
阻塞等待： 父进程一直等待子进程退出，期间不干任何事情
** 实例1：**
#include <iostream>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/types.h>
int main()
{
pid_t id = fork();
if (id < 0){
cerr << "fork error" << endl;
}
else if (id == 0){
// child
int count = 5;
while (count){
printf("child[%d]:I am running... count:%d\n", getpid(), count--);
sleep(1);
}
exit(0);
}
// 阻塞等待
// parent
printf("father begins waiting...\n");
int status;
pid_t ret = waitpid(id, &status, 0);
printf("father finish waiting...\n");
if (id > 0 && WIFEXITED(status)){
// 正常退出
printf("child success exited, exit code is:%d\n", WEXITSTATUS(status));
}
else if (id > 0){
// 异常退出
printf("child exit failed,core dump is:%d,exit singal is:%d\n", (status&(1<<7)), status&0x7f);
}
else{
printf("father wait failed\n");
}
}
- 非阻塞等待： 父进程不断检测子进程的退出状态，期间会干其他事情（基于阻塞的轮询等待）实例2
#include <iostream>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/types.h>
int main()
{
pid_t id = fork();
if (id < 0){
cerr << "fork error" << endl;
}
else if (id == 0){
// child
int count = 5;
while (count){
printf("child[%d]:I am running... count:%d\n", getpid(), count--);
sleep(1);
}
exit(0);
}
// 基于阻塞的轮询等待
// parent
while (1){
int status;
pid_t ret = waitpid(-1, &status, WNOHANG);
if (ret == 0){
// 子进程还未结束
printf("father is running...\n");
sleep(1);
}
else if (ret > 0){
// 子进程退出
if (WIFEXITED(status)){
// 正常退出
printf("child success exited, exit code is:%d\n", WEXITSTATUS(status));
}
else{
// 异常退出
printf("child exited error,exit singal is:%d", status&0x7f);
}
break;
}
else{
printf("wait child failed\n");
break;
}
}
}
进程程序替换
fork创建子进程后一般会有两种行为:
- 想让子进程执行父进程的一部分代码(可以理解为子承父业)
- 想让子进程执行和父进程完全不同的代码，也就是程序替换(可以理解为儿子创业)
原理
用fork创建子进程后执行的是和父进程相同的程序(但有可能执行不同的代码分支)，子进程往往要调用一种exec函数以执行另一个程序。当程序调用一种exec函数时,该进程的用户空间代码和数据完全被新程序替换，从新程序的启动例程开始执行。调用exec并不创建新进程,所以调用exec前后该进程的id并未改变。
**问题: **
1.程序替换的本质是什么?
把磁盘中的程序的代码和数据用加载器加载进特定的进程的上下文,底层用到了exec系列的程序替换了函数。
2.程序替换后，有没有新进程被创建?
没有。因为进程替换前后，没有创建新的PCB，虚拟内存和页表等数据结构,也就是进程的这些数据结构没有发生变化，进程替换只是对物理内存中的数据和代码进行了修改,前后进程的ID没有发生改变,所以程序替换不创建新进程.
3. 子进程发生程序替换后,代码和数据都发生写时拷贝嘛?
由于进程替换会把新程序的代码和数据加载到特定的进程,为了让父子进程之间具有独立性,修改的代码和数据都要发生写时拷贝,这样才不会影响父进程的数据和代码。
替换函数
其中有六种以exec开头的函数,统称exec函数:操作系统其实只提供了第六个系统调用接口，其他五个都是由第六个系统调用接口封装出来的。
#include <unistd.h>
extern char **environ;
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[]);
函数返回值:只要exec*返回，就一定调用失败了，调用成功不需要有返回值检测。
函数参数:
- **path:**用来替换的程序所在的路径
- **file:**程序名
- arg,...:列表的形式传参
- **arg[]:**数组的形式传参
- 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);
参数命名中有I的需要一个一个进行传参，有v的需要将参数放入数组，通过数组传参，有p的第一个参数是file,而不带p的第一个参数是path,有p自动去环境变量PATH中搜索;传参时可以直接传想要使用的命令,不需要传路径，会自动搜索,只需要告诉执行的命令是谁
函数的使用方法
函数名参数格式是否带路径是否使用当前环境变量execl列表是是execlp列表否是execle列表是否，自己组装环境变量execv数组是是execvp数组否是execve数组是否，自己组装环境变量
** execl**
第一个参数是你要执行哪个程序(需要带路径),因为执行程序需要知道你在哪，你是谁,第二个是要执行的程序名，命令行怎么执行,传入什么选项,你就可以在这里直接按照顺序填写参数,命令行上怎么写，这里就怎么写，这种传参方式叫做list方式,最后必须以NULL结尾,告知execl传参结束。
#include<stdio.h>
#include<unistd.h>
int main()
{
execl("/usr/bin/ps","ps","-e","-l","-f",NULL);
return 0;
}
** 运行结果**
第一个参数代表你要执行谁，第二个参数是你在命令行怎么调用执行，在后面的参数中你就怎么传递。
再看一组程序
#include<stdio.h>
#include<unistd.h>
int main()
{
printf("begin............................\n");
execl("/usr/bin/ls","ls","-a","-l","-i",NULL);
printf("hello world\n");
printf("hello world\n");
printf("hello world\n");
printf("hello world\n");
return 0;
}
** 运行结果**
./test是自己写的可执行程序,./test变成了进程,代码执行到execl，进行程序替换，用ls进程的代码和数据替换test进程的代码和数据,执行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");
printf("hello world!\n);
printf("hello world!\n");
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());
execlp("ls","ls","-al",NULL);
printf("hello world!\n);
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;
}
父进程正常执行自己要干的事情，因为替换的是子进程，进程是有独立性的，所以，父进程是不受影响的！
简易shell的实现
要写一个shell,需要循环以下过程:
1.获取命令行
2.解析命令行
3.建立一个子进程(fork)
4.替换子进程(execvp)
5.父进程等待子进程退出(waitpid)
我们发现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，首先我们登录主机后，会打印命令提示符(用户名@主机名 当前目录)提示符，这里我们为了简单，就直接打印一个主机名:
const char* cmd_line = "[temp@VM-0-3-centos myshell]#";
然后我们需要做的就是数据读取，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：
我们期望改的是父进程shell的当前路径，这里则是修改的是子进程的当前路径，子进程干完事就退出了，所以不能创建子进程执行cd，也不能让父进程通过程序替换去执行cd，因为执行了父进程会影响，所以需要系统接口来完成命令的执行。
如果想要支持cd命令，就需要在创建子进程前判断命令：
if(strcmp( args[0]，"cd" ) == 0 && chdir(args[1])== 0)//chdir修改当前路径
{
continue;
}
执行结果
最终代码
#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;
}
版权归原作者 接受平凡 努力出众 所有， 如有侵权，请联系我们删除。