Ejercicio resuelto: 6 hilos POSIX que se identifican en C

Ejercicio de examen resuelto en C: seis hilos POSIX con identificador propio, pthread_create, pthread_join y una salida determinista, con tests.

Actualizado el 27 de octubre de 2026

Código de Examen C Sistemas operativos Nivel examen Código probado

27 1 6 7 97 871

Hilo 1: n=27 pasos=111
Hilo 2: n=1 pasos=0
Hilo 3: n=6 pasos=8
Hilo 4: n=7 pasos=16
Hilo 5: n=97 pasos=118
Hilo 6: n=871 pasos=178
Maximo: hilo 6 con 178 pasos

Pistas

Solución

#include <pthread.h>
#include <stdio.h>

#define NUM_HILOS 6
#define LIMITE 1000000000LL

typedef struct {
    int id;                 /* identificador logico 1..6 */
    unsigned long long n;   /* dato de entrada */
    int pasos;              /* resultado que escribe el hilo */
} Tarea;

static void *trabajar(void *arg)
{
    Tarea *t = (Tarea *)arg;
    unsigned long long x = t->n;
    int pasos = 0;

    while (x != 1ULL) {
        if (x % 2ULL == 0ULL) {
            x /= 2ULL;
        } else {
            x = 3ULL * x + 1ULL;
        }
        pasos++;
    }
    t->pasos = pasos;   /* solo escribe en su propia estructura */
    return NULL;
}

int main(void)
{
    Tarea tareas[NUM_HILOS];
    pthread_t hilos[NUM_HILOS];

    /* Fase 1: leer y validar toda la entrada antes de crear hilos */
    for (int i = 0; i < NUM_HILOS; i++) {
        long long v;
        if (scanf("%lld", &v) != 1 || v < 1 || v > LIMITE) {
            printf("Entrada incorrecta\n");
            return 0;
        }
        tareas[i].id = i + 1;
        tareas[i].n = (unsigned long long)v;
        tareas[i].pasos = -1;
    }

    /* Fase 2: crear todos los hilos, cada uno con su propia Tarea */
    for (int i = 0; i < NUM_HILOS; i++) {
        int err = pthread_create(&hilos[i], NULL, trabajar, &tareas[i]);
        if (err != 0) {
            fprintf(stderr, "pthread_create fallo (codigo %d)\n", err);
            for (int j = 0; j < i; j++) {
                pthread_join(hilos[j], NULL);
            }
            return 1;
        }
    }

    /* Fase 3: esperar a todos */
    for (int i = 0; i < NUM_HILOS; i++) {
        int err = pthread_join(hilos[i], NULL);
        if (err != 0) {
            fprintf(stderr, "pthread_join fallo (codigo %d)\n", err);
            return 1;
        }
    }

    /* Fase 4: imprimir en orden de identificador */
    int mejor = 0;
    for (int i = 0; i < NUM_HILOS; i++) {
        printf("Hilo %d: n=%llu pasos=%d\n", tareas[i].id, tareas[i].n, tareas[i].pasos);
        if (tareas[i].pasos > tareas[mejor].pasos) {
            mejor = i;
        }
    }
    printf("Maximo: hilo %d con %d pasos\n", tareas[mejor].id, tareas[mejor].pasos);
    return 0;
}

Casos de prueba

Complejidad

Llamemos L(n) al número de pasos de Collatz de n. El trabajo total es la suma de los seis L(n) más un coste constante por crear y esperar seis hilos. No se conoce una cota cerrada para L(n) en general. Para el rango del enunciado (hasta 109) los valores son de unos pocos cientos, así que el tiempo es despreciable frente al coste de crear los hilos.

La memoria es constante: dos vectores de seis elementos (tareas e hilos) más la pila de cada hilo, que reserva el sistema. Como el número de hilos es fijo, el espacio adicional es O(1) respecto a los datos. Con varios núcleos el tiempo real tiende al del hilo más lento. Con uno solo, como en el entorno de corrección, se suman los seis cálculos.

Errores típicos

• Pasar &i (la variable del bucle) como argumento de pthread_create. Cuando el hilo la lee, i puede haber cambiado ya, y dos hilos pueden acabar con el mismo identificador o con uno igual a 6.
• Identificar los hilos con pthread_self() e imprimirlo con %d tras convertirlo a int. pthread_t es un tipo opaco, la conversión no es portable y el valor cambia en cada ejecución, así que la salida nunca coincide con la esperada.
• Usar un contador global que cada hilo incrementa con contador += 1 para numerarse. Es una condición de carrera: el incremento no es atómico y el número que obtiene cada hilo depende del planificador.
• Imprimir desde dentro del hilo sin ningún mecanismo de turno. Las líneas salen en un orden distinto en cada ejecución, aunque en el portátil del alumno «siempre salgan bien».
• Leer tareas[i].pasos sin haber hecho antes pthread_join de ese hilo, o terminar main sin esperar a los hilos. Con return desde main el proceso entero termina y los hilos pendientes mueren.
• Hacer la secuencia de Collatz con int. Con valores de entrada grandes, 3x+1 desborda, se produce comportamiento indefinido y el bucle puede no terminar nunca.

