1. Tres estados del proceso
1. Corre . O está siendo ejecutada por la CPU, o está esperando ser ejecutada y eventualmente será programada por el núcleo.
2. parada . La ejecución se suspende y no se programará. Solo después de recibir una señal específica puede continuar ejecutándose.
3. Terminación . El proceso se detuvo para siempre. Hay tres causas posibles: (1) recibir una señal para terminar el proceso, (2) regresar del programa principal, (3) llamar a la función de salida
2. Terminar el proceso.
#include<stdlib.h>
void exit(int status);//这个大家都很熟悉
3. Crear proceso
El proceso padre crea un nuevo proceso hijo en ejecución a través de la función fork: (fork en inglés significa fork y fork, lo que significa que un proceso hijo debe estar separado de un proceso), el proceso hijo recién creado obtendrá el proceso padre Una copia de casi toda la información, la mayor diferencia entre los dos es que tienen PID diferentes.
#include<sys/types.h>
#inlcude<unistd.h>
pid_t fork(void);
//子进程返回值为0，父进程返回子进程的pid，如果出错，则返回-1
Para el caso de un error en la llamada del sistema, en CSAPP , se menciona una solución, utilizando una función envuelta con manejo de errores con el mismo nombre y el mismo nombre que la función original en lugar de la función original.
Por ejemplo, para la función fork, use una función de envoltura llamada Fork:
pid_t Fork(void)
{
pit_t pid;
if((pit = fork())<0)//系统调用出错
unix_error("Fork error");
return pid;
}//可见Fork函数的参数类型、返回类型均与fork相同，故调用方式也是一样的
//unix_error的定义
void unix_error(char *msg)
{
fprintf(stderr,"%s: %s\n",msg,stderror(errno));//errno是一个系统级的全局变量，需包含<errno.h>
//stderror函数需包含头文件<string.h>,作用是根据errno值返回特定的描述错误的文本串
}
La siguiente es la aplicación específica de fork:
Dividido en tres archivos, alluse.h (archivo de encabezado), alluse.c (definición de función de contenedor), fork.c (uso)
//alluse.h
#ifndef ALLUSE_H
#define ALLUSE_H
#include<sys/types.h>
#include<unistd.h>
void unix_error(char *msg);
pid_t Fork(void);
#endif
//alluse.c
#include"alluse.h"
#include<string.h>
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>
#include<errno.h>
void unix_error(char *msg)
{
fprintf(stderr,"%s: %s\n",msg,strerror(errno));
exit(0);
}
pid_t Fork(void)
{
pid_t pid;
if((pid = fork())<0)
unix_error("Fork error");
return pid;
}
//fork.c
#include"alluse.h"
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>
int main()
{
pid_t pid;
int x = 1;
pid = Fork();
printf("return value of function Fork() = %d\n",pid);
if(pid==0){
printf("child : x=%d\n",++x);
printf("pid: %d\n",getpid());
printf("ppid: %d\n",getppid());
exit(0);
}
printf("parent: x=%d\n",--x);
printf("pid: %d\n",getpid());
printf("ppid: %d\n",getppid());
exit(0);
}
Compilar y ejecutar:
linux> gcc -o forktry fork.c alluse.c
linux> ./forktry
#结果如下
linux> ./forktry
return value of function Fork() = 9578
parent: x=0
pid: 9577
ppid: 24176
linux> return value of function Fork() = 0
child : x=2
pid: 9578
ppid: 1
La siguiente tabla se puede obtener de la salida:
| Proceso | PID de proceso | PPID del proceso padre | Valor de retorno de la horquilla |
|---|---|---|---|
| El proceso que llama tenedor | 9577 | 24176 | 9578 |
| Proceso creado por fork | 9578 | 1 | 0 0 |
Se puede ver que el proceso padre del proceso que llama a fork es el mismo que el artículo anterior llamada al sistema Linux: Obtenga PPID24176 en el PID del proceso , y el valor de retorno de fork también es el PID de otro proceso. Lo único que me confunde es que el ppid del proceso obtenido por la bifurcación es 1 en lugar del pid del proceso de llamada. Después de verificar en Internet, puedo usar el comando superior para ver la información del proceso. El proceso con pid = 1 es systemd, y también me sorprendió encontrar el PID. = 24176 El proceso es el bash previamente adivinado.