C++ STL & Qt. Занятие 08.

Темы лекции: Многопоточность в Qt.
Практическое задание: Многопоточность в Qt.
Тренер: Игорь Шкулипа, к.т.н.
С++ Библиотеки STL и Qt. Занятие 8

http://www.slideshare.net/IgorShkulipa 2
Object Pool
Применение паттерна Object Pool может значительно повысить
производительность системы; его использование наиболее
эффективно в ситуациях, когда создание экземпляров
некоторого класса требует больших затрат, объекты в системе
создаются часто, но число создаваемых объектов в единицу
времени ограничено.
Пулы объектов (известны также как пулы ресурсов)
используются для управления кэшированием объектов.
Клиент, имеющий доступ к пулу объектов может избежать
создания новых объектов, просто запрашивая в пуле уже
созданный экземпляр. Пул объектов может быть растущим,
когда при отсутствии свободных создаются новые объекты или
c ограничением количества создаваемых объектов.

Реализация Object Pool на основе Singleton. Классы
объектов
class IObject {
protected:
string _strText;
public:
virtual void Print() {
cout<<"The Object is: "<<_strText.c_str()<<"n";
} };
class Object1: public IObject {
public:
Object1(){
_strText="Object 1";
} };
public:
Object2(){
} };
public:
Object3(){
} };
public:
Object4(){
} };

Object Pool
template<unsigned poolSize> class ObjectPool{
public:
static ObjectPool* GetInstance() {
if (!_instance) _instance=new ObjectPool();
return _instance;
}
IObject* GetObject() {
for (unsigned i=0;i<poolSize;i++)
{ if (!_busyObjects[i]){
_busyObjects[i]=true;
return _objectPool[i];
} }
return NULL;
}
void ReleaseObject(IObject* object){
{ if (_objectPool[i]==object){
_busyObjects[i]=false;
} }
}
...

Object Pool
...
private:
ObjectPool(){
{
unsigned iObjNumber=rand()%4;
switch (iObjNumber)
{
case 0: _objectPool[i]=new Object1(); break;
}
_busyObjects[i]=false;
}
}
private:
IObject* _objectPool[poolSize];
bool _busyObjects[poolSize];
static ObjectPool* _instance;
};

Использование Object Pool
template<unsigned poolSize>
ObjectPool<poolSize>* ObjectPool<poolSize>::_instance=NULL;
int main()
{
ObjectPool<5>* op=ObjectPool<5>::GetInstance();
IObject* object1=op->GetObject();
if (object1) object1->Print(); else cout<<"The Object is: NULLn";
op->ReleaseObject(object2);
}

Результат
The Object is: Object 2
The Object is: NULL
The Object is: NULL

Преимущества и недостатки
◦ Пул объектов отслеживает объекты, которые он создает.
◦ Паттерн Object Pool может использоваться для инкапсуляции
логики создания объектов. Однако он не управляет ими
после их создания.
◦ Достоинством этого паттерна является быстрое создание
объектов, однако это реализовано за счет использования
больших ресурсов памяти.

Процессы и потоки
Процессы представляют собой программы, независимые друг от друга и
загруженные для исполнения. Каждый процесс должен создавать хотя
бы один поток, называемый основным. Основной поток процесса
создается в момент запуска программы. Однако сам процесс может
создавать несколько потоков одновременно.
Многопоточность позволяет разделять задачи и независимо работать над
каждой из них для того, чтобы максимально эффективно
задействовать процессор. Написание многопоточных приложений
требует больше времени и усложняет процесс отладки, поэтому
многопоточность нужно применять тогда, когда это действительно
необходимо.
Многопоточность удобно использовать для того, чтобы блокировка или
зависание одного из методов не стали причиной нарушения
функционирования основной программы.

