简单的线程池

最新推荐文章于 2022-07-12 21:13:07 发布
最新推荐文章于 2022-07-12 21:13:07 发布
阅读量161 收藏 1
点赞数
分类专栏： java  文章标签： 性能优化 java maven
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qigeminghao/article/details/121583667
版权

概要

此线程池拥有一个被所有工作线程共享的任务队列。线程池用户提交的任务，被线程池保存在任务队列中，工作线程从任务队列中获取任务并执行。

gist

任务是可拥有返回值的、无参数的可调用（callable）对象，或者是经 std::bind 绑定了可调用对象及其参数后的调用包装器。具体而言可以是

  • 自由函数（也称为全局函数）
  • lambda
  • 函数对象（也称为函数符）
  • 类成员函数
  • 包装了上述类型的 std::function
  • bind 调用包装器

该线程池异步地执行任务。当任务被提交进线程池后，用户不必等待任务执行和返回结果。

实现

以下代码给出了此线程池的实现。

 

class Thread_Pool {
private:
struct Task_Wrapper { ...
};
atomic<bool> _done_; // #2
Lockwise_Queue<Task_Wrapper> _queue_; // #3
unsigned _workersize_;
thread* _workers_; // #4
void work() {
while (!_done_.load(memory_order_acquire)) {
Task_Wrapper task;
if (_queue_.pop(task))
task();
else
std::this_thread::yield();
}
}
public:
Thread_Pool() : _done_(false) { // #1
try {
_workersize_ = thread::hardware_concurrency(); // #5
_workers_ = new thread[_workersize_];
for (unsigned i = 0; i < _workersize_; ++i) {
_workers_[i] = thread(&Thread_Pool::work, this); // #6
}
} catch (...) { // #7
_done_.store(true, memory_order_release);
for (unsigned i = 0; i < _workersize_; ++i) {
if (_workers_[i].joinable())
_workers_[i].join();
}
delete[] _workers_;
throw;
}
}
~Thread_Pool() {
_done_.store(true, memory_order_release);
for (unsigned i = 0; i < _workersize_; ++i) {
if (_workers_[i].joinable())
_workers_[i].join();
}
delete[] _workers_;
}
template<class Callable>
future<typename std::result_of<Callable()>::type> submit(Callable c) { // #8
typedef typename std::result_of<Callable()>::type R;
packaged_task<R()> task(c);
future<R> r = task.get_future();
_queue_.push(std::move(task)); // #9
return r; // #10
}
};
 

我们从构造 Thread_Pool 对象（#1）开始了解这个线程池。atomic<bool> 数据成员用于标志线程池是否结束，并强制同步内存顺序（#2）；Task_Wrapper 具体化了线程安全的任务队列 Lockwise_Queue<>（#3）；thread* 用于引用所有的工作线程对象（#4）。Task_Wrapper 和 Lockwise_Queue<> 稍后再做说明。
 

线程池通过 thread::hardware_concurrency() 获取当前硬件支持的并发线程数量（#5），并依据此数量创建出工作线程。Thread_Pool 对象的成员函数 work() 作为所有工作线程的初始函数（#6），这使得线程池中的任务队列能被所有工作线程共享。创建 thread 对象和 new 操作可能失败并引发异常，因此用 try-catch 捕获潜在的异常。处理异常过程中，需要标志线程池结束，保证任何创建的线程都能正常的停止，并回收内存资源（#7）。线程池对象析构时的工作与此一致。
 

Thread_Pool 对象构建完成后，任务通过 Thread_Pool::submit<>() 被提交进入线程池（#8）。为了支持任务的异步执行，任务先被封装在 std::packaged_task<> 中，再被放入线程安全的任务队列（#9）。任务执行结果被封装在返回的 std::future<> 对象中（#10），允许用户在未来需要结果时，等待任务结束并获取结果。
 


 因为每一个任务都是一个特定类型的 std::packaged_task<> 对象，为了实现任务队列的泛型化，需要设计一个通用的数据结构 Task_Wrapper，用于封装特定类型的 std::packaged_task<> 对象。
 

 

