Discussion :

[Syarko]

Bonjour,

Je rencontre un petit problème dans un projet pour mon école que j'arrive malheureusement pas à résoudre.
J'ai créé et exécute plusieurs threads dans mon main(). J'aimerais attendre la fin de leur exécution avant de pouvoir continuer. Bien entendu, je dois utiliser des moniteurs pour attendre l’exécution des threads (l'utilisation de pthread_join() serait trop facile ).
J'avais plus ou moins une idée en tête : à la fin de chaque thread, je fais un pthread_cond_signal() à la fin de chaque thread. Et dans une boucle dans mon main, pour chaque thread créé, je fais un pthread_cond_wait().
Cependant, cela ne marche pas. Je pense que cela est du à ce que parfois, un thread execute pthread_cond_signal() avant que le main execute pthread_cond_wait().
Mais je vois absolument pas comment régler ce problème

Si quelqu'un pourrait m'aider à trouver une solution

Merci.

[nnovic]

Hello,

Tu pourrais essayer d'utiliser un semaphore plutôt qu'une cond var.

[Matt_Houston]

Ne pas utiliser pthread_join, mouais.. je vois pas trop bien le but de l'exercice mais soit. Il y a plusieurs manières de faire, sans plus d'informations j'opterais sans doute pour pthread_barrier_wait.

[Syarko]

Moi non plus je n'en vois pas l'intérêt, mais disons que je n'ai pas trop le choix

Et je suis obligé d'utiliser des moniteurs, donc je ne pense pas que je puisse utiliser pthread_barrier

[dalfab]

Il n'y a aucun problème à appeler pthread_cond_signal() avant pthread_cond_wait().
Il faut par contre que pthread_cond_init() ait été appelée avant les deux et que pthread_cond_wait() utilise un mutex disponible.
Peux-tu fournir un exemple avec ton code?

[Syarko]

Voila comment j'ai essayé :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
void * monThread(void * arg){
 
    ... CODE DU THREAD ...
 
    pthread_mutex_lock(&verrousParametre);
    pthread_cond_signal(conditionParametre);
    pthread_mutex_unlock(&verrousParametre);
}
 
int main(){
 
   ...
 
    pthread_mutex_t verrous[4];
    pthread_cond_t conditions[4];
 
    for(int i = 0 ; i < 4; ++i){
        pthread_mutex_init(&verrous[i], NULL);
        pthread_cond_init(&conditions[i], NULL);
    }
 
    //Création de 4 threads avec pthread_create(), avec en paramètre un pthread_cond_t propre
 
    for(int i = 0; i < 4; ++i) {
        pthread_mutex_lock(&verrous[i]);
        pthread_cond_wait(&conditions[i]);
        pthread_cond_unlock(&verrous[i]);
    }
 
}

Voilà en en gros mon code. Je pense que c'est au niveau des utilisations de mutex_lock() / mutex_unlock() que j'ai faux. Mais à vrai dire, même en cherchant sur internet, j'ai pas trop compris leur utilité

[dalfab]

Mea culpa, il faut en effet que qu'il y ait un thread en attente au moment du signal, sinon il est perdu.
C'est pourquoi on utilise un booléen ou un indicateur dans la variable à transmettre.

Tu peux aussi utiliser un unique mutex pour les 4 cond_var

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
    pthread_mutex_lock( &uniqueVerrou );
    for ( int i = 0 ; i < 4 ; ++i ) {
       while ( variable[i] == 0 )  // si pas déjà là, attendre et revérifier (un if suffit dans ton cas, mais while est préférable)
           pthread_cond_wait( &conditions[i] , &uniqueVerrou );
        // ... lecture des données transmises .... (protégée par le verrou)
    }
    pthread_mutex_unlock( &uniqueVerrou );

Et pour le signal, le verrou permet de protéger le remplissage de la donnée signalée.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
void * monThread(void * arg){
 
    ... CODE DU THREAD ...
 
    pthread_mutex_lock( verrousParametre );
        *pvariableParametre = 1; // + éventuellement écriture d'autres données protégées
        pthread_cond_signal( conditionParametre );
    pthread_mutex_unlock( verrousParametre );
}

Et les variables doivent être déclarées par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

    volatile int variable[4] = {0,0,0,0};

[Syarko]

Merci. Je vais essayer ca. Donc il faut en tout 2 verrous : 1 pour le main (ici verrouUnique) et 1 passé en paramètre de chaque thread filles ?

[dalfab]

Merci. Je vais essayer ca. Donc il faut en tout 5 verrous : 1 pour le main (ici verrouUnique) et 1 pour chaque thread filles ?

Non au contraire, il faut 4 verrous ou bien un seul verrou. Surtout pas des verrous différents entre le main et les threads.

[Syarko]

Ah ! Mais dans le cadre où il y a un seul verrou, à quoi il sert ? Car je vois pas trop enfaite
Car si le main lock() le verrou avant un thread fille, le programme restera bloqué, non ?

[dalfab]

Ah ! Mais dans le cadre où il y a un seul verrou, à quoi il sert ? Car je vois pas trop enfaite
Car si le main lock() le verrou avant un thread fille, le programme restera bloqué, non ?

Tu as raison, mais en réalité pendant le pthread_cond_wait() le verrou est relâché (c'est pour ça qu'on lui passe le verrou en paramètre) et donc chacun ne bloque le verrou qu'au cours instant où il va émettre ou recevoir.

Le verrou est indispensable à la protection de l'écriture ou la lecture de la donnée (ici c'est un simple entier donc difficile à commenter car pour transmettre des entiers entre threads il suffit d'utiliser les opérations atomiques.)

[Syarko]

Même si je suis obligé d'utiliser des moniteurs dans le cadre de mon projet, on aurait très bien pu s'en passer ici, nn ? La variable que l'on passe à 1 dans les thread, et où dans le main on test sa valeur dans une boucle while(), elle suffit à elle même pour attendre tous les processus, non ?

Sinon, merci beaucoup pour votre aide

[Matt_Houston]

Non, c'est le but de l'exercice : la variable est une ressource partagée, son accès (en lecture ou en écriture) nécessite donc l'usage d'une primitive d'exclusion mutuelle. Sans cette précaution, le thread qui écrit dans la variable pourrait être préempté alors que l'opération est en cours (rien ne garantit que l'écriture d'un int soit atomique).