Variantes

Que cada hilo imprima su propia línea, en orden de identificador

Si el profesor exige que sea el hilo quien escriba su línea, hace falta sincronizarlos. Se usa una variable global turno protegida por un pthread_mutex_t y una variable de condición. Cada hilo calcula sin cerrojo, después bloquea el mutex y espera con pthread_cond_wait en un bucle while (turno != t->id). Cuando le toca, imprime, incrementa turno y hace pthread_cond_broadcast para despertar a los demás. Se usa broadcast y no signal porque solo uno de los que esperan es el siguiente. El cálculo sigue siendo concurrente: solo la impresión queda en orden. La salida es la misma que la de la solución principal.

#include <pthread.h>
#include <stdio.h>

#define NUM_HILOS 6
#define LIMITE 1000000000LL

typedef struct {
    int id;
    unsigned long long n;
    int pasos;
} Tarea;

static pthread_mutex_t cerrojo = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cambio = PTHREAD_COND_INITIALIZER;
static int turno = 1;

static void *trabajar(void *arg)
{
    Tarea *t = (Tarea *)arg;
    unsigned long long x = t->n;
    int pasos = 0;

    while (x != 1ULL) {
        x = (x % 2ULL == 0ULL) ? x / 2ULL : 3ULL * x + 1ULL;
        pasos++;
    }
    t->pasos = pasos;

    pthread_mutex_lock(&cerrojo);
    while (turno != t->id) {
        pthread_cond_wait(&cambio, &cerrojo);
    }
    printf("Hilo %d: n=%llu pasos=%d\n", t->id, t->n, t->pasos);
    turno++;
    pthread_cond_broadcast(&cambio);
    pthread_mutex_unlock(&cerrojo);
    return NULL;
}

int main(void)
{
    Tarea tareas[NUM_HILOS];
    pthread_t hilos[NUM_HILOS];

    for (int i = 0; i < NUM_HILOS; i++) {
        long long v;
        if (scanf("%lld", &v) != 1 || v < 1 || v > LIMITE) {
            printf("Entrada incorrecta\n");
            return 0;
        }
        tareas[i].id = i + 1;
        tareas[i].n = (unsigned long long)v;
        tareas[i].pasos = -1;
    }

    int creados = 0;
    for (int i = 0; i < NUM_HILOS; i++) {
        if (pthread_create(&hilos[i], NULL, trabajar, &tareas[i]) != 0) {
            fprintf(stderr, "pthread_create fallo\n");
            break;
        }
        creados++;
    }
    if (creados < NUM_HILOS) {
        /* liberar a los que esperan turno que nunca llegara */
        pthread_mutex_lock(&cerrojo);
        turno = NUM_HILOS + 100;
        pthread_mutex_unlock(&cerrojo);
        for (int i = 0; i < creados; i++) {
            pthread_cancel(hilos[i]);
            pthread_join(hilos[i], NULL);
        }
        return 1;
    }

    for (int i = 0; i < NUM_HILOS; i++) {
        pthread_join(hilos[i], NULL);
    }

    int mejor = 0;
    for (int i = 1; i < NUM_HILOS; i++) {
        if (tareas[i].pasos > tareas[mejor].pasos) {
            mejor = i;
        }
    }
    printf("Maximo: hilo %d con %d pasos\n", tareas[mejor].id, tareas[mejor].pasos);
    return 0;
}

Que cada hilo devuelva el resultado por pthread_join

En lugar de escribir en la estructura, el hilo puede devolver su resultado como valor de retorno. Para evitar conversiones dudosas entre enteros y punteros, lo limpio es reservar un int con malloc dentro del hilo y devolver su dirección. main lo recoge con pthread_join(hilos[i], &ret), lo copia y hace free(ret). Nunca se debe devolver la dirección de una variable local del hilo, porque su pila deja de existir al terminar.

En los temarios

La creación y gestión de hilos forma parte del temario de Sistemas Operativos en varias universidades latinoamericanas. El programa de Sistemas Operativos de la Universidad Tecnológica Nacional (FRBA) incluye la planificación e hilos en procesos, y también la comunicación y sincronización entre procesos. La sumilla de Ingeniería Informática de la Pontificia Universidad Católica del Perú recoge «Procesos e Hilos» y la comunicación entre procesos dentro de Sistemas Operativos.

En Chile, el programa de IIC2333 Sistemas Operativos y Redes de la Pontificia Universidad Católica de Chile trata los procesos, su planificación y la sincronización y comunicación entre ellos. Por su parte, CC3301 de la Universidad de Chile trabaja la programación de sistemas sobre la API de Linux con procesos pesados (fork/exec/pipes), que es el contexto natural donde después aparecen los hilos POSIX.

Artículos relacionados de LaRebelión

Ejercicio resuelto: pila con vector y paréntesis equilibrados en CEjercicio resuelto: flota polimórfica con clonación en C++Ejercicio resuelto: contar inversiones con mergesort en Java

Artículo generado mediante AI.larebelion · Revisado por Kernel