Saltar al contenido principal

Lab 4.2 - Control de Procesos

Objetivos​

Al final de este laboratorio, usted será capaz de:

  • Iniciar procesos
  • Detener procesos (kill, killall, pkill)
  • Suspender y reanudar procesos
  • Gestionar jobs en segundo plano
  • Comprender las señales de Linux

Prerrequisitos​

  • Ubuntu 24.04 instalado
  • Terminal abierto
  • Acceso de usuario normal

Ejercicio 1: Iniciar Procesos​

Paso 1: Proceso en Primer Plano​

# Iniciar un proceso simple
sleep 60

# Iniciar un proceso interactivo
nano test.txt
# (Ctrl+X para salir)

Paso 2: Proceso en Segundo Plano​

# Iniciar en segundo plano con &
sleep 300 &

# Ver el PID
echo $!

# Ver los jobs
jobs

# Ver los procesos en segundo plano
ps aux | grep sleep

Paso 3: nohup​

# Iniciar un proceso que continúa después de la desconexión
nohup sleep 600 > sleep.log 2>&1 &

# Verificar
ps aux | grep sleep
cat sleep.log

Ejercicio 2: Señales de Linux​

Paso 1: Comprender las Señales​

# Ver todas las señales
kill -l

# Señales comunes:
# SIGTERM (15): Terminación elegante
# SIGKILL (9):  Terminación forzada (no puede ser ignorada)
# SIGSTOP (19): Suspender
# SIGCONT (18): Reanudar
# SIGHUP (1):   Hang up (reiniciar)

Paso 2: Enviar Señales​

# Iniciar un proceso
sleep 300 &
PID=$!

# Enviar SIGTERM (terminación elegante)
kill $PID

# O con el número
kill -15 $PID

# Verificar
ps -p $PID

Ejercicio 3: kill, killall, pkill​

Paso 1: kill​

# Iniciar varios procesos
sleep 100 &
PID1=$!
sleep 200 &
PID2=$!

# Matar un proceso específico
kill $PID1

# Matar varios procesos
kill $PID1 $PID2

# Matar con fuerza (SIGKILL)
kill -9 $PID1

Paso 2: killall​

# Iniciar varias instancias
sleep 100 &
sleep 200 &
sleep 300 &

# Matar todos los procesos "sleep"
killall sleep

# Con confirmación
killall -i sleep

# Verificar
ps aux | grep sleep

Paso 3: pkill​

# Iniciar procesos
sleep 100 &
sleep 200 &

# Matar por nombre (patrón)
pkill sleep

# Matar por usuario
pkill -u $USER sleep

# Ver lo que se matará (dry-run)
pkill -l sleep

Ejercicio 4: Suspender y Reanudar​

Paso 1: Suspender un Proceso​

# Iniciar un proceso
sleep 300 &

# Suspender con kill
kill -STOP $!

# O con Ctrl+Z (si está en primer plano)
# sleep 300
# [Presionar Ctrl+Z]

# Ver el estado
ps aux | grep sleep
# Note la "T" (stopped)

Paso 2: Reanudar un Proceso​

# Reanudar en segundo plano
kill -CONT $PID

# Reanudar en primer plano
fg

# Reanudar en segundo plano
bg

Ejercicio 5: Gestión de Jobs​

Paso 1: Comandos Jobs​

# Iniciar varios jobs
sleep 100 &
sleep 200 &
sleep 300 &

# Ver los jobs
jobs

# Ver con PID
jobs -l

# Traer un job al primer plano
fg %1  # Job número 1

# Enviar al segundo plano
bg %1

# Matar un job
kill %1

Paso 2: Script con Jobs​

# Crear un script
cat > test-jobs.sh << 'EOF'
#!/bin/bash
sleep 10 &
JOB1=$!
sleep 20 &
JOB2=$!

echo "Jobs lanzados: $JOB1, $JOB2"
jobs

# Esperar a que terminen
wait $JOB1
echo "Job 1 terminado"
wait $JOB2
echo "Job 2 terminado"
EOF

chmod +x test-jobs.sh
./test-jobs.sh

Ejercicio 6: Proceso Zombi​

Paso 1: Crear un Zombi (para prueba)​

# Script que crea un zombi
cat > zombie.sh << 'EOF'
#!/bin/bash
# Fork de un proceso hijo que muere inmediatamente
# El padre no hace wait()
(
    sleep 1
    exit
) &
# El padre no hace wait, el hijo se convierte en zombi
sleep 10
EOF

chmod +x zombie.sh
./zombie.sh &

# Ver los zombis
ps aux | grep -w Z

Paso 2: Limpiar los Zombis​

# Los zombis son limpiados automáticamente por init (PID 1)
# Pero se puede forzar matando al padre
ps aux | grep zombie
# Encontrar el PID del padre y matarlo

Ejercicio 7: Práctica Completa​

Paso 1: Escenario Real​

# Iniciar un servidor web de prueba
python3 -m http.server 8000 &
SERVER_PID=$!

# Verificar que está en ejecución
ps -p $SERVER_PID
curl http://localhost:8000

# Detener elegantemente
kill $SERVER_PID

# Verificar
ps -p $SERVER_PID

Paso 2: Script de Gestión​

# Script para gestionar un proceso
cat > manage-process.sh << 'EOF'
#!/bin/bash
PROCESS="python3"
ACTION=$1

case $ACTION in
    start)
        python3 -m http.server 8000 > /dev/null 2>&1 &
        echo "Servidor iniciado: $!"
        ;;
    stop)
        pkill -f "python3 -m http.server"
        echo "Servidor detenido"
        ;;
    status)
        if pgrep -f "python3 -m http.server" > /dev/null; then
            echo "Servidor activo"
            ps aux | grep "python3 -m http.server" | grep -v grep
        else
            echo "Servidor inactivo"
        fi
        ;;
    restart)
        $0 stop
        sleep 1
        $0 start
        ;;
    *)
        echo "Uso: $0 {start|stop|status|restart}"
        exit 1
        ;;
esac
EOF

chmod +x manage-process.sh

# Usar
./manage-process.sh start
./manage-process.sh status
./manage-process.sh stop

Verificación​

Lista de Verificación​

Verifique que usted puede:

  • Iniciar procesos (primer plano y segundo plano)
  • Enviar señales (kill, killall, pkill)
  • Suspender y reanudar procesos
  • Gestionar jobs (jobs, fg, bg)
  • Comprender las diferentes señales
  • Gestionar procesos de manera práctica

Preguntas de Reflexión​

  1. ¿Cuál es la diferencia entre SIGTERM y SIGKILL?

    • SIGTERM: Terminación elegante (puede ser interceptada)
    • SIGKILL: Terminación forzada (no puede ser ignorada)

  2. ¿Por qué usar nohup?

    • Permite que el proceso continúe después de desconectarse del terminal
    • Útil para tareas largas

  3. ¿Qué es un proceso zombi?

    • Proceso terminado cuyo padre no ha hecho wait()
    • Limpiado automáticamente por init

Próximos Pasos​

  • Lab 4.3: Prioridades y valores Nice
  • Lab 4.4: Jobs y tareas en segundo plano
  • Capítulo 4.2: Visualización de procesos

Lab creado el: diciembre 2024 - Probado en Ubuntu 24.04