Aprenda Linux, 101: Cree, supervise y elimine procesos

Esté al tanto de lo que está sucediendo

Aprenda sobre administración de procesos en Linux®: cómo aleatorizar procesos entre primer plano y segundo plano, descubra lo que se está ejecutando, elimine procesos y mantenga procesos en ejecución después de que salga de su trabajo. Usted puede usar el material de este artículo para el examen LPI 101 para certificación como administrador de sistema Linux, o simplemente por diversión, para aprender.

Ian Shields, Senior Programmer, IBM

Ian ShieldsIan Shields trabaja en múltiples proyectos Linux para la zona Linux dev developerWorks. Es Senior Programmer de IBM en el Research Triangle Park (RTP), Carolina del Norte. Ingresó a IBM en Canberra, Australia, como Systems Engineer en 1973, y desde entonces se dedica a sistemas de comunicaciones y computación ubicua en Montreal, Canadá, y en el RTP de Carolina del Norte. Es propietario de numerosas patentes y publicó diversos trabajos. Tiene una diplomatura en Matemática Pura y Filosofía de la Universidad Nacional de Australia. Es Máster y Doctor en Ciencias de la Computación de la Universidad Estatal de Carolina del Norte.


Nivel de autor contribuyente en developerWorks

06-01-2012

Sobre esta serie

Esta serie de artículos le ayuda a aprender tareas de administración de sistema Linux. Usted también puede usar el material en estos artículos para prepararse para los exámenes (LPIC-1) de nivel 1 Linux Professional Institute Certification.

Vea nuestro mapa de ruta de la serie para una descripción de un enlace hacia cada artículo de esta serie. El mapa de ruta está en desarrollo y refleja los últimos objetivos (abril del 2009) para los exámenes LPIC-1: a medida que completemos artículos, los añadiremos al mapa de ruta. Mientras tanto, usted puede encontrar versiones anteriores de material similar , que soporta objetivos LPIC-1 anteriores a abril del 2009, en nuestros tutoriales de preparación para el examen de certificación LPI.

Visión General

Este artículo le proporciona las técnicas básicas Linux para administración de procesos. Aprenda a:

  • Administrar tareas de primer plano y de segundo plano
  • Iniciar procesos que se ejecutarán después de que usted cierre sesión
  • Supervisar procesos
  • Seleccionar y organizar procesos para mostrar
  • Enviar señales a procesos

Este artículo le ayuda a prepararse para el Objetivo 103.5 del Tema 103 del examen 101 (LPIC-1) Junior Level Administration del Linux Professional Institute. El objetivo tiene un peso de 4.

Prerrequisitos

Para aprovechar al máximo los artículos de esta serie usted debe contar con conocimientos básicos Linux y un sistema Linux funcional en el cual poder practicar los comandos que se cubren en este artículo. Algunas versiones diferentes del programa darán un formato de resultado diferente, por lo que sus resultados pueden no siempre verse igual a los listados y gráficas mostradas aquí. Los resultados de los ejemplos mostrados aquí se obtuvieron en una distribución Ubuntu 9.10 (Karmic Koala).


Administre tareas de primero y segundo plano

Conéctese con Ian

Ian es uno de nuestros autores más prolíficos y populares. Navegue todos los artículos de Ian en developerWorks. Visite el perfil de Ian y conéctese con él, con otros autores y con colegas lectores en My developerWorks.

Si usted se detiene y piensa por un momento, es bastante obvio que hay muchas cosas sucediendo en sua computadora además de los programas de terminal que hemos estado discutiendo en artículos anteriores de esta serie. De hecho, si usted está usando un escritorio gráfico es posible que haya abierto más de una ventana de terminal al mismo tiempo, o tal vez, haya abierto un navegador de archivos, un navegador de Internet, un juego, una hoja de cálculo u otra aplicación. Anteriormente nuestros ejemplos han mostrado comandos ingresados en una ventana de terminal. El comando se ejecuta y usted debe esperar a que se complete antes de que usted pueda hacer algo más. En este artículo usted aprenderá cómo hacer más de una cosa a la vez usando su ventana terminal.

Cuando usted ejecuta un comando en su ventana de terminal, está ejecutando en el primer plano. La mayoría de esos comandos se ejecutan rápidamente, pero suponga que está ejecutando un escritorio gráfico y que desearía que un reloj digital se mostrara en el escritorio. Por ahora, ignoremos el hecho de que la mayoría de escritorios gráficos ya tienen uno; simplemente vamos a usar esto como ejemplo.

Si usted tiene el X Window System instalado, probablemente también tendrá instaladas algunas herramientas como xclock o xeyes. Probablemente usted las encuentre en un paquete llamado xorg-x11-apps o x11-apps si aún no las ha instalado. Cualquiera de ellas sirve para este ejercicio, pero utilizaremos xclock. La página principal explica que usted puede iniciar un reloj digital en su escritorio gráfico usando el comando:

xclock -d -update 1

