Наши партнеры

Библиотека сайта rus-linux.net

Программирование с использованием gtkmm 3. Многопоточные программы

Оригинал: Programming with gtkmm 3
Авторы: Murray Cumming, Bernhard Rieder, Jonathon Jongsma, Ole Laursen, Marko Anastasov, Daniel Elstner, Chris Vine, David King, Pedro Ferreira, Kjell Ahlstedt
Дата публикации: 15 Октября 2013 г.
Перевод: А.Панин
Дата перевода: 10 Апреля 2014 г.

29. Многопоточные программы

29.1. Ограничения

glibmm предоставляет достаточный набор функций для создания потоков, примитивов взаимных исключений (мьютексов), условных переменных и классов для локальных блокировок, необходимых для реализации многопоточных программ с помощью языка программирования C++.

Однако, требуется особая осторожность при разработке многопоточных программ на основе gtkmm, так как библиотека libsigc++, а также сам класс отслеживания sigc::trackable не являются потокобезопасными. Это означает, что ни одно из сложных взаимодействий, происходящих на заднем плане при использовании библиотеки libsigc++, не защищено с помощью взаимного исключения или какого-либо другого примитива синхронизации.¹

29.1.1. Правила разработки

Эти обстоятельства приводят к необходимости принятия к сведению множества правил при разработке многопоточных программ на основе gtkmm. Правила приведены ниже, причем следует особо учесть необходимость проявления дополнительной осторожности при наследовании классов от класса отслеживания sigc::trackable, так как результаты работы созданных классов могут быть непредсказуемыми (следует обратить особое внимание на пункты 4 и 5 ниже).

Используйте экземпляр класса обработчика событий Glib::Dispatcher для вызова функций gtkmm из рабочих потоков (более подробно об этом будет сказано в следующем разделе).
Объект сигнала на основе класса sigc::signal должен рассматриваться как объект, принадлежащий создавшему его потоку. Только этот поток должен соединять объект слота на основе класса sigc::slot с объектом сигнала и только этот поток должен генерировать сигналы с помощью метода emit() или использовать operator()() для перегрузки операторов объекта сигнала, а также удалять любой присоединенный объект слота на основе класса sigc::slot. Из этого следует (помимо остальных вещей) то, что любой объект сигнала, предоставленный виджетом из состава gtkmm, должен обслуживаться исключительно в рамках главного потока приложения с графическим интерфейсом и любой объект на основе унаследованного от класса отслеживания sigc::trackable класса, имеющий нестатические методы со ссылками из присоединенных к объекту сигнала слотов, должен уничтожаться из этого потока.
Любой объект соединения на основе класса sigc::connection должен рассматриваться как принадлежащий потоку, в рамках которого был осуществлен вызов метода, возвращающего этот объект типа sigc::connection. Только в рамках этого потока должны вызываться методы данного объекта соединения типа sigc::connection.
Объект слота на основе класса sigc::slot, создаваемый с помощью вызова метода sigc::mem_fun() и ссылающийся на метод унаследованного от класса отслеживания sigc::trackable класса, никогда не должен копироваться в другой поток, а также уничтожаться в рамках того потока, который его не создавал. (Одно из последствий этого ограничения заключается в том, что метод Glib::Threads::Thread::create() не должен вызываться с передачей в качестве аргумента слота, созданного с помощью вызова метода sigc::mem_fun(), представляющего метод такого унаследованного класса. Однако, методу Glib::Threads::Thread::create() можно безопасно передавать объект функции, представляющий такой метод с помощью, скажем, экземпляра класса boost::bind, std::bind в C++11 или лямбда-выражения в C++11.)
В том случае, если класс, лежащий в основе определенного объекта, наследуется от класса отслеживания sigc::trackable, объекты слотов на основе класса sigc::slot, представляющие любой из нестатических методов класса, должны создаваться в рамках одного потока с помощью вызова sigc::mem_fun(). Первый создавший такой слот поток должен рассматриваться как владелец соответствующего объекта, предназначенный для создания дополнительных слотов, ссылающихся на любой из нестатических методов с помощью данной функции, деактивации этих слотов путем разрыва соединения, а также для уничтожения объекта отслеживания.
Хотя библиотека glib и является потокобезопасной сама по себе, любые использующие библиотеку libsigc++ обертки из состава glibmm не являются таковыми. Таким образом, к примеру, вызовы методов для управления циклом обработки событий Glib::SignalIdle::connect(), Glib::SignalIO:connect(), Glib::SignalTimeout::connect(), Glib::SignalTimeout::connect_seconds, а также манипуляции с объектами соединений на основе класса sigc::connection, возвращаемыми в результате вызовов этих методов, должны осуществляться из одного потока, в рамках которого функционирует цикл обработки событий.
Варианты методов connect*_once(): Glib::SignalIdle::connect_once(), Glib::SignalTimeout::connect_once(), Glib::SignalTimeout::connect_seconds_once() являются потокобезопасными в любых случаях, когда слот не создается с помощью вызова метода sigc::mem_fun(), который представляет метод класса, унаследованного от класса отслеживания sigc::trackable. Эта ситуация аналогична ситуации с вызовом метода Glib::Threads::Thread::create(), описанной в пункте 4.

