Multi-thread portable

**etranger** · 19/10/2005, 16h56

Bonjour

Je developpe une application GTK portable, mon application est un chiffreur de fichier, elle doit donc effectuer des opperation assez longue, pour cela je shouait utiliser un thread supplementaire et ajouter un progress bar.
Ma question : y aurait il une fonction standard,donc portable pour gerer le mutli-thread ?
Merci d'avance

**Franck.H** · 19/10/2005, 17h10

Bha y'a les fonctions de creation et de gestion des Threads fournit avec la GLib, ca tombe bien tu fait aussi du GTK et les deuxs sont etroitement liés

Et puis ca tombe bien, je cherche moi meme de la doc sur ce sujet car il me faut des Threads d'écoute de messages pour mon client IRC fait aussi en C/GTK donc ca va m'eviter de poster un message identique

**etranger** · 19/10/2005, 17h21

Oui j'avais deja lu ca : http://www.gtk.org/faq/#AEN482
http://developer.gnome.org/doc/API/2.0/gdk/gdk-Threads.html

**Franck.H** · 19/10/2005, 17h21

Heu sinon je viens de voir les Threads POSIX, cela doit etre portable Windows/Unixoïdes ! Voir ici : POSIX Threads Décidement, on trouve de plus en plus de choses sur ce site ... bravo Emmanuel

**Franck.H** · 19/10/2005, 17h58

Envoyé par etranger

Oui j'avais deja lu ca : http://www.gtk.org/faq/#AEN482
http://developer.gnome.org/doc/API/2.0/gdk/gdk-Threads.html

Mais alors c'est quoi le problème ? Je vois pas vraiment ... suffit de lire, des Threads tu en créé autant que tu veut, si c'est un programme GTK faut juste faire en sorte de la debloquer pour qu'il puisse gérer des Threads supplémentaires donc endehors de la boucle principale de GTK, tout est dans les liens que tu m'a donné en fait ! C'est sur que des cours supplémentaires sont les bienvenus aussi

Par contre la question que je me pose, c'est dans mon cas, plusieurs Threads utiliseront la meme fonction qui vérifie en fait l'arrivée de nouveaux messages des serveurs sur lesquels l'utilisateur se connect ... cela ne pas pas de problèmes si plusieurs Threads utilisent la meme fonction ?

Merci pour vos lumières

**etranger** · 19/10/2005, 18h19

Mais alors c'est quoi le problème ?

Il n'y a pas vraiment de probleme, en fait je voulai savoir s'il y avait une solution standard (norm AINSI) donc autre que celle de Glib. apparaiment il n'en a pas.

Cependant encore un peu de doc (ou code) sur l'utilisation des thread de Glib (en Francais sa serait un must) serait la bien venue.

Une aute question : est ce que l'utilisation des pthread (ou un API thread sous Windows) poserait probleme a une application GTK ?

**Franck.H** · 19/10/2005, 18h22

Envoyé par etranger

Une aute question : est ce que l'utilisation des pthread (ou un API thread sous Windows) poserait probleme a une application GTK ?

Pour ce qui est de pthread à priori ca ne pose pas de problème, si tu regarde le 2° code source du 2° lien que tu as donné plus haut, tu peut le voir

**etranger** · 19/10/2005, 18h29

a oui désolé , je m'en était déja rendu compte car j'ai essazer de compiler le code, mais je n'est pas l'entête pthread. en fait je voulai plutop demander si sa posait probléme au cas oû on modifirait làinterface a travers le thread (comme en Delphi avec la VCL).

Je croi donc que je vais opter pour glib. Merci pour vos réponces et bonne chance CSoldier

encor un petit lien : http://perso.univ-lr.fr/abouju/informatique/IUP2/thread/index.html

**Emmanuel Delahaye** · 19/10/2005, 18h46

Envoyé par etranger

je voulai savoir s'il y avait une solution standard (norm ANSI)

Non, mais il y a des solutions portables.

**Franck.H** · 19/10/2005, 21h23

Je me pose une question !

Dans mon cas, plusieurs Threads utiliseront la meme fonction qui vérifie en fait l'arrivée de nouveaux messages des serveurs et channels sur lesquels l'utilisateur est connecté ... cela peut poser des problèmes si plusieurs Threads utilisent la meme fonction ? Comment faire pour bien gérer ce cas là ?

**Emmanuel Delahaye** · 19/10/2005, 22h14

Envoyé par CSoldier

Je me pose une question !

