PHP编译特点
编译型语言
对于C语言，C++，编译成机器码(二进制)来运行。
Java语言，把.java 编译成.class， 称为bytecode(字节码)，由jvm来运行 解释型语言
解释器解释执行。 典型的如： linux shell
解释器逐行来执行命令
PHP执行
PHP是先编译后执行
PHP稍有特殊，虽然是一个脚本语言，但不是靠解释器解释。而是zend虚拟机执行，屏蔽了操作系统的区别。
PHP代码编译成 opcode，由zend虚拟机来执行opcode。
但是opcode ,PHP脚本一结束，opcode就清除了。
opcode 能否缓存
PHP本身不支持，但是apc，xcache等加速器，实现了这样的效果。
变量的底层实现
PHP底层是C语言来实现的，C语言是强类型，而PHP是弱类型语言，是如何实现的
PHP的源码包：
|__ ext|__ main|__ pear|__ sapi|__ tests|__ TSRM|__ Zend|__ .gdbinit
最核心的是Zend,这是zend虚拟的实现。包括栈，数据类型，编译器等.
main，PHP的一些内建函数，最重要的函数都在该目录下.最大的一个目录 ext， PHP的扩展. PHP的大部分功能，都是以extenstion形式来完成的。
如果自身开发了一个扩展，也放入ext目录下。弱类型语言变量的实现
/* zend.h */struct _zval_struct { zvalue_value value; /* 值 */ zend_uint refcount__gc; zend_uchar type; /* 活动类型 */ zend_uchar is_ref__gc; } PHP中的一个变量，zend虚拟机中，使用的是 _zval_struct 的结构体来描述，变量的值也是一个就结构体来描述.
_zval_struct的结构体是由 四个字段/域 (可以理解成关联数组)
zvalue_value value; /* 值 */
PHP变量的值，存储这个字段中。
具体存储的位置：
/* value 值 是一个 联合 *//* zend.h */typedef union _zval_value { long lval; /* long value */ double dval; /* double value */ struct { char * val; int len; } str; HashTable *ht; /* hash table 指针 */ zend_object_value obj;} zvalue_value; Zend对变量的表示
zend实现了 zval结构体
{ value: [联合体] /* 联合体的内容可能是C语言中的long,double,hashtable(*ht),obj, 联合体只能是其中一种类型，是一个枚举 */ type: 变量类型 , /* IS_NULL,IS_BOOL,IS_STRING, IS_LONG,IS_DOUBLE,IS_ARRAY,IS_OBJECT,IS_RESOURCE */ refcount_gc is_ref_gc } C语言中类型对应PHP中的数据类型：
long -> intdouble -> doublehashtable -> arraystruct -> stringobj -> object
例如：
$a = 3;{ value: [long lval = 3] type: IS_LONG}$a = 3.5;{ value: [double dval = 3.5] type: IS_DOUBLE} 变量类型的实现
zend_uchar type; /* 活动类型 */
可以根据上下文环境来强制转换。
例如：需要echo 的时候 就转换成 string需要加减运算就 转换成 intPHP 中有8中数据类型，为什么zval->value 联合体中，只有5中 ?
1: NULL，直接 zval->type = IS_NULL, 就可以表示，不必设置 value 的值。2：BOOL， zval->type = IS_BOOL. 再设置 zval.value.lval = 1/0; (C语言中没有布尔值，都是通过1，0，来表示)3: resource ，资源型，往往是服务器上打开一个接口，如果 文件读取接口。 zval->type = IS_RESOURCE, zval->type.lval = 服务器上打开的接口编号。struct { char * val; int len;} str; PHP中，字符串类型，长度是已经缓存的，调用strlen时，系统可以直接返回其长度，不需要计算。
$b = 'hello';/** * * { * union_zvalue { * // 字符串的指针 * struct{ * char: 'hello'; * len: 5 * } str; * } * type: IS_STRING; * refcount_gc: 1, * is_ref_gc: 0 * } * */ //在PHP中字符串的长度，是直接体现在其结构体中,所以调用strlen(); 速度非常快，时间复杂度为0(1)echo strlen($b); 符号表
符号表symbol_table，变量的花名册
符号表是什么?
符号表示一张哈希表(哈希结构理解成关联数组)
里面存储了变量名-> 变量zval结构体的地址struct _zend_executor_globals { ... ... HashTable * active_symbol_table /* 活动符号表 */ HashTable symbol_table /* 全局符号表 */ HashTable included_files; /* files already included */} // 变量花名册$a = 3;$b = 1.223;$c = 'hello';/** * * 生成了3个结构体 * 同时，全局符号表，中多了三条记录 * * a ---> 0x123 ---> 结构体 { 3 } * b ---> 0x21a ---> 结构体 { 1.223 } * c ---> 0x1A0 ---> 结构体 { hello } * */ // 变量声明 // 第一：结构体生成 // 第二：符号表中多了记录，变量的花名册 // 第三：指向结构体 传值赋值
传值赋值发生了什么
在传值赋值时：
以：$a = 3; $b = $a;为例：并没有再次产生结构体，而是2个变量共用1个结构体此时，2个变量，指向同1个结构体refcount_gc 值为 2 (如果没有指针指引，会有垃圾回收机制清除)
写时复制
cow写时复制特性
$a = 3;$b = $a;/** * * 是否产生了2 个结构体? * 不是，共用1个， refcount_gc = 2; * */$b = 5;echo $a, $b; // 3, 5// $a,$b 指向同一个结构体，那么，修改$b或$a，对方会不会受干扰 ? 没有干扰到对方。具有写时复制的特性
如果有一方修改，将会造成结构体的分裂
结构体一开始共用，到某一方要修改值时，才分裂。这种特性称为：COW 。Copy On Write。
引用赋值
引用赋值发生了什么
当引用赋值时，双方共用一个结构体(is_ref_gc=1)
关系图例展示：
强制分裂
1 的过程中(从0到1,表示想引用变量)。refcount_gc>1。多个变量共享一个变量值。将会产生强制分裂/** * // $a $c 结构体 * { * value: 3; * type: IS_LONG; * refcount_gc: 2; * is_ref_gc: 1; * } * * // $b 结构体 * { * value: 3; * type: IS_LONG; * refcount_gc: 1; * is_ref_gc: 0; * } * */ $c = 5;// a c/** * value: 5 * type: IS_LONG; * refcount_gc: 2; * is_ref_gc: 1; */ // b/** * value: 3 * type: IS_LONG; * refcount_gc: 1; * is_ref_gc: 0; */ echo $a, $b, $c; // 5 , 3 , 5 引用数组时的一些奇怪现象
// 引用数组时的怪现象 $arr = array(0, 1, 2, 3);$tmp = $arr;$arr[1] = 11;echo $tmp[1]; // 1// 数组不会比较细致的检查，多维数组存在。 因此，判断的时候，只会判断外面 一层的 结构体。
数组不会比较细致的检查
// 先 引用 后 赋值$arr = array(0, 1, 2, 3);$x = &$arr[1];$tmp = $arr;$arr[1] = 999;echo $tmp[1]; // 999 . hash表中的zvalue结构体中会变成引用类型。 // 只去关注外面一层结构体，而不去关注 hash表中的值。echo '';// 先赋值，后引用$arr = array(0, 1, 2, 3);$tmp = $arr;$x = &$arr[1];$arr[1] = 999;echo $tmp[1]; // 1
循环数组
循环数组时的怪现象
// 循环数组时的怪现象$arr = array(0, 1, 2, 3);foreach ( $arr as $v ) { }var_dump(current($arr)); // 数组指针停留在数组结尾处， 取不到值. falseecho '';$arr = array(0, 1, 2, 3);foreach ( $arr as $val=>$key ) { // foreach 使用的 $arr 是 $arr的副本. $arr[$key] = $val; // 修改之后，就会产生分裂。 foreach 遍历的是 $arr 的副本。 但是原数组的指针已经走了一步. } var_dump(current($arr)); // 1 $arr = array('a', 'b', 'c', 'd');foreach ( $arr as &$val ) { // 该foreach 会导致 $val = &$arr[3]; }foreach ( $arr as $val ) { print_r($arr); echo '';}// 两个问题： // 数组使用时，要慎用引用。// foreach 使用后，不会把数组的内部指针重置, 使用数组时，不要假想内部指针指向数组头部. 也可以在foreach 之后 reset(); 指针。 符号表与作用域
当执行到函数时，会生成函数的“执行环境结构体”，包含函数名，参数，执行步骤，所在的类（如果是方法），以及为这个函数生成一个符号表。
符号表统一放在栈上，并把active_symbol_table指向刚产生的符号表。// Zend/zend_compiles.h 文件中// 源码：struct _zend_execute_data { struct _zend_op *opline; zend_function_state function_state; zend_op_array *op_array; zval *object; HashTable *symbol_table; struct _zend_execute_data *prev_execute_data; zval *old_error_reporting; zend_bool nested; zval **original_return_value; zend_class_entry *current_scope; zend_class_entry *current_called_scope; zval *current_this; struct _zend_op *fast_ret; /* used by FAST_CALL/FAST_RET (finally keyword) */ zval *delayed_exception; call_slot *call_slots; call_slot *call;}; // 简化：struct _zend_execute_data { ... zend_op_array *op_array; // 函数的执行步骤. 如果是函数调用。是函数调用的后的opcode HashTable *symbol_table; // 此函数的符号表地址 zend_class_entry *current_scope; // 执行当前作用域 zval * current_this; // 对象 调用 this绑定 zval * current_object; // object 的指向 ...} 
一个函数调用多次，会有多少个*op_array ?
*op_array. 调用多次，会产生多个 环境结构体， 会依次入栈，然后顺序执行。调用多少次，就会入栈多少次。不同的执行环境，靠 唯一的 *op_array 来执行。 函数什么时候调用， 函数编译后的 opcode 什么时候执行。
$age = 23;function t() { $age = 3; echo $age;}t();/** * t 函数 在执行时，根据函数的参数，局部变量等，生成一个执行环境结构体。 * 结构体 入栈，函数编译后的 opcode， 称为 op_array （就是执行逻辑）。开始执行， 以入栈的环境结构体为环境来执行。 * 并生成此函数的 符号表， 函数寻找变量， 就在符号表中寻找。即局部变量。(一个环境结构体，就对应一张符号表) * * * 注意： 函数可能调用多次。栈中可能有某函数的多个执行环境 入栈。但是 op_array 只有一个。 * */ 静态变量
静态变量的实现
// Zend/zend_compile.h struct _zend_op_array { /* Common elements */ zend_uchar type; const char *function_name; zend_class_entry *scope; zend_uint fn_flags; union _zend_function *prototype; zend_uint num_args; zend_uint required_num_args; zend_arg_info *arg_info; /* END of common elements */ zend_uint *refcount; zend_op *opcodes; zend_uint last; zend_compiled_variable *vars; int last_var; zend_uint T; zend_uint nested_calls; zend_uint used_stack; zend_brk_cont_element *brk_cont_array; int last_brk_cont; zend_try_catch_element *try_catch_array; int last_try_catch; zend_bool has_finally_block; /* static variables support */ HashTable *static_variables; zend_uint this_var; const char *filename; zend_uint line_start; zend_uint line_end; const char *doc_comment; zend_uint doc_comment_len; zend_uint early_binding; /* the linked list of delayed declarations */ zend_literal *literals; int last_literal; void **run_time_cache; int last_cache_slot; void *reserved[ZEND_MAX_RESERVED_RESOURCES];}; // 简化struct _zend_op_array { ... HashTable *static_variables; // 静态变量 ...} 编译后的 op_array 只有一份。 静态变量并没有存储在符号表(symbol_table)中.而是存放在op_array中。
function t() { static $age = 1; return $age += 1; }echo t();echo t();echo t();// 静态变量 不再和 执行的结构体， 也不再和 入栈的符号表有关。 
常量
// Zend/zend_constants.h// 常量结构体 typedef struct _zend_constant { zval value; // 变量结构体 int flags; // 标志，是否大小写敏感等 char *name; // 常量名 uint name_len; // int module_number; // 模块名} zend_constant; define函数的实现
define函数当然是 调用zend_register_constant声明的常量
具体如下：Zend/zend_builtin_functions.c// 源码：
ZEND_FUNCTION(define){ char *name; int name_len; zval *val; zval *val_free = NULL; zend_bool non_cs = 0; int case_sensitive = CONST_CS; zend_constant c; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|b", &name, &name_len, &val, &non_cs) == FAILURE) { return; } if(non_cs) { case_sensitive = 0; } /* class constant, check if there is name and make sure class is valid & exists */ if (zend_memnstr(name, "::", sizeof("::") - 1, name + name_len)) { zend_error(E_WARNING, "Class constants cannot be defined or redefined"); RETURN_FALSE; }repeat: switch (Z_TYPE_P(val)) { case IS_LONG: case IS_DOUBLE: case IS_STRING: case IS_BOOL: case IS_RESOURCE: case IS_NULL: break; case IS_OBJECT: if (!val_free) { if (Z_OBJ_HT_P(val)->get) { val_free = val = Z_OBJ_HT_P(val)->get(val TSRMLS_CC); goto repeat; } else if (Z_OBJ_HT_P(val)->cast_object) { ALLOC_INIT_ZVAL(val_free); if (Z_OBJ_HT_P(val)->cast_object(val, val_free, IS_STRING TSRMLS_CC) == SUCCESS) { val = val_free; break; } } } /* no break */ default: zend_error(E_WARNING,"Constants may only evaluate to scalar values"); if (val_free) { zval_ptr_dtor(&val_free); } RETURN_FALSE; } c.value = *val; zval_copy_ctor(&c.value); if (val_free) { zval_ptr_dtor(&val_free); } c.flags = case_sensitive; /* non persistent */ c.name = str_strndup(name, name_len); if(c.name == NULL) { RETURN_FALSE; } c.name_len = name_len+1; c.module_number = PHP_USER_CONSTANT; if (zend_register_constant(&c TSRMLS_CC) == SUCCESS) { RETURN_TRUE; } else { RETURN_FALSE; }} // 关键代码：c.value = *val;zval_copy_ctor(&c.value);if (val_free) { zval_ptr_dtor(&val_free);}c.flags = case_sensitive; /* 大小写敏感 */c.name = str_strndup(name, name_len);if(c.name == NULL) { RETURN_FALSE;}c.name_len = name_len+1;c.module_number = PHP_USER_CONSTANT; /* 用户定义常量 */if (zend_register_constant(&c TSRMLS_CC) == SUCCESS) { RETURN_TRUE;} else { RETURN_FALSE;} 常量就一个符号(哈希)表. 都使用一个符号表。所以全局有效。
常量的生成
int zend_register_constant(zend_constant *c TSRMLS_DC) { ... ... zend_hash_add(EG(zend_constants), name, c->name_len, (vaid*)c,sizeof(zend_constant, NULL) == FAILURE); ... ...} 对象定义常量
class Dog { public $name = 'kitty'; public function __toString () { return $this->name; } }$dog = new Dog();define('DOG', $dog);print_r(DOG);/** * define 值为对象时，会把对象装成标量来存储，需要类有 __toString魔术方法 */ 对象
对象的底层实现
Zend/zend.h
struct _zval_struct { /* Variable information */ zvalue_value value; /* value */ zend_uint refcount__gc; zend_uchar type; /* active type */ zend_uchar is_ref__gc;};// zvaluetypedef union _zvalue_value { long lval; /* long value */ double dval; /* double value */ struct { char *val; int len; } str; HashTable *ht; /* hash table value */ zend_object_value obj; zend_ast *ast;} zvalue_value;// 在 zend.h 中 查看到 `zend_object_value obj;` 是以zend_object_value 定义. 在Zend/zend_types.h 文件中继续查看// Zend/zend_types.h 定义zend_object_value 结构体
typedef struct _zend_object_value { zend_object_handle handle; const zend_object_handlers *handlers;} zend_object_value; 通过new出来的对象，返回的是什么。是zend_object_value. 并不是真正的对象，而是对象的指针。
返回的 handle再次指向对象。
每次new一个对象，对象就存入一张hash表中。(形象的称之为对象池)
对象存储时的特点：
// 对象class Dog { public $leg = 4; public $wei = 20;}$dog = new Dog();// $dog 是一个对象么?// 严格说，并不是对象./** * { * handle --指向--> [hash表 {leg: 4, wei: 20}] // hash表中存在 对象 * } */ $d2 = $dog;$d2->leg = 5;echo $dog->leg, '`', $d2->leg; // 5`5// 对象并不是 引用赋值. 主要原因 zval 结构体 是再次指向一个hash表中的 对象池$d2 = false;echo $dog->leg; // 5 
内存分层
内存管理与垃圾回收
PHP封装了对系统内存的请求
不要直接使用malloc直接请求内存
PHP函数需要内存的时候，是通过emalloc,efree.
emalloc,efree向 mm_heap索要空间。zend 中底层都离不开hash表。PHP中的HashTable太强大。
PHP 底层 所有的变量都是 放在 zend_mm_heap 中。 然后通过 各自的hash表来指向或跟踪。
zend虚拟机的运行原理
-
PHP语法实现
Zend/zend_language_scanner.lZend/zend_language_parser.y
-
OPcode编译
Zend/zend.compile.c
-
执行引擎
Zend/zend_vm_*Zend/zend_execute.c
以apache模块运行时的流程
