Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
1708 connectés 

 
 


 Mot :   Pseudo :  
 
Bas de page
Auteur Sujet :

Cygwin Posix

n°1299404
sined40
Posté le 20-12-2011 à 20:53:07  profilanswer
 

Bonjour,
 
Je suis actuellement entrain de découvrir POSIX et je me demande comment cygwin gère les threads.
J'ai fait un programme qui permet de créer 3 threads et qui les détachent.
 
Ce que je ne comprends pas c'est que je m'attendais à ce que mes 3threads crées continue à tourner une fois détachée ...
 

Code :
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <pthread.h>
  5. void *PrintServer_01(void)
  6. {
  7. puts(" ..Thread Server_01 is running." );
  8. return NULL;
  9. }
  11. void *PrintClient_01(void)
  12. {
  13. puts(" ..Thread Client_01 is running." );
  14. return NULL;
  15. }
  17. void *PrintClient_02(void)
  18. {
  19. puts(" ..Thread Client_02 is running." );
  20. return NULL;
  21. }
  23. int main()
  24. {
  25.     pthread_t Server_01;
  26.     pthread_t Client_01;
  27.     pthread_t Client_02;
  29. int Ret_Code;
  31.     puts ("--Main Init.--" );
  33. /*---------------------------*/
  34. /* Creation du thread Server */
  35. /*---------------------------*/
  36.     Ret_Code = pthread_create(&Server_01, NULL, (void*)PrintServer_01, NULL);
  38. /* Verif. de la creation */
  39. if (Ret_Code == -1)
  40. {
  41.  printf(" ..Creation of the thread Server_01 fails.\n" );
  42.  return EXIT_FAILURE;
  43. }
  44. else
  45. {
  46.  printf(" ..Creation of the thread Server_01 succeeds.\n" );
  47. }
  49. /*------------------------------*/
  50. /* Creation du thread Client_01 */
  51. /*------------------------------*/
  52.     Ret_Code = pthread_create(&Client_01, NULL, (void*)PrintClient_01, NULL);
  54. /* Verif. de la creation */
  55. if (Ret_Code == -1)
  56. {
  57.  printf(" ..Creation of the thread Client_01 fails.\n" );
  58.  return EXIT_FAILURE;
  59. }
  60. else
  61. {
  62.  printf(" ..Creation of the thread Client_01 succeeds.\n" );
  63. }
  64. /*------------------------------*/
  65. /* Creation du thread Client_02 */
  66. /*------------------------------*/
  67.     Ret_Code = pthread_create(&Client_02, NULL, (void*)PrintClient_02,  NULL);
  69. /* Verif. de la creation */
  70. if (Ret_Code == -1)
  71. {
  72.  printf(" ..Creation of the thread Client_02 fails.\n" );
  73.  return EXIT_FAILURE;
  74. }
  75. else
  76. {
  77.  printf(" ..Creation of the thread Client_02 succeeds.\n" );
  78. }
  80. /* Detachement des threads */
  81. pthread_detach(Server_01);
  82. pthread_detach(Client_01);
  83. pthread_detach(Client_02);
  85. puts ("--Main ends.--" );
  87.     return EXIT_SUCCESS;
  88. }


 
Voila ce que j'obtiens dans ma console cygwin:
$./Main.exe
--Main Init.--
 ..Thread Server_01 is running.
 ..Creation of the thread Server_01 succeeds.
 ..Thread Client_01 is running.
_01 succeeds.
 ..Thread Client_01 is running.
 ..Thread Client_02 is running.
 ..Creation of the thread Client_02 succeeds.
--Main ends.--


Message édité par sined40 le 20-12-2011 à 20:54:01
mood
Publicité
Posté le 20-12-2011 à 20:53:07  profilanswer
 

n°1299454
p-seeker23
Posté le 21-12-2011 à 13:41:38  profilanswer
 