struct Task_Wrapper {
struct Task_Base {
virtual ~Task_Base() {}
virtual void call() = 0;
};
template<class T>
struct Task : Task_Base { // #5
T _t_;
Task(T&& t) : _t_(std::move(t)) {} // #6
void call() { _t_(); } // #9
};
Task_Base* _ptr_; // #7
Task_Wrapper() : _ptr_(nullptr) {};
template<class T>
Task_Wrapper(T&& t) : _ptr_(new Task<T>(std::move(t))) {} // #1
// support move
Task_Wrapper(Task_Wrapper&& other) { // #2
_ptr_ = other._ptr_;
other._ptr_ = nullptr;
}
Task_Wrapper& operator=(Task_Wrapper&& other) { // #3
_ptr_ = other._ptr_;
other._ptr_ = nullptr;
return *this;
}
// no copy
Task_Wrapper(Task_Wrapper&) = delete;
Task_Wrapper& operator=(Task_Wrapper&) = delete;
~Task_Wrapper() {
if (_ptr_) delete _ptr_;
}
void operator()() const { // #4
_ptr_->call(); // #8
}
};
 

std::packaged_task<> 的实例只是可移动的，而不可复制。Task_Wrapper 必须能移动封装 std::packaged_task<R()> 对象（#1）。为了保持一致性，Task_Wrapper 也实现了移动构造（#2）和移动赋值（#3），同时实现了 operator()（#4）。ABC 的继承结构（#5）用于支持泛型化地封装和调用 std::packaged_task<> 对象。std::packaged_task<> 封装在派生类 Task<> 中（#6），由指向非泛型的抽象基类 Task_Base 的指针引用派生类对象（#7）。对 Task_Wrapper 对象的调用由虚调用（#8）委托给派生类并执行实际的任务（#9）。
 


 另一个关键的数据结构是线程安全的任务队列 Lockwise_Queue<>。
 

 

template<class T>
class Lockwise_Queue {
private:
struct Spinlock_Mutex { // #3
atomic_flag _af_;
Spinlock_Mutex() : _af_(false) {}
void lock() {
while (_af_.test_and_set(memory_order_acquire));
}
void unlock() {
_af_.clear(memory_order_release);
}
} mutable _m_; // #2
queue<T> _q_; // #1
public:
Lockwise_Queue() {}
void push(const T& element) {
lock_guard<Spinlock_Mutex> lk(_m_);
_q_.push(std::move(element));
}
void push(T&& element) { // #4
lock_guard<Spinlock_Mutex> lk(_m_);
_q_.push(std::move(element));
}
bool pop(T& element) { // #5
lock_guard<Spinlock_Mutex> lk(_m_);
if (_q_.empty())
return false;
element = std::move(_q_.front());
_q_.pop();
return true;
}
bool empty() const {
lock_guard<Spinlock_Mutex> lk(_m_);
return _q_.empty();
}
};
 

所有 Task_Wrapper 对象保存在 std::queue<> 中（#1）。互斥元控制工作线程对任务队列的并发访问（#2）。为了提高并发程度，采用非阻塞自旋锁作为互斥元（#3）。任务的入队和出队操作，分别由支持移动语义的 push 函数（#4） 和 pop 函数（#5）完成。
 

逻辑
 

以下类图展现了此线程池的代码主要逻辑结构。
 

class
 

[注] 图中用构造型（stereotype）标识出工作线程的初始函数，并在注解中补充说明此关系。
 

以下顺序图展现了线程池用户提交任务与工作线程执行任务的并发过程。
 

sequence
 

验证
 

为了验证此线程池满足概要中描述的能力，设计了如下的各类可调用对象。
 

 

void shoot() {
std::printf("\n\t[Free Function] Let an arrow fly...\n");
}
bool shoot(long n) {
std::printf("\n\t[Free Function] Let %ld arrows fly...\n", n);
return false;
}
auto shootAnarrow = [] {
std::printf("\n\t[Lambda] Let an arrow fly...\n");
};
auto shootNarrows = [](long n) -> bool {
std::printf("\n\t[Lambda] Let %ld arrows fly...\n", n);
return true;
};
class Archer {
public:
void operator()() {
std::printf("\n\t[Functor] Let an arrow fly...\n");
}
bool operator()(long n) {
std::printf("\n\t[Functor] Let %ld arrows fly...\n", n);
return false;
}
void shoot() {
std::printf("\n\t[Member Function] Let an arrow fly...\n");
}
bool shoot(long n) {
std::printf("\n\t[Member Function] Let %ld arrows fly...\n", n);
return true;
}
};
 

