muduo库的高性能日志库（四）——LogFile文件

1.概述

这篇文章就述了日志是怎样与文件打交道的，怎样将日志信息输出文件当中。看完这一部分muduo库的源码收获真的很大，很多细节的实现，都很让人惊叹，厉害!

2.问题(最后解决)

1. 在AppendFile类在构造时将文件的默认缓冲区设置为本地缓冲区
   为什么要这样做？能带来什么样的性能优势？
2. AppendFile中写函数采用的是fwrite_unlock函数，非线程安全的写函数，在LogFile设计写的时候又设计成是否使用互斥锁，调用AppendFile中的append函数。
   为什么不直接采用线程安全的fwite函数?这样的做的优势体现在哪？

3.muduo库日志滚动条件

4. 当日志文件大小超过规定rollSize时，进行日志滚动。
5. 当日志操作次数到达checkEveryN_次时(默认1024),需要检测是否需要进行日志滚动。
   • 跨天(thisPeriod_ != startOfPeriod_) 则需要进行日志滚动
   • 不跨天，则需要判断是否需要flush，超过flush时间间隔则需要flush

4.AppendFile类

该类是LogFile的一个成员类，该类提供了日志文件的管理接口，管理日志文件的
创建，打开，写入，缓冲区刷新，关闭

class AppendFile : noncopyable
{
 public:
 //在构造函数是打开文件，（a:追加，e，相当于O_CLOEXEC，，在调用exec是会关闭文件描述符）
  explicit AppendFile(StringArg filename);
   //关闭文件
  ~AppendFile();

 //向缓冲区（flush后会进入文件）写数据
  void append(const char* logline, size_t len);

  void flush();
 //返回已写入了多少字节
  off_t writtenBytes() const { return writtenBytes_; }

 private:

  size_t write(const char* logline, size_t len);

  FILE* fp_;
  char buffer_[64*1024]; //文件输出缓冲区大小，64kb
  off_t writtenBytes_;  //已写日志数据的总字节数
};

}  // namespace FileUtil
}  // namespace muduo
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

设计细节

4.1构造函数和析构函数

1. 在构造函数当中，以追加的方式打开文件，若文件不存在，进行创建。并将默认缓冲区修改为本地缓冲区。
2. 在析构函数中，将文件关闭，在调用fclose时，内部会先flush一次

FileUtil::AppendFile::AppendFile(StringArg filename)
  : fp_(::fopen(filename.c_str(), "ae")),  // 'e' for O_CLOEXEC
    writtenBytes_(0)
{
  assert(fp_);
  //将缓冲区设置为本地的bufer
  ::setbuffer(fp_, buffer_, sizeof buffer_);
}
FileUtil::AppendFile::~AppendFile()
{
  ::fclose(fp_);
}
1
2
3
4
5
6
7
8
9
10
11
12

4.2写入和缓冲区刷新

该类向日志文件里写数据采用实质调用的是系统函数fwrite_unlocked
不加锁版的写函数，也就是非线程安全的fwrite

void FileUtil::AppendFile::append(const char* logline, const size_t len)
{
  size_t written = 0;

  while (written != len)
  {
   //剩余字节数
    size_t remain = len - written;
    size_t n = write(logline + written, remain);
    if (n != remain)
    {
      int err = ferror(fp_);
      if (err)
      {
        fprintf(stderr, "AppendFile::append() failed %s\n", strerror_tl(err));
        break;
      }
    }
    //已写入字节数
    written += n;
  }
  //该文件已写入的总字节数
  writtenBytes_ += written;
}

size_t FileUtil::AppendFile::write(const char* logline, size_t len)
{
  // #undef fwrite_unlocked
  return ::fwrite_unlocked(logline, 1, len, fp_);
}

void FileUtil::AppendFile::flush()
{
  ::fflush(fp_);
}
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
32
33
34
35

5.LogFile类

该类就是日志文件输出的主要负责者，负责管理日志文件的滚动

