作为一个QA，我本来是很少写代码的，不过这段代码用的次数比较多，每次用的时候都改一些，比较烦，所以整理了一个通用的，作为个人代码库的第一块石头吧
升级于2010-7-26，修复bug

class sql_runner{

	private static $_arr_self = array();

	private $_addr = false;
	private $_user = false;
	private $_passwd = false;
	private $_db_connection = false;

	static function get_instance($addr, $user, $passwd){
		$key = $addr.'#'.$user.'#'.$passwd;
		if(false === array_key_exists($key, self::$_arr_self)){
			sql_runner::$_arr_self[$key] = new sql_runner($addr, $user, $passwd);
		}

		return sql_runner::$_arr_self[$key];
	}

	private function __construct($addr, $user, $passwd){
		$this->_addr = $addr;
		$this->_user = $user;
		$this->_passwd = $passwd;
	}

	public function run_sql($sql){

		if(false === $this->_db_connection || !mysql_ping($this->_db_connection)){
			UB_LOG_DEBUG("connecting db $this->_addr, $this->_user");
			$this->_db_connection = mysql_connect($this->_addr, $this->_user, $this->_passwd);

			if(false === $this->_db_connection){
				UB_LOG_FATAL("connect db failed: ".mysql_error());
				return false;
			}else{
				mysql_set_charset('latin1;', $this->_db_connection);
			}
		}

		$result = false;
		$result = mysql_query($sql, $this->_db_connection);
		if(false === $result){
			UB_LOG_FATAL("[$sql] execute failed:". mysql_error($this->_db_connection)."\n");
			return false;
		}

		$result_arr = array();
		if(is_resource($result)){
			while($row = mysql_fetch_assoc($result)){
				$result_arr[] = $row;
			}
			mysql_free_result($result);
		}

		UB_LOG_DEBUG("[$sql] execute succed, selected result:".print_r($result_arr, true));
		return $result_arr;
	}

}

/**for log functions*/
if(!function_exists('UB_LOG_DEBUG')){
	function UB_LOG_DEBUG($log){
		print($log);
	}
}
if(!function_exists('UB_LOG_FATAL')){
	function UB_LOG_FATAL($log){
		print($log);
	}
}

您可能会喜欢:

1. php中getopt的缺陷及修复
2. php反射效果:基类访问子类数据
3. 利用语言的动态特性减少switch

我看网上应该有不少搜索这个区别的问题，但是回答的都不全面，其中sigterm与sigint尤其有一点区别比较重要，但大都没有提及，今天我就遇到了这个问题，纠结了20分钟才搞明白咋回事。

首先，对于说这几个信号都是终止程序运行的说法不太准确，因为程序收到信号后，如果不对信号处理，就会导致程序退出，但如果程序捕获信号进行处理，按照它的逻辑，它是不一定会退出的。

在这三个信号中，sigkill是不能被捕获的，程序收到这个信号后，一定会退出。这就是kill -9一定能保证将程序杀死的原因。

下面说一下sigterm与sigint的区别，其中有一点区别区别很多文章都没有提及，也是我写这篇blog的原因（如果人家都写了，我就不用写了呗）

下面这两个代码片段就能够验证这种情况(注意使用pcntl的时候，一定要declare ticks，要不然会杯具的发现函数没有被调用，进程不退出，信号发过去没有作用。php手册竟然没有强调这一点)：

文件：loadhelper.php

#为了pcntl能够截获信号
declare(ticks = 1);

$arr_processes = array();

function terminate($signo){
    echo "aaaaaaaaaaa\n";
}

pcntl_signal(SIGTERM, "terminate", true);
pcntl_signal(SIGINT, "terminate", true);

foreach($argv as $key => $operation){

    if(0 === $key){
        continue;
    }   

    $pipes = array();
    $process = proc_open($operation, array(), &$pipes);
    if(false === $process){
        exit(-1);
    }
    $arr_processes[] = $process;
}

while(true){
    sleep(100);
}

文件：child.php

declare(ticks=1);

pcntl_signal(SIGINT, "terminate");
pcntl_signal(SIGTERM, "terminate");

function terminate($signo){
    echo "test_child\n";
}

while(true){
    sleep(100);
}

