Le Multithreading à l'aide de la bibliothèque boost

Souhaitez appeler simultanément une fonction à plusieurs reprises. Je souhaite utiliser des threads pour appeler une fonction qui permettra d'utiliser les machines de capacité au maximum. C'est un 8 core de la machine, et mon exigence est d'utiliser le cpu de la machine de 10% à 100% ou plus.

Mon exigence est d'utiliser le boost de la classe. Est il possible que je peux accomplir cela en utilisant le coup de pouce de fil ou de pool de threads de la bibliothèque? Ou une autre façon de faire?

Aussi, si je dois faire appel à plusieurs fonctions avec des paramètres différents à chaque fois (avec des threads séparés), quelle est la meilleure façon de le faire? [utilisation de boost ou pas d'utilisation de boost] et comment?

#include <iostream>
#include <fstream>
#include <string.h>
#include <time.h>
#include <boost/thread/mutex.hpp>
#include <boost/bind.hpp>

using namespace std;
using boost::mutex;
using boost::thread;

int threadedAPI1( );
int threadedAPI2( );
int threadedAPI3( );
int threadedAPI4( );

int threadedAPI1( ) {
    cout << "Thread0" << endl;
}


int threadedAPI2( ) {
    cout << "Thread1" << endl;
}

int threadedAPI3( ) {
    cout << "Thread2" << endl;
}

int threadedAPI4( ) {
    cout << "Thread3" << endl;
}

int main(int argc, char* argv[]) {

    boost::threadpool::thread_pool<> threads(4);
    //start a new thread that calls the "threadLockedAPI" function
    threads.schedule(boost::bind(&threadedAPI1,0));
    threads.schedule(boost::bind(&threadedAPI2,1));
    threads.schedule(boost::bind(&threadedAPI3,2));
    threads.schedule(boost::bind(&threadedAPI4,3));
    //wait for the thread to finish
    threads.wait();

    return 0;
}

Le ci-dessus ne fonctionne pas et je ne suis pas sûr pourquoi? 🙁

C'est toujours une bonne idée pour spécifier comment c'est "pas de travail". Il ne veut pas faire ce que vous voulez? Il ne compile pas? Quelles erreurs avez-vous l'obtenir? Exactement où obtenez-vous?

OriginalL'auteur gagneet | 2008-12-05

  1. 6

    Je vous suggère de lire sur la documentation pour les fonctions que vous utilisez. À partir de votre commentaire dans James Hopkin réponse, il semble que vous ne savez pas ce que boost::bind, mais il suffit de copier coller le code.

    boost::bind prend une fonction (que l'on appellera f), et éventuellement un certain nombre de paramètres, et retourne une fonction qui, lorsqu'on les appelle, appelle f avec l'aide des paramètres spécifiés.

    Qui est, boost::bind(threadedAPI1, 0)() (en créant une fonction qui ne prend pas d'arguments et d'appels threadedAPI1() avec l'argument 0, puis en l'appelant) est équivalent à threadedAPI1(0).

    Depuis votre threadedAPI fonctions ne prend aucun paramètre, vous ne pouvez pas passer tous les arguments. C'est juste fondamental du C++. Vous ne pouvez pas appeler threadedAPI1(0), mais seulement threadedAPI1(), et pourtant, lorsque vous appelez la fonction, vous essayez (via boost::bind) pour transmettre l'entier 0 comme argument.

    Donc la réponse simple à votre question est tout simplement de définir threadedAPI1 comme suit:

    int threadedAPI1(int i);

    Cependant, une façon d'éviter le boost::bind appels est d'appeler un foncteur au lieu d'une fonction libre lors du lancement du thread. Déclarer une classe à quelque chose comme ceci:

    struct threadedAPI {
  threadedAPI(int i) : i(i) {} //A constructor taking the arguments you wish to pass to the thread, and saves them in the class instance.

  void operator()() { //The () operator is the function that is actually called when the thread starts, and because it is just a regular class member function, it can see the 'i' variable initialized by the constructor
    cout << "Thread" << i << endl; //No need to create 4 identical functions. We can just reuse this one, and pass a different `i` each time we call it.
  }
private:
  int i;
};

    Enfin, en fonction de ce que vous avez besoin, plaine de threads peut-être mieux qu'un pool de threads. En général, un pool de thread s'exécute uniquement un nombre limité de fils, de sorte qu'il peut faire la queue certaines tâches jusqu'à ce que l'un de ses fils terminer l'exécution. Il est principalement prévu pour les cas où vous avez beaucoup de courte durée des tâches.

    Si vous avez un nombre fixe de l'allongement de la durée des tâches, la création d'un thread dédié pour chacun d'eux peut être le chemin à parcourir.

    merci, cela semble faire beaucoup de sens. désolé de ne pas lire sur les docs avant de poster.

    OriginalL'auteur jalf

  2. 4

    Vous êtes à la liaison de paramètres à des fonctions qui ne prennent pas de paramètres:

    int threadedAPI1( );

boost::bind(&threadedAPI1,0)

    Juste passer à la fonction directement si il n'y a pas de paramètres:

    threads.schedule(&threadedAPI1)
    quelle est la façon correcte de le faire alors?

    OriginalL'auteur James Hopkin

  3. 3

    Si votre intérêt est dans l'utilisation de votre processeur efficacement alors vous pourriez envisager de intels fil de blocs de construction de http://www.intel.com/cd/software/products/asmo-na/eng/294797.htm. Je crois qu'il est spécialement conçu pour utiliser les processeurs multi tout en boost fils feuilles de contrôle de l'utilisateur (c'est à dire TBB sera le fil différemment sur un quad core par rapport à un dual core).

    Comme pour votre code de liaison des fonctions qui ne prennent pas de paramètres à un paramètre. Pourquoi? Vous pourriez également vouloir vérifier le code de retour de l'annexe.

    merci patrick. en fait ont modifié la question pour être plus précis. je voulais trouver quelque chose qui me permettra de l'appeler plusieurs fonctions simultanément. aussi, je ne suis pas sûr de comment faire pour envoyer des paramètres.

    OriginalL'auteur Patrick