Discussion :

[Gugelhupf]

Bonjour,

En Java ou C#, lorsqu'on lance des threads, le programme principal ( le main() ) ne se termine pas tant que tous les threads (sauf celui du main() ) est toujours en cours d'ex�cution.

Avec un thread en C sous Unix, ce n'est pas le cas ! Il faut forc�ment faire un pthread_join sur le thread... Sauf que la fonction pthread_join est bloquante.

Je souhaiterais donc savoir comment faire pour que le main() ne s'arr�te pas, tant que TOUS les threads lanc�s (que ce soit � partir du main() , ou d'une fonction qui lance un thread � partir d'un autre thread) ne sont pas termin�s.

Cordialement,

[schonai]

Bonjour,
Une solution facile est de mettre tous tes threads dans un tableau.
A la fin de ton programme, il te suffit alors de faire une boucle pour parcourir ce tableau et ex�cuter pthread_join sur chaque thread.

[EDIT]
Je pense avoir mal compris ton probl�me, tu veux pouvoir demander aux threads de s'arr�ter pour que ton programme puisse lui aussi s'arr�ter correctement ?

Si c'est le cas regarde du cot� de la fonction pthread_cancel qui permet de demander un thread de s'arreter. Par contre, si ton thread avait allou� de la m�moire, je ne sais pas comment la lib�rer.
Si ton thread est une boucle "infinie" avec un temps d�ex�cution raisonnable, tu peux utiliser une variable pass�e en argument de ton thread pour lui demander de sortir de cette boucle et se terminer normalement.

[Bktero]

Si tu cr�es n threads, dans le main(), tu peux en effet faire n pthread_join() pour en attendre la fin. Le fait que cette fonction soit bloquante ne pose pas de probl�me � ma connaissance. Au pire, tu tomberas peut-�tre � un moment � tenter de joindre un thread d�j� termin�, ce qui semble se g�rer simplement.

Je pr�sume que ton probl�me r�el est le cas o� de ces threads lancent lui aussi un thread et ne fait pas un pthread_join() ?

[foetus]

Je pr�sume que ton probl�me r�el est le cas o� de ces threads lancent lui aussi un thread et ne fait pas un pthread_join() ?

Oui mais dans ce cas tu peux coder un singleton global qui g�re tous les threads identifi� par un iD: add_thread cancel_thread wait_threads wait_all_threads

Et si tu veux avoir � la fois l'attente bloquante et non bloquante pour la fin des threads, tu peux faire un singleton-Observateur register_end_threads

[Gugelhupf]

Bonsoir,

@schonai

Une solution facile est de mettre tous tes threads dans un tableau.

Oui, mais dans le cas o� j'ex�cute des threads partout dans le programme, je ne peux pas m'amuser � passer un tableau de thread dans les param�tres de toutes mes fonctions.


@schonai

tu veux pouvoir demander aux threads de s'arr�ter pour que ton programme puisse lui aussi s'arr�ter correctement ?

Non surtout pas de cancel ou stop sur les threads. Je souhaiterais que mon main() s'arr�te de lui-m�me, une fois que tous les pthread_create() lanc�s dans le programme soient termin�s (comportement par d�faut en Java ou C#).


@Bktero

Le fait que cette fonction soit bloquante ne pose pas de probl�me � ma connaissance.

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
void affiche_3_fois(int j){
    int k = 0;
    for(; k < 3; k++){
        printf(" %d ", j);
        sleep(1000);
    }
}
 
int main(){
    printf("Début du programme\n");
    int i = 0;
    for(; i < 10; i++){
        // Création d'un nouveau thread dans chaque itération :
        pthread_t t;
        pthread_create(&t, NULL, affiche_3_fois, &i);
    }
 
    printf("\nFin du programme");
    return 0;
}

Je ne peux malheureusement pas tester le code dessus, car je n'ai pas d'environnement UNIX/Linux.
Aussi je ne sais pas quel comportement ce code peut avoir, sachant que pthread_create est asynchrone, et que la variable t et i sont locales � la boucle for.
Si ce code fonctionne (supposition)... le programme est en th�orie cens� afficher 1 nombre par seconde durant 30 secondes... du moins en Java et C# c'est le cas, sans m�me avoir besoin d'utiliser les m�thodes join qui font parti de la classe Thread...
Exemple de s�quence :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
Début du programme
0 0 1 1 0 2 1 2 4 3 4 3 3 
Fin du programme 2 5 4 5 5 6 7 6 6 8 7 9 8 9 8 7 9

Qu'en est-t-il du C ? Est-ce que le programme affiche en partie des nombres et s�interrompt brutalement ? Ou bien le comportement est comme en Java et C# ?