使用命令php loadhelper.php “php test.php”可以启动这个测试。
1.输入ctrl+c发送sigint可以看到，父进程与子进程的terminate都得到了执行，都有输出，但父进程不会退出，因为子进程还没有退出
2.通过kill向父进程的pid发送sigterm，可以看到，只有父进程输出

遗留问题：

父进程（loadhelper）接受到一次信号后，如果在terminate函数中调用exit，它还是不能退出的，因为还有子进程没有退出。但是从此以后它就不能再接收信号了（子进程还是能够接收到sigint），可能是exit使进程进入了待回收状态，具体还 需要后续在分析一把。

您可能会喜欢:

1. sql运行简单封装
2. php中getopt的缺陷及修复
3. 文件grep-选出两个文件中相同/不同的内容

在这里，我不得不再一次感叹php语言库函数的山寨与不专业。getopt函数就是一个典型的例子，通常用的时候，大家可能觉得没有什么，但在某些情况 下，就真的让人很囧。一个简单的函数，稍微多花几分钟就弄得更好一些了，但这个语言有个随意的开端，就有个随意的实现啊。

在linux中，使用getopt时候，有两种情况：

1.取得的参数解析成字符串：“php test_arg.php -c abc”，这种情况c参数取得的结果就是abc这个字符串

2.取得的参数解析成数组：“php test_arg.php -c abc -c abc123”，这种情况c参数取得的结果就是包含abc与abc123的数组

但是遇到这种情况呢：“php test_arg.php -c abc*”？由于linux的shell已经帮程序做了输入参数的解析，这时候c参数得到的既不是abc*这个结果也不是一个数组，而是被shell展开成了很多文件名后的第一个。

可能getopt用的童鞋很少，但这种山寨的设计，实在太让人憋屈了，自己花个10分钟写一个就比它的要好，为了避免大家重复劳动，分享一个代码片段

   function mygetopt(){
        global $argv;
        $result = array();

        $current_key = false;
        foreach($argv as $opt){

            $matches = array();
            if(1 === preg_match("/^-{1,2}(.*)$/", $opt, $matches)){
                $current_key = $matches[1];

                if(false === isset($result[$current_key])){
                    $result[$current_key] = false;
                }
            }else if (false !== $current_key){

                if(false === $result[$current_key]){
                    $result[$current_key] = $opt;
                }else{
                    if(false === is_array($result[$current_key])){
                        $result[$current_key] = array($result[$current_key]);
                    }
                    $result[$current_key][] = $opt;
                }
            }
        }   

        return $result;
    }

为了方便使用，将新版本的getopt函数设置为不接受任何参数，但是解析的结果可以输出所有的参数内容。因为php官方的getopt函数使用后，也无非是对输出的数组进行foreach之后进行switch，还不如方便点，直接解析所有呢。除了这一点，这个getopt函数的输出结果与php官方的完全一致

php官方getopt函数参考文档：http://cn.php.net/manual/en/function.getopt.php

您可能会喜欢:

1. php反射效果:基类访问子类数据
2. sql运行简单封装
3. sigterm sigint sigkill 区别

php中，使用&表明这个引用是指针，这样在两个引用可以指向同一个内存空间。但其实不使用&的情况下，php也是写时拷贝的，zend引擎只有在修改的时候才会发生内存拷贝，不修改的话是不会产生消耗的。在实际使用中，我还发现使用&符号反而性能会降低。

在不需要修改的情况下，建议尽量不要使用&符号，否则不仅降低效率，还有可能造成出现bug。今天查看最近对测试框架的升级，就踩上了simpletest上面的一个bug，请看simpletest中，想testsuit加上case的函数：

function addTestCase(&$test_case) {
     $this->_test_cases[] = &$test_case;
}

这么简单的函数，我想大家一般都会认为没有问题吧，正常情况下它都能很好的工作，但是如果你这样用，就bug了：

foreach($arr_cases as $case){
     $this->test_suit->addTestCaseOpenTest($case);
}

你会发现_test_cases这个数组里面，只哟foreach最终的那个元素，因为函数都是接受的值引用，foreach改变$case的值，就把已经传入_test_cases数组的内容都给改写了，于是就悲剧了。对于simpletest来说，它并不需要修改用户的case程序，这样做值引用显然是多此一举，还产生了bug。