29.2. Использование класса обработчика событий Glib::Dispatcher

Слоты, соединенные с объектами сигналов на основе класса sigc::signal исполняются в потоке, в рамках которого осуществляется вызов метода emit() или используется operator()() по отношению к объекту сигнала. Объект обработчика событий на основе класса Glib::Dispatcher ведет себя отличным образом: соединенные слоты исполняются в том потоке, в котором объект обработчика событий был создан (в потоке, который должен содержать главный цикл обработки событий glib). В том случае, если объект обработчика событий создается в главном потоке обработки событий графического интерфейса (который также будет главным потоком приема событий), любой рабочий поток сможет с помощью него генерировать сигналы, причем все соединенные слоты будут безопасно исполнять функции gtkmm.

Также существует несколько правил безопасного использования потоков при работе с объектом обработчика событий на основе класса Glib::Dispatcher. Как упоминалось ранее, объект обработчика событий должен создаваться в потоке приема событий (потоке, с помощью главного цикла обработки событий которого будут исполняться соединенные слоты). Обычно это главный поток программы, хотя существует и конструктор класса Glib::Dispatcher, способный принимать объект контекста обработки событий на основе класса Glib::MainContext любого потока, который содержит главный цикл обработки событий. Только поток приема событий может вызывать метод connect() объекта обработчика событий на основе класса Glib::Dispatcher или производить манипуляции с любым связанным объектом соединения на основе класса sigc::connection при отсутствии дополнительного механизма синхронизации. Однако, любой рабочий поток может безопасно генерировать сигналы с помощью объекта обработчика событий на основе класса Glib::Dispatcher без использования любых механизмов блокировки после того, как поток приема событий подсоединит слоты при условии, что этот поток был создан перед запуском рабочего потока (в том случае, если он был создан после запуска рабочего потока, для гарантии видимости потребуются дополнительные механизмы синхронизации).

Помимо того, что соединенные слоты всегда исполняются в рамках потока приема событий, объекты обработчика событий на основе класса Glib::Dispatcher аналогичны объектам sigc::signal<void>. Следовательно, они не позволяют ни передать неограниченное количество аргументов, ни вернуть значение. Лучшим способом передачи неограниченного количества аргументов является потокобезопасная (асинхронная) очередь. Хотя на момент написания этой книги в составе glibmm не имеется реализации подобного механизма, большинство создающих код для работы с множеством потоков разработчиков должно располагать реализацией такой очереди (эти реализации создаются относительно просто, хотя иногда и возникают сложности при комбинировании механизмов безопасного использования потоков и механизмов строгой безопасности генерации исключений).

Сигналы с помощью объекта обработчика событий на основе класса Glib::Dispatcher могут генерироваться как из потока приема событий, так и из рабочих потоков, хотя это и должно делаться в разумных пределах. В Unix-подобных системах объекты обработчиков событий делят единственный неименованный канал, который в теории будет заполняться данными только в очень нагруженной системе при исполнении программы с очень большим количеством объектов обработчиков событий. В том случае, если канал заполнится данными перед тем, как как главный цикл обработки событий потока приема событий получит возможность прочитать из него все данные, а в рамках потока приема событий будет осуществлена попытка генерации нового сигнала с записью данных в канал в текущем состоянии, поток приема событий навсегда заблокируется на операции записи. При генерации событий из потока приема событий, конечно же, может использоваться и обычный объект sigc::signal<void>.

29.3. Пример

Это пример программы с двумя потоками, причем один поток используется для обработки событий графического пользовательского интерфейса, как и во всех программах на основе gtkmm, а второй является рабочим потоком. Рабочий поток создается в момент нажатия вами кнопки "Начать работу". Он уничтожается тогда, когда выполнение работы завершается, тогда, когда вы нажимаете кнопку "Закончить работу", а также тогда, когда вы нажимаете кнопку "Выход".

Объект обработчика событий на основе класса Glib::Dispatcher используется для отправки уведомлений из рабочего потока в поток обработки событий пользовательского интерфейса. Класс ExampleWorker содержит данные, которые доступны обоим потокам. Эти данные защищены с помощью объекта взаимного исключения на основе класса Glib::Threads::Mutex. Обновление состояния пользовательского интерфейса происходит исключительно из потока обработки событий пользовательского интерфейса.

Рисунок 29-1: Многопоточная программа

Исходный код

