RollingFileAppender(
    const std::string &name, 
    const std::string& filename, 
    size_t maxFileSize = 10*1024*1024, // 最大文件是10M
    unsigned int maxBackupIndex = 10, // 超过10文件就把最旧的给删了
    bool append = true, // 追加日志的方式
    mode_t mode = 00644
);

void FileAppender::_append(const LoggingEvent& event) {
    std::string message(_getLayout().format(event));
    if (!::write(_fd, message.data(), message.length())) {
        // XXX help! help!
    }
}

Logger::~Logger() {
    impl_.finish();
    const LogStream::Buffer &buf(stream().buffer());
    g_output(buf.data(), buf.length()); // 主要，这里底层调用AsyncLogging::append
    if (impl_.level_ == FATAL) {
        g_flush();
        abort();
    }
}
void AsyncLogging::append(const char *logline, int len) {
    // 1. 多线程加锁，线程安全
    std::lock_guard<std::mutex> lock(mutex_);
    ; // 多线程加锁
    // 2.判断是否写满buffer
    if (currentBuffer_->avail() > len) // 判断buffer还有没有空间写入这条日志
    {
        // 2.1 buffer未满直接写入buffer
        currentBuffer_->append(logline, len); // 直接写入
    } else {
        // 2.2 当前buffer插入到buffer队列
        buffers_.push_back(std::move(currentBuffer_)); // buffers_是vector，把buffer入队列
        // printf("push_back append_cnt:%d, size:%d\n", ++append_cnt,
        // buffers_.size()); 2.2.1
        // 另个buffer是否为空，如果不为空则复用，如果为空则重新分配
        if (nextBuffer_) // 用了双缓存
        {
            currentBuffer_ = std::move(nextBuffer_); // 如果不为空则将buffer转移到currentBuffer_
        } else {
            // 重新分配buffer
            currentBuffer_.reset(new Buffer); // Rarely happens如果后端写入线程没有及时读取数据，那要再分配buffer
        }
        currentBuffer_->append(logline, len);
        cond_.notify_one(); // 唤醒日志落盘线程
    }
}

