[QT]QThreadPool+lambda-在线程池中使用lambda表达式调用类的成员函数

1.QThreadPool的基础使用

  1.1 引入相关头文件QThreadPool和QRunnable

#include <QRunnable>
#include <QThreadPool>

  1.2 QThreadPool

    创建一个线程池一般有两种方法，第一种使用全局线程池

 QThreadPool *pool = QThreadPool::globalInstance();

    第二种，新建一个线程池，请记住最好设置一些常用的属性

QThreadPool *pool= new QThreadPool();
//最大线程个数：4
pool->setMaxThreadCount(4);

  1.3 QRunnable

    QRunnable需要自己派生出一个具体的类，然后必须重写run函数（类似于QThread），例如

class BTask : public QRunnable
{
public:
    void run() override
    {
        std::cout<<"task running in thread pool"<<std::endl;
    }
};

  1.4 执行（task在默认情况下会由线程池尝试释放，无需手动delete）

BTask * task = new BTask();
pool->start(task);
//等待完成
pool->waitForDone();

2. 加入Lambda表达式

  2.1 使用functional声明一个回调函数，样式为void xxxx();

#include <functional>

typedef std::function<void(void)> task_cb;

  2.2 给BTask添加一个设置回调函数功能add，以下是完整的类

class BTask : public QRunnable
{
public:
    void run() override
    {
        std::cout<<"task running in thread pool"<<std::endl;

        if(call)
            call();
    }

    void add(callback cb)
    {
        call = cb;
    }

private:
    callback call;
};

  2.3 使用Lambda表达式实现回调函数,先实现一个A类，然后在A里创建线程池，创建BTask对象

class A
{
public:
    A()
    {
        pool = new QThreadPool();
        pool->setMaxThreadCount(4);
        //pool = QThreadPool::globalInstance();

    }

    ~A()
    {
        if(pool)
        {
            delete pool;
            pool = nullptr;
        }
    }

    void Do()
    {
        //auto delete task
        BTask * task = new BTask();
        //lambda
        task->add([this](){
            this->DoOther();
        });

        pool->start(task);
        pool->waitForDone();
    }

private:
    void DoOther()
    {
        std::cout<<"do something"<<std::endl;
    }

private:
    QThreadPool *pool;
};

3.完整代码

  完成函数调用

#include <QRunnable>
#include <QThreadPool>

#include <iostream>

typedef std::function<void(void)> callback;

class BTask : public QRunnable
{
public:
    void run() override
    {
        std::cout<<"task running in thread pool"<<std::endl;

        if(call)
            call();
    }

    void add(callback cb)
    {
        call = cb;
    }

private:
    callback call;
};

class A
{
public:
    A()
    {
        pool = new QThreadPool();
        pool->setMaxThreadCount(4);
        //pool = QThreadPool::globalInstance();

    }

    ~A()
    {
        if(pool)
        {
            delete pool;
            pool = nullptr;
        }
    }

    void Do()
    {
        //auto delete task
        BTask * task = new BTask();
        task->add([this](){
            this->DoOther();
        });

        pool->start(task);
        pool->waitForDone();
    }

private:
    void DoOther()
    {
        std::cout<<"do something"<<std::endl;
    }

private:
    QThreadPool *pool;
};



int main(int argc, char *argv[])
{
    A a;
    a.Do();
    std::cout<<"finished"<<std::endl;
    return 0;
}