对这些函数做好必要的参数封装，将其提交给线程池，
 

 

atomic<bool> go(false); 
time_point<steady_clock> start = steady_clock::now();
minutes PERIOD(1);
Thread_Pool pool;
thread t1([&go, &pool, &PERIOD, start] { // test free function of void() 
while (!go.load(memory_order_acquire))
std::this_thread::yield();
void (*task)() = shoot;
for (long x = 0; steady_clock::now() - start <= PERIOD; ++x) {
pool.submit(task);
//pool.submit(std::bind<void(*)()>(shoot));
std::this_thread::yield();
}
});
thread t2([&go, &pool, &PERIOD, start] { // test free function of bool(long)
while (!go.load(memory_order_acquire))
std::this_thread::yield();
bool (*task)(long) = shoot;
for (long x = 2; steady_clock::now() - start <= PERIOD; ++x) {
future<bool> r = pool.submit(std::bind(task, x));
//future<bool> r = pool.submit(std::bind<bool(*)(long)>(shoot, x));
std::this_thread::yield();
}
});
thread t3([&go, &pool, &PERIOD, start] { // test lambda of void()
while (!go.load(memory_order_acquire))
std::this_thread::yield();
for (long x = 0; steady_clock::now() - start <= PERIOD; ++x) {
pool.submit(shootAnarrow);
std::this_thread::yield();
}
});
thread t4([&go, &pool, &PERIOD, start] { // test lambda of bool(long)
while (!go.load(memory_order_acquire))
std::this_thread::yield();
for (long x = 2; steady_clock::now() - start <= PERIOD; ++x) {
future<bool> r = pool.submit(std::bind(shootNarrows, x));
std::this_thread::yield();
}
});
thread t5([&go, &pool, &PERIOD, start] { // test functor of void()
while (!go.load(memory_order_acquire))
std::this_thread::yield();
Archer hoyt;
for (long x = 0; steady_clock::now() - start <= PERIOD; ++x) {
pool.submit(hoyt);
std::this_thread::yield();
}
});
thread t6([&go, &pool, &PERIOD, start] { // test functor of bool(long)
while (!go.load(memory_order_acquire))
std::this_thread::yield();
Archer hoyt;
for (long x = 2; steady_clock::now() - start <= PERIOD; ++x) {
future<bool> r = pool.submit(std::bind(hoyt, x));
std::this_thread::yield();
}
});
thread t7([&go, &pool, &PERIOD, start] { // test member function of void()
while (!go.load(memory_order_acquire))
std::this_thread::yield();
Archer hoyt;
for (long x = 0; steady_clock::now() - start <= PERIOD; ++x) {
pool.submit(std::bind<void(Archer::*)()>(&Archer::shoot, &hoyt));
//pool.submit(std::bind(static_cast<void(Archer::*)()>(&Archer::shoot), &hoyt));
std::this_thread::yield();
}
});
thread t8([&go, &pool, &PERIOD, start] { // test member function of bool(long)
while (!go.load(memory_order_acquire))
std::this_thread::yield();
Archer hoyt;
for (long x = 2; steady_clock::now() - start <= PERIOD; ++x) {
future<bool> r = pool.submit(std::bind<bool(Archer::*)(long)>(&Archer::shoot, &hoyt, x));
//future<bool> r = pool.submit(std::bind(static_cast<bool(Archer::*)(long)>(&Archer::shoot), &hoyt, x));
std::this_thread::yield();
}
});
thread t9([&go, &pool, &PERIOD, start] { // test std::function<> of void()
while (!go.load(memory_order_acquire))
std::this_thread::yield();
std::function<void()> task = static_cast<void(*)()>(shoot);
for (long x = 0; steady_clock::now() - start <= PERIOD; ++x) {
pool.submit(task);
std::this_thread::yield();
}
});
thread t10([&go, &pool, &PERIOD, start] { // test std::function<> of bool(long)
while (!go.load(memory_order_acquire))
std::this_thread::yield();
std::function<bool(long)> task = static_cast<bool(*)(long)>(shoot);
for (long x = 2; steady_clock::now() - start <= PERIOD; ++x) {
future<bool> r = pool.submit(std::bind(task, x));
std::this_thread::yield();
}
});
 

