很多站长朋友们都不太清楚php内存回收原理，今天小编就来给大家整理php内存回收原理，希望对各位有所帮助，具体内容如下：
本文目录一览： 1、 PHP中对象的实例什么时候消失回收 2、 解析PHP中的内存管理,PHP动态分配和释放内存 3、 php底层原理 php是如何运行的 4、 PHP的性能探讨和测试 5、 php工作原理 6、 PHP命令执行PHP脚本，结束之前，内存会回收吗 PHP中对象的实例什么时候消失回收php作为脚本语言是页面结束即释放变量所占内存的.
当一个 PHP线程结束时，当前占用的所有内存空间都会被销毁，当前程序中所有对象同时被销毁。
GC进程一般都跟着每起一个SESSION而开始运行的.gc目的是为了在session文件过期以后自动销毁删除这些文件.
在PHP中，没有任何变量指向这个对象时，这个对象就成为垃圾。PHP会将其在内存中销毁；这是PHP 的GC垃圾处理机制，防止内存溢出。类似与C++中的智能指针一样。
执行这些函数也可以起到回收作用 __destruct /unset/mysql_close /fclose
php对session有明确的gc处理时间设定 session.gc_maxlifetime 如果说有垃圾，那就是整体的程序在框架使用中，会多次调用同一文件等等造成的非单件模式等。
析构函数：当某个对象成为垃圾或者当对象被显式销毁时执行。
解析PHP中的内存管理,PHP动态分配和释放内存本篇文章是对PHP中的内存管理 PHP动态分配和释放内存进行了详细的分析介绍 需要的朋友参考下
摘要 内存管理对于长期运行的程序 例如服务器守护程序 是相当重要的影响 因此 理解PHP是如何分配与释放内存的对于创建这类程序极为重要 本文将重点探讨PHP的内存管理问题
一 内存 在PHP中 填充一个字符串变量相当简单 这只需要一个语句"＜?php $str = hello world ; ?＞"即可 并且该字符串能够被自由地修改 拷贝和移动 而在C语言中 尽管你能够编写例如"char *str = "hello world ";"这样的一个简单的静态字符串 但是 却不能修改该字符串 因为它生存于程序空间内 为了创建一个可操纵的字符串 你必须分配一个内存块 并且通过一 个函数（例如strdup()）来复制其内容
复制代码 代码如下: { char *str; str = strdup("hello world"); if (!str) { fprintf(stderr "Unable to allocate memory!"); } }
由于后面我们将分析的各种原因 传统型内存管理函数（例如malloc() free() strdup() realloc() calloc() 等等）几乎都不能直接为PHP源代码所使用
二 释放内存 在几乎所有的平台上 内存管理都是通过一种请求和释放模式实现的 首先 一个应用程序请求它下面的层(通常指"操作系统") "我想使用一些内存空间" 如果存在可用的空间 操作系统就会把它提供给该程序并且打上一个标记以便不会再把这部分内存分配给其它程序 当 应用程序使用完这部分内存 它应该被返回到OS 这样以来 它就能够被继续分配给其它程序 如果该程序不返回这部分内存 那么OS无法知道是否这块内存不 再使用并进而再分配给另一个进程 如果一个内存块没有释放 并且所有者应用程序丢失了它 那么 我们就说此应用程序"存在漏洞" 因为这部分内存无法再为 其它程序可用 在一个典型的客户端应用程序中 较小的不太经常的内存泄漏有时能够为OS所"容忍" 因为在这个进程稍后结束时该泄漏内存会被隐式返回到OS 这并没有什么 因为OS知道它把该内存分配给了哪个程序 并且它能够确信当该程序终止时不再需要该内存 而对于长时间运行的服务器守护程序 包括象Apache这样的web服务器和扩展php模块来说 进程往往被设计为相当长时间一直运行 因为OS不能清理内存使用 所以 任何程序的泄漏 无论是多么小 都将导致重复操作并最终耗尽所有的系统资源 现 在 我们不妨考虑用户空间内的stristr()函数 为了使用大小写不敏感的搜索来查找一个字符串 它实际上创建了两个串的各自的一个小型副本 然后执 行一个更传统型的大小写敏感的搜索来查找相对的偏移量 然而 在定位该字符串的偏移量之后 它不再使用这些小写版本的字符串 如果它不释放这些副本 那 么 每一个使用stristr()的脚本在每次调用它时都将泄漏一些内存 最后 web服务器进程将拥有所有的系统内存 但却不能够使用它 你可以理直气壮地说 理想的解决方案就是编写良好 干净的 一致的代码 这当然不错 但是 在一个象PHP解释器这样的环境中 这种观点仅对了一半
三 错误处理 为了实现"跳出"对用户空间脚本及其依赖的扩展函数的一个活动请求 需要使用一种方法来 完全"跳出"一个活动请求 这是在Zend引擎内实现的 在一个请求的开始设置一个"跳出"地址 然后在任何die()或exit()调用或在遇到任何关 键错误(E_ERROR)时执行一个longjmp()以跳转到该"跳出"地址 尽管这个"跳出"进程能够简化程序执行的流程 但是 在绝大多数情况下 这会意味着将会跳过资源清除代码部分(例如free()调用)并最终导致出现内存漏洞 现在 让我们来考虑下面这个简化版本的处理函数调用的引擎代码
复制代码 代码如下: void call_function(const char *fname int fname_len TSRMLS_DC){ zend_function *fe; char *lcase_fname; /* PHP函数名是大小写不敏感的 *为了简化在函数表中对它们的定位 *所有函数名都隐含地翻译为小写的 */ lcase_fname = estrndup(fname fname_len); zend_str_tolower(lcase_fname fname_len); if (zend_hash_find(EG(function_table) lcase_fname fname_len + (void **)fe) == FAILURE) { zend_execute(fe ＞op_array TSRMLS_CC); } else { php_error_docref(NULL TSRMLS_CC E_ERROR "Call to undefined function: %s()" fname); } efree(lcase_fname); }
当 执行到php_error_docref()这一行时 内部错误处理器就会明白该错误级别是critical 并相应地调用longjmp()来中断当前 程序流程并离开call_function()函数 甚至根本不会执行到efree(lcase_fname)这一行 你可能想把efree()代码行移 动到zend_error()代码行的上面 但是 调用这个call_function()例程的代码行会怎么样呢？fname本身很可能就是一个分配的 字符串 并且 在它被错误消息处理使用完之前 你根本不能释放它 注意 这个php_error_docref()函数是trigger_error()函数的一个内部等价实现 它的第一个参数是一个将被添加到docref的可选的文档引用 第三个参数可以是任何我们熟悉的E_*家族常量 用于指示错误的严重程度 第四个参数（最后一个）遵循printf()风格的格式化和变量参数列表式样 四 Zend内存管理器 在 上面的"跳出"请求期间解决内存泄漏的方案之一是 使用Zend内存管理(ZendMM)层 引擎的这一部分非常类似于操作系统的内存管理行为 分配内存 给调用程序 区别在于 它处于进程空间中非常低的位置而且是"请求感知"的 这样以来 当一个请求结束时 它能够执行与OS在一个进程终止时相同的行为 也就是说 它会隐式地释放所有的为该请求所占用的内存 图 展示了ZendMM与OS以及PHP进程之间的关系 图 Zend内存管理器代替系统调用来实现针对每一种请求的内存分配 除 了提供隐式内存清除功能之外 ZendMM还能够根据php ini中memory_limit的设置控制每一种内存请求的用法 如果一个脚本试图请求比 系统中可用内存更多的内存 或大于它每次应该请求的最大量 那么 ZendMM将自动地发出一个E_ERROR消息并且启动相应的"跳出"进程 这种方法 的一个额外优点在于 大多数内存分配调用的返回值并不需要检查 因为如果失败的话将会导致立即跳转到引擎的退出部分 把PHP内部代码和 OS的实际的内存管理层"钩"在一起的原理并不复杂 所有内部分配的内存都要使用一组特定的可选函数实现 例如 PHP代码不是使用malloc( ) 来分配一个 字节内存块而是使用了emalloc( ) 除了实现实际的内存分配任务外 ZendMM还会使用相应的绑定请求类型来标志该内存块 这 样以来 当一个请求"跳出"时 ZendMM可以隐式地释放它 经常情况下 内存一般都需要被分配比单个请求持续时间更长的一段时间 这 种类型的分配（因其在一次请求结束之后仍然存在而被称为"永久性分配"） 可以使用传统型内存分配器来实现 因为这些分配并不会添加ZendMM使用的那 些额外的相应于每种请求的信息 然而有时 直到运行时刻才会确定是否一个特定的分配需要永久性分配 因此ZendMM导出了一组帮助宏 其行为类似于其它 的内存分配函数 但是使用最后一个额外参数来指示是否为永久性分配 如果你确实想实现一个永久性分配 那么这个参数应该被设置为 在这 种情况下 请求是通过传统型malloc()分配器家族进行传递的 然而 如果运行时刻逻辑认为这个块不需要永久性分配 那么 这个参数可以被设置为零 并且调用将会被调整到针对每种请求的内存分配器函数 例如 pemalloc(buffer_len )将映射到malloc(buffer_len) 而pemalloc(buffer_len )将被使用下列语句映射到emalloc(buffer_len) #define in Zend/zend_alloc h: #define pemalloc(size persistent) ((persistent)?malloc(size): emalloc(size)) 所有这些在ZendMM中提供的分配器函数都能够从下表中找到其更传统的对应实现 表格 展示了ZendMM支持下的每一个分配器函数以及它们的e/pe对应实现 表格 传统型相对于PHP特定的分配器
分配器函数 e/pe对应实现 void *malloc(size_t count); void *emalloc(size_t count);void *pemalloc(size_t count char persistent); void *calloc(size_t count); void *ecalloc(size_t count);void *pecalloc(size_t count char persistent); void *realloc(void *ptr size_t count); void *erealloc(void *ptr size_t count); void *perealloc(void *ptr size_t count char persistent); void *strdup(void *ptr); void *estrdup(void *ptr);void *pestrdup(void *ptr char persistent); void free(void *ptr); void efree(void *ptr); void pefree(void *ptr char persistent);
你可能会注意到 即使是pefree()函数也要求使用永久性标志 这是因为在调用pefree()时 它实际上并不知道是否ptr是一种永久性分 配 针对一个非永久性分配调用free()能够导致双倍的空间释放 而针对一种永久性分配调用efree()有可能会导致一个段错误 因为内存管理器会试 图查找并不存在的管理信息 因此 你的代码需要记住它分配的数据结构是否是永久性的 除了分配器函数核心部分外 还存在其它一些非常方便的ZendMM特定的函数 例如 void *estrndup(void *ptr int len); 该函数能够分配len+ 个字节的内存并且从ptr处复制len个字节到最新分配的块 这个estrndup()函数的行为可以大致描述如下
复制代码 代码如下: void *estrndup(void *ptr int len) { char *dst = emalloc(len + ); memcpy(dst ptr len); dst[len] = ; return dst; }
在 此 被隐式放置在缓冲区最后的NULL字节可以确保任何使用estrndup()实现字符串复制操作的函数都不需要担心会把结果缓冲区传递给一个例如 printf()这样的希望以为NULL为结束符的函数 当使用estrndup()来复制非字符串数据时 最后一个字节实质上都浪费了 但其中的利明显 大于弊 void *safe_emalloc(size_t size size_t count size_t addtl); void *safe_pemalloc(size_t size size_t count size_t addtl char persistent); 这 些函数分配的内存空间最终大小是((size*count)+addtl) 你可以会问 "为什么还要提供额外函数呢？为什么不使用一个 emalloc/pemalloc呢？"原因很简单 为了安全 尽管有时候可能性相当小 但是 正是这一"可能性相当小"的结果导致宿主平台的内存溢出 这可能会导致分配负数个数的字节空间 或更有甚者 会导致分配一个小于调用程序要求大小的字节空间 而safe_emalloc()能够避免这种类型的陷 井 通过检查整数溢出并且在发生这样的溢出时显式地预以结束 注意 并不是所有的内存分配例程都有一个相应的p*对等实现 例如 不存在pestrndup() 并且在PHP 版本前也不存在safe_pemalloc()
五 引用计数 慎重的内存分配与释放对于PHP（它是一种多请求进程）的长期性能有极其重大的影响 但是 这还仅是问题的一半 为了使一个每秒处理上千次点击的服务器高效地运行 每一次请求都需要使用尽可能少的内存并且要尽可能减少不必要的数据复制操作 请考虑下列PHP代码片断
复制代码 代码如下: ＜?php $a = Hello World ; $b = $a; unset($a); ?＞
在第一次调用之后 只有一个变量被创建 并且一个 字节的内存块指派给它以便存储字符串"Hello World" 还包括一个结尾处的NULL字符 现在 让我们来观察后面的两行 $b被置为与变量$a相同的值 然后变量$a被释放 如 果PHP因每次变量赋值都要复制变量内容的话 那么 对于上例中要复制的字符串还需要复制额外的 个字节 并且在数据复制期间还要进行另外的处理器加 载 这一行为乍看起来有点荒谬 因为当第三行代码出现时 原始变量被释放 从而使得整个数据复制显得完全不必要 其实 我们不妨再远一层考虑 让我们设想 当一个 MB大小的文件的内容被装载到两个变量中时会发生什么 这将会占用 MB的空间 此时 已经足够了 引擎会把那么多的时间和内存浪费在这 样一种无用的努力上吗？ 你应该知道 PHP的设计者早已深谙此理 记住 在引擎中 变量名和它们的值实际上是两个不同的概念 值本身是一个无名的zval*存储体（在本例中 是一个字符串值） 它被通过zend_hash_add()赋给变量$a 如果两个变量名都指向同一个值 会发生什么呢？
复制代码 代码如下: { zval *helloval; MAKE_STD_ZVAL(helloval); ZVAL_STRING(helloval "Hello World" ); zend_hash_add(EG(active_symbol_table) "a" sizeof("a") helloval sizeof(zval*) NULL); zend_hash_add(EG(active_symbol_table) "b" sizeof("b") helloval sizeof(zval*) NULL); }
此 时 你可以实际地观察$a或$b 并且会看到它们都包含字符串"Hello World" 遗憾的是 接下来 你继续执行第三行代码"unset($a);" 此时 unset()并不知道$a变量指向的数据还被另一个变量所使 用 因此它只是盲目地释放掉该内存 任何随后的对变量$b的存取都将被分析为已经释放的内存空间并因此导致引擎崩溃 这个问题可以借助于 zval（它有好几种形式）的第四个成员refcount加以解决 当一个变量被首次创建并赋值时 它的refcount被初始化为 因为它被假定仅由 最初创建它时相应的变量所使用 当你的代码片断开始把helloval赋给$b时 它需要把refcount的值增加为 这样以来 现在该值被两个变量 所引用
复制代码 代码如下: { zval *helloval; MAKE_STD_ZVAL(helloval); ZVAL_STRING(helloval "Hello World" ); zend_hash_add(EG(active_symbol_table) "a" sizeof("a") helloval sizeof(zval*) NULL); ZVAL_ADDREF(helloval); zend_hash_add(EG(active_symbol_table) "b" sizeof("b") helloval sizeof(zval*) NULL); }
现在 当unset()删除原变量的$a相应的副本时 它就能够从refcount参数中看到 还有另外其他人对该数据感兴趣 因此 它应该只是减少refcount的计数值 然后不再管它
六 写复制（Copy on Write） 通过refcounting来节约内存的确是不错的主意 但是 当你仅想改变其中一个变量的值时情况会如何呢？为此 请考虑下面的代码片断
复制代码 代码如下: ＜?php $a = ; $b = $a; $b += ; ?＞
通过上面的逻辑流程 你当然知道$a的值仍然等于 而$b的值最后将是 并且此时 你还知道 Zend在尽力节省内存 通过使$a和$b都引用相同的zval（见第二行代码） 那么 当执行到第三行并且必须改变$b变量的值时 会发生什么情况呢？ 回答是 Zend要查看refcount的值 并且确保在它的值大于 时对之进行分离 在Zend引擎中 分离是破坏一个引用对的过程 正好与你刚才看到的过程相反
复制代码 代码如下: zval *get_var_and_separate(char *varname int varname_len TSRMLS_DC) { zval **varval *varcopy; if (zend_hash_find(EG(active_symbol_table) varname varname_len + (void**)varval) == FAILURE) { /* 变量根本并不存在 失败而导致退出*/ return NULL; } if ((*varval) ＞refcount ＜ ) { /* varname是唯一的实际引用 *不需要进行分离 */ return *varval; } /* 否则 再复制一份zval*的值*/ MAKE_STD_ZVAL(varcopy); varcopy = *varval; /* 复制任何在zval*内的已分配的结构*/ zval_copy_ctor(varcopy); /*删除旧版本的varname *这将减少该过程中varval的refcount的值 */ zend_hash_del(EG(active_symbol_table) varname varname_len + ); /*初始化新创建的值的引用计数 并把它依附到 * varname变量 */ varcopy ＞refcount = ; varcopy ＞is_ref = ; zend_hash_add(EG(active_symbol_table) varname varname_len + varcopy sizeof(zval*) NULL); /*返回新的zval* */ return varcopy; }
现在 既然引擎有一个仅为变量$b所拥有的zval*（引擎能知道这一点） 所以它能够把这个值转换成一个long型值并根据脚本的请求给它增加
七 写改变（change on write） 引用计数概念的引入还导致了一个新的数据操作可能性 其形式从用户空间脚本管理器看来与"引用"有一定关系 请考虑下列的用户空间代码片断
复制代码 代码如下: ＜?php $a = ; $b = $a; $b += ; ?＞
在 上面的PHP代码中 你能看出$a的值现在为 尽管它一开始为 并且从未(直接)发生变化 之所以会发生这种情况是因为当引擎开始把$b的值增加 时 它注意到$b是一个对$a的引用并且认为"我可以改变该值而不必分离它 因为我想使所有的引用变量都能看到这一改变" 但是 引擎是如何 知道的呢？很简单 它只要查看一下zval结构的第四个和最后一个元素（is_ref）即可 这是一个简单的开/关位 它定义了该值是否实际上是一个用户 空间风格引用集的一部分 在前面的代码片断中 当执行第一行时 为$a创建的值得到一个refcount为 还有一个is_ref值为 因为它仅为一 个变量($a)所拥有并且没有其它变量对它产生写引用改变 在第二行 这个值的refcount元素被增加为 除了这次is_ref元素被置为 之外 （因为脚本中包含了一个""符号以指示是完全引用） 最后 在第三行 引擎再一次取出与变量$b相关的值并且检查是否有必要进行分离 这一次该值没有被分离 因为前面没有包括一个检查 下面是get_var_and_separate()函数中与refcount检查有关的部分代码
复制代码 代码如下: if ((*varval) ＞is_ref || (*varval) ＞refcount ＜ ) { /* varname是唯一的实际引用 * 或者它是对其它变量的一个完全引用 *任何一种方式 都没有进行分离 */ return *varval; }
这一次 尽管refcount为 却没有实现分离 因为这个值是一个完全引用 引擎能够自由地修改它而不必关心其它变量值的变化
八 分离问题 尽管已经存在上面讨论到的复制和引用技术 但是还存在一些不能通过is_ref和refcount操作来解决的问题 请考虑下面这个PHP代码块
复制代码 代码如下: ＜?php $a = ; $b = $a; $c = $a; ?＞
在 此 你有一个需要与三个不同的变量相关联的值 其中 两个变量是使用了"change on write"完全引用方式 而第三个变量处于一种可分离 的"copy on write"（写复制）上下文中 如果仅使用is_ref和refcount来描述这种关系 有哪些值能够工作呢？ 回答是 没有一个能工作 在这种情况下 这个值必须被复制到两个分离的zval*中 尽管两者都包含完全相同的数据(见图 )
图 引用时强制分离
同样 下列代码块将引起相同的冲突并且强迫该值分离出一个副本(见图 )
图 复制时强制分离
复制代码 代码如下: ＜?php $a = ; $b = $a; $c = $a; ?＞ lishixinzhi/Article/program/PHP/201311/20951
php底层原理 php是如何运行的1、PHP动态语言执行过程：拿到一段代码后，经过词法解析、语法解析等阶段后，源程序会被翻译成一个个指令（opcodes）,然后ZEND虚拟机顺次执行这些指令完成操作。PHP本身是用C实现的，因此最终调用的也是C的函数，实际上，我们可以把PHP看做一个C开发的软件。
2、PHP的4层运行体系：
（1）Zend引擎：Zend整体用纯C实现，是PHP的内核部分，他将PHP代码翻译（词法、语法解析等一系列编译过程）为可执行opcode的处理并实现相应的处理方法、实现了基本的数据结构（如：hashtable、OO）、内存分配机制及管理、提供了相应的api方法供外部调用，是一切的核心，所有的外围功能均围绕Zend实现。
（2）Extensions：围绕着Zend引擎，extensions通过组件式的方式提供各种基础服务，我们常见的各种内置函数（array系列）、标准库等都是通过extension来实现，用户也可以根据需要实现自己的extension的典型应用）。
（3）Sapi：Sapi全称ServerApplicationProgrammingInterface，也就是服务端应用编程接口，Sapi通过一系列钩子函数，使得PHP可以和外围交互数据，这是PHP非常优雅和成功的设计，通过sapi成功的将PHP本身和上层应用解耦隔离，PHP可以不再考虑如何针对不同应用进行兼容，而应用本身也可以针对自己的特点实现不同的处理方式。
（4）上层应用：这就是我们平时编写的PHP程序，通过不同的spai方式得到各种各样的应用模式，如何通过webserver实现web应用、在命令行下已脚本方式运行等等。
PHP的性能探讨和测试缘起
关于PHP 很多人的直观感觉是PHP是一种灵活的脚本语言 库类丰富 使用简单 安全 非常适合WEB开发 但性能低下 PHP的性能是否真 的就如同大家的感觉一样的差呢？本文就是围绕这么一个话题来进行探讨的 从源码 应用场景 基准性能 对比分析等几个方面深入分析PHP之性能问题 并通 过真实的数据来说话
从原理分析PHP性能
从原理分析PHP的性能 主要从以下几个方面 内存管理 变量 函数 运行机制来进行分析
内存管理
类似Nginx的内存管理方式 PHP在内部也是基于内存池 并且引入内存池的生命周期概念 在内存池方面 PHP对PHP脚本和扩展的所有内 存相关操作都进行了托管 对大内存和小内存的管理采用了不同的实现方式和优化 具体可以参考以下文档 在内存分配和回收的生命周期内 PHP采用一次初始化申请+动态扩容+内存标识回收机制 并且在每次请求结束后直 接对内存池进行重新mask
变量
总所周知 PHP是一种弱变量类型的语言 所以在PHP内部 所有的PHP变量都对应成一种类型Zval 其中具体定义如下
图一PHP变量
在变量方面 PHP做了大量的优化工作 比如说Reference counting和copy on writer机制 这样能够保证内存使用上的优化 并且减少内存拷贝次数（请参考） 在数组方面 PHP内部采用高效的hashtable来实现
函数
在PHP内部 所有的PHP函数都回转化成内部的一个函数指针 比如说扩展中函数
ZEND_FUNCTION ( my_function );//类似function my_function(){}
在内部展开后就会是一个函数
void zif_my_function ( INTERNAL_FUNCTION_PARAMETERS );
void zif_my_function(
int ht
zval * return_value
zval * this_ptr
int return_value_used
zend_executor_globals * executor_globals
);
从这个角度来看 PHP函数在内部也是对应一个函数指针
运行机制
在话说PHP性能的时候 很多人都会说“C/C++是编译型 JAVA是半编译型 PHP是解释型” 也就是说PHP是先动态解析再代码运行的 所以从这个角度来看 PHP性能必然很差
的确 从PHP脚本运行来输出 的确是一个动态解析再代码运行的过程 具体来说 PHP脚本的运行机制如下图所示
图二 PHP运行机制
PHP的运行阶段也分成三个阶段
Parse 语法分析阶段
Compile 编译产出opcode中间码
Execute 运行 动态运行进行输出
所以说 在PHP内部 本身也是存在编译的过程 并且据此产生了大量的opcode cache工具 比如说apc eacc xcache等等 这些opcode cache在生产环境基本上在标配 基于opcode cache 能到做到“PHP脚本编译一次 多次运行”的效果 从这点上 PHP就和JAVA的半编译机制非常类似
所以 从运行机制上来看 PHP的运行模式和JAVA是非常类似的 都是先产生中间码 然后运行在不同虚拟机上
动态运行
从上面的几个分析来看 PHP在内存管理 变量 函数 运行机制等几个方面都做了大量的工作 所以从原理来看 PHP 不应该存在性能问题 性能至少也应该和Java 比较接近
这个时候就不得不谈PHP动态语言的特性所带来的性能问题了 由于PHP是动态运行时 所以所有的变量 函数 对象调用 作用域实现等等都是在 执行阶段中才确定的 这个从根本上决定了PHP性能中很难改变的一些东西 在C/C++等能够在静态编译阶段确定的变量 函数 在PHP中需要在动态运行 中确定 也就决定了PHP中间码不能直接运行而需要运行在Zend Engine上
说到PHP变量的具体实现 又不得不说一个东西了 Hashtable Hashtable可以说在PHP灵魂之一 在PHP内部广泛用到 包含变量符号栈 函数符号栈等等都是基于hashtable的
以PHP变量为例来说明下PHP的动态运行特点 比如说代码
<?php
$var = “hello blog xiuwz ”;
?>
该代码的执行结果就是在变量符号栈（是一个hashtable）中新增一个项
当要使用到该变量时候 就去变量符合栈中去查找（也就是变量调用对出了一个hash查找的过程）
同样对于函数调用也基本上类似有一个函数符号栈（hashtable）
其实关于动态运行的变量查找特点 在PHP的运行机制中也能看出一些 PHP代码通过解释 编译后的流程下图
图 PHP运行实例
从上图可以看出 PHP代码在pile之后 产出的了类符号表 函数符号表 和OPCODE 在真正执行的时候 zend Engine会根据op code去对应的符号表中进行查找 处理
从某种程度上 在这种问题的上 很难找到解决方案 因为这是由于PHP语言的动态特性所决定的 但是在国内外也有不少的人在寻找解决方案 因为 通过这样 能够从根本上完全的优化PHP 典型的列子有facebook的hiphop
结论
从上面分析来看 在基础的内存管理 变量 函数 运行机制方面 PHP本身并不会存在明显的性能差异 但由于PHP的动态运行特性 决定了 PHP和其他的编译型语言相比 所有的变量查找 函数运行等等都会多一些hash查找的CPU开销和额外的内存开销 至于这种开销具体有多大 可以通过后 续的基准性能和对比分析得出
因此 也可以大体看出PHP不太适合的一些场景 大量计算性任务 大数据量的运算 内存要求很严格的应用场景 如果要实现这些功能 也建议通过扩展的方式实现 然后再提供钩子函数给PHP调用 这样可以减低内部计算的变量 函数等系列开销
基准性能
对于PHP基准性能 目前缺少标准的数据 大多数同学都存在感性的认识 有人认为 QPS就是PHP的极限了 此外 对于框架的性能和框架对性能的影响很没有响应的权威数字
本章节的目的是给出一个基准的参考性能指标 通过数据给大家一个直观的了解
具体的基准性能有以下几个方面
裸PHP性能 完成基本的功能
裸框架的性能 只做最简单的路由分发 只走通核心功能
标准模块的基准性能 所谓标准模块的基准性能 是指一个具有完整服务模块功能的基准性能
环境说明
测试环境
Uname aPnux db forum test db baidu _ # SMP Wed Aug : : CST x _ x _ x _ GNU/Pnux
Red Hat Enterprise Pnux AS release (Nahant Update )
Intel(R) Xeon(R) CPU E @ GHz
软件相关
Nginx nginx version: nginx/ built by gcc (Red Hat )
Php （采用php fpm）
PHP (cP) (built: Mar : : )
Copyright (c) The PHP Group
Zend Engine v Copyright (c) Zend Technologies
with eAccelerator v Copyright (c) eAccelerator by eAccelerator
bingo
PHP框架
其他说明
目标机器的部署方式 nginx >php fpm >php脚本
测试压力机器和目标机器独立部署
裸PHP性能
最简单的PHP脚本
<?php
require_once ‘ /actions/indexAction php’;
$objAction = new indexAction();
$objAction >init();
$objAction >execute();
?>
Acitons/indexAction php里面的代码如下
<?php
class indexAction
{
pubPc function execute()
{
echo ‘hello world!’;
}
}
?>
通过压力工具测试结果如下
裸PHP框架性能
为了和 的对比 基于bingo 框架实现了类似的功能 代码如下
<?php
require_once ‘Bingo/Controller/Front php’;
$objFrontController = Bingo_Controller_Front::getInstance(array(
‘actionDir’ => ‘ /actions’
));
$objFrontController >dispatch();
压力测试结果如下
从该测试结果可以看出 框架虽然有一定的消耗 但对整体的性能来说影响是非常小的
标准PHP模块的基准性能
所谓标准PHP模块 是指一个PHP模块所必须要具体的基本功能
路由分发
自动加载
LOG初始化Notice日志打印 所以的UI请求都一条标准的日志
错误处理
时间校正
自动计算每个阶段耗时开销
编码识别编码转化
标准配置文件的解析和调用
采用bingo 的代码自动生成工具产生标准的测试PHP模块 test
测试结果如下
结论
从测试数据的结论来看 PHP本身的性能还是可以的 基准性能完全能够达到几千甚至上W的QPS 至于为什么在大多数的PHP模块中表现不佳 其实这个时候更应该去找出系统的瓶颈点 而是简单的说OK PHP不行 那我们换C来搞吧 （下一个章节 会通过一些例子来对比 采用C来处理不见得有特 别的优势）
通过基准数据 可以得出以下几个具体的结论
PHP本身性能也很不错 简单功能下能够达到 QPS 极限也能过W
PHP框架本身对性能影响非常有限 尤其是在有一定业务逻辑和数据交互的情况下 几乎可以忽略
一个标准的PHP模块 基准性能能够达到 QPS（ cpu idle）
对比分析
lishixinzhi/Article/program/PHP/201311/21287
php工作原理PHP的工作原理
：PHP的所有应用程序都是通过WEB服务器(如IIS或Apache)和PHP引擎程序解释执行完成的。
工作过程包括四个方面：
(1)当用户在浏览器地址中输入要访问的PHP页面文件名，然后回车就会触发这个PHP请求，并将请求传送化支持PHP的WEB服务器。
(2)WEB服务器接受这个请求，并根据其后缀进行判断如果是一个PHP请求，WEB服务器从硬盘或内存中取出用户要访问的PHP应用程序，并将其发送给PHP引擎程。
(3)PHP引擎程序将会对WEB服务器传送过来的文件从头到尾进行扫描并根据命令从后台读取，处理数据，并动态地生成相应的HTML页面。
(4)PHP引擎将生成HTML页面返回给WEB服务器。WEB服务器再将HTML页面返回给客户端浏览器。
PHP即“超文本预处理器”，是一种通用开源脚本语言。PHP是在服务器端执行的脚本语言，与C语言类似，是常用的网站编程语言。PHP独特的语法混合了C、Java、Perl以及 PHP 自创的语法。利于学习，使用广泛，主要适用于Web开发领域。
PHP语言作为一种语言程序，其专用性逐渐在应用过程中显现，其技术水平的优劣与否将直接影响网站的运行效率。其特点是具有公开的源代码， 在程序设计上与通用型语言，如C语言相似性较高，因此在操作过程中简单易懂，可操作性强。
PHP命令执行PHP脚本，结束之前，内存会回收吗再详细说下问题：
unix下，用php命令来执行php脚本，在php结束之前，内存有没有机会被回收？新的GC算法有没有机会被调用？
出现这个问题，是因为线上有个 离线数据导入脚本，需要把几千万行数据筛选入库，发现，在执行过程中，到达一定程度，就会抛出 内存使用超过最大值。
1 Fatal error: Allowed memory size of 293601280 bytes exhausted
那第一想到的就是程序是不是有什么bug，造成内存超出，看了半天没有发现问题，于是，突然出现了这个疑问。 那要解决这个疑问，最好的办法就去翻源码吧。
在之前我这么说：
都知道，PHP5.3有了新的垃圾回收机制：GC，它不是重点，不谈它的原理。
经过翻阅PHP源码，发现，调用这个的时机是在 main/main.c ::php_request_shutdown这个函数中，
12 /* 7. Shutdown scanner/executor/compiler and restore ini entries */ zend_deactivate(TSRMLS_C);
php_request_shutdown，通过名字就能看出，它是在php请求结束的时候执行的，在这里会执行 gc_collect_cycles 来清理内存。
其实这句话是没错，但它只针对于SAPI接口（之前我就错在这个地方。），在用PHP命令执行php脚本的时候，是不会执行这个php_request_shutdown的。
那回到最初的问题，过程中到底有没有执行GC呢？
为了更直观有效的知道答案，我选择了最BT，最暴力的方法，拦截gc_collect_cycles，输出error_log到文件，只要执行了，
那肯定会输出log来。
重新编译PHP后，果不其然，符合官方的说法，只要buckets满超过默认值1000，就会启动GC来清理没用的内存，防止内存泄露。
那问 “什么时间 触发的GC呢？”，答 “buckets超过1000的时候啊”，这不屁话嘛，要的是真真正正的执行流程，so。。不断的debug,
不断的grep，不断的step，不断的C+T，终于搞清楚了。下面就来根据官方的说法详细谈谈，PHP到底是怎么触发的。
有一点要注意，PHP的命令入口 和 sapi接口的入口 是不同的，我就载在这个地方，以为都公用一个。
测试代码以官方文档为例：
1234567891011121314 <?phpclass Foo{ public $var = '3.1415962654';} for ( $i = 0; $i <= 1000000; $i++ ){ $a = new Foo; $a->self = $a;} echo memory_get_peak_usage(), "\n";?>
这样的代码，在PHP5.3之前，肯定会造成大量的 内存泄露，不过，谁在开发时又能开发出这么变态的代码来？除非这个人很变态。^.*
那PHP的命令入口是什么？流程又是什么？
主要函数流程如下：
入口main函数（sapi/cli/php_cli.c） ==》php_execute_script(main/main.c)==>zend_execute_scripts(Zend/zend.c)==>execute(Zend/zend_vm_execute.h)
调用GC的地方在execute里。
简单描述下这个过程，
main 是入口，它的作用是根据我们传递的参数做不同的设置，最后会把我们的php脚本作为一个zend_file_handle指针传递给
php_execute_script函数，zend_file_handle其实就是把FILE*做了一下封装，保存了一些其他的文件信息。
php_execute_script会做一些文件检查工作，把php脚本加到 哈希表included_files中。
php_execute_scripts 会执行 zend_compile_file函数来解释我们写的PHP代码，最后执行execute。
应该都知道 Zend把脚本解析完会生成op代码保存到 哈希表：active_op_array中，execute会逐个执行每个op，
op基本上都对应一个ZEND_ASSIGN_*_HANDLER这样的一个宏，它就保存在active_op_array->opline->handlers中。
在进入到 execute之后：
首先初始化execute_data，它保存了很多重要信息，上下文信息，然后调用 ZEND_VM_SET_OPCODE宏，
把execute_data->opline的指针指向active_op_array->opline->handlers。
之后，execute会执行一个while循环，逐条执行opline：
123456789101112131415161718192021222324 while (1) { int ret;#ifdef ZEND_WIN32 if (EG(timed_out)) { zend_timeout(0); }#endif if ((ret = EX(opline)->handler(execute_data TSRMLS_CC)) > 0) { switch (ret) { case 1: EG(in_execution) = original_in_execution; return; case 2: op_array = EG(active_op_array); goto zend_vm_enter; case 3: execute_data = EG(current_execute_data); default: break; } } }
每个handlers都会执行一个宏：ZEND_VM_NEXT_OPCODE()，它意思就是跳到下一个Opline，这样就能逐条执行了。
最后跟踪 上面的PHP代码会执行 ZEND_ASSIGN_SPEC_CV_VAR_HANDLER这个宏，它是干嘛的？他就是 变量赋值
下面代码执行的操作：
1234 class A{ }$a=new A();
这里就会执行 这个宏。
在这个宏里有段代码：
12345678910111213141516171819202122232425262728293031 static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS){ zend_op *opline = EX(opline); zend_free_op free_op2; zval *value = _get_zval_ptr_var(opline->op2, EX(Ts), free_op2 TSRMLS_CC); zval **variable_ptr_ptr = _get_zval_ptr_ptr_cv(opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC); if (IS_CV == IS_VAR !variable_ptr_ptr) { if (zend_assign_to_string_offset(EX_T(opline->op1.u.var), value, IS_VAR TSRMLS_CC)) { if (!RETURN_VALUE_UNUSED(opline->result)) { EX_T(opline->result.u.var).var.ptr_ptr = EX_T(opline->result.u.var).var.ptr; ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr); INIT_PZVAL(EX_T(opline->result.u.var).var.ptr); ZVAL_STRINGL(EX_T(opline->result.u.var).var.ptr, Z_STRVAL_P(EX_T(opline->op1.u.var).str_offset.str)+EX_T(opline->op1.u.var).str_offset.offset, 1, 1); } } else if (!RETURN_VALUE_UNUSED(opline->result)) { AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr)); PZVAL_LOCK(EG(uninitialized_zval_ptr)); } } else { value = zend_assign_to_variable(variable_ptr_ptr, value, 0 TSRMLS_CC); if (!RETURN_VALUE_UNUSED(opline->result)) { AI_SET_PTR(EX_T(opline->result.u.var).var, value); PZVAL_LOCK(value); } } /* zend_assign_to_variable() always takes care of op2, never free it! */ if (free_op2.var) {zval_ptr_dtor(free_op2.var);}; ZEND_VM_NEXT_OPCODE();}
free_op2.var保存的是 new A的对象.
free_op2.var这个是哪儿来的呢?
在整个execute期间,维持一个 execute_data结构,里面有个 Ts指针
1 union _temp_variable *Ts;
它用来保存一些临时的变量信息,比如 new A(),这个会保存到Ts链表里,
opline->op2.u.var这个里面保存了此临时变量所在的位置,然后Ts+这个值是一个zval*指针,它就保存了new A产生的对象.
在代码中
1 if (free_op2.var) {zval_ptr_dtor(free_op2.var);};
zval_ptr_dtor会根据free_op2.var的值执行到 Zend/zend_execute_API.c::_zval_ptr_dtor函数中,
1234567891011121314151617181920212223242526 ZEND_API void _zval_ptr_dtor(zval **zval_ptr ZEND_FILE_LINE_DC) /* {{{ */{ zval *zv = *zval_ptr; #if DEBUG_ZEND>=2 printf("Reducing refcount for %x (%x): %d->%d\n", *zval_ptr, zval_ptr, Z_REFCOUNT_PP(zval_ptr), Z_REFCOUNT_PP(zval_ptr) - 1);#endif Z_DELREF_P(zv); if (Z_REFCOUNT_P(zv) == 0) { TSRMLS_FETCH(); if (zv != EG(uninitialized_zval)) { GC_REMOVE_ZVAL_FROM_BUFFER(zv); zval_dtor(zv); efree_rel(zv); } } else { TSRMLS_FETCH(); if (Z_REFCOUNT_P(zv) == 1) { Z_UNSET_ISREF_P(zv); } GC_ZVAL_CHECK_POSSIBLE_ROOT(zv); }}
GC_ZVAL_CHECK_POSSIBLE_ROOT(zv);
它就是最终GC算法执行的地方.
gc_collect_cycles就在这个宏中执行了..
所以..
回到上面的问题,
php无论在SAPI接口或命令端,都会执行 GC算法来进行垃圾内存回收.
关于php内存回收原理的介绍到此就结束了，不知道本篇文章是否对您有帮助呢？如果你还想了解更多此类信息，记得收藏关注本站，我们会不定期更新哦。
查看更多关于php内存回收原理 php内存管理机制和垃圾回收机制的详细内容...