QProcess
Процесс — это экземпляр программы, загруженной в память компьютера
для выполнения.
Создание процесса может оказаться полезным для использования
функциональных возможностей программ, не имеющих графического
интерфейса и работающих с командной строкой. Другое полезное
свойство — довольно простой запуск других программ из текущей
программы.
Процессы можно создавать с помощью класса QProcess, который
определен в заголовочном файле QProcess. Благодаря тому, что этот
класс унаследован от класса QIODevice, объекты этого класса в
состоянии считывать информацию, выводимую запущенными
процессами, и даже подтверждать их запросы на ввод информации.
Этот класс содержит методы для манипулирования системными
переменными процесса.
Работа с объектами класса QProcess производится в асинхронном
режиме, что позволяет сохранять работоспособность графического
интерфейса программы в моменты, когда запущенные процессы
находятся в работе.

QThread
Для использования многопоточности можно унаследовать класс от QThread и
перезаписать метод run(), в который должен быть помещен код для исполнения
в потоке. Чтобы запустить поток, нужно вызвать метод start().
class CustomThread : public QThread
{
public:
CustomThread();
void setMessage(const QString &message);
void run() {/*Действия потока*/};
void stop();
private:
QString messageStr;
volatile bool stopped;
};
//...
int main(int argc, char** argv)
{
CustomThread thread;
thread.start();
}

Приоритет потоков
У каждого потока есть приоритет, указывающий процессору, как должно протекать
выполнение потока по отношению к другим потокам. Приоритеты разделяются
по группам:
• в первую входят четыре наиболее часто применяемых приоритета. Их
значимость распределяется по возрастанию — IdlePriority, LowestPriority,
LowPriority, NormaiPriority. Они подходят для решения задач, которым
процессор требуется только время от времени, например, для фоновой
печати или для каких-нибудь несрочных действий;
• во вторую группу входят два приоритета — HighPriority, HighestPriority.
Пользуйтесь такими приоритетами с большой осторожностью. Обычно эти
потоки большую часть времени ожидают какие-либо события;
• в третью входят два приоритета — TimeCriticalPriority, InheritPriority.
Потоки с этими приоритетами нужно создавать в случаях крайней
необходимости. Эти приоритеты нужны для программ, напрямую
общающихся с аппаратурой или выполняющих операции, которые ни в коем
случае не должны прерваться.
Для того чтобы запустить поток с нужным приоритетом, необходимо передать одно
из приведенных выше значений в метод start(). Например:
CustomThread thread;
thread.start(QThread::IdlePriority);

Синхронизация
Основные сложности возникают тогда, когда потокам нужно совместно
использовать одни и те же данные. Так как несколько потоков могут
одновременно обращаться и записывать данные в одну область, то это
может привести к нежелательным последствиям.
Синхронизация позволяет задавать критические секции (critical
sections), к которым в определенный момент имеет доступ только один
из потоков. Это гарантирует то, что данные ресурса, контролируемые
критической секцией, будут невидимы другими потоками и они не
изменят их. И только после того, как поток выполнит всю
необходимую работу, он освобождает ресурс, и, затем, доступ к этому
ресурсу может получить любой другой поток.
Например, если один поток записывает информацию в файл, то все
другие не смогут использовать этот файл до тех пор, пока поток не
освободит его.

Объекты синхронизации Mutex
Мьютексы (mutex) обеспечивают взаимоисключающий доступ к ресурсам,
гарантирующий то, что критическая секция будет обрабатываться только одним
потоком. Поток, владеющий мьютексом, обладает эксклюзивным правом на
использование ресурса, защищенного мьютексом, и другой поток не может
завладеть уже занятым мьютексом.
Механизм мьютексов реализован классом QMutex. Метод lock() класса QMutex
производит блокировку ресурса. Для обратной операции существует метод
unlock(), который открывает закрытый ресурс для других потоков.
Класс QMutex также содержит метод tryLock(). Этот метод можно использовать для
того, чтобы проверить, заблокирован ресурс или нет. Этот метод не
приостанавливает исполнение потока и возвращается немедленно, со значением
false, если ресурс уже захвачен другим потоком, и не ожидает его
освобождения. В случае успешного захвата ресурса этот метод вернет true.
В сложных функциях, особенно при использовании исключений C++, легко можно
ошибиться при выполнении последовательностей операций по
запиранию/отпиранию мьютексов. Поэтому, в состав Qt включен класс
QMutexLocker, который значительно упрощает работу с мьютексами.
Конструктор класса QMutexLocker принимает объект QMutex в виде
аргумента и запирает его. Деструктор класса QMutexLocker - отпирает
мьютекс.

