使用进程创建、等待、终止等知识自主实现简单的Linuxshell命令行，Linux环境：CentOS7.3

进程创建

创建进程的方式

• 通常使用fork()函数来创建一个新进程，新进程为子进程，而原来的进程即为父进程。在Linux中fork()是一个非常重要的函数，它的头文件为<unistd.h>。
• 通过vfork()也可以来创建一个子进程，它的返回值与fork()相同。

fork()的返回值

fork()函数有两个返回值，它会给子进程返回0，给父进程返回子进程的pid，如果创建子进程失败，则会返回-1。

写时拷贝

通过fork()创建的子进程与父进程会共享同一份代码，因为代码段的数据是只读的，不会发生写入，而当父进程与子进程的数据段不发生写入时，它们的数据段也是共享的，当子进程或父进程任何一方发生写入时，就会另外开辟自己的数据段，将原来的数据拷贝过去。

fork()与vfork()的区别

• 通过vfork()函数创建的子进程与父进程共享同一块地址空间，而通过fork()创建的子进程与父进程各自拥有自己独立的地址空间。
• 通过vfork()创建进程会保证子进程先运行，等到子进程调用exec(进程替换)或exit(退出)之后，父进程才会被执行。

进程终止

进程终止的情况

正常终止(可以通过echo $?来查看退出码，echo $?只可查看最近一次退出的进程的退出码)

• 从main主函数返回(return):调用main函数运行时，函数会将main的返回值当做exit()的参数
• 调用exit函数：exit()函数的参数即为退出码
• _exit

异常退出

• 通过对进程发送信号终止进程

_exit(int status)与exit(int status)的区别

• _exit()相比exit()而言，退出的更加粗暴直接，而exit()在进程退出之前，还会做许多收尾工作，但在exit()函数中，最终还是会调用_exit()。

进程等待

进程等待的意义

• 子进程退出，如果父进程不采取措施，那么子进程就会变成一个僵尸进程，而僵尸进程会造成操作系统内存泄露。
• 子进程退出时，会返回子进程任务的执行信息，父进程需要获取到子进程的退出信息。

进程等待的方式

wait方法&waitpid方法

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

pid_t wait(int* status);
返回值：
	成功返回则返回被等待进程的ID,失败返回0
参数：
	获取子进程的退出状态，不关心则设置为NULL

pid_t waitpid(pid_t pid, int* status, int options);
返回值：
	当waitpid收集到已退出的子进程时waitpid返回被等待进程的ID
	如果设置了选项WNOHANG,而调用waitpid发现没有已退出的子进程可以被收集时，则返回0
	
参数说明：
	pid:
		pid=-1,等待任意一个子进程，与wait效果相同。
		pid>0,等待进程ID与pid相等的子进程。
	status:
		WIFEXITED(status): status若为正常终止子进程返回的状态，则为真。
		WEXITSTATUS(status): 若WIFEXITED非零，提取子进程提出码。
	options:
		WNHANG:若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束，则返回该子进程的ID。
		

• 如果子进程已经退出，则调用wait/waitpid时，wait/waitpid会立即返回，并且释放资源，并获得子进程退出信息。
• 如果当调用wait/waitpid时子进程存在并且正常运行，则进程可能阻塞。
• 如果不存在该子进程，则立即出错返回。

子进程退出信息status

• 子进程的退出信息会被操作系统保存在status内，当我们使用wait/waitpid时，如果想知道子进程的退出信息，就必须定义一个int类型的变量，将该变量的地址传给wait/waitpid,操作系统就会将收集到的子进程的退出信息保存在该变量内。
• 当子进程的退出信息我们不需要时，亦可以传递NULL空指针
• status虽然是一个整型变量，但是它并不是代表一个简单的整型数字，它可以当作位图来看待。
• status示意图：(仅研究status的低16比特位)
  

代码实现简单的shell

设计思想

