Gtkmm/Glibmm Thread Example

After dealing with threads in Qt and seeing how nice and simple it was, I decided to try again with the Gtkmm/Glibmm threading system. I think the crucial piece for me with the Qt threads was the excellent documentation, so I'm going to show you my full example here and document it in detail. As a quick disclaimer, I do not know if this is the 100% "right" way to do threads, but it matches up with everything I've read and, more importantly, it works.

Where to start...
I'm going to start with a brief description of what is going to happen. We will develop a threaded worker class, a trivial Gtk::Window class and a trivial main function. Let's get the first two out of the way early, since they are the easy ones.

int main ()

int main (int argc , char ** argv) {

  if(!Glib::thread_supported()) Glib::thread_init();

  Gtk::Main kit (argc, argv);
  MyWindow win;
  Gtk::Main::run (win);
  return 0;
}

if(!Glib::thread_supported()) Glib::thread_init();

If the rest of this function doesn't make sense to you, walk away from this tutorial and go read the Gtkmm one.

MyWindow
Next we are going to implement that Gtk::Window class that we use in main, ever so imaginatively called MyWindow. There is nothing much special going on, so I'll show you the full listing then pick out the important bits.

class MyWindow : public Gtk::Window {

  public:
    MyWindow () : thrashHive("Go!") {
      bee = NULL;
      thrashHive.signal_clicked().connect(sigc::mem_fun(*this, &MyWindow::go));
      add(thrashHive);
      show_all();
    }

    void go () {
      if(bee != NULL)
        return;

      bee = new Worker();
      bee->sig_done.connect(sigc::mem_fun(*this, &MyWindow::beeDone));
      bee->start();

      thrashHive.set_sensitive(false);
      thrashHive.set_label("Working");
    }

    void beeDone () {
      delete bee;
      bee = NULL;
      thrashHive.set_sensitive(true);
      thrashHive.set_label("Go!");
    }

  private:
    Gtk::Button thrashHive;
    Worker * bee;

};

As you can tell, this is a simple Gtk::Window with just a single button (thrashHive) in it. In the constructor we connect this button to a method go() at line 52. go() is important to us because it is where we create and launch our thread, which is represented as the class Worker of which we have a pointer declared at line 78 called bee. Let's run through go() line by line.

      if(bee != NULL)
        return;

      bee = new Worker();
      bee->sig_done.connect(sigc::mem_fun(*this, &MyWindow::beeDone));
      bee->start();

      thrashHive.set_sensitive(false);
      thrashHive.set_label("Working");

Worker
The Worker class is actually fairly simple. It has a basic set of steps:

1. Create and wait to be started.
2. Get started, create thread and run.
3. Do work, emit signals, check for being aborted.
4. Return when done, then wait around until cleaned up.

class Worker {
  public:
 
    Worker() : thread(0), stop(false) {}
 
    // Called to start the processing on the thread
    void start () {
      thread = Glib::Thread::create(sigc::mem_fun(*this, &Worker::run), true);
    }
 
    // When shutting down, we need to stop the thread
    ~Worker() {
      {
        Glib::Mutex::Lock lock (mutex);
        stop = true;
      }
      if (thread)
        thread->join(); // Here we block to truly wait for the thread to complete
    }
 
    Glib::Dispatcher sig_done;
 
  protected:
    // This is where the real work happens
    void run () {
 
      while(true) {
        {
          Glib::Mutex::Lock lock (mutex);
          if (stop) break;
        }
        sleep(5);
        std::cout << "Thread write!" << std::endl;
        sig_done();
        break;
      }
    }
 
    Glib::Thread * thread;
    Glib::Mutex mutex;
    bool stop;
};

We don't have anything to deal with for the first point. In the constructor we just initialize the Glib::Thread to 0 and our sentinel boolean, stop to false.

For the second point, we need to look at start() and run().

start() is our public method, and it creates and runs the actual Glib::Thread. Doing that is fairly straight forward:

    void start () {
      thread = Glib::Thread::create(sigc::mem_fun(*this, &Worker::run), true);
    }

The run() method is where our blocking operations go so that we don't have to worry about gumming up the UI, this is where the work actually happens (i.e. step 3).

    void run () {
 
      while(true) {
        {
          Glib::Mutex::Lock lock (mutex);
          if (stop) break;
        }
        sleep(5);
        std::cout << "Thread write!" << std::endl;
        sig_done();
        break;
      }
    }

On line 37 we see a "signal" being emitted. This is actually a Glib::Dispatcher, which uses pipes for asynchronous communication between threads. In practical application just treat it like a sigc::signal . If you need to communicate data, emit the Glib::Dispatcher and have the receiving thread do method calls to get the information from stored values in the sending thread.

One easy to miss caveat when using gthreads, you have to throw in some extra libraries with pkg-config --libs gthread-2.0, here is the command line to compile this demo application.

g++ -Wall -o bee gthread.cpp `pkg-config gtkmm-2.4 --cflags --libs` `pkg-config --libs gthread-2.0`

That is the guts of a simple Gtkmm/Glibmm worker thread, I hope that I was clear if not concise. Here is the complete listing of the program for your reading/borrowing/compiling pleasure.

#include 
#include 

class Worker {
  public:

    Worker() : thread(0), stop(false) {}

    // Called to start the processing on the thread
    void start () {
      thread = Glib::Thread::create(sigc::mem_fun(*this, &Worker::run), true);
    }

    // When shutting down, we need to stop the thread
    ~Worker() {
      {
        Glib::Mutex::Lock lock (mutex);
        stop = true;
      }
      if (thread)
        thread->join(); // Here we block to truly wait for the thread to complete
    }

    Glib::Dispatcher sig_done;

  protected:
    // This is where the real work happens
    void run () {

      while(true) {
        {
          Glib::Mutex::Lock lock (mutex);
          if (stop) break;
        }
        sleep(5);
        std::cout << "Thread write!" << std::endl;
        sig_done();
        break;
      }
    }

    Glib::Thread * thread;
    Glib::Mutex mutex;
    bool stop;
};

class MyWindow : public Gtk::Window {

  public:
    MyWindow () : thrashHive("Go!") {
      bee = NULL;
      thrashHive.signal_clicked().connect(sigc::mem_fun(*this, &MyWindow::go));
      add(thrashHive);
      show_all();
    }

    void go () {
      if(bee != NULL)
        return;

      bee = new Worker();
      bee->sig_done.connect(sigc::mem_fun(*this, &MyWindow::beeDone));
      bee->start();

      thrashHive.set_sensitive(false);
      thrashHive.set_label("Working");
    }

    void beeDone () {
      delete bee;
      bee = NULL;
      thrashHive.set_sensitive(true);
      thrashHive.set_label("Go!");
    }

  private:
    Gtk::Button thrashHive;
    Worker * bee;

};

int main (int argc , char ** argv) {

  if(!Glib::thread_supported()) Glib::thread_init();

  Gtk::Main kit (argc, argv);
  MyWindow win;
  Gtk::Main::run (win);
  return 0;
}