Un proceso no es más que una instancia de ejecución de un programa.

 También
se define como un programa en acción.
El concepto de un proceso es el concepto fundamental de un sistema Linux. Los
procesos pueden generar otros procesos, matar a otros procesos, comunicarse
con otros procesos y mucho más.
En este tutorial, vamos a discutir el ciclo de vida de un proceso y mantener el
contacto en varios aspectos que un proceso pasa a través de su ciclo de vida. 

1. Proceso Código Vs Vs Programa

Vamos primero entender la diferencia entre el código, el programa y el proceso.
Código: A continuación se presenta un ejemplo de código:

#include <stdio.h>
# include <unistd.h>

int main (void)

{
printf ( "\ n Hello World \ n");
sueño (10);

return 0;
}

Permite guardar la pieza anterior de código en un archivo llamado

helloWorld.c.Por lo que este archivo se convierte en código.
Programa: Ahora, cuando se compila el código, se produce un archivo
ejecutable. Aquí es cómo se compila el código de seguridad:

$ Gcc -Wall -o helloWorld.c helloWorld

Esto produciría un ejecutable llamado helloWorld. Este ejecutable se conoce

como un programa.
Proceso: Ahora, vamos a ejecutar este archivo ejecutable:

$ ./helloWorld

Hola Mundo
Una vez ejecutado, se crea un proceso que corresponde a este ejecutable (o
programa). Este proceso se ejecutará todo el código máquina que estaba allí en
el programa. Esta es la razón por la cual se conoce un procedimiento como el
funcionamiento ejemplo de un programa.
Para comprobar los detalles del proceso de nueva creación, ejecute el comando
ps en la siguiente forma:

$ Ps -aef | grep hola *

1000 6163 3017 0 18:15 pts / 0 00:00:00 ./helloWorld

Para entender la salida del comando ps, lea nuestro artículo sobre ejemplos de
comandos 7 ps .
2. El padre y el proceso hijo
Cada proceso tiene un proceso padre y puede o no tener procesos
secundarios.Vamos a tomar esta uno por uno. Considere la posibilidad de la
salida del comando ps en mi máquina de Ubuntu:

1000 3008 1 0 12:50? 00:00:23 gnome-terminal

1000 3016 3008 0 12:50? 00:00:00 gnome-pty-helper
1000 3017 3008 0 12:50 pts / 0 golpe 00:00:00
1000 3079 3008 0 12:58 pts / 1 golpe 00:00:00
1000 3321 1 0 14:29? 00:00:12 gedit
5143 2 0 raíz 17:20? 00:00:04 [kworker / 1: 1]
5600 2 0 raíz 17:39? 00:00:00 [migración / 1]
5642 2 0 raíz 17:39? 00:00:00 [kworker / u: 69]
5643 2 0 raíz 17:39? 00:00:00 [kworker / u: 70]
5677 2 0 raíz 17:39? 00:00:00 [kworker / 0: 2]
5680 2 0 raíz 17:39? 00:00:00 [hci0]
5956 916 0 raíz 17:39? 00:00:00 / sbin / dhclient -d -sf
/usr/lib/NetworkManager/nm-dhcp-client.action -pf / run / sendsigs.
6181 2 0 raíz 18:35? 00:00:00 [kworker / 1: 0]
6190 2 0 raíz 18:40? 00:00:00 [kworker / 1: 2]
1000 6191 3079 0 18:43 pts / 1 00:00:00 ps -aef

Números enteros en la segunda y tercera columna de la salida anteriormente

representan ID de proceso y proceso padre. Tenga en cuenta las cifras resaltadas
en negrita. Cuando ejecuta el comando 'ps -aef', un proceso de creación, su ID
de proceso es 6191. Ahora, mira a su ID de los padres proceso, es 3079. Si se
mira hacia el comienzo de la producción se verá que ID 3079 es el ID del
proceso del proceso de golpe. Esto confirma que la cáscara del golpe es la matriz
cualquier comando que se ejecuta a través de él.
Del mismo modo, incluso para procesos que no se crean a través de la cáscara,
hay un cierto proceso padre. Sólo tiene que ejecutar el comando 'ps -aef' en su
máquina Linux y observar la columna de la PPID (padre proceso de
identificación). No verá ninguna entrada vacía en ella. Esto confirma que cada
proceso tiene un proceso padre.
Ahora, vamos a llegar a procesos secundarios. Cada vez que un proceso crea otro
proceso, el primero es llamado padre mientras que este último se llama proceso
hijo. Técnicamente, un proceso hijo se crea llamando a la función tenedor
() desde dentro del código. Por lo general, cuando se ejecuta un comando del
shell, el tenedor () es seguido por exec (serie) de funciones .
Hemos discutido que cada proceso tiene un proceso padre, esto puede traer una
pregunta que lo que va a pasar a un proceso hijo cuyo proceso padre está
muerto?Bueno, esta es una buena pregunta, pero deja volver a ella en algún
momento posterior.
3. El proceso init
Cuando se arranca el sistema Linux, primero que se carga en memoria es
vmlinuz.Es el núcleo de Linux ejecutable comprimido. Esto resulta en la
creación de proceso init. Este es el primer proceso que se crea. proceso init tiene
PID de uno, y es el padre súper de todos los procesos en una sesión de Linux. Si
se tiene en cuenta la estructura de procesos Linux como un árbol luego init es el
nodo de inicio de ese árbol.
Para confirmar que init es el primer proceso, puede ejecutar el comando pstree
en su máquina Linux. Este comando muestra el árbol de procesos para una
sesión de Linux.
Aquí es un ejemplo de salida:

init - + - NetworkManager - + - dhclient

| | -dnsmasq
| `-3 * [{} NetworkManager]
| -Cuentas-Daemon --- 2 * [{} cuentas-daemon]
| -acpid
| -at-Bus SPI-Lavandería - + - dbus-daemon
| `-3 * [{At-spi-bus-Lavandería}]
| -at-SPI2-registr --- {a-SPI2-registr}
| -avahi-Daemon --- avahi-daemon
| -bamfdaemon --- 3 * [{} bamfdaemon]
| -bluetoothd
| -colord --- {} Colord
| -console-Kit-dae --- 64 * [{consola-kit-dae}]
| -cron
| -cups-navegado
| -cupsd
| -2 * [Dbus-daemon]
| -dbus-Lanzamiento
| -dconf De servicio --- 2 * [{dconf servicio}]
| -evince --- 3 * [{} evince]
| -evinced --- {} Evidenciado
| -Evolution-Vitam --- 2 * [{evolución-vitam}]
| -firefox - + - Plugin-containe --- 16 * [{plugin-containe}]
| `-36 * [{} Firefox]
| -gconfd-2
| -gedit --- 3 * [{} gedit]
| -6 * [Getty]
| -gnome-Llavero-d --- 7 * [{gnome-keyring-d}]
| - Gnome-terminal - + - Bash
| | - Bash - + - menos
| | `- Pstree
| | -gnome-Pty-helpe
| `-3 * [{Gnome-terminal}]
| -gvfs-AFC-volumen --- 2 * [{gvfs-AFC-volumen}]
| -gvfs-Gphoto2-vo --- {gvfs-gphoto2-vo}
| -gvfs-MTP-volumen --- {gvfs-MTP-volumen}
| -gvfs-Udisks2-vo --- {gvfs-udisks2-vo}
| -gvfsd --- {} Gvfsd
| -gvfsd Quema --- 2 * [{gvfsd quema}]
 | -gvfsd-Fusible --- 4 * [{gvfsd-fusible}]
...
...
...

La salida confirma que init es en la parte superior de árbol de procesos. Además,

si se observa el texto en negrita, podrás ver la relación completa entre padres e
hijos del proceso de pstree. Leer más sobre pstree en nuestro artículo sobre el
árbol y pstree .
Ahora, vamos a volver a la pregunta (que dejamos abierta en la última sección)
sobre las consecuencias cuando proceso padre muere mientras el niño aún está
vivo. Bueno, en este caso, el niño se convierte en huérfano, obviamente, pero es
adoptado por el proceso init. Por lo tanto, el proceso init se convierte en el
nuevo padre de esos procesos hijos cuyos padres están terminados.
4. Proceso de Ciclo de Vida
En esta sección, vamos a discutir el ciclo de vida de un proceso normal de Linux
cubre antes del sacrificio y se elimina de la tabla de procesos del núcleo.
 Como ya se ha comentado, un nuevo proceso es creado a través tenedor ()
y si un nuevo archivo ejecutable se va a ejecutar a continuación, exec ()
familia de funciones se llama después de tenedor (). Tan pronto como se
crea este nuevo proceso, se pone en cola en la cola de procesos que están
listos para funcionar.
 Si tan solo tenedor () fue llamado entonces es muy probable que el nuevo
proceso se ejecuta en modo usuario, pero si exec () se llama entonces el
nuevo proceso se ejecutará en modo de núcleo hasta que se crea un espacio
de direcciones del proceso fresca para ello.
 Mientras se ejecuta el proceso, un proceso de mayor prioridad puede
adelantarse a través de una interrupción. En este caso, el proceso de vaciado
anteriormente va de nuevo a la cola de procesos que están listos para
funcionar. Este proceso es recogido por el planificador en una etapa
posterior.
 Un proceso puede entrar en modo de núcleo mientras se ejecuta. Esto es
posible cuando se requiere acceder a algún recurso como archivo de texto
que se guarda en el disco duro. A medida que las operaciones que involucran
el acceso al hardware pueden necesitar mucho tiempo, es muy probable que
 el proceso se irá a dormir y se despierta sólo cuando los datos solicitados
está disponible. Cuando se despierta el proceso, eso no quiere decir que va a
comenzar a ejecutar inmediatamente, se volverá a poner en cola y será
recogido para su ejecución por el planificador en el momento apropiado.
 Un proceso se puede matar a través de muchas maneras. Se puede llamar
a la función exit () para salir o puede procesar señales de Linux para
salir. Además, algunas señales no pueden ser capturados y hacen que el
proceso de terminar inmediatamente.
 Hay diferentes tipos de procesos de Linux . Una vez que se elimina el
proceso, que no consigue completamente eliminado. Una entrada que
contenga alguna información relacionada con él se mantiene en la tabla de
direcciones del proceso del núcleo hasta que el proceso padre pide
explícitamente a wait () funciones o waitpid () para obtener el código de
salida del proceso hijo. Hasta proceso padre hace esto, el proceso terminado
se conoce como proceso de zombi.