• 创建父进程，父进程的工作为打印shell提示信息，等待标准输入输入命令
• 当命令输入之后，父进程创建子进程，子进程的工作为使用exec()函数进行进程替换
• 在子进程运行的过程中，父进程持续等待子进程，待子进程退出之后，父进程即可继续循环

#include<stdio.h>
#include<stdlib.h>
#include<sys/wait.h>
#include<string.h>
#include<unistd.h>
#define MAX_ARGV 20
#define MAX_CMD 1024
void cut_str(char* argv[],char cmd[])//将输入的命令分段，保存至argv[]指针数组内
{
  char* ptr=cmd;
  int i=0;
  int flag=0;
  while(*ptr!='\0')
  {
    if(*ptr!=' '&&flag==0)
    {
      argv[i++]=ptr;
      flag=1;
    }
    else if(*ptr==' '&&flag==1)
    {
      *ptr='\0'; 
      argv[i++]=ptr+1;
    }
    ptr+=1;
  }
  
  //去掉命令尾部的'\n'
  ptr=argv[i-1];
  while(*ptr!='\0')
  {
    ptr+=1;
  }
  *(ptr-1)='\0';
  
  //以NULL结尾
  argv[i]=NULL;
}

void new_pro(char* argv[])
{
  pid_t id=fork();
  if(-1==id)
  {
    perror("fork");
    exit(-1);
  }
  else if(0==id)//子进程
  {
    execvp(argv[0],argv);
  }
  else//父进程
  {
    int st;//定义st用来保存子进程的返回信息
    while(wait(&st)!=id);//使用while循环为了确保wait()收集到的子进程是上面所创建的子进程
  }
}
int main()
{
  char cmd[MAX_CMD]={'\0'};//定义数组来保存输入的内容
  char* argv[MAX_ARGV];//定义一个数组来存放argv(execvp()函数的第二个参数)
  while(1)
  {
    printf("[ahao@AHAOAHA ~ ]& ");//打印shell提示符
	
	//此处不能使用scanf()函数来接受，因为scanf()在用“%s”格式输入字符时，输入的字符串中含有空白字符(space,tab,newline)。字符串读取结束
    fgets(cmd,sizeof(cmd),stdin); //从标准输入来接受将要执行的命令
    cut_str(argv,cmd);//将输入的命令切开，并将其的地址存入数组argv[]，最终以NULL结尾
    new_pro(argv);//新进程，在此函数内会创建一个子进程，在子进程运行的时候，父进程会等待子进程，待到子进程运行完毕，父进程才会继续向下运行
  }
  return 0;
}

封装fork/wait函数，编写函数process_create(pid_t* pid,void* fun ,void* arg),func回调函数就是子进程执行的函数入口，arg是传递给func回调函数的参数

#include<sys/wait.h>
#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
void process_create(pid* pid, void func, void* arg)
{
	*pid = fork();
	typedef void (PF*)(void* arg);//重命名一个返回值为void，只有一个参数为void*函数指针PF,用来对回调函数强制转换
	if(-1 == *pid)//创建子进程失败
	{
		exit(-1);
	}
	else if(0 == *pid)//子进程
	{
		if(NULL == func)//判断是否传递回调函数地址
		{
			printf("未传递回调函数地址！\n");
			exit(0);
		}
		((PF)func)(arg);//执行func函数，先要进行强制类型转换
		exit(0);
	}
	else//父进程
	{
		int st;
		while(wait(&st) == *pid);
	}
	
}

fork+exec与system/popen的区别

system函数

#include<stdlib.h>

int system(const char* command);

• system函数用来在程序中执行shell命令行的命令。

system的源码