@Bktero

Je pr�sume que ton probl�me r�el est le cas o� de ces threads lancent lui aussi un thread et ne fait pas un pthread_join() ?

Oui il y a de �a. Rien n'emp�che un thread de lancer un autre thread. Donc comment faire en sorte que le main() ne s'interrompt pas tant que tous ces threads sont en cours d'ex�cution ?


Merci pour vos r�ponses.

[Trademark]

Il faut que tu fasses un join � chaque fois que tu lances un thread. Ce que je veux dire c'est que le join ne se fera pas n�cessairement dans le main. De cette mani�re tu n'auras pas de thread orphelin (dont le p�re s'est termin� avant), et du coup, r�cursivement, le main ne s'arr�tera pas avant les autres threads vu que c'est une fonction dans le thread root (principal).

[Bktero]

Tu fais 2 demandes contradictoires dans le m�me message : d'un c�t� que le main() s'arr�te sans que les autres threads s'arr�tent et de l'autre que le main() ne se termine pas tant que les threads ne sont pas termin�s. Si tu veux retrouver un comportement � la Java, tu peux regarder des detachable threads. Regarde cette section d'un cours Developpez : http://gkemayo.developpez.com/tempsr...osix/#LIII-B-3

[gangsoleil]

Je ne peux malheureusement pas tester le code dessus, car je n'ai pas d'environnement UNIX/Linux.

Heureusement, tu peux le tester gratuitement en ligne : https://www.google.fr/#q=compile+C+online

[Gugelhupf]

Bonjour,


Je rectifie juste une erreur grosse comme la lune par rapport � mon message pr�c�dent :

le programme est en th�orie cens� afficher 1 nombre par seconde durant 30 secondes...

=>

le programme est en th�orie cens� afficher plusieurs nombres par seconde durant 3 secondes... avec 30 nombres au total

@Trademark

Il faut que tu fasses un join � chaque fois que tu lances un thread

C'est cens� �tre le comportement par d�faut, mais on peut remplacer le mode JOIN par un autre avec le 2�me param�tre de la fonction pthread_create.


@Trademark

De cette mani�re tu n'auras pas de thread orphelin (dont le p�re s'est termin� avant)

Je pense qu'il y a une confusion avec les processus (les fork). Avec les processus l�gers (les thread), il n'y a pas de thread "parent" ou "enfant". Les threads ne sont pas li�s.



@Bktero

Tu fais 2 demandes contradictoires dans le m�me message : d'un c�t� que le main() s'arr�te sans que les autres threads s'arr�tent et de l'autre que le main() ne se termine pas tant que les threads ne sont pas termin�s.

