我也是直到最近才接触到'高可用性'这个词儿的，从我所在的项目需求角度出发，我理解'高可用性'就是在系统的外部依赖实体(如主数据库、主网络)等瘫痪了之后，系统仍然能正常的支撑业务的运行，当然系统自己宕掉了，那就没辙了^_^。高可用性设计实际上就是在系统自身完好的情况下如何考虑其外部实体的设计以保证系统能持续的运行支撑下去，起码从我现在正在做的项目的角度来说是可以这样理解的。

目前我们的系统的高可用性主要体现在对数据库的访问机制上。对于24×7小时运行的系统来说，数据库不可避免的需要采用一些容灾机制来保证数据的正确和不丢失或者是将损失减少到最低点。我们的系统采用双机热备的方式，一旦ACTIVE数据库宕掉，我们的系统就应该'自动'切换到STANDBY数据库上。这里就存在一个问题，到底如何切换，又如何在ACTIVE数据库恢复后，重新将数据库切换回到ACTIVE数据库呢？我个人从一开始就想这个切换过程应该对我们的系统保持透明，我们的系统能看到的只有一套用户名、密码和服务名并利用这套配置访问数据库，置于访问到哪一个数据库可由数据库那方来定，这样对于我们的系统来说实现起来会简单很多，但是我们的技术支持组给的答案却是做不到，需要我们的系统自己提供一套行之有效的数据库切换方案。经过研究我们提供这样一套办法：利用一个外部监视程序定时检测主数据库是否可用，这个状态检测程序一旦发现主数据库不可用，就通过一个简单内部通信协议发送一个消息包到我们的系统，我们的系统解析该消息包，做出相应的切换处理，并发送告警通知相关人员；当检测程序一旦发现主数据库可用了，发送另外一个消息包通知我们的系统数据库恢复了。我们的系统中有多个兄弟进程依赖数据库，每个进程都是单独与数据库建立session的，这样一旦需要切换数据库，我们这些可怜的进程就需要做同样的判断流程，可想而知代码中会存在多少的重复或相似的代码段，而且一旦流程修改我势必要修改多处，这样代码中的坏味道儿可就太浓了，势必应该进行重构，记得以前写过这么一篇'C语言也重构'，关于C语言重构的一些事项可以到那篇文章中查询。

灵光一闪！突然想到在Java组有数据库连接池的概念，我们可否效仿一下呢，我们也做一个这样的'数据库Session池'或者是一组抽象了的数据库session管理接口，这样对session的管理就集中起来了！session的管理接口负责判断是否需要切换和重新连接数据库，而这些切换操作对那些依赖数据库的进程来说是透明的。这样每个进程在每处理一条消息的时候都去调用一次open_session这样的接口，然后利用打开的session进行数据库操作即可。而open_session这个接口的实现也许要分两种情况：
1、在未切换数据库的情况下，使用原来已经存在的session即可，这里浪费的仅仅是一次条件判断而已；
2、在切换数据库的情况下，重新建立一个连到新数据库的session即可。

感觉这个方案可行，晚些儿时候再认真考虑一下，拿出一套可行方案。其实这里还要考虑这样一种情况也是可能性极其微小的情况，那就是两个数据库都宕了，这时候要考虑高可用性的话，那就该提供一些在没有数据库情况下的默认处理机制或者策略了。

33.00s和14.27s，两个截然不同的运行时间值，两次提交尝试解决素数回文问题，终于搞定了！用两个字形容’恼人’！算法不复杂，就是要求时间很’紧’，大部分工作都在考虑着如何缩短运行时间。桃花在冷空气袭来的日子都开了，我的心也算可以放下了！

最近项目吃紧，连续两天没有做ACM习题了，手都有些生了^_^！按照Volume1的习题顺序，该轮到1004题了！这是一道关于’素数回文(Prime Palindromes)’的习题，源自’USACO’，估计是什么比赛吧！大家一定都知道什么是素数，或者又叫质数！那么什么是回文(Palindromes)，不用定义，举几个例子大家就明白了，如121、1331、14741、89098等等看起来对称的数都叫做回文数，具体的定义或者数学上的定义我也没找到，好像对解决此题关系也不大！

