Are signals and streams a good or bad design decision?

Question

I need to write a program that performs highly computational computing. The program can work for several days. The calculation can be easily divided in different streams without the need for common data. I want the GUI or web service to inform me of the current status.

My current project uses BOOST :: signals2 and BOOST :: thread. It compiles and works as expected. If the stream is completed, iteration and new data are available, it causes a signal that is connected to a slot in the GUI class.

My question (s):

• Is this combination of signals and streams a wise idea? I have another forum someone advised someone else not to "follow this path."
• Are there any potential dangerous pitfalls that I have not seen?
• Is my expectation realistic that it will be easy to use my GUI class to provide a web interface or QT, VTK or any window?
• Is there a smarter alternative (e.g. other boost libs) that I forgot?

The following code compiles with

g++ -Wall -o main -lboost_thread-mt <filename>.cpp

:

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

Answer 1

Is this combination of signals and thread a wise idea? I am another forum someone advised someone else not to "Follow this road."

It seems to sound. Can you provide a link to another thread? Did they explain their reasoning?

Are there any potential dangerous pitfalls that I have not seen?

, . , ( , GuiClass::slot_data_changed .

, "" GUI- - QT, VTK ?

. , . :

GuiClass , . GuiClass::slot_data_changed , (private:) . GuiClass , . ( , GuiClass).

:

• , .

:

• , ( ).

• :)

, "" GUI- - QT, VTK - ?

, . , .

? ( boost libs), ?

boost libs, , , : . join , boost:: thread_group.

:

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

:

boost::thread_group processors;
processors.create_thread(r1, 3);
// the other threads here

processors.join_all();

. - , (, , , , ..).

( ), , , ( ).

, , a, class A [ tA], b, class B [ tB] b a -.

" a -" , b a.something() a.something() tB ( B).

( a.something() tA), . , b a "run A::something()", b a " A:: something()` .

:

• b a tB

• a tA

• a b, .something(), tA.

( A::something tA tB, , b).

, boost::asio::io_service, , , .

Answer 2

:

signal2 thread safety, . ( Qt OpenGL) . , . :

-, , GuiClass::slot_data_changed ( Qt, QCoreApplication:: postEvent (, Qt)).

-, , . , , GUI .