pthread mutex lock/unlock dans le while(1)

Je suis en train d'écrire très simple, multi threading programme juste pour obtenir le catch, mais je n'arrive pas à comprendre quel est exactement le problème dans l'un des cas. Donc:

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

char string[100];
pthread_t thr_id_rd;
pthread_t thr_id_wr;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond, cond1;
int read = 0;

void *thread_rd()
{
    pthread_mutex_lock(&lock);
    while (1) {
        pthread_cond_wait(&cond, &lock);
        printf("rd: entered: %s\n", string);
        pthread_cond_signal(&cond1);
    }
    pthread_mutex_unlock(&lock);
}

void *thread_wr()
{
    pthread_mutex_lock(&lock);
    while (1) {
        printf("wr: enter something: ");
        scanf("%s", string);
        pthread_cond_signal(&cond);
        pthread_cond_wait(&cond1, &lock);
    }
    pthread_mutex_unlock(&lock);
}

int main(int argc, char *argv[])
{
    pthread_create(&thr_id_rd, NULL, thread_rd, NULL);
    pthread_create(&thr_id_wr, NULL, thread_wr, NULL);

    pthread_join(thr_id_rd, NULL);
    pthread_join(thr_id_wr, NULL);

    return 0;
}

Ci-dessus semble fonctionner correctement. Mais quand j'ai modifier les deux fils comme ceci:

void *thread_rd()
{
    while (1) {
        pthread_mutex_lock(&lock);
        pthread_cond_wait(&cond, &lock);
        printf("rd: entered: %s\n", string);
        pthread_cond_signal(&cond1);
        pthread_mutex_unlock(&lock);
    }
}

void *thread_wr()
{
    while (1) {
        pthread_mutex_lock(&lock);
        printf("wr: enter something: ");
        scanf("%s", string);
        pthread_cond_signal(&cond);
        pthread_cond_wait(&cond1, &lock);
        pthread_mutex_unlock(&lock);
    }
}

Je reçois un comportement indéfini - parfois, c'est OK, parfois, le programme est bloqué. Selon les pages man pthread_cond_wait doit être appelé avec mutex verrouillé, mais il n'y a aucune restriction pour _cond_signal (Question: Quelle est la meilleure pratique?). J'ai donc décidé de l'appeler avec un mutex verrouillé...

Évidemment, je suis débutant complet s'il vous plaît excuser ma question stupide 🙁
Je serai très reconnaissant si quelqu'un peut il m'expliquer...

En fait, c'était vraiment une question stupide, mais j'ai été frustré que j'ai besoin d'un peu de temps loin d'elle pour voir comment je suis bête (et en fait de lire quelques pages de man...) 😀 Comme je l'ai dit je n'ai absolument aucune expérience avec les threads... 🙁 Donc le mutex peut être tenu par 1 seul thread à la fois, de sorte à pthread_thread_create les deux threads sont en course pour le mutex et qui est de la fermeture de la première ne peut pas être défini. Ma solution est le drapeau supplémentaire pour déterminer quel thread pour verrouiller le mutex en premier. Est-ce correct? Encore une fois je vais vraiment reconnaissant si quelqu'un peut partager certaines "bonnes pratiques"...

OriginalL'auteur Meh | 2012-11-04

  1. 5

    pthread conditionnelle de signaux variables ne sont pas persistantes. Si vous signal quand rien n'est en attente pour le signal, le signal est perdu. Ainsi, vous pouvez voir quelque chose comme ceci:

    WR: Lock
WR: Read input
WR: Signal cond
WR: Wait for cond1 (implicitly unlocks)
RD: Lock
RD: Wait for cond (implicitly unlocks)

    À ce stade, vous avez une impasse - les deux threads sont en attente pour les signaux qui ne viendra jamais.

    Le schéma habituel avec condvars est d'avoir un drapeau (ou d'un autre problème persistant), jumelée avec la variable de condition. Vous pouvez ensuite faire une boucle comme:

    while (!flag) pthread_cond_wait(&cond, &lock);

    De signal, vous définissez le drapeau, puis le signal de la condvar à se réveiller à tout les serveurs.

    Dans votre cas vous pouvez réellement utiliser string que votre drapeau - ont string == NULL être le réveil à condition jumelé avec cond1 et string != NULL jumelé avec cond. Maintenant, si votre lecteur de fil entre le verrou de la fin il va voir que string != NULL et de ne pas attendre sur le condvar.

    OriginalL'auteur bdonlan