Control de procesos
1. Qué es un proceso : Un proceso es un programa que se puede ejecutar simultáneamente. Es un proceso en ejecución en un conjunto de datos.
Cuando un programa comienza a ejecutarse, durante el período desde el inicio de la ejecución hasta el final de la ejecución, el parte de su memoria se llama Proceso En
términos sencillos: un programa es un archivo ejecutable en el disco duro Un
proceso es un programa en ejecución.
2. Qué es la concurrencia : varios procesos se ejecutan al mismo tiempo, varias tareas se ejecutan al mismo tiempo
3. Memoria virtual :
tecnología de administración de memoria virtual de Linux:
memoria física: el módulo de memoria real en el procesador es de cientos de M.
Parte de la unidad de almacenamiento en el disco duro se usa como memoria para usar 4 G (afectada por el rango de direccionamiento de el sistema operativo)
0x000000 ——0xffffff
sistema operativo: espacio de usuario y espacio de kernel Espacio de
kernel: alta dirección 1g
espacio de usuario: baja dirección 3g
Los beneficios de la tecnología de gestión de memoria virtual:
1. Evita eficazmente que se destruya el espacio del kernel
2. Previene el malware hacer palanca (como una asignación al disco duro),)
3. No se encontrarán datos al quitar el disco duro
. La composición de la dirección virtual: dirección física + desplazamiento (rel)
4. Expanda el espacio de memoria
4. Clasificación de proceso
1, proceso demonio
2, proceso por lotes
3, proceso interactivo
5, atributos de
proceso ID de proceso (número de proceso PID): es el único atributo utilizado para distinguir el proceso.
ID de proceso principal (PPID)
inicia el proceso ID de usuario: UID
Estado del proceso: R en ejecución, S inactivo, proceso zombi Z, proceso muerto X, estado suspendido T
prioridad del proceso
El tamaño del recurso ocupado por el proceso (memoria, CPU)
6. Plantilla de control de proceso PCB : estructura de datos
Número de proceso: ps comando para ver los procesos en el sistema Linux (comando ps)
- l: salida de formato largo
- u: muestra el proceso en el orden de nombre de usuario y hora de inicio
- f: muestra el proceso en formato de árbol
- a: muestra todos los procesos de todos los usuarios
- x: muestra el proceso de terminal no controlado
% CPU es el tamaño de la CPU ocupada
% MEM es la cantidad de memoria ocupada
STAT es el estado del proceso
TIEMPO: el proceso consume tiempo
Kill command: kill
kill + número de proceso (PID)
kill + nombre de proceso -9: terminación forzada
pkill: pkill + nombre del programa
xkill: kill interfaz gráfica en el escritorio
renice: cambia la prioridad del proceso, cambiando el ID del proceso (PID ) para cambiar la humildad, y luego lograr la prioridad de cambiar el proceso
renice humildad PID
7. La transición de estado del proceso
(1) Listo: Cuando el proceso ha asignado todos los recursos necesarios excepto la CPU, se puede ejecutar inmediatamente siempre que se obtenga el procesador
(2) Ejecución: Se ha obtenido el procesador, y su el programa se está ejecutando en el procesador
(3) Bloqueo: El proceso que se está ejecutando, cuando no puede ejecutarse debido a la espera de que ocurra un evento, renuncia a la oportunidad de procesamiento y se encuentra en un estado bloqueado
. La naturaleza de la concurrencia: intervalo de tiempo sondeo
8, programación de procesos de Linux
1, FCFS también se llama FIFO, primero en llegar Trate primero; desventajas: las tareas cortas pueden volverse muy lentas2
, algoritmo round robin de intervalo de tiempo: conmutación periódica, la duración total es más corta que FIFO; desventaja: también muchas tareas cortas consumirán mucho tiempo en el cambio de tareas3
, STCF:
algoritmo de prioridad de tareas cortas
Preventivo y no preventivo Desventajas: Es difícil obtener recursos de CPU para tareas largas
4, algoritmo bancario
9, la función crear un proceso
fork ()
tiene dos valores de retorno 0: proceso hijo -1: error> 0: proceso padre
Archivo de encabezado:
#include “unistd.h”
Prototipo de función:
pid_t fork(void);
Hay dos valores de retorno:
#include"stdio.h"
#include"sys/types.h"
#include"unistd.h"
#include"stdlib.h"
int main()
{
pid_t pid =fork();
if(-1 ==pid)
{
perror("fork error!");
exit(1);
}
if (0 == pid)
{
printf("this is child\n");
}
else
{
printf("this is father\n");
}
}
getpid: obtenga el ID del proceso actual
getppid: obtenga el ID del proceso principal actual
obtenga el ID del proceso y el ID del proceso principal
#include"stdio.h"
#include"sys/types.h"
#include"unistd.h"
#include"stdlib.h"
int main()
{
pid_t pid =fork();
if(-1 ==pid)
{
perror("fork error!");
exit(1);
}
if (0 == pid)
{
printf("this is child: pid:%d ppid:%d\n",getpid(),getppid());
}
else
{
printf("this is father: pid:%d ppid:%d\n",getpid(),getppid());
}
}
Después de que se ejecuta la función de bifurcación, el proceso hijo copiará el espacio de datos de la pila del
proceso padre. El proceso padre y el proceso hijo se ejecutan en diferentes espacios de memoria: el proceso padre y el proceso hijo tienen su propio espacio de memoria independiente
#include"stdio.h"
#include"sys/types.h"
#include"unistd.h"
#include"stdlib.h"
int main()
{
int a=5;
pid_t pid =fork();
if(-1 ==pid)
{
perror("fork error!");
exit(1);
}
if (0 == pid)
{
a=a*5;
printf("this is child: pid:%d ppid:%d a =%d\n",getpid(),getppid(),a);
}
else
{
a =a-1;
printf("this is father: pid:%d ppid:%d a =%d\n",getpid(),getppid(),a);
}
}
Etapa inicial: después de que se
ejecuta la función de bifurcación, el proceso secundario copiará el espacio de datos de la pila del proceso principal.
Optimización:
no importa cuando se lee, se copia cuando se escribe. El
proceso principal y el proceso secundario utilizan la misma dirección de parámetro:
//输出所用参数的地址
#include"stdio.h"
#include"sys/types.h"
#include"unistd.h"
#include"stdlib.h"
int main()
{
int a=5;
int b=100;
pid_t pid =fork();
if(-1 ==pid)
{
perror("fork error!");
exit(1);
}
if (0 == pid)
{
a=a*2;
printf("this is child: a=%d a addr:%x b=%d b addr:%x \n",a,&a,b,&b);
}
else
{
a =a-1;
printf("this is father: a=%d a addr:%x b=%d b addr:%x \n",a,&a,b,&b);
}
}
La relación de proceso padre-hijo creada por la función de bifurcación es una relación competitiva y es imposible determinar quién se movió primero.
//判断谁快一点
#include"stdio.h"
#include"sys/types.h"
#include"unistd.h"
#include"stdlib.h"
int main()
{
int i=0;
pid_t pid=fork();
if(-1 == pid)
{
perror("fprk error");
exit(1);
}
if (0 == pid)
{
for(i=0;i<5;i++)
{
printf("child\n");
sleep(2);
}
}
else
{
for(i=0;i<5;i++)
{
printf("father\n");
sleep(2);
}
}
}
vfork (): crea
un proceso
1 para garantizar que el proceso hijo se mueva primero
//子进程先动
#include"stdio.h"
#include"sys/types.h"
#include"unistd.h"
#include"stdlib.h"
int main()
{
int i=0;
pid_t pid=vfork();
if(-1 == pid)
{
perror("fprk error");
exit(1);
}
if (0 == pid)
{
for(i=0;i<5;i++)
{
printf("child\n");
sleep(2);
}
}
else
{
for(i=0;i<5;i++)
{
printf("father\n");
sleep(2);
}
}
}
2. Cuando el proceso hijo llama a la función exit (), el proceso padre ejecuta
3 y no heredará la página del proceso padre
Por ejemplo:
1, cree dos procesos, una salida A, una salida B, salida alternativa ABABABABAB
#include"stdio.h"
#include"sys/types.h"
#include"unistd.h"
#include"stdlib.h"
int main()
{
int i=0;
pid_t pid=vfork();
if(-1 == pid)
{
perror("fprk error");
exit(1);
}
for(i=0;i<5;i++)
{
if (0 == pid)
{
printf("A\n");
pid =1;
}
else
{
printf("B\n");
pid =0;
}
}
exit(0);
}
Ej .: Tres procesos, salida alternativa ABC
#include"stdio.h"
#include"sys/types.h"
#include"unistd.h"
#include"stdlib.h"
int main()
{
int i=0;
for(i=0;i<5;i++)
{
pid_t pid =vfork();
if(-1 == pid)
{
perror("fprk error");
exit(1);
}
if(0 == pid)
{
printf("A\n");
exit(1);
}
else
{
int pit =vfork();
if(0 == pit)
{
printf("B\n");
exit(1);
}
else
{
printf("C\n");
}
}
}
}
por ejemplo: Tres procesos, impresión ABC alternativamente
(creo que significa ingresar al archivo)
#include"stdio.h"
#include"sys/types.h"
#include"unistd.h"
#include"stdlib.h"
int main()
{
int i=0;
FILE *fp;
fp =fopen("./text.txt","w+");
for(i=0;i<5;i++)
{
pid_t pid =vfork();
if(-1 == pid)
{
perror("fprk error");
exit(1);
}
if(0 == pid)
{
fputs("A",fp);
exit(1);
}
else
{
int pit =vfork();
if(0 == pit)
{
fputs("B",fp);
exit(1);
}
else
{
fputs("C",fp);
}
}
}
fclose(fp);
}