int system(const char *command)
{
    struct sigaction sa_ignore, sa_intr, sa_quit;
    sigset_t block_mask, orig_mask;
    pid_t pid;

    sigemptyset(&block_mask);
    sigaddset(&block_mask, SIGCHLD);
    sigprocmask(SIG_BLOCK, &block_mask, &orig_mask);        //1. block SIGCHLD

    sa_ignore.sa_handler = SIG_IGN;
    sa_ignore.sa_flags = 0;
    sigemptyset(&sa_ignore.sa_mask);
    sigaction(SIGINT, &sa_ignore, &sa_intr);                //2. ignore SIGINT signal
    sigaction(SIGQUIT, &sa_ignore, &sa_quit);                //3. ignore SIGQUIT signal

    switch((pid = fork()))
    {
        case -1:
            return -1;
        case 0:
            sigaction(SIGINT, &sa_intr, NULL); 
            sigaction(SIGQUIT, &sa_quit, NULL); 
            sigprocmask(SIG_SETMASK, &orig_mask, NULL);
            execl("/bin/sh", "sh", "-c", command, (char *) 0);
            exit(127);
        default:
            while(waitpid(pid, NULL, 0) == -1)    //4. wait child process exit
            {
                if(errno != EINTR)
                {
                    break;
                }
            }
    }
}

• system函数在执行的过程中，在子进程没有退出前，父进程会一直等待，直到子进程运行结束，所以system是串行执行。
• system对SIGCHLD、SIGINT、SIGQUIT信号做了处理

popen函数

#include<stdio.h>
FILE* popen(const char* command, const char* type);
int pclose(FILE* stream);

popen()也是执行shell命令并且通过管道和shell命令进行通信。

popen源码

static pid_t    *childpid = NULL;  
                        /* ptr to array allocated at run-time */  
static int      maxfd;  /* from our open_max(), {Prog openmax} */  

#define SHELL   "/bin/sh"  

FILE *  
popen(const char *cmdstring, const char *type)  
{  
    int     i, pfd[2];  
    pid_t   pid;  
    FILE    *fp;  

            /* only allow "r" or "w" */  
    if ((type[0] != 'r' && type[0] != 'w') || type[1] != 0) {  
        errno = EINVAL;     /* required by POSIX.2 */  
        return(NULL);  
    }  

    if (childpid == NULL) {     /* first time through */  
                /* allocate zeroed out array for child pids */  
        maxfd = open_max();  
        if ( (childpid = calloc(maxfd, sizeof(pid_t))) == NULL)  
            return(NULL);  
    }  

    if (pipe(pfd) < 0)  
        return(NULL);   /* errno set by pipe() */  

    if ( (pid = fork()) < 0)  
        return(NULL);   /* errno set by fork() */  
    else if (pid == 0) {                            /* child */  
        if (*type == 'r') {  
            close(pfd[0]);  
            if (pfd[1] != STDOUT_FILENO) {  
                dup2(pfd[1], STDOUT_FILENO);  
                close(pfd[1]);  
            }  
        } else {  
            close(pfd[1]);  
            if (pfd[0] != STDIN_FILENO) {  
                dup2(pfd[0], STDIN_FILENO);  
                close(pfd[0]);  
            }  
        }  
            /* close all descriptors in childpid[] */  
        for (i = 0; i < maxfd; i++)  
            if (childpid[ i ] > 0)  
                close(i);  

        execl(SHELL, "sh", "-c", cmdstring, (char *) 0);  
        _exit(127);  
    }  
                                /* parent */  
    if (*type == 'r') {  
        close(pfd[1]);  
        if ( (fp = fdopen(pfd[0], type)) == NULL)  
            return(NULL);  
    } else {  
        close(pfd[0]);  
        if ( (fp = fdopen(pfd[1], type)) == NULL)  
            return(NULL);  
    }  
    childpid[fileno(fp)] = pid; /* remember child pid for this fd */  
    return(fp);  
}

• popen在执行的过程中，父进程并没有等待子进程运行完成，所以popen是并行执行。
• 使用popen函数时，必须在调用popen函数之后调用pclose函数来回收子进程，否则子进程就会变成一个僵尸进程，会造成操作系统内存泄漏。
• popen函数没有屏蔽SIGCHLD、SIGINT、SIGQUIT信号。