进程控制【Linux】

1.进程终止

1.1.进程退出场景

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

1.2.进程常见退出方法

常见的正常中止:

1. 从main函数return返回
2. 调用exit
3. _exit

查看进程退出码: echo $?(查看最近一次的进程退出码)
测试代码:

include <stdio.h>                                                                                                     

int main()
{
    printf("hello world\n");
    return 0;
} 

异常中止:

1. ctrl +c
2. 信号中止

1.3._exit函数和exit函数

函数使用：

函数区别：

1.exit是C语言的库函数，_exit是系统接口(所以说exit函数底层带调用也是_exit函数)

2.exit中止进程之前会刷新缓冲区，而_exit不会

测试代码:

#include <stdio.h>    
#include <stdlib.h>    
                                                                                                                       
int main()    
{    
    printf("hello world");    
    exit(-1);//-1为进程退出码,调用exit会刷新缓冲区，打印出hello world    
    //_exit(-1); 而_exit并不会刷新缓冲区，什么都不打印  
    //同时也能说明缓冲区是用户级缓冲区  
}   

return 退出:

return 是一种更常见的退出进程方法，执行return n等同于执行exit(n)，因为调用main函数运行时函数会将main函数的返回值当作exit参数。

2.进程等待

2.1.进程等待必要性

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

2.2.进程等待方法

wait方法和waitpid方法：

wait函数注意事项:

返回值: 成功返回被等待进程pid,失败返回-1
参数:status是输出型参数，获取子进程退出状态，不关心则设置为NULL

waitpid函数注意事项:

pid_t waitpid(pid_t pid,int* status,int options);
返回值:
当正常返回的时候waitpid返回收集到的子进程的进程ID
如果设置了选项WNOHANG，而调用中waitpid发现没有已退出的子进程可收集，则返回0；
如果调用中出错，则返回-1，这时error会被设置成相应的值以指示错误所在。
参数:
pid = -1 等待任一子进程，与wait等效。
pid > 0 等待其进程ID与pid相等的子进程
status：
WIFEXITED(status)：若为正常中止子进程返回的状态，则为真
WEXISTATUS(status)：若 WIFEXITED非零，提取子进程退出码
options ：
WNOHANG:如指定的子进程没有结束，则waitpid()函数返回0，不予以等待，如正常结束，则返回该子进程的ID。

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

2.2.1.获取子进程status

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

测试代码:

  #include <stdio.h>           
  #include <unistd.h>          
  #include <sys/wait.h>        
  #include <sys/types.h>       
  #include <stdlib.h>          
                               
  int main()                   
  {                            
      pid_t id = fork();       
      if(id < 0)               
      {                        
          perror("fork error\n");    
      }                        
      else if(id > 0)          
      {                        
          //子进程             
          printf("I am child process\n");    
          sleep(5);            
          exit(0);             
      }                        
      //parent               
      int status = 0;        
      int ret = waitpid(id,&status,0);    
      //获取子进程的退出信号和退出状态                                                                                 
      printf("signal code = %d,state code = %d\n",(status & 0x7F),(status >> 8) & 0xFF);    
      return 0;    
       
  }

2.2.2.进程的阻塞等待方式

int main()
{
	pid_t 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);//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;
}

2.2.3.进程的非阻塞等待方式

int main()
{
	pid_t 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);//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;
}

3.进程程序替换

3.1.替换原理

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

3.2.六个替换函数

函数用法:

首先，这六个函数都是基于系统调用execve上层做的封装，则这六个函数其实是语言级别维护的替换函数，方便用户应用到不同的场景。

测试代码:

	//不在具体一个一个具体环境中跑了，如果有疑问，可以查文档，
	execl("/usr/bin/ls","ls","-a","-l","-i","--color=auto",NULL);
	execlp("ls","ls","-a","-l","-i","--color=auto",NULL);
	execle("/usr/bin/ls","ls","-a","-l","--color=auto",NULL,environ);//系统环境变量,当然也可以传自定义环境变量
	char* const _argv[] = {
		"mybin",
		NULL
	};
	execvpe("./mybin",_argv,environ);
	execv("/usr/bin/ls",_argv);
	execvp("ls",_argv);

3.3.函数解释

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