C++11下的线程池以及灵活的functional + bind + lamda

来源：互联网发布：php注册登录系统源码编辑：程序博客网时间：2024/04/30 04:33

最近学习了一些C++11的文章，急着动手玩一玩。这次，打算利用boost的thread实现一个线程类，维护一个任务队列，以便可以承载非常灵活的调用。这个线程类可以方便的为后面的线程池打好基础。线程池还是动态均衡，没有什么别的。由于minGW 4.7 对 C++11 thread 不支持，所以采用 boost 代替，linux 下是支持的，只是名字空间不同而已，套路都一样。先上代码：

[cpp] view plaincopy

#include <iostream>
#include <boost/thread/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <functional>
#include <list>
#include <atomic>
#include <vector>
#include <stdlib.h>
#include <time.h>
#include <assert.h>
#include <memory>
//This class defines a class contains a thread, a task queue
class cpp11_thread
{
public:
cpp11_thread()
:m_b_is_finish(false)
,m_pthread(nullptr)
{
}
~cpp11_thread()
{
if (m_pthread != nullptr)
delete m_pthread;
m_list_tasks.clear();
}
public:
//wait until this thread is terminated;
void join() {
terminate();
if (m_pthread!=nullptr)
m_pthread->join();
}
//wait until this thread has no tasks pending.
void wait_for_idle()
{
while(load())
boost::this_thread::sleep(boost::posix_time::milliseconds(200));
}
//set the mask to termminiate
void terminate() {m_b_is_finish = true; m_cond_incoming_task.notify_one();}
//return the current load of this thread
size_t load()
{
size_t sz = 0;
m_list_tasks_mutex.lock();
sz = m_list_tasks.size();
m_list_tasks_mutex.unlock();
return sz;
}
//Append a task to do
size_t append(std::function< void (void) > func)
{
if (m_pthread==nullptr)
m_pthread = new boost::thread(std::bind(&cpp11_thread::run,this));
size_t sz = 0;
m_list_tasks_mutex.lock();
m_list_tasks.push_back(func);
sz = m_list_tasks.size();
//if there were no tasks before, we should notidy the thread to do next job.
if (sz==1)
m_cond_incoming_task.notify_one();
m_list_tasks_mutex.unlock();
return sz;
}
protected:
std::atomic< bool> m_b_is_finish; //atomic bool var to mark the thread the next loop will be terminated.
std::list<std::function< void (void)> > m_list_tasks; //The Task List contains function objects
boost::mutex m_list_tasks_mutex; //The mutex with which we protect task list
boost::thread *m_pthread; //inside the thread, a task queue will be maintained.
boost::mutex m_cond_mutex; //condition mutex used by m_cond_locker
boost::condition_variable m_cond_incoming_task; //condition var with which we notify the thread for incoming tasks
protected:
void run()
{
// loop wait
while (!m_b_is_finish)
{
std::function< void (void)> curr_task ;
bool bHasTasks = false;
m_list_tasks_mutex.lock();
if (m_list_tasks.empty()==false)
{
bHasTasks = true;
curr_task = *m_list_tasks.begin();
}
m_list_tasks_mutex.unlock();
//doing task
if (bHasTasks)
{
curr_task();
m_list_tasks_mutex.lock();
m_list_tasks.pop_front();
m_list_tasks_mutex.unlock();
}
if (!load())
{
boost::unique_lock< boost::mutex> m_cond_locker(m_cond_mutex);
boost::system_time const timeout=boost::get_system_time()+ boost::posix_time::milliseconds(5000);
if (m_cond_locker.mutex())
m_cond_incoming_task.timed_wait(m_cond_locker,timeout);//m_cond_incoming_task.wait(m_cond_locker);
}
}
}
};
//the thread pool class
class cpp11_thread_pool
{
public:
cpp11_thread_pool(int nThreads)
:m_n_threads(nThreads)
{
assert(nThreads>0 && nThreads<=512);
for (int i = 0; i< nThreads ;i++)
m_vec_threads.push_back(std::shared_ptr<cpp11_thread>(new cpp11_thread()));
}
~cpp11_thread_pool()
{
}
public:
//total threads;
size_t count(){return m_vec_threads.size();}
//wait until all threads is terminated;
void join()
{
for_each(m_vec_threads.begin(),m_vec_threads.end(),[this](std::shared_ptr<cpp11_thread> & item)
{
item->terminate();
item->join();
});
}
//wait until this thread has no tasks pending.
void wait_for_idle()
{
int n_tasks = 0;
do
{
if (n_tasks)
boost::this_thread::sleep(boost::posix_time::milliseconds(200));
n_tasks = 0;
for_each(m_vec_threads.begin(),m_vec_threads.end(),[this,&n_tasks](std::shared_ptr<cpp11_thread> & item)
{
n_tasks += item->load();
});
}while (n_tasks);
}
//set the mask to termminiate
void terminate()
{
for_each(m_vec_threads.begin(),m_vec_threads.end(),[this](std::shared_ptr<cpp11_thread> & item)
{
item->terminate();
});
}
//return the current load of this thread
size_t load(int n)
{
return (n>=m_vec_threads.size())?0:m_vec_threads[n]->load();
}
//Append a task to do
void append(std::function< void (void) > func)
{
int nIdx = -1;
unsigned int nMinLoad = -1;
for (unsigned int i=0;i<m_n_threads;i++)
{
if (nMinLoad> m_vec_threads[i]->load())
{
nMinLoad = m_vec_threads[i]->load();
nIdx = i;
}
}
assert(nIdx>=0 && nIdx<m_n_threads);
m_vec_threads[nIdx]->append(func);
}
protected:
//NO. threads
int m_n_threads;
//vector contains all the threads
std::vector<std::shared_ptr<cpp11_thread> > m_vec_threads;
};
//a function which will be executed in sub thread.
void hello()
{
//sleep for a while
boost::this_thread::sleep(boost::posix_time::milliseconds(rand()%900+100));
std::cout <<
"Hello world, I'm a function runing in a thread!"
<< std::endl;
}
//a class has a method, which will be called in a thread different from the main thread.
class A
{
private:
int m_n;
public:
A(int n)
:m_n(n)
{}
~A(){}
public:
void foo (int k)
{
//sleep for a while
boost::this_thread::sleep(boost::posix_time::milliseconds(rand()%900+100));
std::cout <<"n*k = "<<k*m_n<<std::endl;
m_n++;
}
};
//let's test the thread.
int main()
{
cpp11_thread_pool thread(2);
srand((unsigned int)time(0));
A a(1),b(2),c(3);
int nsleep = rand()%900+100;
//append a simple function task
thread.append(&hello);
//append lamda
thread.append
(
[&nsleep]()
{
boost::this_thread::sleep(boost::posix_time::milliseconds(nsleep));
std::cout<<"I'm a lamda runing in a thread"<<std::endl;
}
);
//append object method with copy-constructor(value-assignment)
thread.append(std::bind(&A::foo,a,10));
thread.append(std::bind(&A::foo,b,11));
thread.append(std::bind(&A::foo,c,12));
thread.append(std::bind(&A::foo,a,100));
//append object method with address assignment, will cause the objects' member increase.
thread.append(std::bind(&A::foo,&a,10));
thread.append(std::bind(&A::foo,&b,11));
thread.append(std::bind(&A::foo,&c,12));
thread.append(std::bind(&A::foo,&a,100));
//wait for all tasks done.
thread.wait_for_idle();
//kill
thread.terminate();
//wait for killed
thread.join();
//test function
std::function < void (void) > func1 = &hello;
std::function < void (void) > func2 = &hello;
if (func1.target<void (void) >()!=func2.target<void (void)>())
return 0;
else
return 1;
}

