【Linux进程控制】

进程创建

fork函数初识

在Linux中fork函数是非常重要的函数，它从已存在进程中创建一个新进程，新进程为子进程，而原进程为父进程。

#include<unistd.h>
pid_t fork(void);
返回值：子进程中返回0，父进程返回子进程id，出错返回-1

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

• 分配新的内存块和内存数据结构给子进程
• 将父进程部分数据结构内容拷贝至子进程
• 添加子进程到系统进程列表当中
• fork返回，开始调度器调度
  

写时拷贝

通常父子代码共享，父子在不写入时，数据也是共享的，当任意一方试图写入，编以写时拷贝的方式各自创建副本，具体见下图

fork常规用法

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

fork调用失败的原因

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

进程终止

进程退出场景

• 代码运行完毕，结果正确
• 代码运行完毕，结果错误
• 代码异常终止

  1 #include<stdio.h>
  2 
  3 int add_to_top(int top)
  4 {
  5   int sum = 0;
  6   for(int i = 0;i<top;i++)
  7   {
  8     sum+=i;
  9   }
 10   return sum;
 11 }
 12 
 13 int main()
 14 {
 15   int result = add_to_top(100);
 16   if(result == 5050) return 0;                                                                                               
 17   else return 1;//计算结果不正确
 18 }

这里首个echo $?的值才是程序的返回值，也就是echo $?只会保留最近一次执行的进程的退出码

进程常见退出方法

正常终止（可以通过echo $?查看进程退出码）：

• 1、从main函数return
• 2、其他函数调用exit
• 3、_exit
  
  简单的来看，exit与_exit存在下面的关系
  

异常退出

• ctrl+c，信号终止

进程等待

---

进程等待必要性

之前讲过，子进程退出，父进程如果不管不顾，就可能造成“僵尸进程”的问题，进而造成内存泄漏。
另外，进程一旦编程僵尸状态，那就刀枪不入，“杀人不眨眼”的kill -9 也不无能为力，因为谁也没有办法杀死一个已经死去的进程
最后，父进程派给子进程的任务完成的如何，我们需要知道。如：子进程运行完成 结果对还是不对，或者是否正常退出。
父进程通过进程等待的方式，回收子进程资源，获取子进程退出信息

进程等待的方法

wait方法

#include<sys/types.h>
#include<sys/wait.h>
pid_t wait(int*status);
返回值：
成功返回被等待进程pid，失败返回-1。
参数：
输出型参数，获取子进程退出状态,不关心则可以设置成为NULL

现在来看下面这段代码

#include<sys/types.h>
#include<sys/wait.h>
int main()
{
   pid_t id = fork();
   if(id==0)
   {
     //子进程
     int cnt =5;
     while(cnt)
     {
       printf("我是子进程，我还活着呢，我还有%dS,pid:%d,ppid:%d\n",cnt--,getpid(),getppid());
       sleep(1);
     }
     exit(0);
   }
   sleep(10);
   //父进程
   pid_t ret_id = wait(NULL);
   printf("我是父进程，等待子进程成功,pid:%d,ppid:%d,ret_id:%d\n",getpid(),getppid(),ret_id);
}   

首先分析上面一段代码，即是父子进程同时运行5s后，子进程退出。
接下来看一下输出结果

我们可以看见子进程在刚开始退出到父进程退出的这个过程中状态始终为Z+，同时wiat（）成功返回子进程的pid

waitpid方法

pid_ t waitpid(pid_t pid, int *status, int options);
返回值：
当正常返回的时候waitpid返回收集到的子进程的进程ID；
如果设置了选项WNOHANG,而调用中waitpid发现没有已退出的子进程可收集,则返回0；
如果调用中出错,则返回-1,这时errno会被设置成相应的值以指示错误所在；
参数：
pid：
Pid=-1,等待任一个子进程。与wait等效。
Pid>0.等待其进程ID与pid相等的子进程。
status:
WIFEXITED(status): 若为正常终止子进程返回的状态，则为真。（查看进程是否是正常退出）WEXITSTATUS(status): 若WIFEXITED非零，提取子进程退出码。（查看进程的退出码）
options:
WNOHANG: 若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束，则返回该子进程的ID。
如果子进程已经退出，调用wait/waitpid时，wait/waitpid会立即返回，并且释放资源，获得子进程退出信息。
如果在任意时刻调用wait/waitpid，子进程存在且正常运行，则进程可能阻塞。
如果不存在该子进程，则立即出错返回。

获取子进程的status

