Usando el control de trabajos
Control de trabajos se refiere a la habilidad de poner procesos (esencialmente, otra palabra para programas) en background (segundo plano) y ponerlos de vuelta en foreground (primer plano).
Esto es como decir, que se quiere ser capaz de ejecutar algo mientras se hacen otras cosas, pero que estén ahí otra vez cuando se les quiera decir algo o pararlos. En Unix, la principal herramienta para el control de procesos es el shell, seguirá la pista de los procesos por usted, si se aprende como hablar su lenguaje.
Las dos palabras más importantes en ese lenguaje son fg, para primer plano, y bg, para segundo plano. Para entender como funcionan, use el comando yes en el indicador del sistema.
/home/larry$ yes
Esto produce el maravilloso efecto de desplazar una larga columna de yes por la parte izquierda de la pantalla, tan rápido que no se pueden seguir5. Para pararlo, se podría pulsar |_Ctrl-c_| y matarlo, pero esta vez Ud. oprimirá |_Ctrl-z_|. Parece haberse detenido, pero habrá un mensaje antes del indicador de sistema, más o menos parecido a este:
[1]+ Stopped yes
_
5 Hay buenas razones para que este extraño comando exista. Ciertos comandos esperan una confirmación, un "si" ([y]es en inglés) a una pregunta. El comando yes permite al programador automatizar la respuesta a esas preguntas.
Significa que el trabajo yes se ha suspendido en el segundo plano. Se puede hacer que siga ejecutándose tecleando fg en el indicador de sistema, que lo pondrá en primer plano otra vez. Si se desea, se pueden hacer otras cosas antes, mientras está suspendido. Pruebe unos cuantos ls o algo antes de ponerlo en primer plano nuevamente.
Una vez que ha vuelto al primer plano, las yes empezarán a salir otra vez, tan rápido como antes.
No hay que preocuparse de que si mientras ha estado suspendido ha "almacenado" más yes para enviarlas a la pantalla: cuando un trabajo se suspende, el programa entero no se ejecuta hasta que se lo vuelva de vuelta a la vida. (Ahora pulse |_Ctrl-c_| para matarlo de veras).
Pongamos aparte el mensaje que obtuvimos del shell:
[1]+ Stopped yes
El número entre corchetes es el número de trabajo de este proceso, y se usará cuando se necesite referenciarlo específicamente. (Naturalmente, desde el momento que tengamos en ejecución múltiples trabajos, se necesita un modo de acceder a cada uno). El "+" siguiente indica que ése es el "trabajo actual", esto es, el proceso más reciente que se ha movido del primer plano al segundo.
Si se tecleara "fg" , se pondría el trabajo con el "+" en primer plano otra vez. (Más sobre esto después, cuando se discuta la ejecución de múltiples trabajos a la vez). La palabra Stopped significa que el trabajo está "parado". El trabajo no está muerto, pero actualmente no se ejecuta. Linux lo ha guardado en un estado especial de suspendido, listo para saltar a la acción cuando alguien lo solicite. Finalmente, el yes es el nombre del trabajo que se ha detenido.
Antes de seguir adelante, matemos este trabajo y lo arrancamos otra vez de forma diferente. El comando se llama kill y se usa del siguiente modo:
/home/larry$ kill %1
[1]+ Stopped yes
/home/larry$
Ese mensaje sobre el proceso que indica "parado" otra vez induce a error. Para saber si aún está vivo (eso es, tanto en ejecución como congelado en un estado suspendido), teclee "jobs":
/home/larry$ jobs
[1]+ Terminated yes
/home/larry$
Ahora ya lo sabe: ¡el trabajo ha terminado! (Es posible que el comando jobs no muestre nada, lo que simplemente significa que no hay trabajos ejecutándose en segundo plano. Si se acaba de matar un trabajo, y al teclear jobs no muestra nada, se tiene la seguridad de que el comando kill se ha ejecutado correctamente. Normalmente indicará que el trabajo ha "terminado").
Ahora, ejecute yes de nuevo, de esta forma:
/home/larry$ yes > /dev/null
Si lee la sección sobre la redirección de entrada y salida, sabrá que se está enviando la salida de yes a un fichero especial llamado /dev/null. /dev/null es un agujero negro que come cualquier salida que se le envíe (se puede imaginar ese torrente de yes saliendo por detrás del ordenador y perforando un agujero en la pared, si eso le hace feliz).
Después de teclear esto, no se recuperará el indicador de sistema, pero tampoco saldrá esa columna de yes. Sin embargo la salida se está enviando a /dev/null, el trabajo aún se ejecuta en primer plano. Como siempre, se puede suspender pulsando |_Ctrl-z_|. Hágalo ahora para volver al indicador del sistema.
/home/larry$ yes > /dev/null
["yes" se ejecuta, y solamente se ha pulsado Ctrl-z]
[1]+ Stopped yes >/dev/null
/home/larry$
Hmm. . . ¿hay alguna forma de ponerlo en ejecución en segundo plano, mientras deja el indicador del sistema para trabajar de forma interactiva? El comando para hacer eso es bg:
/home/larry$ bg
[1]+ yes >/dev/null &
/home/larry$
Ahora, deberá tener confianza en mí sobre esto: después de teclear bg, el trabajo "yes > /dev/null" habrá continuado con su ejecución otra vez, pero esta vez en segundo plano. De hecho, si hace alguna cosa en el prompt, como ls u otros, se dará cuenta que su máquina se ha ralentizado un poco (¡generar y descargar continuamente una cadena preparada de "yes" lleva algo de tiempo, al fin y al cabo!) Aparte de esto, no hay ningún otro efecto. Se puede hacer lo que se desee en el indicador del sistema, y yes continuará felizmente enviando su salida al agujero negro.
Ahora hay dos formas diferentes de matarlo: con el comando kill que ya se explicó, o poniendo el trabajo en primer plano de nuevo e interrumpirlo con una interrupción, |_Ctrl-c_|. Probemos la segunda forma, sólo para entender la relación entre fg y bg un poco mejor;
/home/larry$ fg
yes >/dev/null
[ahora esta en primer plano. Imagine que pulso Ctrl-c para terminarlo]
/home/larry$
Bueno, se acabó. Ahora, ejecute unos cuantos trabajos simultáneamente, como estos:
/home/larry$ yes > /dev/null &
[1] 1024
/home/larry$ yes _ sort > /dev/null &
[2] 1026
/home/larry$ yes _ uniq > /dev/null
[y aqui, pulse Ctrl-z para suspenderlo, por favor]
[3]+ Stopped yes _ uniq >/dev/null
/home/larry$
La primera cosa que le debe llamar la atención de estos comandos es la terminación "&" al final de los dos primeros. Poner un "&" después del comando indica al shell que los ejecute en segundo plano desde el principio. (Es una forma de evitarse tener que ejecutar el programa, pulsar |_Ctrl-z_|, y luego teclear "bg" .) Así, estos dos comandos han empezado a ejecutarse en segundo plano. El tercero está suspendido e inactivo en este momento. Se puede dar cuenta de que la máquina se ha vuelto más lenta, ya que los que se están ejecutando requieren un poco de tiempo de CPU.
Cada uno indica su número de trabajo. Los dos primeros también muestran sus números de identificación de proceso, o PID, después del número de trabajo. Los PIDs normalmente no son algo que se necesite conocer, pero a veces viene bien.
Matemos el segundo, ya que creo que está ralentizando su máquina. Se puede teclear "kill %2", pero eso sería demasiado fácil. Por el contrario, haga esto:
/home/larry$ fg %2
yes _ sort >/dev/null
[pulse Ctrl-c para matarlo]
/home/larry$
Como esto demuestra, fg toma parámetros empezando con "%" . De hecho, se podría teclear sólo esto:
/home/larry$ %2
yes _ sort >/dev/null
[pulse Ctrl-c para matarlo]
/home/larry$
Esto funciona por que el shell automáticamente interpreta un número de trabajo como una petición para poner ese trabajo en primer plano. Se puede indicar los números de trabajo con otros números precedidos por un "%". Ahora teclee "jobs" para ver cuáles trabajos quedan en ejecución:
/home/larry$ jobs
[1]- Running yes >/dev/null &
[3]+ Stopped yes _ uniq >/dev/null
/home/larry$
El "-" indica que ese trabajo número 1 es segundo en la lista para ser puesto en el primer plano, si sólo se teclea "fg" sin dar parámetros. El "+" indica que el trabajo especificado es el primero en la lista un "fg" sin parámetros pondrá al trabajo número 3 en el primer plano. Sin embargo, se puede acceder a él llamándolo, si se desea, mediante:
/home/larry$ fg %1
yes >/dev/null
[ahora pulse Ctrl-z para suspenderlo]
[1]+ Stopped yes >/dev/null
/home/larry$
Al cambiar al trabajo número 1 y luego suspenderlo han cambiado las prioridades de todos los trabajos de usuario. Esto se puede ver con el comando jobs:
/home/larry$ jobs
[1]+ Stopped yes >/dev/null
[3]- Stopped yes _ uniq >/dev/null
/home/larry$
Ahora los dos están parados (porque los dos se han suspendido con |_Ctrl-z_|), y el número 1 es el siguiente en la lista a entrar en el primer plano por defecto. Esto es así porque se le puso en el primer plano manualmente, y luego fue suspendido. El "+" siempre se refiere al trabajo más reciente que ha sido suspendido del primer plano. Se puede continuar con su ejecución otra vez:
/home/larry$ bg
[1]+ yes >/dev/null &
/home/larry$ jobs
[1]- Running yes >/dev/null
[3]+ Stopped yes _ uniq >/dev/null
/home/larry$
Fíjese que ahora está en ejecución, y el otro trabajo se ha movido en la lista y tiene el "+". Ahora matémoslos para que el sistema no esté permanentemente ralentizado por procesos que no hacen nada.
/home/larry$ kill %1 %3
[3] Terminated yes _ uniq >/dev/null
/home/larry$ jobs
[1]+ Terminated yes >/dev/null
/home/larry$
Aparecerán varios mensajes sobre la terminación de los trabajos, nada muere tranquilamente, al parecer. La figura 6.1 de la página 59 muestra un breve resumen de lo que se debe saber acerca del control de trabajos.
Teoría del control de trabajos
Es importante entender que el control de procesos lo hace el shell. No hay ningún programa en el sistema llamado fg; por eso, fg, bg, &, jobs, y kill son internos al shell6. (A veces kill es un programa independiente; en el shell bash usado por Linux pertenece al shell). Esto es una forma lógica de hacerlo: ya que cada usuario quiere su propio espacio de control de trabajos, y cada usuario ya tiene su propio shell, es más fácil que el shell siga la pista de los trabajos usuario. Por otro lado, cada número de trabajo de usuario sólo tiene significado para ese usuario: mi trabajo número [1] y su trabajo número [1] son probablemente dos procesos totalmente diferentes. De hecho, si se está conectado más de una vez, cada uno de los shells tendrá datos únicos sobre el control de trabajos, así como también un usuario puede tener dos trabajos diferentes con el mismo número ejecutándose en dos shells diferentes.
_
6 N. del T.: En el original pone "shell-builtins", eso es que se compilan dentro del shell.
La manera segura de referenciarlos es usar el número IDentificador de Proceso (PID). Estos números abarcan todo el sistema, cada proceso tiene su propio (y único) número. Dos usuarios diferentes pueden referenciar un proceso por su PID y saber que están hablando sobre el mismo proceso (¡asumiendo que están conectados en la misma máquina!).
Echémosle un vistazo a un comando más para entender que son los PIDs. El comando ps lista todos los procesos en ejecución, incluyendo el shell. Pruébelo. Tiene también unas cuantas opciones, de las cuales las más importantes (para mucha gente) son "a" , "u" , y "x" . La opción "a" lista los procesos pertenecientes a algún usuario, no sólo los suyos propios. La "x" lista los procesos que no tienen un terminal asociado a ellos7. Finalmente, la "u" da información adicional sobre los procesos que es frecuentemente útil.
Para hacerse una idea de lo que realmente está haciendo el sistema, se ponen todos juntos: "ps -aux" . Se pueden ver los procesos que usan más memoria mirando la columna %MEM, y más CPU mirando a la columna %CPU. (La columna TIME lista la cantidad total de tiempo de CPU usado).
Otra nota rápida sobre los PIDs. kill, aparte de tomar opciones de la forma %no_trabajo, toma opciones de los PIDs en crudo. Esto es, si pone un "yes > /dev/null" en segundo plano, se ejecuta "ps" , y se busca el yes. Luego se teclea "kill PID" 8 .
Si empieza a programar en C con su sistema Linux, pronto aprenderá que el control de trabajos del shell es sólo una versión interactiva de las llamadas a las funciones fork y execl. Esto es demasiado complejo para explicarlo aquí, pero sería útil recordarlo después cuando se esté programando y se quieran ejecutar múltiples procesos desde un simple programa.
