目录

• 1.概述
• 2.问题(最后解决)
• 3.muduo库日志滚动条件
• 4.AppendFile类
• • 4.1构造函数和析构函数
  • 4.2写入和缓冲区刷新
• 5.LogFile类
• • 5.1构造函数和析构函数
  • 5.2日志滚动
  • 5.3日志消息添加
• 问题解决
• • 问题一
  • 问题二

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]; //文件输出缓冲区大小，64kboff_t writtenBytes_;  //已写日志数据的总字节数
};}  // namespace FileUtil
}  // namespace muduo

设计细节

4.1构造函数和析构函数

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

FileUtil::AppendFile::AppendFile(StringArg filename): fp_(::fopen(filename.c_str(), "ae")),  // 'e' for O_CLOEXECwrittenBytes_(0)
{assert(fp_);//将缓冲区设置为本地的bufer::setbuffer(fp_, buffer_, sizeof buffer_);
}
FileUtil::AppendFile::~AppendFile()
{::fclose(fp_);
}

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_unlockedreturn ::fwrite_unlocked(logline, 1, len, fp_);
}void FileUtil::AppendFile::flush()
{::fflush(fp_);
}

5.LogFile类

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

class LogFile : noncopyable
{public:LogFile(const string& basename,off_t rollSize,bool threadSafe = true,int flushInterval = 3, //默认刷新间隔为3int 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_;    //日志文件超过设定值进行rollconst int flushInterval_;   //flush时间间隔const int checkEveryN_;    //多少次日志操作，检查是否刷新，是否rollint count_; //对当前日志文件，进行的日志操作次数，结合checkEveryN_使用std::unique_ptr mutex_;   //操作Appendfiles是否加锁time_t startOfPeriod_;  //用于标记同一天的时间戳time_t lastRoll_;  //上一次roll的时间戳time_t lastFlush_;  //上一次flush的时间戳std::unique_ptr file_;const static int kRollPerSeconds_ = 60*60*24; //一天的秒数
};

设计细节

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;

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，会自动调用flushlastFlush_ = now;startOfPeriod_ = start;//重新写入新的文件file_.reset(new FileUtil::AppendFile(filename));return true;}return false;
}

在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();//进程idchar pidbuf[32];snprintf(pidbuf, sizeof pidbuf, ".%d", ProcessInfo::pid());filename += pidbuf;//文件后缀filename += ".log";//返回构建的的日志文件名return filename;
}

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 次就检查是否需要rollif (count_ >= checkEveryN_){count_ = 0;//重置time_t now = ::time(NULL);time_t thisPeriod_ = now / kRollPerSeconds_ * kRollPerSeconds_;//不在同一天，就需要进行日志滚动if (thisPeriod_ != startOfPeriod_){rollFile();}//判断是否需要flushelse if (now - lastFlush_ > flushInterval_){lastFlush_ = now;file_->flush();}}}
}

问题解决

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

问题一

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

问题二

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

muduo库的作者真的很厉害，他的办法是，是在上层封装中判断是否使用互斥锁，在下层调用非线程安全的::fwrite_unlock
这样就完美解决了以上问题。