QUELQUES EXEMPLES D'UTILIISATION DES THREADS

Structure.h
#ifndef StructuredH
#define StructureH
#include <winsock2.h>
#include <ws2tcpip.h>
#include <windows.h>
#pragma comment(lib,"ws2_32.lib")

/*
    la classe MyThread encapsule un thread et nous permet de l'utilisé le
    plus simplement du monde.cette classe peut etre la classe de base à toute
    autre objet thread et facilitera l'accés aux focntions et aux données membre
    ,il suffira juste de surcharger la methode Run;

*/
class MyThread
{
private :
        HANDLE  ThreadHandle;
        DWORD   ThreadID;

        bool    Suspendu;

public :
  
             bool    IsRunning;
                     MyThread(bool);
                    ~MyThread();
  virtual    void    Run (void);
             void    Demarrer(void);
             void    Reprendre(void);
             void    Suspendre(void);
             void    Terminer(void);
             void    SetPriority(int);
             HANDLE  GetHandle(void);
             DWORD   GetThreadID(void);


} ;

#endif


Structure.cpp
#include "Structure.h"

/*
   la fonction ThreadProc est la fonction exécution par tout thread héritant de MyThread.
   il peut ya avoir autant de thread que peut supporter le système.

*/
DWORD WINAPI ThreadProc(LPVOID lparam)
{
  MyThread*gthread=(MyThread*)lparam;//cast pour recuperer l'objet
  gthread->Run();/*execution de la methode Run de notre objet mythread ,
                  c'est pour cela qu'il faut écrire le code à éxecuter dans la fonction Run
                  */
 return 0;
}

MyThread::MyThread( bool EnSuspens)
{
    ThreadHandle=NULL;
    ThreadID=0;
    IsRunning=false;
    Suspendu=false;
    if(!EnSuspens) //creation du thread et lancement direct
     { ThreadHandle=CreateThread(NULL,
                                 NULL,
                                 ThreadProc,//fonction que devra executer le thread
                                 (void*)this,//paramètre que l'on passe au thread, ici c'est l'adresse mémoire de MyThread
                                 0,        //mode de creation du thread, ici 0 equivaut à une execution immédiat
                                 &ThreadID);//l'identifiant du thread crée
      Suspendu=false;
     }
    else
    {ThreadHandle=CreateThread(NULL,NULL  //creation du thread en mode suspendu
                      ,ThreadProc,(void*)this,CREATE_SUSPENDED,&ThreadID);
      Suspendu=true;
     }
  if(ThreadHandle!=NULL)
     IsRunning=true;

}


void MyThread::Terminer(void)
{
  TerminateThread( ThreadHandle,0);/*methode pour terminer brutalement le thread ,
                                     qu'il est terminé sont exécution ou non.
                                     ya d'autre méthodes plus soft pour arreter un thread
                                     notamment un fonction de test dans la boucle Run de l'objet héritant de MyThread,
                                     déterminant si on doit sortir du Run ou pas.
                                     */

  IsRunning=false;
}
/*
  Une fois qu'on possède un Handle et un identifiant valide pour les threads
  on peut exécuter les API pour modifié notre thread
  tel que les méthodes qui suivent.

*/

void MyThread::Demarrer(void)
{
  if((!IsRunning)||(!Suspendu))
  return ;
  ResumeThread(ThreadHandle);
  Suspendu=false;
}


void MyThread::Reprendre(void)
{
  Demarrer();
}

void MyThread::Suspendre(void)
{
   if((!IsRunning)||(Suspendu))
  return ;
 SuspendThread(ThreadHandle);
 Suspendu=true;
}

void MyThread::Run(void)
{

}

void MyThread::SetPriority(int priority)
{
   if(ThreadHandle!=NULL)
     SetThreadPriority(ThreadHandle,priority);

}

HANDLE MyThread::GetHandle(void)
{
  return ThreadHandle;
}

DWORD MyThread::GetThreadID(void)
{
 return ThreadID;
}

MyThread::~MyThread()
{
 if(IsRunning)
 Terminer();
  if(ThreadHandle!=NULL)
  CloseHandle(ThreadHandle);
  ThreadHandle=NULL;
}