it-swarm.com.de

Einfaches Beispiel für Threading in C++

Kann jemand ein einfaches Beispiel zum Starten von zwei (objektorientierten) Threads in C++ posten. 

Ich suche nach echten C++ - Thread-Objekten, auf die ich Laufmethoden erweitern kann (oder etwas Ähnlichem), anstatt eine C-ähnliche Thread-Bibliothek aufzurufen.

Update - Ich habe alle betriebssystemspezifischen Anforderungen in der Hoffnung ausgelassen, dass jeder, der geantwortet hat, mit plattformübergreifenden Bibliotheken antworten würde. Ich mache das jetzt gerade deutlich.

364
Zak

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 das thread-Objekt, das die Funktion oben wie folgt aufrufen wird:

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

(Sie müssen #include <thread> eingeben, um auf die std::thread-Klasse zugreifen zu können.)

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

Wenn Sie später darauf warten möchten, dass der Thread die Funktion ausführt, rufen Sie Folgendes auf:

t1.join(); 

(Verknüpfen bedeutet, dass der Thread, der den neuen Thread aufgerufen hat, wartet, bis die Ausführung des neuen Threads abgeschlossen ist, 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 hier

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

Technisch gesehen wird jedes Objekt über eine Threadbibliothek im C-Stil erstellt, da C++ nur ein std::thread - Modell in c ++ 0x angegeben hat, das nur festgeschnürt und noch nicht implementiert wurde. Das Problem ist etwas systemisch. Technisch gesehen ist das vorhandene C++ - Speichermodell nicht streng genug, um eine klar definierte Semantik für alle Fälle zu ermöglichen, die vor dem Ereignis geschehen. Hans Boehm hat vor einiger Zeit einen Artikel zu diesem Thema verfasst und war maßgeblich an der Ausarbeitung des C++ 0x-Standards zum 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-Threadbausteine ​​enthalten ein tbb :: thread-Objekt, das dem C++ - Standard 0x 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 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;
}
76
Edward KMETT

Es gibt auch eine POSIX-Bibliothek für POSIX-Betriebssysteme. Überprüfen Sie auf 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 mit -lpthread 

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

18

Hier ist eine robustere Methode zum Erstellen einer beliebigen Anzahl von Threads (in C++ 11 oder neuer):

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

void doSomething(int id) {
    cout << "Thread id = " << id;
}

/**
 * Spawns n threads
 */
void spawnThreads(int n)
{
    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();
    }
}
11
Caner

Bei der Suche nach einem Beispiel für eine C++ - Klasse, die eine eigene Instanzmethode in einem neuen Thread aufruft, wird diese Frage angezeigt, die Antworten konnten jedoch nicht verwendet werden. Hier ist ein Beispiel, das das tut:

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.

8
livingtech

Es hängt weitgehend von der Bibliothek ab, die Sie verwenden möchten. Wenn Sie beispielsweise die Bibliothek wxWidgets verwenden, würde die Erstellung eines Threads folgendermaßen aussehen:

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 beibehalten, um ihn zu verbinden oder zu stoppen. Weitere Informationen finden Sie hier: wxThread documentation

7
LorenzCK

Wenn Sie nicht eine separate Funktion in globalen Namensräumen wünschen, können Sie Lambda-Funktionen zum Erstellen von Threads verwenden. 

Ein großer Vorteil der Erstellung von Threads mit Lambda besteht darin, dass keine lokalen Parameter als Argumentliste übergeben werden müssen. Wir können eine Fangliste für dasselbe verwenden und die Schließungseigenschaft von Lambda wird den Lebenszyklus berücksichtigen.

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

5
Daksh

// multithreaded.c ++: Ein einfaches Beispiel für Threading in C++, das Threading und einen wichtigen Abschnitt verwendet.

#include "stdafx.h"
#include <thread>
#include <iostream>
#include<fstream>
#include <windows.h>

using namespace std;


bool flag = 1;
auto path = "D:\\temp";
void writestatus(int i, int j);
CRITICAL_SECTION cs;

void workerThread(int j)
{
    int i = 1;
    ofstream f2;
    char buff[150] = { 0 };
    while (flag)
    {
        sprintf_s(buff, 150, "D:\\temp\\MyTemp_%d%03d.txt", j, i++);

        //str.append("%d", i++);
        f2.open(buff);
        f2 << buff;
        f2.close();
        //Sleep(10);
    }
    EnterCriticalSection(&cs);
    writestatus(i, j);
    LeaveCriticalSection(&cs);
}

void writestatus(int i, int j)
{
    ofstream f1;
    char buff[150] = { 0 };
    f1.open("D:\\temp\\status.txt", ios_base::app);
    sprintf_s(buff, 150, "%d Writes %d files \n", j, i++);
    if (f1)
    {
        f1 << buff;
    }
    else
    {
        MessageBeep(1);
    }
    f1.close();
}

int main()
{
    system("del d:\\temp\\*.txt");

    InitializeCriticalSection(&cs);
    thread t1(workerThread, 1);
    thread t2(workerThread, 2);
    thread t3(workerThread, 3);
    thread t4(workerThread, 4);
    thread t5(workerThread, 5);

    Sleep(250);
    flag = 0;
    t1.join();
    t2.join();
    t3.join();
    t4.join();
    t5.join();
    return 0;
}
0
Anirudha Ketkar