es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Ejecución de múltiples hilos con programación round-robin

06 Aug, 2023 Programación

Soy bastante nuevo en la programación de multiprocesamiento. Quiero escribir un código con 3 hilos diferentes, cada uno de los cuales imprime algunos caracteres diferentes. La ejecución de los hilos debería basarse en un algoritmo de round-robin. Supongamos que tenemos los hilos t1, t2 y t3, su secuencia de ejecución debería ser t1, t2, t3, t1, t2, t3, …

Escribo el siguiente código para este propósito:

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

void* a(void* ptr) {
    for (int i=0; i<10; i++){
        printf("1");
        printf("2");
        printf("3");
        printf("4");
    }
    return NULL;
}

void* b(void* ptr) {
    for (int i=0; i<10; i++){
        printf("a");
        printf("b");
        printf("c");
        printf("d");
    }
    return NULL;
}

void* c(void* ptr) {
    for (int i=0; i<10; i++){
        printf("5");
        printf("6");
        printf("7");
        printf("8");
    }
    return NULL;
}

int main() {
    pthread_attr_t attr1, attr2, attr3;

    pthread_attr_init(&attr1);
    pthread_attr_init(&attr2);
    pthread_attr_init(&attr3);

    pthread_t t1, t2, t3;

    pthread_attr_setschedpolicy(&attr1, SCHED_RR);
    pthread_create(&t1, &attr1, a, NULL);

    pthread_attr_setschedpolicy(&attr2, SCHED_RR);
    pthread_create(&t2, &attr2, b, NULL);

    pthread_attr_setschedpolicy(&attr3, SCHED_RR);
    pthread_create(&t3, &attr3, c, NULL);

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);

    pthread_exit(0);
    return 0;
}

Y la salida es:

Primero que nada: la salida no es reproducible, cada vez que ejecuto el archivo binario obtengo una salida diferente.

12341234123412341234156785678567856785678567856785678567856782341234123412341234abcdabcdabcdabcdabcdabcdabcdabcdabcdabcd.

Mi salida deseada es algo como esto:

123abc567...

¿Alguien sabe cuál es el problema con mi código?

Gracias</sched.h></pthread.h></stdlib.h></stdio.h>

Tags:  , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    El problema con tu código es que no estás implementando correctamente el algoritmo de round-robin. En tu implementación, cada hilo se ejecuta por completo antes de que comience el siguiente hilo. Para implementar la planificación de round-robin, necesitas utilizar algún tipo de método de sincronización para cambiar entre hilos después de cierto tiempo. Una forma de hacer esto es utilizando una variable compartida y un mutex. Aquí tienes un ejemplo de implementación utilizando este método:

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

#define NUM_THREADS 3
#define NUM_ITERATIONS 10

pthread_t threads[NUM_THREADS];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int current_thread = 0;

void* print_chars(void* arg) {
    const char* chars = (const char*) arg;
    for (int i = 0; i < NUM_ITERATIONS; i++) {
        pthread_mutex_lock(&mutex);
        if (i % NUM_THREADS == current_thread) {
            for (int j = 0; j < strlen(chars); j++) {
                putchar(chars[j]);
            }
            current_thread = (current_thread + 1) % NUM_THREADS;
        }
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

int main() {
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setschedpolicy(&attr, SCHED_RR);

    const char* thread_chars[NUM_THREADS] = {"1234", "abcd", "5678"};
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_create(&threads[i], &attr, print_chars, thread_chars[i]);
    }

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

    pthread_exit(NULL);
}

    En esta implementación, cada hilo imprime sus caracteres solo cuando es el hilo actual según la variable compartida current_thread, la cual está protegida por un mutex. El valor de current_thread se incrementa de manera circular después de que cada hilo haya impreso sus caracteres. Esto asegura que cada hilo se programe para ejecutarse durante un tiempo aproximadamente igual, de manera circular. La salida debería ser algo así:

    1a5
2b6
3c7
4d8
1a5
2b6
3c7
4d8
1a5
2b6
3c7
4d8
...

    Espero que esto te ayude a entender cómo implementar la planificación de round-robin en tus programas multinúcleo.</sched.h></pthread.h></stdlib.h></stdio.h>

Comments are closed.