Linux 进程操作

文章目录

- 进程的基本知识
- - 进程pid
  - 进程常用的函数
- fork
- wait和waitpid
- exec函数簇
- system函数
- 信号处理signal函数
- - Linux的SIGUSR1SIGUSR2
- 讨论

进程的基本知识

一个程序的执行称为一个进程，所有的代码都是在进程中执行的，进程是操作系统资源分配的基本单位。

在Linux中，除了内核的启动进程外，其他所有的进程都是由它的父进程通过fork函数调用产生的。

操作系统通过识别每一个进程的pid来识别每一个进程，pid在进程中是唯一的，可以重复利用(比如说前一个为pid=11的进程死掉了，那么pid=11的这个进程就可以分配给其他进程使用了：当pid达到最大限制时，内核会从头开始查找闲置的pid并使用最先找到的那一个作为新进程的id)
在这里插入图片描述

进程pid

操作系统中有一些进程的id是专用的：

id=0的进程为调度进程，调度进程是内核的一部分，并不执行任何磁盘上的程序
id=1的进程叫做 init 进程，init 进程是以超级用户权限运行着的普通用户进程，不是系统进程。

进程常用的函数

头文件：#include<unistd.h>
__pid_t getpid (void)：调用进程的进程ID
__pid_t getppid (void)：调用进程的父进程ID
__uid_t getuid (void) ：调用进程的实际用户ID
__uid_t geteuid (void)：调用进程的有效用户ID
__gid_t getegid (void)：调用进程的有效组ID

fork

fork用于进程的创建（完整的复制），使用fork()函数要引入头文件#include<unistd.h>，其函数原型为pid_t fork(void)，fork返回值是pid_t，本质上是int类型。
对于fork的返回值，如果是成功，子进程的id号会返回给父进程，并且把0返回给子进程；如果失败了，-1会返回给父进程，并且不会有子进程的创建，

//举一个简单的例子
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
int main(){pid_t n=fork();if(n==0){//说明这是一个子进程printf("child：my pid=%d.,my ppid =%d\n",getpid(),getppid());}else if(n==-1){printf("程序创建错误\n");return -1;}else{sleep(1)//保证子进程可以执行完成printf("parent：my pid =%d,n=%d\n",getpid(),n);}
}

[cch@aubin s]$ gcc file.c
[cch@aubin s]$ ./a.out
child：my pid=3585.,my ppid =3584
parent：my pid =3584,n=3585
[cch@aubin s]$

以上的程序结果显示的是子进程先执行，而后父进程开始执行，但是实际上，在执行了fork之后，父进程与子进程都是同时存在的，也就是child：my pid=3585.,my ppid =3584语句和parent：my pid =3584,n=3585语句是同时执行的（并发执行），只是在执行父进程的时候进行了睡眠而已。

可能会出现以下的执行情况：

parent：my pid =3584,n=3585
[cch@aubin s]$ child：my pid=3585.,my ppid =3584

这是因为在并发执行的过程中，父进程先执行完毕，父进程执行完毕会返回给父进程的父进程，也就是系统调用，然后显示出来美元符号$，紧接着子进程也执行完毕，想要返回父进程会发现父进程已经结束了，只能返回上一层的上一层，也就是在美元符号后面显示。

wait和waitpid

库函数exit(status)终止一进程，将进程占用的所有资源(内存、文件描述符等)归还内核。参数status为一整形变量，标识进程的退出状态。父进程可以通过系统调用wait()来获取该状态
系统调用wait(&status)的目的有二：
其一：如果子进程尚未调用exit()终止，那么wait()会挂起父进程直到有一个子进程终止
其二：子进程的终止状态通过 wait()的 status 参数返回

#include<sys/types.h>
#include<sys/wait.h>
#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>int main(){pid_t pid;char *message;int n;int exit_code;pid=fork();switch(pid){case -1:exit( -1);case 0:message="child child";n=5;exit_code=37;break;default:message="father father";n=3;exit_code=38;break;}for(;n>0;n--){puts(message);sleep(1);}if(pid){//父进程int stat_val;pid_t child_pid;child_pid=wait(&stat_val);//父进程等待子进程的结束printf("child finish:pid=%d\n",child_pid);if(WIFEXITED(stat_val))//子进程正常终止的情况printf("child exit with code %d\n",WEXITSTATUS(stat_val));else//子进程非正常终止的情况printf("child terminated abnormally\n");}exit(exit_code);
}

[cch@aubin s]$ gcc file.c 
[cch@aubin s]$ ./a.out
father father
child child
father father
child child
father father
child child
child child
child child
child finish:pid=4459
child exit with code 37
[cch@aubin s]$

pid_t wait(int *status)用于等待子进程结束，回收并且释放子进程资源；其中status用来保存子进程退出时的状态，如果status为NULL，表示忽略子进程退出时的状态；如果函数执行成功，返回子进程的进程号，失败则返回-1。
pid_t waitpid(pid_t pid ,int *status , int options)waitpid相比于wait多了两个参数，options=0时，同wait，阻塞父进程，等待子进程退出。

exec函数簇

