C++11 可复用线程任务队列

本文 主要是解决一些实际项目中，添加一些耗时操作，放到线程队列中，处理完成后返回给UI线程；


用到一些知识点：
Functor 仿函数:又称为函数对象（function object）是一个能行使函数功能的类,其实现就是类中实现一个operator();
                      目的：迭代和计算逻辑分离;




//----------------------------------------仿函数;-------------------------------------------------------------------
//类是模板;
template<typename T>
class displayA
{
public:
void operator()(const T& x)
{
m_data = x;
cout << x << " ";
}


T m_data;
};


class display
{
public:


//类内的函数是模板;
template<typename T>
void operator()(const T& x)
{
cout << x << " ";
}
};


// 仿函数 添加多个参数;
class  displayB
{
public:
displayB(int lenth) : m_lenth(lenth) {}
template<typename T>
void operator()(const T& x)
{
cout << "x:  " << x << "lenth:  " << m_lenth << endl;
}
private:
int m_lenth;
};




struct Printer
{
template<typename T> 
void operator()(const T& x) {
cout << x << " ";
}
};




//--------------------------------------模板函数;---------------------------------------------------------
//模板函数;
template <typename T>
bool displayC(const T& x)
{
cout << x << " ";
return 1;


}


//-----------------------------删除指针----------------------------------------------
//for_each(m_users.begin(),m_users.end(), DeletePtr());
//仿函数删除指针;
struct  DeletePtr
{
template<typename T>
void operator()(const T* ptr) const
{
if (ptr)
delete ptr;
}
};


// map 的用法;
// std::map<long, CUserInfo*> m_users;
// for_each(m_users.begin(),m_users.end(),DeletePair())




struct DeletePair
{
template<typename Ty1,typename Ty2>
void operator()(const std::pair<Ty1, Ty2>& ptr) const
{
if (ptr.second)
delete ptr.second;
}
};


typedef std::function<void()> synJob;


template<typename T>
class SyncThread
{
public:
SyncThread() :m_ptrThread(nullptr)
{
m_mapSyncJob.clear();
m_syncJobIndex = -1;
}
~SyncThread(){}

// 添加耗时操作;
void AddJob(T oper)
{
AutoLock lk(m_mutex);
m_mapSyncJob[++m_syncJobIndex] = oper;
}
T GetJob(int index)
{
if (index >= m_mapSyncJob.size())
return nullptr;
return m_mapSyncJob[index];
}
void jobImp()
{
AutoLock lk(m_mutex);
for (auto iter = m_mapSyncJob.begin(); iter != m_mapSyncJob.end(); ++iter)
{
if (nullptr != iter->second){
iter->second();
}
}
}
void StartThread()
{
if (m_ptrThread.get()&& m_ptrThread->joinable()){
m_ptrThread->join();
}
m_ptrThread.reset();
m_ptrThread = make_shared<thread>(bind(&SyncThread::jobImp, this));
}


void WaitforAllJob()
{
if (nullptr != m_ptrThread.get() && m_ptrThread->joinable())
m_ptrThread->join();
m_mapSyncJob.clear();
m_syncJobIndex = -1;
}
private:
SyncThread(const SyncThread&);
SyncThread& operator = (const SyncThread&);


typedef std::lock_guard<mutex> AutoLock;
mutex m_mutex;
shared_ptr<thread> m_ptrThread;


map<int, T> m_mapSyncJob;
int m_syncJobIndex;
};




测试代码：
test（）
{
                shared_ptr<SyncThread<synJob>> ptrSynThread = make_shared<SyncThread<synJob>>();


                //主动添加一些耗时操作，类型自己定义；
ptrSynThread->AddJob([](){
this_thread::sleep_for(chrono::seconds(2));
cout << "sleep 1" << endl;
});
ptrSynThread->AddJob([](){
this_thread::sleep_for(chrono::seconds(2));
cout << "sleep 2" << endl;
});
ptrSynThread->AddJob([](){
this_thread::sleep_for(chrono::seconds(2));
cout << "sleep 3" << endl;
});
ptrSynThread->StartThread();
ptrSynThread->WaitforAllJob();


return;


}


本人技术有限，欢迎大家指正。 c++交流群 560664300  欢迎大家一起讨论技术