Einfaches Beispiel für das Threading in C ++

Kann jemand ein einfaches Beispiel für das Starten von zwei (objektorientierten) Threads in C ++ veröffentlichen?

Ich suche nach tatsächlichen C ++ - Thread-Objekten, auf die ich Ausführungsmethoden (oder ähnliches) erweitern kann, anstatt eine Thread-Bibliothek im C-Stil aufzurufen.

Ich habe alle betriebssystemspezifischen Anfragen ausgelassen, in der Hoffnung, dass jeder, der geantwortet hat, mit plattformübergreifenden Bibliotheken antworten würde. Ich mache das jetzt nur explizit.

Erstellen Sie eine Funktion, die der Thread ausführen soll, z.

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

Erstellen Sie nun das threadObjekt, das letztendlich die obige Funktion aufruft, wie folgt:

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

(Sie müssen auf #include <thread>die std::threadKlasse zugreifen )

Die Argumente des Konstruktors sind die Funktion, die der Thread ausführen wird, gefolgt von den Parametern der Funktion. Der Thread wird beim Aufbau automatisch gestartet.

Wenn Sie später warten möchten, bis der Thread die Funktion ausgeführt hat, rufen Sie Folgendes auf:

t1.join(); 

(Beitritt bedeutet, dass der Thread, der den neuen Thread aufgerufen hat, darauf wartet, dass der neue Thread die Ausführung beendet, bevor er seine eigene Ausführung fortsetzt.)

Der 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();
}

Weitere Informationen zu std :: thread finden Sie hier

• Kompilieren Sie auf GCC mit -std=c++0x -pthread.
• Dies sollte für jedes Betriebssystem funktionieren, vorausgesetzt, Ihr Compiler unterstützt diese Funktion (C ++ 11).

Technisch gesehen wird ein solches Objekt über eine Thread-Bibliothek im C-Stil erstellt, da C ++ std::threadin c ++ 0x nur ein Aktienmodell angegeben hat, das gerade festgenagelt und noch nicht implementiert wurde. Das Problem ist etwas systematisch. Technisch gesehen ist das vorhandene C ++ - Speichermodell nicht streng genug, um eine genau definierte Semantik für alle Fälle zu ermöglichen, die vorher auftreten. Hans Boehm hat vor einiger Zeit einen Artikel zu diesem Thema geschrieben und war maßgeblich daran beteiligt, den c ++ 0x-Standard zu diesem Thema auszuarbeiten.

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

Es gibt jedoch mehrere plattformübergreifende Thread-C ++ - Bibliotheken, die in der Praxis einwandfrei funktionieren. Intel-Thread-Bausteine ​​enthalten ein tbb :: thread-Objekt, das dem c ++ 0x-Standard sehr nahe kommt, und Boost verfügt über eine boost :: thread-Bibliothek, die dasselbe tut.

http://www.threadingbuildingblocks.org/

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

Mit boost :: thread erhalten Sie Folgendes:

#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;
}

Es gibt auch eine POSIX-Bibliothek für POSIX-Betriebssysteme. Überprüfen Sie die Kompatibilität

#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;

}

Kompilieren Sie mit -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);
}

Bei der Suche nach einem Beispiel für eine C ++ - Klasse, die eine ihrer eigenen Instanzmethoden in einem neuen Thread aufruft, wird diese Frage gestellt, aber wir konnten keine dieser Antworten auf diese Weise verwenden. Hier ist ein Beispiel dafür:

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
    }
}

Beachten Sie, dass dieses Beispiel nicht in Mutex oder Sperren gerät.

Sofern keine separate Funktion in globalen Namespacs gewünscht wird, können Lambda-Funktionen zum Erstellen von Threads verwendet werden.

Einer der Hauptvorteile beim Erstellen von Threads mit Lambda besteht darin, dass wir keine lokalen Parameter als Argumentliste übergeben müssen. Wir können die Erfassungsliste für dasselbe verwenden und die Schließungseigenschaft von Lambda kümmert sich um den Lebenszyklus.

Hier ist ein Beispielcode

int main() {
    int localVariable = 100;

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

    th.join();

    return 0;
}

Bei weitem habe ich festgestellt, dass C ++ - Lambdas die beste Methode zum Erstellen von Threads sind, insbesondere für einfachere Threadfunktionen

Dies hängt weitgehend von der Bibliothek ab, für die Sie sich entscheiden. Wenn Sie beispielsweise die Bibliothek wxWidgets verwenden, sieht die Erstellung eines Threads folgendermaßen aus:

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;
}

Wenn Ihr Hauptthread die CreateThread-Methode aufruft, erstellen Sie einen neuen Thread, der den Code in Ihrer "Entry" -Methode ausführt. In den meisten Fällen müssen Sie einen Verweis auf den Thread behalten, um ihn zu verbinden oder zu stoppen. Weitere Infos hier: wxThread-Dokumentation