编译代码 g++ -std=c++11 a_simple_thread_pool.cpp 成功后执行 ./a.out。以下是执行过程中的部分输出，
 

 

...
[Functor] Let an arrow fly...
[Free Function] Let 9224 arrows fly...
[Free Function] Let 9445 arrows fly...
[Member Function] Let 9375 arrows fly...
[Lambda] Let 9449 arrows fly...
[Free Function] Let an arrow fly...
[Lambda] Let an arrow fly...
[Member Function] Let an arrow fly...
[Functor] Let 9469 arrows fly...
...
 

最后
 

完整示例请参考 [github] a_simple_thread_pool 。
 

作者参考了 C++并发编程实战 / （美）威廉姆斯 (Williams, A.) 著; 周全等译. - 北京: 人民邮电出版社, 2015.6 (2016.4重印) 一书中的部分设计思路。致 Anthony Williams、周全等译者。
 

受限于作者的 C++ 编程和 UML 建模的水平，读者如发现有任何错误或有疑问之处，请追加评论或发邮件联系 15040298@qq.com。作者将在收到意见后的第一时间里予以回复。谢谢！# 概要
 

此线程池拥有一个被所有工作线程共享的任务队列。线程池用户提交的任务，被线程池保存在任务队列中，工作线程从任务队列中获取任务并执行。
 

gist
 

任务是可拥有返回值的、无参数的可调用（callable）对象，或者是经 std::bind 绑定了可调用对象及其参数后的调用包装器。具体而言可以是
 

  • 自由函数（也称为全局函数）
  • lambda
  • 函数对象（也称为函数符）
  • 类成员函数
  • 包装了上述类型的 std::function
  • bind 调用包装器
 

该线程池异步地执行任务。当任务被提交进线程池后，用户不必等待任务执行和返回结果。
 

实现
 

以下代码给出了此线程池的实现。
 

 

class Thread_Pool {
private:
struct Task_Wrapper { ...
};
atomic<bool> _done_; // #2
Lockwise_Queue<Task_Wrapper> _queue_; // #3
unsigned _workersize_;
thread* _workers_; // #4
void work() {
while (!_done_.load(memory_order_acquire)) {
Task_Wrapper task;
if (_queue_.pop(task))
task();
else
std::this_thread::yield();
}
}
public:
Thread_Pool() : _done_(false) { // #1
try {
_workersize_ = thread::hardware_concurrency(); // #5
_workers_ = new thread[_workersize_];
for (unsigned i = 0; i < _workersize_; ++i) {
_workers_[i] = thread(&Thread_Pool::work, this); // #6
}
} catch (...) { // #7
_done_.store(true, memory_order_release);
for (unsigned i = 0; i < _workersize_; ++i) {
if (_workers_[i].joinable())
_workers_[i].join();
}
delete[] _workers_;
throw;
}
}
~Thread_Pool() {
_done_.store(true, memory_order_release);
for (unsigned i = 0; i < _workersize_; ++i) {
if (_workers_[i].joinable())
_workers_[i].join();
}
delete[] _workers_;
}
template<class Callable>
future<typename std::result_of<Callable()>::type> submit(Callable c) { // #8
typedef typename std::result_of<Callable()>::type R;
packaged_task<R()> task(c);
future<R> r = task.get_future();
_queue_.push(std::move(task)); // #9
return r; // #10
}
};
 

我们从构造 Thread_Pool 对象（#1）开始了解这个线程池。atomic<bool> 数据成员用于标志线程池是否结束，并强制同步内存顺序（#2）；Task_Wrapper 具体化了线程安全的任务队列 Lockwise_Queue<>（#3）；thread* 用于引用所有的工作线程对象（#4）。Task_Wrapper 和 Lockwise_Queue<> 稍后再做说明。
 

线程池通过 thread::hardware_concurrency() 获取当前硬件支持的并发线程数量（#5），并依据此数量创建出工作线程。Thread_Pool 对象的成员函数 work() 作为所有工作线程的初始函数（#6），这使得线程池中的任务队列能被所有工作线程共享。创建 thread 对象和 new 操作可能失败并引发异常，因此用 try-catch 捕获潜在的异常。处理异常过程中，需要标志线程池结束，保证任何创建的线程都能正常的停止，并回收内存资源（#7）。线程池对象析构时的工作与此一致。
 

