¿Cómo puedo comunicarme entre hilos?

Question

¿Cómo puedo crear hilos en C++ y comunicarme entre el hilo principal y otro?

Se apreciarán algunas muestras de código.

Answer 1

Los subprocesos comparten variables con su alcance, es por eso que los bloqueos de mutex son tan importantes.

Así se puede comunicar con bastante facilidad simplemente editando una variable común a los dos hilos:

#include <iostream> 
#include <pthread.h> 
main() { 
    pthread_t f2_thread, f1_thread; 
    void *f2(), *f1(); 
    int i1; 
    i1 = 1; 
    pthread_create(&f1_thread,NULL,f1,&i1); 
    pthread_create(&f2_thread,NULL,f2,&i1); 
    pthread_join(f1_thread,NULL); 
    pthread_join(f2_thread,NULL); 
} 
void *f1(int *x){ 
    std::cout << *x << std::endl; 
} 
void *f2(int *x){ 
    sleep(1) 
    std::cout << ++(*x) << std::endl; 
} 

Esto debe imprimir:

1 
2 

Y el i1 variable ha sido compartido entre hilos. Esta es una forma de comunicación, puedes compartir clases estructura cadenas, cualquier cosa que quieras.

NOTA: Este código casi definitivamente causará una carrera de subprocesos. Este es solo un ejemplo, siempre debe usar la sincronización y las prácticas de seguridad de subprocesos al compartir memoria entre subprocesos.

Answer 2

La creación del hilo depende del sistema operativo.

en Linux, puede usar la función pthread library pthread_create para crear subprocesos, y usar pthread_join para esperar a que termine el subproceso.

En Windows, puede usar la función de API de Windows CreateThread() para crear subprocesos y usar la función WaitForSingleObject() para esperar a que termine el subproceso.

Answer 3

bien, yo le dirá más simple de lo que sé: _beginthread

• Debe incude process.h para que esto funcione.
• Debe haber una función para enhebrar.
• La entrada del parámetro de funciones debe ser (nulo *).
• La función debería tener un _endthread() cuando es necesario que finalice.

En el siguiente programa, dos hilos compiten contra encontrar el valor pi. Si uno de ellos encuentra el valor pi, informa al otro hilo que debe terminar. También en el principal() se imprime cuál encontró el pi. El tercer hilo solo espera uno de los otros hilos para terminar.

 #include<process.h> 
     #include<windows.h> //for the Sleep() 
     #include<stdio.h> 
     volatile boolean found=false; 
     volatile int who=0; 

     void find_pi_core1(void * iterations) 
     { 

      int * ite=(int *)iterations; 
      for(int i=0;i<ite;i++) 
      { 
       //a sample of Monte-Carlo method here to find pi 
       //gets pi with more precision with additional iterations 
       if(found) _endthread(); 
      } 
      found=true;who=1; 
      _endthread();  

     } 

     void find_pi_core2(void * iterations) 
     { 

      int * ite=(int *)iterations; 
      for(int i=0;i<ite;i++) 
      { 
       //a sample of Monte-Carlo method here to find pi 
       //gets pi with more precision with additional iterations 
       if(found) _endthread(); 
      } 
      found=true;who=2; 
      _endthread(); 
     } 

     void printscreeN(void * dummy) 
     { 

      while(!found) 
      { 
       Sleep(30);  //if dont sleep, it gets a lot of cpu power 
      } 
      printf(" found! \n"); 
      _endthread(); 
     } 

     int main() 
     { 

         Function name 
         ^  Stack size 
          |  ^   Function parameter 
          |   |   ^
      _beginthread(find_pi_core1,0,(void *) 3000000); 
      _beginthread(find_pi_core2,0,(void *) 2500000); 
      _beginthread(printscreeN,0,(void *)0); 
      Sleep(3000); 
      if(found) 
      { 
       printf("pi has been found! core-%d has found pi first ",who); 
      } 
      else 
      {printf("pi has not been bound!");} 
      return 0; 
     } 

Answer 4

En la creación del hilo, la respuesta es obvia (creo que es), o bien si tiene std::thread C++ 11 o boost::thread de otro modo, pero en caso de paso de mensajes que dependen de su problema y su estilo de programación.
Como solución de uso general prefiero el uso de boost::asio::io_service es muy flexible y puede publicar cualquier tipo de función u objeto de función para ser ejecutado en el contexto de otro hilo, utilizando esta técnica no necesita ningún mutex o tal y también puede agrupar hilos a consumidores y productores y muchas otras características útiles están disponibles.