论坛网站论坛网站建设建设常州seo
一、借用标准库模板构造自己的模板
通常，模板设计是遵循当对象的类型不影响类中函数的行为时就使用模板。这也就是为何标准库提供大部分的模板都是与容器、迭代器、适配器、通用算法等有关，因为这些主要是除了对象集合行为，如读写、增删、遍历、排序、比较等大多与对象类型无关的逻辑行为。
在实际项目中，本人建议大家在使用模板时，采用的最好模板设计方式是走适配器方法，就像标准库基于vector、list、deque这些基准容器，通过适配封装去实现stack、queue、priority queue这些容器适配器一样。我们根据自己项目需要，采用标准库提供的容器及算法，创建自己的类模板应用到项目中。
二、基于标准库模板创建自定义类模板案例
2.1 自定义容器适配器
在本文中，将设计一个日志消息队列的容器适配器，基于双端队列(deque)容器和互斥锁，通过适配，创建一个线程安全的消息队列类模板。该消息队列类通过二次封装，实现数据末端添加数据，头部取出数据，队列大小有限制的跨线程安全消息缓冲区。
首先创建一个queuedata.h和queuedata.cpp源文件，在queuedata.h文件实现消息队列类模板进行声明，在queuedata.cpp源文件进行定义，在queuedata.h文件末通过#include "queuedata.cpp"引用定义内容。本文中，QueueData类模板虽然说类似容器适配器，但是没有提供配套的迭代器iterator，大家感兴趣的可以自行实现一下（就是将deque容器的迭代器iterator做一下中转即可）。
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000#ifndef _QUEUE_DATA_H_
#define _QUEUE_DATA_H_/************************************************************************Copyright 2023-02-06, pyfree**File Name : queuedata.h*File Mark : *Summary : *数据队列类模板,线程安全，对std::deque进行适配，通过PYMutex锁约束线程安全，提供数据增删等功能接口**Current Version : 1.00*Author : pyfree*FinishDate :**Replace Version :*Author :*FinishDate :************************************************************************/
#include <deque>
#include <queue>
#include <stdio.h>
#include <string.h>
#include <string>#include "Mutex.h"template <class T>
class QueueData
{
public:QueueData(std::string desc = "thread_queue");~QueueData();///*** 获取队列大小* @return {int } 队列大小*/int size();/*** 判定队列是否为空* @return {bool } 是否为空队列*/bool isEmpty();/*** 获取队列头元素* @param it {T&} 头元素* @return {bool } 是否成功*/bool getFirst(T &it);/*** 删除元素* @return {bool } 是否成功*/bool removeFirst();/*** 获取队列头元素，并从队列终删除* @param it {T&} 头元素* @return {bool } 是否成功*/bool pop(T &it);/*** 从队列头开始逐步获取多个元素，并剔除* @param its {queue<T>&} 获取到的元素集* @param sizel {int} 一次获取多少个* @return {bool } 至少获取一个元素以上则成功*/bool getList(std::queue<T> &its,unsigned int sizel=5);/*** 从队列尾部添加元素* @param it {T} 被添加元素* @return {void } 无返回*/void add(T it);/*** 从队列头部添加元素* @param it {T} 被添加元素* @return {void } 无返回*/void add_front(T it);/*** 清空元素* @return {void }*/void clear();
private:void init();QueueData& operator=(const QueueData&) {return this;};
protected:std::string queue_desc;
private:/点集转发//协议解析结果缓存std::deque<T> datacache_queue; //队列容器PYMutex m_Mutex; //线程锁,或者如果更彻底采用acl库,采用acl::thread_mutex替代//static unsigned int QSize; //队列大小约束,超出是会从队列头剔除旧数据腾出空位在对末添加数据//int queue_overS; //队列溢出次数计数
};#include "queuedata.cpp"#endif //_QUEUE_DATA_H_2.2 非类型模板参数的结构体模板
传入消息队列类的信息是一个非类型模板参数的结构体模板，可以根据实际项目需要选择消息缓存区最大字节数。创建LogDef.h源文件，实现消息结构体模板，并定义日志等级枚举值。该结构体在定义对象时可以采用默认的方法MyLogStruct<> obj，也可以指定大小MyLogStruct<DATA_SIZE_MAX_LEVLE2> obj，或指定任意值作为缓存区域大小，MyLogStruct<100> obj。
#ifndef _LOG_DEF_H_
#define _LOG_DEF_H_
/************************************************************************Copyright 2023-02-06, pyfree**File Name : LogDef.h*File Mark : *Summary : Log线程类使用到的日志等级枚举类型，日志信息格式-用于日志缓冲区存放日志的结构体**Current Version : 1.00*Author : pyfree*FinishDate :**Replace Version :*Author :*FinishDate :************************************************************************/
#ifdef __linux__
#include <string.h>
#endif typedef enum eLogType
{eLog_DEBUG = 1,eLog_TRACE = 2,eLog_NOTICE = 3,eLog_WARNING = 4,eLog_ERROR = 5
}LogLevel;#define DATA_SIZE_MAX_LEVLE1 1024 //日志缓存信息空间大小(1024字节)
#define DATA_SIZE_MAX_LEVLE2 512 //日志缓存信息空间大小(512字节)
#define DATA_SIZE_MAX_LEVLE3 256 //日志缓存信息空间大小(256字节)//日志缓存信息结构体,采用结构体默认赋值
template<int SIZE = DATA_SIZE_MAX_LEVLE3>
struct MyLogStruct
{MyLogStruct():type(0){memset(szBuffer, 0, SIZE);};int type;char szBuffer[SIZE];
};#endif //_LOG_DEF_H_2.3 日志记录类设计
下来就是日志记录功能部分，创一个日志类，该类有一个QueueData<MyLogStruct<> > logs_cache对象用来缓存日志。该日志类还是一个单体模式设计，并继承一个线程类。线程循环体内，日志对象会不断去读取缓存区内的日志信息，如果读取到信息，就写入到日志文件内。另外，为了方式日志记录过大造成磁盘存储空间不足，将有一个DiskSpaceMgr类对象来定期巡检磁盘剩余空间，在存储空间不足时，去删除旧的日志信息。
创建Log.h和Log.cpp源文件，Log.h源文件如下：
#ifndef _CLOGGER_H_
#define _CLOGGER_H_
/************************************************************************Copyright 2023-02-06, pyfree**File Name : Log.h*File Mark : *Summary : Log写入独立线程类，提供添加日志信息进入缓存接口，自身不断从缓存读取日志信息写入文件* 会启动一个磁盘空间管理线程对象DiskSpaceMgr，在磁盘空间不足时，删除旧日志**Current Version : 1.00*Author : pyfree*FinishDate :**Replace Version :*Author :*FinishDate :************************************************************************/
#include "myThread.h"
#include "LogDef.h"
#include "queuedata.h"class DiskSpaceMgr;class CLogger : public MyThread
{
public:void Log(const eLogType type, const char* lpszFormat, ...);static CLogger* createInstance( void );
private:CLogger();~CLogger();int Run();void WriteLog( const int iMsgType, const char * strMsg);void WriteLogToFile( std::string strPath,std::string strTime,const char * strMsg);std::string createFileName(std::string strTime_);std::string strTime();std::string createLogTimeAndTypeDesc(const unsigned int iMsgType, std::string strTime_);
private:static CLogger* m_pLogInstance;bool running;FILE * fpLog;std::string cur_log_path;//for cacheQueueData<MyLogStruct<> > logs_cache;//DiskSpaceMgr *disk_space_mgr;
};
#endif //_CLOGGER_H_
2.4 磁盘剩余空间管理类
对象DiskSpaceMgr *disk_space_mgr是由Logger类创建的，该磁盘空间管理类是继承了类线程类的，在线程循环体内，不间断地巡检指定磁盘的剩余空间是否小于限定空间大小，小于时，将按配置要求去删除旧的日志信息。
创建spaceMgr.h和spaceMgr.cpp源文件，spaceMgr.h内容如下：
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000#ifndef _SPACE_MGR_H_
#define _SPACE_MGR_H_
/************************************************************************Copyright 2023-02-06, pyfree**File Name : spaceMgr.h*File Mark : *Summary : 磁盘空间巡检线程类，根据预留空间要求删除app日志文件**Current Version : 1.00*Author : pyfree*FinishDate :**Replace Version :*Author :*FinishDate :************************************************************************/
#ifdef linux
#include <string>
#endif
#include <vector>#include "myThread.h"class DiskSpaceMgr : public MyThread
{
public:/*** 构造函数,如传入参数D 2000 log log,则指明当D盘空闲空间不足2000M时,删除当前目录/log下的log(后缀)文件* @param disk_ {char} 指定盘符* @param fsl_ {int} 预留空间大小,单位MB* @param dir_ {string} 指定目录* @param ext_ {string} 扩展名* @return { } */DiskSpaceMgr(char disk_, int fsl_,std::string dir_="log",std::string ext_="log");virtual ~DiskSpaceMgr(void);int Run();void add(std::string dir_,std::string ext_);
private:struct DelInfo{DelInfo(std::string dir_,std::string ext_): dir(dir_), ext(ext_){};std::string dir;std::string ext;};
private://用于日志删除std::vector<DelInfo> dirs; //存储目录char DiskStr; //日志存储磁盘int freeSizeLimit; //磁盘预留空间要求
};#endif
2.5 其他辅助类及函数设计
日志类及磁盘管理类都继承了线程类MyThread，是通过myThread.h和myThread.cpp声明定义的，myThread.h内容如下：
#ifndef _MYTHREAD_H
#define _MYTHREAD_H
/************************************************************************Copyright 2023-02-06, pyfree**File Name : myThread.h*File Mark : *Summary : *支持windows和linux的线程类,提供基本的线程功能(循环、启动、退出)**Current Version : 1.00*Author : pyfree*FinishDate :**Replace Version :*Author :*FinishDate :************************************************************************/
#ifdef WIN32
#include <process.h>
#include <iostream>typedef void* HANDLE_THREAD;
#else
#include <pthread.h>
#include <unistd.h>typedef pthread_t HANDLE_THREAD;
#endifclass MyThread
{
public://funcMyThread(); // constructed function~MyThread();/*** the entity for thread running* @param null {void } 无参数* @return {int} 运行返回结果*/virtual int Run()=0;/*** start thread* @param null {void } 无参数* @return {bool} 是否启动成功*/bool start();/*** get thread ID* @param null {void } 无参数* @return {HANDLE_THREAD} 线程句柄*/HANDLE_THREAD getThreadID();
#ifdef __linux__//get thread statusint getState();//wait for thread endvoid join();//wait for thread end in limit timevoid join(unsigned long millisTime);
#endif
public://val
#ifdef __linux__//threadStatus-new createstatic const int THREAD_STATUS_NEW = 0;//threadStatus-runningstatic const int THREAD_STATUS_RUNNING = 1;//threadStatus-endstatic const int THREAD_STATUS_EXIT = -1;
#endif
private://func
#ifdef WIN32static void agent(void *p);
#else//get manner pointer of execution static void* run0(void* pVoid);//manner of execution insidevoid* run1();
#endif
private://valHANDLE_THREAD hThread;
#ifdef __linux__//thread statusint threadStatus;
#endif
};#endif /* _MYTHREAD_H */
消息队列类在队列内容进行变更时，需要通过互斥锁确保跨线程操作安全，互斥锁是由Mutex.h和Mutex.cpp源文件声明定义的，Mutex.h内容如下：
#ifndef PYMUTEX_H
#define PYMUTEX_H#ifdef WIN32
//#include <windows.h>
#else
#include <pthread.h>
#endiftypedef void *HANDLE;class IMutex
{
public:virtual ~IMutex() {}virtual void Lock() const = 0;virtual bool TryLock() const = 0;virtual void Unlock() const = 0;
};class PYMutex : public IMutex
{
public:PYMutex();~PYMutex();virtual void Lock() const;virtual bool TryLock() const;virtual void Unlock() const;
private:
#ifdef _WIN32HANDLE m_mutex;
#elsemutable pthread_mutex_t m_mutex;
#endif
};#endif //PYMUTEX_H磁盘管理类，在进行磁盘信息读取和文件删除时，是借用了DiskSpace.h和DiskSpace.cpp源文件声明定义的磁盘空间统计和日志删除相关函数集来实现的，DiskSpace.h内容如下：
#ifndef DISK_SPACE_H
#define DISK_SPACE_H/************************************************************************Copyright 2023-02-06, pyfree**File Name : DiskSpace.h*File Mark : *Summary : *磁盘空间统计和日志删除相关函数集*Current Version : 1.00*Author : pyfree*FinishDate :**Replace Version :*Author :*FinishDate :************************************************************************/#include <string>namespace pyfree
{/*** 根据指定磁盘获取磁盘的总空间和剩余空间* @param _DiskStr {char} 磁盘目录,一般win指定{C,D},linux指定{/}* @param _totalSize {int} 返回磁盘总空间* @param _freeSize {int} 返回磁盘剩余空间* @return {int} 预留的返回值,暂指定是常量1*/int getDiskFreeSpace(char _DiskStr, int &_totalSize, int &_freeSize);/*** 根据指定目录 扩展名 天数限制等删除目录下的文件,项目用于删除旧日志操作* @param _dir {string}} 目录* @param extname {string} 扩展名,如txt/ini/log等* @param dayForLimit_ {int} 指定天数，默认为0时会删除非当天的其他文件* @return {void} 无返回*/void moveOldFile(std::string _dir, const std::string &extname, int dayForLimit_=0);/*** 获取当天凌晨时刻的偏移时间,单位秒,与1970-01-01 00:00:00起* @param deviation {int} 偏移秒数* @return {int} 当天凌晨时刻的偏移时间.单位秒*/int getCurDayZeroClockTime(int deviation=0);
};#endif三、工程结构及编程测试
3.1 工程目录结构
按上述源文件设计，给出组织这些源文件的工程目录结构：
log_testbin #测试程序输出build_win #win编译中间文件存储build_linux #Linux编译中间文件存储srcDiskSpace.h #磁盘访问、文件删除等功能实现DiskSpace.cppLog.h #日志类，单体模式，继承线程类Log.cppLogDef.h #日志信息定义Mutex.h #互斥锁Mutex.cppmyThread.h #线程类myThread.cpppysleep.h #线程睡眠等待统一宏转换设计queuedata.h #消息队列类模板queuedata.cppspaceMgr.h #磁盘空间管理类，继承线程类spaceMgr.cpptestmain.cpp #测试程序代码CMakeLists.txt #cmake工程compile.txt #工程编译指令3.2 cmake工程配置
CMakeLists.txt，cmake工程配置文件
# CMake 最低版本号要求
cmake_minimum_required (VERSION 2.8)
# 项目信息
project (log_test)
#
if(WIN32)message(STATUS "windows compiling...")add_definitions(-D_PLATFORM_IS_WINDOWS_)set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MT")set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MTd")set(WIN_OS true)
else(WIN32)message(STATUS "linux compiling...")add_definitions( -D_PLATFORM_IS_LINUX_)add_definitions("-Wno-invalid-source-encoding")# add_definitions("-O2")set(UNIX_OS true)set(_DEBUG true)endif(WIN32)#
set(EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)# 指定源文件的目录,并将名称保存到变量
SET(source_h${PROJECT_SOURCE_DIR}/src/pysleep.h${PROJECT_SOURCE_DIR}/src/Mutex.h${PROJECT_SOURCE_DIR}/src/myThread.h${PROJECT_SOURCE_DIR}/src/queuedata.h${PROJECT_SOURCE_DIR}/src/LogDef.h${PROJECT_SOURCE_DIR}/src/Log.h${PROJECT_SOURCE_DIR}/src/DiskSpace.h${PROJECT_SOURCE_DIR}/src/spaceMgr.h)SET(source_cpp#${PROJECT_SOURCE_DIR}/src/Mutex.cpp${PROJECT_SOURCE_DIR}/src/myThread.cpp${PROJECT_SOURCE_DIR}/src/Log.cpp${PROJECT_SOURCE_DIR}/src/DiskSpace.cpp${PROJECT_SOURCE_DIR}/src/spaceMgr.cpp${PROJECT_SOURCE_DIR}/test/main.cpp)#头文件目录
include_directories(${PROJECT_SOURCE_DIR}/src)if (${UNIX_OS})add_definitions("-W""-fPIC""-Wall"# "-Wall -g""-Werror""-Wshadow""-Wformat""-Wpointer-arith""-D_REENTRANT""-D_USE_FAST_MACRO""-Wno-long-long""-Wuninitialized""-D_POSIX_PTHREAD_SEMANTICS""-DACL_PREPARE_COMPILE""-Wno-unused-parameter""-fexceptions")set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -O0")link_directories()
# 指定生成目标
add_executable(log_test ${source_h} ${source_cpp})
#link
target_link_libraries(log_test -lpthread -pthread -lz -lrt -ldl
)endif(${UNIX_OS})if (${WIN_OS})set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4819")add_definitions("-D_CRT_SECURE_NO_WARNINGS""-D_WINSOCK_DEPRECATED_NO_WARNINGS""-DNO_WARN_MBCS_MFC_DEPRECATION""-DWIN32_LEAN_AND_MEAN"
)link_directories()if (CMAKE_BUILD_TYPE STREQUAL "Debug")set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG ${PROJECT_SOURCE_DIR}/bin)
# 指定生成目标
add_executable(log_testd ${source_h} ${source_cpp})else(CMAKE_BUILD_TYPE)set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE ${PROJECT_SOURCE_DIR}/bin)
# 指定生成目标
add_executable(log_test ${source_h} ${source_cpp})endif (CMAKE_BUILD_TYPE)endif(${WIN_OS})compile.txt，编译指令指示文件
win:
cd log_test && mkdir build_win && cd build_win
cmake -G "Visual Studio 10 2010 Win64" -DCMAKE_BUILD_TYPE=Release ..
msbuild log_test.sln /p:Configuration="Release" /p:Platform="x64"cmake -G "Visual Studio 10 2010 Win64" -DCMAKE_BUILD_TYPE=Debug ..
msbuild log_test.sln /p:Configuration="Debug" /p:Platform="x64"Linux:
cd log_test
mkdir build_linux
cd build_linux
cmake ..
make3.3 日志类调用，测试案例
测试工程文件main.cpp：
#include <stdio.h>
#include <stdlib.h>#include "pysleep.h"
#include "Log.h"namespace GlobalVar {extern char disk_DescStr; //磁盘名extern unsigned int disk_space_limit; //剩余空间限制为*MBextern std::string logdir; //后期记录日志目录重配置文件读取extern std::string logname; //可设置为服务名extern std::string log_ext_flag; //日志扩展名
};
//log_test.exe D 2000 log log
//log_test.exe D
void arg_analysis(int argc, char *argv[]);int main(int argc, char *argv[])
{arg_analysis(argc,argv);int i = 0;while(i<100){CLogger::createInstance()->Log(LogLevel(rand()%5),"log test for [%d]",i++);pysleep(10);}//while(1){pysleep(10);}return 0;
}void arg_analysis(int argc, char *argv[])
{for(int index=0; index<argc; index++){switch(index){case 0:{#ifdef WIN32std::string appname = std::string(argv[0]);GlobalVar::logname = appname.substr(0,appname.length()-4);#elseGlobalVar::logname = std::string(argv[0]);#endif}break;case 1:{GlobalVar::disk_DescStr = argv[1][0];}break;case 2:{GlobalVar::disk_space_limit = static_cast<unsigned int>(atoi(argv[2]));}break;case 3:{GlobalVar::logdir = std::string(argv[3]);}break;case 4:{GlobalVar::log_ext_flag = std::string(argv[4]);}break;default:break;}}
}
3.4 编译及测试
win:
linux:
四、补充源码
部分源码前面已经给出（头文件），下面给出其他源码文件：
pysleep.h
#ifndef _PY_SLEEEP_H_
#define _PY_SLEEEP_H_#ifdef WIN32
#include <windows.h>
#define pysleep(x) Sleep(x)
#else
#define pysleep(x) usleep(1000*x)
#endif#endif //_PY_SLEEEP_H_DiskSpace.cpp
#include "DiskSpace.h"#include <time.h>
#include <list>
#include <vector>#ifdef WIN32
#include <io.h>
#include <direct.h>
#include <Windows.h>
#else
#include <sys/statfs.h>
#include <dirent.h>
/*#include <sys/vfs.h> or <sys/statfs.h> */
#include <sys/vfs.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <stdio.h>
#endif#include "Log.h"int pyfree::getDiskFreeSpace(char _DiskStr, int &_totalSize, int &_freeSize)
{
#ifdef WIN32BOOL fResult;unsigned _int64 i64FreeBytesToCaller;unsigned _int64 i64TotalBytes;unsigned _int64 i64FreeBytes;char dir[4] = { _DiskStr, ':', '\\' };fResult = GetDiskFreeSpaceEx(dir,(PULARGE_INTEGER)&i64FreeBytesToCaller,(PULARGE_INTEGER)&i64TotalBytes,(PULARGE_INTEGER)&i64FreeBytes);//GetDiskFreeSpaceEx function,get the disk space status,return BOOL type if (fResult)//jude the disk is in work status by the return value {_totalSize = static_cast<int>(static_cast<float>(i64TotalBytes) / 1024 / 1024);_freeSize = static_cast<int>(static_cast<float>(i64FreeBytesToCaller) / 1024 / 1024);//std::cout << " totalspace:" << _totalSize << " MB" << std::endl;//disk total size //std::cout << " freespace:" << _freeSize << " MB" << std::endl;//disk free space sze }
#endif // WIN32
#ifdef __linux__//printf("DiskFlag(%c)\n", _DiskStr);struct statfs diskInfo;statfs("/", &diskInfo);unsigned long long totalBlocks = diskInfo.f_bsize;unsigned long long totalSize = totalBlocks * diskInfo.f_blocks;_totalSize = static_cast<int>(totalSize >> 20);//printf("TOTAL_SIZE == %d MB\n", _totalSize);unsigned long long freeDisk = diskInfo.f_bfree*totalBlocks;_freeSize = static_cast<int>(freeDisk >> 20);//printf("DISK_FREE == %d MB\n", _freeSize);
#endifreturn 1;
}//delete old file which is older taday for the file modify time
void pyfree::moveOldFile(std::string _dir, const std::string &extname, int dayForLimit_)
{try{
#ifdef WIN32_finddata_t fileInfo;intptr_t hFile;std::string filter = _dir;if (filter[filter.size() - 1] != '//' || filter[filter.size() - 1] != '\\') {filter.push_back('\\');}filter += "*.";filter += extname;//time_t file_time_ = time(NULL);time_t file_time_ = (time_t)getCurDayZeroClockTime(dayForLimit_*86400);//gethFile = _findfirst(filter.c_str(), &fileInfo);if (hFile == -1) {return;}std::string delOldFile = "";//find the oldest file by modify time do {if (extname.empty())//no ext name, that is dir{if ((fileInfo.attrib & _A_SUBDIR)) {if (0 == strcmp(fileInfo.name, ".") || 0 == strcmp(fileInfo.name, "..")){continue;}}}//if(fileInfo.time_write<_time)//modify timeif (fileInfo.time_create<file_time_)//create time{file_time_ = fileInfo.time_create;delOldFile = _dir + "//" + (std::string(fileInfo.name));}} while (_findnext(hFile, &fileInfo) == 0);_findclose(hFile);
#endif#ifdef linux//printf("moveOldFile(*.%s) 1 from(%s) \n",extname.c_str(),_dir.c_str());std::string curdir = _dir;if (curdir[curdir.size() - 1] != '/') {curdir.push_back('/');}DIR *dfd;if ((dfd = opendir(curdir.c_str())) == NULL){CLogger::createInstance()->Log(eLog_WARNING,"open %s error with msg is: %s\n", curdir.c_str(), strerror(errno));return;}struct dirent *dp;//time_t file_time_ = time(NULL);time_t file_time_ = (time_t)getCurDayZeroClockTime(dayForLimit_ * 86400);std::string delOldFile = "";while ((dp = readdir(dfd)) != NULL){if (extname.empty())//no ext name, that is dir{if (dp->d_type == DT_DIR) {if (0 == strcmp(dp->d_name, ".") || 0 == strcmp(dp->d_name, "..")){continue;}}}else {if (NULL == strstr(dp->d_name, extname.c_str())){continue;}}std::string _path = _dir + "/";_path += dp->d_name;struct stat el;stat(_path.c_str(), &el);if (el.st_mtime<file_time_) {file_time_ = el.st_mtime;delOldFile = _path;}}if (NULL != dp) {delete dp;dp = NULL;}if (NULL != dfd) {closedir(dfd);dfd = NULL;}
#endifif (!delOldFile.empty()){//printf("get old file: %s \n", delOldFile.c_str());int ret = remove(delOldFile.c_str());if (0 != ret) {CLogger::createInstance()->Log(eLog_WARNING,"can't remove %s \n", delOldFile.c_str());}else{CLogger::createInstance()->Log(eLog_NOTICE,"success remove %s \n", delOldFile.c_str());}}}catch(...){CLogger::createInstance()->Log(eLog_ERROR,"moveOldFile(*.%s) from(%s) exception error\n",extname.c_str(),_dir.c_str());}
}int pyfree::getCurDayZeroClockTime(int deviation)
{int ZeroClockTime_ = 0;time_t cur_time_ = time(NULL);struct tm _tt;
#ifdef WIN32localtime_s(&_tt, &cur_time_);
#elselocaltime_r(&cur_time_,&_tt);
#endif//当日凌晨时刻_tt.tm_hour = 0;_tt.tm_min = 0;_tt.tm_sec = 0;ZeroClockTime_ = static_cast<int>(mktime(&_tt));ZeroClockTime_ -= deviation;//偏移时间return ZeroClockTime_;
}
Log.cpp
#include "Log.h"
#include <time.h>
#include <sys/timeb.h>#include <stdio.h>
#include <stdarg.h>
#include <string>#ifdef __linux__
#include <string.h>
#include <unistd.h>
#include <stdlib.h>#ifndef sprintf_s
#define sprintf_s sprintf
#endif#else //WIN32#ifndef vsnprintf
#define vsnprintf vsnprintf_s
#endif
#endif#include "pysleep.h"
#include "spaceMgr.h"namespace GlobalVar
{char disk_DescStr = 'D'; //磁盘名unsigned int disk_space_limit = 2000; //剩余空间限制为*MB,少于该值去删除日志释放空间std::string logdir = "log"; //后期记录日志目录重配置文件读取std::string logname = "pyfree"; //可设置为服务名std::string log_ext_flag = "log";//日志扩展名
};CLogger* CLogger::m_pLogInstance = NULL;
CLogger::CLogger() : running(true), fpLog(NULL), cur_log_path("log")
{char buf[256] = {0};sprintf_s(buf,"mkdir %s",GlobalVar::logdir.c_str());system(buf);this->start();disk_space_mgr = new DiskSpaceMgr(GlobalVar::disk_DescStr,GlobalVar::disk_space_limit,GlobalVar::logdir,GlobalVar::log_ext_flag);disk_space_mgr->start();
};CLogger::~CLogger()
{delete disk_space_mgr;disk_space_mgr = NULL;running = false;if (NULL != fpLog){fclose(fpLog);fpLog = NULL;}
};CLogger* CLogger::createInstance( void )
{if (m_pLogInstance == NULL){m_pLogInstance = new CLogger();return m_pLogInstance;}elsereturn m_pLogInstance;
};int CLogger::Run()
{MyLogStruct<> log_item;while (running) {if(logs_cache.pop(log_item)){WriteLog(log_item.type, log_item.szBuffer);#ifdef _DEBUG#ifndef WIN32printf("Log::[%d]-->%s\n", getpid(), log_item.szBuffer);#elseprintf("Log::-->%s\n", log_item.szBuffer);#endif //WIN32#endif //_DEBUG}pysleep(1);}return 0;
};void CLogger::Log(const eLogType type, const char* lpszFormat, ...)
{va_list args;MyLogStruct<> log_item;log_item.type = static_cast<int>(type);va_start(args, lpszFormat);vsnprintf(log_item.szBuffer, sizeof(log_item.szBuffer), lpszFormat, args);va_end(args); logs_cache.add(log_item);
}void CLogger::WriteLog( const int iMsgType, const char * strMsg)
{try {//system time to stringstd::string strTime_ = strTime();//file namestd::string strPath = createFileName(strTime_.substr(0,10)); // log time and type descstd::string strTimeAndTypeDesc = createLogTimeAndTypeDesc(iMsgType, strTime_);WriteLogToFile(strPath,strTimeAndTypeDesc,strMsg);}catch (...) {printf("write log[%d]{%s}error\n", iMsgType, strMsg);}
}void CLogger::WriteLogToFile( std::string strPath,std::string strTime_,const char * strMsg)
{if(cur_log_path!=strPath||NULL == fpLog){if (NULL != fpLog){fclose(fpLog);fpLog = NULL;} //open#ifdef WIN32fopen_s(&fpLog, strPath.c_str(), "a+");#elsefpLog = fopen(strPath.c_str(), "a+");#endif}if (NULL != fpLog){fseek(fpLog, 0, SEEK_END);fwrite(strTime_.c_str(), strTime_.length(), 1, fpLog);fwrite(strMsg, strlen(strMsg), 1, fpLog);fwrite("\n", 1, 1, fpLog);}
}std::string CLogger::createFileName(std::string strTime_)
{//file namestd::string strPath = GlobalVar::logdir;
#ifdef WIN32strPath += "\\";
#elsestrPath += "/";
#endifstrPath += strTime_;strPath += "_";strPath += GlobalVar::logname;strPath += ".log";return strPath;
}std::string CLogger::strTime()
{time_t tt;struct timeb tm0;struct tm tm1;char buf[64];ftime(&tm0);tt = tm0.time;
#ifdef WIN32localtime_s(&tm1, &tt);
#elselocaltime_r(&tt, &tm1);
#endifsprintf_s(buf, "%04d-%02d-%02d %02d:%02d:%02d.%03d ", tm1.tm_year + 1900, tm1.tm_mon + 1, tm1.tm_mday, tm1.tm_hour, tm1.tm_min, tm1.tm_sec, tm0.millitm);std::string strTime_ = buf;buf[10] = '\0';return strTime_;
}
//日志等级枚举值的字符串描述
std::string eLogTypeDesc[6] = {"[UNKNOWN] ","[eLog_DEBUG] ","[eLog_TRACE] ","[eLog_NOTICE] ","[eLog_WARNING] ","[eLog_ERROR] "};std::string CLogger::createLogTimeAndTypeDesc(const unsigned int iMsgType, std::string strTime_)
{std::string strTimeAndTypeDesc = strTime_;unsigned int msg_type = iMsgType;if(msg_type>6) msg_type = 0; //非枚举值外的均为未知strTimeAndTypeDesc += eLogTypeDesc[msg_type];return strTimeAndTypeDesc;
};/*以下是LogFunction*/
/*
*在queuedata.cpp中应用,该函数主要用来解决QueueData类嵌套调用CLogger的异常问题：
*“嵌套名指定中使用了不完全的类型”
*/
void reportLogCacheOver(const char *queue_desc,int size)
{//每溢出10次，报告一次CLogger::createInstance()->Log(eLog_WARNING,"add item to queue %s, but the size of QueueData is up to limmit size: %d.\n", queue_desc, size);
}
Mutex.cpp
#include "Mutex.h"#ifdef WIN32
#include <windows.h>
#endif
//#include <iostream>
#include <stdio.h>PYMutex::PYMutex()
{
#ifdef _WIN32m_mutex = ::CreateMutex(NULL, FALSE, NULL);
#elsepthread_mutex_init(&m_mutex, NULL);
#endif
}PYMutex::~PYMutex()
{
#ifdef _WIN32::CloseHandle(m_mutex);
#elsepthread_mutex_destroy(&m_mutex);
#endif
}void PYMutex::Lock() const
{
#ifdef _WIN32//DWORD d = WaitForSingleObject(m_mutex, INFINITE);WaitForSingleObject(m_mutex, INFINITE);/// \todo check 'd' for result
#elsepthread_mutex_lock(&m_mutex);
#endif
}bool PYMutex::TryLock() const
{
#ifdef _WIN32DWORD dwWaitResult = WaitForSingleObject(m_mutex, 0); if (dwWaitResult != WAIT_OBJECT_0 && dwWaitResult != WAIT_TIMEOUT) {printf("thread WARNING: bad result from try-locking mutex\n");}return (dwWaitResult == WAIT_OBJECT_0) ? true : false;
#elsereturn (0==pthread_mutex_trylock(&m_mutex))?true:false;
#endif
};void PYMutex::Unlock() const
{
#ifdef _WIN32::ReleaseMutex(m_mutex);
#elsepthread_mutex_unlock(&m_mutex);
#endif
}
myThread.cpp
#include "myThread.h"#ifdef WIN32
#include <windows.h>
#else
#include <stdio.h>
#endif MyThread::MyThread()
{#ifdef __linux__hThread = 0;threadStatus = THREAD_STATUS_NEW;#endif
}MyThread::~MyThread()
{#ifdef WIN32WaitForSingleObject(hThread, INFINITE);#elsejoin(10);#endif
}int MyThread::Run()
{#ifdef WIN32printf("Base Thread\n");#elsewhile(true){printf("thread is running!\n");sleep(100);}#endifreturn 0;
}bool MyThread::start()
{#ifdef WIN32return NULL!=(hThread =(HANDLE_THREAD)_beginthread(agent, 0, (void *)this));#elsereturn pthread_create(&hThread, NULL, run0, this) == 0;#endif
}HANDLE_THREAD MyThread::getThreadID()
{return hThread;
}#ifdef WIN32
void MyThread::agent(void *p)
{MyThread *agt = (MyThread *)p;agt->Run();
}#else
void* MyThread::run0(void* pVoid)
{MyThread* p = (MyThread*) pVoid;p->run1();return p;
}void* MyThread::run1()
{threadStatus = THREAD_STATUS_RUNNING;hThread = pthread_self();Run();threadStatus = THREAD_STATUS_EXIT;hThread = 0;pthread_exit(NULL);
}int MyThread::getState()
{return threadStatus;
}void MyThread::join()
{if (hThread > 0){pthread_join(hThread, NULL);}
}void MyThread::join(unsigned long millisTime)
{if (hThread == 0){return;}if (millisTime == 0){join();}else{unsigned long k = 0;while (threadStatus != THREAD_STATUS_EXIT && k <= millisTime){usleep(100);k++;}}
}
#endif
queuedata.cpp
#include "queuedata.h"#include "LogDef.h"
#include "Log.h"extern void reportLogCacheOver(const char*,int);template <class T>
unsigned int QueueData<T>::QSize = 100;template <class T>
QueueData<T>::QueueData(std::string desc): queue_desc(desc)
{init();
};template <class T>
void QueueData<T>::init()
{queue_overS = 0;
};template <class T>
QueueData<T>::~QueueData()
{}//
template <class T>
int QueueData<T>::size()
{int ret = 0;m_Mutex.Lock();ret = static_cast<int>(datacache_queue.size());m_Mutex.Unlock();return ret;
}template <class T>
bool QueueData<T>::isEmpty()
{bool ret = false;m_Mutex.Lock();ret = datacache_queue.empty();m_Mutex.Unlock();return ret;
}template <class T>
bool QueueData<T>::getFirst(T &it)
{bool ret = false;m_Mutex.Lock();if (!datacache_queue.empty()) {it = datacache_queue.front();ret = true;}m_Mutex.Unlock();return ret;
}template <class T>
bool QueueData<T>::removeFirst()
{bool ret = false;m_Mutex.Lock();if (!datacache_queue.empty()) {datacache_queue.pop_front();ret = true;}m_Mutex.Unlock();return ret;
}template <class T>
bool QueueData<T>::pop(T &it)
{bool ret = false;m_Mutex.Lock();if (!datacache_queue.empty()) {it = datacache_queue.front();datacache_queue.pop_front();ret = true;}m_Mutex.Unlock();return ret;
};template <class T>
bool QueueData<T>::getList(std::queue<T> &its,unsigned int sizel)
{m_Mutex.Lock();while (!datacache_queue.empty()){its.push(datacache_queue.front());datacache_queue.pop_front();if (its.size() >= sizel){break;}}m_Mutex.Unlock();return !its.empty();
};template <class T>
void QueueData<T>::add(T it)
{m_Mutex.Lock();if (datacache_queue.size() > QSize) {queue_overS++;datacache_queue.pop_front();}datacache_queue.push_back(it);m_Mutex.Unlock();if (queue_overS >= 10) {//每溢出10次，报告一次reportLogCacheOver(queue_desc.c_str(),QSize);queue_overS = 0;}
}template <class T>
void QueueData<T>::add_front(T it)
{m_Mutex.Lock();if (datacache_queue.size() > QSize) {queue_overS++;datacache_queue.pop_front();}datacache_queue.push_front(it);m_Mutex.Unlock();if (queue_overS >= 10) {reportLogCacheOver(queue_desc.c_str(),QSize);queue_overS = 0;}
}template <class T>
void QueueData<T>::clear()
{m_Mutex.Lock();datacache_queue.clear();m_Mutex.Unlock();queue_overS = 0;
}
spaceMgr.cpp
#include "spaceMgr.h"#include "pysleep.h"
#include "DiskSpace.h"DiskSpaceMgr::DiskSpaceMgr(char disk_, int fsl_, std::string dir_/*="log"*/, std::string ext_/*="log"*/): DiskStr(disk_),freeSizeLimit(fsl_)
{DelInfo del_(dir_,ext_);dirs.push_back(del_);
}DiskSpaceMgr::~DiskSpaceMgr(void)
{}int DiskSpaceMgr::Run()
{int i_totalSize = 0;int i_freeSize = 0;while (true){if (pyfree::getDiskFreeSpace(DiskStr, i_totalSize, i_freeSize) > 0){if (freeSizeLimit > i_freeSize){for(unsigned int i=0; i<dirs.size(); ++i){std::string ext = dirs.at(i).ext;pyfree::moveOldFile(dirs.at(i).dir, ext);}}}pysleep(10);}return 0;
}void DiskSpaceMgr::add(std::string dir_,std::string ext_)
{DelInfo del_(dir_,ext_);dirs.push_back(del_);
}