碎碎念：
有快3个月没有写博客了，这段时间很多事，抽不出空来写博客。后面的博客可能风格也会转变，从理论到实战为主，尽量减少源码的解读。(看完源码后面自己也忘了QAQ），本篇博客主要介绍线程池的实现及其前置单例模式的一些实现方法，其中使用了恋恋辰风大佬的一些例子。
单例模式
在众多的设计模式中，尽管因为语言特性而使某些设计模式缺乏实用性。但是单例模式却是使用最为广泛的设计模式之一。在需要大规模数据通信的场景，又或者需要重复构造释放以及各种工厂模式,句柄。单例模式都在其中展现出了优势。例如,如果你想进行线程间通信，如果仅仅是处理轻量级的数据交换或同步任务，那么你可以选择使用future,task,promise等，但是如果是大规模数据，实现一个单例缓冲区Buffer，构造一个生产者消费者模型则是方法之一。值得一提的是，在观看boost库的实现中，我发现了一种写法可以些许提高性能，也就是消费者自身维护一个buffer,在消费完之后，直接和单例类中的buffer进行swap，而无需从单例buffer中取数据，这种方法可以减少锁的竞争和访问延迟。。单例模式一般常见的来说有懒汉式和饿汉式两种，懒汉式就是在getInstance函数执行的时候如果未创建单例，则创建单例。饿汉式则是将单例模式的创建放在了构造函数当中。如果是单线程无所谓，但是在多线程的情况下，我并不是很推荐使用懒汉式(即使他使用双锁)。这是因为new本身不是一个原子操作，他可能出现重排序问题从而先返回了但是还没实际构建，这样的风险非常大。而懒汉式由于是在构造函数中实现则不存在这个问题。这两种我都不是很常用，我常用的两种一种是返回局部变量，这种非常简单，而且可靠性较高，但是注意不要在C++11标准之前使用，会有风险，而11之后修复了这个问题。第二种是使用once_flag和call_once配合来实现，call_once会保证once_flag只被初始化一次。下面来看一下具体的实现，为了观看方便我就不分开写了:
#include<mutex>
#include<memory>
class SingleClass {
public:
static SingleClass& getInstance() {
static SingleClass instance;
return instance;
}
static std::shared_ptr<SingleClass> getInstance2() {
std::call_once(flag_, [&]() {
instance_ = std::make_shared<SingleClass>();
});
return instance_;
}
private:
static std::once_flag flag_;
SingleClass() = default;
SingleClass(const SingleClass&) = delete;
SingleClass& operator =(const SingleClass&) = delete;
static std::shared_ptr<SingleClass> instance_;
};
std::once_flag SingleClass::flag_;
std::shared_ptr<SingleClass> SingleClass::instance_ = nullptr;这里有几个注意的点，getInstance都要返回引用，一定一定一定要返回引用，不然他就是走的拷贝，我们已经删除了就过不了而且就算是过了也不能走拷贝。
如果需要单例多可以写个模板：
#pragma once
#include <memory>
#include <mutex>
#include <iostream>
using namespace std;
template<typename T>
class Singleton{
public:
static shared_ptr<T> getInstance(){
static std::once_flag s_flag;
std::call_once(s_flag,[&]{
instance_ = make_shared<T>();
});
return instance_;
}
protected:
Singleton()=default;
Singleton(const Singleton& ) = delete;
Singleton& operator= (const Singleton& ) = delete;
static shared_ptr<T> instance_;
};
template<typename T>
shared_ptr<T> Singleton<T>::instance_ = nullptr;这个只要继承就好了，他比较好的就是继承之后不用删除拷贝构造和重写赋值了，因为构造由内而外，先构造父类，父类那里直接禁了子类也用不了这俩了。但是需要注意的是，如果子类自身的构造函数放在private里记得把这个模板设为友元，不然拿不到构造函数。
线程池
线程池的主要功能是管理线程的生命周期，以减少频繁创建和销毁线程的开销。在线程池创建时，会启动一定数量的线程，并让这些线程通过任务队列来获取待执行的任务。工作线程会不断地循环获取任务并执行，从而提高了任务处理的效率。线程池在销毁时，确保所有子线程都完成任务后才退出，这一点非常重要。如果主线程在子线程还未完成任务时就退出，可能会导致未完成的任务丢失或程序状态不一致。因此，在设计线程池时，必须确保在主线程退出之前，所有子线程的任务都已经处理完毕。在多线程程序设计中，通常需要确保主线程在所有子线程完成任务后才退出。线程池通过管理工作线程的生命周期和同步机制（如使用`join`或条件变量）确保所有任务完成后，主线程才能安全退出。我们来看一下主要的实现，这里使用了恋恋辰风博主写的一个线程池，只完成了主要功能。也便于理解：
线程池主要代码
#ifndef __THREAD_POOL_H__
#define __THREAD_POOL_H__
#include <atomic>
#include <condition_variable>
#include <future>
#include <iostream>
#include <mutex>
#include <queue>
#include <thread>
#include <vector>
class NoneCopy {
public:
~NoneCopy(){}
protected:
NoneCopy(){}
private:
NoneCopy(const NoneCopy&) = delete;
NoneCopy& operator=(const NoneCopy&) = delete;
};
class ThreadPool : public NoneCopy {
public:
//继承基类NoneCopy就不需要写如下删除了
//ThreadPool(const ThreadPool&) = delete;
//ThreadPool& operator=(const ThreadPool&) = delete;
static ThreadPool& instance() {
static ThreadPool ins;
return ins;
}
using Task = std::packaged_task<void()>;
~ThreadPool() {
stop();
}
template <class F, class... Args>
auto commit(F&& f, Args&&... args) ->
std::future<decltype(std::forward<F>(f)(std::forward<Args>(args)...))> {
using RetType = decltype(std::forward<F>(f)(std::forward<Args>(args)...));
if (stop_.load())
return std::future<RetType>{};
auto task = std::make_shared<std::packaged_task<RetType()>>(
std::bind(std::forward<F>(f), std::forward<Args>(args)...));
std::future<RetType> ret = task->get_future();
{
std::lock_guard<std::mutex> cv_mt(cv_mt_);
tasks_.emplace([task] { (*task)(); });
}
cv_lock_.notify_one();
return ret;
}
int idleThreadCount() {
return thread_num_;
}
private:
ThreadPool(unsigned int num = std::thread::hardware_concurrency())
: stop_(false) {
{
if (num <= 1)
thread_num_ = 2;
else
thread_num_ = num;
}
start();
}
void start() {
for (int i = 0; i < thread_num_; ++i) {
pool_.emplace_back([this]() {
while (!this->stop_.load()) {
Task task;
{
std::unique_lock<std::mutex> cv_mt(cv_mt_);
this->cv_lock_.wait(cv_mt, [this] {
return this->stop_.load() || !this->tasks_.empty();
});
if (this->tasks_.empty())
return;
task = std::move(this->tasks_.front());
this->tasks_.pop();
}
this->thread_num_--;
task();
this->thread_num_++;
}
});
}
}
void stop() {
stop_.store(true);
cv_lock_.notify_all();
for (auto& td : pool_) {
if (td.joinable()) {
std::cout << "join thread " << td.get_id() << std::endl;
td.join();
}
}
}
private:
std::mutex cv_mt_;
std::condition_variable cv_lock_;
std::atomic_bool stop_;
std::atomic_int thread_num_;
std::queue<Task> tasks_;
std::vector<std::thread> pool_;
};
#endif // !__THREAD_POOL_H__
继承
class NoneCopy {
public:
~NoneCopy(){}
protected:
NoneCopy(){}
private:
NoneCopy(const NoneCopy&) = delete;
NoneCopy& operator=(const NoneCopy&) = delete;
};这里继承也就是我们前面说的模板继承方式，不过他并没有在模板类中创建getinsance而是禁止拷贝构造和拷贝赋值。往下看
static ThreadPool& instance() {
static ThreadPool ins;
return ins;
}
using Task = std::packaged_task<void()>;
~ThreadPool() {
stop();
}第一个没什么好说的 ，析构也没什么好说的，主要看第二个Task，他可不是乱写的哈，这里是因为投递的任务返回类型不同，参数也不同统一拿void()包装一下，内部函数就是通过Bind绑定过参数的任务了，直接调用就好了。对了这里要给不太了解的朋友说一下，这个packaged_task可以和future绑定，只要返回future,使用线程池调用者就可以通过future拿到函数运行后的返回值。接下来看看构造函数：
构造函数
ThreadPool(unsigned int num = std::thread::hardware_concurrency())
: stop_(false) {
{
if (num <= 1)
thread_num_ = 2;
else
thread_num_ = num;
}
start();
}这里也没什么好说的，建议是开的线程数等于你的CPU核数。过多的线程会造成线程竞争，浪费时间片。但是1核我们也不能让他太寒碜变成单线程了吧，至少开两个吧。。。
start函数
void start() {
for (int i = 0; i < thread_num_; ++i) {
pool_.emplace_back([this]() {
while (!this->stop_.load()) {
Task task;
{
std::unique_lock<std::mutex> cv_mt(cv_mt_);
this->cv_lock_.wait(cv_mt, [this] {
return this->stop_.load() || !this->tasks_.empty();
});
if (this->tasks_.empty())
return;
task = std::move(this->tasks_.front());
this->tasks_.pop();
}
this->thread_num_--;
task();
this->thread_num_++;
}
});
}
}这也就是线程就射设置线程，让他循环的执行任务，{}作用域的作用主要是提前结束对共享资源的掌控，要是想用延迟锁也可以，直接让他加完锁再解锁，只是这种方便一点。而且对于lock_guard这种不支持加锁解锁的，也可以控制加锁范围。非常方便十分推荐。这里需要注意的是如果他等待挂起的时候如果是准备退出了，那么他就处理完自己的函数就退出了。忘了说了这里一定要用emlace_back。因为push_back其实是拷贝，那就会存在两个线程一个还回收不掉。
stop函数
void stop() {
stop_.store(true);
cv_lock_.notify_all();
for (auto& td : pool_) {
if (td.joinable()) {
std::cout << "join thread " << td.get_id() << std::endl;
td.join();
}
}
}这里也没什么好说的，就是设置退出标志服，然后唤醒所有挂起线程，再回收。
Commit函数
这是线程池中最关键的函数，为什么不同返回值什么不同的参数函数可以投递到一个队列中.我们来看一下。
template <class F, class... Args>
auto commit(F&& f, Args&&... args) ->
std::future<decltype(std::forward<F>(f)(std::forward<Args>(args)...))> {
using RetType = decltype(std::forward<F>(f)(std::forward<Args>(args)...));
if (stop_.load())
return std::future<RetType>{};
auto task = std::make_shared<std::packaged_task<RetType()>>(
std::bind(std::forward<F>(f), std::forward<Args>(args)...));
std::future<RetType> ret = task->get_future();
{
std::lock_guard<std::mutex> cv_mt(cv_mt_);
tasks_.emplace([task] { (*task)(); });
}
cv_lock_.notify_one();
return ret;
}首先他使用了auto来确定返回值的类型，怎么做到的呢？
auto commit(F&& f, Args&&... args)
-> std::future<decltype(std::forward<F>(f)(std::forward<Args>(args)...))>这个首先他返回的是一个future嘛，这样调用者才可以通过future拿到结果。里面就是用decltype确定类型，什么类型呢？f函数调用的类型。后面args是参数，...是展开。这样就可以输入多个参数然后确定类型了。注意这里一定要用完美转发来确保他的参数左值右值性质不变。往后就是如果线程准备退出了就直接return。
auto task = std::make_shared<std::packaged_task<RetType()>>(
std::bind(std::forward<F>(f), std::forward<Args>(args)...));
std::future<RetType> ret = task->get_future();
{
std::lock_guard<std::mutex> cv_mt(cv_mt_);
tasks_.emplace([task] { (*task)(); });
}然后task用bind进行绑定参数，这样就可以不输入参数直接调用了，但是他还有返回值怎么办呢？那就用lambda表达式直接包装一层就行了，注意这里一定要捕获task要不就&，最好不要捕获this。不然会导致潜在的访问悬空指针的问题，除非你确保this在任务执行期间依然有效。就算他是单例模式，在主程序挂掉之前不会失效，我仍然还是建议不要捕获this。然后往下直接唤醒返回就行了。
结语
放假之后抽空写了一下自己的一些理解和感悟，希望后面能找一个好一点的实习。后面主要会写车载网络的一些知识，也穿插一下和普通TCP/IP的区别，DDS和SOME/IP的一些实战。源码还是等工作后有空再写吧。
