Arreter l'execution d'une fonction au bout d'un certain temps

Version imprimable

18/05/2007, 13h18
stranger

Arreter l'execution d'une fonction au bout d'un certain temps

Bonjour,
Je programme actuellement une application en c++ et j'ai un petit souci, j'ai des traitement a lancer à la suite et s'ils dépassent un certains temps (5 min en moyenne) je doit les arreter pour que mon programme ne boucle pas à l'infini!
On m'a dit que je peu faire cela en utilisant des threads, mais je suis un petit peu perdu vu que je n'ai presque jammais programmer en multithreading donc j'ai pas trop d'idées concerants ce probleme.
Si quelqu'un peut m'éclairer, un exemple de code ou de librairie à utiliser ...
Merci d'avance
18/05/2007, 14h05
loufoque

Des threads ou des processus oui.
18/05/2007, 14h25
stranger

Citation:

Envoyé par loufoque

Des threads ou des processus oui.

Ok et t'aurais pas un exemple de code ou des liens interessant à me donner?

Bonjour,

Pour le multithreading si tu es sous linux/unix c'est la bibliothèque pthread qu'il faut utiliser (pthread.h, NPTL par défaut et non celle de Xavier Leroy).

le fonctionnement général est celui-ci :

Code:

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
 
#include <pthread.h>
#include <iostream>
// Le nombre de threads de mon processus.
#define NUMTHREADS 2
 
// Déclaration de la fonction qui sera le "main" de mon thread en case 0.
void *theZeroThread(void *parm)
{
   // variable locale au thread, pour avoir une variable globale au thread mais
   // non visible par les autres thread il faut passer par des TLS (dits TSD, voir API pthread).
   unsigned long int* IdThread;
 
   IdThread = (unsigned long int*) parm;
   std::cout << "Bonjour je suis le thread " << *IdThread  << std::endl;
   std::cout << "Mes traitements Zero Thread... Done." << std::endl << std::endl;
   return NULL;
}
 
// Déclaration de la fonction qui sera le "main" de mon thread en case 1.
void *theFirstThread(void *parm)
{
   // variable locale au thread, pour avoir une variable globale au thread mais
   // non visible par les autres thread il faut passer par des TLS (dits TSD, voir API pthread).
   unsigned long int* IdThread;
 
   IdThread = (unsigned long int*) parm;
   std::cout << "Bonjour je suis le thread " << *IdThread  << std::endl;
   std::cout << "Mes traitements First Thread... Done." << std::endl << std::endl;
   return NULL;
}
 
int main()
{
    std::cout << "Naissance du processus" << std::endl;
    // Tableau des identifiants de tous mes threads.
    pthread_t             thread[NUMTHREADS];
 
    std::cout << "Début de vie des threads" << std::endl;
    pthread_create(&thread[0], NULL, theZeroThread, &thread[0]);
    pthread_create(&thread[1], NULL, theFirstThread, &thread[1]);
 
    std::cout << "Attente de la fin de vie des threads" << std::endl;
    pthread_join(thread[0], NULL);
    pthread_join(thread[1], NULL);
 
    std::cout << "Mort du processus" << std::endl;
 
    return 0;
}

Tu as deux threads déclarés avec deux méthodes différentes de traitement.
Note que pthread_join est bloquant.
Le tout est à compiler avec la directive de compil -l pthread -D_REENTRANT.
Tu peux encapsuler ce fonctionnement dans des classes ou bien utiliser des bibliothèques (BOOST ou autre) encapsulant pour toi la gestion des threads.
Note que d'un lancement à l'autre les traces n'apparaissent pas dans le même ordre.

Sinon tu peux faire avec plusieurs processus (le fork unix) mais là je te laisse chercher des exemples de code.

Citation:
Envoyé par Ziploppe
Bonjour,

Pour le multithreading si tu es sous linux/unix c'est la bibliothèque pthread qu'il faut utiliser (pthread.h, NPTL par défaut et non celle de Xavier Leroy).

le fonctionnement général est celui-ci :
Code:

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 #include <pthread.h> #include <iostream> // Le nombre de threads de mon processus. #define NUMTHREADS 2 // Déclaration de la fonction qui sera le "main" de mon thread en case 0. void *theZeroThread(void *parm) { // variable locale au thread, pour avoir une variable globale au thread mais // non visible par les autres thread il faut passer par des TLS (dits TSD, voir API pthread). unsigned long int* IdThread; IdThread = (unsigned long int*) parm; std::cout << "Bonjour je suis le thread " << *IdThread << std::endl; std::cout << "Mes traitements Zero Thread... Done." << std::endl << std::endl; return NULL; } // Déclaration de la fonction qui sera le "main" de mon thread en case 1. void *theFirstThread(void *parm) { // variable locale au thread, pour avoir une variable globale au thread mais // non visible par les autres thread il faut passer par des TLS (dits TSD, voir API pthread). unsigned long int* IdThread; IdThread = (unsigned long int*) parm; std::cout << "Bonjour je suis le thread " << *IdThread << std::endl; std::cout << "Mes traitements First Thread... Done." << std::endl << std::endl; return NULL; } int main() { std::cout << "Naissance du processus" << std::endl; // Tableau des identifiants de tous mes threads. pthread_t thread[NUMTHREADS]; std::cout << "Début de vie des threads" << std::endl; pthread_create(&thread[0], NULL, theZeroThread, &thread[0]); pthread_create(&thread[1], NULL, theFirstThread, &thread[1]); std::cout << "Attente de la fin de vie des threads" << std::endl; pthread_join(thread[0], NULL); pthread_join(thread[1], NULL); std::cout << "Mort du processus" << std::endl; return 0; }
Tu as deux threads déclarés avec deux méthodes différentes de traitement.
Note que pthread_join est bloquant.
Le tout est à compiler avec la directive de compil -l pthread -D_REENTRANT.
Tu peux encapsuler ce fonctionnement dans des classes ou bien utiliser des bibliothèques (BOOST ou autre) encapsulant pour toi la gestion des threads.
Note que d'un lancement à l'autre les traces n'apparaissent pas dans le même ordre.

Sinon tu peux faire avec plusieurs processus (le fork unix) mais là je te laisse chercher des exemples de code.
Merci pour ton coup de main, t'a éclairci mon chemin ;)
Voila j'ai modifier un peu ton exemple et j'ai fai boucler le 1er thread, et j'ai réussi à l'arreter , voici les modifs que j'ai faite :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 void *theZeroThread(void *parm) { while(1){ timer++; if(timer ==1000){ std::cout << " TIMER a depassé 1000 Thread va mourir " << std::endl; pthread_yield(); pthread_exit(NULL); } } // variable locale au thread, pour avoir une variable globale au thread mais // non visible par les autres thread il faut passer par des TLS (dits TSD, voir API pthread). //unsigned long int* IdThread; IdThread1 = (unsigned long int*) parm; std::cout << "Bonjour je suis le thread " << *IdThread1 << std::endl; std::cout << "Mes traitements Zero Thread... Done." << std::endl << std::endl; return NULL; }
j'ai rajouter un compteur timer pour pouvoir tuer le processus et ca marche.
Sinon comme mon code devra étre portable sous Windows aussi, je pense que je v plutot utiliser la bibilio Boost. Comme j'ai compris le principe là, je pense qu'il y aura pas de probleme pour la suite (enfin si j'en ai je vienderai ici ;)
Merci encore et bon week end