class LogFile : noncopyable
{
 public:
  LogFile(const string& basename,
          off_t rollSize,
          bool threadSafe = true,
          int flushInterval = 3, //默认刷新间隔为3
          int checkEveryN = 1024); //默认检查间隔为1024
  ~LogFile();

  void append(const char* logline, int len);
  void flush();
  bool rollFile();

 private:
  void append_unlocked(const char* logline, int len);

  static string getLogFileName(const string& basename, time_t* now);

  const string basename_;   //日志文件名，默认保存在当前工作目录下
  const off_t rollSize_;    //日志文件超过设定值进行roll
  const int flushInterval_;   //flush时间间隔
  const int checkEveryN_;    //多少次日志操作，检查是否刷新，是否roll

  int count_; //对当前日志文件，进行的日志操作次数，结合checkEveryN_使用

  std::unique_ptr<MutexLock> mutex_;   //操作Appendfiles是否加锁
  time_t startOfPeriod_;  //用于标记同一天的时间戳
  time_t lastRoll_;  //上一次roll的时间戳
  time_t lastFlush_;  //上一次flush的时间戳
  std::unique_ptr<FileUtil::AppendFile> file_;

  const static int kRollPerSeconds_ = 60*60*24; //一天的秒数
};
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
32
33
34

设计细节

5.1构造函数和析构函数

在构造函数当中，完成对成员变量的初始化，默认threadSafe为true则创建mutex,反之则不需要创建mutex。
因为这是刚开始，所以要进行一次日志滚动rollFile()
析构函数采用默认析构函数

LogFile::LogFile(const string &basename,
                 off_t rollSize,
                 bool threadSafe,
                 int flushInterval,
                 int checkEveryN)
    : basename_(basename),
      rollSize_(rollSize),
      flushInterval_(flushInterval),
      checkEveryN_(checkEveryN),
      count_(0),
      mutex_(threadSafe ? new MutexLock : NULL),
      startOfPeriod_(0),
      lastRoll_(0),
      lastFlush_(0)
{
  assert(basename.find('/') == string::npos);
  rollFile();
}

LogFile::~LogFile() = default;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

5.2日志滚动

什么是日志滚动？
当一个日志文件达到某种限制时，需要将日志信息输出到另一个新的日志文件当中，这个过程叫做日志滚动.
日志滚动是必要的，不能让一个日志文件无限大下去，根据一定周期进行日志滚动，也更方便后期日志的查看。
不同日志库的日志滚动策略是不同的。

muduo库日志日志滚动干了下面几件事情

1. 获取重新生成日志文件的文件名
2. 更新数据
3. file_.reset()

//日志滚动的实现
//相当于重新生成日志，再向里面写数据
bool LogFile::rollFile()
{
  time_t now = 0;
  //获取日志文件名,并获取当前时间戳存入now中
  string filename = getLogFileName(basename_, &now);
  
  //将now对齐到kRollPerSeconds_的整数倍,来表示那一天
  time_t start = now / kRollPerSeconds_ * kRollPerSeconds_;


 //如果大于上一次滚动的时间
  if (now > lastRoll_)
  {
    lastRoll_ = now;
    //这里要更新日志flush时间是因为，进行日志滚动，上一个日志文件会被close，会自动调用flush
    lastFlush_ = now;
    startOfPeriod_ = start;
    //重新写入新的文件
    file_.reset(new FileUtil::AppendFile(filename));
    return true;
  }
  return false;
}
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

在rollFile中调用了getLogFileName()，如下

/*
 * 构造一个日志文件名
 * 日志名由基本名字+时间戳+主机名+进程id+加上“.log”后缀
 */