Thread_Pool 对象构建完成后，任务通过 Thread_Pool::submit<>() 被提交进入线程池（#8）。为了支持任务的异步执行，任务先被封装在 std::packaged_task<> 中，再被放入线程安全的任务队列（#9）。任务执行结果被封装在返回的 std::future<> 对象中（#10），允许用户在未来需要结果时，等待任务结束并获取结果。
 


 因为每一个任务都是一个特定类型的 std::packaged_task<> 对象，为了实现任务队列的泛型化，需要设计一个通用的数据结构 Task_Wrapper，用于封装特定类型的 std::packaged_task<> 对象。
 

 

struct Task_Wrapper {
struct Task_Base {
virtual ~Task_Base() {}
virtual void call() = 0;
};
template<class T>
struct Task : Task_Base { // #5
T _t_;
Task(T&& t) : _t_(std::move(t)) {} // #6
void call() { _t_(); } // #9
};
Task_Base* _ptr_; // #7
Task_Wrapper() : _ptr_(nullptr) {};
template<class T>
Task_Wrapper(T&& t) : _ptr_(new Task<T>(std::move(t))) {} // #1
// support move
Task_Wrapper(Task_Wrapper&& other) { // #2
_ptr_ = other._ptr_;
other._ptr_ = nullptr;
}
Task_Wrapper& operator=(Task_Wrapper&& other) { // #3
_ptr_ = other._ptr_;
other._ptr_ = nullptr;
return *this;
}
// no copy
Task_Wrapper(Task_Wrapper&) = delete;
Task_Wrapper& operator=(Task_Wrapper&) = delete;
~Task_Wrapper() {
if (_ptr_) delete _ptr_;
}
void operator()() const { // #4
_ptr_->call(); // #8
}
};
 

std::packaged_task<> 的实例只是可移动的，而不可复制。Task_Wrapper 必须能移动封装 std::packaged_task<R()> 对象（#1）。为了保持一致性，Task_Wrapper 也实现了移动构造（#2）和移动赋值（#3），同时实现了 operator()（#4）。ABC 的继承结构（#5）用于支持泛型化地封装和调用 std::packaged_task<> 对象。std::packaged_task<> 封装在派生类 Task<> 中（#6），由指向非泛型的抽象基类 Task_Base 的指针引用派生类对象（#7）。对 Task_Wrapper 对象的调用由虚调用（#8）委托给派生类并执行实际的任务（#9）。
 


 另一个关键的数据结构是线程安全的任务队列 Lockwise_Queue<>。
 

 

template<class T>
class Lockwise_Queue {
private:
struct Spinlock_Mutex { // #3
atomic_flag _af_;
Spinlock_Mutex() : _af_(false) {}
void lock() {
while (_af_.test_and_set(memory_order_acquire));
}
void unlock() {
_af_.clear(memory_order_release);
}
} mutable _m_; // #2
queue<T> _q_; // #1
public:
Lockwise_Queue() {}
void push(const T& element) {
lock_guard<Spinlock_Mutex> lk(_m_);
_q_.push(std::move(element));
}
void push(T&& element) { // #4
lock_guard<Spinlock_Mutex> lk(_m_);
_q_.push(std::move(element));
}
bool pop(T& element) { // #5
lock_guard<Spinlock_Mutex> lk(_m_);
if (_q_.empty())
return false;
element = std::move(_q_.front());
_q_.pop();
return true;
}
bool empty() const {
lock_guard<Spinlock_Mutex> lk(_m_);
return _q_.empty();
}
};
 

所有 Task_Wrapper 对象保存在 std::queue<> 中（#1）。互斥元控制工作线程对任务队列的并发访问（#2）。为了提高并发程度，采用非阻塞自旋锁作为互斥元（#3）。任务的入队和出队操作，分别由支持移动语义的 push 函数（#4） 和 pop 函数（#5）完成。
 

逻辑
 

以下类图展现了此线程池的代码主要逻辑结构。
 

class
 

[注] 图中用构造型（stereotype）标识出工作线程的初始函数，并在注解中加以说明调用关系。
 

以下顺序图展现了线程池用户提交任务与工作线程执行任务的并发过程。
 

sequence
 

验证
 

为了验证此线程池满足概要中描述的能力，设计了如下的各类可调用对象。
 

 

