Материал из Wiki.crossplatform.ru

Внимание: Актуальная версия перевода документации находится здесь

__NOTOC__

Поддержка потоков в Qt

Qt предоставляет поддержку потоков в виде платформенно-независимых потоковых классов, потокобезопасного способа посылки сообщений и возможности установки соединений сигнал-слот через границы потоков. Это облегчает создание портируемых многопроцессорных приложений и использование преимуществ многопроцессорных машин. Мультипоточное программирование также полезная парадигма для выполнения занимающих продолжительное время действий без замораживания пользовательского интерфейса.

Более ранние версии Qt предлагали возможность постройки библиотеки без поддержки потоков. Начиная с Qt 4.0 потоки всегда доступны.

Данный документ предназначен для аудитории имеющей знания и опыт работы с многопоточными приложениями. Если вы плохо знакомы с потоками, см. наш Список рекомендованной литературы.

Темы:

• Потоковые классы
  • Создание потока
  • Синхронизация потоков
• Монопоточность и потоковая безопасность
• Потоки и объекты QObject
  • Монопоточные QObject
  • Цикл обработки сообщений потока
  • Вызов подклассов QObject из других потоков
  • Соединение Сигналов и слотов между потоками
• Потоки и неявное совместное использование данных
• Потоки и модуль SQL
• Рекомендуемая литература

Потоковые классы

Qt включает следующие потоковые классы:

• QThread предоставляет средства для создания нового потока.
• QThreadStorage обеспечивает хранение данных потока.
• QMutex обеспечивает защиту от взаимных блокоровок - мьютекс.
• QMutexLocker предсоставлен для удобства, автоматически блокирует и разблокирует QMutex.
• QReadWriteLock обеспечивает блокировку, позволяющую одновременное чтение.
• QReadLocker и QWriteLocker предоставлены для удобства, автоматически блокирует и разблокирует QReadWriteLock.
• QSemaphore предоставляет целочисленный семафор (обобщенный мьютекс).
• QWaitCondition предоставляет реализацию потока, который дремлет, пока не пробужен другим потоком.

Создание потока

Для создания потока, определите подкласс QThread и заново реализуйте его функцию run(). Например:

    class MyThread : public QThread
    {
        Q_OBJECT
 
    protected:
        void run();
    };
 
    void MyThread::run()
    {
        ...
    }

Затем, создайте экземпляр объекта вашего потокового класса и вызовите QThread::start(). Код, который содержится в Вашей реализации функции run() будет выполнен в отдельном потоке. Создание потока подробно объясняется в документации QThread.

Обратите внимание, что QCoreApplication::exec() всегда должен вызываться из главного потока (потока, в котором выполняется main()), а не из QThread. В приложениях с GUI главный поток также назвается потоком GUI thread, потому, что только ему разрешается выполнять какие-либо действия, связанные с GUI.

Кроме того, до создания объектов QThread, вы должны создать объект QApplication (или QCoreApplication).

Синхронизация потоков

Классы QMutex, QReadWriteLock, QSemaphore и QWaitCondition предоставляют средства синхронизации потоков. Хотя, как основная идея потоков состоит в том, чтобы сделать потоки настолько параллельными, насколько это возможно, бывают моменты, когда поток должет остановить выполнение текущих операций и подождать другие потоки.Например, если два потока одновременно пытаются получить доступ к одной глобальной переменной, то результат, обычно, не определен.

QMutex предоставляет взаимноисключающую блокировку или мьютекс. В одно и то-же время не больше одного потока может блокировать мьютекс. Если поток пытается заблокировать мьютекс в то время, как он уже заблокирован, то поток переходит в режим ожидания пока заблокировавший мютекс поток не освободит его (мьютекс). Мьютексы часто используются для защиты доступа к разделенным данным (т.е. данным, к которым можно обратиться от нескольких потоков одновременно). В разделе Однопоточность и Потоковая Безопасность ниже, мы используем мьютексы для создания потокобезопасного класса.

QReadWriteLock подобен QMutex, за исключением того, что делает различие между доступом к данным для "чтения" и "записи" и позволяет нескольким читателям одновременно обращаться к данным. По возможности используя QReadWriteLock вместо QMutex можно сделать многопоточную программу более параллельными.

