boost库封装Thread

喜欢ヅ旅行 2022-07-14 01:41 201阅读 0赞

曾经尝试对pthread进行封装，使用Thread虚基类，子类重写run方法的方式。详情见：  
[C++封装POSIX 线程库（三）线程的封装][C_POSIX]

最近阅读[ 以boost::function和boost:bind取代虚函数][_boost_function_boost_bind]学习了使用boost::function和boost::bind对Thread库进行封装。

令Thread是一个具体类，其构造函数接收ThreadCallback对象。应用程序只需提供一个能够转换为ThreadCallback的对象，即可创建Thread实体，然后调用start()即可。Java中的Thread可以这么用，传入一个Runnable对象。

下面实现了一个基于boost::function的简单的Thread Class

//Thread.h
    
    #ifndef __THREAD_H__
    #define __THREAD_H__
    #include <iostream>
    #include <boost/bind.hpp>
    #include <boost/function.hpp>
    #include <unistd.h>
    #include <vector>
    #include <memory>
    
    using namespace std;
    using namespace boost;
    
    class Thread{
    public:
        typedef boost::function<void()> ThreadCallback;
        explicit Thread(const ThreadCallback&);
        void start();
        void join();
        private:
        void run()
        {
            cb_();
        }
        ThreadCallback cb_;
        static void * RunInThread(void *);
    
        pthread_t threadId_;
    };
    #endif

//Thread.cpp
    
    #include "Thread.h"
    
    Thread::Thread(const ThreadCallback& cb ):cb_(cb),threadId_(0)
    {
    }
    
    
    void Thread::start()
    {
        pthread_create(&threadId_,NULL,RunInThread,this);
    }
    
    
    void * Thread::RunInThread(void * arg)
    {
        Thread * pt= static_cast<Thread*>(arg);
        pt->run();
    }
    
    void Thread::join()
    {
         pthread_join(threadId_, NULL);
    }

**下面是相关测试程序。**

//main.cpp
    
    #include "Thread.h"
    void threadFunc1(int a,int b,int c,int d)
    {
        cout<<a<<b<<c<<d<<endl;
        sleep(1);
    }
    void threadFunc2()
    {
        cout<<"threadFunc2"<<endl;
        sleep(1);
    }
    class Foo
    {
        private:
        int count_;
        public :
        Foo(int count):count_(count){}
        void threadFunc(int a)
        {
            while(count_--)
            {
                cout << "Foo func"<<a<<endl;
                sleep(1);
            }
        }
    };
    int main()
    {
        int a=4;
        int b=5;
        int c=7;
        int d=8;
    
        typedef std::shared_ptr<Thread> ThreadPtr;
        Foo foo(3);
        {
        vector<ThreadPtr> threads(3);
    #if 1
            threads[0].reset(new Thread(boost::bind(threadFunc1,a,b,c,d)));
            threads[1].reset(new Thread(boost::bind(threadFunc2)));
            threads[2].reset(new Thread(boost::bind(&Foo::threadFunc,&foo,1000)));
    
            threads[0]->start();
            threads[0]->join();
            threads[1]->start();
            threads[1]->join();
            threads[2]->start();
            threads[2]->join();
    #endif 
        }
        return 0;
    }

结果如图：

![这里写图片描述][20161122225605842]

## 参考 ##

1.《Linux多线程服务端编程 使用muduo C++网络库》  
2.[http://blog.csdn.net/jnu\_simba/article/details/12944043][http_blog.csdn.net_jnu_simba_article_details_12944043]  
3.[http://blog.csdn.net/solstice/article/details/3066268][_boost_function_boost_bind]  
4.[http://blog.csdn.net/zhangxiao93/article/details/52040369?locationNum=7&fps=1][C_POSIX]

[C_POSIX]: http://blog.csdn.net/zhangxiao93/article/details/52040369?locationNum=7&fps=1
[_boost_function_boost_bind]: http://blog.csdn.net/solstice/article/details/3066268
[20161122225605842]: /images/20220714/f4eefc1ae8b84495878b426cc69f8a7f.png
[http_blog.csdn.net_jnu_simba_article_details_12944043]: http://blog.csdn.net/jnu_simba/article/details/12944043