Пример «Потокобезопасный стек»
template <class Type>
class ThreadSafeStack
{
public:
void push(const Type& val)
{
mutex.lock();
stack.push(val);
mutex.unlock();
}
Type pop()
{
QMutexLocker locker (&mutex);
return stack.empty() ? Type() : stack.pop();
}
private:
QMutex mutex;
QStack<Type> stack;
};

QWaitCondition
Библиотека Qt предоставляет класс QWaitCondition, обеспечивающий
возможность координации потоков.
Если поток намеревается дождаться разблокировки ресурса, то он
вызывает метод QWaitCondition::wait() и, тем самым, входит в
режим ожидания. Выводится он из этого режима в том случае, если
поток, который заблокировал ресурс, вызовет метод
QWaitCondition::wakeOne() или QWaitCondition::wakeAll().
Разница этих двух методов в том, что первый выводит из состояния
ожидания только один поток, а второй — все сразу. Также для потока
можно установить время, в течение которого он может ожидать
разблокировки данных. Для этого нужно передать в метод wait()
целочисленное значение, обозначающее временной интервал в
миллисекундах.

Семафоры
Семафоры являются обобщением мьютексов. Как и мьютексы, они
служат для защиты критических секций, чтобы доступ к ним
одновременно могло иметь определенное число потоков. Все другие
потоки обязаны ждать.
Предположим, что программа поддерживает пять ресурсов одного и того
же типа, одновременный доступ к которым может быть предоставлен
только пяти потокам. Как только все пять ресурсов будут
заблокированы, следующий поток, запрашивающий ресурс данного
типа, будет приостановлен до освобождения одного из них.
Принцип действия семафоров очень прост. Они начинают действовать с
установленного значения счетчика. Каждый раз, когда поток получает
право на владение ресурсом, значение этого счетчика уменьшается на
единицу. И наоборот, когда поток уступает право владения этим
ресурсом, счетчик увеличивается на единицу. При значении счетчика
равном нулю семафор становится недоступным. Механизм семафоров
реализует класс QSemaphore. Счетчик устанавливается в
конструкторе при создании объекта этого класса.

Взаимная блокировка
При работе с многопоточностью, возможна
такая ситуация, когда поток
заблокировал ресурс А, а после
работы над ним собирается работать с
ресурсом В. Другой же поток
заблокировал ресурс В и по окончании
намеревается работать с ресурсом А. И
вот один из потоков, закончив работу,
обнаружил, что нужный ему ресурс
заблокирован другим потоком. Он
переходит в режим ожидания, надеясь
дождаться разблокировки ресурса, но
то же самое делает и другой поток.
В итоге — оба ждут друг друга. Если ни один из этих потоков не освободит занятый
им ресурс, то оба "зависнут" и не смогут продолжать свою работу дальше.
Это явление получило название взаимной блокировки (deadlock).
Существует множество решений такой проблемы. Например, можно так организовать
работу потока, чтобы, в том случае, если поток не сможет получить доступ к
необходимому ресурсу, он просто произвел бы освобождение занятых им
ресурсов, а позже повторил попытку захвата необходимых ресурсов.

Обмен сообщениями между потоками
Один из важнейших вопросов при многопоточном программировании —
это обмен сообщениями.
Каждый поток может иметь свой собственный цикл событий. Благодаря
этому можно осуществлять связь между объектами. Такая связь может
производиться двумя способами: при помощи соединения сигналов и
слотов или обмена событиями.
Класс QObject реализован так, что обладает близостью к потокам.
Каждый объект, произведенный от унаследованного от QObject
класса, располагает ссылкой на поток, в котором он был создан. Эту
ссылку можно получить вызовом метода QObject::thread(). Потоки
осведомляют свои объекты. Благодаря этому каждый объект знает, к
какому потоку он принадлежит.
Обработка событий производится из контекста принадлежности объекта к
потоку, то есть обработка его событий будет производиться в том
потоке, которому объект принадлежит. Объекты можно перемещать из
одного потока в другой с помощью метода
QObject::moveToThread().