用fork函数创建子进程后，子进程往往要调用一种exec函数以执行另一个程序。当进程调用一种exec函数时，该进程执行的程序完全替换为新程序，而新程序则从其main函数开始执行。因为调用exec并不创建新进程，所以前后的进程ID并未改变。exec只是用一个全新的程序替换了当前进程的正文、数据、堆和栈段。
exec本身不是一个函数，而是有6种不同的函数可供使用，所以被称为exec函数簇

#include <unistd.h>int execl( const char *pathname, const char *arg0, ... /* (char *)0 */ );int execv( const char *pathname, char *const argv[] );int execle( const char *pathname, const char *arg0, ... /* (char *)0, char *const envp[] */ );int execve( const char *pathname, char *const argv[], char *const envp[] );//进程映像的名字，映像所携带的参数，参数为0表示结束int execlp( const char *filename, const char *arg0, ... /* (char *)0 */ );int execvp( const char *filename, char *const argv[] );6个函数返回值：若出错则返回-1，若成功则不返回值

#include<sys/types.h>
#include<sys/wait.h>
#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>int main(){printf("exec:\n");execlp("ls","ls,0");printf("dome\n");exit(0);
}

[cch@aubin s]$ gcc file.c 
[cch@aubin s]$ ./a.out
exec:
dome
[cch@aubin s]$

system函数

int system(const char * command)system函数包含在头文件stdlib.h中，该函数会执行dos(windows系统) 或 shell(Linux/Unix系统) 命令，参数字符以command为命令名字。
在windows系统中，system函数直接在控制台调用一个command命令。
在Linux/Unix系统中，system函数会调用fork函数产生子进程，由子进程来执行command命令，并且使用wait阻塞父进程，直到子进程执行完毕后父进程继续执行。
命令执行成功返回0，执行失败返回-1。

#include<stdlib.h>
#include<stdio.h>int main(){printf("system:\n");system("ls");printf("dome\n");exit(0);
}

[cch@aubin s]$ gcc file.c 
[cch@aubin s]$ ./a.out
system:
a.out  file.c
dome
[cch@aubin s]$

system("ls &");//表示把子进程放到后台去做

信号处理signal函数

Linux中的信号可以通过kill -l命令获取

#include<signal.h>
#include<stdio.h>
#include<unistd.h>void ouch(int sig){printf("signal:%d\n",sig);(void)signal(SIGINT,SIG_DFL);//将ctrl+c的对应信号处理函数恢复成默认的值，也就是中断当前程序的执行
}int main(){(void)signal(SIGINT,ouch);//捕获信号ctrl+c，ouch是信号处理函数while(1){printf("hello world\n");sleep(1);}
}

void（* signal（int sig，void（* func）（int）））（int）;指定使用sig指定的信号编号处理信号的方法。其中void（* func）（int）表示的是一个带有int类型参数的函数指针；而signal本身的函数的返回值也是一个函数指针
常用的sig包括（共32）：
- SIGINT：2，表示interrupt中断
- SIGKILL：9，表示发送不可屏蔽的kill信号
- SIGSEGV：11，表示segmentation violation，段违规
- SIGUSR1：10，开放用户使用，默认处理进程终止
- SIGUSR2：12，开放用户使用，默认处理进程终止
参数func指定程序可以处理信号的三种方式之一：
- 默认处理（SIG_DFL）：信号由该特定信号的默认动作处理。
- 忽略信号（SIG_IGN）：忽略信号，即使没有意义，代码执行仍将继续。
- 函数处理程序：定义一个特定的函数来处理信号。

除了在终端，也可以使用kil -2 pid来给对应的进程发送信号，表示系统向程序发送信号

Linux的SIGUSR1SIGUSR2

当一个进程调用fork时，因为子进程在开始时复制父进程的存储映像，信号捕捉函数的地址在子进程中是有意义的，所以子进程继承父进程的信号处理方式。
但是当子进程调用exec后，因为exec运行新的程序后会覆盖从父进程继承来的存储映像，那么信号捕捉函数在新程序中无意义，所以exec会将原本设置要捕捉的信号都更改为默认动作。

讨论

略

fotk语句执行成功后，会返回一个子进程的pid给父进程，并且返回0给子进程，由于父子进程并发执行，所以这个时候x的值为1或者-1都有可能，看父子进程谁先被调用。

尝试使用wait和waitid来同步父子进程的执行

child_pid=wait(&stat_val);//父进程等待子进程的结束
child_pid=wait(child_id,&stat_val,-1);//父进程等待子进程的结束

什么是execl函数簇

execl函数簇不是指一个函数，而是6个execl函数的统称，execl函数可以在不创建新进程的情况下，以一个全新的程序替换当前的程序的正文、数据和堆栈。

在一个程序中有多少种信号，怎么使用一个用户定义信号

#include<signal.h>
#include<stdio.h>
#include<unistd.h>
#include<signal.h>void signal_handle(int sig_num){if(sig_num==SIGUSR1)printf("SIGUSR1-----\n");//在命令行中发送SIGUSR1信号可以执行signal_handle函数printf("signal_handle\n");
}int main(){signal(SIGUSR1,signal_handle);while(1){printf("main------\n");sleep(1);}return 0;
}