Dans mon cas, plusieurs Threads utiliseront la meme fonction qui vérifie en fait l'arrivée de nouveaux messages des serveurs et channels sur lesquels l'utilisateur est connecté ... cela peut poser des problèmes si plusieurs Threads utilisent la meme fonction ? Comment faire pour bien gérer ce cas là ?

Utiliser la même fonction, c'est pas un problème. La question se pose pour les données. Tant qu'on travaille sur des copies (paramètres formels) ou des données appartenant à chaque thread (via une adresse), tout va bien. Les choses se compliquent si 2 threads lisent ou écrivent le même bloc de données (globales, statiques, ...). A ce moment là, il faut mettre en oeuvre des mécanismes de protection comme expliqué dans mon article.

**Franck.H** · 20/10/2005, 11h02

Ok, bon ca ne devrait pas poser de problème car la fonction ne travaillera qu'avec une copie d'une donnée d'apres le paramètre qui lui est passée, à partir de là une ptite lecture de données, une lecture de reception de message ... si le message est a afficher bah on traite l'affichage vers une zone de texte, si le message est pas exemple un Ping, bah on répond directement par un Pong !! Ce genre de chose, mais ca s'arrete là !

**Franck.H** · 20/10/2005, 16h49

J'ai une derniere petite question !

Quand on créé un Thread, il tourne continuellement jusqu'à la fin de l'application ou bien ... ? Car là mes Thread doivent tourner à interval réguliers style toutes les secondes, quelques chose dans ce genre, mais étant donné qu'il utilisent tous la meme fonction, comment les mettre en pause etc... ?

Hé oui tant que j'y pense, comment detruire un Thread ?

Merci pour ces précisions

PS: C'est ma premiere fois avec les Threads alors bon

**Emmanuel Delahaye** · 20/10/2005, 17h06

Envoyé par CSoldier

J'ai une derniere petite question !

Quand on créé un Thread, il tourne continuellement jusqu'à la fin de l'application ou bien ... ?

Si il n'y a pas de fonction de suspension dans la boucle, oui. Dans un système coopératif (Linux 2.4 ?) ce genre de manip est interdite, car elle prend 100% du CPU. Sinon (Système préemptif comme Windows), elle est peu recommandée, sauf pour la tâche de fond (de priorité la plus basse)

Car là mes Thread doivent tourner à interval réguliers style toutes les secondes, quelques chose dans ce genre, mais étant donné qu'il utilisent tous la meme fonction, comment les mettre en pause etc... ?

Windows : Sleep()
Linux : sleep(), usleep()

attention, ce ne sont pas les mêmes unités...

Hé oui tant que j'y pense, comment detruire un Thread ?

La suppression se fait quand on quitte la tâche (return).

Un flag en mémoire partagée peut suffire à commander la fin de la boucle d'un thread.

Sinon, il existe une fonction d'auto destruction (pthread_exit()) et une fonction de destruction à distance (pthread_kill())

**Franck.H** · 20/10/2005, 17h12

