Discussion :

[sone47]

Bonsoir,

J’implémente sur Boost::thread une classe mère de façon a gérer facilement mes threads sous formes d'objets.
Chaque objet voulant être threadé hérite de cette classe et redéfinie une méthodes propre a son traitement. Il peut également ajouter un process d'init et de fin de traitement.

Voici le code

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
class Task
{
public:
    Task();
    ~Task();
 
    virtual void   taskRun      ( void ) = 0;
    virtual void   taskInit     ( void );
    virtual void   taskTerminate( void );
    void           taskStart    ( void );    
    void           Exec         ( void );
    void           Wait         ( void );
 
protected:
private:
    boost::thread mThread;
 
};

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
 
void Task::Exec( void )
{
    taskInit();
    taskStart();
    taskTerminate();
}
 
void Task::Wait()
{
    mThread.join();
}
 
void Task::taskInit( void )
{
}
 
void Task::taskStart( void )
{
    cout << "Task::taskStart" << endl;
    mThread = boost::thread( boost::bind( &Task::taskRun, boost::ref(*this) ) ); 
}
 
void Task::taskTerminate( void )
{   
}

J'aurais voulu eglement rajouter comme traitement l'arret (que je ne sais malheureusement pas comment faire :/)
Avez vous une idée sur comment je pourrais proceder ?

Merci d'avance
Guitou

[backlash]

Pour gérer l'arrêt : http://www.boost.org/doc/libs/1_52_0...read.interrupt

Cependant je ne vois pas du tout l'intérêt de ton encapsulation, sachant que tu ne fais que (quasiment) wrapper boost::thread sans réelle traitement en plus.

[Emmanuel Deloget]

Pour gérer l'arrêt : http://www.boost.org/doc/libs/1_52_0...read.interrupt

Cependant je ne vois pas du tout l'intérêt de ton encapsulation, sachant que tu ne fais que (quasiment) wrapper boost::thread sans réelle traitement en plus.

L'intérêt est peut-être de wrapper boost.thread en attandant que std::thread soit correctement implémenté sur la majorité des compilateurs - bien que pour ma part, je proposerais (ou tenterais de proposer) une classe cpp11::thread dont l'interface est la même que std::thread, et s'appuyant sur boot.thread le temps de la transition.

Pour ce qui est d'un arrêt propre d'un thread, il est peut-être préférable de faire quelque chose de moins violent que interrupt() - passer par une variable atomique, et tester cette variable dans le corps du thread (via, par exemple, une méthode shall_stop()).

[sone47]

Merci pour vos reponses,

Bien entendu l'exemple posté n'est que le debut donc ne fait que réencapsuler la base.
L'interet comme le dit Emmanuel est d'attendre le support de std::thread, mais c'est sur qu'en utilisant les memes noms ça facilitera le boulot.
De plus ça permet d'instaurer des pseudos regles sur les droits de chaque dev sur un objet thread, ou d'en faciliter l'usage.

Pour le stop je pourrai effectivement faire un mix de vos 2 idees:

1- utiliser interrupt:
La tache passe obligatoirement par une phase d'init, son run et un temrinate.
L'idée est que dans le run, aucune allocation ne soit effectuée (l'init est fait pour ca), ce n'est qu'un thread de calcul.
Si le stop fait un interrupt sur le thread en cours, cette interruption sera suivie du "terminate" (car l'execution suit la regle: init>run>temrinate).
Ai je bon ?

2- Pour les threads plus complexes implementer dans la classe mere un flag d'interruption. Et le tester a differents endroits critiques dans le run de la classe derivee

Qu'en pensez vous ?

Merci d'avance