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é