multithreading et classes?

Question

Voici le problème que j'ai avec le multithreading. Le processus doit être statique, ce qui signifie que la seule façon dont je vois que 2 threads peuvent communiquer et partager des données est à travers la portée globale. Cela ne semble pas très propre et ne se sent pas très OO. Je sais que je peux créer une fonction de processus statique dans une classe, mais cela reste statique. Ce que je voudrais faire, par exemple, est d'avoir des threads threads dans la classe pour que je puisse créer une classe de checksum MD5 et avoir un tableau de ces objets, chacun sur son propre thread vérifiant son hash, alors que le fil de l'interface utilisateur n'est pas affecté par cela et une autre classe pourrait simplement garder une trace des poignées et attendre plusieurs objets avant de dire "Complete" ou quelque chose. Comment cette limitation est-elle habituellement surmontée?

Answer 1

Vous ne pouvez pas éviter d'utiliser une fonction statique si vous souhaitez y démarrer un thread. Vous pouvez cependant (en utilisant Windows) passer le pointeur this comme paramètre et l'utiliser de l'autre côté pour entrer dans l'instance de classe.

#include <windows.h> 

class Threaded { 
    static DWORD WINAPI StaticThreadEntry(LPVOID me) { 
     reinterpret_cast<Threaded*>(me)->ThreadEntry(); 
     return 0; 
    } 

    void ThreadEntry() { 
     // Stuff here. 
    } 

public: 
    void DoSomething() { 
     ::CreateThread(0, 0, StaticThreadEntry, this, 0, 0); 
    } 
}; 

Answer 2

Je ne suis pas sûr d'avoir bien compris ... Je fais un essai. Cherchez-vous thread local storage?

Answer 3

En C++, Boost.Thread résout bien le problème. Un thread est représenté par un foncteur, ce qui signifie que le operator() (non statique) est le point d'entrée du thread.

Par exemple, un fil peut être créé comme ceci:

// define the thread functor 
struct MyThread { 
    MyThread(int& i) : i(i) {} 
    void operator()(){...} 
private: 
    int& i; 
}; 

// create the thread 
int j; 
boost::thread thr(MyThread(j)); 

en transmettant les données au constructeur du foncteur de fil, on peut passer des paramètres au fil sans avoir à compter sur globals. (Dans ce cas, le thread reçoit une référence à l'entier j déclaré en dehors du thread.)

Avec d'autres bibliothèques ou API, c'est à vous de faire le saut d'un point d'entrée (généralement statique) au partage non -statique des données.

La fonction thread prend généralement un paramètre (parfois facultatif) (souvent de type void*) que vous pouvez utiliser pour transmettre des données d'instance au thread.

Si vous utilisez cette commande pour passer un pointeur vers un objet, le thread peut simplement renvoyer le pointeur vers le type d'objet et accéder aux données sans avoir à s'appuyer sur les globales.

Par exemple, (en pseudocode), cela aurait à peu près le même effet que l'exemple Boost ci-dessus:

void MyThreadFunc(void* params) { 
    int& i = *(int*)params; 
    ... 
} 

int j; 
CreateThread(MyThreadFunc, &j); 

Ou le paramètre peut être un pointeur vers un objet dont (non statique) fonction membre vous souhaitez appeler, ce qui vous permet d'exécuter une fonction de membre de classe au lieu d'un non-membre.

Answer 4

Les routines de création de threads permettent généralement de passer un paramètre à la fonction qui sera exécutée dans un nouveau thread. Cela est vrai pour Posix pthread_create (...) et Win32 CreateThread (...). Voici un exemple utilisant Pthreads:

void* func (void* arg) { 
    queue_t* pqueue = (queue_t*)arg; 

    // pull messages off the queue 
    val = queue_pull(pqueue); 

    return 0; 
} 

int main (int argc, char* argv[]) { 
    pthread_t thread; 
    queue_t queue = queue_init(); 

    pthread_create(&thread, 0, func, &queue); 

    // push messages on the queue for the thread to process 
    queue_push(&queue, 123); 

    void* ignored; 
    pthread_join(&thread, &ignored); 

    return 0; 
} 

Aucune statique nulle part. Dans un programme C++, vous pouvez passer un pointeur sur une instance d'une classe.