Ok!我们来看一下题目，题目很简单，找出输入的两个数之间的所有素数回文，并按照数值顺序输出，每行一个数！要求：运行时间在15秒以内。输入值范围[5, 1000000000]。

如果不估计时间，大家脑中一定选中了’遍历’这种方案，而达到目标前所要解决的两个问题包括如何判断一个数是否是一个素数和如何判断一个数是否为一个回文数？

如何判断素数？这个在大学学习C语言的时候好像是习题，不过算法早已经忘到了’九霄云外’，这样自己就顺手写了一个宏：
#define IS_PRIMER(i) \
        ((i <= 10) \
         ? (i == 2 || i == 3 || i == 5 || i == 7) \
         : (((i % 2 == 0) || (i % 3 == 0) || (i % 5 == 0) || ( i % 7 == 0)) ? 0 : 1))
用几个数测了一下，屡试不爽！为了更加精确的测试，还是到网上找一个素数表吧！这样有参照的测试势必比较准确无误。试着用这个宏找出500以内的所有素数，发现与素数表中的个数不符，仔细查查，一眼就看到了121这个数，按照我的算法，它就是个’素数’了，但实际上它还能被11所整除，别忘了素数的定义："不能被1和自己之外的任何数整除"，看来我的算法是’漏洞百出’，不过在100之内它是有效的，起码算是个’Uncompleted Algorithm’^_^。重新修整一下，改进版如下：
int is_primer(int x) {
        int i;
        for (i = 2; i <= sqrt(x); ++i) {
                if (x % i == 0) {
                        return 0;
                }
        }
        return 1;
}
这种算法也是网上常见的算法，如果和外层的遍历一起来看，这是个接近O(n^2)的算法，显然性能不高！不过目前还少有好算法公布在网上，就暂用这个吧，我也想不出来什么好方法！也许需要好的数学功底才能提高该算法性能！

如何判断回文？这就是个’见仁见智’的问题了。这里提供两种方案，感觉性能上差不多，各有千秋：
[方案一]
/* 获取一个数i的位数n */
#define GET_DIGITS(n, i) do { \
                n = 1; \
                while (i >= pow(10, n)) { \
                        n++; \
                } \
        } while(0)

/*
 * 从外到内，比较每一个对称位上的数值是否相等
 * 如果全相等则是回文，否则不是。
 *
 * ! 这种方法还是很容易想出来的
 */
int is_palindrome(int x) {
        int     i = 0;
        int     j = 0;
        int     n = 0;

        int     high = 0;
        int     low = 0;

        GET_DIGITS(n, x);
        j = (n % 2) ? ((n-1) / 2) : (n / 2);

        for (i = 1; i <= j; ++i) {
                low = x % (int)(pow(10, i));
                high = x/(pow(10, n-i));
                if (low != high) {
                        return 0;
                }
        }
        return 1;
}

[方案二]
/*
 * ‘回文数’再造
 * 从低位到高位，按’低位 * 10 + 高位’累加的方式得到一个数
 * 如果该最终数值与原数一致，则为回文数，否则不是
 *
 * 这个方法对后面的方法还是很有启发的！
 */
int is_palindrome(int x) {
        int     rv = 0;
        int     i = x;

        while (i != 0) {
                rv = rv * 10 + i % 10;
                i = i / 10;
        }

        return rv == x;
}

现在两个难题都解决了，我们只需要遍历加判断即可。那么是先判断素数还是先判断回文呢？看起来判断素数较浪费时间，那我们先判断回文吧！第一次提交代码，不出所料，运行时间33s(我想不止33s，也许33s只是服务器的一个时间上限，大于该时间的统一显示为33s)。看来我们的重新考量一下我们的方案了！这种遍历+判断的方法无论如何是不能够蒙混过关的了^_^。

