Qt多线程方法二

 

　　创建一个QThread和QWorker(继承自QObject)类对象，使用moveToThread函数移动到thread中运行，通过thread类start信号和worker槽函数绑定。

　　主函数：

void main()
{
    QSharedPointer<QThread> controlThread = QSharedPointer<QThread>(new QThread());
    MyControl* control = new MyControl(controlThread.data(), subCount);
   
    QMutex mutex;
    for(int i=0; i<idCounnt; ++i)
    {
        workerParam* param = new workerParam();
        param->mutex = &mutex;
        MyWorker* worker = control->getWorker();
        emit worker->sigWork(param);
    }
    control->waitFinish();
    controlThread->quit();
    controlThread->wait();
}

　　总控类.h

class MyControl : public QObject
{
   Q_OBJECT

public:  
   MyControl(QThread* controlThread, int subTreadCount);
   ~MyControl();

    //等待结束，有进度条时，从主函数调用
    void waitFinish();
    MyWorker* getWorker();

protected slots:
    void slotWorkDone(MyWorker* worker);

private:
    QVector<QThread*> m_threads;
    QStack<MyWorker*> m_workers;

    QMutex m_workerMutex;
    QWaitCondition m_workerCondition;

    QMutex m_countMutex;
    QWaitCondition m_countCondition;

    int m_iDone; //已处理完个数
}

　　总控类.cpp

MyControl::MyControl(QThread* controlThread, int subThreadCount)
    : m_iDone(0);
{
   this->moveToThread(controlThread);
   conect(controlThread,SIGNAL(finished()), this,SLOT(deleteLater()));

   m_threads.reserve(subThreadCount);
   m_workers.reserve(subThreadCount);
   for(int i=0; i<subThreadCount; ++i)
   {
        QThread* thread = new QThread();
        MyWorker* worker = new MyWorker(thread);
        connect(worker,SIGNAL(sigWorkDone()), this,SLOT(slotWorkDone()));

        m_threads.push_back(thread);
        m_workers.push(worker);
        thread->start();
    }
}

MyControl::~MyControl()
{
    for(int i=0; i<m_threads.size(); ++i)
    {
        m_threads[i]->quit();
        m_threads[i]->wait();
    }
    qDeleteAll(m_threads);
    m_threads.clear();
    m_workers.clear();
}

MyWorker* MyControl::getWorker()
{
    QMuteLocker locker(&m_workerMutex);
    while(m_workers.isEmpty())
    {
        m_workerCondition.wait(&m_workerMutex);
    }
    MyWorker* worker = m_workers.pop();
    return worker;
}

void MyControl::waitFinish()
{
    m_countMutex.lock();
    while(m_iDone < total)
    {
        m_countCondition.wait(&m_countMutex);
        //可以在这里刷新进度条
        m_countMutex.unlock();
        m_bar->setValue(m_iDone);
        QCoreApplication::processEvent();
        m_countMutex.lock();
    }
    m_countMutex.unlock();

    if(m_threads.size() != m_workers.size())
        Q_ASSERT(false);
}    

void MyControl::slotWorkDone(MyWorker* worker)
{
    QMetexLocker locker1(&m_workerMutex);
    QMetexLocker locker2(&m_countMutex);
    m_workers.push(worker);
    if(m_workers.size() >= 1)
        m_workerCondition.wakeAll();
    iDone++;
    m_countCondition.wakeAll();
}

 　　工作类.h

class MyWorker : public QObject
{
    Q_OBJECT

public:
    MyWorker(QThread* thread);
    ~MyWorker();

protected slots:
    void slotWork();

signals:
    void sigWork();
    void sigWorkDone();
}

　　工作类.cpp

MyWork::MyWork(QThread* thread)
{
    connect(this,SIGNAL(sigWork()), this,SLOT(slotWork()));
    connect(thread,SIGNAL(finished()), this,SLOT(deleteLater()));
    this->moveToThread(thread);
}

void MyWork::slotWork()
{
    //to do ...
    emit sigWorkDone();
}