关于性能降低，用一个简单的代码测试一下就知道了

$a = array('a','c','n'); 

function printArray(&$arr)
{
    print(count($arr));
}

for($i=0;$i<100000;$i++){
    printArray($a);
}

用time命令跑一次，把printArray的&符号去掉再跑一次，可以看到大致下面的结果（机器不同，结果不同啊）

可见使用&反而会使性能下降的，所以除非有必要，不建议使用&符号

您可能会喜欢:

1. sql运行简单封装
2. php中getopt的缺陷及修复
3. php反射效果:基类访问子类数据

今天早茶的topic。介绍了paxos算法与zookeeper相关的内容，可以解决单点问题觉得还挺实用的。这个算法由三个不同类型的实体，通过投票的方式决策出一个值传播到网络中，实现分布式数据的统一，使各个节点不会各自为政。

paxos是一种比较主流的算法，google与微软的集群都用这个，具体参与进来的有三个实体：

1.提议者：提议者发起新的提议，比如设置某个值。每个提议都有个编号。提议者根据参与者的反馈，多数参与者赞同的提议就获得通过。

2.参与者：参与者对提议者的提议进行投票，将投票结果反馈给提议者。当有多个提议时，参与者倾向于接受编号大的提议。例如已经接受编号n的，此时收到了编号为n-1的提议，就会拒绝

3.接受者：接受提议者与参与者的决策（获得投票通过的提议）。

一个典型的也是最简单的流程：

 Client   Proposer      Acceptor     Learner
   |         |          |  |  |       |  |
   X-------->|          |  |  |       |  |  Request
   |         X--------->|->|->|       |  |  Prepare(N)
   |         |<---------X--X--X       |  |  Promise(N,{Va,Vb,Vc})
   |         X--------->|->|->|       |  |  Accept!(N,Vn)
   |         |<---------X--X--X------>|->|  Accepted(N,Vn)
   |<---------------------------------X--X  Response
   |         |          |  |  |       |  |

如图，为了简单理解，可以认为proposer与acceptor是相同功能server构成的一个集群，client可以认为是一个外部的用户，发送一个请求到集群后，集群中的一个server扮演提议者角色发起一个提议，后面的三个accepto进行投票，投票反馈给提议者后发现获得通过，acceptor将信息扩散给接受者。这样整个集群中就针对这个提议达成了一致。

根据这个算法，接受者收到的信息是顺序的，不会产生乱序的问题。所以对于需要序列化的服务，就可以使用这种方式将单点整成多点，避免运维风险。

还有一些更复杂情况以及一个极端情况请见参考资料吧，另外：

1.集群中有多少个节点，首先就是各个节点就是要知道的。集群中要想增加一个新的节点比较麻烦

2.当集群中有效的节点数是少数时，算法会失效

zookeeper是用来协调分布式应用的，用于维护资源信息，它的关键算法就是用的paxos来做的。当然，在其上也有一些更复杂的内容。提供服务的节点作为client链接到zookeeper上面，与zookeeper保持心跳。当client宕机，zookeeper中的一个服务节点发现后就会通过投票流程来判定这个client挂掉了，其它依赖于这个client的服务作为算法中的接受者，收到挂掉的信息后，将依赖改到其它的client上面去。当然，也存在client断开zookeeper中的一个节点后连到zookeeper的另外一个节点，但因为算法保证了发送给client断开与联通消息的顺序，也是可以满足需求的。

在我看来，zookeeper的最大作用是使资源配置服务器本身从单点变为多点，避免了单点运维的问题。对于paxos算法还是很不错的，对于需要将系统中需要将命令序列化，而又希望避免服务单点是一个非常有效的方法。

参考资料：
1.Paxos algorithm
2.zookeeper

您可能会喜欢:

1. mysql学习笔记-1
2. apple商店模式？
3. 我对自动化测试框架的愿景

以前也曾写过这样的代码，但没有特殊注意过，今天大家讨论收银台的问题时候，再提起这样的设计，却感觉非常有效。

因为分支很多，使用switch-case几乎是不可避免的，而这对与代码的维护与理解却不是一件很好的事情，在增加分支的时候，也是一种比较郁闷的事情。利用语言的动态特性与模块化的设计，可以在一定程度上减轻这种问题。

