Ejemplo simple de subprocesos en C ++

¿Alguien puede publicar un ejemplo simple de iniciar dos subprocesos (orientados a objetos) en C ++.

Estoy buscando objetos de subprocesos reales de C ++ en los que pueda extender los métodos de ejecución (o algo similar) en lugar de llamar a una biblioteca de subprocesos de estilo C.

Dejé de lado cualquier solicitud específica del sistema operativo con la esperanza de que quien respondiera respondería con bibliotecas multiplataforma para usar. Solo estoy haciendo eso explícito ahora.

Cree una función que desee que ejecute el hilo, por ejemplo:

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

Ahora cree el threadobjeto que finalmente invocará la función anterior de la siguiente manera:

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

(Necesitas #include <thread>acceder a la std::threadclase)

Los argumentos del constructor son la función que ejecutará el hilo, seguidos de los parámetros de la función. El hilo se inicia automáticamente en la construcción.

Si más adelante desea esperar a que se termine el hilo ejecutando la función, llame a:

t1.join(); 

(Unirse significa que el hilo que invocó el nuevo hilo esperará a que el nuevo hilo termine la ejecución, antes de que continúe su propia ejecución).

El código

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

Más información sobre std :: thread aquí

• En GCC, compila con -std=c++0x -pthread.
• Esto debería funcionar para cualquier sistema operativo, dado que su compilador admite esta característica (C ++ 11).

Bueno, técnicamente cualquier objeto de este tipo terminará construyéndose sobre una biblioteca de subprocesos de estilo C porque C ++ solo especificó un std::threadmodelo de stock en c ++ 0x, que se acaba de clavar y aún no se ha implementado. El problema es un tanto sistémico, técnicamente el modelo de memoria c ++ existente no es lo suficientemente estricto como para permitir una semántica bien definida para todos los casos de "suceder antes". Hans Boehm escribió un artículo sobre el tema hace un tiempo y fue fundamental para elaborar el estándar c ++ 0x sobre el tema.

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

Dicho esto, hay varias bibliotecas C ++ de subprocesos multiplataforma que funcionan bien en la práctica. Los bloques de creación de subprocesos de Intel contienen un objeto tbb :: thread que se aproxima mucho al estándar c ++ 0x y Boost tiene una biblioteca boost :: thread que hace lo mismo.

http://www.threadingbuildingblocks.org/

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

Usando boost :: thread obtendrías algo como:

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

También hay una biblioteca POSIX para sistemas operativos POSIX. Verifique la compatibilidad

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

}

compilar con -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);
}

Al buscar un ejemplo de una clase C ++ que llama a uno de sus propios métodos de instancia en un nuevo hilo, surge esta pregunta, pero no pudimos usar ninguna de estas respuestas de esa manera. Aquí hay un ejemplo que hace eso:

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

Tenga en cuenta que este ejemplo no entra en mutex o bloqueo.

A menos que uno quiera una función separada en los nombres globales, podemos usar funciones lambda para crear hilos.

Una de las principales ventajas de crear hilos usando lambda es que no necesitamos pasar parámetros locales como una lista de argumentos. Podemos usar la lista de captura para el mismo y la propiedad de cierre de lambda se encargará del ciclo de vida.

Aquí hay un código de muestra

int main() {
    int localVariable = 100;

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

    th.join();

    return 0;
}

De lejos, he encontrado que C ++ lambdas es la mejor manera de crear hilos especialmente para funciones de hilo más simples

Depende en gran medida de la biblioteca que decida usar. Por ejemplo, si usa la biblioteca wxWidgets, la creación de un hilo se vería así:

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 su hilo principal llama al método CreateThread, creará un nuevo hilo que comenzará a ejecutar el código en su método de "Entrada". Tendrá que mantener una referencia al hilo en la mayoría de los casos para unirse o detenerlo. Más información aquí: documentación de wxThread