程序输出:

[plain] view plaincopy

Hello world, I'm a function runing in a thread!
I'm a lamda runing in a thread
n*k = 22
n*k = 10
n*k = 36
n*k = 100
n*k = 22
n*k = 10
n*k = 36
n*k = 200
Process returned 0 (0x0) execution time : 2.891 s
Press any key to continue.

下面来看看代码。首先是线程类。

第13-99行是线程类。该类实现了一个带任务队列的线程模型。关键部件是62行的std::list<std::function< void (void)> > m_list_tasks; ，这个fifo 用来承载顺序在子线程运行的任务。任务通过48行的append方法进行追加，64行m_list_tasks_mutex是一个mutex，来保护队列的进出。65行定义的线程对象boost::thread在构造函数中初始化并运行，绑定了本对象的run方法。线程得以运行的关键是run方法，在71-99行定义。该方法首先判断是否有pending的任务，有的话就弹出来执行。如果任务做完了，则使用67行定义的条件变量m_cond_incoming_task 进行wait, 直到新的任务到来，在第56行触发条件，激活队列。

线程类还提供了一些方法，比如load()返回队列的大小，以及terminate终止线程。而后，转到线程池。线程池采用最简单的策略，即直接分配给最空闲的线程。

有了上述封装，main函数就简单多了。可以append几乎所有的东西到线程池，这是以前简单的利用 virtual function 很难做到的。

0 0