Discussion :

[Alpha573]

Bonjour,
Dans le cadre d'un rojet, je suis amener à utiliser des threads.
J'ai trouvé la librairie Pthread en C, et j'ai vu que l'on pouvait l'adapter à C++.
Existe-t-il d'autres possibilités ? Il faut que mon programme tourne sur Linux.
Merci

[Emmanuel Deloget]

pthread est la librairie de thread système ; a ma connaissance, toute autre librairie sera soit basée dessus (comme boost.thread), soit bâtie autour d'un système qui sera très similaire voire identique (comme... comme... mince, je n'ai pas d'exemple).

A noter que gcc sait nativement quoi faire avec pthread.

Il ne sert à rien, à mon humble avis, de vouloir trouver une autre solution : c'est la librairie système, donc autant l'utiliser. Construire un wrapper C++ autour de pthread est relativement simple, et il en existe des tonnes (dont le déjà mentionné boost.thread).

Cf. http://blog.emptycrate.com/node/270 pour une base (relativement) correcte. On peut faire bien mieux, bien sûr.

[Alpha573]

Ok merci beaucoup.
Bonne journée !

[Alpha573]

J'ai commencé un wrapper en m'inspirant fortement de ce que j'ai trouvé ici :
http://blog.nicoleau-fabien.net/inde...ns-un-object-C

Mais j'ai un problème à la déclaration de la structure pthread_t dans mon header :

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
#ifndef PTHREAD_H
#define PTHREAD_H
#include <pthread.h>
 
//Définition du processus
typedef void* (*threadProcess)(void*);
 
//Définition de la structure d'un thread
typedef struct
{
    threadProcess process;
    void *args;
    bool *running;
    bool *finished;
} threadParams;
 
////////////////////////////////////////////////////////////////////////////
// Librairie utilisant les pthread du C pour faire un objet thread simple //
////////////////////////////////////////////////////////////////////////////
class PThread
{
    private:
   ///////////////
   // ATTRIBUTS //
   ///////////////
 
   //Handle du thread
   pthread_t* handle;
 
   //S'il est actif
   bool running;
 
   //S'il est fini
   bool finished;
 
    //////////////
   // FONCTIONS //
   ///////////////
   //Fonction threadée
   static void* threadStartup(void*);
 
   public:
 
   //Constructeur
   PThread();
 
   //Destructeur
   ~PThread();
 
   //Prparer et lancer un thread
   bool exec(threadProcess, void*);
 
   //Terminer un thread
   bool terminate();
 
   //Le thread tourne ?
   bool isRunning();
 
   //Le thread est terminé ?
   bool isFinished();
 
   //Join le thread
   void* join();
 
   //Récupérer l'handle du thread
   pthread_t* getHandle();
};
 
#endif // PTHREAD_H

Et ce que me sors GCC :

Code :

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

error: ISO C++ forbids declaration of 'pthread_t' with no type

Je vous met aussi le cpp :

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
#include <iostream>
#include "../include/PThread.h"
using namespace std;
 
/**Constructeur*/
PThread::PThread()
{
    this->finished=false;
    this->running=false;
    this->handle=new pthread_t;
}
 
/**Destructeur*/
PThread::~PThread()
{
    this->terminate();
    pthread_join(*this->handle, NULL);
    delete this->handle;
}
 
/** Prépare et lance un thread.
Enregistre la fonction à exécuter et ses arguments,
Puis crée un thread et lance la fonction */
bool PThread::exec(threadProcess monThreadProcess, void* args)
{
    //Test si le thread ne tourne pas déjà
    if(!this->isRunning())
    {
        threadParams tp;
        tp.process=monThreadProcess;
        tp.args;
        tp.running=&this->running;
        tp.finished=&this->finished;
 
        if(pthread_create (this->handle, NULL, PThread::threadStartup, (void*)&tp<0)
        {
            return false;
        }
    }
    return false;
}
 
/**Fonction threadée. Dans cette fonction, le thread est préparé, et ensuite la fonction à
exécuter est lancée*/
void* PThread::threadStartup(void* targs)
{
    threadParams* tp=(threadParams*)targs;
    bool* running=tp->running;
    bool* finished=tp->finished;
    threadProcess process=tp->process;
    void* args=tp->args;
    *running=true;
    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
    pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
    process(args);
    *running = false;
    *finished = true;
    pthread_exit(0);
}
 
/**Arrête le thread */
bool PThread::terminate()
{
    //Si le thread tourne
    if(this->isRunning())
    {
        if(pthread_cancel (*this->handle)!=0)
        {
            return false;
        }
        this->running=false;
        return true;
    }
    return false;
}
 
/**Donne l'état du thread*/
bool PThread::terminate()
{
    return this->running;
}
 
/**Dis si le thread est fini*/
bool PThread::isFinished()
{
    return this->finished;
}
 
/**Attends la fin du thread et libère la mémoire*/
void* PThread::join()
{
    void* ret;
    pthread_join(*this->handle, &ret);
    return ret;
}
 
/**Retourne l'handle d'un thread*/
pthread_t* PThread::getHandle()
{
    return this->handle;
}

Merci !

[fregolo52]

Nommer tes fichiers exactement comme les nom des API sytème ne me semble pas très malin !!! *

A 1 '_' près tu définissais le define system :
toi : #ifndef PTHREAD_H
pthread de linux : #ifndef _PTHREAD_H

[JolyLoic]

Suivant l'usage que tu veux faire des threads, certaines alternatives plus haut niveau que les pthreads peuvent être intéressants (ou pas). Je pense par exemple à TBB ou à openMP.