string LogFile::getLogFileName(const string &basename, time_t *now)
{
  string filename;
  // reserve()将字符串的容量设置为至少basename.size() + 64,因为后面要添加时间、主机名、进程id等内容，
  //  预先设置容量大小，为了避免反复重新分配缓冲区内存而导致效率降低，
  //  或者在使用某些STL操作(例如std::copy)之前保证缓冲区够大
  filename.reserve(basename.size() + 64);
  //基本文件名
  filename = basename;

 //获取当前年月日
  char timebuf[32];
  struct tm tm;
  *now = time(NULL);
  gmtime_r(now, &tm); // FIXME: localtime_r ?//可重入时间获取函数
  /*C 库函数 
  size_t strftime(char *str, size_t maxsize,
   const char *format, const struct tm *timeptr) 
  根据 format 中定义的格式化规则，格式化结构
   timeptr 表示的时间，并把它存储在 str 中。*/
  strftime(timebuf, sizeof timebuf, ".%Y%m%d-%H%M%S.", &tm);
  filename += timebuf;


  //获取主机名
  filename += ProcessInfo::hostname();
   //进程id
  char pidbuf[32];
  snprintf(pidbuf, sizeof pidbuf, ".%d", ProcessInfo::pid());
  filename += pidbuf;

  //文件后缀
  filename += ".log";
  //返回构建的的日志文件名
  return filename;
}
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
32
33
34
35
36
37
38
39
40
41

5.3日志消息添加

消息的写入就体现了muduo库的日志滚动策略

//LogFile::append()函数添加日志内容，实际是调用AppendFile::append()函数。
//但是，这里还设计是否使用互斥锁、日志滚动的策略判断。
void LogFile::append(const char *logline, int len)
{
  if (mutex_)
  {
    MutexLockGuard lock(*mutex_);
    append_unlocked(logline, len);
  }
  else
  {
    append_unlocked(logline, len);
  }
}

void LogFile::flush()
{
  if (mutex_)
  {
    MutexLockGuard lock(*mutex_);
    file_->flush();
  }
  else
  {
    file_->flush();
  }
}

void LogFile::append_unlocked(const char *logline, int len)
{
  file_->append(logline, len);

  if (file_->writtenBytes() > rollSize_)
  {
    rollFile();
  }
  else
  {
    ++count_;
     每写入日志checkEveryN_ = 1024 次就检查是否需要roll
    if (count_ >= checkEveryN_)
    {
      count_ = 0;//重置
      time_t now = ::time(NULL);
      time_t thisPeriod_ = now / kRollPerSeconds_ * kRollPerSeconds_;
      //不在同一天，就需要进行日志滚动
      if (thisPeriod_ != startOfPeriod_)
      {
        rollFile();
      }
      //判断是否需要flush
      else if (now - lastFlush_ > flushInterval_)
      {
        lastFlush_ = now;
        file_->flush();
      }
    }
  }
}
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

问题解决

在文章一开始，就写出了我在阅读muduo库源码过程中的疑惑

问题一

在我看来，将缓冲区改为本地缓冲区无非就是想增加缓冲区大小，Linux下输入到文件的默认缓冲区大小为4096（详细内容查看《UNIX高级环境编程手册》）。
我们知道磁盘IO是十分耗费时间的操作，缓冲区过小就意味着要不断的进行磁盘IO操作。
为了尽量减少磁盘IO操作次数，一个可行的方法就是使用::setbuffer函数将文件的缓冲区设置大一些。

问题二

在多线程下，向文件写数据线程安全是必要的，不然会出现消息交织的情况，为了保证线程安全，就要拿锁来维护。
而加锁解锁，会有一定的性能损耗。在某些场景下（单线程），则并没有线程安全的顾虑，因此锁并不需要。

muduo库的作者真的很厉害，他的办法是，是在上层封装中判断是否使用互斥锁，在下层调用非线程安全的::fwrite_unlock

muduo库是一个多生产者单消费者模型，多个前端将日志信息写入日志队列当中，但后端只有一个，负责将日志信息写入磁盘，显然后端这是单线程，不会出现线程安全问题，就可以采用上面方法高效写文件