C++ 自制Redis数据库（十三) 持久化AOF日志模块测试完毕

持久化AOF部分测试完毕

废话不多说，一般写日志，很多人就直接write 了，但是效率很低，这里就不详细解释了。

我AOF模块的设计

我是在为我的数据库写这个日志模块所以我需要考虑如下几个指标：

1.并发量不敢说很巨大。但是多个线程同时需要写日志这种可能性还是有的，一个连接给一个线程池中的线程干活，当业务很多的时候，好几个线程同时需要写日志是很可能的，所以需要来考虑。

2.吞吐量这个指标对于一个日志自系统来说都是很重要的，我们当然需要尽量利用硬盘的读写速度。

设计模式

我也查了很多的多路缓冲写日志的相关信息，也问了学长@王伟豪@苗帅，然后还是不晓得怎么搞，大概理解就是开辟缓冲区，然后加锁，当缓冲区到达一定程度的时候执行写文件操作。这样，策略很多，我也是眼花缭乱，我突然想起来之前看过Glibc 的malloc的设计，于是结合着我的需求，我这个多路缓冲日志就应运而生啦。

思路：

开辟几个缓冲区，每个缓冲区均有自己的锁，然后需要写日志的时候，就获取其中的一个锁，写入缓冲区，如果一个线程发现自己写完日志后，正好这个缓冲区满了，那么它就要负责去抢文件的锁，将整个缓冲区一股脑全写进文件里去。

就是这样，我希望每次来的日志都写进缓冲区去，然后当一个缓冲区满了就去抢写的锁。我们需要尽量将锁的争抢过程放到缓冲区上，文件写锁尽量少发生抢锁的情况，所以我们的缓冲区可以开得大一些。拖延时间，减少文件磁盘IO操作。

下面是一些代码和测试结果

class AOF_FILE{
    private:
        int fd;
    public:
        std::mutex mutex_write;
        AOF_FILE();
};


class AOF_LOG{
    private:
        
        char    (*log_data)[AOF_LOG_MAXSIZE];
        AOF_FILE  FILE_WRITE;
        int useful;
                        
    public:
        std::mutex mutex_log;
        AOF_LOG();
        ~AOF_LOG();
        bool AOF_LOG_ADD(const char *mesg,int flag);
        bool WRITE();

};


class AOF_LOG_DO{
    private:
        AOF_LOG  aof_buffer[AOF_LOG_AREA];
        int useful;
        int resume;
    public:
        AOF_LOG_DO();
        bool AOF_LOG_add(const char *mesg);
        bool AOF_LOG_enforce_write();
        bool AOF_LOG_READ(char *get);
        int & AOF_LOG_getresume();
};

AOF_FILE::AOF_FILE(){
    
    fd = 0;

}

/********************************************************/



AOF_LOG::AOF_LOG(){             /*init  one pice of buffer*/
    
    log_data = new char[AOF_LOG_ELEM][AOF_LOG_MAXSIZE];
    
    useful   = 0;
      
}

AOF_LOG::~AOF_LOG(){
    
    delete [] log_data;

}

bool AOF_LOG::AOF_LOG_ADD(const char *mesg,int flag){
    
    int length = std::strlen(mesg);
    if(length != flag){
	    return false;
    }
    bzero(log_data[useful],AOF_LOG_MAXSIZE);
    memcpy(log_data[useful],mesg,AOF_LOG_MAXSIZE);
    useful++;
    if(useful == AOF_LOG_ELEM){
        WRITE();
    }
    return true;
}

bool AOF_LOG::WRITE(){
    
    while(1){
        if(FILE_WRITE.mutex_write.try_lock()){
            break;
        }
    }
    FILE *fp;
    //fd = open("LOG_AOF.log",O_RDWR|O_APPEND|O_CREAT,777);
    fp = fopen("LOG_AOF.log","ab+");
    if(!fp){
               
        return false;                                             
    }else{
        for(int i = useful;i > 0;i--){
	     
             //write(fd,log_data[i],AOF_LOG_MAXSIZE);
            fwrite(log_data[i],AOF_LOG_MAXSIZE,1,fp);
        }
        useful = 0;
        fclose(fp);
        FILE_WRITE.mutex_write.unlock();
        return true;
    }


}

/*******************************************************/

AOF_LOG_DO::AOF_LOG_DO(){
    useful = 0;
}




bool AOF_LOG_DO::AOF_LOG_add(const char *mesg){

    int length = std::strlen(mesg);
    if(length > AOF_LOG_MAXSIZE){
        return false;                         
    }
    int get_mutex = 1;
    while(get_mutex){
        for(int id = 0;id < AOF_LOG_AREA; id++){    
            if(aof_buffer[id].mutex_log.try_lock()){
                aof_buffer[id].AOF_LOG_ADD(mesg,length); 
                aof_buffer[id].mutex_log.unlock();
                get_mutex = 0;
                break;
            }
        }
    }

}

bool AOF_LOG_DO::AOF_LOG_enforce_write(){    
    for(int i = 0;i < AOF_LOG_AREA;i++){
        while(1){
            if(aof_buffer[i].mutex_log.try_lock()){
                break;
            }
        }
        aof_buffer[i].WRITE();
        aof_buffer[i].mutex_log.unlock();
        
    }
    return true;
}

bool AOF_LOG_DO::AOF_LOG_READ(char *get){
    FILE *fp;
    resume = 0;
    fp = fopen("LOG_AOF.log","rb");
    if(!fp){
        return false;
    }else{
        while(fread(get,AOF_LOG_MAXSIZE,1,fp)){
            
            resume++;
            //std::cout << get << std::endl;
        }
    }
    fclose(fp);
}

int & AOF_LOG_DO::AOF_LOG_getresume(){
    return resume;
}

测试结果

老实说，我也不知道什么样的效果才能算是称职的日志子系统，大家都看看，提提意见，这肯定不是最优的方法。

开4个线程，每个线程写500000（五十万）条日志，总共两百万条日志。

共花费1.9秒，平均每秒100万条日志，100万条日志 大约等于244MB/s.（基本把硬盘都用上了）

以上。