void shoot() {
std::printf("\n\t[Free Function] Let an arrow fly...\n");
}
bool shoot(long n) {
std::printf("\n\t[Free Function] Let %ld arrows fly...\n", n);
return false;
}
auto shootAnarrow = [] {
std::printf("\n\t[Lambda] Let an arrow fly...\n");
};
auto shootNarrows = [](long n) -> bool {
std::printf("\n\t[Lambda] Let %ld arrows fly...\n", n);
return true;
};
class Archer {
public:
void operator()() {
std::printf("\n\t[Functor] Let an arrow fly...\n");
}
bool operator()(long n) {
std::printf("\n\t[Functor] Let %ld arrows fly...\n", n);
return false;
}
void shoot() {
std::printf("\n\t[Member Function] Let an arrow fly...\n");
}
bool shoot(long n) {
std::printf("\n\t[Member Function] Let %ld arrows fly...\n", n);
return true;
}
};
 

对这些函数做好必要的参数封装，将其提交给线程池，
 

 

atomic<bool> go(false); 
time_point<steady_clock> start = steady_clock::now();
minutes PERIOD(1);
Thread_Pool pool;
thread t1([&go, &pool, &PERIOD, start] { // test free function of void() 
while (!go.load(memory_order_acquire))
std::this_thread::yield();
void (*task)() = shoot;
for (long x = 0; steady_clock::now() - start <= PERIOD; ++x) {
pool.submit(task);
//pool.submit(std::bind<void(*)()>(shoot));
std::this_thread::yield();
}
});
thread t2([&go, &pool, &PERIOD, start] { // test free function of bool(long)
while (!go.load(memory_order_acquire))
std::this_thread::yield();
bool (*task)(long) = shoot;
for (long x = 2; steady_clock::now() - start <= PERIOD; ++x) {
future<bool> r = pool.submit(std::bind(task, x));
//future<bool> r = pool.submit(std::bind<bool(*)(long)>(shoot, x));
std::this_thread::yield();
}
});
thread t3([&go, &pool, &PERIOD, start] { // test lambda of void()
while (!go.load(memory_order_acquire))
std::this_thread::yield();
for (long x = 0; steady_clock::now() - start <= PERIOD; ++x) {
pool.submit(shootAnarrow);
std::this_thread::yield();
}
});
thread t4([&go, &pool, &PERIOD, start] { // test lambda of bool(long)
while (!go.load(memory_order_acquire))
std::this_thread::yield();
for (long x = 2; steady_clock::now() - start <= PERIOD; ++x) {
future<bool> r = pool.submit(std::bind(shootNarrows, x));
std::this_thread::yield();
}
});
thread t5([&go, &pool, &PERIOD, start] { // test functor of void()
while (!go.load(memory_order_acquire))
std::this_thread::yield();
Archer hoyt;
for (long x = 0; steady_clock::now() - start <= PERIOD; ++x) {
pool.submit(hoyt);
std::this_thread::yield();
}
});
thread t6([&go, &pool, &PERIOD, start] { // test functor of bool(long)
while (!go.load(memory_order_acquire))
std::this_thread::yield();
Archer hoyt;
for (long x = 2; steady_clock::now() - start <= PERIOD; ++x) {
future<bool> r = pool.submit(std::bind(hoyt, x));
std::this_thread::yield();
}
});
thread t7([&go, &pool, &PERIOD, start] { // test member function of void()
while (!go.load(memory_order_acquire))
std::this_thread::yield();
Archer hoyt;
for (long x = 0; steady_clock::now() - start <= PERIOD; ++x) {
pool.submit(std::bind<void(Archer::*)()>(&Archer::shoot, &hoyt));
//pool.submit(std::bind(static_cast<void(Archer::*)()>(&Archer::shoot), &hoyt));
std::this_thread::yield();
}
});
thread t8([&go, &pool, &PERIOD, start] { // test member function of bool(long)
while (!go.load(memory_order_acquire))
std::this_thread::yield();
Archer hoyt;
for (long x = 2; steady_clock::now() - start <= PERIOD; ++x) {
future<bool> r = pool.submit(std::bind<bool(Archer::*)(long)>(&Archer::shoot, &hoyt, x));
//future<bool> r = pool.submit(std::bind(static_cast<bool(Archer::*)(long)>(&Archer::shoot), &hoyt, x));
std::this_thread::yield();
}
});
thread t9([&go, &pool, &PERIOD, start] { // test std::function<> of void()
while (!go.load(memory_order_acquire))
std::this_thread::yield();
std::function<void()> task = static_cast<void(*)()>(shoot);
for (long x = 0; steady_clock::now() - start <= PERIOD; ++x) {
pool.submit(task);
std::this_thread::yield();
}
});
thread t10([&go, &pool, &PERIOD, start] { // test std::function<> of bool(long)
while (!go.load(memory_order_acquire))
std::this_thread::yield();
std::function<bool(long)> task = static_cast<bool(*)(long)>(shoot);
for (long x = 2; steady_clock::now() - start <= PERIOD; ++x) {
future<bool> r = pool.submit(std::bind(task, x));
std::this_thread::yield();
}
});
 

