多线程Thread类不同封装实现

• 多线程Thread类实现
  1.C语言实现方式：通过建立多个全局线程回调函数实现
  2.面向对象实现方式：通过多态特性实现，虚函数在派生类中不同的行为方式
  3.基于对象实现方式：通过boost::function和bind实现
• - 对于Linux线程创建方式：

int pthread_create(pthread_t *restrict thread,  
        const pthread_attr_t *restrict attr,  
        void *(*start_routine)(void*), void *restrict arg);  

参数1.线程ID
参数2.线程属性
参数3.线程回调函数
参数4.回调函数

1. C语言实现线程方式：

       通过建立全局线程回调函数实现，对于多个线程多个 不同任务需要建立多个全局函数，例子
   

void threadFunction1(void* arg)
{
    printf("child thread 1\n");
    pthread_exit(NULL);
}
void threadFunction2(void* arg)
{
    printf("child thread 2\n");
    pthread_exit(NULL);
}
int main(){
    pthread_t thread1;
    pthread_t thread2;
    pthread_create(&thread1,NULL,threadFunction1,NULL);
    pthread_create(&thread2,NULL,threadFunction2,NULL);
    pthread_join(thread1,NULL);
    pthread_join(thread2,NULL);
    return 0;
} 

1. 面向对象封装方式

   虚函数在派生类中不同的行为方式
   

class Thread
{
public:
    Thread(){}
    virtual ~Thread(){}
    void start()
    {
        pthread_create(&_thread,NULL,thread_rountine,this);
    }
    void join()
    {
        pthread_join(_thread,NULL);
    }
private:
static void* thread_rountine(void* arg)
{
    // 不同的线程调用同样的thread_rountine函数，this指针指向不同的线程派生类，执行派生类中的run行为
    Thread* thread = static_cast<Thread*>(arg);
    thread->run();
    return NULL;
}
virtual run()=0;
pthread_t _thread;
};

在prthread_create中为什么不能传递类的成员函数，使用静态的成员函数，因为pthread_create的参数三是一个普通的函数，而类的成员函数隐含传递一个this指针。
3. 基于对象封装方式（muduo库实现方式 boost::function/bind）

    通过boost::function和bind实现

class Thread
{
public:
    typedef boost::function<void ()> ThreadFunc;
    explicit Thread(const ThreadFunc& func):_func(func){}
    ~Thread(){}
    void start(){pthread_create(&_thread,NULL,thread_rountine,this);}
    void join(){pthread_join(_thread,NULL);}
private:
    ThreadFunc _func;
    pthread_t _thread;
    void run()
    {
        _func();
    }
    static void* thread_rountine(void* arg)
    {
        // boost::function类似于一种函数指针的声明，boost::bind类似于绑定一个函数
        // 对于不同线程执行不同的行为时，只需要通过boost::bind改变即可实现。
        Thread* thread = static_cast<Thread*>(arg);
        thread->run();
        return NULL;
}
};
class Foo
{
public:
void MemberFun()
{
    cout<<"child thread1"<<endl;
}
void MemberFun1(int count)
{
    cout<<"child thread2:"<<count<<endl;
}
};
int main()
{
    Foo foo1();
    Foo foo2();
    Thread t(boost::bind(&Foo::MemberFun, &foo));
    Thread t1(boost::bind(&Foo::MemberFun1,&foo2,3));
}

1. 两种方式比较

   个人观点：
   继承实现的方式耦合性强，当功能扩展时，都需要建立新的派生类实现run方法
   对于基于对象方式来说，耦合性低，对于功能扩展只需要编写一个函数就可以了，扩展性强