Spdlog记述：四-Aet

Bingliaolong 2023-09-16 16:26 Aet | 隐藏边栏 | 抢沙发 | 9 0

文章评分 1 次，平均分 5.0 ：

线程池

创建线程池方法一

调用async_factory_impl::create创建线程池
1. 但是这个函数实际作用是用于创建一个记录器
2. 由于需要一个线程池对象参数，所以在创建记录器之前做了个检查，如果还不存在线程池，就先创建线程池，再构造记录器

template<async_overflow_policy OverflowPolicy = async_overflow_policy::block>

struct async_factory_impl

{

template<typename Sink, typename... SinkArgs>

static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&... args)

{

// create global thread pool if not already exists..

std::lock_guard<std::recursive_mutex> tp_lock(details::s_thread_pool_mutex);

if (!details::s_thread_pool)

{

details::s_thread_pool = std::make_shared<details::thread_pool>(details::default_async_q_size, 1U);

}

auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);

auto new_logger =

std::make_shared<async_logger>(std::move(logger_name), std::move(sink), std::move(details::s_thread_pool), OverflowPolicy);

return new_logger;

}

};

这里使用递归锁的原因可能是为了使代码的防御性强一些
thread_pool类的解析看后文

创建线程池方法二

调用init_thread_pool创建线程池

// set global thread pool.

inline void init_thread_pool(size_t q_size, size_t thread_count, std::function<void()> on_thread_start)

{

auto tp = std::make_shared<details::thread_pool>(q_size, thread_count, on_thread_start);

details::registry::instance().set_tp(std::move(tp));

}

// set global thread pool.

inline void init_thread_pool(size_t q_size, size_t thread_count)

{

init_thread_pool(q_size, thread_count, [] {});

}

而s_thread_pool是一个静态的std::shared_ptr对象

namespace details {

static const size_t default_async_q_size = 8192;

static std::shared_ptr<thread_pool> s_thread_pool;

static std::recursive_mutex s_thread_pool_mutex;

} // namespace details

static对象只会被初始化一次，并且：
1. 在C++11及之后的版本中，函数内的局部静态对象的初始化是线程安全的
可以看到用上面这个方法创建线程池后，会被转移到了class SPDLOG_API registry这个类的实例里面
1. 而这个类class SPDLOG_API registry是一个单例类
2. 类class SPDLOG_API registry解析见下文

SPDLOG_INLINE registry &registry::instance()

{

static registry s_instance;

return s_instance;

}

获取线程池方法三

如方法二中所述，用方法二创建的线程池会被保存到class SPDLOG_API registry这个类的静态实例里面
1. 所以可以通过这个类的接口来获取，这个类提供了这样的方法

SPDLOG_INLINE std::shared_ptr<thread_pool> registry::get_tp()

{

std::lock_guard<std::recursive_mutex> lock(tp_mutex_);

return tp_;

}

thread_pool类

类

class SPDLOG_API thread_pool

{

public:

using item_type = async_msg;

using q_type = details::mpmc_blocking_queue<item_type>;

thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start, std::function<void()> on_thread_stop);

thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start);

thread_pool(size_t q_max_items, size_t threads_n);

// message all threads to terminate gracefully and join them

~thread_pool();

thread_pool(const thread_pool &) = delete;

thread_pool &operator=(thread_pool &&) = delete;

void post_log(async_logger_ptr &&worker_ptr, const details::log_msg &msg, async_overflow_policy overflow_policy);

void post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy);

size_t overrun_counter();

size_t queue_size();

private:

q_type q_;

std::vector<std::thread> threads_;

void post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy);

void worker_loop_();

// process next message in the queue

// return true if this thread should still be active (while no terminate msg

// was received)

bool process_next_msg_();

};

q_是一个队列，是在线程池构造的初始化列表里面，通过调用这个队列的构造函数来初始化
1. 根据上面的代码，可以看到，它一般被初始化为下面的大小

1	static const size_t default_async_q_size = 8192;

在构造函数里，检查了要创建的线程的数量，为0或过大，就抛一个异常出去
然后创建所要求的数量的线程，并保存在了vector里面
1. 可以看到，是通过传入了一个lambda来隐式生成了一个线程对象

for (size_t i = 0; i < threads_n; i++)

{

threads_.emplace_back([this, on_thread_start, on_thread_stop] {

on_thread_start();

this->thread_pool::worker_loop_();

on_thread_stop();

});

}