wait和waitpid，都有一个status参数，该参数是一个输出型参数，由操作系统填充。
如果传递NULL，表示不关心子进程的退出状态信息。
否则，操作系统会根据该参数，将子进程的退出信息反馈给父进程。
status不能简单的当作整形来看待，可以当作位图来看待，具体细节如下图（只研究status低16比特位）：

#include<sys/types.h>
#include<sys/wait.h>
int main()
{
   pid_t id = fork();
   if(id==0)
   {
     //子进程
     int cnt =5;
     while(cnt)
     {
       printf("我是子进程，我还活着呢，我还有%dS,pid:%d,ppid:%d\n",cnt--,getpid(),getppid());
       sleep(1);
     }
     exit(0);
   }
   sleep(10);
   //父进程
   int status =0;
   pid_t ret_id = waitpid(id,&status,0);
   printf("我是父进程，等待子进程成功,pid:%d,ppid:%d,ret_id:%d\n",getpid(),getppid(),ret_id);
}   

通过简单的位运算，拿到退出码和退出信息。我们可以进一步观察程序的运行情况

#include<sys/types.h>
#include<sys/wait.h>
int main()
{
   pid_t id = fork();
   if(id==0)
   {
     //子进程
     int cnt =5;
     while(cnt)
     {
       printf("我是子进程，我还活着呢，我还有%dS,pid:%d,ppid:%d\n",cnt--,getpid(),getppid());
       sleep(1);
     }
     exit(0);
   }
   sleep(10);
   //父进程
   int status =0;
   pid_t ret_id = waitpid(id,&status,0);
   printf("我是父进程，等待子进程成功,pid:%d,ppid:%d,ret_id:%d，child exist code:%d,child exist signal:%d\n",getpid(),getppid(),ret_id,(status>>8)&0xFF,status&0x7F);
}   

• 进程的阻塞式等待方式