void AsyncLogging::threadFunc() {
    assert(running_ == true);
    LogFile output(basename_, rollSize_, false);
    BufferPtr newBuffer1(new Buffer); // 是给currentBuffer_
    BufferPtr newBuffer2(new Buffer); // 是给nextBuffer_
    newBuffer1->bzero();              // 内容设置为'\0'
    newBuffer2->bzero();
    BufferVector buffersToWrite; // 保存要写入的日志
    buffersToWrite.reserve(16);  // 队列初始化容量为16个buffer
    while (running_) {
        assert(newBuffer1 && newBuffer1->length() == 0);
        assert(newBuffer2 && newBuffer2->length() == 0);
        assert(buffersToWrite.empty());
        // MutexLockGuard lock(mutex_);  //
        // 这个位置锁的粒度就大了，落盘的时候都会阻塞append
        { // 1. 多线程加锁，线程安全，注意锁的作用域
            std::unique_lock<std::mutex> lock(mutex_);
            // 2. 判断buffer队列是否为空，如果为空则休眠，如果不为空等待
            if (buffers_.empty()) // 没有数据可读取，休眠
            {
                // printf("waitForSeconds into\n");
                // 超时退出或者被唤醒 收到notify
                cond_.wait_for(
                    lock, std::chrono::milliseconds(flushInterval_ * 1000),
                    [this] { return (!buffers_.empty()) | !running_; });
                // printf("waitForSeconds leave\n");
            }
            // 3. 只要触发日志的落盘，不管当前的buffer是否写满都取出来，以后续写入磁盘
            buffers_.push_back(std::move(currentBuffer_)); // currentBuffer_被锁住  currentBuffer_被置空
            // 4.为当前buffer设置缓存空间，复用已经分配的空间
            // printf("push_back threadFunc:%d, size:%d\n", ++threadFunc_cnt,  buffers_.size()); 
            currentBuffer_ = std::move(newBuffer1); // currentBuffer_ 需要内存空间
            // 5. 把前台日志队列buffers_的buffer转日到后台日志队列buffersToWrite，这样在日志落盘过程不影响
            //    前台日志队列buffers_.push_back的插入
            buffersToWrite.swap(buffers_); // 用了双队列，把前端日志的队列所有buffer都转移到buffersToWrite队列
            if (!nextBuffer_) // newBuffer2是给nextBuffer_
            {
                nextBuffer_ = std::move(newBuffer2); // 如果为空则使用newBuffer2的缓存空间
            }
        } // 注意这里加锁的粒度，日志落盘的时候不需要加锁了，主要是双队列的功劳

        // 从这里是没有锁，数据落盘的时候不要加锁
        assert(!buffersToWrite.empty());
        // 6.判断日志是否有及时写入，如果不及时删掉一部分日志，并插入提示信息
        // fixme的操作 4M一个buffer *25 = 100M
        if (buffersToWrite.size() >  25) // 这里缓存的数据太多了，比如4M为一个buffer空间，25个buffer就是100M了。
        { // 以一行日志100字节为例，那有100*1000*1000/100=100 0000 ,一百万的日志
            printf("Dropped\n");
            char buf[256];
            snprintf(buf, sizeof buf,  "Dropped log messages at %s, %zd larger buffers\n",
                     Timestamp::now().toFormattedString().c_str(), buffersToWrite.size() - 2); // 只保留2个buffer
            fputs(buf, stderr);
            output.append(buf, static_cast<int>(strlen(buf)));
            buffersToWrite.erase(
                buffersToWrite.begin() + 2,
                buffersToWrite.end()); // 只保留2个buffer(默认4M) 
        }
        // 7.循环写入所有buffer
        for (const auto &buffer : buffersToWrite) // 遍历buffer
        {
            // FIXME: use unbuffered stdio FILE ? or use ::writev ?
            output.append(buffer->data(), buffer->length()); // 负责fwrite数据
        }
        // 8.刷新磁盘,刷到哪里去了？
        output.flush(); //有待商榷
        if (buffersToWrite.size() > 2) {
            // drop non-bzero-ed buffers, avoid trashing
            buffersToWrite.resize(2); // 只保留2个buffer
        }
        // 9. newBuffer1 和newBuffer2获取
        if (!newBuffer1) {
            assert(!buffersToWrite.empty());
            newBuffer1 = std::move(buffersToWrite.back()); // 复用buffer对象
            buffersToWrite.pop_back();
            newBuffer1->reset(); // 复位
        }

        if (!newBuffer2) {
            assert(!buffersToWrite.empty());
            newBuffer2 = std::move(buffersToWrite.back()); // 复用buffer对象
            buffersToWrite.pop_back();
            newBuffer2->reset(); // 重置
        }

        buffersToWrite.clear();
    }
    // 这里应该也应该继续把没有写完的数据写完
    {
        std::unique_lock<std::mutex> lock(mutex_);
        // 只要触发日志的落盘，不管当前的buffer是否写满都取出来，以后续写入磁盘
        buffers_.push_back(std::move(currentBuffer_)); // currentBuffer_被锁住  currentBuffer_被置空
        currentBuffer_ = std::move(newBuffer1); // currentBuffer_ 需要内存空间
        buffersToWrite.swap(buffers_); // 用了双队列，把前端日志的队列所有buffer都转移到buffersToWrite队列
        if (!nextBuffer_) // newBuffer2是给nextBuffer_
        {
            nextBuffer_ = std::move(newBuffer2); // 如果为空则使用newBuffer2的缓存空间
        }
         // 循环写入所有buffer
        for (const auto &buffer : buffersToWrite) // 遍历buffer
        {
            // FIXME: use unbuffered stdio FILE ? or use ::writev ?
            output.append(buffer->data(), buffer->length()); // 负责fwrite数据
        }
    }

    output.flush();
}

#include "async_logging.h"

#include <stdio.h>
#include <sys/resource.h>
#include <unistd.h>
#include <sys/time.h>
#include <iostream>
#include "tc_logging.h"
#define LOG_NUM 5000000 // 总共的写入日志行数

using namespace std;
off_t kRollSize = 1 * 1000 * 1000;    // 只设置1M
static AsyncLogging *g_asyncLog = NULL;
static void asyncOutput(const char *msg, int len)
{
  g_asyncLog->append(msg, len);
}

static uint64_t get_tick_count()
{
  struct timeval tval;
  uint64_t ret_tick;
  gettimeofday(&tval, NULL);
  ret_tick = tval.tv_sec * 1000L + tval.tv_usec / 1000L;
  return ret_tick;
}


