基于对象的线程类的封装（基于boost bind/function库）

boost bind/function

例：boost bind/function库的使用
bf_test.cpp

#include <iostream>
#include <boost/function.hpp>
#include <boost/bind.hpp>
using namespace std;
class Foo
{
public:
	void memberFunc(double d, int i, int j)
	{
		cout << d << endl;
		cout << i << endl;
		cout << j << endl;
	}
};

void Func(double d, int i, int j)
{
	cout << d << endl;
	cout << i << endl;
	cout << j << endl;
}
int main()
{
	Foo foo;
	//事实上，boost::bind中的占位符个数就是所创建的boost::function对象接受参数的个数
	boost::function<void(int)> fp = boost::bind(&Foo::memberFunc, &foo, 0.5, _1, 22);//_1表示占位
	fp(11);
	boost::function<void(int, int)> fp1 = boost::bind(&Foo::memberFunc, &foo, 0.5, _1, _2);//_1、_2表示占位
	fp1(33, 44);
	boost::function<void(int, int)> fp2 = boost::bind(&Foo::memberFunc, boost::ref(foo), 0.5, _1, _2);
	fp2(55, 66);
	boost::function<void(int, int)> fp3 = boost::bind(Func, 0.5, _1, _2);
	fp3(77, 88);

	//auto fp4 = boost::bind(&Foo::memberFunc, _1, 0.5, _2, _3);
	boost::function<void(Foo*, int, int)> fp4 = boost::bind(&Foo::memberFunc, _1, 0.5, _2, _3);//_1、_2、_3表示占位
	fp4(&foo, 33, 44);

	system("pause");
	return 0;
}

基于对象的线程类的封装

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);//重点

        void Start();
        void Join();

        void SetAutoDelete(bool autoDelete);

private:
        static void* ThreadRoutine(void* arg);
        void Run();
        ThreadFunc func_;//重点
        pthread_t threadId_;
        bool autoDelete_;
};

#endif // _THREAD_H_

Thread.cpp

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


Thread::Thread(const ThreadFunc& func) : func_(func), autoDelete_(false)
{
}

void Thread::Start()
{
        pthread_create(&threadId_, NULL, ThreadRoutine, this);
}

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

void* Thread::ThreadRoutine(void* arg)
{
        Thread* thread = static_cast<Thread*>(arg);//这里就不体现多态了
        thread->Run();
        if (thread->autoDelete_)
                delete thread;
        return NULL;
}

void Thread::SetAutoDelete(bool autoDelete)
{
        autoDelete_ = autoDelete;
}

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

Thread_test.cpp

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

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

	void MemberFun()
	{
		while (count_--)
		{
			cout<<"this is a test ..."<<endl;
			sleep(1);
		}
	}

	void MemberFun2(int x)
	{
		while (count_--)
		{
			cout<<"x="<<x<<" this is a test2 ..."<<endl;
			sleep(1);
		}
	}

	int count_;
};

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

void ThreadFunc2(int count)
{
	while (count--)
	{
		cout<<"ThreadFunc2 ..."<<endl;
		sleep(1);
	}
}


int main(void)
{
    //分别用普通函数和类的成员函数测试
	Thread t1(ThreadFunc);
	Thread t2(boost::bind(ThreadFunc2, 3));
	Foo foo(3);
	Thread t3(boost::bind(&Foo::MemberFun, &foo));
	Foo foo2(3);
	Thread t4(boost::bind(&Foo::MemberFun2, &foo2, 1000));

	t1.Start();
	t2.Start();
	t3.Start();
	t4.Start();

	t1.Join();
	t2.Join();
	t3.Join();
	t4.Join();


	return 0;
}