使用C++11的function/bind组件封装Thread以及回调函数的使用

最新推荐文章于 2022-09-30 21:56:10 发布

boboxxd

最新推荐文章于 2022-09-30 21:56:10 发布

阅读量600

点赞数

分类专栏： c++11

c++11 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

转自:https://www.cnblogs.com/inevermore/p/4038498.html
现在我们采用C++11的function，将函数作为Thread类的成员，用户只需要将function对象传入线程即可，所以Thread的声明中，应该含有一个function成员变量。

类的声明如下：

#ifndef THREAD_H_
#define THREAD_H_

#include <boost/noncopyable.hpp>
#include <functional>
#include <pthread.h>

class Thread : boost::noncopyable
{
public:
    typedef std::function<void ()> ThreadCallback;

    Thread(ThreadCallback callback);
    ~Thread();

    void start();
    void join();

    static void *runInThread(void *);

private:
    pthread_t threadId_;
    bool isRunning_;
    ThreadCallback callback_; //回调函数
};
#endif //THREAD_H_

复制代码
那么如何开启线程？思路与之前一致，写一个static函数，用户pthread_create的第三个参数，this作为最后一个参数即可。

void Thread::start()
{
    pthread_create(&threadId_, NULL, runInThread, this);
    isRunning_ = true;
}

回调函数

注意在这种封装方式中，我们采用了回调函数。回调函数与普通函数的区别就是，普通函数写完由我们自己直接调用，函数调用是一种不断往上堆积的方式，而回调函数通常是我们把某一个函数传入一个“盒子”，由该盒子内的机制来调用它。

在这个例子里面，我们将function传入Thread，当Thread启动的时候，由Thread去执行function对象。

在win32编程中大量用到这种机制，我们为鼠标单击、双击等事件编写相应的函数，然后将其注册给windows系统，然后系统在我们触发各种事件的时候，根据事件的类型，调用相应的构造函数。

关于回调函数，可以参考：http://www.zhihu.com/question/19801131

以后有时间，再专门总结下回调函数。

完整的cpp如下：

复制代码

#include "Thread.h"

Thread::Thread(ThreadCallback callback)
: threadId_(0),
  isRunning_(false),
  callback_(std::move(callback))
{

}

Thread::~Thread()
{
    if(isRunning_)
    {
        //detach
        pthread_detach(threadId_);
    }
}

void Thread::start()
{
    pthread_create(&threadId_, NULL, runInThread, this);
    isRunning_ = true;
}
void Thread::join()
{
    pthread_join(threadId_, NULL);
    isRunning_ = false;
}

void *Thread::runInThread(void *arg)
{
    Thread *pt = static_cast<Thread*>(arg);
    pt->callback_(); //调用回调函数

    return NULL;
}

复制代码

这个线程的使用方式有三种：

一是将普通函数作为回调函数

复制代码

void foo()
{
    while(1)
    {
        printf("foo\n");
        sleep(1);
    }
}

int main(int argc, char const *argv[])
{
    Thread t(&foo);

    t.start();
    t.join();

    return 0;
}

复制代码

二是采用类的成员函数作为回调函数：

复制代码

class Foo
{
public:
    void foo(int i)
    {
        while(1)
        {
            printf("foo %d\n", i++);
            sleep(1);
        }
    }
};


int main(int argc, char const *argv[])
{
    Foo f;
    int i = 34;
    Thread t(bind(&Foo::foo, &f, i));

    t.start();
    t.join();

    return 0;
}

复制代码
最后一种是组合一个新的线程类，注意这里采用的是类的组合：

复制代码

class Foo
{
public:

    Foo()
    : thread_(bind(&Foo::foo, this))
    {
    }

    void start()
    {
        thread_.start();
        thread_.join();
    }

    void foo()
    {
        while(1)
        {
            printf("foo\n");
            sleep(1);
        }
    }
private:
    Thread thread_;
};

int main(int argc, char const *argv[])
{
    Foo f;
    f.start();
    return 0;
}