Файл: exampleworker.h (Для использования совместно с gtkmm 3, а не с gtkmm 2)

Файл: examplewindow.h (Для использования совместно с gtkmm 3, а не с gtkmm 2)

Файл: examplewindow.cc (Для использования совместно с gtkmm 3, а не с gtkmm 2)

#include "examplewindow.h"
#include <iostream>

ExampleWindow::ExampleWindow() :
  m_VBox(Gtk::ORIENTATION_VERTICAL, 5),
  m_ButtonBox(Gtk::ORIENTATION_HORIZONTAL),
  m_ButtonStart("Начать работу"),
  m_ButtonStop("Закончить работу"),
  m_ButtonQuit("_Выход", /* mnemonic= */ true),
  m_ProgressBar(),
  m_ScrolledWindow(),
  m_TextView(),
  m_Dispatcher(),
  m_Worker(),
  m_WorkerThread(0)
{
  set_title("Пример многопоточного приложения");
  set_border_width(5);
  set_default_size(300, 300);

add(m_VBox);

// Добавление индикатора степени выполнения задачи.
  m_VBox.pack_start(m_ProgressBar, Gtk::PACK_SHRINK);

m_ProgressBar.set_text("Ход выполнения задачи");
  m_ProgressBar.set_show_text();

// Добавление виджета поля ввода текста в окно прокрутки.
  m_ScrolledWindow.add(m_TextView);

// Показ полос прокрутки только тогда, когда они необходимы.
  m_ScrolledWindow.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);

m_VBox.pack_start(m_ScrolledWindow);

m_TextView.set_editable(false);

// Добавление кнопок в контейнер для кнопок.
  m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);

m_ButtonBox.pack_start(m_ButtonStart, Gtk::PACK_SHRINK);
  m_ButtonBox.pack_start(m_ButtonStop, Gtk::PACK_SHRINK);
  m_ButtonBox.pack_start(m_ButtonQuit, Gtk::PACK_SHRINK);
  m_ButtonBox.set_border_width(5);
  m_ButtonBox.set_spacing(5);
  m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);

// Установка обработчиков сигналов для кнопок.
  m_ButtonStart.signal_clicked().connect(sigc::mem_fun(*this, &ExampleWindow::on_start_button_clicked));
  m_ButtonStop.signal_clicked().connect(sigc::mem_fun(*this, &ExampleWindow::on_stop_button_clicked));
  m_ButtonQuit.signal_clicked().connect(sigc::mem_fun(*this, &ExampleWindow::on_quit_button_clicked));

// Установка обработчика сигналов для объекта обработчика событий.
  m_Dispatcher.connect(sigc::mem_fun(*this, &ExampleWindow::on_notification_from_worker_thread));

// Создание метки в текстовом буфере для использования функции update_widgets().
  Glib::RefPtr<Gtk::TextBuffer> buffer = m_TextView.get_buffer();
  buffer->create_mark("last_line", buffer->end(), /* left_gravity= */ true);

update_start_stop_buttons();

show_all_children();
}

void ExampleWindow::on_start_button_clicked()
{
  if (m_WorkerThread)
  {
    std::cout << "Невозможно запустить рабочий поток в момент исполнения другого рабочего потока." << std::endl;
  }
  else
  {
    // Запуск нового рабочего потока.
    m_WorkerThread = Glib::Threads::Thread::create(
      sigc::bind(sigc::mem_fun(m_Worker, &ExampleWorker::do_work), this));
  }
  update_start_stop_buttons();
}

void ExampleWindow::on_stop_button_clicked()
{
  if (!m_WorkerThread)
  {
    std::cout << "Невозможно остановить исполнение рабочего потока, так как ни один рабочий поток не исполняется." << std::endl;
  }
  else
  {
   // Запрос на остановку рабочего потока.
    m_Worker.stop_work();
    m_ButtonStop.set_sensitive(false);
  }
}

void ExampleWindow::update_start_stop_buttons()
{
  const bool thread_is_running = m_WorkerThread != 0;

m_ButtonStart.set_sensitive(!thread_is_running);
  m_ButtonStop.set_sensitive(thread_is_running);
}

void ExampleWindow::update_widgets()
{
  double fraction_done;
  Glib::ustring message_from_worker_thread;
  m_Worker.get_data(&fraction_done, &message_from_worker_thread);

m_ProgressBar.set_fraction(fraction_done);

if (message_from_worker_thread != m_TextView.get_buffer()->get_text())
  {
    Glib::RefPtr<Gtk::TextBuffer> buffer = m_TextView.get_buffer();
    buffer->set_text(message_from_worker_thread);

// Переход к последней добавленной в поле ввода текста строке. Это достаточно запутанная операция.
    Gtk::TextIter iter = buffer->end();
    iter.set_line_offset(0); // Начало последней добавленной строки
    Glib::RefPtr<Gtk::TextMark> mark = buffer->get_mark("last_line");
    buffer->move_mark(mark, iter);
    m_TextView.scroll_to(mark);
    // Метод TextView::scroll_to(iter) не является идеальным.
    // Нам нужна метка (TextMark) для того, чтобы всегда переходить к последней строке в поле ввода текста.
  }
}

