Einfaches Beispiel für Threading in C++

Question

Kann jemand ein einfaches Beispiel für das Starten zweier (objektorientierter) Threads in C++ posten?

Ich bin auf der Suche nach tatsächlichen C++-Thread-Objekte, die ich ausführen Methoden auf (oder etwas ähnliches) im Gegensatz zu Aufruf einer C-Stil-Thread-Bibliothek erweitern können.

Ich habe keine betriebssystemspezifischen Anfragen gestellt, in der Hoffnung, dass derjenige, der geantwortet hat, mit plattformübergreifenden Bibliotheken antworten würde. Ich bin nur machen, dass explizit jetzt.

Answer 1

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

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

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

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

(Sie müssen #include <thread> zum Zugriff auf die std::thread Klasse)

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

Wenn Sie zu einem späteren Zeitpunkt warten wollen, bis der Thread mit der Ausführung der Funktion fertig ist, rufen Sie auf:

t1.join(); 

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

---

Der Kodex

#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

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

Answer 2

Nun, technisch gesehen wird ein solches Objekt über eine C-ähnliche Thread-Bibliothek erstellt werden, da C++ gerade erst einen Bestand an std::thread Modell in C++0x, das gerade erst festgeschrieben wurde und noch nicht implementiert ist. Das Problem ist in gewisser Weise systemisch, denn das bestehende C++-Speichermodell ist technisch nicht streng genug, um eine gut definierte Semantik für alle Fälle zu ermöglichen, in denen "etwas vorher passiert". Hans Boehm hat vor einiger Zeit eine Abhandlung zu diesem Thema geschrieben und war maßgeblich an der Ausarbeitung des c++0x-Standards zu diesem Thema beteiligt.

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

Allerdings gibt es mehrere plattformübergreifende Thread-C++-Bibliotheken, die in der Praxis gut funktionieren. Intel Thread Building Blocks enthält ein tbb::Thread-Objekt, das dem C++0x-Standard sehr nahe kommt, und Boost hat eine boost::Thread-Bibliothek, die das Gleiche tut.

http://www.threadingbuildingblocks.org/

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

Mit boost::thread erhalten Sie etwas wie:

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

Answer 3

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

Answer 4

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

Klasse.h

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

Klasse.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 auf Mutex oder Locking eingeht.

Answer 5

Es gibt auch eine POSIX-Bibliothek für POSIX-Betriebssysteme. Siehe für 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;

}

mit -lpthread kompilieren

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