我必须编写一个执行高度计算密集型计算的程序。该程序可能会运行几天。 计算可以很容易地在不同的线程中分离，而不需要共享数据。 我想要一个 GUI 或网络服务来通知我当前状态。

我目前的设计使用 BOOST::signals2 和 BOOST::thread。 它编译并且到目前为止按预期工作。 如果一个线程完成了一次迭代并且有新数据可用，它会调用一个连接到 GUI 类中的插槽的信号。

我的问题:

• 信号和线程的这种结合是明智的想法吗？我在另一个论坛上有人建议其他人不要“走这条路”。
• 附近是否有我没有看到的潜在致命陷阱？
• 我的期望是否现实，即使用我的 GUI 类来提供 Web 界面或 QT、VTK 或任何窗口会“容易”？
• 是否有我忽略的更聪明的替代方案(如其他提升库)？

以下代码编译为

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

最佳答案

Is this combination of signals and threads a wise idea? I another forum somebody advised someone else not to "go down this road".

好像还不错。你能提供另一个线程的链接吗？他们是否在解释他们的推理？

Are there potential deadly pitfalls nearby that I failed to see?

如果它们是，我也看不到它们。您需要注意的是通知是线程安全的(信号的触发不会切换线程上下文，您的 GuiClass::slot_data_changed 应该从所有其他线程调用。

Is my expectation realistic that it will be "easy" to use my GUI class to provide a web interface or a QT, a VTK or a whatever window?

这并不容易。要解决这个问题，您必须让您的通知切换线程上下文。这是我会做的:

让您的 GuiClass 成为一个抽象基类，实现它自己的消息队列。当您的线程调用 GuiClass::slot_data_changed 时，您会锁定一个互斥锁并将收到的通知拷贝发布到内部 (private:) 消息队列中。在 GuiClass 的线程中，您创建了一个函数来锁定互斥锁并在队列中查找通知。此函数应在客户端代码的线程中运行(在您从抽象 GuiClass 专门化的具体类的线程中)。

优点:

• 您的基类封装并隔离线程上下文切换，对其特化透明。

缺点:

• 您的客户端代码必须运行轮询方法或允许它运行(作为线程处理函数)。

• 有点复杂:)

Is my expectation realistic that it will be "easy" to use my GUI class to provide a web interface or a QT, a VTK or a whatever window?

不这么认为，但这并不容易。除了线程上下文切换之外，我目前可能还遗漏了其他问题。

Is there a more clever alternative (like other boost libs) that I overlooked?

不是其他 boost 库，但是您编写线程的方式不好:连接是在您的代码中按顺序进行的。要让所有线程只有一个 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，A 类 的一个实例 [在线程 tA 中运行] 做一些事情，b， B 类 的实例 [在线程 tB 的上下文中运行] 和 b 想要告诉 a 一些事情。

“想要告诉 a 某事”部分意味着 b 想要调用 a.something() 和 a。 something() 将在 tB 的上下文中调用(在线程 B 的堆栈上)。

要改变这一点(让 a.something() 在 tA 的上下文中运行)，您必须切换线程上下文。这意味着 b 告诉 a “运行 A::something()”，b 告诉 a “在您自己的线程上下文中运行 A::something()`”。

经典实现步骤:

• b 从 tB 中向 a 发送消息

• a 从 tA 中轮询消息

• 当 a 找到来自 b 的消息时，它会在 tA 内运行 a.something() 本身。

这是线程上下文的切换(A::something 的执行将在 tA 而不是 tB 中执行，因为如果直接从 b).

从您提供的链接来看，这似乎已经由 boost::asio::io_service 实现，因此如果您使用它，则不必自己实现。

关于c++ - 信号和线程——好的还是坏的设计决策？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/3021854/