process_next_msg_这个函数相当于是线程池里线程的消息泵
1. 只有当这个函数返回false的时候，该线程结束
2. 所以销毁线程的时候，也是利用了这一点，通过传入了类型为terminate的消息包，并调用notify_one来通知一个线程来处理这个消息包
3. 在process_next_msg_里面，发现消息包的类型为terminate，于是返回了false，从而结束了这个线程

void SPDLOG_INLINE thread_pool::worker_loop_()

{

while (process_next_msg_()) {}

}

消息泵函数里面，则通过队列的dequeue_for这个函数来获取一个消息包
1. 没有拿到消息包，返回true，从而再次进入消息泵
2. 拿到了消息包，根据消息包的类型来处理
3. 消息包里，不仅存了消息包的类型，还存了一个记录器的智能指针对象
4. 对于log类型的消息，用存着的智能指针对象去记录
5. 对于flush类型的消息，用存着的智能指针对象去调用fflush
6. 对于terminate类型的消息，返回false，让线程结束

数据队列

pop_cv_在检查队列，只要队列没满，就能往里面添加数据，成功添加一个数据，便push_cv_通知一下

void enqueue(T &&item)

{

std::unique_lock<std::mutex> lock(queue_mutex_);

pop_cv_.wait(lock, [this] { return !this->q_.full(); });

q_.push_back(std::move(item));

}

push_cv_.notify_one();

}

立即加入队列的版本

void enqueue_nowait(T &&item)

{

std::unique_lock<std::mutex> lock(queue_mutex_);

q_.push_back(std::move(item));

}

push_cv_.notify_one();

}

取数据，这个函数正是上面线程的消息泵取数据的地方
1. push_cv_在等待数据，一段时间内，队列还是为空就返回
2. 不为空就取出来一个消息，而这个函数的第一个参数是出参，调这个函数的地方，会对这个消息包进行处理，上文有讲
3. 同时，每取出一个消息包，就通知一下pop_cv_这个条件变量，而它不再阻塞，开始继续检查队列是不是已满

bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration)

{

std::unique_lock<std::mutex> lock(queue_mutex_);

if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); }))

{

return false;

}

popped_item = std::move(q_.front());

q_.pop_front();

}

pop_cv_.notify_one();

return true;

}

查询队列数据
1. 这里上锁是为了确保在多线程环境中数据的一致性和线程安全

size_t SPDLOG_INLINE thread_pool::overrun_counter()

{

return q_.overrun_counter();

}

size_t SPDLOG_INLINE thread_pool::queue_size()

{

return q_.size();

}

size_t overrun_counter()

{

std::unique_lock<std::mutex> lock(queue_mutex_);

return q_.overrun_counter();

}

size_t size()

{

std::unique_lock<std::mutex> lock(queue_mutex_);

return q_.size();

}

其他接口

post_log
1. 往线程池里投递消息log消息包
post_flush
1. 往线程池里投递消息flush消息包

registry类

记录器

会在创建registry类的时候创建一个默认记录器，默认记录器没有名字

SPDLOG_INLINE registry::registry()

: formatter_(new pattern_formatter())

{

#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER

// create default logger (ansicolor_stdout_sink_mt or wincolor_stdout_sink_mt in windows).

# ifdef _WIN32

auto color_sink = std::make_shared<sinks::wincolor_stdout_sink_mt>();

# else

auto color_sink = std::make_shared<sinks::ansicolor_stdout_sink_mt>();

# endif

const char *default_logger_name = "";

default_logger_ = std::make_shared<spdlog::logger>(default_logger_name, std::move(color_sink));

loggers_[default_logger_name] = default_logger_;

#endif // SPDLOG_DISABLE_DEFAULT_LOGGER

}

可以往registry里面注册记录器
1. 可以看到，注册记录器就是，registry用了一个map把每一个记录器的智能指针对象保存了起来

1	std::unordered_map<std::string, std::shared_ptr<logger>> loggers_;

SPDLOG_INLINE void registry::register_logger(std::shared_ptr<logger> new_logger)

{

std::lock_guard<std::mutex> lock(logger_map_mutex_);

register_logger_(std::move(new_logger));

}

SPDLOG_INLINE void registry::register_logger_(std::shared_ptr<logger> new_logger)

