Жасмин Бланшет - QT 4: программирование GUI на С++
В многопоточном приложении графический пользовательский интерфейс выполняется в своем собственном потоке, а обработка осуществляется в одном или в нескольких других потоках. В результате такие приложения способны реагировать на действия пользователя даже при продолжительной обработке. Еще одним преимуществом многопоточной обработки является возможность в многопроцессорных системах одновременно выполнять несколько потоков на разных процессорах, увеличивая производительность.
В данной главе мы сначала продемонстрируем способы создания подкласса QThread и способы применения классов QMutex, QSemaphore и QWaitCondition для синхронизации потоков. Затем мы рассмотрим способы взаимодействия вторичных потоков с главным потоком в ходе цикла обработки событий. Наконец, мы завершим главу обзором классов Qt, объясняя, какие из них могут использоваться во вторичных потоках.
Многопоточная обработка представляет собой обширную тему, которой посвящается много книг. В данной главе предполагается, что вам уже известны принципы многопоточного программирования, поэтому основное внимание уделяется методам разработки многопоточных приложений средствами Qt, а не теме потоков выполнения в целом.
Создание потоков
Обеспечить многопоточную обработку в приложении Qt достаточно просто: мы только создаем подкласс QThread и переопределяем его функцию run(). Чтобы показать, как это работает, мы начнем с рассмотрения программного кода очень простого подкласса QThread, который периодически выводит на консоль заданный текст:
01 class Thread : public QThread
02 {
03 Q_OBJECT
04 public:
05 Thread();
06 void setMessage(const QString &message);
07 void stop();
08 protected:
09 void run();
10 private:
11 QString messageStr;
12 volatile bool stopped;
12 };
Класс Thread наследует QThread и переопределяет функцию run(). Он содержит две дополнительные функции: setMessage() и stop().
Переменная stopped объявляется со спецификатором volatile (изменчивый), поскольку доступ к ней осуществляется из разных потоков, и мы хотим быть уверенными, что всегда получаем ее обновленное значение. Если мы опустим ключевое слово volatile, компилятор может оптимизировать доступ к этой переменной, что, возможно, приведет к получению неправильного результата.
01 Thread::Thread()
02 {
03 stopped = false;
04 }
Мы устанавливаем в конструкторе переменную stopped на значение false.
01 void Thread::run()
02 {
03 while (!stopped)
04 cerr << qPrintable(messageStr);
05 stopped = false;
06 cerr << endl;
07 }
Функция run() вызывается для запуска потока. Пока переменная stopped имеет значение false, эта функция будет выводить на консоль заданное сообщение. Работа потока завершается, когда завершается функция run().
01 void Thread::stop()
02 {
03 stopped = true;
04 }
Функция stop() устанавливает переменную stopped на значение true, тем самым указывая функции run() на необходимость прекращения вывода текстовых сообщений на консоль. Данная функция может вызываться из любого потока в любое время. В нашем примере мы предполагаем, что присваивание значения переменной типа bool является атомарной операцией. Такое предположение является разумным, учитывая, что переменная типа bool может иметь только два состояния. Позже мы рассмотрим в данном разделе способы применения класса QMutex, гарантирующего атомарность операции присваивания значения переменной.
Класс QThread содержит функцию terminate(), которая прекращает выполнение потока, если он все еще не завершен. Функцию terminate() не рекомендуется применять, поскольку она может остановить поток в произвольной точке и не позволяет потоку выполнить очистку после себя. Всегда надежнее использовать переменную stopped и функцию stop(), как мы уже делали здесь.
Рис. 18.1. Приложение Threads.
Теперь мы рассмотрим способы применения класса Thread в небольшом приложении Qt, которое применяет два потока, А и В, не считая главный поток.
01 class ThreadDialog : public QDialog
02 {
03 Q_OBJECT
04 public:
05 ThreadDialog(QWidget *parent = 0);
06 protected:
07 void closeEvent(QCloseEvent *event);
08 private slots:
09 void startOrStopThreadA();
10 void startOrStopThreadB();
11 private:
12 Thread threadA;
13 Thread threadB;
14 QPushButton *threadAButton;
15 QPushButton *threadBButton;
16 QPushButton *quitButton;
17 };
В классе ThreadDialog объявляются две переменные типа Thread и несколько кнопок для обеспечения основных средств интерфейса пользователя.
01 ThreadDialog::ThreadDialog(QWidget *parent)
02 : QDialog(parent)
03 {
04 threadA.setMessage("А");
05 threadB.setMessage("B");
06 threadAButton = new QPushButton(tr("Start А"));
07 threadBButton = new QPushButton(tr("Start В"));
08 quitButton = new QPushButton(tr("Quit"));
09 quitButton->setDefault(true);
10 connect(threadAButton, SIGNAL(clicked()),
11 this, SLOT(startOrStopThreadA()));
12 connect(threadBButton, SIGNAL(clicked()),
13 this, SLOT(startOrStopThreadB()));
14 …
15 }
В конструкторе мы вызываем функцию setMessage() для периодического вывода на экран первым потоком буквы «А» и вторым потоком буквы «В».
01 void ThreadDialog::startOrStopThreadA()
02 {
03 if (threadA.isRunning()) {
04 threadA.stop();
05 threadAButton->setText(tr("Start А"));
06 } else {
07 threadA.start();
08 threadAButton->setText(tr("Stop А"));
09 }
10 }
Когда пользователь нажимает кнопку потока А, функция startOrStopThreadA() останавливает поток, если он выполняется, и запускает его в противном случае. Она также обновляет текст кнопки.
01 void ThreadDialog::startOrStopThreadB()
02 {
03 if (threadB.isRunning()) {
04 threadB.stop();
05 threadBButton->setText(tr("Start В"));
06 } else {
07 threadB.start();
08 threadBButton->setText(tr("Stop В"));
09 }
10 }
Программный код функции startOrStopThreadB() очень похож.
01 void ThreadDialog::closeEvent(QCloseEvent *event)
02 {
03 threadA.stop();
04 threadB.stop();
05 threadA.wait();
06 threadB.wait();
07 event->accept();
08 }
Если пользователь выбирает пункт меню Quit или закрывает окно, мы даем команду останова для каждого выполняющегося потока и ожидаем их завершения (используя функцию QThread::wait()) прежде, чем сделать вызов CloseEvent::accept(). Это обеспечивает аккуратный выход из приложения, хотя в данном случае это не имеет значения.
Если при выполнении приложения вы нажмете кнопку Start А, консоль заполнится буквами «А». Если вы нажмете кнопку Start В, консоль заполнится попеременно последовательностями букв «А» и «В». Нажмите кнопку Stop А, и тогда на экран будет выводиться только последовательность букв «В».
Синхронизация потоков
Обычным требованием для многопоточных приложений является синхронизация работы нескольких потоков. Для этого в Qt предусмотрены следующие классы: QMutex, QReadWriteLock, QSemaphore и QWaitCondition.
Класс QMutex обеспечивает такую защиту переменной или участка программного кода, что доступ к ним в каждый момент времени может осуществлять только один поток. Этот класс содержит функцию lock(), которая закрывает мьютекс (mutex). Если мьютекс открыт, текущий поток захватывает его и немедленно закрывает; в противном случае работа текущего потока блокируется до тех пор, пока захвативший мьютекс поток не освободит его. В любом случае после вызова lock() текущий поток будет держать мьютекс до вызова им функции unlock(). Класс QMutex содержит также функцию tryLock(), которая сразу же возвращает управление, если мьютекс уже закрыт.
Предположим, что нам нужно обеспечить защиту переменной stopped класса Thread из предыдущего раздела с помощью QMutex. Тогда мы бы добавили к классу Thread следующую переменную—член:
private:
QMutex mutex;
…
