PHP单例模式编写的PDO类的程序
用php大部分操作都是和各种数据库打交道，包括mysql,redis,memcache等各种关系型和非关系型数据库，所以一个应用中会 存在大量连接数据库的操作，如果不用单例模式，那每次都要new操作，但是每次new都会消耗大量的内存资源和系统资源，而且每次打开和关闭数据库连接都 是对数据库的一种极大考验和浪费
代码如下：
<?php
class MyPDO
{
protected static $_instance = null;
protected $dbName = '';
protected $dsn;
protected $dbh;
/**
* 构造
*
* @return MyPDO
*/
private function __construct($dbHost, $dbUser, $dbPasswd, $dbName, $dbCharset)
{
try {
$this->dsn = 'mysql:host='.$dbHost.';dbname='.$dbName;
$this->dbh = new PDO($this->dsn, $dbUser, $dbPasswd);
$this->dbh->exec('SET character_set_connection='.$dbCharset.', character_set_results='.$dbCharset.', character_set_client=binary');
} catch (PDOException $e) {
$this->outputError($e->getMessage());
}
}
/**
* 防止克隆
*
*/
private function __clone() {}
/**
* Singleton instance
*
* @return Object
*/
public static function getInstance($dbHost, $dbUser, $dbPasswd, $dbName, $dbCharset)
{
if (self::$_instance === null) {
self::$_instance = new self($dbHost, $dbUser, $dbPasswd, $dbName, $dbCharset);
}
return self::$_instance;
}
/**
* Query 查询
*
* @param String $strSql SQL语句
* @param String $queryMode 查询方式(All or Row)
* @param Boolean $debug
* @return Array
*/
public function query($strSql, $queryMode = 'All', $debug = false)
{
if ($debug === true) $this->debug($strSql);
$recordset = $this->dbh->query($strSql);
$this->getPDOError();
if ($recordset) {
$recordset->setFetchMode(PDO::FETCH_ASSOC);
if ($queryMode == 'All') {
$result = $recordset->fetchAll();
} elseif ($queryMode == 'Row') {
$result = $recordset->fetch();
}
} else {
$result = null;
}
return $result;
}
/**
* Update 更新
*
* @param String $table 表名
* @param Array $arrayDataValue 字段与值
* @param String $where 条件
* @param Boolean $debug
* @return Int
*/
public function update($table, $arrayDataValue, $where = '', $debug = false)
{
$this->checkFields($table, $arrayDataValue);
if ($where) {
$strSql = '';
foreach ($arrayDataValue as $key => $value) {
$strSql .= ", `$key`='$value'";
}
$strSql = substr($strSql, 1);
$strSql = "UPDATE `$table` SET $strSql WHERE $where";
} else {
$strSql = "REPLACE INTO `$table` (`".implode('`,`', array_keys($arrayDataValue))."`) VALUES ('".implode("','", $arrayDataValue)."')";
}
if ($debug === true) $this->debug($strSql);
$result = $this->dbh->exec($strSql);
$this->getPDOError();
return $result;
}
/**
* Insert 插入
*
* @param String $table 表名
* @param Array $arrayDataValue 字段与值
* @param Boolean $debug
* @return Int
*/
public function insert($table, $arrayDataValue, $debug = false)
{
$this->checkFields($table, $arrayDataValue);
$strSql = "INSERT INTO `$table` (`".implode('`,`', array_keys($arrayDataValue))."`) VALUES ('".implode("','", $arrayDataValue)."')";
if ($debug === true) $this->debug($strSql);
$result = $this->dbh->exec($strSql);
$this->getPDOError();
return $result;
}
/**
* Replace 覆盖方式插入
*
* @param String $table 表名
* @param Array $arrayDataValue 字段与值
* @param Boolean $debug
* @return Int
*/
public function replace($table, $arrayDataValue, $debug = false)
{
$this->checkFields($table, $arrayDataValue);
$strSql = "REPLACE INTO `$table`(`".implode('`,`', array_keys($arrayDataValue))."`) VALUES ('".implode("','", $arrayDataValue)."')";
if ($debug === true) $this->debug($strSql);
$result = $this->dbh->exec($strSql);
$this->getPDOError();
return $result;
}
/**
* Delete 删除
*
* @param String $table 表名
* @param String $where 条件
* @param Boolean $debug
* @return Int
*/
public function delete($table, $where = '', $debug = false)
{
if ($where == '') {
$this->outputError("'WHERE' is Null");
} else {
$strSql = "DELETE FROM `$table` WHERE $where";
if ($debug === true) $this->debug($strSql);
$result = $this->dbh->exec($strSql);
$this->getPDOError();
return $result;
}
}
/**
* execSql 执行SQL语句
*
* @param String $strSql
* @param Boolean $debug
* @return Int
*/
public function execSql($strSql, $debug = false)
{
if ($debug === true) $this->debug($strSql);
$result = $this->dbh->exec($strSql);
$this->getPDOError();
return $result;
}
/**
* 获取字段最大值
*
* @param string $table 表名
* @param string $field_name 字段名
* @param string $where 条件
*/
public function getMaxValue($table, $field_name, $where = '', $debug = false)
{
$strSql = "SELECT MAX(".$field_name.") AS MAX_VALUE FROM $table";
if ($where != '') $strSql .= " WHERE $where";
if ($debug === true) $this->debug($strSql);
$arrTemp = $this->query($strSql, 'Row');
$maxValue = $arrTemp["MAX_VALUE"];
if ($maxValue == "" || $maxValue == null) {
$maxValue = 0;
}
return $maxValue;
}
/**
* 获取指定列的数量
*
* @param string $table
* @param string $field_name
* @param string $where
* @param bool $debug
* @return int
*/
public function getCount($table, $field_name, $where = '', $debug = false)
{
$strSql = "SELECT COUNT($field_name) AS NUM FROM $table";
if ($where != '') $strSql .= " WHERE $where";
if ($debug === true) $this->debug($strSql);
$arrTemp = $this->query($strSql, 'Row');
return $arrTemp['NUM'];
}
/**
* 获取表引擎
*
* @param String $dbName 库名
* @param String $tableName 表名
* @param Boolean $debug
* @return String
*/
public function getTableEngine($dbName, $tableName)
{
$strSql = "SHOW TABLE STATUS FROM $dbName WHERE Name='".$tableName."'";
$arrayTableInfo = $this->query($strSql);
$this->getPDOError();
return $arrayTableInfo[0]['Engine'];
}
/**
* beginTransaction 事务开始
*/
private function beginTransaction()
{
$this->dbh->beginTransaction();
}
/**
* commit 事务提交
*/
private function commit()
{
$this->dbh->commit();
}
/**
* rollback 事务回滚
*/
private function rollback()
{
$this->dbh->rollback();
}
/**
* transaction 通过事务处理多条SQL语句
* 调用前需通过getTableEngine判断表引擎是否支持事务
*
* @param array $arraySql
* @return Boolean
*/
public function execTransaction($arraySql)
{
$retval = 1;
$this->beginTransaction();
foreach ($arraySql as $strSql) {
if ($this->execSql($strSql) == 0) $retval = 0;
}
if ($retval == 0) {
$this->rollback();
return false;
} else {
$this->commit();
return true;
}
}
/**
* checkFields 检查指定字段是否在指定数据表中存在
*
* @param String $table
* @param array $arrayField
*/
private function checkFields($table, $arrayFields)
{
$fields = $this->getFields($table);
foreach ($arrayFields as $key => $value) {
if (!in_array($key, $fields)) {
$this->outputError("Unknown column `$key` in field list.");
}
}
}
/**
* getFields 获取指定数据表中的全部字段名
*
* @param String $table 表名
* @return array
*/
private function getFields($table)
{
$fields = array();
$recordset = $this->dbh->query("SHOW COLUMNS FROM $table");
$this->getPDOError();
$recordset->setFetchMode(PDO::FETCH_ASSOC);
$result = $recordset->fetchAll();
foreach ($result as $rows) {
$fields[] = $rows['Field'];
}
return $fields;
}
/**
* getPDOError 捕获PDO错误信息
*/
private function getPDOError()
{
if ($this->dbh->errorCode() != '00000') {
$arrayError = $this->dbh->errorInfo();
$this->outputError($arrayError[2]);
}
}
/**
* debug
*
* @param mixed $debuginfo
*/
private function debug($debuginfo)
{
var_dump($debuginfo);
exit();
}
/**
* 输出错误信息
*
* @param String $strErrMsg
*/
private function outputError($strErrMsg)
{
throw new Exception('MySQL Error: '.$strErrMsg);
}
/**
* destruct 关闭数据库连接
*/
public function destruct()
{
$this->dbh = null;
}
}
?>
调用方法：
PHP
<?php
require 'MyPDO.class.php';
$db = MyPDO::getInstance('localhost', 'root', '123456', 'test', 'utf8');
//do something...
$db->destruct();
?>
最近一直在微信群里体验红包功能，红包类型有
•普通红包
•拼手气红包两种
普通红包就不用多解析了，大锅饭原理，平分。
拼手气红包讲的是手气（运气），有人可以抢到很多，有人抢的少得可怜，当然也不是先抢就一定多，说到底了就是随机。
想了想，自己写写看，能不能实现类似的功能（不敢说是算法）。
// $bonus_total 红包总金额
// $bonus_count 红包个数
// $bonus_type 红包类型 1=拼手气红包 0=普通红包
function randBonus($bonus_total=0, $bonus_count=3, $bonus_type=1){
$bonus_items = array(); // 将要瓜分的结果
$bonus_balance = $bonus_total; // 每次分完之后的余额
$bonus_avg = number_format($bonus_total/$bonus_count, 2); // 平均每个红包多少钱
$i = 0;
while($i<$bonus_count){
if($i<$bonus_count-1){
$rand = $bonus_type?(rand(1, $bonus_balance*100-1)/100):$bonus_avg; // 根据红包类型计算当前红包的金额
$bonus_items[] = $rand;
$bonus_balance -= $rand;
}else{
$bonus_items[] = $bonus_balance; // 最后一个红包直接承包最后所有的金额，保证发出的总金额正确
}
$i++;
}
return $bonus_items;
}
好吧，我们现在来体验一下
// 发3个拼手气红包，总金额是100元
$bonus_items = randBonus(100, 3, 1);
// 查看生成的红包
var_dump($bonus_items);
// 校验总金额是不是正确，看看微信有没有坑我们的钱
var_dump(array_sum($bonus_items));
另一个使用数组实现的版本，原理差不多：
function sendRandBonus($total=0, $count=3, $type=1){
if($type==1){
$input = range(0.01, $total, 0.01);
if($count>1){
$rand_keys = (array) array_rand($input, $count-1);
$last = 0;
foreach($rand_keys as $i=>$key){
$current = $input[$key]-$last;
$items[] = $current;
$last = $input[$key];
}
}
$items[] = $total-array_sum($items);
}else{
$avg = number_format($total/$count, 2);
$i = 0;
while($i<$count){
$items[] = $i<$count-1?$avg:($total-array_sum($items));
$i++;
}
}
return $items;
}
在开发过程中，函数的返回值类型应该是确定不变的，但PHP是弱类型的语言，
所以PHP是没有此类语法验证的，正因为如此，造成了很多坑坑。
比如下面的代码：
<?php
function getArticles(...){
$arrData = array();
if($exp1){
return $arrData;
}else if($exp2){
return 1;
}else{
return false;
}
}
$arrData =getArticles(...);
foreach($arrData as $record){
//do something.
....
}
?>
函数getArticles根据不同的条件返回不同类型的值，有bool、int、还有数组，正常情况这类函数是希望返回数组，然后拿数组去做一些其他操作，
可因为函数返回值类型不固定，调用时就很可能产生各种预想不到的坑，
因此我就想，既然不能规范，那直接强制好了。
函数/方法返回值可以强制类型，如 图
支持四种强制类型限制：int、array、bool、object，当返回值与函数声明中的类型不匹配时，抛出warning，本来想抛出error，但是觉得
太狠了，只能算是个异常，不能算错误，所以就用warning好了。
PHP本身是不支持 int function 这样的语法的，所以要支持，就先要搞定语法解析器，关于语法解析器，可以移步这里>>>查看
详情，这里就不讲了，
先修改语法扫描 Zend/zend_language_scanner.l文件
增加如下代码：
<ST_IN_SCRIPTING>"int" {
return T_FUNCTION_RETURN_INT;
}
<ST_IN_SCRIPTING>"bool" {
return T_FUNCTION_RETURN_OBJECT;
}
<ST_IN_SCRIPTING>"object" {
return T_FUNCTION_RETURN_OBJECT;
}
<ST_IN_SCRIPTING>"resource" {
return T_FUNCTION_RETURN_RESOURCE;
}
意思很简单，扫描器扫描到到关键字 int、bool、object、resource、array时返回相应的T_FUNCTION_* ，这是一个token，
scanner根据不同的token做不同的处理，token要先在Zend/zend_language_parser.y文件中定义
增加如下代码
..........
%token T_FUNCTION_RETURN_INT
%token T_FUNCTION_RETURN_BOOL
%token T_FUNCTION_RETURN_STRING
%token T_FUNCTION_RETURN_OBJECT
%token T_FUNCTION_RETURN_RESOURCE
然后增加token处理逻辑：
function:
T_FUNCTION { $$.u.opline_num = CG(zend_lineno);$$.u.EA.var = 0; }
| T_FUNCTION_RETURN_INT T_FUNCTION {
$$.u.opline_num = CG(zend_lineno);
$$.u.EA.var = IS_LONG;
}
| T_FUNCTION_RETURN_BOOL T_FUNCTION {
$$.u.opline_num = CG(zend_lineno);
$$.u.EA.var = IS_BOOL;
}
| T_FUNCTION_RETURN_STRING T_FUNCTION {
$$.u.opline_num = CG(zend_lineno);
$$.u.EA.var = IS_STRING;
}
| T_FUNCTION_RETURN_OBJECT T_FUNCTION {
$$.u.opline_num = CG(zend_lineno);
$$.u.EA.var = IS_OBJECT;
}
| T_FUNCTION_RETURN_RESOURCE T_FUNCTION {
$$.u.opline_num = CG(zend_lineno);
$$.u.EA.var = IS_RESOURCE;
}
| T_ARRAY T_FUNCTION {
$$.u.opline_num = CG(zend_lineno);
$$.u.EA.var = IS_ARRAY;
}
$$.u.EA.var 存储的是 函数返回类型，最后要拿他来跟返回值类型做匹配，
这样语法解释器就可以处理我们新的php语法了。
这还不够，还需要修改函数声明定义的处理逻辑
Zend/zend_compile.c ：：zend_do_begin_function_declaration
......
zend_op_array op_array;
char *name = function_name->u.constant.value.str.val;
int name_len = function_name->u.constant.value.str.len;
int function_type = function_token->u.EA.var; //保存函数类型,在语法解释器中增加的： $$.u.EA.var = IS_LONG;
int function_begin_line = function_token->u.opline_num;
......
op_array.function_name = name;
op_array.fn_type = function_type; //将类型保存到op_array中，
op_array.return_reference = return_reference;
op_array.fn_flags |= fn_flags;
op_array.pass_rest_by_reference = 0;
..........
PHP是先解析PHP语法生成相应的opcode，将需要的环境、参数信息保存到execute_data全局变量中，最后在通过execute函数逐条执行opcode，
所以要做处理就要把函数的类型保存到opcode中：op_array.fn_type = function_type;
op_array是没有fn_type的，要修改op_array的结构，增加zend_uint fn_type;
（关于opcode你可以想象一下 从c转为汇编，我博客中也有相关文章，可以参考一下）
最后要修改opcode的毁掉函数，函数的返回 return 会生成token T_RETURN，T_RETURN会根据返回的类型调用不同的calback函数：
ZEND_RETURN_SPEC_CONST_HANDLER
ZEND_RETURN_SPEC_TMP_HANDLER
ZEND_RETURN_SPEC_VAR_HANDLER
它有三个callback，如果返回值是一个 const类型的数据，则 ZEND_RETURN_SPEC_CONST_HANDLER
返回值是临时数据，如 ： return 1，则ZEND_RETURN_SPEC_TMP_HANDLER
返回值是一个变量，如 ： return $a，则ZEND_RETURN_SPEC_VAR_HANDLER
所以要在这三个callback函数中增加处理逻辑：
在callback函数return之前增加如下代码
if((EG(active_op_array)->fn_type > 0) && Z_TYPE_P(retval_ptr) != EG(active_op_array)->fn_type){
php_error_docref0(NULL TSRMLS_DC,E_WARNING, "function name %s return a wrong type.", EG(active_op_array)->function_name );
}
fn_type 去跟 返回值的类型作比较，如果没有匹配到，就会抛出这个warning。
我已经打了补丁，目前只支持php5.3版本，有需要的可以拿去玩一玩。
不清楚为什么官方不支持此语法，我觉得还是挺有必要的。
下载补丁：php-syntax.patch
续:
后来有找鸟哥(惠新宸:http://weibo.com/laruence) 聊过,
下面是他的回答:
“这个话题, 基本也是邮件组的月经贴了…. 1. 因为PHP是若类型, 很多类型可以互相转换, 那么到底要不要隐式转换, 你的实现是不转换, 这样的局限太大, 如果转换又涉及到各种转换规则. 2. 也不是不支持, 不过你的这个实现肯定是不够的(各种自定类,和继承类). 3. 以后如果要做jit, 可能会考虑支持.”
如此看来,这个问题官方也是比较纠结的,确实是我的思路是不强制转换,只需要抛出警告就行了,让开发人员自己决定是否转换,是不是更好?
facebook的hack语言，也支持强制类型转换。不过改动太多的话，PHP升级维护是不是会比较差一些。。
这部分将说明PHP 5.3的新的垃圾回收机制(也就是GC)的特点。
每个php变量存在一个叫”zval”的变量容器中。一个zval变量容器，除了包含变量的类型和值，还包括两个字节的额外信息。第一个是”is_ref”，是个bool值，用来标识这个变量是否是属于引用集合(reference set)。通过这个字节，php引擎才能把普通变量和引用变量区分开来，由于php允许用户通过使用&来使用自定义引用，zval变量容器中还有一个内部引用计数机制，来优化内存使用。第二个额外字节是”refcount”，用以表示指向这个zval变量容器的变量(也称符号即symbol)个数。所有的符号存在一个符号表中，其中每个符号都有作用域(scope)，那些主脚本(比如：通过浏览器请求的的脚本)和每个函数或者方法也都有作用域。
当一个变量被赋常量值时，就会生成一个zval变量容器，如下例这样：
Example #1 Creating a new zval container
<?php
$a = "new string";
?>
在上例中，新的变量a，是在当前作用域中生成的。并且生成了类型为 string 和值为new string的变量容器。在额外的两个字节信息中，”is_ref”被默认设置为 FALSE，因为没有任何自定义的引用生成。”refcount” 被设定为 1，因为这里只有一个变量使用这个变量容器. 注意到当”refcount”的值是1时，”is_ref”的值总是FALSE. 如果你已经安装了» Xdebug，你能通过调用函数 xdebug_debug_zval()显示”refcount”和”is_ref”的值。
Example #2 Displaying zval information
<?php
xdebug_debug_zval('a');
?>
以上例程会输出：
a: (refcount=1, is_ref=0)='new string'
把一个变量赋值给另一变量将增加引用次数(refcount).
Example #3 Increasing refcount of a zval
<?php
$a = "new string";
$b = $a;
xdebug_debug_zval( 'a' );
?>
以上例程会输出：
a: (refcount=2, is_ref=0)='new string'
这时，引用次数是2，因为同一个变量容器被变量 a 和变量 b关联.当没必要时，php不会去复制已生成的变量容器。变量容器在”refcount“变成0时就被销毁. 当任何关联到某个变量容器的变量离开它的作用域(比如：函数执行结束)，或者对变量调用了函数 unset()时，”refcount“就会减1，下面的例子就能说明:
Example #4 Decreasing zval refcount
<?php
$a = "new string";
$c = $b = $a;
xdebug_debug_zval( 'a' );
unset( $b, $c );
xdebug_debug_zval( 'a' );
?>
以上例程会输出：
a: (refcount=3, is_ref=0)='new string'
a: (refcount=1, is_ref=0)='new string'
如果我们现在执行 unset($a);，包含类型和值的这个变量容器就会从内存中删除。
复合类型(Compound Types)
当考虑像 array和object这样的复合类型时，事情就稍微有点复杂. 与 标量(scalar)类型的值不同，array和 object类型的变量把它们的成员或属性存在自己的符号表中。这意味着下面的例子将生成三个zval变量容器。
Example #5 Creating a array zval
<?php
$a = array( 'meaning' => 'life', 'number' => 42 );
xdebug_debug_zval( 'a' );
?>
以上例程的输出类似于：
a: (refcount=1, is_ref=0)=array (
'meaning' => (refcount=1, is_ref=0)='life',
'number' => (refcount=1, is_ref=0)=42
)
这三个zval变量容器是: a，meaning和 number。增加和减少”refcount”的规则和上面提到的一样. 下面, 我们在数组中再添加一个元素,并且把它的值设为数组中已存在元素的值:
Example #6 Adding already existing element to an array
<?php
$a = array( 'meaning' => 'life', 'number' => 42 );
$a['life'] = $a['meaning'];
xdebug_debug_zval( 'a' );
?>
以上例程的输出类似于：
a: (refcount=1, is_ref=0)=array (
'meaning' => (refcount=2, is_ref=0)='life',
'number' => (refcount=1, is_ref=0)=42,
'life' => (refcount=2, is_ref=0)='life'
)
从以上的xdebug输出信息，我们看到原有的数组元素和新添加的数组元素关联到同一个”refcount”2的zval变量容器. 尽管 Xdebug的输出显示两个值为‘life’的 zval 变量容器，其实是同一个。 函数xdebug_debug_zval()不显示这个信息，但是你能通过显示内存指针信息来看到。
删除数组中的一个元素，就是类似于从作用域中删除一个变量. 删除后,数组中的这个元素所在的容器的“refcount”值减少，同样，当“refcount”为0时，这个变量容器就从内存中被删除，下面又一个例子可以说明：
Example #7 Removing an element from an array
<?php
$a = array( 'meaning' => 'life', 'number' => 42 );
$a['life'] = $a['meaning'];
unset( $a['meaning'], $a['number'] );
xdebug_debug_zval( 'a' );
?>
以上例程的输出类似于：
a: (refcount=1, is_ref=0)=array (
'life' => (refcount=1, is_ref=0)='life'
)
现在，当我们添加一个数组本身作为这个数组的元素时，事情就变得有趣，下个例子将说明这个。例中我们加入了引用操作符，否则php将生成一个复制。
Example #8 Adding the array itself as an element of it self
<?php
$a = array( 'one' );
$a[] =& $a;
xdebug_debug_zval( 'a' );
?>
以上例程的输出类似于：
a: (refcount=2, is_ref=1)=array (
0 => (refcount=1, is_ref=0)='one',
1 => (refcount=2, is_ref=1)=...
)
能看到数组变量 (a) 同时也是这个数组的第二个元素(1) 指向的变量容器中“refcount”为 2。上面的输出结果中的”…”说明发生了递归操作, 显然在这种情况下意味着”…”指向原始数组。
跟刚刚一样，对一个变量调用unset，将删除这个符号，且它指向的变量容器中的引用次数也减1。所以，如果我们在执行完上面的代码后，对变量$a调用unset, 那么变量 $a 和数组元素 “1″ 所指向的变量容器的引用次数减1, 从”2″变成”1″. 下例可以说明:
Example #9 Unsetting $a
(refcount=1, is_ref=1)=array (
0 => (refcount=1, is_ref=0)='one',
1 => (refcount=1, is_ref=1)=...
)
清理变量容器的问题(Cleanup Problems)
尽管不再有某个作用域中的任何符号指向这个结构(就是变量容器)，由于数组元素“1”仍然指向数组本身，所以这个容器不能被清除 。因为没有另外的符号指向它，用户没有办法清除这个结构，结果就会导致内存泄漏。庆幸的是，php将在请求结束时清除这个数据结构，但是在php清除之前，将耗费不少空间的内存。如果你要实现分析算法，或者要做其他像一个子元素指向它的父元素这样的事情，这种情况就会经常发生。当然，同样的情况也会发生在对象上，实际上对象更有可能出现这种情况，因为对象总是隐式的被引用。
如果上面的情况发生仅仅一两次倒没什么，但是如果出现几千次，甚至几十万次的内存泄漏，这显然是个大问题。在长时间运行的脚本，比如请求基本上不会结束的守护进程(deamons)或者单元测试中的大的套件(sets)中，在给 eZ 组件库的模板组件做单元测试时，后者(指单元测试中的大的套件)就会出现问题.它将需要耗用2GB的内存，而一般的测试服务器没有这么大的内存空间。
传统上，像以前的 php 用到的引用计数内存机制，无法处理循环的引用内存泄漏。然而 5.3.0 PHP 使用文章» 引用计数系统中的同步周期回收(Concurrent Cycle Collection in Reference Counted Systems)中的同步算法，来处理这个内存泄漏问题。
对算法的完全说明有点超出这部分内容的范围，将只介绍其中基础部分。首先，我们先要建立一些基本规则，如果一个引用计数增加，它将继续被使用，当然就不再在垃圾中。如果引用计数减少到零，所在变量容器将被清除(free)。就是说，仅仅在引用计数减少到非零值时，才会产生垃圾周期(garbage cycle)。其次，在一个垃圾周期中，通过检查引用计数是否减1，并且检查哪些变量容器的引用次数是零，来发现哪部分是垃圾。
为避免不得不检查所有引用计数可能减少的垃圾周期，这个算法把所有可能根(possible roots 都是zval变量容器),放在根缓冲区(root buffer)中(用紫色来标记，称为疑似垃圾)，这样可以同时确保每个可能的垃圾根(possible garbage root)在缓冲区中只出现一次。仅仅在根缓冲区满了时，才对缓冲区内部所有不同的变量容器执行垃圾回收操作。看上图的步骤 A。
在步骤 B 中，模拟删除每个紫色变量。模拟删除时可能将不是紫色的普通变量引用数减”1″，如果某个普通变量引用计数变成0了，就对这个普通变量再做一次模拟删除。每个变量只能被模拟删除一次，模拟删除后标记为灰(原文说确保不会对同一个变量容器减两次”1″,不对的吧)。
在步骤 C 中，模拟恢复每个紫色变量。恢复是有条件的，当变量的引用计数大于0时才对其做模拟恢复。同样每个变量只能恢复一次，恢复后标记为黑，基本就是步骤 B 的逆运算。这样剩下的一堆没能恢复的就是该删除的蓝色节点了，在步骤 D 中遍历出来真的删除掉。
算法中都是模拟删除、模拟恢复、真的删除，都使用简单的遍历即可(最典型的深搜遍历)。复杂度为执行模拟操作的节点数正相关，不只是紫色的那些疑似垃圾变量。
现在，你已经对这个算法有了基本了解，我们回头来看这个如何与PHP集成。默认的，PHP的垃圾回收机制是打开的，然后有个 php.ini 设置允许你修改它：zend.enable_gc 。
当垃圾回收机制打开时，每当根缓存区存满时，就会执行上面描述的循环查找算法。根缓存区有固定的大小，可存10,000个可能根,当然你可以通过修改PHP源码文件Zend/zend_gc.c中的常量GC_ROOT_BUFFER_MAX_ENTRIES，然后重新编译PHP，来修改这个10,000值。当垃圾回收机制关闭时，循环查找算法永不执行，然而，可能根将一直存在根缓冲区中，不管在配置中垃圾回收机制是否激活。
当垃圾回收机制关闭时，如果根缓冲区存满了可能根，更多的可能根显然不会被记录。那些没被记录的可能根，将不会被这个算法来分析处理。如果他们是循环引用周期的一部分，将永不能被清除进而导致内存泄漏。
即使在垃圾回收机制不可用时，可能根也被记录的原因是，相对于每次找到可能根后检查垃圾回收机制是否打开而言，记录可能根的操作更快。不过垃圾回收和分析机制本身要耗不少时间。
除了修改配置zend.enable_gc ，也能通过分别调用gc_enable() 和 gc_disable()函数来打开和关闭垃圾回收机制。调用这些函数，与修改配置项来打开或关闭垃圾回收机制的效果是一样的。即使在可能根缓冲区还没满时，也能强制执行周期回收。你能调用gc_collect_cycles()函数达到这个目的。这个函数将返回使用这个算法回收的周期数。
允许打开和关闭垃圾回收机制并且允许自主的初始化的原因，是由于你的应用程序的某部分可能是高时效性的。在这种情况下，你可能不想使用垃圾回收机制。当然，对你的应用程序的某部分关闭垃圾回收机制，是在冒着可能内存泄漏的风险，因为一些可能根也许存不进有限的根缓冲区。因此，就在你调用gc_disable()函数释放内存之前，先调用gc_collect_cycles()函数可能比较明智。因为这将清除已存放在根缓冲区中的所有可能根，然后在垃圾回收机制被关闭时，可留下空缓冲区以有更多空间存储可能根。
性能方面考虑的因素
在上一节我们已经简单的提到：回收可能根有细微的性能上影响，但这是把PHP 5.2与PHP 5.3比较时才有的。尽管在PHP 5.2中，记录可能根相对于完全不记录可能根要慢些，而PHP 5.3中对 PHP run-time 的其他修改减少了这个性能损失。
这里主要有两个领域对性能有影响。第一个是内存占用空间的节省，另一个是垃圾回收机制执行内存清理时的执行时间增加(run-time delay)。我们将研究这两个领域。
内存占用空间的节省
首先，实现垃圾回收机制的整个原因是为了，一旦先决条件满足，通过清理循环引用的变量来节省内存占用。在PHP执行中，一旦根缓冲区满了或者调用gc_collect_cycles() 函数时，就会执行垃圾回收。在下图中，显示了下面脚本分别在PHP 5.2 和 PHP 5.3环境下的内存占用情况，其中排除了脚本启动时PHP本身占用的基本内存。
Example #1 Memory usage example
<?php
class Foo
{
public $var = '3.1415962654';
}
$baseMemory = memory_get_usage();
for ( $i = 0; $i <= 100000; $i++ )
{
$a = new Foo;
$a->self = $a;
if ( $i % 500 === 0 )
{
echo sprintf( '%8d: ', $i ), memory_get_usage() - $baseMemory, "n";
}
}
?>
在这个很理论性的例子中，我们创建了一个对象，这个对象中的一个属性被设置为指回对象本身。在循环的下一个重复(iteration)中，当脚本中的变量被重新复制时，就会发生典型性的内存泄漏。在这个例子中，两个变量容器是泄漏的(对象容器和属性容器)，但是仅仅能找到一个可能根：就是被 unset的那个变量。在10,000次重复后(也就产生总共10,000个可能根)，当根缓冲区满时，就执行垃圾回收机制，并且释放那些关联的可能根的内存。这从PHP 5.3的锯齿型内存占用图中很容易就能看到。每次执行完10,000次重复后，执行垃圾回收，并释放相关的重复使用的引用变量。在这个例子中由于泄漏的数据结构非常简单，所以垃圾回收机制本身不必做太多工作。从这个图表中，你能看到 PHP 5.3的最大内存占用大概是9 Mb，而PHP 5.2的内存占用一直增加。
执行时间增加(Run-Time Slowdowns)
垃圾回收影响性能的第二个领域是它释放已泄漏的内存耗费的时间。为了看到这个耗时时多少，我们稍微改变了上面的脚本，有更多次数的重复并且删除了循环中的内存占用计算，第二个脚本代码如下：
Example #2 GC performance influences
<?php
class Foo
{
public $var = '3.1415962654';
}
for ( $i = 0; $i <= 1000000; $i++ )
{
$a = new Foo;
$a->self = $a;
}
echo memory_get_peak_usage(), "n";
?>
我们将运行这个脚本两次，一次通过配置zend.enable_gc 打开垃圾回收机制时，另一次是它关闭时。
Example #3 Running the above script
time php -dzend.enable_gc=0 -dmemory_limit=-1 -n example2.php
# and
time php -dzend.enable_gc=1 -dmemory_limit=-1 -n example2.php
在我的机器上，第一个命令持续执行时间大概为10.7秒，而第二个命令耗费11.4秒。时间上增加了7%。然而，执行这个脚本时内存占用的峰值降低了98%，从931Mb 降到 10Mb。这个基准不是很科学，或者并不能代表真实应用程序的数据，但是它的确显示了垃圾回收机制在内存占用方面的好处。好消息就是，对这个脚本而言，在执行中出现更多的循环引用变量时，内存节省的更多的情况下，每次时间增加的百分比都是7%。
PHP内部 GC 统计信息
在PHP内部，可以显示更多的关于垃圾回收机制如何运行的信息。但是要显示这些信息，你需要先重新编译PHP使benchmark和data-collecting code可用。你需要在按照你的意愿运行./configure前，把环境变量CFLAGS设置成-DGC_BENCH=1。下面的命令串就是做这个事：
Example #4 Recompiling PHP to enable GC benchmarking
export CFLAGS=-DGC_BENCH=1
./config.nice
make clean
make
当你用新编译的PHP二进制文件来重新执行上面的例子代码，在PHP执行结束后，你将看到下面的信息：
Example #5 GC statistics
GC Statistics
-------------
Runs: 110
Collected: 2072204
Root buffer length: 0
Root buffer peak: 10000
Possible Remove from Marked
Root Buffered buffer grey
-------- -------- ----------- ------
ZVAL 7175487 1491291 1241690 3611871
ZOBJ 28506264 1527980 677581 1025731
主要的信息统计在第一个块。你能看到垃圾回收机制运行了110次，而且在这110次运行中，总共有超过两百万的内存分配被释放。只要垃圾回收机制运行了至少一次，根缓冲区峰值(Root buffer peak)总是10000.
结论
通常，PHP中的垃圾回收机制，仅仅在循环回收算法确实运行时会有时间消耗上的增加。但是在平常的(更小的)脚本中应根本就没有性能影响。
然而，在平常脚本中有循环回收机制运行的情况下，内存的节省将允许更多这种脚本同时运行在你的服务器上。因为总共使用的内存没达到上限。
这种好处在长时间运行脚本中尤其明显，诸如长时间的测试套件或者daemon脚本此类。同时，对通常比Web脚本运行时间长的» PHP-GTK应用程序，新的垃圾回收机制，应该会大大改变一直以来认为内存泄漏问题难以解决的看法。
interface是面向对象编程语言中接口操作的关键字，功能是把所需成员组合起来，以封装一定功能的集合。本文我们来讲讲interface基本知识及用法实例。接口是一种约束形式，其中只包括成员定义，不包含成员实现的内容。用接口（interface），你可以指定某个类必须实现哪些方法，但不需要定义这些方法的具体内容。 我们可以通过interface来定义一个接口，就像定义一个标准的类一样，但其中定义所有的方法都是空的。
接口中定义的所有方法都必须是public，这是接口的特性。
实现
要实现一个接口，可以使用implements操作符。类中必须实现接口中定义的所有方法，否则会报一个fatal错误。如果要实现多个接口，可以用逗号来分隔多个接口的名称。
Note:
实现多个接口时，接口中的方法不能有重名。
Note:
接口也可以继承，通过使用extends操作符。
常量
接口中也可以定义常量。接口常量和类常量的使用完全相同。它们都是定值，不能被子类或子接口修改。
范例
Example #1 接口代码示例
<?php
// 声明一个'iTemplate'接口
interface iTemplate
{
public function setVariable($name, $var);
public function getHtml($template);
}
// 实现接口
// 下面的写法是正确的
class Template implements iTemplate
{
private $vars = array();
public function setVariable($name, $var)
{
$this->vars[$name] = $var;
}
public function getHtml($template)
{
foreach($this->vars as $name => $value) {
$template = str_replace('{' . $name . '}', $value, $template);
}
return $template;
}
}
// 下面的写法是错误的，会报错：
// Fatal error: Class BadTemplate contains 1 abstract methods
// and must therefore be declared abstract (iTemplate::getHtml)
class BadTemplate implements iTemplate
{
private $vars = array();
public function setVariable($name, $var)
{
$this->vars[$name] = $var;
}
}
?>
Example #2 Extendable Interfaces
<?php
interface a
{
public function foo();
}
interface b extends a
{
public function baz(Baz $baz);
}
// 正确写法
class c implements b
{
public function foo()
{
}
public function baz(Baz $baz)
{
}
}
// 错误写法会导致一个fatal error
class d implements b
{
public function foo()
{
}
public function baz(Foo $foo)
{
}
}
?>
Example #3 多个接口间的继承
<?php
interface a
{
public function foo();
}
interface b
{
public function bar();
}
interface c extends a, b
{
public function baz();
}
class d implements c
{
public function foo()
{
}
public function bar()
{
}
public function baz()
{
}
}
?>
Example #4 使用接口常量
<?php
interface a
{
const b = 'Interface constant';
}
// 输出接口常量
echo a::b;
// 错误写法，因为常量的值不能被修改。接口常量的概念和类常量是一样的。
class b implements a
{
const b = 'Class constant';
}
?>
相关文章
- 这篇文章主要介绍了Postgresl 如何选择正确的关闭模式，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...2021-01-18
- 神马是“解释器模式”？先翻开《GOF》看看Definition：给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。在开篇之前还是要科普几个概念： 抽象语法树： 解释器模式并未解释如...2014-06-07
- 很多集成的PHP环境(PHPnow WAMP Appserv等)自带的MySQL貌似都没有开启MySQL的严格模式，何为MySQL的严格模式，简单来说就是MySQL自身对数据进行严格的校验（格式、长度、类型等），比如一个整型字段我们写入一个字符串类型的数...2013-10-04
- 这篇文章主要为大家介绍了JavaScript设计模式中的装饰者模式，对JavaScript设计模式感兴趣的小伙伴们可以参考一下...2016-01-21
- 下面将把C#里实现IDispose模式的代码展现出来，大家一起来学习一下，它的使用场合也很多的，当我们手动对网站，数据库作封装时，都会用的到...2020-06-25
C# MVC模式中应该怎样区分应用程序逻辑（Controller层）和业务逻辑（Model层）?
这篇文章主要介绍了C# MVC模式中应该怎样区分应用程序逻辑（Controller层）和业务逻辑（Model层）?,这也小编做.NET项目时经常思考和让人混乱的一个问题,这篇文章写的挺好,一下清晰了许多,需要的朋友可以参考下...2020-06-25- 这篇文章主要介绍了JavaScript设计模式之职责链模式，对设计模式感兴趣的同学，可以参考下...2021-04-25
- 当我们在星际中开地图和几家电脑作战的时候，电脑的几个玩家相当于结盟，一旦我们出兵进攻某一家电脑，其余的电脑会出兵救援。 那么如何让各家电脑知道自己的盟友被攻击了...2016-11-25
- 这篇文章主要介绍了Java接口DAO模式代码原理及应用详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下...2020-11-03
- 这篇文章主要介绍了C#中的IDisposable模式用法,讲述了垃圾资源回收机制的实现,并对比分析了Dispose()方法、~DisposableClass()析构函数、虚方法Dispose(bool disposing)的原理,需要的朋友可以参考下...2020-06-25
- 版本：php_v2.0.6 在CloudsearchClient的类中，开启debug模式，设置为true 如：$opts = array('host'=>$host,'debug'=>true); 注意true不能加引号...2016-05-19
- 这篇文章主要为大家介绍了JavaScript设计模式中的状态模式，对JavaScript设计模式感兴趣的小伙伴们可以参考一下...2016-01-12
- 这篇文章主要介绍了C#使用Dispose模式实现手动对资源的释放,涉及C#采用Dispose模式操作资源的技巧,具有一定参考借鉴价值,需要的朋友可以参考下...2020-06-25
- 您是否遇到过孩子想要玩手机又不好拒绝，或者是您想要给孩子配一个联系用的手机有担心孩子玩手机上瘾？如果您购买的是小米手机，那么MIUI的儿童模式就能很好地解决这个问题...2016-12-21
- 这篇文章主要为大家介绍了JavaScript设计模式中的单例模式，对JavaScript设计模式感兴趣的小伙伴们可以参考一下...2016-01-21
- 本文实例讲述了php单例模式实现方法。...2015-03-15
vue-router history模式服务器端配置过程记录
vue路由有hash和history两种模式,这篇文章主要给大家介绍了关于vue-router history模式服务器端配置的相关资料,需要的朋友可以参考下...2021-06-08- 这篇文章主要介绍了JavaScript设计模式之命令模式，对设计模式感兴趣的同学，可以参考下...2021-04-25
- 我们建站的时候，开始是每次请求数据库都要重新连接的、这样显然不合理、然后自己封装了一个数据库操作类、DBTools.php、要解决一个连接多次使用的话、最好的办法是使...2016-11-25
- 这篇文章主要为大家介绍了JavaScript设计模式中的责任链模式，对JavaScript设计模式感兴趣的小伙伴们可以参考一下...2016-01-21