编译代码 g++ -std=c++11 a_simple_thread_pool.cpp 成功后执行 ./a.out。以下是执行过程中的部分输出，
 

 

...
[Functor] Let an arrow fly...
[Free Function] Let 9224 arrows fly...
[Free Function] Let 9445 arrows fly...
[Member Function] Let 9375 arrows fly...
[Lambda] Let 9449 arrows fly...
[Free Function] Let an arrow fly...
[Lambda] Let an arrow fly...
[Member Function] Let an arrow fly...
[Functor] Let 9469 arrows fly...
...

                

        

        

    




    

      

        

            

              
                
                  面向bug，春暖花开
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    1
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
简单线程池的实现

				
			

			

				

					chengonghao的博客
				

				

					06-30
					
					2066
					
				

			

		

		

			
				
1. 什么是线程池
线程池是线程的集合，拥有若干个线程，线程池中的线程一般用于执行大量的且相对短暂的任务。如果一个任务执行的时间很长，那么就不适合放在线程池中处理，比如说一个任务的执行时间跟进程的生命周期是一致的，那么这个线程的处理就没有必要放到线程池中调度，用一个普通线程即可。


线程池中线程的个数太少的话会降低系统的并发量，太多的话又会增加系统的开销。一般而言，线程池中线程的个数与线

			
		

	



                

              
                



	

		

			

				
					
线程池的简单实现

				
			

			

				

					Damon_X的博客
				

				

					10-10
					
					178
					
				

			

		

		

			
				
网上摘来修改了一下：

threadpool.h：

#ifndef

THREADPOOL_H

#define

THREADPOOL_H





#include

<thread>

#include

<condition_variable>

#include

<mutex>

#include

<vector>

#include

<queue>

#include

<future>





class...

			
		

	



                


  
              

                


	

		

			

				
					
简单实现线程池

				
			

			

				

					仟各的博客
				

				

					05-01
					
					1487
					
				

			

		

		

			
				
1.线程池的基本概念



2.使用线程池的目的

3.线程池工作原理

3.1主要组成：

3.2工作情况：

3.3代码实现：


			
		

	





	

		

			

				
					
这是一个使用C++实现的简易线程池.zip

					
最新发布

				
			

			

				

					03-08
				

			

		

		

			
				
这是一个使用C++实现的简易线程池.zip这是一个使用C++实现的简易线程池.zip这是一个使用C++实现的简易线程池.zip这是一个使用C++实现的简易线程池.zip这是一个使用C++实现的简易线程池.zip这是一个使用C++实现的简易...

			
		

	



		

			
		



	

		

			

				
					
C语言实现简单线程池.zip

				
			

			

				

					09-05
				

			

		

		

			
				
在本项目"简单线程池"中，我们将重点探讨如何用C语言在Linux环境下实现这样一个线程池系统，特别是关注其核心组件和设计原则。  首先，线程池的核心概念是线程复用，通过预先创建一组线程，可以避免频繁地创建和销毁...

			
		

	





	

		

			

				
					
easy-threadpool:简易线程池

				
			

			

				

					05-14
				

			

		

		

			
				
《简易线程池——easy-threadpool深度解析》  在Java编程中，线程池是一种管理线程资源的有效方式，它可以提高系统性能、避免资源浪费，同时简化并发编程的复杂性。今天我们将深入探讨一个名为“easy-threadpool”的...

			
		

	





	

		

			

				
					