void ExampleWindow::on_quit_button_clicked()
{
  if (m_WorkerThread)
  {
    // Запрос на остановку рабочего потока и ожидание его остановки.
    m_Worker.stop_work();
    m_WorkerThread->join();
  }
  hide();
}

// Метод notify() вызывается из метода ExampleWorker::do_work(). Он исполняется в рабочем
// потоке. С помощью него в потоке обработки событий пользовательского интерфейса 
// осуществляется вызов обработчика on_notification_from_worker_thread().
void ExampleWindow::notify()
{
  m_Dispatcher.emit();
}

void ExampleWindow::on_notification_from_worker_thread()
{
  if (m_WorkerThread && m_Worker.has_stopped())
  {
    // Работа завершена.
    m_WorkerThread->join();
    m_WorkerThread = 0;
    update_start_stop_buttons();
  }
  update_widgets();
}

Файл: main.cc (Для использования совместно с gtkmm 3, а не с gtkmm 2)

Файл: exampleworker.cc (Для использования совместно с gtkmm 3, а не с gtkmm 2)

#include "exampleworker.h"
#include "examplewindow.h"
#include <sstream>

ExampleWorker::ExampleWorker() :
  m_Mutex(),
  m_shall_stop(false),
  m_has_stopped(false),
  m_fraction_done(0.0),
  m_message()
{
}

// Доступ к этим данным синхронизируется с помощью примитива взаимного исключения.
// Несколько микросекунд могут быть сохранены благодаря чтению всех данных, вместо 
// использования отдельных методов get_fraction_done() и get_message().
void ExampleWorker::get_data(double* fraction_done, Glib::ustring* message) const
{
  Glib::Threads::Mutex::Lock lock(m_Mutex);

if (fraction_done)
    *fraction_done = m_fraction_done;

if (message)
    *message = m_message;
}

void ExampleWorker::stop_work()
{
  Glib::Threads::Mutex::Lock lock(m_Mutex);
  m_shall_stop = true;
}

bool ExampleWorker::has_stopped() const
{
  Glib::Threads::Mutex::Lock lock(m_Mutex);
  return m_has_stopped;
}

void ExampleWorker::do_work(ExampleWindow* caller)
{
  {
    Glib::Threads::Mutex::Lock lock(m_Mutex);
    m_has_stopped = false;
    m_fraction_done = 0.0;
    m_message = "";
  } // Примитив взаимного исключения разблокируется благодаря деструктору.

// Симуляция длительного расчета.
  for (int i = 0; ; ++i) // выполнение до момента прерывания
  {
    Glib::usleep(250000); // микросекунды

Glib::Threads::Mutex::Lock lock(m_Mutex);

m_fraction_done += 0.01;

if (i % 4 == 3)
    {
      std::ostringstream ostr;
      ostr << (m_fraction_done * 100.0) << "% выполнено\n";
      m_message += ostr.str();
    }

if (m_fraction_done >= 1.0)
    {
      m_message += "Завершено";
      break;
    }
    if (m_shall_stop)
    {
      m_message += "Остановлено";
      break;
    }
    lock.release();
    caller->notify();
  }

Glib::Threads::Mutex::Lock lock(m_Mutex);
  m_shall_stop = false;
  m_has_stopped = true;
  lock.release();
  caller->notify();
}

Эти взаимодействия происходят из-за того, что, помимо других вещей, наследуемый от класса отслеживания sigc::trackable класс благодаря механизму наследования будет содержать объект типа std::list, с помощью которого будут отслеживаться слоты, созданные с помощью вызовов метода sigc::mem_fun() и представляющие любые из нестатических методов (точнее, он содержит список методов обратного вызова, который позволяет отсоединить соединенные слоты при уничтожении объекта). Каждый объект слота на основе класса sigc::slot также сохраняет с помощью объектов на основе класса sigc::slot_rep собственный объект отслеживания на основе класса sigc::trackable для отслеживания любых объектов соединений на основе класса sigc::connection, которые необходимы для выполнения операции его уничтожения, а также позволяют разорвать соединение с объектом отслеживания на основе класса sigc::trackable при отсоединении или при уничтожении. Объекты сигналов на основе класса sigc::signal также содержат список слотов, который будет обновляться при вызове их метода connect() или при вызове методов любого объекта соединения на основе класса sigc::connection, связанного с таким соединением.

Следующий раздел : Рекомендуемые техники.