Discussion :

[buse974]

Bonjour.

j'ai développer une classe serveur qui exécute un serveur mulitcast ce serveur écoute une adresse multicast (UDP) et un port. jusque la tout va bien.

donc par la suite je veux exécuter mon serveur dans un thread pour que bien sur je puisse continué d'autre traitement.

en dessous un bout de code de mon main pour vous montrer a quoi cela ressemble

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
 
include <iostream>
#include "include/server.h"
 
using namespace std;
 
int main()
{
 
    char ip[]   = "224.000.023.012";
    unsigned char * str = NULL;
 
 
   cout<<"Demarage du serveur"<< endl;
   server server(ip,3721)
   server.initAll();
   server.recv();
 
 
   //ici je voudrais continuer d'autre traitement
 
    return 1;
}

Donc dans mon code la méthode appeler server.recv() est bloquante.
donc j'aimerai que mon objet serveur ce déroule dans un thread different.
j'ai essayer plusieurs chose, avec pthread et ensuite la fonction pthread_create()
mais je n'arrive pas a passé mon objet.

peu etre que tout simplement je mis prend mal, donc pourriez vous me guidé sur la maniéré de procédé proprement ?

et comment puis je passer un objet dans un tread ?

merci.

[Mac LAK]

Usuellement, pour fabriquer une classe threadable, on utilise les points suivants (indépendant de l'API thread utilisée) :

• La classe doit posséder une méthode statique ayant la même signature que la fonction attendue par la création du thread.
  Classiquement, ces fonctions prennent en argument un pointeur void*.
• Ta classe doit implémenter une méthode threadée. La signature est libre, mais la plupart du temps, cette méthode est du genre "void ThreadImplementation()".
  La méthode peut être virtuelle ou pas, aucune importance, cela dépend de ta hiérarchie de classe uniquement.
• Ta classe doit aussi implémenter une méthode non-statique (mais elle peut ne pas être virtuelle) de lancement du thread. Usuellement, c'est une fonction du genre "void Run()".

Maintenant, passons au code. Je vais prendre un exemple pour pthread. La fonction statique est implémentée comme suit :

Code Méthode statique :

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

1
2
3
4
5
void* ThreadedClass::StaticThreadMethod ( void* Parameter ) {
  ThreadedClass* tclass = reinterpret_cast<ThreadedClass*>(Parameter);
  tclass->ThreadImplementation();
  return tclass->ExitStatus();
}

Comme tu vois, elle caste son argument pour accéder à une instance de la classe. Comme c'est une méthode statique, elle n'a pas accès au paramètre tacite this, et sa signature est donc adéquate avec la fonction attendue par la création de thread.
C'est la fonction ThreadImplementation() qui est alors lancée dans un thread, et comme elle est issue tout à fait normalement d'un appel de méthode "banal", elle a donc accès à toute l'instance de la classe tout à fait normalement.

Maintenant, la fonction Run() :

Code Lancement du thread :

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

1
2
3
void ThreadedClass::Run() {
  pthread_create(this->TID,this->TID_attr,ThreadedClass::StaticThreadMethod, this);
]

Comme tu le vois, elle utilise l'instance courante pour stocker les informations du thread (TID et attributs) de façon à pouvoir le contrôler, elle passe le pointeur de méthode statique, et enfin, le this comme argument du thread.

Dans ton cas particulier, tu devras renommer ta méthode recv() en recv_threaded() (ce sera ton ThreadImplementation()), et écrire une nouvelle méthode recv() qui prendra la place du Run(). Tu peux même décliner ce principe pour avoir une classe "tournant" sur PLUSIEURS threads, il faut et il suffit de savoir gérer le cas dans la méthode statique appelée lors de la création réelle du thread... Le plus simple étant peut-être encore d'avoir autant de méthodes statiques que de threads à lancer.


Voilà, j'espère que c'est plus clair pour toi.

[buse974]

ben un grand merci, c'est exactement ce que je cherché c'est une méthode que je trouve élégante, car entre temps j'ai fait un bricolage qui marché mais cela resté du bricolage, donc merci encore pour cette explication, je l'implémente sur le champ.
@+

[Mac LAK]

donc merci encore pour cette explication, je l'implémente sur le champ.

De rien. Il va sans dire qu'il est infiniment plus pratique de te créer une classe de base "ThreadClass", avec les méthodes minimales, et de dériver ensuite directement de cette classe... Suivant tes goûts, tu peux faire une classe normale ou un template.

Tu peux raffiner encore le truc en implémentant une méthode "BeforeRun()" et une méthode "AfterRun()", cela peut te servir pour les initialisations / finalisations et pour implémenter aussi des éléments "constants" dans une hiérarchie de classes. Ces méthodes sont appelées dans le contexte de l'appelant, bien entendu, et non pas dans le thread.