pthread - thread c++ ejemplo
Ejemplo simple de enhebrado en C++ (7)
A menos que uno quiera una función separada en espacios de nombres globales, podemos usar las funciones lambda para crear hilos.
Una de las principales ventajas de crear subprocesos utilizando 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 hará cargo 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 las lambdas de C ++ son la mejor manera de crear subprocesos, especialmente para funciones de subprocesos más simples
¿Puede alguien publicar un ejemplo simple de inicio de dos subprocesos (orientados a objetos) en C ++?
Estoy buscando objetos de subprocesos de C ++ reales en los que pueda extender los métodos de ejecución (o algo similar) en lugar de llamar una biblioteca de subprocesos de estilo C.
Actualización: omití cualquier solicitud específica de SO con la esperanza de que quien respondiera respondiera con las bibliotecas de plataforma cruzada para usar. Solo estoy haciendo eso explícito ahora.
Al buscar un ejemplo de una clase de C ++ que llame 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 exclusión o bloqueo.
Aquí hay una forma más robusta de crear un número arbitrario de subprocesos (en C ++ 11 o más reciente):
#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();
}
}
Bueno, técnicamente, cualquier objeto de este tipo terminará siendo construido sobre una biblioteca de subprocesos de estilo C porque C ++ solo especificó un modelo estándar de std::thread estándar en c ++ 0x, que se acaba de definir 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 ''sucede antes''. Hans Boehm escribió un artículo sobre el tema hace un tiempo y jugó un papel decisivo en la elaboración de la norma 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 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;
}
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 objeto de thread que finalmente invocará la función anterior así:
std::thread t1(task1, "Hello");
( #include <thread> para acceder a la clase std::thread )
Los argumentos del constructor son la función que ejecutará el hilo, seguido 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:
t1.join();
(Unirse significa que el hilo que invocó el nuevo hilo esperará a que el nuevo hilo termine de ejecutarse, 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 :: hilo aquí
- En GCC, compile con
-std=c++0x -pthread. - Esto debería funcionar para cualquier sistema operativo, si su compilador admite esta característica (C ++ 11).
Depende en gran medida de la biblioteca que decida utilizar. 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 ©);
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
También hay una biblioteca POSIX para sistemas operativos POSIX. Check 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