QSemaphore - это обобщение для QMutex которое защищает некоторое количество идентичных ресурсов. В отличие от мьютекса, защищающего один ресурс. Пример в описании Семафоров показывает типичное использование семафоров: синхронизированние доступа производителя и потребителя к кольцевому буферу.

QWaitCondition позволяет потоку пробуждать другие потоки при выполнении некоторого условия. Один или несколько потоков могут быть заблокированы в ожидании выполнения QWaitCondition установленного в состояние wakeOne() или wakeAll(). При использовании wakeOne() потоки пробуждаются при выполнении одного из нужных условий, а wakeAll() требует выполнения всех условий. Пример Условие Ожидания показывает как решить проблему производитель-потребитель используя QWaitCondition вместо QSemaphore.

Монопоточность и потоковая безопасность

Везде в документации Qt, термины межпоточность и потоковая безопасность для определения того, как функции могут использоваться в многопоточных приложениях:

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

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

Обратите внимание, что терминология в данной области еще не стандартизирована. POSIX использует несколько отличные определения межпоточности и потокобезопасности в своих API C. Когда имеешь дело с объектно-ориентированной библиотекой классов C++, такой как Qt, определения должны быть адаптированы.

Большинство классов-наследников классов C++ являются межпоточными, поскольку обычно они работают с данными членов класса. Любой поток может вызвать функцию-член экземпляра класса пока другой поток не вызывает функцию-член того-же самого экземпляра класса. Например, класс Counter показанный ниже является межпоточным:

    class Counter
    {
    public:
        Counter() { n = 0; }
 
        void increment() { ++n; }
        void decrement() { --n; }
        int value() const { return n; }
 
    private:
        int n;
    };

Данный класс не является потокобезопасным, поскольку если несколько потоков попытаются изменить член n, результат будет неопределен. Это так, потому что операторы C++ ++ и -- не всегда атомарны. В действительности они обычно расширяются до трех машинных инструкций:

1. Загрузка значения переменной в регистр.
2. Увеличение или уменьшение значения регистра.
3. Сохранение значения регистра обратно в основную память.

Потоки A и B одновременно могут загрузить старое значение переменной, увеличить ее значение в регистре и сохранить значение переменной в памяти, но переменная будет увеличена только однажны!

Становится ясно, что обращения должны быть упорядочены: Поток A должен выполнить шаги 1, 2, 3 без прерывания (автоматического) прежде, чем поток B сможет выполнить теже шаги; или наоборот. Самый легкий способ создания потокобезопасного класса состоит в том, чтобы защитить весь доступ к членам с помощью QMutex:

    class Counter
    {
    public:
        Counter() { n = 0; }
 
        void increment() { QMutexLocker locker(&mutex); ++n; }
        void decrement() { QMutexLocker locker(&mutex); --n; }
        int value() const { QMutexLocker locker(&mutex); return n; }
 
    private:
        mutable QMutex mutex;
        int n;
    };

Класс QMutexLocker автоматически запирает мьютекс в своем конструкторе и отпирает его в деструкторе, вызываемом при завершении функции. Запирание мьютекса гарантирует, что обращения из разных потоков будут упорядочены. Член mutex объявлен как mutable потому, что позволяет запереть и отпереть мьютекс в функции value(), которая является константной.

Большинство классов Qt сделаны межпоточными и не потокобезопасными для того, чтобы избежать многократного запирания и отпирания QMutex. Например, класс QString является межпоточным, что означает, что вы можете использовать его в различных потоках, но вы не можете получить доступ к одному и тому-же объекту QString одновременно из различных потоков (если вы самостоятельно не защищаете его с помощью мьютекса). Несколько классов и функций являются потокобезопасными; они, главным образом, связаны с потоковыми классами, такими как QMutex, или фундаментальными функциями, такими как QCoreApplication::postEvent().

Потоки и объекты QObject

QThread наследует QObject. Он испускает сигналы, сообщающие о том, что поток начал или закончил работу, а также предоставляет несколько слотов.