La parte -update 1 solicita actualizaciones cada segundo; en caso contrario, el reloj se actualiza solo cada minuto. Así que vamos a ejecutar esto en una ventana de terminal. Usted deberá ver un reloj como el de la Figura 1, y su ventana de terminal deberá verse como el Listado 1. Si no tiene xclock o el X Window System, dentro de poco verá cómo crear un reloj digital de hombre pobre con su terminal, de manera que pueda seguir por ahora y luego intentar estos ejercicios.

Nota: En el momento de la escritura, hay un error que afecta a xclock cuando están habilitados los efectos de escritorio. El efecto más notorio es que la barra de título no cambia, ni siquiera cuando se enfoca. Si su xclock no se ve como ninguno en este artículo, tal vez desee desactivar los efectos de escritorio durante un tiempo.

Figura 1. Un reloj digital con xclock
Un reloj digital con xclock
Listado 1. Iniciando xclock
ian@attic4:~$ xclock -d -update 1

Desafortunadamente, su ventana de terminal ya no tiene un prompt, por lo cual usted realmente necesita retomar el control. Afortunadamente, el Bash shell tiene una clave suspend , Ctrl-z. Presionar esta combinación de claves le proporciona un prompt de terminal de nuevo, como se muestra en el Listado 2.

Listado 2. Suspendiendo xclock con Ctrl-z
ian@attic4:~$ xclock -d -update 1  
^Z
[1]+  Stopped                 xclock -d -update 1

El reloj todavía está en su escritorio, pero se ha detenido. Eso fue exactamente lo que hizo la suspensión. De hecho, si usted arrastra otra ventana sobre parte de esta, la parte del reloj ni siquiera se volverá a dibujar. Note el mensaje de resultado de terminal indicando "[1]+  Stopped". El 1 del mensaje es un número de tareas. Usted puede reiniciar el reloj escribiendo fg %1. También puede usar el nombre de comando o parte de él escribiendo fg %xclock o fg %?clo. Finalmente, usted simplemente escribe fg sin parámetros, usted puede reiniciar el trabajo detenido más recientemente, el trabajo 1 en este caso. Reiniciar con fg también trae el trabajo de nuevo al primer plano y usted ya no tendrá un prompt de comando shell. Lo que usted necesita hacer es poner el trabajo en el segundo plano; un comando bg toma el mismo tipo de especificación de trabajo que el comando fg y hace exactamente eso.

El Listado 3 muestra cómo traer el trabajo xclock de nuevo al primer plano y suspenderlo usando dos formas del comando fg.. Usted puede suspenderlo de nuevo y ponerlo en segundo plano; el reloj continuará ejecutándose mientras usted hace otros trabajos en su terminal.

Listado 3. Poniendo xclock en primer plano o en segundo plano
ian@attic4:~$ fg %1
xclock -d -update 1
^Z
[1]+  Stopped                 xclock -d -update 1
ian@attic4:~$ fg %?clo
xclock -d -update 1
^Z
[1]+  Stopped                 xclock -d -update 1
ian@attic4:~$ bg
[1]+ xclock -d -update 1 &

Usando "&"

Posiblemente usted haya notado que cuando pone la tarea xclock en segundo plano, el mensaje ya no dirá "Stopped" y estará terminado por un signo (&). De hecho, usted no necesita suspender el proceso para ponerlo en segundo plano; simplemente añada un signo & al comando y el shell iniciará el comando (o lista de comandos) en el segundo plano. Vamos a iniciar un reloj análogo con un wheat de trasfondo usando este método. Usted deberá ver un reloj como el de la Figura 2 y un resultado de terminal como el del Listado 4.

Figura 2. Reloj análogo con xclock
Reloj análogo con xclock
Listado 4. Iniciando un xclock análogo con &
ian@attic4:~$ xclock -bg wheat -update 1&
[2] 4320

Note que el mensaje es ligeramente diferente esta vez. Este representa un número de trabajo y una ID de proceso (PID). Cubriremos las PID y más sobre el estado en un momento. Por ahora, vamos a usar el comando jobs para descubrir cuáles trabajos se están ejecutando. Añada la opción -l para listar las PID y verá que el trabajo 2 de hecho tiene una PID 4320 como se muestra en el Listado 5. Note también que el trabajo 2 tiene un signo de suma (+) junto al número de trabajo, indicando que este es el trabajo actual. Este trabajo vendrá al primer plano si no se da ninguna especificación de trabajo con el comandofg .

Listado 5. Mostrando información de trabajo y de proceso
ian@attic4:~$ jobs -l
[1]-  3878 Running                 xclock -d -update 1 &
[2]+  4320 Running                 xclock -bg wheat -update 1 &

Antes de resolver algunos otros problemas relacionados con trabajos de segundo plano, vamos a crear el reloj digital de un hombre pobre. Usamos el comando sleep para causar una demora de dos segundos y usamos el comando date para imprimir la fecha y hora actuales. Empaquetamos este comando en un bucle while con un bloque do/done para crear un bucle infinito. Finalmente, ponemos todo entre paréntesis para hacer una lista de comandos y poner toda la lista en segundo plano usando un signo &. Usted aprenderá más sobre cómo construir comandos complejos usando bucles y scripts en artículos posteriores de esta serie. Vea nuestro mapa de ruta de la serie para una descripción de un enlace hacia cada artículo de esta serie.