void testLogPerformance(int argc, char *argv[])
{
  printf("pid = %d\n", getpid());
  char name[256] = {'\0'};
  strncpy(name, argv[0], sizeof name - 1);
  // 回滚大小kRollSize（1M）, 最大1秒刷一次盘（flush）
  AsyncLogging log(::basename(name), kRollSize, 1);  // 注意，每个文件的大小 还取决于时间的问题，不是到了大小就一定换文件。
  Logger::setOutput(asyncOutput);   // 不是说只有一个实例

  g_asyncLog = &log;
  log.start();        // 启动日志写入线程
  uint64_t begin_time = get_tick_count();
  std::cout << "name:" <<::basename(name) << ", begin_time: " << begin_time << std::endl;
  for (int i = 0; i < LOG_NUM; i++)
  {
    LOG_INFO << "NO." << i << " Root Error Message!"; // 47个字节  调用调用async append
  }
  
  log.stop();
  uint64_t end_time = get_tick_count();
  std::cout << "end_time: " << end_time << std::endl;
  int64_t ops = LOG_NUM;
  ops = ops * 1000 / (end_time - begin_time);
  std::cout << "need the time1: " << end_time << " " << begin_time << ", " << end_time - begin_time << "毫秒"
            << ", ops = " << ops << "ops/s\n";
}

void testCoredump()
{
    AsyncLogging log("coredump", 200*1000*1000);
    log.start();   //开启日志线程
    g_asyncLog = &log;
    int msgcnt = 0;
    Logger::setOutput(asyncOutput);//设置日志输出函数
 
    for(int i=0;i<1000000;i++)   {//写入100万条日志消息
      LOG_INFO << "0voice 0123456789" << " abcdefghijklmnopqrstuvwxyz "
               << ++msgcnt;
      if(i == 500000) {
         int *ptr = NULL;
        *ptr = 0x1234;  // 人为制造异常
      }
    } 
}

int main(int argc, char *argv[])
{
  // 这里每次二选1去进行测试
  testLogPerformance(argc, argv);   
  // testCoredump();
  return 0;
}

// 异步写入
void test_async_example()
{
    uint64_t begin_time;
    {
        // Default thread pool settings can be modified *before* creating the async logger:
        // spdlog::init_thread_pool(3276800, 2); // queue with max 32k items 1 backing thread.
        // spdlog::init_thread_pool(327680, 1);  // 块大小非常影响性能
        spdlog::init_thread_pool(3276, 1);
        // auto async_file = spdlog::basic_logger_mt<spdlog::async_factory>("async_file_logger", "logs/async_log.txt");
        // alternatively:
        // auto async_file = spdlog::create_async<spdlog::sinks::basic_file_sink_mt>("async_file_logger", "logs/async_log.txt");
        auto async_file = spdlog::basic_logger_mt<spdlog::async_factory>("async_file_logger","logs/async_log.txt");
        // size_t q_size = 4096; //queue size must be power of 2
    
        async_file->set_pattern("[%Y-%m-%d %H:%M:%S.%f %z][thread %t][%n][%l]: %v");
        begin_time = get_tick_count();
        std::cout <<   " test_async_example begin_time: " << begin_time << std::endl;
        for (int i = 0; i < LOG_NUM; i++)
        {
            async_file->info("NO. {0:d}  Root Error Message!", i); // 47个字节
        }
     }
    uint64_t end_time = get_tick_count();
    std::cout << "end_time: " << end_time << std::endl;
    int64_t ops = LOG_NUM;
    ops = ops * 1000 / (end_time - begin_time);
    std::cout << "need the time1: " << end_time << " " << begin_time << ", " << end_time - begin_time << "毫秒"
            << ", ops = " << ops << "ops/s\n";
}
// 同步写入
void test_basic_example()
{
    uint64_t begin_time;
    uint64_t end_time;
    {
        // Create basic file logger (not rotated).
        auto my_logger = spdlog::basic_logger_mt("file_logger", "logs/basic-log.txt");
        my_logger->set_pattern("[%Y-%m-%d %H:%M:%S.%f %z][thread %t][%n][%l]: %v");
        begin_time = get_tick_count();
        std::cout <<   " test_basic_example begin_time: " << begin_time << std::endl;
        for (int i = 0; i < LOG_NUM; i++)
        {
            my_logger->info("NO. {}  Root Error Message!", i); // 47个字节
        }
        end_time = get_tick_count();
    }
    std::cout << "end_time: " << end_time << std::endl;
    int64_t ops = LOG_NUM;
    ops = ops * 1000 / (end_time - begin_time);
    std::cout << "need the time1: " << end_time << " " << begin_time << ", " << end_time - begin_time << "毫秒"
            << ", ops = " << ops << "ops/s\n";
}