Очень интересно использование QObject в многопоточном приложении, он испускает сигналы, приходящие в слоты, находящиеся в других потоках, и посылает сообщения объектам "живущим" в других потоках. Это возможно потому, что каждый поток имеет собственный цикл обработки сообщений.

Монопоточность QObject

QObject монопоточен. Большинство из его не-GUI подклассов, таких как QTimer, QTcpSocket, QUdpSocket, QHttp, QFtp и QProcess, также межпоточны. Их возможно использовать из нескольких потоков одновременно. Вы должны знать о двух ограничениях:

• Дочерние по отношению к QObject объекты должны создаваться с том же потоке, что и родитель. Это подразумевает, помимо прочего, что вы никогда не должны передавать объект QThread (this) как родитель объекта, созданного в своем потоке (так как объект QThread сам создан в другом потоке).
• Вы должны заботиться о том, чтобы все объекты, созданные в потоке, были разрушены прежде, чем будет разрушен объект QThread. Это легко можно сделать создавая объекты в стеке в Вашей реализации run().

Несмотря на то, что QObject межпоточен, классы GUI, особенно QWidget и все его подклассы, не межпоточны. Они могут использоваться только в главном потоке. Как отмечено выше, QCoreApplication::exec() также может вызываться из главного потока.

На практике невозможно использовать классы GUI в других потоках, кроме главного, но можен легко поместить выполнение продолжительных действий в отдельный поток и отображать на экране результаты выполнения средствами главного потока по окончании обработки. Такой подход используется в примерах Mandelbrot и Blocking Fortune Client.

Цикл обработки сообщений потока

Каждый поток может иметь собственный цикл обработки сообщений. Главный поток начинает цикл обработки сообщений используя QCoreApplication::exec(); другие потоки могут начать свои циклы обработки сообщений используя QThread::exec(). Подобно QCoreApplication, QThread предоставляет функцию exit(int) и слот quit().

Цикл обработки сообщений сделан возможным для потока, чтобы можно было использовать некоторые не-GUI классы Qt которые требуют наличия цикла обработки сообщений (такие как QTimer, QTcpSocket и QProcess). Это также доет возможность соединить сигналы из любых потоков со слотами в определенном потоке. В разделе Соединение Сигналов и Слотов Между Потоками это описано подробнее.

Файл:Images/threadsandobjects.png

Экземпляр QObject считается живущим в потоке, в котором был создан. Сообщения этому объекту пересылаются циклом обработки сообщений потока. Поток в котором живет QObject может быть получен с помощью QObject::thread().

Вызов delete для объекта QObject (и вообще обращение к объекту) из потока, отличного от того, в котором он был создан может быть опасен, если нельзя быть уверенным, что объект не обрабатывает другие сообщения в этот момент. Вместо этого используйте QObject::deleteLater(); объекту будет послано сообщение DeferredDelete, которое, в конце концов, будет обработано циклом обработки сообщений данного объекта.

Если никакой цикл обработки сообщений не запущен, то сообщения не будут доставлены объекту. Например, если вы создаете объект QTimer в потоке, который никогда не вызывает exec(), то QTimer никогда не испустит сигнал timeout(). Вызов deleteLater() также не сработает. (Это также относится к главному потоку.)

Вы можете вручную послать сообщение любому объекту в любом потоке используя потокобезопасную функцию QCoreApplication::postEvent(). Сообщения будут автоматически посланы циклу обработки сообщений потока, в котором объект был создан.

Фильтры сообщений поддерживаются во всех потоках, с условием, что контролируемый объект должен располагаться в том-же потоке, что и контролирующий объект. Также QCoreApplication::sendEvent() (в отличие от postEvent()) может использоваться только для посылки сообщений живущим в том-же потоке, что и посылающая сообщения функции.

Вызов подклассов QObject из других потоков

QObject и все его подклассы не потокобезопасны. Это влияет на всю систему доставки сообщений. Важно помнить, что цикл обработки сообщений может доставлять сообщения Вашему подклассу QObject в то время, как вы обращаетесь к объекту из другого потока.

