Teoria: Monitoratge de Fils (Threads) amb Bash

Introducció

Els fils (threads) són unitats d'execució dins d'un procés que comparteixen el mateix espai de memòria. Com a administradors de sistemes, és essencial saber identificar, monitorar i gestionar els fils dels processos en execució.

A diferència dels processos, que són completament independents, els fils d'un mateix procés comparteixen recursos, cosa que els fa més lleugers però també requereix eines específiques per visualitzar-los.

Conceptes bàsics

Procés vs Fil

Procés (Process): Unitat independent amb el seu propi PID, espai de memòria, descriptors de fitxers, etc.
Fil (Thread): Unitat d'execució dins d'un procés. Diversos fils poden existir dins del mateix procés.
TID (Thread ID): Identificador únic de cada fil dins del sistema.

Per què és important monitorar fils?

Diagnòstic de rendiment: Identificar fils que consumeixen massa CPU o memòria
Depuració: Detectar fils bloquejats o en estat zombie
Optimització: Entendre com les aplicacions utilitzen el paral·lelisme
Troubleshooting: Identificar problemes de concurrència o deadlocks

Comandes per monitorar fils

1. ps - Llistar fils d'un procés

Mostrar tots els fils d'un procés específic

ps -p PID -T

Exemple:

# Si el PID del procés és 12345
ps -p 12345 -T

Sortida típica:

  PID  SPID TTY          TIME CMD
12345 12345 pts/0    00:00:00 fils01
12345 12346 pts/0    00:00:01 fils01
12345 12347 pts/0    00:00:01 fils01
12345 12348 pts/0    00:00:01 fils01

On:

PID: ID del procés pare
SPID: ID del fil (Thread ID)
TIME: Temps de CPU utilitzat
CMD: Nom del programa

Mostrar més informació dels fils

ps -p PID -L -o pid,tid,pcpu,pmem,comm

Exemple:

ps -p 12345 -L -o pid,tid,pcpu,pmem,comm

Sortida:

  PID   TID %CPU %MEM COMMAND
12345 12345  0.0  0.1 fils01
12345 12346  0.3  0.1 fils01
12345 12347  0.3  0.1 fils01
12345 12348  0.3  0.1 fils01

Mostrar tots els fils del sistema

ps -eLf

Això mostra TOTS els fils de TOTS els processos (pot ser molt llarg).

Comptar nombre de fils d'un procés

ps -p PID -T | wc -l

o més elegant:

ps -p PID -T --no-headers | wc -l

2. top - Monitoratge en temps real

Mostrar fils en top

Per defecte, top no mostra fils. Per activar la visualització de fils:

Opció 1: Iniciar top amb fils

top -H

Opció 2: Dins de top

Executa top
Prem H per alternar entre processos i fils

Opció 3: Monitorar un procés específic

top -H -p PID

Exemple:

top -H -p 12345

Ordenar per consum de CPU en top

Dins de top:

Prem P per ordenar per CPU
Prem M per ordenar per memòria
Prem T per ordenar per temps de CPU acumulat

Filtrar dins de top

Dins de top, prem L i després pots buscar text (per exemple, el nom del programa).

3. htop - Visualització avançada (si està disponible)

htop és una alternativa més amigable a top amb millor visualització.

Instal·lació

# Debian/Ubuntu
sudo apt-get install htop

# RHEL/CentOS
sudo yum install htop

Mostrar fils en htop

Opció 1: Iniciar amb fils

htop -t

Opció 2: Dins de htop

Executa htop
Prem F2 (Setup)
Navega a "Display options"
Activa "Tree view" i "Show custom thread names"
Prem F10 per sortir

Opció 3: Vista d'arbre
Dins de htop, prem F5 per alternar la vista d'arbre (mostra fils com a fills del procés).

Filtrar per procés en htop

Prem F3 o / per buscar
Escriu el nom del procés o PID
Prem F4 per filtrar (només mostra coincidències)

4. Eines addicionals

pstree - Visualització en arbre

pstree -p PID

Mostra l'arbre de processos i fils:

pstree -p 12345 -t

Exemple de sortida:

fils01(12345)─┬─{fils01}(12346)
              ├─{fils01}(12347)
              ├─{fils01}(12348)
              └─{fils01}(12349)

/proc filesystem

El directori /proc/PID/task/ conté informació sobre cada fil:

ls /proc/12345/task/

Sortida:

12345  12346  12347  12348  12349

Cada subdirectori correspon a un TID (Thread ID).

Veure estat d'un fil:

cat /proc/12345/task/12346/status | head -20

Comptar fils:

ls /proc/12345/task/ | wc -l

Exemples pràctics amb els programes fils01

Escenari: Executar el programa C

# Compilar
gcc -pthread fils01.c -o fils01

# Executar amb 6 fils durant 120 segons
./fils01 6 120

El programa ens mostra el PID:

=== PROGRAMA DE FILS ===
PID del procés: 12345
...

Monitoratge bàsic

1. Veure els fils creats

ps -p 12345 -T

2. Veure consum de recursos per fil

ps -p 12345 -L -o pid,tid,pcpu,pmem,stat,comm

Sortida esperada:

  PID   TID %CPU %MEM STAT COMMAND
12345 12345  0.0  0.1 Sl   fils01
12345 12346  0.1  0.1 Sl   fils01
12345 12347  0.1  0.1 Sl   fils01
12345 12348  0.1  0.1 Sl   fils01
12345 12349  0.1  0.1 Sl   fils01
12345 12350  0.1  0.1 Sl   fils01
12345 12351  0.1  0.1 Sl   fils01

On STAT indica l'estat:

S: Sleeping (dormint, esperant)
R: Running (executant-se)
l: Multi-threaded (té múltiples fils)