Moi j'ai ca pour la fonction utilisée par les Threads (Threads qui doivent etre permanent tant que la connection vers un serveur ou channel est etablie:

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
void * foncs_messages_monitoring (void *p_data)
{
   int numbytes;
   int current_page;
   char s_buffer[MAX_BUF_SIZE];
   GtkTextBuffer *p_buffer = NULL;
   GtkTextIter i_end;
   gpointer p_st_data;
   gpointer p;
   _tab_srv_s *p_tmp_tab_srv_s = NULL;
   _tab_chan_s *p_tmp_tab_chan_s = NULL;
   _tab_type_e *tab_type_e = NULL;
 
#if defined (WIN32)
   SOCKET tmp_sock;
#endif
 
 
   /* -------------------------------------------
      On recupere le numero de la page courrante
   */
 
   current_page = gtk_notebook_get_current_page (
                     GTK_NOTEBOOK (main_win_s->p_notebook));
 
 
 
 
   /* ---------------------------------------
      Recupere l'element de la liste chainee
   */
 
   if (p_data != NULL)
   {
      p = p_data;
      tab_type_e = (_tab_type_e *)p;
 
 
      /* On recupere la structure des widget */
      p_st_data = g_list_nth_data (p_tab_srv_chan_list, current_page);
 
      switch (*tab_type_e)
      {
         case TAB_TYPE_SERVER:
         {
            p_tmp_tab_srv_s = p_st_data;
            tmp_sock = p_tmp_tab_srv_s->sock;
         }
         break;
 
         case TAB_TYPE_CHANNEL:
         {
            p_tmp_tab_chan_s = p_st_data;
            tmp_sock = p_tmp_tab_chan_s->sock;
         }
         break;
 
         default:
            break;
      }
   }
   else
   {
      return NULL;
   }
 
   if (p_tmp_tab_srv_s == NULL && p_tmp_tab_chan_s == NULL)
   {
      return NULL;
   }
 
 
 
 
   /* -------------------------------------
      Reception et traitement des messages
   */
 
   /* Reception d'un message */
   if ((numbytes = recv (tmp_sock,
                         s_buffer,
                         MAX_BUF_SIZE,
                         0)) < 0)
   {
      return NULL;
   }
 
 
   /* Verification du message. Si c'est un PING, on repond par un PONG.
      Sinon, on affiche le message a l'ecran. */
   s_buffer[numbytes] = '\0';
 
   if (strncmp (s_buffer, "PING", 4) == 0)
   {
      strncpy (s_buffer, "PONG", 4);
 
      /* Envoie de la reponse du PING */
      if ((numbytes = send (tmp_sock,
                            s_buffer,
                            strlen (s_buffer),
                            0)) < 0)
      {
         memset (&s_buffer, 0, sizeof (s_buffer));
         return NULL;
      }
 
      memset (&s_buffer, 0, sizeof (s_buffer));
   }
   else
   {
      /* Recupere le buffer de la zone de texte */
      switch (*tab_type_e)
      {
         case TAB_TYPE_SERVER:
         {
            p_buffer = gtk_text_view_get_buffer (
                           GTK_TEXT_VIEW (p_tmp_tab_srv_s->p_text_view));
         }
         break;
 
         case TAB_TYPE_CHANNEL:
         {
            p_buffer = gtk_text_view_get_buffer (
                           GTK_TEXT_VIEW (p_tmp_tab_chan_s->p_text_view));
         }
         break;
 
         default:
            break;
      }
 
 
      /* Envoie du message */
      gtk_text_buffer_get_end_iter (p_buffer, &i_end);
      gtk_text_buffer_insert (p_buffer, &i_end, s_buffer, -1);
 
      memset (&s_buffer, 0, sizeof (s_buffer));
   }
 
 
 
 
   return NULL;
}

Moi dans ma pensée, c'est que le Thread utilise la fonction, la quitte, puis dès que son delais d'attente (que j'ai pas fait d'ailleur) est passé bah il rentre à nouveau dans la fonction etc... N'est-ce pas de cette façon que cela fonctionne ? Je suis quelque peu perdu dans tout ca

**Médinoc** · 20/10/2005, 20h59

Quand tu crées un thread, il commence à la fonction que tu lui as passée, puis se termine lorsque celle-ci retourne (ou si le thread est détruit par un autre moyen). Une fois terminé, c'est comme si le thread n'existait plus: tout ce qu'on peut faire normalement avec son identifiant, c'est vérifier qu'il est terminé.

Pour que la fonction du thread soit à nouveau exécutée, il faut à nouveau démarrer explicitement un nouveau thread sur cette fonction-là.

Généralement, un thread qui doit durer tout au long du programme boucle sur une fonction d'attente (select(), wait(), mq_recv(), accept(), getchar(), etc.) pendant que les autres threads bouclent eux aussi sur une autre fonction d'attente, comme le terminal, etc.
Ensuite, pour terminer un thread, une variable globale déclarée en volatile peut suffire à terminer la boucle, mais sous unixoïde c'est rare (il faut s'arranger pour que la fonction sur laquelle ils attendent finisse par retourner).

Sous Windows, un programme se termine quand son dernier thread se termine (à une subtilité vicieuse près, le main() doit se terminer par un appel à ExitThread() au lieu de return, sinon c'est tout le processus qui se termine).
Sous Posix, je ne sais pas si c'est le cas ou non.

Question subsidiaire : que se passe-t-il quand un processus multithreadé posix reçoit un signal? quel thread le reçoit? (déjà, est-ce qu'un thread particulier le reçoit, ou bien est-ce simplement le thread qui était en train de s'exécuter à ce moment-là, etc.)

**Franck.H** · 20/10/2005, 21h13

Ok, mais là le problème, c'est que je dois surveiller l'arriver de nouveaux messages des serveurs et channels sur lesquelles l'utilisateur se connect (c'est un client IRC que je suis en train de faire) ! Mais le truc c'est que tous les Threads utiliseront la meme fonction, donc je pense que si un Thread boucle sur une fonction, les threads qui attendent, bah ils entrent jamais non ? Car si un thread sort de la fonction, et qu'il n'existe plus, je ne vois pas l'interet d'en faire ! Donc je cherche des infos, des astuces, etc... en prennant en compte que je suis assez debutant avec les Threads ! En fait, c'est ma premiere fois