那么怎么来做呢？方案一是拿来一个数，我们来判断是否是回文，这样绝大部分的数都不是回文数，那么这些判断也都是无效的，但却占用了大量的时间，我们能不能尽量让我们每步操作都是生成结果之路上有效的一步呢？我们来尝试自己生成一定范围内的回文数。回文数组成是有一定的规律可循的。现在我们可以将问题集中在’如何生成位数为n的所有回文数’上！我们举几个例子就能看得出来：
[例子]
6446 — 我们可以看成两个部分 — 高二位的64和低二位的46互为反序数，我们也可以理解为高二位的值随着低二位的变化而变化；
64546 — 我们可以看成三个部分 — 高二位的64和低二位的46互为反序数，再加上中间的一个独立变化的值，我们也可以理解为高二位的值随着低二位的变化而变化；中间值独立变化；

可以看出我们的算法可以将处理分为两类：奇数和偶数。
1、如何生成位数为偶数位的所有回文数？
算法名称：gen_even_palindrome
输入项：n (回文数的位数)
算法步骤：
gen_even_palindrome(n) {
 j = n/2; /* j为独立变化的低位部分的位数 */
 k = (10^j – 1); /* k为独立变化的低位部分的上限值 */
 for (i = 1; i <= k; ++i) {
     /*
      * 这里的i就是低位部分独立变化的值
      */
     if (i % 10) {
      /* 如果 i = 10、1000等这些10^n的数，它们是没有回文的 */
       continue;
     }

     rv = _gen_even_palindrome(i, n); /* rv就是一个n位回文数 */
 }
}

_gen_even_palindrome(x, n) {
        int i = x;
        int j = 1;
        int rv = 0;

 /*
  * 利用低位部分的信息，造出高位部分的数值
  */
        while (i != 0) {
                rv += ((i % 10) * pow(10, n-j));
                i = i / 10;
                j++;
        }

 /* 最后的回文数还要加上低位部分的数 */
        rv += x;
        return rv;
}

2、如何生成位数为奇数位的所有回文数？
算法名称：gen_odd_palindrome
输入项：n (回文数的位数) n > 1 对n = 1作特殊处理便是
算法步骤：
gen_odd_palindrome(n) {
 j = (n + 1)/2; /* j为独立变化的低位部分的位数 *
/
 k = (10^(j-1) – 1); /* k为独立变化的低位部分的上限值 */

 for (h = 0; h <= 9; ++h) { /* 中间位独立变化 */
  for (i = 1; i <= k; ++i) {
   /*
     * 这里的i就是低位部分独立变化的值
     */
   if (i % 10) {
    /* 如果 i = 10、1000等这些10^n的数，它们是没有回文的 */
    continue;
   }

   rv = _gen_odd_palindrome(i, h, n); /* rv就是一个n位回文数 */
  }
 }
}

_gen_odd_palindrome(x, mid, n) {
        int i = x;
        int j = 1;
        int rv = 0;

 /*
  * 利用低位部分的信息，造出高位部分的数值
  */
        while (i != 0) {
                rv += ((i % 10) * pow(10, n-j));
                i = i / 10;
                j++;
        }

 /* 最后的回文数还要加上中间数和低位部分的数 */
 rv += mid * pow(10, (n-1)/2);
        rv += x;
        return rv;
}

至此，我们算是解决了如何生成回文数的问题了，不过目前还有一点不能满足，那就是按照数值顺序来输出回文素数，不知道大家发现没有，上面的回文数生成算法不能保证按照数值顺序生成会文数，所以我们还要再动动脑筋！

这里不妨尝试一下作弊！^_^ 由于回文数生成算法不能保证按照数值顺序输出回文数，那么我们势必需要记下来已经生成的回文数，那么到底有多少回文素数需要记下来呢？我们可以利用前面提到过的’遍历’方案在本地计算一下，结果是不到10000个，那么OK！我们就分配一个大数组，并用一个static global variable记下当前数组使用情况，待所有的回文素数都写入数组，我们对该数组进行一次quick sort，这又需要有个quick sort算法(O(nlogn)级别的，简单快速是我选它的原因)，不过这个比较容易，这里也不详述了。

把这个’回文生成’解决方案提交后，得出14.27s的结果，状态: Accepted。对了千万别忘了，这里还加了些优化，比如不存在位数为6的素数回文，所以当判断n = 6就直接返回，省着走冤枉路！14.27s属于刚及格范畴！该题肯定还有更快的解法，由于太烦，这里就浅尝辄止了！^_^