int main()
{
 	pid_t pid;
 	pid = fork();
 	if(pid < 0){
 		printf("%s fork error\n",__FUNCTION__);
 		return 1;
 	} else if( pid == 0 ){ //child
 		printf("child is run, pid is : %d\n",getpid());
 		sleep(5);
 		exit(257);
 	} else{
 		int status = 0;
 		pid_t ret = waitpid(-1, &status, 0);//阻塞式等待，等待5S
 		printf("this is test for wait\n");
 	if( WIFEXITED(status) && ret == pid ){
 		printf("wait child 5s success, child return code is 					:%d.\n",WEXITSTATUS(status));
 	}else{
 		printf("wait child failed, return.\n");
 		return 1;
 	}
 	return 0;
}

• 进程的非阻塞式等待方式

#include <stdio.h> 
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
int main()
{
	pid_t pid;

	pid = fork();
	if(pid < 0){
	printf("%s fork error\n",__FUNCTION__);
		return 1;
	}else if( pid == 0 ){ //child
		printf("child is run, pid is : %d\n",getpid());
   	sleep(5);
   	exit(1);
	} else{
		int status = 0;
    	pid_t ret = 0;
	do
	{
		ret = waitpid(-1, &status, WNOHANG);//非阻塞式等待
		if( ret == 0 ){
		printf("child is running\n");
		}
	sleep(1);
	}while(ret == 0);

	if( WIFEXITED(status) && ret == pid ){
	printf("wait child 5s success, child return code is :%d.\n",WEXITSTATUS(status));
	}else{
		printf("wait child failed, return.\n");
		return 1;
		}
	}
	return 0;
}

进程程序替换

替换原理

用fork创建子进程后执行的是和父进程相同的程序（但有可能执行不同的代码分支），子进程往往要调用一种exec函数以执行另一个程序，当进程调用一种exec函数时，该进程的用户空间代码和数据完全被新程序替换，从新程序的启动例程开始执行。调用exec并不创建新进程，所以调用exec前后该进程的id并未改变。

替换函数

• #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[]);

函数解释

• 这些函数如果调用成功则加载新的程序从启动开始执行，不再返回
• 如果调用出错则返回1
• 所以exec函数只有出错的返回值而没有成功的返回值

命名解释

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

#include <unistd.h>
int main()
{
    char *const argv[] = {"ps", "-ef", NULL};
    char *const envp[] = {"PATH=/bin:/usr/bin", "TERM=console", NULL};    execl("/bin/ps", "ps", "-ef", NULL);
    // 带p的，可以使用环境变量PATH，无需写全路径
    execlp("ps", "ps", "-ef", NULL);
    // 带e的，需要自己组装环境变量
    execle("ps", "ps", "-ef", NULL, envp);
    execv("/bin/ps", argv);
    // 带p的，可以使用环境变量PATH，无需写全路径
    execvp("ps", argv);
    // 带e的，需要自己组装环境变量
    execve("/bin/ps", argv, envp);
    exit(0);
}

事实上，只有execve是真正的系统调用，其他五个函数最终都调用execve，所以execve在man手册第二节，其他的函数都在man手册第三节。这些函数之间的关系如下图所示。

简易的shell

    1 #include<stdio.h>
    2 #include<unistd.h>
    3 #include<assert.h>
    4 #include<string.h>
    5 #include<sys/wait.h>
    6 #include<sys/types.h>
    7 #include<stdlib.h>
    8 
    9 #define ARGC 64
   10 #define MAX 1024
   11 #define SEP " "
   12 
   13 int split(char* commandstr,char* argv[])
   14 {
   15   assert(commandstr);
   16   assert(argv);
   17                                                                                                   
   18   argv[0] = strtok(commandstr,SEP);
   19   if(argv[0]==NULL) return -1;
   20   int i = 1;
   21   while(argv[i++] = strtok(NULL,SEP)); 
   22                               
   23   //int i = 1;
   24   //while(1)                                                                                   
   25   //{
   26   //  argv[i] = strtok(NULL,SEP);
   27   //  if(argv[i] == NULL) break;
   28   //  i++;
   29   //}                            
   30   return 0;                     
   31 }         
   32 void debugPrint(char* argv[])
   33 {          
   34   for(int i =0;argv[i];i++)
   35   {                          
   36     printf("%d:%s\n",i,argv[i]);
   37   }                        
   38 }  
   39 void showEnv()                  
   40 {
   41   extern char **environ;
   42   for(int i = 0 ;environ[i];i++)
   43   {
   44     printf("%d:%s\n",i,environ[i]);
   45   }
   46 }
   47 int main()
   48 {
   49   int last_exit =0;
   50   char myenv[32][256];
   51   int env_index = 0;
   52   extern char** environ;
   53   while(1)
   54   {
   55     char commandstr[MAX] = {0};
   56     char *argv[ARGC]={NULL};
   57     printf("[mr@machine curpath]#");                                                           
   58     fflush(stdout);
   59     char* s = fgets(commandstr,sizeof(commandstr),stdin);
   60     assert(s);
   61     (void)s;//保证在release方式发布的时候；因为去掉了assert了，所以s就没有被使用，而带来的告警>      ，什么都没做，但是充当一次使用
   62       //abcd\n\0   
   63       commandstr[strlen(commandstr)-1] = '\0';
   64     //ls -a -l
   65     //"ls" "-a" "-l"
   66     int n  = split(commandstr,argv);
   67     if(n!=0) continue;
   68     //debugPrint(argv);
   69     //version2:说明几个细节
   70     if(strcmp(argv[0],"ls")==0)
   71     {
   72       int pos =  0;
   73       while(argv[pos]!=NULL) pos++;
   74       argv[pos++] =(char*) "--color=auto";
   75       argv[pos] = NULL;
   76     }
   77     if(strcmp(argv[0],"cd")==0)
   78     {
   79       if(argv[1]!=NULL) chdir(argv[1]);
   80       continue;
   81     }
   82     else if(strcmp(argv[0],"export")==0)
   83     {
   84       if(argv[1]!=NULL) 
   85       {
   86         strcpy(myenv[env_index],argv[1]);
   87         putenv(myenv[env_index++]);
   88       }
   89       continue;
   90     }
   91     else if(strcmp(argv[0],"env")==0)
   92     {
   93       showEnv();
   94       continue;
   95     }
   96     else if(strcmp(argv[0],"echo")==0)
   97     {
   98       //echo $PATH
   99       const char* target_env = NULL;
  100 
  101       if(argv[1][0]=='$') 
  102       {
  103         if(argv[1][1]=='?')
  104         {
  105            printf("%d\n",last_exit);
  106            continue;
  107         }
  108         else target_env = getenv(argv[1]+1);
  109       }
  110       if(target_env!=NULL) printf("%s=%s\n",argv[1]+1,target_env);
  111       continue;
  112     }
  113     //version1
  114     pid_t id = fork();
  115     assert(id>=0);
  116     (void)id;
  117     if(id==0)
  118     {
  119       //child
  120       execvp(argv[0], argv);
  121       exit(1);
  122       
  123     }
  124     //parent
  125     int status =0;
  126     pid_t ret = waitpid(id,&status,0);
  127     if(ret>0)
  128     {
  129       last_exit = WEXITSTATUS(status);
  130     }
  131    // printf("%s\n",commandstr);
  132   }
  133 }