linux下线程的两种封装方式

在网络编程的时候往往需要对Linux下原生的pthread库中的函数进行封装,使其使用起来更加方便,封装方法一般有两种:面向对象和基于对象,下面将分别介绍这两种方式,最后统一分析这两种方式的优缺点:

面向对象:

面向对象的封装方式是通过虚函数提供回调功能,我们创建一个Thread类,然后设置一个run虚函数,使用时只需要重载这个类并实现其中的虚函数即可:

具体实现如下:

//------thread.h----------------

#ifndef _THREAD_H_
#define _THREAD_H_

#include <pthread.h>

class Thread
{
public:
    Thread();
    virtual ~Thread();
    void start();
    void join();
    void setAutoDelete(bool autoDelete);

private:
    static void* threadRoutine(void* args);
    virtual void run() = 0;
    pthread_t threadId_;
    bool autoDelete_;
};

#endif
详细实现如下:
//---------thread.c-------------------

#include "thread.h"
#include <iostream>
using namespace std;

Thread::Thread() : autoDelete_(false)
{
    cout << "Thread..." << endl;
}

Thread::~Thread()
{
    cout << "~Thread..." << endl;
}

void* Thread::threadRoutine(void* arg)
{
    Thread* thread = static_cast<Thread*>(arg);
    thread->run();

    if (thread->autoDelete_)
    {
        delete thread;
    }

    return NULL;
}


void Thread::start()
{
    pthread_create(&threadId_,NULL, threadRoutine,this);
}

void Thread::join()
{
    pthread_join(threadId_, NULL);
}

void Thread::setAutoDelete(bool autoDelete)
{
    autoDelete_ = autoDelete;
}
View Code

调用方式如下:

#include "thread.h"
#include <unistd.h>
#include <iostream>
using namespace std;

class TestThread : public Thread
{
public:
    TestThread(int count) : count_(count)
    {
        cout << "TestThread..." << endl;
    }
    ~TestThread()
    {
        cout << "~TestThread..." << endl;
    }
private:
    void run()
    {
        while( count_-- )
        {
            cout << "This is a test" << endl;
            sleep(1);
        }
    }

private:
    int count_;
};


int main(void)
{
    TestThread t(5);
    t.start();
    t.join();

    //do other work....
}
View Code

  可以看到,其中有一个私有的重虚函数run,使用时只需要继承thread,实现run函数,并在其内实现线程需要执行的逻辑就可以了。

  同时有一个静态的threadRoutine成员函数,因为C++成员函数缺省的调用方式是__thiscall,成员函数中隐含的第一个参数都是this指针,所以不能匹配给pthread_create的形参void *(*start_routine) (void *), 这时候就可以传递类的一个静态成员,把this指针做为该静态成员的参数。也就是start方法的: pthread_create(&threadId_,NULL, threadRoutine,this);   在threadRoutine函数中将接收到的void*类型的参数转换成Thread*就可以了,然后调用他的run方法。

  在main函数中静态创建了一个TestThread变量 t,然后启动线程, 但是如果线程运行结束了,这个变量 t 就失去存在的价值了, 总不能一直让它在哪里占用着栈上空间吧,此时我们就可以动态创建TestThread, 然后设定其autoDelete_属性,这样当该线程执行完毕后就会检查是否需要delete掉这个堆上变量,这就是autoDelete_属性的作用,可以将main函数修改如下:

int main(void)
{
    TestThread *t = new TestThread(5);
    t->setAutoDelete(true);
    t->start();
    t->join();

       //do other work....

}
View Code

  如果你决心只在堆上分配的话,就可以将析构函数设置为私有的,这样就可以只在堆上分配,但是你还得提供一个公有的自定义的析构方法。

基于对象

  基于对象的封装方法,实现思路同上,但是它不是通过虚函数的方式实现回调的功能,而是通过函数绑定的方式, boost库中的bind/function可以实现将一个函数转换成另一种函数,就算是成员函数也可以,它相当于C++中的bind1st,bin2nd等函数适配器,在C++11中也实现了bind/function, 关于boost bind/function的使用方法,可以看这里。这里不做过多介绍。

用基于对象的封装方法如下:

//-------thread.h-------

#ifndef _THREAD_H_
#define _THREAD_H_

#include <pthread.h>
#include <boost/function.hpp>

class Thread
{
public:
    typedef boost::function<void ()> ThreadFunc;
    explicit Thread(const ThreadFunc& func);
    ~Thread();
    void start();
    void join();
    void setAutoDelete(bool autoDelete);

private:
    static void* threadRoutine(void* args);
    void run();
    bool autoDelete_;
    ThreadFunc func_;
    pthread_t threadId_;

};

#endif

其中在构造函数中需要ThreadFunc对象,这个函数就是在run中调用的实例,可以看下面代码:

//---------thread.cpp-----------

#include "thread.h"
#include <iostream>
using namespace std;


Thread::Thread(const ThreadFunc& func):autoDelete_(false),func_(func)
{
    cout << "Thread..." << endl;
}


Thread::~Thread()
{
    cout << "~Thread..." << endl;
}


void Thread::run()
{
    func_();
}

void* Thread::threadRoutine(void* arg)
{
    Thread* thread = static_cast<Thread*>(arg);
    thread->run();

    if (thread->autoDelete_)
    {
        delete thread;
    }

    return NULL;
}


void Thread::start()
{
    pthread_create(&threadId_,NULL, threadRoutine,this);
}


void Thread::join()
{
    pthread_join(threadId_, NULL);
}


void Thread::setAutoDelete(bool autoDelete)
{
    autoDelete_ = autoDelete;
}
View Code

在主函数中调用方法也很简单:

#include "thread.h"
#include <unistd.h>
#include <iostream>
#include <boost/bind.hpp>
using namespace std;

void ThreadFunc()
{
    cout << "ThreadFunc..." << endl;
}

void ThreadFunc2(int count)
{
    while( count_-- )
    {
        cout << "This is a test" << endl;
        sleep(1);
    }
}

class Foo
{
public:
    Foo(int count) : count_(count){    }

    void MemerFunc()
    {
        while( count_-- )
        {
            cout << "This is a test" << endl;
            sleep(1);
        }
    }
private:
    int count_;

};

int main(void)
{


    //Thread *t = new Thread(ThreadFunc);    
  
    //Thread *t = new Thread(boost::bind(ThreadFunc2,4));
    
    Foo foo(3);
    Thread *t = new Thread(boost::bind(&Foo::MemerFunc,&foo));

    t->setAutoDelete(true);
    t->start();
    t->join();

    //do other work....

}
View Code

在上面的例子中我们可以绑定不同的对象到Thread的构造函数中,这样就可以实现随着绑定的不同调用不同的函数。

上面就是线程用面向对象和基于对象的不同封装方式,如果你要问,它们孰优孰劣,请挪步这篇精彩的分析

 

posted @ 2016-08-28 19:43  gaorong404  阅读(714)  评论(0编辑  收藏  举报