Listado 6. reloj digital de un hombre pobre
ian@attic4:~$ (while sleep 2; do date;done)&
[2] 4856
ian@attic4:~$ Tue Jan 19 09:23:30 EST 2010
Tue Jan 19 09:23:32 EST 2010
Tue Jan 19 09:23:34 EST 2010
fTue Jan 19 09:23:36 EST 2010
Tue Jan 19 09:23:38 EST 2010
gTue Jan 19 09:23:40 EST 2010

( while sleep 2; do
    date;
done )
Tue Jan 19 09:23:42 EST 2010
Tue Jan 19 09:23:44 EST 2010
Tue Jan 19 09:23:46 EST 2010
^C

Nuestra lista se está ejecutando como trabajo 2 con PID 4856. Cada dos segundos se ejecuta el comando de fecha y se imprime la fecha y hora en la terminal. La entrada que usted digitó se resalta. Una persona que teclee despacio tendrá caracteres con espacios intermedios con varias líneas de resultado antes de que se pueda escribir un comando completo. De hecho, note que la 'f' y la 'g' que usted escribió para traer la lista de comandos al primer plano, están separadas un par de líneas. Cuando usted finalmente logra ingresar el comando fg , bash muestra el comando que se está ejecutando ahora en su shell, a saber, la lista de comandos, la cual todavía estará todavía imprimiendo cada dos segundos.

En cuanto tenga éxito haciendo el trabajo en el segundo plano, usted puede terminarlo (o eliminarlo), o efectuar cualquier otra acción. En este caso, usemos Ctrl-c para terminar nuestro 'reloj'.

Usted se preguntará por qué este trabajo es el trabajo 2. Con el reloj análogo terminado, solo hay un trabajo ejecutándose, que era el trabajo número 1. Así, el siguiente número de trabajo fue asignado y nuestro reloj de hombre pobre se convirtió en el trabajo 2.

Procesos de E/S estándar y de segundo plano

El resultado del comando date en nuestro ejemplo previo está intercalado con caracteres a los que se hizo eco para el comando fg que estamos tratando de escribir. Esto genera un problema interesante. ¿Qué le sucede a un proceso de segundo plano si necesita entrada de stdin?

El proceso terminal bajo el cual iniciamos una aplicación de fondo es llamado controlling terminal. A menos que se redirija a cualquier otra parte, las secuencias stdout y stderr desde el proceso de segundo plano se dirigen hacia la terminal de control. De forma similar, la tarea de segundo plano espera una entrada desde la terminal de control, pero la terminal de control no tiene forma de dirigir ningún carácter que usted escriba en el stdin de un proceso de segundo plano. En tal caso, el Bash shell suspende el proceso de manera que ya no se ejecuta. Usted puede traerlo a primer plano y proporcionar las entradas necesarias. El Listado 7 ilustra un caso simple donde usted puede poner una lista de comandos en segundo plano. Después de un momento, presione Enter y observe el mensaje que dice que el proceso se ha detenido. Tráigalo a primer plano y proporcione una línea de entrada seguida porCtrl-d para señalar el final del archivo de entrada. La lista de comandos se completa y usted muestra el archivo creado.

Listado 7. Esperando a stdin
ian@attic4:~$ (date; cat - > bginput.txt;date)&
[2] 5070
ian@attic4:~$ Tue Jan 19 10:33:13 EST 2010


[2]+  Stopped                 ( date; cat - > bginput.txt; date )
ian@attic4:~$ 
ian@attic4:~$ fg
( date; cat - > bginput.txt; date )
some textmore text
Tue Jan 19 10:33:31 EST 2010
ian@attic4:~$ cat bginput.txt 
some text
more text

Ejecute un proceso después de cerrar sesión

En la práctica usted probablemente desee que las secuencias de E/S estándar de procesos de segundo plano sean redirigidas hacia o desde un archivo. Esta es otra pregunta relacionada: ¿qué le sucede al proceso si la terminal que lo controla se cierra o si el usuario cierra su sesión? LA respuesta depende del shell en uso. Si el shell envía una señal SIGHUP (o hangup), entonces la aplicación probablemente se cerrará. Nosotros cubrimos las señales en breve, pero por ahora consideraremos otra forma de resolver este problema.

nohup

El comando nohup se utiliza para iniciar un comando que ignora señales de hangup y anexará stdout y stderr a un archivo. El archivo predeterminado es nohup.out o $HOME/nohup.out. Si el archivo no puede ser escrito, entonces el comando no se ejecutará. Si usted desea que el resultado se dirija a cualquier otra parte, redirija stdout, o stderr como se trató en el artículo "Learn Linux 101: Streams, pipes and redirects."

El comando nohup ahora ejecutará una interconexión o una línea de comandos. Usted puede guardar una interconexión o lista en un archivo y luego ejecutarla usando el sh (shell predeterminado) o el comando bash . Otro artículo de esta serie le mostrará cómo hacer ejecutable el archivo de script, pero por ahora nos apegaremos a los script en ejecución usando el comando sh o el bash . El Listado 8 muestra cómo podemos hace resto para nuestro reloj digital de hombre pobre. No es necesario decirlo, hacer que la hora se escriba a un archivo no es particularmente útil, y el archivo seguirá creciendo, por lo que configuraremos el reloj para que se actualice cada 30 segundos en lugar de cada segundo.

