5
Tengo que escribir un programa que realiza cálculos altamente computacionales intensivos. El programa puede funcionar por varios días. El cálculo se puede separar fácilmente en diferentes subprocesos sin la necesidad de datos compartidos. Quiero una GUI o un servicio web que me informe del estado actual.Señales e hilos: ¿decisión de diseño buena o mala?
Mi diseño actual usa BOOST :: signals2 y BOOST :: thread. Compila y hasta el momento funciona como se esperaba. Si un hilo terminó una iteración y hay nuevos datos disponibles, llama a una señal que está conectada a una ranura en la clase de la GUI.
Mi pregunta (s):
- ¿Es esta combinación de señales y los hilos de una buena idea? En otro foro, alguien aconsejó a otra persona que no "siga por este camino".
- ¿Hay posibles peligros mortales cerca que no pude ver?
- ¿Es realista mi expectativa de que sea "fácil" utilizar mi clase de GUI para proporcionar una interfaz web o un QT, un VTK o una ventana cualquiera?
- ¿Hay una alternativa más inteligente (como otras librerías de refuerzo) que pasé por alto?
siguiente código se compila con
códigog++ -Wall -o main -lboost_thread-mt <filename>.cpp
sigue:
#include <boost/signals2.hpp>
#include <boost/thread.hpp>
#include <boost/bind.hpp>
#include <iostream>
#include <iterator>
#include <string>
using std::cout;
using std::cerr;
using std::string;
/**
* Called when a CalcThread finished a new bunch of data.
*/
boost::signals2::signal<void(string)> signal_new_data;
/**
* The whole data will be stored here.
*/
class DataCollector
{
typedef boost::mutex::scoped_lock scoped_lock;
boost::mutex mutex;
public:
/**
* Called by CalcThreads call the to store their data.
*/
void push(const string &s, const string &caller_name)
{
scoped_lock lock(mutex);
_data.push_back(s);
signal_new_data(caller_name);
}
/**
* Output everything collected so far to std::out.
*/
void out()
{
typedef std::vector<string>::const_iterator iter;
for (iter i = _data.begin(); i != _data.end(); ++i)
cout << " " << *i << "\n";
}
private:
std::vector<string> _data;
};
/**
* Several of those can calculate stuff.
* No data sharing needed.
*/
struct CalcThread
{
CalcThread(string name, DataCollector &datcol) :
_name(name), _datcol(datcol)
{
}
/**
* Expensive algorithms will be implemented here.
* @param num_results how many data sets are to be calculated by this thread.
*/
void operator()(int num_results)
{
for (int i = 1; i <= num_results; ++i)
{
std::stringstream s;
s << "[";
if (i == num_results)
s << "LAST ";
s << "DATA " << i << " from thread " << _name << "]";
_datcol.push(s.str(), _name);
}
}
private:
string _name;
DataCollector &_datcol;
};
/**
* Maybe some VTK or QT or both will be used someday.
*/
class GuiClass
{
public:
GuiClass(DataCollector &datcol) :
_datcol(datcol)
{
}
/**
* If the GUI wants to present or at least count the data collected so far.
* @param caller_name is the name of the thread whose data is new.
*/
void slot_data_changed(string caller_name) const
{
cout << "GuiClass knows: new data from " << caller_name << std::endl;
}
private:
DataCollector & _datcol;
};
int main()
{
DataCollector datcol;
GuiClass mc(datcol);
signal_new_data.connect(boost::bind(&GuiClass::slot_data_changed, &mc, _1));
CalcThread r1("A", datcol), r2("B", datcol), r3("C", datcol), r4("D",
datcol), r5("E", datcol);
boost::thread t1(r1, 3);
boost::thread t2(r2, 1);
boost::thread t3(r3, 2);
boost::thread t4(r4, 2);
boost::thread t5(r5, 3);
t1.join();
t2.join();
t3.join();
t4.join();
t5.join();
datcol.out();
cout << "\nDone" << std::endl;
return 0;
}
Si bien este ejemplo particular está bien, debe tener cuidado, ya que no está protegiendo su vector con el mutex en la función 'out' – nos