# CMakeList.txt: ThreadDemo1 的 CMake 项目，在此处包括源代码并定义
# 项目特定的逻辑。
#
cmake_minimum_required (VERSION 3.8)
# 将源代码添加到此项目的可执行文件。
set(INC_LIST
./Task.h
./Producer.h
./ThreadPool.h
./CommonCond.h
)
set(SRC_LIST
./Task.cpp
./Producer.cpp
./ThreadPool.cpp
./CommonCond.cpp
./main.cpp
)
add_executable (ThreadDemo2 ${INC_LIST} ${SRC_LIST})
# TODO: 如有需要，请添加测试并安装目标。
#include "Producer.h"
#include "ThreadPool.h"
int main() {
Producer* producer=new Producer();
producer->produceTask(100000);
ThreadPool::instance()->start();
getchar();
return 0;
}
#ifndef _COMMON_COND_H_
#define _COMMON_COND_H_
#include <condition_variable>
#include <mutex>
class CommonCond {
protected:
static std::condition_variable m_cond;
static std::mutex m_mutex;
};
#endif
#include "CommonCond.h"
std::condition_variable CommonCond::m_cond;
std::mutex CommonCond::m_mutex;
#ifndef _PRODUCER_H_
#define _PRODUCER_H_
#include "CommonCond.h"
class Producer :public CommonCond{
public:
void runProduce(int num);
void produceTask(int taskNum);
};
#endif //_PRODUCER_H_
#include "Producer.h"
#include "ThreadPool.h"
#include "Task.h"
void Producer::runProduce(int num)
{
/*std::thread th(&Producer::produceTask,num,this,ThreadPool::instance());
th.join();*/
}
void Producer::produceTask(int taskNum) {
for (int i = 0; i < taskNum; i++)
{
ThreadPool::instance()->addTask(Task(i));
}
}
#ifndef _TASK_H_
#define _TASK_H_
#include <mutex>
class Task {
public:
explicit Task(int nNumber = 0);
void operator ()(int id);
private:
int m_nNumber;
static std::mutex m_mutex;
};
#endif // !_TASK_H_
#include "Task.h"
#include <iostream>
std::mutex Task::m_mutex;
Task::Task(int nNumber):m_nNumber(nNumber)
{
}
void Task::operator()(int id)
{
std::unique_lock<std::mutex> lk(m_mutex);
std::cout << "我是第: "<< id<<" 个工作者" << " 我是第 " << m_nNumber << " 任务！" << std::endl;
}
#ifndef _THREAD_POOL_H_
#define _THREAD_POOL_H_
#include "CommonCond.h"
#include <vector>
#include <thread>
#include <queue>
#include <functional>
class ThreadPool :public CommonCond {
using Task = std::function<void(int)>;
public:
static ThreadPool* instance();
void addTask(Task task);
void runTask(int id);
void initThreadPool();
~ThreadPool();
void start();
protected:
explicit ThreadPool();
private:
static ThreadPool* m_instance;
std::queue<Task> m_tasks;
std::vector<std::thread*> m_threads;
bool m_goFlag = false;
bool m_exitFlag = true;
};
#endif // ! _THREAD_POOL_H_
#include "ThreadPool.h"
#include "Task.h"
ThreadPool* ThreadPool::m_instance = nullptr;
ThreadPool* ThreadPool::instance()
{
if (m_instance == nullptr) {
m_instance = new ThreadPool();
}
return m_instance;
}
void ThreadPool::addTask(Task taskPtr)
{
m_tasks.push(taskPtr);
}
void ThreadPool::runTask(int id)
{
while (m_exitFlag)
{
Task task;
{
std::unique_lock<std::mutex> ulock(m_mutex);
m_cond.wait(ulock, [=]() {
return m_goFlag&&!m_tasks.empty();
});
task = m_tasks.front();
m_tasks.pop();
ulock.unlock();
m_cond.notify_all();
}
task(id);
}
}
void ThreadPool::initThreadPool()
{
for (size_t i = 0; i < 10; i++)
{
std::thread* threadPtr=new std::thread(&ThreadPool::runTask, this,i);
m_threads.push_back(threadPtr);
threadPtr->detach();
}
}
ThreadPool::~ThreadPool()
{
if (!m_threads.empty()) {
std::vector<std::thread*>::iterator iter = m_threads.begin();
for (; iter !=m_threads.end(); iter++)
{
delete (*iter);
}
}
}
void ThreadPool::start()
{
/*if (!m_threads.empty()) {
std::vector<std::thread*>::iterator iter = m_threads.begin();
for (; iter != m_threads.end(); iter++)
{
(*iter)->detach();
}
}*/
std::unique_lock<std::mutex> ulock(m_mutex);
m_goFlag = true;
m_cond.notify_all();
}
ThreadPool::ThreadPool()
{
initThreadPool();
}
附上截图