{

auto logger_name = new_logger->name();

throw_if_exists_(logger_name);

loggers_[logger_name] = std::move(new_logger);

}

初始化记录器，对一个新的记录器进行初始化，并注册

SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr<logger> new_logger) {

// ...

}

从registry里面用记录器名字获取记录器
1. 它这些查找都是加锁的

SPDLOG_INLINE std::shared_ptr<logger> registry::get(const std::string &logger_name)

{

std::lock_guard<std::mutex> lock(logger_map_mutex_);

auto found = loggers_.find(logger_name);

return found == loggers_.end() ? nullptr : found->second;

}

默认记录器

它不仅被存到了registry里面，没有使用std::move
而且还用单独的default_logger_来存储默认记录器
当然，也有更新默认记录器的方法

SPDLOG_INLINE std::shared_ptr<logger> registry::default_logger()

{

std::lock_guard<std::mutex> lock(logger_map_mutex_);

return default_logger_;

}

SPDLOG_INLINE logger *registry::get_default_raw()

{

return default_logger_.get();

}

SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr<logger> new_default_logger)

{

std::lock_guard<std::mutex> lock(logger_map_mutex_);

// remove previous default logger from the map

if (default_logger_ != nullptr)

{

loggers_.erase(default_logger_->name());

}

if (new_default_logger != nullptr)

{

loggers_[new_default_logger->name()] = new_default_logger;

}

default_logger_ = std::move(new_default_logger);

}

线程池

获取

SPDLOG_INLINE std::shared_ptr<thread_pool> registry::get_tp()

{

std::lock_guard<std::recursive_mutex> lock(tp_mutex_);

return tp_;

}

记录器->接收器->格式器

设置
1. 可以看到，调用这个接口设置一个格式器后，不仅被保存了，而且还被用于更新每一个记录器的格式器

SPDLOG_INLINE void registry::set_formatter(std::unique_ptr<formatter> formatter)

{

std::lock_guard<std::mutex> lock(logger_map_mutex_);

formatter_ = std::move(formatter);

for (auto &l : loggers_)

{

l.second->set_formatter(formatter_->clone());

}

格式器是接收器的组件
1. 具象化的接收器，每一个都实现了基类接收器设置格式器的抽象方法

SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter)

{

std::lock_guard<mutex_t> lock(mutex_);

formatter_ = std::move(sink_formatter);

}

记录器->回溯器

每个记录器还有一个回溯器
1. 可以看到，回溯器有个环形缓冲区

1	details::backtracer tracer_;

class SPDLOG_API backtracer

{

mutable std::mutex mutex_;

std::atomic<bool> enabled_{false};

circular_q<log_msg_buffer> messages_;

public:

backtracer() = default;

backtracer(const backtracer &other);

backtracer(backtracer &&other) SPDLOG_NOEXCEPT;

backtracer &operator=(backtracer other);

void enable(size_t size);

void disable();

bool enabled() const;

void push_back(const log_msg &msg);

// pop all items in the q and apply the given fun on each of them.

void foreach_pop(std::function<void(const details::log_msg &)> fun);

};

打印消息的时候，会根据记录器的回溯器的标志，来判断是否把消息添加到回溯器中

1	bool traceback_enabled = tracer_.enabled();

打印回溯信息
1. 记录器给出了接口，通过回溯器的foreach_pop接口获取回溯器里面的每一个消息包，并打印信息

SPDLOG_INLINE void logger::dump_backtrace_()

{

using details::log_msg;

if (tracer_.enabled())

{

sink_it_(log_msg{name(), level::info, "****************** Backtrace Start ******************"});

tracer_.foreach_pop([this](const log_msg &msg) { this->sink_it_(msg); });

sink_it_(log_msg{name(), level::info, "****************** Backtrace End ********************"});

}

本文为原创文章，版权归Aet所有，欢迎分享本文，转载请保留出处！

Bingliaolong 关注：0 粉丝：0

Everything will be better.

一	二	三	四	五	六	日
1	2	3	4	5	6	7
8	9	10	11	12	13	14
15	16	17	18	19	20	21
22	23	24	25	26	27	28
29	30	31

线程池

创建线程池方法一

创建线程池方法二

获取线程池方法三

thread_pool类

类

数据队列

其他接口

registry类

记录器

默认记录器

线程池

记录器->接收器->格式器

记录器->回溯器

类图

你可能也喜欢

热评文章

发表评论

标签云集