Je me suis peut-�tre mal exprim� en faisant r�f�rence au main(). Mais ce que je souhaiterais, c'est qu'une fois arriv� � la derni�re accolade du programme (l'accolade de fermeture de la fonction main() ), mon programme ne s'arr�te pas brutalement, et que tous les threads en cours d'ex�cution soient termin�s "normalement" (pas de cancel).

@Bktero

Si tu veux retrouver un comportement � la Java, tu peux regarder des detachable threads.

Je suis all� dans le code source de Java (impl�mentation OpenJDK) pour mieux comprendre le comportement, et en effet on peut y lire :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
// Fichier os/linux/vm/os_linux.cpp
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
 
[...]
 
pthread_t tid;
int ret = pthread_create(&tid, &attr, (void* (*)(void*)) java_start, thread);

@gangsoleil
Je le savais d�j�, mais en ayant utilis� ideone, il me semble qu'on n'a pas le droit d'utiliser les fonctions syst�mes.


Je vous remercie pour vos r�ponses. Je pense maintenant avoir une meilleure id�e des threads en C avec Posix. N'h�sitez pas � faire part de vos remarques, je mettrais le sujet en r�solu d'ici la fin de la semaine.


Cordialement,

[Bktero]

Je suis all� dans le code source de Java (impl�mentation OpenJDK) pour mieux comprendre le comportement, et en effet on peut y lire

C'est bourrin mais c'est une bonne id�e !

J'ai eu le nez creux sur ce coup l�

[M�dinoc]

Je me suis peut-�tre mal exprim� en faisant r�f�rence au main(). Mais ce que je souhaiterais, c'est qu'une fois arriv� � la derni�re accolade du programme (l'accolade de fermeture de la fonction main() ), mon programme ne s'arr�te pas brutalement, et que tous les threads en cours d'ex�cution soient termin�s "normalement" (pas de cancel).

Dans ce cas, il me semble qu'� moins d'�tre sous Windows, le seul moyen est de mettre une boucle de pthread_join() juste avant cette derni�re accolade: pthread n'a pas, � ma connaissance, de notion de "laisser le premier thread se terminer sans tuer tous les autres".

Et m�me sous Windows, ce n'est pas recommand� parce que trop de fonctions cr�ent des threads d'arri�re-plan que l'utilisateur ne contr�le pas (.Net r�sout le probl�me en ayant deux sortes de threads).

[Gugelhupf]

Bonsoir,

@M�dinoc

Dans ce cas, il me semble qu'� moins d'�tre sous Windows, le seul moyen est de mettre une boucle de pthread_join() juste avant cette derni�re accolade: pthread n'a pas, � ma connaissance, de notion de "laisser le premier thread se terminer sans tuer tous les autres".

D'accord, mais si j'ai des threads qui lancent d'autres threads dans une boucle ? Comment mettre un pthread_join() � la fin du main sachant qu'on n'a pas la m�me port�e ?
"laisser le premier thread se terminer sans tuer tous les autres" -> Le "premier thread" ?... je suis perdu, vous faite bien r�f�rence au main() ?

Et m�me sous Windows, ce n'est pas recommand� parce que trop de fonctions cr�ent des threads d'arri�re-plan que l'utilisateur ne contr�le pas (.Net r�sout le probl�me en ayant deux sortes de threads).

Vous faite peut-�tre r�f�rence aux Processus et Thread de Windows (cf: documentation)... mais je ne vois pas le rapport avec le sujet. M�me si les detached thread sont d�conseill�es, les langages de haut niveau semblent ne pas s'abstenir pour les utiliser.
Aussi je ne vois pas en quoi .NET r�sout le probl�me, .NET n'est pas magique (tout comme Java), pour Windows derri�re il y a la lib C pour les threads Win32. La seule diff�rence que j'ai constat� par rapport � Linux est que la fonction fork() n'existe pas sous Windows.



En ce moment j'ai acc�s � un poste sous Linux, et voici mes tests (j'aurais deux nouvelles questions, A et B) :

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#include <stdlib.h>
#include <stdio.h>
#include <pthread.h>
 
 
void* affiche1(){
    int i;
    for(i = 0; i < 3; i++){
        printf("%d", i);
        sleep(1); // Attente de 1 seconde
    }
}
 
void* affiche2(){
    int i;
    for(i = 3; i < 6; i++){
        printf("%d", i);
        sleep(1); // Attente de 1 seconde
    }
}
 
int main(int argc, char *argv[]){
 
    // Mode JOIN
    pthread_t thread1;
    pthread_create(&thread1, NULL, affiche1, NULL);
    pthread_join(thread1, NULL);
    printf("Hello");
    /* Analyse :
        - Sans la fonction join, le programme s'arrête immédiatement, sans rien afficher.
        - Avec la fonction join, le programme attend trois secondes, affiche "012Hello3" d'un seul coup, et s'arrête.
 
        Question A : Pourquoi l'affichage n'est pas en temps réel (seconde par seconde) ? Pourquoi 012Hello s'affiche d'un seul coup ?
        PS : le "3" représente le chiffre affiché par la fonction affiche2(), et non pas affiche1() !
    */
 
 
    // Mode DETACHED
    pthread_t thread2;
    pthread_attr_t detachedAttr;
    pthread_attr_init(&detachedAttr);
    pthread_attr_setdetachstate(&detachedAttr, PTHREAD_CREATE_DETACHED);
    pthread_create(&thread2, &detachedAttr, affiche2, NULL);
    // Pas de join possible sur un thread en mode detached
    /* Analyse :
        - Malgré le mode PTHREAD_CREATE_DETACHED, le programme se termine avant la fin de thread2.
        
        Question B : Qu'est-ce qui m'assure que mon thread2 va jusqu'au bout de sa tâche en arrière plan (traiter le "4" et "5" après le "3"), après la fin du main ?
    */
 
    return 0; // On quitte la console  
}

Les questions A et B sont dans les commentaires du code.


Cordialement,

[Bktero]

Pourquoi 012Hello s'affiche d'un seul coup ?

Parce la sortie standard est bufferis�e. Tu printes sans retour � la ligne donc il n'y a pas de flux. Rajoute un flush ou un \n � la fin de ton printf().

J'essayerai de penser � tester �a demain sous Linux.

[Bktero]

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
32
33
34
35
36
37
38
39
40
41
42
43
#include <pthread.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
 
 
void* affiche1(){
    int i;
    for(i = 0; i < 3; i++){
        printf("%d\n", i);
        sleep(1); // Attente de 1 seconde
    }
}
 
void* affiche2(){
    int i;
    for(i = 3; i < 6; i++){
        printf("%d\n", i);
        sleep(1); // Attente de 1 seconde
    }
}
 
int main(int argc, char *argv[]){
 
    // Mode JOIN
    pthread_t thread1;
    pthread_create(&thread1, NULL, affiche1, NULL);
    pthread_join(thread1, NULL);
    printf("Thread has been joined\n");
 
 
    // Mode DETACHED
    pthread_t thread2;
    pthread_attr_t detachedAttr;
    pthread_attr_init(&detachedAttr);
    pthread_attr_setdetachstate(&detachedAttr, PTHREAD_CREATE_DETACHED);
    pthread_create(&thread2, &detachedAttr, affiche2, NULL);
    printf("Thread will not be joined, exiting main()\n");
 
    pthread_detach(pthread_self());
    pthread_exit(NULL);
    //return 0; // On quitte la console  
}

$:~/Documents$ c99 test_thread.c -lpthread && ./a.out 
0
1
2
Thread has been joined
Thread will not be joined, exiting main()
3
4
5
$:~/Documents$ echo $?
0

Voir : http://www.domaigne.com/blog/computing/the-main-thread/
Je ne suis pas s�r que le pthread_exit() soit totalement utile, � voir. Aucun de mes threads n'appellent exit() non plus. Mais �a fait le taf.

[M�dinoc]

Voir : http://www.domaigne.com/blog/computing/the-main-thread/

Merci beaucoup pour ce lien.

Donc, c'est semblable � Windows pour ce qui est du premier thread.

Vous faite peut-�tre r�f�rence aux Processus et Thread de Windows (cf: documentation)... mais je ne vois pas le rapport avec le sujet. M�me si les detached thread sont d�conseill�es, les langages de haut niveau semblent ne pas s'abstenir pour les utiliser.
Aussi je ne vois pas en quoi .NET r�sout le probl�me, .NET n'est pas magique (tout comme Java), pour Windows derri�re il y a la lib C pour les threads Win32.

Je ne fais pas r�f�rence aux detached thread, mais au fait que si tu utilises certaines fonctions comme celles li�es au thread pool (QueueUserWorkItem() etc.) ou certaines li�es � COM, la biblioth�que correspondante va cr�er des threads qui ne se terminent jamais: Ils bloquent ind�finiment sur une fonction d'attente, et il n'y a pas de fonction TellAllWindowsThreadsToStopWaitingAndExitCleanly().
R�sultat, avec �a la m�thode "pthread_exit() dans main, puis laisser tous mes threads se terminer proprement, le processus finira de lui-m�me" ne marche pas, et il faut forc�ment qu'au moins un de tes threads appelle exit().

Le framework .Net r�sout (ou contourne) le probl�me en marquant tous ces threads-l� comme threads "faibles", et en surveillant (et comptant) les threads manag�s qui se terminent: Quand le dernier thread "fort" d'un processus se termine, le framework appelle ExitProcess(), tuant tous les threads "faibles" encore l�.

[Gugelhupf]

Bonsoir,

Je pense que je fais une erreur en essayant de comparer les threads Posix en C et C++11, et les threads propos�es par des langages tels que Java et C#, car ces derniers ne sont pas ex�cut�s de la m�me mani�re.

N�anmoins, j'aurais vraiment une derni�re questions avant de fermer ce sujet :
Malgr� avoir lu la documentation, je ne comprends pas du tout � quoi servent (avec l'utilit� et les limites au niveau de la port�e), et quand il faut utiliser les 2 instructions suivantes :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

pthread_detach(pthread_self());

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

pthread_exit(NULL);

Cordialement,

[M�dinoc]

Je pense que c'est pour �viter des fuites de m�moire.

L'API de pthread doit permettre � une biblioth�que d'allouer dynamiquement une structure de donn�es associ�e au thread. Cette structure de donn�e est lib�r�e par pthread_join() si un thread n'est pas d�tach�, ou d�s la fin du thread si celui-ci l'est.

Donc, si on ne fait jamais de pthread_join() sur un thread non-d�tach�, la m�moire allou�e est leak�e.

J'ai du mal � comprendre pour pthread_exit() par contre, sauf dans le main() pour �viter le exit() automatique. Je ne pense pas que ce soit une question de lib�ration de m�moire, vu qu'un thread peut faire �a quand la start_routine pass�e � pthread_create() retourne.

Editl:

The process exits with an exit status of 0 after the last thread has been terminated. The behaviour is as if the implementation called exit() with a zero argument at thread termination time.

�a par contre, c'est diff�rent de ce que fait l'API Windows, qui termine avec le code de sortie du dernier thread.

[Gugelhupf]

Alors je viens de faire des tests, et je comprends � quoi sert le pthread_exit, c'est tout b�te : Cela sert � quitter la fonction courante en retourner une valeur (de n'importe quel type). Dans notre cas il est int�ressant de placer pthread_exit dans une fonction ex�cut�e par un pthread_create ( ex: 'affiche' ).
C'est un peu comme la valeur de retour d'un "future".

pthread_detach sert � faire passer un thread du mode JOIN au mode DETACHED.
pthread_self sert � retourner l'id du thread courant.
Donc dans l'exemple pthread_detach(pthread_self()) sert, je crois, � rendre le thread principal (main) en mode DETACHED.

Maintenant je ne suis toujours pas sorti de l'auberge, car je ne vois toujours pas comment je pourrais terminer proprement tous mes threads (dont ceux qui sont ex�cut�s par d'autres threads), sans que le main() se termine.
Le but �tant d'avoir un comportement similaire aux threads en Java & C#.

