logger_async.hpp

浏览该文件的文档.

// Copyright 2026 CZF-H
// Licensed under the Apache License, Version 2.0
 
//
// Created by wanjiangzhi on 2026/3/30.
//
 
#ifndef ZCLIBLOG_LOGGER_ASYNC_HPP
#define ZCLIBLOG_LOGGER_ASYNC_HPP
 
#include <atomic>
#include <condition_variable>
#include <functional>
#include <memory>
#include <queue>
#include <thread>
#include <mutex>
 
#include "logger_base.hpp"
 
#if ZCLIBLOG_LOGGER_CONFIGURATIONS_LOGGER_ASYNC_MUTEX
#ifndef ZCLibLog_MUTEX
#if ZCLibLog_CPP >= 17
#include <shared_mutex>
#define ZCLibLog_MUTEX std::shared_mutex
#else
#define ZCLibLog_MUTEX std::mutex
#endif
#endif
#endif
 
namespace ZCLibLog {
    namespace details {
        class ThreadPool {
        public:
            explicit ThreadPool(const size_t numThreads = 1) : stop(false) {
                for (size_t i = 0; i < numThreads; ++i) {
                    workers.emplace_back(
                        [this] {
                            while (true) {
                                std::function<void()> task;
                                {
                                    std::unique_lock<std::mutex> lock(mtx);
                                    cv.wait(lock, [this] { return stop || !tasks.empty(); });
                                    if (stop && tasks.empty()) return;
                                    task = std::move(tasks.front());
                                    tasks.pop();
                                }
                                task();
                            }
                        }
                    );
                }
            }
 
            ~ThreadPool() {
                {
                    std::lock_guard<std::mutex> lock(mtx);
                    stop = true;
                }
                cv.notify_all();
                for (auto& t : workers) t.join();
            }
 
            void submit(std::function<void()> task) {
                {
                    std::lock_guard<std::mutex> lock(mtx);
                    tasks.push(std::move(task));
                }
                cv.notify_one();
            }
 
        private:
            std::vector<std::thread> workers;
            std::queue<std::function<void()>> tasks;
            std::mutex mtx;
            std::condition_variable cv;
            std::atomic<bool> stop;
        };
    }
 
    static details::ThreadPool LoggerAsync_ThreadPool{ZCLIBLOG_LOGGER_CONFIGURATIONS_ASYNC_THREAD_NUM};
 
    template <
        typename Formatter
        #if ZCLIBLOG_LOGGER_CONFIGURATIONS_DEFAULT_CSNPRINTF
        = formatters::csnprintf
        #endif
    >
    struct LoggerAsync : BaseLogger<Formatter> {
        using BaseLogger<Formatter>::BaseLogger;
        using Self = LoggerAsync;
 
        void execute(std::string& message, const LogLevel level) const {
            if (!message.empty()) {
                auto message_p = std::make_shared<std::string>(std::move(message));
                LoggerAsync_ThreadPool.submit(
                    [this, message_p, level] {
                        #if ZCLIBLOG_LOGGER_CONFIGURATIONS_LOGGER_ASYNC_MUTEX
                        std::lock_guard<ZCLibLog_MUTEX> lock(m_mutex);
                        #endif
                        // ReSharper disable once CppUseStructuredBinding
                        // ReSharper disable once CppUseElementsView
                        for (const auto& the_executor_pair : this->m_executors) {
                            the_executor_pair.second->do_execute(*message_p, level);
                        }
                    }
                );
            }
        }
 
        using Tag = LogTag<typename Formatter::Format_API, Self>;
 
        Tag ALL{this, LogLevel::ALL};
        Tag TRACE{this, LogLevel::TRACE};
        Tag DEBUG{this, LogLevel::DEBUG};
        Tag INFO{this, LogLevel::INFO};
        Tag WARN{this, LogLevel::WARN};
        Tag ERROR{this, LogLevel::ERROR};
        Tag FATAL{this, LogLevel::FATAL};
    };
}
 
#endif //ZCLIBLOG_LOGGER_ASYNC_HPP