Estoy haciendo un programa más grande en el que quiero usar subprocesos, así que primero estoy tratando de averiguar cómo funcionan realmente los subprocesos, así que creé un programa simple y no puedo entender por qué no recibo un mensaje "Bomberman has just put a bomb. Wait for the boom." antes del { {X1}}.

¿Alguien puede instruirme por qué no funciona como esperaba?

#include <unistd.h>
#include <chrono>
#include <iostream>
#include <thread>

using namespace std;

class CBomberman;

class CBomb {
 public:
  CBomb(void) : m_Owner(nullptr) {
    thread other_thread(&CBomb::Timer, this);
    other_thread.join();
  }

 private:
  void Timer(void) {
    this_thread::sleep_for(chrono::seconds(3));
    cout << "The bomb has just detonated." << endl;
  }

  CBomberman* m_Owner;
};

class CBomberman {
 public:
  CBomberman(void) : m_Bomb(nullptr) {}

  bool PutBomb(void) {
    if (m_Bomb == nullptr) {
      m_Bomb = new CBomb();
      delete m_Bomb;
      return true;
    } else {
      cout << "The bomb has already been put." << endl;
      return false;
    }
  }

 private:
  CBomb* m_Bomb;
};

int main() {
  CBomberman bomberman;

  bomberman.PutBomb();
  cout << "Bomberman has just put a bomb. Wait for the boom." << endl;

  return 0;
}
0
scarface 17 ago. 2016 a las 18:49

2 respuestas

La mejor respuesta

Su problema es que se está uniendo al hilo inmediatamente después de crearlo, lo que significa que solo está utilizando subprocesos múltiples en un sentido muy técnico: definitivamente ha creado otro hilo y (probablemente) operará en otro núcleo de CPU , pero el hilo del host simplemente está inactivo mientras el otro hilo funciona.

Necesita almacenar localmente el objeto thread para poder unirse a él en un momento posterior.

class CBomb
{
public:
    CBomb ( void )
    : m_Owner ( nullptr ),
    bomb_thread(&CBomb::Timer, this)
    {
    }
    std::thread bomb_thread; //This needs to be a member of this object. Whether you make it public or not is a matter of your design approach.
private:
    void Timer ( void )
    {
        this_thread::sleep_for( chrono::seconds( 3 ) );
        cout << "The bomb has just detonated." << endl;
    }

    CBomberman * m_Owner;
};

class CBomberman
{
public:
    CBomberman ( void )
    : m_Bomb ( nullptr )
    {

    }

    bool PutBomb ( void )
    {
        if( m_Bomb == nullptr )
        {
            m_Bomb = new CBomb();//Don't delete the object immediately after creating it. What were you expecting to have happen if you did?
            return true;
        }
        else
        {
            cout << "The bomb has already been put." << endl;
            return false;
        }
    }
    CBomb * m_Bomb;
};

int main()
{
    CBomberman bomberman;

    bomberman.PutBomb();
    cout << "Bomberman has just put a bomb. Wait for the boom." << endl;
    bomberman.m_bomb->bomb_thread.join(); //If we hit the end before the thread concludes, there could be some errors.

    return 0;
}
4
Xirema 17 ago. 2016 a las 16:01

Porque llamas a join en other_thread inmediatamente después de crear other_thread. La llamada join bloquea el hilo principal y espera a que other_thread salga. Consulte los documentos sobre std :: thread :: join en http: //en.cppreference. com / w / cpp / thread / thread / join.

0
malchemist 17 ago. 2016 a las 16:09