Отправка событий
Отправка событий — это еще одна из возможностей для осуществления
связи между объектами. Есть два метода для высылки событий -
QCoreApplication::postEvent() и QCoreApplication::sendEvent().
Для того чтобы объект потока был в состоянии обрабатывать получаемые
события, в классе потока нужно реализовать метод QObject::event().
Если поток предназначен исключительно для отправки событий, а не для
их получения, то реализацию методов обработки событий и запуск
цикла обработки событий можно опустить.

Сигналы и слоты
Можно взять сигнал объекта одного потока и соединить его со слотом
объекта другого потока. Как мы уже знаем, соединение с помощью
метода connect() предоставляет дополнительный параметр,
обозначающий режим обработки и равный, по умолчанию, значению
Qt::AutoConnection, которое соответствует автоматическому режиму.
Как только происходит высылка сигнала, Qt проверяет — происходит
связь в одном и том же или разных потоках. Если это один и тот же
поток, то высылка сигнала приведет к прямому вызову метода. В том
случае, если это разные потоки, сигнал будет преобразован в событие
и доставлен нужному объекту.
Сигналы и слоты в Qt реализованы с механизмом надежности работы в
потоках, а это означает, что вы можете высылать сигналы и получать,
не заботясь о блокировке ресурсов.

Пример «Спам-бот». См. Занятие №8.
#ifndef SPAMBOT_H
#define SPAMBOT_H
#include <QObject>
#include <QString>
#include <QTime>
#include "chatmessage.h"
class SpamBot: public QObject
{
Q_OBJECT
public:
SpamBot();
void stop();
void run();
public slots:
void handleRun();
signals:
void sendSpam();
private:
volatile bool stopped;
};
#endif // SPAMBOT_H

Реализация класса
#include "spambot.h"
SpamBot::SpamBot() {
stopped=false;
}
void SpamBot::stop() {
stopped=true;
}
void SpamBot::run() {
while(!stopped)
{
QTime endTime= QTime::currentTime().addSecs(3);
while( QTime::currentTime() < endTime )
{
//Waiting...
}
emit sendSpam();
}
}
void SpamBot::handleRun() {
this->run();
}

Дополненный презентер
class ChatClientPresenter: public QObject
{
Q_OBJECT
public:
ChatClientPresenter(ChatClient* cl, IView* v);
ChatClientPresenter(IView* v);
void emitRunBot()
{
emit runBot();
}
signals:
void runBot();
private slots:
void DisplayMessage();
void SendMessage();
void SendMessageSpam();
private:
ChatClient* client;
IView* view;
};
void ChatClientPresenter::SendMessageSpam()
{
ChatMessage message("SpamBot","Spam");
client->sendToServer(message);
}

Функция main
#include <QtGui/QApplication>
#include "mainwindow.h"
#include "chatclientpresenter.h"
#include "spambot.h"
#include <QThread>
int main(int argc, char *argv[]) {
QApplication a(argc, argv);
MainWindow* view=new MainWindow();
ChatClientPresenter* present=new ChatClientPresenter(view);
view->show();
QThread *thread=new QThread();
SpamBot *spamBot=new SpamBot();
QObject::connect(spamBot, SIGNAL(sendSpam()),
present,SLOT(SendMessageSpam()),Qt::QueuedConnection);
QObject::connect(present, SIGNAL(runBot()),
spamBot, SLOT(handleRun()), Qt::QueuedConnection);
spamBot->moveToThread(thread);
thread->start();
present->emitRunBot();
return a.exec();
}

Результат

Лабораторная работа №8. Многопоточность
Создать в тетрисе дополнительный поток, который с определенной
периодичностью будет обновлять рейтинг пользователей на форме
(см. Лабораторную работу №5).

C++ STL & Qt. Занятие 08.

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to C++ STL & Qt. Занятие 08. (20)

More from Igor Shkulipa (20)

C++ STL & Qt. Занятие 08.