C++11 简易线程池实现

				
			

			

				

					03-15
				

			

		

		

			
				
简易的C++11线程池实现，线程池为固定方式，后面会新增非固定模式。

			
		

	





	

		

			

				
					
一个简单的线程池例子

				
			

			

				

					09-17
				

			

		

		

			
				
一个简单的线程池例子;

			
		

	





	

		

			

				
					
简单线程池与线程池检查的实现

				
			

			

				

					04-13
				

			

		

		

			
				
标题 "简单线程池与线程池检查的实现" 涉及到的是计算机编程中的多线程管理和优化，特别是线程池的概念及其检查机制。线程池是一种多线程处理形式，预先创建一定数量的线程，放入池中，当有任务需要执行时，直接从池...

			
		

	





	

		

			

				
					
简单线程池实现

				
			

			

				

					Alatebloomer的博客
				

				

					08-22
					
					394
					
				

			

		

		

			
				
 

目标

1.用于执行大量相对短暂的任务
2.当任务增加的时候能够动态的增加线程池中线程的数量值到达一个阈值
3.当任务执行完毕的时候，能够动态的销毁线程池中的线程
4.该线程池的实现本质上也是生产者与消费者模型的应用。生产者线程向任务队列添加任务，一旦队列有任务到来，如果有等待线程就唤醒来执行任务，如果没有等待线程并且线程数没有达到阈值，就创建线程来执行任务。

线程池拥有若干个线程，通常情...

			
		

	





	

		

			

				
					
带你实现简单线程池

				
			

			

				

					qq_59693947的博客
				

				

					07-12
					
					300
					
				

			

		

		

			
				
1.创建/销毁线程伴随着系统开销，过于频繁的创建/销毁线程，会很大程度上影响处理效率。2.线程并发数量过多，抢占系统资源从而导致阻塞。3.对线程进行一些简单的管理。1.定义一个基本函数类，用户可继承此类实现自定义方法即可使用。


2.定义一个函数指针，为基本类的函数对象。


3.定义一个仿函数类实现，重写“（）”运算符。


4.自定义线程类


5.定义线程池类


6.实现继承基础类。


7.使用线程池类。......

			
		

	





	

		

			

				
					
简易线程池的实现

				
			

			

				

					某薛的黑猫
				

				

					11-30
					
					283
					
				

			

		

		

			
				
1.首先我们创建一个任务类。
//回调函数
typedef int(*cal_t)(int,int);

class Task{
  private:
    int x;//操作数1
    int y;//操作数2
    int z;//运算结果
    cal_t handler_task;//运算操作
  public:
    Task(int a,int b,cal_t handle...

			
		

	





	

		

			

				
					
手写一个最简单线程池

				
			

			

				

					绅士jiejie的博客
				

				

					05-08
					
					607
					
				

			

		

		

			
				
先定义个一个保存任务的队列类，同时提供获取任务和添加任务的方法


public class RunnableTaskQueue {

    /**
     * 定义一个LinkedList来做为存放任务的队列
     */
    private final LinkedList<Runnable> tasks = new LinkedList<>();


    /**
     * 获取任务
     *
     * @return 任务
     * @thro..

			
		

	





	

		

			

				
					
2017.12.11 线程池的简单实践

				
			

			

				

					weixin_30367169的博客
				

				

					12-11
					
					84
					
				

			

		

		

			
				
参考来自：慕课网

1.线程池的介绍
创建线程开销大，线程池的作用就是预先建立好线程，等待任务派发。
主要由两部分组成：线程+派发任务的queue。所有的线程都会从队列的头部获取任务。如果队列是空的，线程就会一直等待，直到有任务进来。
使用方法：创建一个线程池，然后往队列中放任务。



2.重要参数


3.ThreadPoolExecutor

...

			
		

	





	

		

			

				
					
简单线程池

				
			

			

				

					一个勤奋的coder的博客
				

				

					02-24
					
					91
					
				

			

		

		

			
				
#ifndef ThreadPool_h
#define ThreadPool_h
#include <vector>
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <future>
#inc...

			
		

	





	

		

			

				
					
c++实现简单线程池

				
			

			

				

					09-02
				

			

		

		

			
				
- *1* [C++ 实现一个简易的线程池](https://blog.csdn.net/junmangbo4166/article/details/104806037)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值