class A{};
class B{};

$arr_actions = array(
    'a' => 'A',
    'b' => 'B',
);

function do_action_no_switch($action){

    global $arr_actions;

    if(!array_key_exists($action, $arr_actions)){
        return false;
    }   

    $job = new $arr_actions[$action];

    //job->do...
}

do_action_no_switch('a');

您可能会喜欢:

1. 更换域名为www.mirecle.com
2. 成都九寨归来
3. 地震

今天看到大家在讨论，发现这是个很严重而又容易疏忽的问题，我以前也一直是用set names，遂记录下来，也提醒自己一把。

1.set names与mysql_set_charset有什么区别？

一般情况下, 使用”SET NAMES”就足够了, 也是可以保证正确的. 那么为什么手册又要说推荐使用 mysqli_set_charset(PHP>=5.0.5)呢。手册里面也没有明确说明。我们可以看下php扩展的源代码：

//php-5.2.11-SRC/ext/mysqli/mysqli_nonapi.c line 342
PHP_FUNCTION(mysqli_set_charset)
{
    MY_MYSQL            *mysql;
    zval                *mysql_link;
    char                *cs_name = NULL;
    unsigned int        len;
    if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis()
                , "Os", &mysql_link, mysqli_link_class_entry, &cs_name, &len) == FAILURE) {
        return;
    }
    MYSQLI_FETCH_RESOURCE(mysql, MY_MYSQL*, &mysql_link, "mysqli_link", MYSQLI_STATUS_VALID);
    if (mysql_set_character_set(mysql->mysql, cs_name)) {
                //** 调用libmysql的对应函数
        RETURN_FALSE;
    }
    RETURN_TRUE;
}

可以看到php的mysql扩展是直接调用了mysql的mysql_set_character_set函数，接下来看看mysql的代码