3. Monitoratge en temps real

# Amb top
top -H -p 12345

# O dins de top normal
top
# després prem 'H'

4. Veure jerarquia de fils

pstree -p 12345 -t

Escenari: Executar el programa Python

# Executar amb 4 fils durant 60 segons
python3 fils01.py 4 60

Les mateixes comandes de monitoratge funcionen:

# Obtenir PID (el programa ho mostra, o bé:)
pgrep -f fils01.py

# Monitorar fils
ps -p <PID> -T

# Monitoratge en temps real
top -H -p <PID>

Comparació C vs Python

Pots executar els dos programes simultàniament i comparar:

# Terminal 1
./fils01 5 300

# Terminal 2
python3 fils01.py 5 300

# Terminal 3
# Compara el consum de recursos
ps -eLo pid,tid,pcpu,pmem,comm | grep -E "(fils01|python3)"

Scripts útils per monitoratge

Script 1: Monitorar fils contínuament

#!/bin/bash
# monitor_threads.sh - Monitorar fils d'un procés

if [ -z "$1" ]; then
    echo "Ús: $0 PID"
    exit 1
fi

PID=$1

watch -n 2 "ps -p $PID -L -o pid,tid,pcpu,pmem,stat,comm"

Ús:

./monitor_threads.sh 12345

Script 2: Comptar fils cada segon

#!/bin/bash
# count_threads.sh - Comptar fils al llarg del temps

if [ -z "$1" ]; then
    echo "Ús: $0 PID [segons]"
    exit 1
fi

PID=$1
DURATION=${2:-60}

echo "Monitorant fils del PID $PID durant $DURATION segons"
echo "Temps,Nombre_Fils"

for i in $(seq 1 $DURATION); do
    COUNT=$(ps -p $PID -T --no-headers 2>/dev/null | wc -l)
    if [ $? -ne 0 ]; then
        echo "Procés $PID ha finalitzat"
        break
    fi
    echo "$i,$COUNT"
    sleep 1
done

Ús:

./count_threads.sh 12345 120 > thread_count.csv

Script 3: Alerta si massa fils

#!/bin/bash
# alert_threads.sh - Alertar si un procés té massa fils

if [ -z "$1" ] || [ -z "$2" ]; then
    echo "Ús: $0 PID LLINDAR"
    exit 1
fi

PID=$1
LLINDAR=$2

while true; do
    if ! kill -0 $PID 2>/dev/null; then
        echo "Procés $PID no existeix"
        exit 1
    fi
    
    COUNT=$(ps -p $PID -T --no-headers | wc -l)
    
    if [ $COUNT -gt $LLINDAR ]; then
        echo "[ALERTA] $(date): Procés $PID té $COUNT fils (llindar: $LLINDAR)"
    fi
    
    sleep 5
done

Ús:

./alert_threads.sh 12345 10

Informació avançada

Estats dels fils

Els fils poden estar en diferents estats:

R (Running): Executant-se o llest per executar-se
S (Sleeping): Esperant un esdeveniment (interruptible)
D (Disk sleep): Esperant I/O (no interruptible)
Z (Zombie): Fil acabat però no netejat
T (Stopped): Aturat (per exemple, amb Ctrl+Z)
t (Tracing stop): Aturat per debugger

Limitacions del sistema

Veure límits de fils:

# Límit màxim de fils per procés
cat /proc/sys/kernel/threads-max

# Límit per usuari
ulimit -u

# Processos i fils actuals al sistema
ps -eLf | wc -l

Problemes comuns

Fil en estat D (uninterruptible sleep)

Indica que el fil està esperant I/O i no pot ser interromput. Si això persisteix, pot indicar:

Problemes amb disc/NFS
Driver de dispositiu bloquejat

Identificar:

ps -eLo pid,tid,stat,wchan:20,comm | grep " D "

Fils zombie

Fils que han acabat però no han estat netejats pel procés pare.

Identificar:

ps -eLo pid,tid,stat,comm | grep " Z "

Eines addicionals per administradors

perf - Profiling de rendiment

# Instal·lació
sudo apt-get install linux-tools-generic

# Veure activitat de fils
sudo perf top -p PID

# Registrar activitat
sudo perf record -p PID -g -- sleep 10
sudo perf report

strace - Traçar crides del sistema

# Traçar tots els fils d'un procés
strace -f -p PID

# Només crides específiques
strace -f -e trace=open,read,write -p PID

Resum de comandes essencials

Comanda	Funció
`ps -p PID -T`	Llistar fils d'un procés
`ps -p PID -L -o pid,tid,pcpu,pmem,comm`	Fils amb consum recursos
`top -H -p PID`	Monitoratge en temps real
`htop -p PID` (F5)	Vista d'arbre amb fils
`pstree -p PID -t`	Jerarquia de fils
`ls /proc/PID/task/`	Llistar TIDs directament
`cat /proc/sys/kernel/threads-max`	Límit màxim de fils

Exercicis recomanats

Executa fils01 amb diferents nombres de fils i observa el consum de recursos
Compara el comportament entre la versió C i Python
Crea scripts per automatitzar la monitorització
Experimenta amb top i htop per familiaritzar-te amb les opcions
Investiga processos del sistema que utilitzen molts fils (per exemple, navegadors web)

Consells per administradors

Monitoratge proactiu: Configura alertes per processos amb massa fils
Documentació: Mantén un registre dels valors normals per les aplicacions del teu sistema
Logs: Registra històrics de nombre de fils per detectar tendències
Límits: Coneix i configura els límits del sistema adequadament
Problemes de rendiment: Els fils en estat D persistent poden indicar problemes greus

Aquest document proporciona les eines necessàries per monitorar i gestionar fils en sistemes Linux des de la perspectiva d'un administrador de sistemes.