Exemple simple de threading en C ++

Quelqu'un peut-il publier un exemple simple de démarrage de deux threads (orientés objet) en C ++.

Je recherche des objets de thread C ++ réels sur lesquels je peux étendre les méthodes d'exécution (ou quelque chose de similaire) au lieu d'appeler une bibliothèque de threads de style C.

J'ai omis toutes les demandes spécifiques au système d'exploitation dans l'espoir que celui qui répondrait répondrait avec les bibliothèques multiplateformes à utiliser. Je ne fais que rendre cela explicite maintenant.

Créez une fonction que vous souhaitez que le thread exécute, par exemple:

void task1(std::string msg)
{
    std::cout << "task1 says: " << msg;
}

Créez maintenant l' threadobjet qui appellera finalement la fonction ci-dessus comme ceci:

std::thread t1(task1, "Hello");

(Vous devez #include <thread>accéder à la std::threadclasse)

Les arguments du constructeur sont la fonction que le thread exécutera, suivie des paramètres de la fonction. Le fil démarre automatiquement lors de la construction.

Si plus tard vous voulez attendre que le thread ait fini d'exécuter la fonction, appelez:

t1.join(); 

(La jointure signifie que le thread qui a appelé le nouveau thread attendra la fin de l'exécution du nouveau thread, avant de poursuivre sa propre exécution).

Le code

#include <string>
#include <iostream>
#include <thread>

using namespace std;

// The function we want to execute on the new thread.
void task1(string msg)
{
    cout << "task1 says: " << msg;
}

int main()
{
    // Constructs the new thread and runs it. Does not block execution.
    thread t1(task1, "Hello");

    // Do other things...

    // Makes the main thread wait for the new thread to finish execution, therefore blocks its own execution.
    t1.join();
}

Plus d'informations sur std :: thread ici

• Sur GCC, compilez avec -std=c++0x -pthread.
• Cela devrait fonctionner pour n'importe quel système d'exploitation, étant donné que votre compilateur prend en charge cette fonctionnalité (C ++ 11).

Eh bien, techniquement, un tel objet finira par être construit sur une bibliothèque de threads de style C car C ++ vient de spécifier un std::threadmodèle de stock en c ++ 0x, qui vient d'être cloué et n'a pas encore été implémenté. Le problème est quelque peu systémique, techniquement, le modèle de mémoire c ++ existant n'est pas assez strict pour permettre une sémantique bien définie pour tous les cas «avant». Hans Boehm a écrit un article sur le sujet il y a quelque temps et a joué un rôle déterminant dans l'élaboration de la norme c ++ 0x sur le sujet.

http://www.hpl.hp.com/techreports/2004/HPL-2004-209.html

Cela dit, il existe plusieurs bibliothèques C ++ de threads multiplateforme qui fonctionnent très bien dans la pratique. Les blocs de construction de threads Intel contiennent un objet tbb :: thread qui se rapproche étroitement de la norme c ++ 0x et Boost a une bibliothèque boost :: thread qui fait de même.

http://www.threadingbuildingblocks.org/

http://www.boost.org/doc/libs/1_37_0/doc/html/thread.html

En utilisant boost :: thread, vous obtiendrez quelque chose comme:

#include <boost/thread.hpp>

void task1() { 
    // do stuff
}

void task2() { 
    // do stuff
}

int main (int argc, char ** argv) {
    using namespace boost; 
    thread thread_1 = thread(task1);
    thread thread_2 = thread(task2);

    // do other stuff
    thread_2.join();
    thread_1.join();
    return 0;
}

Il existe également une bibliothèque POSIX pour les systèmes d'exploitation POSIX. Vérifier la compatibilité

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <iostream>

void *task(void *argument){
      char* msg;
      msg = (char*)argument;
      std::cout<<msg<<std::endl;
}

int main(){
    pthread_t thread1, thread2;
    int i1,i2;
    i1 = pthread_create( &thread1, NULL, task, (void*) "thread 1");
    i2 = pthread_create( &thread2, NULL, task, (void*) "thread 2");

    pthread_join(thread1,NULL);
    pthread_join(thread2,NULL);
    return 0;

}

compiler avec -lpthread

http://en.wikipedia.org/wiki/POSIX_Threads

#include <thread>
#include <iostream>
#include <vector>
using namespace std;

void doSomething(int id) {
    cout << id << "\n";
}

/**
 * Spawns n threads
 */
void spawnThreads(int n)
{
    std::vector<thread> threads(n);
    // spawn n threads:
    for (int i = 0; i < n; i++) {
        threads[i] = thread(doSomething, i + 1);
    }

    for (auto& th : threads) {
        th.join();
    }
}

int main()
{
    spawnThreads(10);
}

Lorsque vous recherchez un exemple d'une classe C ++ qui appelle l'une de ses propres méthodes d'instance dans un nouveau thread, cette question se pose, mais nous n'avons pas pu utiliser l'une de ces réponses de cette façon. Voici un exemple qui fait cela:

Class.h

class DataManager
{
public:
    bool hasData;
    void getData();
    bool dataAvailable();
};

Class.cpp

#include "DataManager.h"

void DataManager::getData()
{
    // perform background data munging
    hasData = true;
    // be sure to notify on the main thread
}

bool DataManager::dataAvailable()
{
    if (hasData)
    {
        return true;
    }
    else
    {
        std::thread t(&DataManager::getData, this);
        t.detach(); // as opposed to .join, which runs on the current thread
    }
}

Notez que cet exemple n'entre pas dans le mutex ou le verrouillage.

À moins que l'on veuille une fonction distincte dans les espaces de noms globaux, nous pouvons utiliser des fonctions lambda pour créer des threads.

L'un des principaux avantages de la création de thread à l'aide de lambda est que nous n'avons pas besoin de transmettre les paramètres locaux sous forme de liste d'arguments. Nous pouvons utiliser la liste de capture pour la même chose et la propriété de fermeture de lambda se chargera du cycle de vie.

Voici un exemple de code

int main() {
    int localVariable = 100;

    thread th { [=](){
        cout<<"The Value of local variable => "<<localVariable<<endl;
    }}

    th.join();

    return 0;
}

De loin, j'ai trouvé que les lambdas C ++ étaient le meilleur moyen de créer des threads, en particulier pour les fonctions de thread plus simples

Cela dépend en grande partie de la bibliothèque que vous décidez d'utiliser. Par exemple, si vous utilisez la bibliothèque wxWidgets, la création d'un thread ressemblerait à ceci:

class RThread : public wxThread {

public:
    RThread()
        : wxThread(wxTHREAD_JOINABLE){
    }
private:
    RThread(const RThread &copy);

public:
    void *Entry(void){
        //Do...

        return 0;
    }

};

wxThread *CreateThread() {
    //Create thread
    wxThread *_hThread = new RThread();

    //Start thread
    _hThread->Create();
    _hThread->Run();

    return _hThread;
}

Si votre thread principal appelle la méthode CreateThread, vous allez créer un nouveau thread qui commencera à exécuter le code dans votre méthode "Entry". Vous devrez conserver une référence au thread dans la plupart des cas pour le rejoindre ou l'arrêter. Plus d'informations ici: documentation wxThread