//mysql-5.1.30-SRC/libmysql/client.c, line 3166:
int STDCALL mysql_set_character_set(MYSQL *mysql, const char *cs_name)
{
  struct charset_info_st *cs;
  const char *save_csdir= charsets_dir;
  if (mysql->options.charset_dir)
    charsets_dir= mysql->options.charset_dir;
  if (strlen(cs_name) < MY_CS_NAME_SIZE &&
     (cs= get_charset_by_csname(cs_name, MY_CS_PRIMARY, MYF(0))))
  {
    char buff[MY_CS_NAME_SIZE + 10];
    charsets_dir= save_csdir;
    /* Skip execution of "SET NAMES" for pre-4.1 servers */
    if (mysql_get_server_version(mysql) < 40100)       return 0;     sprintf(buff, "SET NAMES %s", cs_name);     if (!mysql_real_query(mysql, buff, strlen(buff)))     {       mysql->charset= cs;
    }
  }
  //以下省略

可以看到，除了调用real_query设置set names，还设置了mysql的charset变量。

2.这样有什么影响？

mysql_real_escape_string会受到影响，它与mysql_escape_string的区别就 是,  它会考虑”当前”字符集。如果仅仅使用set names，mysql_real_escape_string可能会失效。

例子：

$mysqli = new mysqli("localhost", "user", "pass", "test", 3306);

/* check connection */
if (mysqli_connect_errno()) {
    printf("Connect failed: %s\n", mysqli_connect_error());
    exit();
}

$mysqli->query('SET NAMES gbk'); //使用set names设置字符集
$city = chr(0xbf).chr(0x5c); //0xbf5c是个有效的gbk字符，模拟用户输入
$city = $mysqli->real_escape_string ($city);//使用real_escape进行过滤

/* this query will fail, cause we didn't escape $city */
 if (!$mysqli->query("INSERT into myCity(name) VALUES ('$city')")) {
    print "INSERT into myCity (name) VALUES ('$city')\n";
    printf("Error: %s\n", $mysqli->error);
}

var_dump($city);

var_dump($mysqli->client_encoding());

$mysqli->close();

3.解决方案

mysqli_set_charset函数对PHP和Mysql有版本要求，必须当mysql版本大于5，PHP版本大于5.0.5时，此函数才有效。至于另一个mysql_set_charset函数，则更要求PHP版本大于5.2.3时才能有效。对于mysql4.1以上版本，使用”SET character_set_client=binary;”
推荐使用mysql_set_charset设置字符集的方案，只有在环境不允许的情况下，我们才推荐使用第二种binary编码的方案。但是无论在什么情况下，都禁止使用”SET NAMES”来作为设置字符集的操作。

您可能会喜欢:

1. php反射效果:基类访问子类数据
2. php中getopt的缺陷及修复
3. php中&符号的滥用与它引发的bug

升级于2010-6-10，发现了一个bug，当时用notmatch模式时，如果文件2先eof将导致文件1中的内容没有输出

这个是最近做数据统计用的比较多的一个脚本，目的是根据key值，输出文件中相同或者不同的行。例如文件A的样子：

10000007^H_O
10000036^Hzerui
10000037^Hyanpeng_haha

文件B的样子：

10000037^Hyanpeng_haha

注意文件中的^H是一个字符，在vim中使用输入ctrl+v再输入ctrl+h就可以看到了，这里用它主要是起到文件不同列之间的分隔符作用

使用命令

php mygrep.php A B

可以得到“10000037^Hyanpeng_haha”这一行数据，使用命令

php mygrep.php A B “notmatch”

可以得到另外两行数据。

脚本默认使用第零列作为筛选依据，默认使用^H作为分隔符，在脚本中自己配置一下可以更改。脚本工作时，要求筛选依据是已排序的。对于排序，可以使用sort命令操作文件，sort通过-t参数指定分隔符，-f指定按照那一列进行排序。

mygrep.php的代码:

$base_file_name    = $argv[1];
$check_file_name   = $argv[2];
$mode              = isset($argv[3])?$argv[3]:false;

$field_index = 0;
$delimiter = ',';

//////////////////////////////////////////////////////////////
$base_file = @fopen($base_file_name, 'r');
$check_file = @fopen($check_file_name, 'r');
$read_base_file = true;
$compare_result = 0;
$readed_base_file_arr = array();

//以要检查的文件作为外层循环
while(!feof($check_file)){
    //读取要检查的文件
    $readed_check_arr = explode($delimiter, trim(fgets($check_file)));
    do{
        //读取基准文件
        if($read_base_file === true){
            $readed_base_arr = explode($delimiter, trim(fgets($base_file)));
        }   

        //作比较
        $compare_result = strcmp($readed_check_arr[$field_index], $readed_base_arr[$field_index]);
        $grep_flag = ($compare_result == 0);
        //如果是要取出不相等的数据
        //且检查key小于或等于基准key时，说明需要将检查key下移一行,即此比较key已经比较完成
        //此时如果比较结果相等则不输出,
        //如果比较结果不等，并且检查key大于基准key则输出,如果检查结果小于基准key，说明检查key要下移继续检查
        if($mode !== false && (strcmp($mode, "notmatch") == 0)
            && $compare_result >= 0){
            $grep_flag = !$grep_flag;
        }

        //print("comparing check=".$readed_check_arr[$field_index]." base=".$readed_base_arr[$field_index]." result=$compare_result
grep_flag=$grep_flag\n");

        if($grep_flag){
            print implode($delimiter, $readed_base_arr)."\n";
        }

        //总是设置为要读取，如果跳出循环，则由外面设置
        $read_base_file = true;

    //如果检查的key是大于基准的key，并且检查文件未到尾，则重新读取一行基准文件进行检查
    }while($compare_result > 0 && !feof($base_file));

    if(feof($base_file)){
        break;
    }

    //当检查key小于基准key时，不读取下个基准key,等于则是因为已经比较过，两个都需要读取
    if($compare_result < 0){
        $read_base_file = false;
    }
}

//当check_file结束了但是base_file未结束
do{
    print implode($delimiter, $readed_base_arr)."\n";
    $readed_base_arr = explode($delimiter, trim(fgets($base_file)));
}while(!feof($base_file));

fclose($check_file);
fclose($base_file);

您可能会喜欢:

1. sigterm sigint sigkill 区别
2. php中getopt的缺陷及修复
3. sql运行简单封装

有的时候，由于我们队Java api理解上面的错误，可能会导致出现一些意外的问题，比如内存泄露。认为虚拟机会为你创建一个新的对象，引用了不同的内存区域，结果却和想象中的不一样，导致服务宕机。

今天在查网关的内存溢出问题时，发现问题出现在String.split函数上面。大家都认为Java中的String是只读的，new新对象的时候一定是分配了新的内存，但虚拟机内部却不一定如此。sun的hotspot1.5版本在实现java的类时做了优化，为了减少内存拷贝，一个String对象可能会引用另外一个String对象的内存。查看jdk的源代码可知，String内部是用一个名为value的char数组存储内容的，但同时另外也有两个int类型的变量：offset与count。

查看String.split()函数的源代码，随后调用的是Pattern.split()，随后调用String.subSequence()，随后调用String.substring()。String的substring代码如下

public String substring(int beginIndex, int endIndex) {
if (beginIndex < 0) {
throw new StringIndexOutOfBoundsException(beginIndex);
}
if (endIndex > count) {
throw new StringIndexOutOfBoundsException(endIndex);
}
if (beginIndex > endIndex) {
throw new StringIndexOutOfBoundsException(endIndex - beginIndex);
}
return ((beginIndex == 0) && (endIndex == count)) ? this :
new String(offset + beginIndex, endIndex - beginIndex, value);
}

如果看到最后return的是new String，以为就是一个新的String就真的囧了，这不是一个向外开放的构造函数，它创建了一个新的对象，却是用的原来String对象中的内存

// Package private constructor which shares value array for speed.
String(int offset, int count, char value[]) {
this.value = value;
this.offset = offset;
this.count = count;
}

本来这样进行优化无可厚非，但在网关的应用情况下就出现问题了：
一次性查询得到一个String，里面记载了1000条数据结果，将这1000条数据结果拆分，封装成1000个对象，存在缓存里面。缓存是用LinkedHashMap，当Entry达到一定数量时就进行淘汰。这样就导致这1000个对象都淘汰了，才会释放存储了1000个数据的String，这个String可是相当的大啊。
又因为查询的时间段是有重叠的，导致每次查询的String都记载了很多重复的内容，虽然缓存里面只对String不同的地方保持了一次引用，但是却无意间存储了大量的无用数据。这就导致了jvm的内存溢出。

好多年没搞java了，结合以前上学时候查java内存泄露的一点经验，说明了：

1.出现内存泄露，通常都是有容器保持了大量的引用，查问题的时候，可以从容器优先开始

2.查看jdk的源代码，是很有必要的。

您可能会喜欢:

1. 关于数钱费

以前写的一个小脚本，用在linux的shell批量修改大量文件名的情况下。昨天不小心删除了大量文件，找回的时候，又一次用到了它，在遇到大批量文件的时候，还是挺有效果的，共享一下。

用法：

1.将你要改名的文件都放在同一个文件夹下，运行”ls -l > oldnames”，然后“vi oldnames”，这时候看到的大概是这个样子：

total 1224
drwxrwxr-x   3 yanpeng yanpeng    4096 Sep 17 16:13 app
drwxrwxr-x   2 yanpeng yanpeng    4096 May 19  2009 bin
drwxrwxr-x   2 yanpeng yanpeng    8192 Jan 26 16:40 docpay

2.输入”ctrl+v”，移动光标，选中要删除的那一堆内容，其实就是文件名前面的那些列，输入“d”，得到的文件大概为

app
bin
docpay

3.删除掉第一行的空行，保存退出vi，然后”cp oldnames newnames”。

4.修改newnames文件中想要改名的文件为新文件名

5.将change_name.sh脚本放在你的那个放置文件的夹下，运行./change_name.sh就可以了(注意有执行权限，加执行权限的方法chmod a+x change_name.sh)

change_name.sh脚本内容，拷贝下，存好就能用了

#!/bin/sh

OLDNAMES='oldnames'
NEWNAMES='newnames'

fileline=`sed -n '$=' $OLDNAMES`
echo $fileline

index=1
while [ $index -le $fileline ]
do
oldname=`sed -n "${index}p" $OLDNAMES`
newname=`sed -n "${index}p" $NEWNAMES`
mv $oldname $newname
index=`expr $index + 1`
done

您可能会喜欢:

1. 分层次管理tag文件