Listado 8. Usando nohup con una línea de comandos en un script
ian@attic4:~$ echo "while sleep 30; do date;done">pmc.sh 
ian@attic4:~$ nohup sh pmc.sh&
[2] 5485
ian@attic4:~$ nohup: ignoring input and appending output to `nohup.out'

ian@attic4:~$ nohup bash pmc.sh&
[3] 5487
ian@attic4:~$ nohup: ignoring input and appending output to `nohup.out'

Si mostramos el contenido de nohup.out, veremos líneas, con cada línea a aproximadamente 30 segundos después de la que está dos líneas antes que ella, como se muestra en el Listado 9.

Listado 9. Resultado de procesos nohup
ian@attic4:~$cat nohup.out
Tue Jan 19 15:01:12 EST 2010
Tue Jan 19 15:01:26 EST 2010
Tue Jan 19 15:01:44 EST 2010
Tue Jan 19 15:01:58 EST 2010
Tue Jan 19 15:02:14 EST 2010
Tue Jan 19 15:02:28 EST 2010
Tue Jan 19 15:02:44 EST 2010
Tue Jan 19 15:02:58 EST 2010

Las versiones antiguas de nohup no escribieron un mensaje de estado en la terminal de control, por lo que si usted cometió un error, puede que no lo sepa inmediatamente. Usted puede ver la conducta anterior si redirige tanto stdout como stderr hacia un archivo de su propia elección. Suponga que usted ha decidido que sería más fácil aprovisionar el comando usando . en lugar de escribir sh o bash. El Listado 10 muestra qué sucede si usted usa nohup como lo hicimos antes, pero redirigiendo con stdout y stderr. Después de que usted ingresa el comando, puede ver el mensaje que indica que el trabajo 4 ha iniciado con PID 5853. Pero presione Enter de nuevo y verá otro mensaje diciendo que el trabajo se terminó con el código de salida 126.

Listado 10. Cometiendo errores con nohup
ian@attic4:~$ nohup . pmc.sh >mynohup.out 2>&1 &
[4] 5853
ian@attic4:~$ 
[4]+  Exit 126                nohup . pmc.sh > mynohup.out 2>&1

El Listado 11 muestra el contenido de mynohup.out. No es sorprendente en realidad. Usted usa nohup para ejecutar un comando en segundo plano, y utiliza source (.) para leer comandos de un archivos y luego ejecutarlos en el Shell actual. L o que es importante recordar sobre esto es que usted tal vez necesita presionarEnter para permitir que el shell muestre el estado de salida del trabajo en segundo plano, y usted tal vez necesite observar el archivo de salida nohup para ver qué fue realmente los que salió mal.

