Création de threads qui copient les arguments qui leur sont transmis

J’utilise actuellement boost :: thread, car il me permet très facilement de transmettre un nombre arbitraire d’arguments au thread et de les copier en cours de route. Je n’ai donc pas à craindre qu’ils soient supprimés avant le lancement du thread. Existe-t-il une autre bibliothèque permettant cela, ou un moyen de la simuler à l’aide de pthreads? J’aimerais me sevrer, mais je n’ai jamais vu une autre bibliothèque faire cela.

Je ne me souviens pas des détails de Boost.Thread, mais l’idée générale ressemble à ceci:

class thread_function_base { public: virtual ~thread_function_base(void) {} virtual void run(void) = 0; }; template  class thread_function_0 : public thread_function_base { public: thread_function_0(const Func& pFunc) : mFunc(pFunc) {} void run(void) { mFunc(); } private: Func mFunc; }; template  class thread_function_1 : public thread_function_base { public: thread_function_1(const Func& pFunc, const A0& pA0) : mFunc(pFunc), mA0(pA0) {} void run(void) { mFunc(mA0); } private: Func mFunc; A0 mA0; }; // and so on to some limit, either // generated either by hand (yuck), by // Boost.PP (phew), or by C++0x's // variadic templates (yay, no limit either) class thread { public: template  thread(const Func& pFunc) { std::auto_ptr threadFunc(new thread_function_0(pFunc)); create_thread(threadFunc); } template  thread(const Func& pFunc, const A0& pA0) { std::auto_ptr threadFunc(new thread_function_1(pFunc, pA0)); create_thread(threadFunc); } // again, needs to be generated somehow private: // noncopyable thread(const thread&); thread& operator=(const thread&); // signature needs to match implementations expectations: static void thread_function(void* pUserData) { std::auto_ptr pFunc(static_cast(pUserData)); // (A) pFunc->run(); } void create_thread(std::auto_ptr& pThreadFunc) { // again, implementation specific function: if (create_thread(&thread_function, pThreadFunc.get(), ...)) { // failed, do something (and return), // auto_ptr in constructor will free resources return; } // thread was created, so it now owns that resource pThreadFunc.release(); // (B) } }; 

Fondamentalement, tout ce qui est nécessaire pour appeler le thread est copié dans un conteneur alloué dynamicment, un pointeur sur ce conteneur dynamic est transmis à la fonction de thread (sortingvial), puis la propriété est transférée de l’extérieur au thread.

Vous pouvez rendre les choses plus sûres en thread_function_base non seulement la base thread_function_base dans les données utilisateur, mais également un descripteur de signal (spécifique à l’implémentation). La fonction de threading bloquera en (A) jusqu’à ce que le signal soit émis en (B) , indiquant que le thread principal a donné au thread de travail la pleine propriété des ressources. (Et à partir de là, c’est auto_ptr qui finira par le supprimer.)

Et ainsi de suite, le rendant plus sophistiqué.

Vous devez créer un wrapper autour de pthread_create et transmettre un stockage spécifique au thread à pthread_create contenant un tableau d’arguments, par exemple. Le wrapper utiliserait un formulaire tel que:

 void *mythreadfunction(void *arg) {...} pthread_create_wrapper(context ctx, ...) { Array *arr; pthread_t mythread; arr = new Array(); // push arguments to array here blah blah ... // create thread and pass in argument list as thread data pointer. pthread_create(&mythread, NULL, mythreadfunction, (void *)arr); }