Détacher un thread ne veut pas dire qu'il va s'exécuter indépendamment de son processus ! (il ne peut exister en dehors de son processus).
Cela veut dire que ses ressources (l'espace mémoire qu'il lui a été attribué à sa création - au sein de l'espace adresse de son processus !) peut être réclamer par le système QUAND ce thread aura finit.

 

Sinon, pour que ton expérience réussisse, il y a deux problèmes à résoudre dans ton code :

 

- Tes threads ne font pas beaucoup de travail pour que tu puisse constater qu'ils continuent de s'exécuter !
Rajoute un sleep de quelque secondes par exemple (ou une boucle de sleep/printf), parce que le puts, il va trop vite pour tes yeux !

 

- Quelque soit le mode de lancement des threads, si main() a finit, les threads qu'elle a lancé seront terminés.
Il faut donc bloquer main() tant que ses petits sont toujours entrain de jouer : appeler pthread_exit(NULL) à la fin de main().

 

Tu peux sinon bloquer sur un fiston bien précis en le "rejoignant" avec pthread_join().. (mais dans ce cas, il ne faut pas le détacher ! Un thread détaché n'est pas "joignable" :)).

 

Bienvenu dans le monde merveilleux des Posix Threads !  :D


Message édité par p-seeker23 le 21-12-2011 à 13:42:51
n°1299471
sined40
Posté le 21-12-2011 à 19:49:30  profilanswer
 

Bonjour,
 
Tout d'abord merci pour ta réponse. J'ai suivi tes conseils et effectivement, j'ai bien ce que j'attends.
As-tu de la documentation à me conseiller ?
 
Merci
 

Code :
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <pthread.h>
  4. #include <unistd.h>
  6. #define SLEEP_TIMEOUT 2
  8. void *PrintServer_01(void)
  9. {
  10. int Index = 0;
  12. while(1)
  13. {
  14.  sleep(SLEEP_TIMEOUT);
  15.  printf(" ..Thread Server_01 is running - Nbr: %05d.\n",Index++);
  16. }
  17.  return NULL;
  18. }
  20. void *PrintClient_01(void)
  21. {
  22. int Index = 0;
  24. while(1)
  25. {
  26.  sleep(SLEEP_TIMEOUT);
  27.  printf(" ..Thread Client_01 is running - Nbr: %05d.\n",Index++);
  28. }
  29.  return NULL;
  30. }
  32. void *PrintClient_02(void)
  33. {
  34. int Index = 0;
  36. while(1)
  37. {
  38.  sleep(SLEEP_TIMEOUT);
  39.  printf(" ..Thread Client_02 is running - Nbr: %05d.\n",Index++);
  40. }
  41.  return NULL;
  42. }
  44. int main()
  45. {
  46.     pthread_t Server_01;
  47.     pthread_t Client_01;
  48.     pthread_t Client_02;
  50. int Ret_Code;
  52.     printf("--Main Init.--\n" );
  54. /*---------------------------*/
  55. /* Creation du thread Server */
  56. /*---------------------------*/
  57.     Ret_Code = pthread_create(&Server_01, NULL, (void*)PrintServer_01, NULL);
  59. /* Verif. de la creation */
  60. if (Ret_Code == -1)
  61. {
  62.  printf(" ..Creation of the thread Server_01 fails.\n" );
  63.  return EXIT_FAILURE;
  64. }
  65. else
  66. {
  67.  printf(" ..Creation of the thread Server_01 succeeds.\n" );
  68. }
  70. /*------------------------------*/
  71. /* Creation du thread Client_01 */
  72. /*------------------------------*/
  73.     Ret_Code = pthread_create(&Client_01, NULL, (void*)PrintClient_01, NULL);
  75. /* Verif. de la creation */
  76. if (Ret_Code == -1)
  77. {
  78.  printf(" ..Creation of the thread Client_01 fails.\n" );
  79.  return EXIT_FAILURE;
  80. }
  81. else
  82. {
  83.  printf(" ..Creation of the thread Client_01 succeeds.\n" );
  84. }
  85. /*------------------------------*/
  86. /* Creation du thread Client_02 */
  87. /*------------------------------*/
  88.     Ret_Code = pthread_create(&Client_02, NULL, (void*)PrintClient_02,  NULL);
  90. /* Verif. de la creation */
  91. if (Ret_Code == -1)
  92. {
  93.  printf(" ..Creation of the thread Client_02 fails.\n" );
  94.  return EXIT_FAILURE;
  95. }
  96. else
  97. {
  98.  printf(" ..Creation of the thread Client_02 succeeds.\n" );
  99. }
  101. /* Detachement des threads */
  102. pthread_detach(Server_01);
  103. pthread_detach(Client_01);
  104. pthread_detach(Client_02);
  106. printf("--Main ends.--\n" );
  108. pthread_exit(NULL);
  110.     return EXIT_SUCCESS;
  111. }


Message édité par sined40 le 21-12-2011 à 19:50:15
n°1299721
p-seeker23
Posté le 26-12-2011 à 12:59:19  profilanswer
 

Bien.
Les pthreads sont un sujet hyper classique, il y a l'embarras des choix pour la doc.
Mais comme t'es déjà initié, cette introduction illustrée sera parfaite pour toi.
->si t'es "anglaisglotte", tant mieux, sinon faut pas avoir peur, c'est principalement des mots techniques, très facile à comprendre.
(de toutes façons, les meilleurs docs sont anglais !)
Si qq1 te recommande "Programming with POSIX Threads", c'est qu'il t'aime pas.
 
A vrai-dire, la notion de thread en elle-même n'est pas si difficile à comprendre que ça, et l'introduction de Blaise Barney délivre l'essentiel à savoir. Pour trouver mieux après ça, il ne sert à rien de délaisser Dieu pour ses saints, le plus simple est d'utiliser la spec elle même. Voici un point d'entrée avec pthread_create().
 
Après, le sujet est plus vaste que ça. Le modèle des threads lui-même est discutable. Tous les modèles de programmation à "partage d'état" (shared state), c-a-d qui utilisent en gros un bout de mémoire partagée pour se synchroniser montrent leur limites avec la taille (du projet). Ils ne sont pas "scalable". Tant que le code ne dépasse pas qqes milliers de lignes, c'est plus ou moins gérable, mais au delà, les "live/deadlocks", "race conditions", et autres "starvations" deviennent un vrai casse-tête à tel point qu'il devient impossible de *garantir* que le code est exempt de tels soucis !
(De même pour la gestion de la mémoire tout simplement, il est déraisonnable de confier les new/malloc/free/delete.. aux développeurs quand le code fait 50 milles lignes. Le ramasse-miettes devient une nécessité. Comme pour les deadlock/race conditions et autres, toute une culture s'est développée autour des fuites de mémoires en tous genres, et autres "overrun" et "overflows" qui posent des risques de stabilité et de sécurité).
 
Avec la pression imposée par l'évolution du matériel (processeurs multiples, GPGPU), plusieurs tentatives ont été faite pour apprivoiser la programmation concurrente, et il est clair que ceux qui veulent simplifier la tache aux développeurs ont beaucoup de mal. En même temps, cela a ravivé d'anciennes techniques qui semblent beaucoup plus saines pour gérer des process parallèles. L'idée étant de supprimer la mémoire partagée, et d'utiliser plutôt un système de "messaging". Dans ce modèle, les protagonistes ne font qu'échanger des messages, et chacun vit dans son enclos bien protégé, où son seul contact avec le monde extérieur est sa boîte aux lettres. Tous les problèmes liée à l'état partagé s'évaporent d'un coup, et il devient soudain possible de monter en volume jusqu'à des dizaines de milliers de process parallèles de façon robuste, et sans y perdre son latin ! (Twitter). Il devient même possible de distribuer le traitement sur le réseau facilement, sans problèmes de locks ingérables..
 
Cela est représenté par le modèle d'acteurs, ou on parle des fois de "système d'agents" (chaque process étant un agent indépendant interagissant avec les autres agents).
 
 


Aller à :
Ajouter une réponse
 

Sujets relatifs
[cygwin] Reconnaissance du clavierCygwin/NFS et droits d'accès
export X vers CygwinUSB bootable avec cygwin
Cygwin + OpenSSH, création des users et des groupeslancer cygwin via une tache planifiée windows
Installation de GNOME sur CygwinCompilation kphotoalbum sous cygwin
cygwin c++ compilerVPNC et Cygwin
Plus de sujets relatifs à : Cygwin Posix

Forum MesDiscussions.Net, Version 2010.2
(c) 2000-2011 Doctissimo
Page générée en 0.067 secondes

Copyright © 1997-2022 Hardware.fr SARL (Signaler un contenu illicite / Données personnelles) / Groupe LDLC / Shop HFR