Listado 11. Mensaje oculto de nohup
ian@attic4:~$ cat mynohup.out
nohup: ignoring input
nohup: cannot run command `.': Permission denied

Ahora enfoquemos nuestra atención en el estado de nuestro proceso. Si usted está siguiendo todo y planea tomar un descanso en este punto, por favor permanezca cerca pues ahora usted tiene dos trabajos que están creando archivos cada vez más grandes en su sistema de archivos. Usted puede usar el comando fg para traer cada uno, a su vez, al primer plano, y luego usar Ctrl-c para terminarlos, pero si desea dejar que se ejecuten un poco más, verá otras formas de supervisarlos e interactuar con ellos.


Supervisión de procesos

Antes tuvimos una breve introducción al comando jobs y vimos cómo usarlo para listar los ID de Proceso (o PIDs) de nuestros trabajos.

ps

Existe otro comando, el comando ps , el cual utilizamos para mostrar en pantalla varias piezas de información de estado procesos. Recuerde que "ps" es el acrónimo de "process status", El comando ps acepta cero o más PIDs como argumentos y muestra los estados de proceso asociados. Si usamos el comando jobs con la opción -p , el resultado es simplemente el PID del líder de grupo de proceso para cada trabajo. Usaremos este resultado como argumento para el comando ps como se muestra en el Listado 12.

Listado 12. Estado de procesos de segundo plano
ian@attic4:~$ jobs -p
3878
5485
5487
ian@attic4:~$ ps $(jobs -p)
  PID TTY      STAT   TIME COMMAND
 3878 pts/1    S      0:06 xclock -d -update 1
 5485 pts/1    S      0:00 sh pmc.sh
 5487 pts/1    S      0:00 bash pmc.sh

Si usted usa ps sin opciones, verá una lista de procesos que tienen su terminal como su terminal de control, como se muestra en el Listado 13. Note que los comandos pmc.sh no aparecen en esta lista. En un momento verá por qué.

Listado 13. Mostrando estado con ps
ian@attic4:~$ ps
  PID TTY          TIME CMD
 2643 pts/1    00:00:00 bash
 3878 pts/1    00:00:06 xclock
 5485 pts/1    00:00:00 sh
 5487 pts/1    00:00:00 bash
 6457 pts/1    00:00:00 sleep
 6467 pts/1    00:00:00 sleep
 6468 pts/1    00:00:00 ps

Diversas opciones, incluyendo -f (full), -j (jobs) y -l (long) proporcionan control sobre cuánta información se muestra. Si usted no especifica ningún PID, entonces otra opción útil es la opción --forest , la cual muestra los comandos en una jerarquía en árbol, mostrando cuáles procesos tienen a cuáles otros como padres. Particularmente, usted verá que los comandos sleep del anterior listado son hijos de los script que usted ha ejecutado en segundo plano. si usted ha podido ejecutar el comando en un momento diferente, podrá ver el comando en un instante diferente, usted podrá ver el comando date listado en su lugar en el estado de proceso, pero esto es muy poco probable con este script. Ilustramos algunas de estas opciones en el Listado 14.

Listado 14. Más información de estado
ian@attic4:~$ ps -f
UID        PID  PPID  C STIME TTY          TIME CMD
ian       2643  2093  0 Jan18 pts/1    00:00:00 bash
ian       3878  2643  0 09:17 pts/1    00:00:06 xclock -d -update 1
ian       5485  2643  0 15:00 pts/1    00:00:00 sh pmc.sh
ian       5487  2643  0 15:01 pts/1    00:00:00 bash pmc.sh
ian       6635  5485  0 15:41 pts/1    00:00:00 sleep 30
ian       6645  5487  0 15:42 pts/1    00:00:00 sleep 30
ian       6647  2643  0 15:42 pts/1    00:00:00 ps -f
ian@attic4:~$ ps -j --forest
  PID  PGID   SID TTY          TIME CMD
 2643  2643  2643 pts/1    00:00:00 bash
 3878  3878  2643 pts/1    00:00:06  \_ xclock
 5485  5485  2643 pts/1    00:00:00  \_ sh
 6657  5485  2643 pts/1    00:00:00  |   \_ sleep
 5487  5487  2643 pts/1    00:00:00  \_ bash
 6651  5487  2643 pts/1    00:00:00  |   \_ sleep
 6658  6658  2643 pts/1    00:00:00  \_ ps

Ahora que usted cuenta con algunas herramientas básicas para monitorear sus procesos usando los comandos jobs y ps , observemos brevemente otros comandos de supervisión antes de pasar a otras formas de seleccionar y ordenar procesos para mostrar.

free

El comando free muestra la cantidad de memoria libre y usada en su sistema. De forma predeterminada se muestra en kilobytes, pero usted puede alterar esto usando -b para bytes, -k para kilobytes, -m para megabytes, o -g para gigabytes. La opción -t muestra una línea total, y la opción -s junto con un valor renueva la información con la frecuencia especificada. El número es en segundos, pero puede ser un valor flotante. El Listado 15 muestra dos ejemplos.

Listado 15. Usando el comando free
ian@attic4:~$ free
             total       used       free     shared    buffers     cached
Mem:       4057976    1543164    2514812          0     198592     613488
-/+ buffers/cache:     731084    3326892
Swap:     10241428          0   10241428
ian@attic4:~$ free -mt
             total       used       free     shared    buffers     cached
Mem:          3962       1506       2456          0        193        599
-/+ buffers/cache:        713       3249
Swap:        10001          0      10001
Total:       13964       1506      12457

uptime

El comando uptime le muestra una visualización de una línea que incluye el tiempo actual, por cuánto tiempo se ha estado ejecutando el sistema, cuántos usuarios están actualmente en sesión activa y los promedios de carga de sistema durante los últimos 1, 5 y 15 minutos. El Listado 16 muestra un ejemplo.

Listado 16. Mostrando información de tiempo de operación
ian@attic4:~$ uptime
 17:41:17 up 20:03,  5 users,  load average: 0.00, 0.00, 0.00

Seleccione y organice procesos para mostrar

Usando ps

El comando ps que ya tratamos solo lista procesos que fueron iniciados desde su sesión de terminal (note la columna de SID, o ID de sesión, en el segundo ejemplo delListado 14). Para ver todos los procesos con terminales de control, use la opción -a . La opción -x muestra procesos sin una terminal de control, y la opción -e muestra información para cada proceso. El Listado 17 muestra el formato completo para todos los procesos con una terminal de control.

Listado 17. Mostrando otros procesos
ian@attic4:~$ ps -af
UID        PID  PPID  C STIME TTY          TIME CMD
ian       3878  2643  0 09:17 pts/1    00:00:06 xclock -d -update 1
ian       5485  2643  0 15:00 pts/1    00:00:00 sh pmc.sh
ian       5487  2643  0 15:01 pts/1    00:00:00 bash pmc.sh
ian       7192  5485  0 16:00 pts/1    00:00:00 sleep 30
ian       7201  5487  0 16:00 pts/1    00:00:00 sleep 30
ian       7202  2095  0 16:00 pts/0    00:00:00 ps -af

Note la terminal de control listada en la columna TTY. Para este listado, cambié la ventana de terminal que abrí originalmente (pts/0), así que el comando ps -af se está ejecutando bajo pts/0, mientras que los comandos creados para este artículo se están ejecutando bajo pts/1.

Hay muchas opciones para ps, incluyendo un número que proporciona control significativo sobre cuáles campos son mostrados y cómo son mostrados. Otros proporciona control sobre la selección de procesos a mostrar, por ejemplo, seleccionando los procesos para un usuario particular (-u) o un comando particular (-C). En el Listado 18 se listan todos los procesos que están ejecutando el comando getty ; usamos la opción -o para especificar las columnas que se mostrarán. Hemos añadido la opción usuario a la lista normal que usted obtiene con el ps plano, para que pueda ver cuál usuario ejecuta getty.

Listado 18. ¿Quién está ejecutando el comando getty?
ian@attic4:~$ ps -C getty -o user,pid,tty,time,comm
USER       PID TT           TIME COMMAND
root      1192 tty4     00:00:00 getty
root      1196 tty5     00:00:00 getty
root      1209 tty2     00:00:00 getty
root      1219 tty3     00:00:00 getty
root      1229 tty6     00:00:00 getty
root      1731 tty1     00:00:00 getty

Algunas veces usted deseará ordenar el resultado por algún campo en particular, y puede hacerlo usando la opción --sort para especificar los campos a ordenar. Lo predeterminado es ordenar en orden ascendente (+), pero usted también puede especificar orden descendente (-). El Listado 19 muestra el ejemplo ps final, donde todos los procesos se listan usando formato de trabajos y donde el resultado es ordenado por ID de sesión y nombre de comando. En la primera usamos el ordenamiento predeterminado, y la segunda vez especificamos ambos ordenamientos de manera específica.

Listado 19. Ordenando el resultado de ps
ian@attic4:~$ ps -aj --sort -sid,+comm
  PID  PGID   SID TTY          TIME CMD
 5487  5487  2643 pts/1    00:00:00 bash
 9434  9434  2643 pts/1    00:00:00 ps
 5485  5485  2643 pts/1    00:00:00 sh
 9430  5485  2643 pts/1    00:00:00 sleep
 9433  5487  2643 pts/1    00:00:00 sleep
 3878  3878  2643 pts/1    00:00:10 xclock
 8019  8019  2095 pts/0    00:00:00 man
 8033  8019  2095 pts/0    00:00:00 pager
ian@attic4:~$ ps -aj --sort sid,comm
  PID  PGID   SID TTY          TIME CMD
 8019  8019  2095 pts/0    00:00:00 man
 8033  8019  2095 pts/0    00:00:00 pager
 5487  5487  2643 pts/1    00:00:00 bash
 9435  9435  2643 pts/1    00:00:00 ps
 5485  5485  2643 pts/1    00:00:00 sh
 9430  5485  2643 pts/1    00:00:00 sleep
 9433  5487  2643 pts/1    00:00:00 sleep
 3878  3878  2643 pts/1    00:00:10 xclock

Como es usual, vea las páginas man para ps para conocer todos los detalles sobre las diversas opciones y campos que usted puede especificar, o puede obtener un breve resumen usandops --help.

Usando top

Si usted ejecuta ps varias veces en una fila para ver lo que está cambiando, probablemente necesite el comando top en lugar de ello. Este muestra una lista de procesos actualizada continuamente, junto con útil información de resumen. El Listado 20 muestra las primeras líneas de una pantalla top . Use el subcomando q para salir de top.

Listado 20. Mostrando procesos usando top
top - 16:07:22 up 18:29,  5 users,  load average: 0.03, 0.02, 0.00
Tasks: 170 total,   1 running, 169 sleeping,   0 stopped,   0 zombie
Cpu(s):  2.1%us,  0.5%sy,  0.0%ni, 97.4%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st
Mem:   4057976k total,  1543616k used,  2514360k free,   194648k buffers
Swap: 10241428k total,        0k used, 10241428k free,   613000k cached

  PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND
 6820 ian       20   0  506m  78m  26m S    1  2.0   0:23.97 firefox
 1381 root      20   0  634m  40m  18m S    1  1.0   2:06.74 Xorg
 2093 ian       20   0  212m  15m  10m S    1  0.4   0:13.53 gnome-terminal
 6925 ian       20   0 1118m 298m  19m S    1  7.5   1:07.04 java
 6855 ian       20   0 73416  11m 8808 S    1  0.3   0:05.01 npviewer.bin
 7351 ian       20   0 19132 1364  980 R    0  0.0   0:00.07 top
    1 root      20   0 19584 1888 1196 S    0  0.0   0:00.74 init
    2 root      15  -5     0    0    0 S    0  0.0   0:00.01 kthreadd

El comando top tiene cierto número de subcomandos, de los cuales los más útiles para comenzar son:

h
le muestra la ayuda
q
termina el comando top .
f
le permite añadir o eliminar campos desde la pantalla
o
ordena el orden de presentación
F
selecciona campos por los cuales ordenar

Vea las páginas man para top para detalles completos sobre opciones, incluyendo cómo ordenar por uso de memoria o por otros criterios. El Listado 21 muestra un ejemplo virtual del resultado clasificado por uso de memoria virtual en orden descendente.

Listado 21. Ordenando el resultado de top
top - 16:21:48 up 18:43,  5 users,  load average: 0.16, 0.06, 0.01
Tasks: 170 total,   3 running, 167 sleeping,   0 stopped,   0 zombie
Cpu(s):  2.1%us,  0.8%sy,  0.0%ni, 96.6%id,  0.0%wa,  0.0%hi,  0.5%si,  0.0%st
Mem:   4057976k total,  1588940k used,  2469036k free,   195412k buffers
Swap: 10241428k total,        0k used, 10241428k free,   613056k cached

  PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND            
 6925 ian       20   0 1171m 338m  21m S    0  8.5   1:44.10 java               
 1381 root      20   0  634m  40m  18m S    0  1.0   2:13.63 Xorg                
 6820 ian       20   0  506m  83m  26m S    3  2.1   0:51.28 firefox            
 2004 ian       20   0  436m  23m  15m S    0  0.6   0:01.55 nautilus           
 2031 ian       20   0  419m  13m  10m S    0  0.3   0:00.11 evolution-alarm    
 2118 ian       20   0  372m  10m 7856 S    0  0.3   0:00.06 evolution-data-    
 2122 ian       20   0  344m  13m  10m S    0  0.3   0:00.10 evolution-excha    
 2001 ian       20   0  331m  22m  14m S    0  0.6   0:13.61 gnome-panel        
 1971 ian       20   0  299m 9.9m 7244 S    0  0.3   0:05.00 gnome-settings-    
 1989 ian       20   0  288m  15m  11m S    0  0.4   0:11.95 metacity           
 1954 ian       20   0  265m 5460 3412 S    0  0.1   0:00.28 pulseaudio

Envíe señales a procesos

Ahora observemos las señales Linux, que son una forma asíncrona para comunicarse con procesos. Ya hemos mencionado la señal SIGHUP, y hemos usado tanto Ctrl-c como Ctrl-z, que son otras formas de enviar una señal a los procesos. LA forma general para enviar una señal es con el comando kill .

Enviando señales usando kill

El comando kill envía una señal a un trabajo o proceso especificado. El Listado 22 muestra el uso de señales SIGTSTP y SIGCONT para detener y reanudar un trabajo en segundo plano. El uso de la señal SIGTSTP es equivalente a usar el comando fg para llevar el trabajo al primer plano y luego hacer Ctrl-z para suspenderlo. Usar SIGCONT es como usar el comando bg .

Listado 22. Deteniendo y reiniciando trabajos en segundo plano
ian@attic4:~$ kill -s SIGTSTP %1

[1]+  Stopped                 xclock -d -update 1
ian@attic4:~$ jobs -l
[1]+  3878 Stopped                 xclock -d -update 1
[2]   5485 Running                 nohup sh pmc.sh &
[3]-  5487 Running                 nohup bash pmc.sh &
ian@attic4:~$ kill -s SIGCONT 3878
ian@attic4:~$ jobs -l
[1]   3878 Running                 xclock -d -update 1 &
[2]-  5485 Running                 nohup sh pmc.sh &
[3]+  5487 Running                 nohup bash pmc.sh &

Utilizamos la especificación de trabajo (%1) para detener el proceso xclock de este ejemplo, y luego el ID de proceso (PID) para reiniciarlo (continuarlo). Si usted detuvo el trabajo %2 y luego usó tail con la opción -f para seguirlo, verá que solo un proceso está actualizando el archivo nohup.out.

Existen numerosas señales adicionales posibles que usted puede visualizar en su sistema usando kill -l. Algunas se utilizan para reportar errores, como códigos de operación ilegales, excepciones de punto flotante, o intentos de acceso a memoria a los que un proceso no tiene acceso. Note que las señales tienen tanto un número, como 20, y un nombre, como SIGTSTP. Usted puede usar o el número con un signo - como prefijo, o la opción -s y el nombre de señal. En mi sistema podría haber usado kill -20 en lugar de kill -s SIGTSTP. Usted siempre debe verificar los números de señal de su sistema antes de suponer cuál número pertenece a cuál señal.

Manejadores de señal y terminación de procesos

Usted ha visto que Ctrl-c termina un proceso. De hecho, este envía una señal SIGINT (o interrupt) al proceso. Si usted usa kill sin ningún nombre de señal, este envía una señal SIGTERM. Para la mayoría de los propósitos, estas señales son equivalentes.

Usted ha visto que el comando nohup hace que un propósito sea inmune a la señal SIGHUP. En general, un proceso puede implementar señales signal handler hasta catch . Así un proceso podría implementar un manejador de señales para capturar SIGINT o SIGTERM. Como el manejador de señales sabe cuál señal se ha enviado, este puede optar por ignorar SIGINT y solo terminarlo cuando reciba SIGTERM, por ejemplo. El Listado 23 muestra cómo enviar la señal SIGTERM al trabajo %2. Note que el estado de proceso se muestra como "Terminated" justo después de que enviamos la señal. Si en su lugar hubiéramos usado SIGINT este mostraría "Interrupt". Después de algunos momentos habrá sucedido la limpieza de proceso y el trabajo ya no aparecerá en la lista de trabajos.

Listado 23. Terminando un proceso con SIGTERM
ian@attic4:~$ kill -s SIGTERM %2
ian@attic4:~$ 
[2]-  Terminated              nohup sh pmc.sh
ian@attic4:~$ jobs -l
[1]-  3878 Running                 xclock -d -update 1 &
[3]+  5487 Running                 nohup bash pmc.sh &

Los manejadores de señal proporcionan a los procesos gran flexibilidad. Un proceso puede hacer su trabajo normal y puede ser interrumpido por una señal por algún propósito especial. Además de permitir que un proceso capture solicitudes de terminación y que lleve a cabo las acciones posibles, como cerrar archivos o marcar puntos de verificación en transacciones en curso, las señales se usan a menudo para decirle a un proceso daemon que vuelva a leer su archivo de configuración y posiblemente que reinicie la operación. Usted puede hacer esto para el proceso inetd cuando cambia parámetros de red, o el daemon de impresora de línea (lpd) cuando añade una nueva impresora.

Terminando procesos incondicionalmente

Algunas señales no se pueden atrapar, como algunas excepciones de hardware. SIGKILL, el que más probablemente utilizará usted no puede ser capturado por un manejador de señales y termina un proceso incondicionalmente. En general, Usted necesitará esto solo si todos los otros medios de terminación de proceso han fallado.


Cierre de sesión y nohup

Recuerde que vimos que usar nohup le permitiría a sus procesos seguir funcionando después de que usted cerrara sesión. Bien, vamos a hacerlo y luego volveremos a iniciar sesión. Después de que usted inicie sesión, revise su proceso remanente de reloj de hombre pobre usandojobs y ps como lo hemos hecho arriba. El resultado se muestra en el Listado 24.

Listado 24. Volviendo a iniciar sesión
ian@attic4:~$ jobs -l
ian@attic4:~$ ps -a
  PID TTY          TIME CMD
10995 pts/0    00:00:00 ps

Esta vez estamos ejecutando pts/0, pero no hay signos de nuestros trabajos, solo el comando ps . No es tal vez lo que estábamos esperando. No obstante, no todo está perdido. Suponga que no puede recordar si usted terminó el trabajo nohup que comenzó con bash o el que inició con bash. Arriba usted vio cómo encontrar los procesos que estaban ejecutando el comando getty , así que puede usar el mismo truco para mostrar solo SID, PID, PPID y la serie de comandos. Luego puede usar la opción -js para mostrar todos los procesos de la sesión. El Listado 25 muestra el resultado. Piense en otras formas en las que usted habría podido encontrar estos procesos, como buscando por nombre de usuario y luego filtrando usando grep.

Listado 25. Encontrando nuestros comandos perdidos
ian@attic4:~$ ps -C bash -C sh -o pid,sid,tname,cmd
  PID   SID TTY      CMD
 5487  2643 ?        bash pmc.sh
 7050  7050 pts/3    -bash
10851 10851 pts/0    bash
ian@attic4:~$ ps -js 2643
  PID  PGID   SID TTY          TIME CMD
 5487  5487  2643 ?        00:00:00 bash
11197  5487  2643 ?        00:00:00 sleep

Note que el pmc.sh todavía se está ejecutando pero que ahora tiene un signo de interrogación (?) para el TTY que controla.

Dado que usted ya ha aprendido sobre eliminación de procesos, usted podrá eliminar el proceso restante de reloj de hombre pobre usando si PID y el comando kill .

Recursos

Aprender

Obtener los productos y tecnologías

  • Con el software de prueba IBM, disponible para descarga directamente desde developerWorks, construya su próximo proyecto de desarrollo en Linux.

Comentar

Comentarios

developerWorks: Ingrese

Los campos obligatorios están marcados con un asterisco (*).


¿Necesita un IBM ID?
¿Olvidó su IBM ID?


¿Olvidó su Password?
Cambie su Password

Al hacer clic en Enviar, usted está de acuerdo con los términos y condiciones de developerWorks.

 


La primera vez que inicie sesión en developerWorks, se creará un perfil para usted. La información en su propio perfil (nombre, país/región y nombre de la empresa) se muestra al público y acompañará a cualquier contenido que publique, a menos que opte por la opción de ocultar el nombre de su empresa. Puede actualizar su cuenta de IBM en cualquier momento.

Toda la información enviada es segura.

Elija su nombre para mostrar



La primera vez que inicia sesión en developerWorks se crea un perfil para usted, teniendo que elegir un nombre para mostrar en el mismo. Este nombre acompañará el contenido que usted publique en developerWorks.

Por favor elija un nombre de 3 - 31 caracteres. Su nombre de usuario debe ser único en la comunidad developerWorks y debe ser distinto a su dirección de email por motivos de privacidad.

Los campos obligatorios están marcados con un asterisco (*).

(Por favor elija un nombre de 3 - 31 caracteres.)

Al hacer clic en Enviar, usted está de acuerdo con los términos y condiciones de developerWorks.

 


Toda la información enviada es segura.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=90
Zone=Linux
ArticleID=783717
ArticleTitle=Aprenda Linux, 101: Cree, supervise y elimine procesos
publish-date=01062012