多备份数据更新管理器模板设计（C++ Template）

在网络服务等需要提供不间断服务的程序中，程序的运行时升级通常都是一项常规任务，例如：

1）运行时修改一些参数配置；

2）运行时修改一个算法模块（动态库）；

为了在执行这些任务时，程序不停（仍使用旧配置或旧模块运行），常见的解决方案包括：

1）增加冗余的配置项或模块句柄的存储空间（所有这些数据打包成一个结构体），程序运行时使用其中的一份；当需要更新时，在更新的过程中将新的配置（或模块句柄）内容存储至备用内存；加载完成后将运行时配置（或模块句柄）指针指向新的内存地址。由于修改配置（或模块句柄）的频率远小于这些内容的读取频率，因此一个线程执行更新操作即可。另外，即使外加有多个线程同时读取，由于只涉及到配置项（或模块句柄）的整体结构体的这一个指针修改，读线程读到的值无非是“旧指针”和“新指针”二者之一（如果内存读写模型不支持这一点，或者在这种情况下可能有第三种，甚至第四种情况出现，本方案将不可用），因此程序仍能正常执行，并最终使用更新后的内容运行。

2）程序通过一个主进程协调，具体任务由工作进程完成。外界通知这个主进程使用新的配置（或模块），主进程便创建新的工作进程，这些新启动的进程自然会使用新的配置（或模块）；当新创建的进程一切就绪之后，主进程便会通知其他进程结束，并在之后将新的任务委派给新创建的进程。Nginx的设计便是这种方案的一个典型。

这里设计的一个C++模板是上述解决方案1）的一种实现（完整地VS2008项目代码在这里）：

//
// 数据清理函数指针类型
//
template<typename T>
struct DataCleaner {
typedef void (*ClearFun)(T*);
};

template<typename T>
void _default_reset_fun_(T* t)
{
memset(t, 0, sizeof(T));
};

//
// 多备份数据更新管理器
//
template<typename T, const size_t POOLSIZE=2, bool static_memory=true>
class LatestDataManager;

template<typename T, const size_t POOLSIZE>
class LatestDataManager<T, POOLSIZE, true>
{
public:
typedef T value_type;

LatestDataManager(){m_clf = _default_reset_fun_<T>;}
~LatestDataManager(){}

T& GetCurrent(){ return m_elem[m_current]; }
T& GetNext(){
size_t next = (m_current+1)%POOLSIZE;
m_clf(&m_elem[next]);
return m_elem[next];
}
void UseLatest(){ m_current = (m_current+1)%POOLSIZE; }
void SetClearFun(typename DataCleaner<T>::ClearFun f){ m_clf = f; }
private:
T                           m_elem[POOLSIZE];
size_t                      m_current;
typename DataCleaner<T>::ClearFun    m_clf;
};

template<typename T, const size_t POOLSIZE>
class LatestDataManager<T, POOLSIZE, false>
{
public:
typedef T value_type;

LatestDataManager(){memset(m_elem, 0, POOLSIZE*sizeof(T*));}
~LatestDataManager(){}

T* GetCurrent(){ return m_elem[m_current]; }
T* GetNext(){
size_t next = (m_current+1)%POOLSIZE;
if(NULL!=m_elem[next]){
delete m_elem[next];
m_elem[next] = NULL;
}
m_elem[next] = new T;
return m_elem[next];
}
void UseLatest(){ m_current = (m_current+1)%POOLSIZE; }
void SetClearFun(typename DataCleaner<T>::ClearFun){}
private:
T*                          m_elem[POOLSIZE];
size_t                      m_current;
};

测试代码：

template<typename T>
void _primdata_reset_fun_(T* t)
{
*t = 0;
}
typedef LatestDataManager<int, 2, true>  LatestConfig;

template<typename T>
void _container_reset_fun_(T* t)
{
if(t) t->clear();
}
typedef LatestDataManager<std::vector<std::string>, 2, false>  LatestMachines;

{
LatestConfig g_cfg;
g_cfg.SetClearFun( _primdata_reset_fun_< LatestConfig::value_type > );
{// 更新者 ... ...
g_cfg.GetNext() = 3;
g_cfg.UseLatest();
}
{// 使用者 ... ...
int config = g_cfg.GetCurrent();
std::cout << config << std::endl;
}
}

{
LatestMachines g_lm;
g_lm.SetClearFun( _container_reset_fun_< LatestMachines::value_type > );
{// 更新者 ... ...
std::vector<std::string>* machines = g_lm.GetNext();
machines->push_back("192.168.0.1");
machines->push_back("192.168.0.2");
machines->push_back("192.168.0.3");
g_lm.UseLatest();
}
{// 使用者 ... ...
std::vector<std::string>* machines = g_lm.GetCurrent();
for(std::vector<std::string>::iterator it=machines->begin(); it!=machines->end(); ++it)
{
std::cout << it->c_str() << std::endl;
}
}
}