PS: Si une personne qui a de l'exp�rience � ce sujet (les threads en C & Java | C#), n'h�sitez pas � r�pondre � ce sujet et m'envoyer un mp pour me notifier. Je fermerai ce sujet d'ici la fin de la semaine.


Cordialement,

[Trademark]

Je ne pense pas qu'il y ait 36 solutions. Soit tu encapsules la cr�ation de thread qui en plus de cr�er le thread, le stocke dans un environnement (que tu passes � chaque fonction, ce qui peut �tre lourd si tu n'as pas de notion d'environnement ; en plus il faut prot�ger la structure pour les acc�s concurrents). Soit tu pars du principe que chaque thread termine ses propres fils (conceptuellement � on s'en fiche que techniquement il n'y a pas de relation parent-enfant) et du coup par induction, tu n'auras qu'� faire un join sur les threads que tu auras lanc� dans le main (qui eux-m�mes ne se termineront pas avant d'avoir attendu leurs propres "fils").

[Bktero]

Donc dans l'exemple pthread_detach(pthread_self()) sert, je crois, � rendre le thread principal (main) en mode DETACHED.

Oui.


A quoi sert pthread_exit() ?
C'est clairement indiqu� dans la documentation :
http://linux.die.net/man/3/pthread_join

pthread_join() copies the exit status of the target thread (i.e., the value that the target thread supplied to pthread_exit(3))