En fait, ce que je veut, c'est une fonction qui boucle tout le temps du programme pour vérifier les messages et y repondent dans le cas d'un PING par exemple pour pas que le serveur clos la session et ce genre de chose ! Meme si c'est que 1 Thread qui fait ca pour toutes les connections serveur et channels mais il me faut une fonction de monitoring de ce genre ! Du moins je pense mais c'est ce qui me parait le plus logique en l'occurence !

A savoir aussi que je developpe certes sous Windows mais le programme sera aussi porté sous Linux

Donc si quelqu'un peut me donner des conseils, astuces etc... je suis plus que preneur

Ca fait quand meme 2 jours que je planche que là dessus, donc si je pouvais avoir une reponse censsée et qui m'aide vraiment ce serais super !

Merci d'avance

**Médinoc** · 20/10/2005, 21h50

Mais il n'y a absolument aucun problème pour utiliser la même fonction en même temps dans N threads!
Le problème, c'est pour les données: Il ne faut pas que les threads touchent aux mêmes données, aux mêmes fichiers, aux mêmes variables globales et/ou statiques, et à des fonctions non-thread-safe.

Tu peux très bien avoir N threads qui attendent N ressources différentes ave cla même fonction!

**Franck.H** · 20/10/2005, 21h55

Envoyé par Médinoc

Mais il n'y a absolument aucun problème pour utiliser la même fonction en même temps dans N threads!
Le problème, c'est pour les données: Il ne faut pas que les threads touchent aux mêmes données, aux mêmes fichiers, aux mêmes variables globales et/ou statiques, et à des fonctions non-thread-safe.

Tu peux très bien avoir N threads qui attendent N ressources différentes ave cla même fonction!

Oui mais comment faire !!!!!! C'est ca que je veut savoir, deja vu le manque de doc sur les reseau et autre threads, et quand y'a c'est tres sommaire et non accompagné de ptits exemples etc... !!! Moi je fournit un code mis j'aimerais bien qu'on me dise ce qui va pas, ce que je dois changer, ce que je peut améliorer, etc... sinon j'avancerais jamais !

Car pour moi, si je boucle dans la fonction par exemple avec un truc du style while (1) ..., bah tu crois que les autres threads arrivont a utiliser la fonction ?

Pour ce qui touche aux données, le seul truc c'est que les threads accederont a une liste chainees qui dans chaque element aura une adresse d'une structure allouée dynamiquement, structure dans laquelle se trouve des infos sur le serveur, socket sur lequelle travailler, etc...

A part un ptit affichage dans une zone de texte mais sinon c'est tout, enfin tu peut le voir sur ma fonction au bas de la page 1

Enfin bref, c'est presque un appel au secours que je fait là

**Médinoc** · 20/10/2005, 22h05

Envoyé par CSoldier

Car pour moi, si je boucle dans la fonction par exemple avec un truc du style while (1) ..., bah tu crois que les autres threads arrivont a utiliser la fonction ?

OUI. C'est le principe des threads, ils s'exécutent EN MÊME TEMPS. contrairement à de la programmation événementielle mono-threadée.

Pour ce qui touche aux données, le seul truc c'est que les threads accederont a une liste chainees qui dans chaque element aura une adresse d'une structure allouée dynamiquement, structure dans laquelle se trouve des infos sur le serveur, socket sur lequelle travailler, etc...

1° Ils ont chacun leur propre liste, ou bien est-elle partagée ? (c'est à toi de décider cela selon le fonctionnement de ton programme). S'ils ont chacun la leur, pas de problème.
2° Si elle est partagée, est-ce qu'ils la modifient ? Si ils ne font que la lire, aucun problème. S'ils peuvent la modifier, tu dois utiliser un mutex (EXclusion MUTuelle) pour les empêcher de toucher à la liste en même temps (il ne faut pas qu'un thread la lise pendant qu'un autre la modifie)

Multi-thread portable

Réseau C

Vue hybride

Discussions similaires

Partager

Partager