Вот один пример как правильно использовать QThread, но с ним есть некоторые проблемы, которые отражены в комментариях. В частности, поскольку порядок выполнения слотов строго не определен, это может привести к различным проблемам. Комментарий, опубликованный 6 августа 2013 г., дает хорошее представление о том, как решить эту проблему. Я использую что-то подобное в своей программе, и вот пример кода для пояснения.
Основная идея та же: я создаю экземпляр QThread, который живет в моем основном потоке, экземпляр рабочего класса, который живет в новом созданном потоке, а затем подключаю все сигналы.
void ChildProcesses::start()
{
QThread *childrenWatcherThread = new QThread();
ChildrenWatcher *childrenWatcher = new ChildrenWatcher();
childrenWatcher->moveToThread(childrenWatcherThread);
// These three signals carry the "outcome" of the worker job.
connect(childrenWatcher, SIGNAL(exited(int, int)),
SLOT(onChildExited(int, int)));
connect(childrenWatcher, SIGNAL(signalled(int, int)),
SLOT(onChildSignalled(int, int)));
connect(childrenWatcher, SIGNAL(stateChanged(int)),
SLOT(onChildStateChanged(int)));
// Make the watcher watch when the thread starts:
connect(childrenWatcherThread, SIGNAL(started()),
childrenWatcher, SLOT(watch()));
// Make the watcher set its 'stop' flag when we're done.
// This is performed while the watch() method is still running,
// so we need to execute it concurrently from this thread,
// hence the Qt::DirectConnection. The stop() method is thread-safe
// (uses a mutex to set the flag).
connect(this, SIGNAL(stopped()),
childrenWatcher, SLOT(stop()), Qt::DirectConnection);
// Make the thread quit when the watcher self-destructs:
connect(childrenWatcher, SIGNAL(destroyed()),
childrenWatcherThread, SLOT(quit()));
// Make the thread self-destruct when it finishes,
// or rather, make the main thread delete it:
connect(childrenWatcherThread, SIGNAL(finished()),
childrenWatcherThread, SLOT(deleteLater()));
childrenWatcherThread->start();
}
Немного фона:
Класс ChildProcesses — это менеджер дочерних процессов, который запускает новые дочерние процессы с помощью вызовов spawn(), сохраняет список запущенных в данный момент процессов и так далее. Однако ему необходимо отслеживать дочерние состояния, что означает использование вызова waitpid() в Linux или WaitForMultipleObjects в Windows. Раньше я вызывал их в неблокирующем режиме с помощью таймера, но теперь я хочу более быстрой реакции, что означает блокирующий режим. Вот где в дело вступает нить.
Класс ChildrenWatcher определяется следующим образом:
class ChildrenWatcher: public QObject {
Q_OBJECT
private:
QMutex mutex;
bool stopped;
bool isStopped();
public:
ChildrenWatcher();
public slots:
/// This is the method which runs in the thread.
void watch();
/// Sets the stop flag.
void stop();
signals:
/// A child process exited normally.
void exited(int ospid, int code);
/// A child process crashed (Unix only).
void signalled(int ospid, int signal);
/// Something happened to a child (Unix only).
void stateChanged(int ospid);
};
Вот как это работает. Когда все это запускается, вызывается метод ChildProcess::start() (см. выше). Он создает новый QThread и новый ChildrenWatcher, который затем перемещается в новый поток. Затем я подключаю три сигнала, которые информируют моего менеджера о судьбе его дочерних процессов (выход/сигнализация/бог знает, что случилось). Дальше начинается основное веселье.
Я подключаю QThread::started() к методу ChildrenWatcher::watch(), поэтому он запускается, как только поток готов. Поскольку наблюдатель живет в новом потоке, именно там выполняется метод watch() (для вызова слота используется соединение в очереди).
Затем я подключаю сигнал ChildProcesses::stopped() к слоту ChildrenWatcher::stop(), используя Qt::DirectConnection, потому что мне нужно сделать это асинхронно. Это необходимо, чтобы мой поток останавливался, когда диспетчер ChildProcesses больше не нужен. Метод stop() выглядит так:
void ChildrenWatcher::stop()
{
mutex.lock();
stopped = true;
mutex.unlock();
}
И затем ChildrenWatcher::watch():
void ChildrenWatcher::watch()
{
while (!isStopped()) {
// Blocking waitpid() call here.
// Maybe emit one of the three informational signals here too.
}
// Self-destruct now!
deleteLater();
}
Да, и метод isStopped() — это просто удобный способ использовать мьютекс в условии while():
bool ChildrenWatcher::isStopped()
{
bool stopped;
mutex.lock();
stopped = this->stopped;
mutex.unlock();
return stopped;
}
Итак, что здесь происходит, так это то, что я устанавливаю флаг остановки, когда мне нужно закончить, а затем при следующем вызове isStopped() он возвращает false, и поток завершается.
Так что же происходит, когда заканчивается цикл watch()? Он вызывает deleteLater(), поэтому объект самоуничтожается, как только управление возвращается в цикл событий потока, который происходит сразу после вызова deleteLater() (когда возвращается watch()). Возвращаясь к ChildProcesses::start(), вы можете видеть, что существует соединение между сигналом destroy() наблюдателя и слотом quit() потока. Это означает, что поток автоматически завершается, когда наблюдатель завершает работу. И когда он закончен, он также самоуничтожается, потому что его собственный сигнал finish() подключен к его слоту deleteLater().
Это в значительной степени та же идея, что и Maya, но поскольку я использую идиому самоуничтожения, мне не нужно зависеть от последовательности, в которой вызываются слоты. Он всегда сначала самоуничтожается, потом останавливает поток, а потом тоже самоуничтожается. Я мог бы определить сигнал finish() в рабочем потоке, а затем соединить его с его собственным deleteLater(), но это означало бы только одно дополнительное соединение. Поскольку мне не нужен сигнал finish() для каких-либо других целей, я решил просто вызвать deleteLater() из самого воркера.
Maya также упоминает, что вы не должны размещать новые объекты QObject в конструкторе рабочего процесса, потому что они не будут жить в потоке, в который вы перемещаете рабочий процесс. Я бы сказал, сделайте это в любом случае, потому что так работает ООП. Просто убедитесь, что все эти объекты QObject являются дочерними элементами рабочего процесса (то есть используйте конструктор QObject(QObject*)) — moveToThread() перемещает все дочерние объекты вместе с перемещаемым объектом. Если вам действительно нужно иметь QObjects, которые не являются дочерними элементами вашего объекта, переопределите moveToThread() в вашем рабочем потоке, чтобы он также перемещал все необходимое.
person
Sergei Tachenov
schedule
16.08.2013
