---

QThread使用的两种方式

  Qt提供了两种线程的使用方式，分别如下：

moveToThread

 class Worker : public QObject
  {
    
      Q_OBJECT

  public slots:
      void doWork(const QString &parameter) {
    
          QString result;
          /* ... here is the expensive or blocking operation ... */
          emit resultReady(result);
      }

  signals:
      void resultReady(const QString &result);
  };

  class Controller : public QObject
  {
    
      Q_OBJECT
      QThread workerThread;
  public:
      Controller() {
    
          Worker *worker = new Worker;
          worker->moveToThread(&workerThread);
          connect(&workerThread, &QThread::finished, worker, &QObject::deleteLater);
          connect(this, &Controller::operate, worker, &Worker::doWork);
          connect(worker, &Worker::resultReady, this, &Controller::handleResults);
          workerThread.start();
      }
      ~Controller() {
    
          workerThread.quit();
          workerThread.wait();
      }
  public slots:
      void handleResults(const QString &);
  signals:
      void operate(const QString &);
  };

  这种方式下worker的slot将会执行在一个独立的线程，但是，我们仍然能够自由的使用connect通过queue connection，这是线程安全的。

subclass QThread

  class WorkerThread : public QThread
  {
    
      Q_OBJECT
      void run() override {
    
          QString result;
          /* ... here is the expensive or blocking operation ... */
          emit resultReady(result);
      }
  signals:
      void resultReady(const QString &s);
  };

  void MyObject::startWorkInAThread()
  {
    
      WorkerThread *workerThread = new WorkerThread(this);
      connect(workerThread, &WorkerThread::resultReady, this, &MyObject::handleResults);
      connect(workerThread, &WorkerThread::finished, workerThread, &QObject::deleteLater);
      workerThread->start();
  }

  这种方式需要注意：QThread的实例化版本存在于创建其的线程中，而不是新的线程，对于这种方式而言，只有run函数是运行在一个独立的线程中，所以所有QThread的queue slots都将在老的线程中执行，这意味这如果我们连接槽，那么就要考虑临界资源问题。

Qthread同步

QMutex

  QMutex无疑是最常用的线程同步方式，其主要作用是：如果一个线程已经获得了临界资源，第二个线程访问时就会被挂起，直到第一个线程解锁。我们可以像下面这样来使用QMutex：

QMutex mutex;
int number = 6;

void method1()
{
    
  mutex.lock();
  number *= 5;
  number /= 4;
  mutex.unlock();
}

void method2()
{
    
  mutex.lock();
  number *= 3;
  number /= 2;
  mutex.unlock();
}

  这种方式本身并没有什么问题，但是可能出现这样一种情况，即在unlock()之前函数就返回了，这是一种很常见的情况，那么此时程序就会被冻结；为了避免这种情况，所以Qt提供了QMutexLocker，它们锁定一个资源，然后在销毁时释放资源。我们可以像下面这样使用：

QMutex mutex;
int complexFunction(int flag)
{
    
	QMutexLocker locker(&mutex);
	...
	return 1;
}

  与QMutex类似的还有QReadWriteLock，其与QMutex的不同在于：QMutex将会锁定资源，包括读写，而QReadWriteLock则支持多个线程同时读取，但是只能一个线程进行写入。从效率上来说，QReadWriteLock更胜一筹。QReadWriteLock也提供了QReadLocker and QWriteLocker以简化使用。

QWaitCondition

  QWaitCondition契合了多线程中的生产者 - 消费者模式，考虑一下如果只使用QMutex进行生产者与消费者之间的线程同步会是怎样的情形：当生产者生产产品时未满时，消费者无法消费；当产品还未消费完时，生产者不能生产。这种方式将会带来严重的效率问题，所以这种情形下就需要更加灵活的线程同步，因此需要QWaitCondition。示例代码如下：

  const int DataSize = 100000;

  const int BufferSize = 8192;
  char buffer[BufferSize];

  QWaitCondition bufferNotEmpty;
  QWaitCondition bufferNotFull;
  QMutex mutex;
  int numUsedBytes = 0;