On peut aussi lire :

Performing a return from the start function of any thread other than the main thread results in an implicit call to pthread_exit(), using the function's return value as the thread's exit status.

Dans une autre documentation, il y a aussi cette phrase int�ressante:
http://linux.die.net/man/3/pthread_exit

To allow other threads to continue execution, the main thread should terminate by calling pthread_exit() rather than exit(3).

Maintenant je ne suis toujours pas sorti de l'auberge, car je ne vois toujours pas comment je pourrais terminer proprement tous mes threads (dont ceux qui sont ex�cut�s par d'autres threads), sans que le main() se termine.
Le but �tant d'avoir un comportement similaire aux threads en Java & C#.

L� o� tu fais fausse route, c'est sur le comportement de Java et la mani�re que tu as de comparer ce fonctionnement aux threads Posix. En Java, le main() s'arr�te si tu ne fais pas un join() des threads lanc�s et il n'y a pas (en tout cas, je ne vois rien de ce genre dans la doc : http://docs.oracle.com/javase/7/docs...ng/Thread.html), de threads d�tachables. La JVM elle ne s'arr�te pas. Ce n'est pas du tout pareil de vouloir en C que le main() ne s'arr�te pas. Je rejoins l'avis de Trademark sur ce point : il faudrait que tu fasses ta propre API de threads, qui utiliserait un compteur pour savoir combien de threads sont encore vivants. Le main() lancerait finalement un premier thread, qui lancerait d'autres, qui se terminerait, mais main() continuera d'attendre les autres threads. De ce que j'ai pu lire pour �crire mon pr�c�dent message, je ne vois pas d'autres solutions. Qu'as-tu � ce sujet dans le source d'OpenJDK ?

PS: Si une personne qui a de l'exp�rience � ce sujet (les threads en C & Java | C#), n'h�sitez pas � r�pondre � ce sujet et m'envoyer un mp pour me notifier. Je fermerai ce sujet d'ici la fin de la semaine.

Tu peux demander � t'abonner au sujet et tu pourras ainsi recevoir un mail en cas de r�ponse.