Если Вы вызываете функции подкласса QObject не живущего в текущем потоке, и объект может получать сообщения, то вы должны защитить все обращения к данным Вашего подкласса QObject с помощью мьютекса; в противном случае вы можете получить крах программы или другое неожиданное поведение.

Подобно другим объектам, объект QThread живет в потоке, в котором он был создан, а не в потоке, который создан при вызове QThread::run(). Вообще, опасно иметь слоты в Вашем подклассе QThread, если вы не защищаете переменные-члены с помощью мьютекс.

С другой стороны, Вы можете спокойно испускать сигналы Вашей реализацией QThread::run(), потому, что испускание сигналов потокобезопасно.

Связь сигналов и слотов между потоками

Qt поддерживает два типа соединений сигнал-слот:

• C прямыми связями - слот выполняется немедленно после испускания сигнала. Слот выполняется в потоке, испустившем сигнал (который не обязательно является потоком, в котором живет объект).
• С постановкой сигналов в очередь - слот выполняется, когда управление возвращается циклу обработки сообщений потока, которому принадлежит объект. Слот выполняется в потоке, в котором проживает объект-приемник.

По умолчанию QObject::connect() устанавливает прямую связь, если отправитель и получатель принадлежат одному потоку, и связь с постановкой в очередь, если отправитель и получатель принадлежат различным потокам. Это можно изменить, передав дополнительный аргумент в connect(). Помните, что использование прямых связей, когда отправитель и получатель проживают в разных потоках опасно в случае, если цикл обработки сообщений выполняется в потоке, где живет приемник, по той-же самой причине, по которой небезопасен вызов функций объекта, принадлежащего другому потоку.

QObject::connect() само по себе потокобезопасно.

В примере Mandelbrot используется соединение с постановкой в очередь для установки связи между рабочим и основным потоками. Для того, чтобы избежать заморозки цикла обработки сообщений основного потока (и, как следствие, заморозки пользовательского интерфейса приложения), все рекурсивные вычисления фрактала в Mandelbrot выполняются в отдельно потоке. Это поток испускает сигнал после вычислений, который рисует фрактал.

Точно также, в примере Blocking Fortune Client используется отдельный поток для асинхронной связи с TCP-сервером.

Потоки и неявное совместное использование данных

Qt использует оптимизацию, называемую неявным совместным использованием данных для многих своих классов, особенно QImage и QString. Многие считеют, что неявное совместное использование данных и много поточность - несовместимые концепции из-за способа, которым обычно выполняется подсчет ссылок. Одно из решений состоит в том, чтобы защитить внутренний счетчик ссылок с помощью мьютекса, но это очень медленно. Более ранние версии Qt не предоставляли удовленворительного решения этой проблемы.

Начиная с Qt 4, классы использующие неявное совместное использование данных могут быть безопасно скопированы между потоками подобно любым другим классам. Они полностью межпоточны. Неявное совместное использование данных действительно неявно. Это реализовано с использованием атомарных действий подсчета ссылок на ассемблере для различных платформ, поддерживаемых Qt. Атомарный подсчет ссылок очень быстр, намного быстрее, чем использование мьютекса.

Но напоминаем, если вы получаете доступ к одному и тому-же объекту из нескольких потоков (в отличие от копий одного и того-же объекта), вы все еще должны использовать мьютекс для упорядочивания доступа к объекту так-же как и при работе с любым межпоточным классом.

Резюмируя скажем, что неявное совместное использование данных в Qt 4 действительно неявное разделение. Даже в многопоточных приложениях вы можете благополучно применять классы, использующие неявное разделение данных, так, будто это простые межпоточные классы.

Потоки и модуль SQL

Соединение может использоваться только внутри создавшего его потока. Перемещение соединений между потоками и создание запросов в другой поток не поддерживается.

Кроме того, библиотеки третьих лиц, используемые драйверами QSqlDriver могут наложить дополнительные ограничения на использование Модуля SQL в многопоточной программе. За дополнительной информацией обращайтесь к создателю клиента базы данных.

Рекомендуемая литература

• Threads Primer: A Guide to Multithreaded Programming
• Thread Time: The Multithreaded Programming Guide
• Pthreads Programming: A POSIX Standard for Better Multiprocessing
• Win32 Multithreaded Programming