class Producer : public QThread
  {
    
  public:
      Producer(QObject *parent = NULL) : QThread(parent)
      {
    
      }

      void run() override
      {
    
          for (int i = 0; i < DataSize; ++i) {
    
              mutex.lock();
              if (numUsedBytes == BufferSize)
                  bufferNotFull.wait(&mutex);
              mutex.unlock();

              buffer[i % BufferSize] = "ACGT"[QRandomGenerator::global()->bounded(4)];

              mutex.lock();
              ++numUsedBytes;
              bufferNotEmpty.wakeAll();
              mutex.unlock();
          }
      }
  };

 class Consumer : public QThread
  {
    
      Q_OBJECT
  public:
      Consumer(QObject *parent = NULL) : QThread(parent)
      {
    
      }

      void run() override
      {
    
          for (int i = 0; i < DataSize; ++i) {
    
              mutex.lock();
              if (numUsedBytes == 0)
                  bufferNotEmpty.wait(&mutex);
              mutex.unlock();

              fprintf(stderr, "%c", buffer[i % BufferSize]);

              mutex.lock();
              --numUsedBytes;
              bufferNotFull.wakeAll();
              mutex.unlock();
          }
          fprintf(stderr, "\n");
      }

  signals:
      void stringConsumed(const QString &text);
  };

解析：

• 生产者使用对临界资源使用mutex.lock()上锁，然后检查缓冲区是否满了，如果满了，那么bufferNotFull进入等待，此时可以认为mutex暂时释放，生者者将阻塞在这里。
• 消费者消费产品，产品不再满仓，那么bufferNotFull.wakeAll()，条件激活，但由于消费者中mutex.lock()，生产者暂不启动，但一旦mutex.unlock()，生产者立即获得mutex的控制权，直到mutex.unlock();

  这里需要注意的一点是：为什么使用了QWaitCondition还要使用QMutex呢？对此，Qt assistant中给出了解释：

QWaitCondition allows a thread to tell other threads that some sort of condition has been met. One or many threads can block waiting for a QWaitCondition to set a condition with wakeOne() or wakeAll(). Use wakeOne() to wake one randomly selected thread or wakeAll() to wake them all.

  也就是说：也就是说，线程获得互斥锁，但是会因为QWaitConation不满足而阻塞，直到有使用wakeOne或者wakeAll来激活。
  关于QWaitCondition，有一篇很好的博客可以帮助我们理解，链接如下：https://blog.csdn.net/flyoxs/article/details/54617342

总结：以上只介绍了QMutex、QWaitCondition，但是并不意味着线程同步方式只有这两种，只是因为它们具有代表性而已，至于其他方式，我们还可以使用QSemaphore，这里就不再详述，有兴趣的同学可以去研究一下。

优雅的取消线程

  怎样结束一个long Task呢？比较常用的方式如下：

while(!bStop)
{
    
...
}

  通过控制bStop的状态，我们可以结束一个长时间的任务，但是这种使用方式需要注意：因为bStop是一个临界资源，当我们改变它的状态时，需要考虑互斥问题。但实际上，Qt已经为我们做了这方面的考虑，主要依赖于以下两个函数：

• void QThread::requestInterruption()
• bool QThread::isInterruptionRequested() const

  前者只是发起一个中断请求，是否响应完全由线程本身决定。后者则对应前者：如果已经发起中断请求，返回true，否则为false。这两个函数都是线程安全的，其源码如下：

void QThread::requestInterruption()
{
    
    Q_D(QThread);
    QMutexLocker locker(&d->mutex);
    if (!d->running || d->finished || d->isInFinish)
        return;
    if (this == QCoreApplicationPrivate::theMainThread) {
    
        qWarning("QThread::requestInterruption has no effect on the main thread");
        return;
    }
    d->interruptionRequested = true;
}
 
bool QThread::isInterruptionRequested() const
{
    
    Q_D(const QThread);
    QMutexLocker locker(&d->mutex);
    if (!d->running || d->finished || d->isInFinish)
        return false;
    return d->interruptionRequested;
}

  从源码中可以看出，Qt实际已经在实现中加了锁。因此，我们可以放心使用这种方式如下所示：

 void long_task() {
    
       forever {
    
          if ( QThread::currentThread()->isInterruptionRequested() ) {
    
              return;
          }
      }
  }

  需要注意的是，在Qt助手中，建议我们不要调用isInterruptionRequested()过于频繁，以保持cpu的低开销。