QT Thread 练习Demo

#ifndef THREADTEST1_H
#define THREADTEST1_H

#include <QObject>
#include <QThread>
#include <QDebug>
#include <QRandomGenerator>
#include <QWaitCondition>
#include <QMutex>
#include <QSemaphore>

class ThreadTest1 : public QThread
{
    Q_OBJECT
public:
    ThreadTest1(int _index, QWaitCondition *_condition, QMutex *_mutex, QSemaphore *_semaphore, QObject *parent = nullptr);
    ~ThreadTest1();
signals:
    void updateProgress(int);

public:
    void doSomething();

    void run() override;

    QWaitCondition *condition;
    QMutex *mutex;
    QSemaphore *semaphore;
    int index;

private:
    int nProgress = 0;
    QRandomGenerator *generator = QRandomGenerator::global();

};

#endif // THREADTEST1_H

#include "threadtest1.h"

ThreadTest1::ThreadTest1(int _index, QWaitCondition *_condition, QMutex *_mutex, QSemaphore *_semaphore, QObject *parent)
    : QThread(parent)
    , index(_index)
    , condition(_condition)
    , mutex(_mutex)
    , semaphore(_semaphore)
{
    qDebug() << __FUNCTION__ << " : " << index;
}

ThreadTest1::~ThreadTest1()
{
    qDebug() << __FUNCTION__ << " : " << index;
}

void ThreadTest1::doSomething()
{
    mutex->lock();
    qDebug() << index << " :enter wait block";
    semaphore->release(1);
    condition->wait(mutex);
    mutex->unlock();
    qDebug() << index << " :start ";
    nProgress = 0;
    for( ; ; )
    {
        msleep(1000);
        nProgress += generator->bounded(1, 20);
        if(nProgress >= 100)
        {
            nProgress = 100;
            emit updateProgress(nProgress);
            break;
        }
        else{
            emit updateProgress(nProgress);
        }
    }
    qDebug() << index << " : finished!";

}

void ThreadTest1::run()
{
    doSomething();
}

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include "threadtest1.h"
#include <QProgressBar>
#include <QVBoxLayout>
#include <QVector>
#include <QPushButton>
#include <QWaitCondition>
#include <QMutex>
#include <QThread>
#include <QSemaphore>

QT_BEGIN_NAMESPACE
namespace Ui { class Widget; }
QT_END_NAMESPACE

class Widget : public QWidget
{
    Q_OBJECT

public:
    Widget(QWidget *parent = nullptr);
    ~Widget();

private slots:
    void slotPushButton();

public:
    Ui::Widget *ui;
    QWaitCondition condition;
    QMutex mutex;
    QSemaphore semaphore;

public:
    QVector<ThreadTest1*> vecThread;
    QVector<QProgressBar*> vecProgressBar;
    QVBoxLayout* layout;
    QPushButton *btn;
    const int cnt = 10;
    void init();
    void reset();


};
#endif // WIDGET_H

#include "widget.h"
#include "ui_widget.h"

struct ThreadClass : public QThread
{
    Widget *widget;
    void run() override
    {
        widget->reset();
        ThreadTest1 *thread;
        for(int i = 0; i < widget->cnt; i++)
        {
            thread = new ThreadTest1(i, &widget->condition, &widget->mutex, &widget->semaphore);
            widget->vecThread.push_back(thread);
            connect(widget->vecThread.at(i), &ThreadTest1::updateProgress, widget->vecProgressBar.at(i), &QProgressBar::setValue);
            connect(widget->vecThread.at(i), &ThreadTest1::finished, this, [=](){
                thread->deleteLater();
                widget->vecThread[i] = nullptr;
            });
            widget->vecThread.at(i)->start();
        }
        widget->semaphore.acquire(widget->cnt);
        qDebug() << "all ready";
        widget->condition.wakeAll();
    }

    ThreadClass(Widget *_widget)
        : widget(_widget)
    {
        qDebug() << __FUNCTION__;
    }

    ~ThreadClass()
    {
        qDebug() << __FUNCTION__;
    }
};

Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);
    init();
}

Widget::~Widget()
{
    delete ui;
}

void Widget::slotPushButton()
{
    ThreadClass *thread = new ThreadClass(this);
    connect(thread, &ThreadClass::finished, thread, &QObject::deleteLater);
    thread->start();
    qDebug() << "Leave " << __FUNCTION__;
}


void Widget::init()
{
    QProgressBar *bar;
    layout = new QVBoxLayout(this);
    for(int i = 0; i < cnt; i++)
    {
        bar = new QProgressBar(this);
        bar->setRange(0, 100);
        bar->reset();
        vecProgressBar.push_back(bar);
        layout->addWidget(bar);
    }
    btn = new QPushButton("Start", this);
    connect(btn, &QPushButton::clicked, this, &Widget::slotPushButton);
    layout->addWidget(btn);
}

void Widget::reset()
{
    for(int i = 0; i < cnt; i++)
    {
        vecProgressBar[i]->reset();
    }
    vecThread.clear();
}