多线程 gtkmm 应用程序的最简单示例

Question

I'm developing a stopwatch application in c++ and gtkmm.The first approach was to integrate the stopwatch loop with main event loop,but that caused delays in the stopwatch loop,So I decided to use two threads, one for GUI the other is for the stopwatch counter. the GUI thread and and stopwatch thread -which counts the number of seconds passed-, the stopwatch thread updates the label after each second. I've read that I've to use specific techniques to use multi threaded gtkmm program. I also checked this example which i didn't understand. Can any one tell me what shall I do in the stopwatch thread to make it update the GUI without crashing.

Here's the code,

#include <ctime>
#include <thread>
#include <iostream>
#include <sstream>
#include <gtkmm.h>

using namespace std;
using namespace Gtk;
using namespace std::chrono;

class Timer
{
    bool condition;
    Label *label_ptr;

private:
    void startTimer()
    {
        condition = true;
        auto t0 = high_resolution_clock::now();
        int x = 0;
        while (condition)
        {
            cout << condition << endl;
            auto t1 = high_resolution_clock::now();
            int duration = duration_cast<seconds>(t1 - t0).count();
            if (duration - x == 1)
            {
                x = duration;
                //cout << duration_cast<seconds>(t1 - t0).count() << "sec" << endl;
                stringstream moment;
                moment << to_string(duration_cast<seconds>(t1 - t0).count());
                moment << ": 0 s";

                label_ptr->set_label(moment.str());
            }
            if (g_main_context_pending(NULL))
            {
                g_main_context_iteration(NULL, true);
            }
        }
    }

public:
    //This is the function which start the thread
    void start_timer(){
        thread t0(sigc::mem_fun(this , &Timer::startTimer));
    }

    Timer(Label &label)
    {
        condition = 0;
        label_ptr = &label;
    }

    void stop_timer()
    {
        label_ptr->set_text("0 : 0");
        condition = false;
    }
};

int main(int argc, char *argv[])
{
    auto app = Application::create(argc, argv, "Timer");

    if (!g_thread_supported())
        g_thread_init(NULL);

    gdk_threads_init();

    gdk_threads_enter();

    Window window;
    HBox mainBox;
    window.add(mainBox);
    window.set_title("Timer & Stopwatch");
    window.set_default_size(240, 100);
    window.set_border_width(10);
    Label label;
    VButtonBox buttons;
    Separator sep0;

    mainBox.pack_start(buttons, PACK_EXPAND_PADDING, 20);
    mainBox.pack_start(sep0, PACK_SHRINK);
    mainBox.pack_end(label, PACK_EXPAND_PADDING);

    label.set_size_request(120, 100);

    Button start, stop;
    buttons.add(start);
    buttons.add(stop);
    start.set_border_width(5);
    stop.set_border_width(5);

    start.set_label("Start");
    stop.set_label("Stop");

    label.set_text("0 : 0");

    Timer timer(label);
    start.signal_clicked().connect(sigc::mem_fun(timer, &Timer::start_timer));

    window.show_all_children();

    gdk_threads_leave();

    return app->run(window);
}

Answer 1

if your requirement is just to count number of seconds elapsed, you do not need a worker thread. Also you cannot modify any GUI element (in your case the 'label') from a worker thread since Gdk is not thread safe. You will then need to use Glib::Dispatcher to notify the main thread of a 'tick' event and then increment a counter from the main loop.

Instead of all this you can simply use Glib::SignalTimeout and connect a function to it like below.

In the function that handles starting of the stop-watch

//Connect to timeout
m_connectionStopWatch = Glib::SignalTimeout::connect(sigc::mem_fun(*this, &CStopWatchClass::OneSecondElapsed), 1000);

//Reset counter
m_nCounter = 0;

The function that is called every second

bool CStopWatchClass::OneSecondElapsed(void)
{
  //Increment counter
  m_nCounter++;

  //TODO Update label

  return true;
}

In the function that stops the stop watch

m_connectionStopWatch.disconnect();

m_connectionStopWatch and m_nCounter shall be class private (or protected or even public though not preferred) members.

If you are not particular about having a delay of up to 0.99... seconds in starting your stop watch you can even use Glib::SignalTimeout::connect_seconds which loads your application even less. In any case a 1 second timeout is no problem at all, I myself am using a 20 millisecond timeout for a similar graphical application.