Archive for the ‘PHP’ Category

c java php 语言性能对比

同一台服务器测试

C      0.04 秒

Java   0.21 秒

PHP  2.06  秒

由此可算出 C 是 java性能的5倍,Java 是 PHP 性能的10倍

C

#include <stdio.h>
#include <sys/time.h>

#define BAILOUT 16
#define MAX_ITERATIONS 1000

int mandelbrot(double x, double y)
{
	double cr = y - 0.5;
	double ci = x;
	double zi = 0.0;
	double zr = 0.0;
	int i = 0;

	while(1) {
		i ++;
		double temp = zr * zi;
		double zr2 = zr * zr;
		double zi2 = zi * zi;
		zr = zr2 - zi2 + cr;
		zi = temp + temp + ci;
		if (zi2 + zr2 > BAILOUT)
			return i;
		if (i > MAX_ITERATIONS)
			return 0;
	}

}

int main (int argc, const char * argv[]) {
	struct timeval aTv;
	gettimeofday(&aTv, NULL);
	long init_time = aTv.tv_sec;
	long init_usec = aTv.tv_usec;

	int x,y;
	for (y = -39; y < 39; y++) {
		printf("\n");
		for (x = -39; x < 39; x++) {
			int i = mandelbrot(x/40.0, y/40.0);
			if (i==0)
				printf("*");
			else
				printf(" ");
		}
	}
	printf ("\n");

	gettimeofday(&aTv,NULL);
	double query_time = (aTv.tv_sec - init_time) + (double)(aTv.tv_usec - init_usec)/1000000.0;
	printf ("C Elapsed %0.2f\n", query_time);
    return 0;
}

Java

import java.util.*;

class Mandelbrot
{
	static int BAILOUT = 16;
	static int MAX_ITERATIONS = 1000;

	private static int iterate(float x, float y)
	{
		float cr = y-0.5f;
		float ci = x;
		float zi = 0.0f;
		float zr = 0.0f;
		int i = 0;
		while (true) {
			i++;
			float temp = zr * zi;
			float zr2 = zr * zr;
			float zi2 = zi * zi;
			zr = zr2 - zi2 + cr;
			zi = temp + temp + ci;
			if (zi2 + zr2 > BAILOUT)
				return i;
			if (i > MAX_ITERATIONS)
				return 0;
		}
	}

	public static void main(String args[])
	{
		Date d1 = new Date();
		int x,y;
		for (y = -39; y < 39; y++) {
			System.out.print("\n");
			for (x = -39; x < 39; x++) {
				if (iterate(x/40.0f,y/40.0f) == 0)
					System.out.print("*");
				else
					System.out.print(" ");

			}
		}
		Date d2 = new Date();
		long diff = d2.getTime() - d1.getTime();
		System.out.println("\nJava Elapsed " + diff/1000.0f);

	}
}

PHP

<?php
define("BAILOUT",16);
define("MAX_ITERATIONS",1000);

class Mandelbrot
{

	function Mandelbrot()
	{
		$d1 = microtime(1);
		for ($y = -39; $y < 39; $y++) {
			echo("\n");
			for ($x = -39; $x < 39; $x++) {
				if ($this->iterate($x/40.0,$y/40.0) == 0)
					echo("*");
				else
					echo(" ");

			}
		}
		$d2 = microtime(1);
		$diff = $d2 - $d1;
		printf("\nPHP Elapsed %0.2f", $diff);
	}

	function iterate($x,$y)
	{
		$cr = $y-0.5;
		$ci = $x;
		$zi = 0.0;
		$zr = 0.0;
		$i = 0;
		while (true) {
			$i++;
			$temp = $zr * $zi;
			$zr2 = $zr * $zr;
			$zi2 = $zi * $zi;
			$zr = $zr2 - $zi2 + $cr;
			$zi = $temp + $temp + $ci;
			if ($zi2 + $zr2 > BAILOUT)
				return $i;
			if ($i > MAX_ITERATIONS)
				return 0;
		}

	}

}

$m = new Mandelbrot();
?>

PHP APC配置

配置参数如下:
./configure –enable-apc –enable-apc-spinlocks –disable-apc-pthreadmutex
安装过程就不说了, 标准的php扩展安装模式.

2套配置文件

性能高, 不适合频繁更新:
apc.enabled=1
apc.stat = 0
apc.stat_ctime = 0
apc.shm_size = 64M
apc.shm_segments = 1
apc.num_files_hint = 1000
apc.ttl = 0
apc.slam_defense = 0
apc.write_lock = 1
apc.file_update_protection = 2

性能稍低
apc.enabled=1
apc.stat = 1
apc.stat_ctime = 1
apc.shm_size = 64M
apc.shm_segments = 1
apc.num_files_hint = 1000
apc.ttl = 86400
apc.slam_defense = 0
apc.write_lock = 1
apc.file_update_protection = 2

2套配置关键在于apc.stat, 开启后APC将不会检查文件是否更新, 这样可以减少大量不必要的系统调用.
但是, 对于新发布的问题 需要重新启动PHP. 可以根据情况选择.

另外, 附上参数说明:

apc.enabled boolean
apc.enabled 可以设成 0 来禁用 APC.主要是用在当 APC 被静态编译入 PHP 时,因为没有其它方法来禁用了(编译为 DSO , 的时候,可以将php.ini中的extension 行注释掉)。

apc.shm_segments integer

编译器缓存要分配的共享内存块的数目。如果 APC 用光了共享内存但是已经将 apc.shm_size 设为了系统所能允许的最大值,可以尝试增大此值。

apc.shm_size integer

以 MB 为单位的每个共享内存块的大小。默认时,有些系统(包括大多数 BSD 变种)的共享内存块大小非常低。

apc.optimization integer

优化级别。设为 0 则禁用优化器,更高的值则使用更主动的优化。期望非常有限的速度提升。尚在试验中。

apc.num_files_hint integer

Web 服务器上的被包含或被请求的不同源文件的数目的大概估计。如果不确定则设为 0 或去掉此项;此设定主要用在有数千个源文件的站点。

apc.user_entries_hint integer

与apc.num_files_hint类似, 根据唯一用户数来存储缓存变量。 如果不能确定则设置为0或或去掉此项。

apc.ttl integer

缓存条目在缓冲区中允许逗留的秒数。0 表示永不超时。建议值为7200~86400 设为 0 意味着缓冲区有可能被旧的缓存条目填满,从而导致无法缓存新条目。

apc.user_ttl integer

类似于apc.ttl,只是针对每个用户而言,建议值为7200~86400。 设为 0 意味着缓冲区有可能被旧的缓存条目填满,从而导致无法缓存新条目。 如果大于0,APC将尝试删除过期条目。

apc.gc_ttl integer

缓存条目在垃圾回收表中能够存在的秒数。此值提供了一个安全措施,即在服务器进程在执行缓存的源文件时,如果该文件被修改则旧版本将不会被回收,直到达到此 TTL 为止。设为零将禁用此特性。

apc.cache_by_default boolean

默认为 on,但可以设为 off 并和加号开头的 apc.filters 一起用,则文件仅在匹配过滤器时被缓存。

apc.filters string

一个以逗号分隔的 POSIX 扩展正则表达式的列表。如果任一个模式匹配源文件名,则该文件不被缓存。注意用来匹配的文件名是传递给 include/require 的文件名,而不是绝对路径。如果正则表达式的第一个字符是+ t则意味着任何匹配表达式的文件会被缓存,如果第一个字符是 - 则任何匹配项都不会被缓存。 -是默认值,可以省略掉。

apc.mmap_file_mask string

如果使用 –enable-mmap(默认启用)为APC编译了MMAP支持, 这里的值就是传递给mmap模块的mktemp风格的文件掩码(建议值为” /tmp/apc.XXXXXX“)。 该掩码用于决定内存映射区域是否要被file-backed或者shared memory backed。 对于直接的file-backed内存映射,要设置成”/tmp/apc.XXXXXX”的样子(恰好6个X)。 要使用POSIX风格的shm_open/mmap就需要设置成”/apc.shm.XXXXXX”的样子。 你还可以设为”/dev/zero”来为匿名映射的内存使用内核的”/dev/zero”接口。 不定义此指令则表示强制使用匿名映射。

apc.slam_defense integer

在非常繁忙的服务器上,无论是启动服务还是修改文件, 都可能由于多个进程企图同时缓存一个文件而导致竞争条件。 这个选项用于设置进程在处理未被缓存的文件时跳过缓存步骤的百分率。 比如设为75表示在遇到未被缓存的文件时有75%的概率不进行缓存,从而减少碰撞几率。 反对使用该指令,鼓励设为 0来禁用这个特性。建议该用apc.write_lock指令。

Deprecated by apc.write_lock.

apc.file_update_protection integer

当你在一个运行中的服务器上修改文件时,你应当执行原子操作。 也就是先写进一个临时文件,然后将该文件重命名(mv)到最终的名字。 文本编辑器以及 cptar 等程序却并不是这样操作的,从而导致有可能缓冲了残缺的文件。 默认值 2 表示在访问文件时如果发现修改时间距离访问时间小于 2 秒则不做缓冲。 那个不幸的访问者可能得到残缺的内容,但是这种坏影响却不会通过缓存扩大化。 如果你能确保所有的更新操作都是原子操作,那么可以用 0 关闭此特性。 如果你的系统由于大量的IO操作导致更新缓慢,你就需要增大此值。

apc.enable_cli integer

是否为CLI版本启用APC功能,仅用于测试和调试目的才打开此选项。 在正常情况下不是理想的创建、 填充和销毁 CLI 的每个请求上的 APC 缓存,但各种测试方案很有用,能够轻松地使 CLI 版本的 PHP APC

apc.max_file_size integer

默认1M, 对于大于此值的文件将不进行缓存.

apc.stat integer

是否启用脚本更新检查。 改变这个指令值要非常小心。 默认值 On 表示APC在每次请求脚本时都检查脚本是否被更新, 如果被更新则自动重新编译和缓存编译后的内容。但这样做对性能有不利影响。 如果设为 Off 则表示不进行检查,从而使性能得到大幅提高。 但是为了使更新的内容生效,你必须重启Web服务器(译者注:如果采用cgi/fcgi类似的,需重启cgi/fcgi进程)。 生产服务器上脚本文件很少更改, 可以通过禁用本选项获得显著的性能提升。

这个指令对于include/require的文件同样有效。但是需要注意的是, 如果你使用的是相对路径,APC就必须在每一次include/require时都进行检查以定位文件。 而使用绝对路径则可以跳过检查,所以鼓励你使用绝对路径进行include/require操作。

apc.write_lock boolean

在繁忙的服务器上,Web服务器第一次被启动,或者很多文件在同一时间被修改,APC可能会多次编译同一个文件,写锁保证只有一个进程将尝试编译并缓存未缓存的脚本。其他进程试图使用该脚本将不使用opcode缓存,而不是锁定和等待缓存生成。

apc.report_autofilter boolean

是否记录所有由于early/late binding原因而自动未被缓存的脚本。

apc.include_once_override boolean

优化include_once()和require_once()函数以避免执行额外的系统调用。

apc.rfc1867 boolean
开启监控文件上传进度功能

apc.rfc1867_prefix string
用于上传文件的缓冲项条目名称前缀

apc.rfc1867_name string

需要由APC处理的上传文件的隐藏表单项名称

apc.rfc1867_freq string

用户上传文件缓存项的更新频率。 取值可以是总文件大小的百分比,或者以 “k”“m”, or “g” kilobytes, megabytes, or gigabytes 结尾的绝对尺寸 (大小写不敏感). 0 表示尽可能快的更新,不过这样可能会导致上传速度下降。

apc.rfc1867_ttl bool

TTL for rfc1867 entries.

apc.localcache boolean

使用非锁定本地进程shadow-cache ,它可以减少了向缓冲区写入时锁之间的竞争。

apc.localcache.size integer

The size of the local process shadow-cache, should be set to a sufficiently large value, approximately half of apc.num_files_hint.

apc.coredump_unmap boolean

启用APC的信号句柄,例如SIGSEGV信号,当信号写入核心文件。当这些信号被接收,APC将试图取消映射的共享内存段,从核心文件中排除它。此设置可以提高系统的稳定性,当接受到致命的信号或者采用APC的大型共享内存段配置方式。

apc.stat_ctime integer
验证ctime(创建时间)可以避免SVN或者rsync带来的问题,确保自上次统计inode没有改变。APC通常只检查mtime(修改时间)。

apc.canonicalize bool

如果设置为on,则在no-state 模式(不检查文件更新)时会将相对路径改为绝对路径。

apc.preload_path string

apc.use_request_time bool

Use the SAPI request start time for TTL.

apc.file_md5 bool

记录文件的md5值

apc.lazy_functions integer

启用函数延迟加载

apc.lazy_classes integer

启用类延迟加载

nginx php mysql 需要安装的扩展包

129  yum install gcc
134  yum install ncurses
135  yum install glibc-headers
136  yum install gcc-c++
142  yum -y install libxml2 libxml2-devel
143  yum install curl curl-devel
144  yum install openssl openssl-devel
145  yum install bzip2 bzip2-devel
146  yum install libjpeg libjpeg-devel
147  yum install libpng libpng-devel
148  yum install freetype-devel
149  yum install gmp-devel
150  yum install libmcrypt libmcrypt-devel
163  yum -y install pcre pcre-devel

php-fpm configure

./configure –prefix=/usr/local/php –with-config-file-path=/usr/local/php/etc –enable-fpm –with-fpm-user=administrator –with-fpm-group=administrator –enable-safe-mode

rc4 加密类

<?php
/*
* By julying.com
*/
define(‘CRYPT_RC4_MODE_INTERNAL’, 1);
define(‘CRYPT_RC4_MODE_MCRYPT’, 2);
define(‘CRYPT_RC4_ENCRYPT’, 0);
define(‘CRYPT_RC4_DECRYPT’, 1);
class Crypt_RC4 {
/**
* The Key
*
* @see Crypt_RC4::setKey()
* @var String
* @access private
*/
var $key = “\0″;
/**
* The Key Stream for encryption
*
* If CRYPT_RC4_MODE == CRYPT_RC4_MODE_MCRYPT, this will be equal to the mcrypt object
*
* @see Crypt_RC4::setKey()
* @var Array
* @access private
*/
var $encryptStream = false;
/**
* The Key Stream for decryption
*
* If CRYPT_RC4_MODE == CRYPT_RC4_MODE_MCRYPT, this will be equal to the mcrypt object
*
* @see Crypt_RC4::setKey()
* @var Array
* @access private
*/
var $decryptStream = false;
/**
* The $i and $j indexes for encryption
*
* @see Crypt_RC4::_crypt()
* @var Integer
* @access private
*/
var $encryptIndex = 0;
/**
* The $i and $j indexes for decryption
*
* @see Crypt_RC4::_crypt()
* @var Integer
* @access private
*/
var $decryptIndex = 0;
/**
* MCrypt parameters
*
* @see Crypt_RC4::setMCrypt()
* @var Array
* @access private
*/
var $mcrypt = array(”, ”);
/**
* The Encryption Algorithm
*
* Only used if CRYPT_RC4_MODE == CRYPT_RC4_MODE_MCRYPT.  Only possible values are MCRYPT_RC4 or MCRYPT_ARCFOUR.
*
* @see Crypt_RC4::Crypt_RC4()
* @var Integer
* @access private
*/
var $mode;
/**
* Default Constructor.
*
* Determines whether or not the mcrypt extension should be used.
*
* @param optional Integer $mode
* @return Crypt_RC4
* @access public
*/
var $continuousBuffer ;
function Crypt_RC4()
{
if ( !defined(‘CRYPT_RC4_MODE’) ) {
switch (true) {
case extension_loaded(‘mcrypt’) && (defined(‘MCRYPT_ARCFOUR’) || defined(‘MCRYPT_RC4′)):
// i’d check to see if rc4 was supported, by doing in_array(‘arcfour’, mcrypt_list_algorithms(”)),
// but since that can be changed after the object has been created, there doesn’t seem to be
// a lot of point…
define(‘CRYPT_RC4_MODE’, CRYPT_RC4_MODE_MCRYPT);
break;
default:
define(‘CRYPT_RC4_MODE’, CRYPT_RC4_MODE_INTERNAL);
}
}
switch ( CRYPT_RC4_MODE ) {
case CRYPT_RC4_MODE_MCRYPT:
switch (true) {
case defined(‘MCRYPT_ARCFOUR’):
$this->mode = MCRYPT_ARCFOUR;
break;
case defined(‘MCRYPT_RC4′);
$this->mode = MCRYPT_RC4;
}
}
}
/**
* Sets the key.
*
* Keys can be between 1 and 256 bytes long.  If they are longer then 256 bytes, the first 256 bytes will
* be used.  If no key is explicitly set, it’ll be assumed to be a single null byte.
*
* @access public
* @param String $key
*/
function setKey($key)
{
$this->key = $key;
if ( CRYPT_RC4_MODE == CRYPT_RC4_MODE_MCRYPT ) {
return;
}
$keyLength = strlen($key);
$keyStream = array();
for ($i = 0; $i < 256; $i++) {
$keyStream[$i] = $i;
}
$j = 0;
for ($i = 0; $i < 256; $i++) {
$j = ($j + $keyStream[$i] + ord($key[$i % $keyLength])) & 255;
$temp = $keyStream[$i];
$keyStream[$i] = $keyStream[$j];
$keyStream[$j] = $temp;
}
$this->encryptIndex = $this->decryptIndex = array(0, 0);
$this->encryptStream = $this->decryptStream = $keyStream;
}
/**
* Dummy function.
*
* Some protocols, such as WEP, prepend an “initialization vector” to the key, effectively creating a new key [1].
* If you need to use an initialization vector in this manner, feel free to prepend it to the key, yourself, before
* calling setKey().
*
* [1] WEP’s initialization vectors (IV’s) are used in a somewhat insecure way.  Since, in that protocol,
* the IV’s are relatively easy to predict, an attack described by
* {@link http://www.drizzle.com/~aboba/IEEE/rc4_ksaproc.pdf Scott Fluhrer, Itsik Mantin, and Adi Shamir}
* can be used to quickly guess at the rest of the key.  The following links elaborate:
*
* {@link http://www.rsa.com/rsalabs/node.asp?id=2009 http://www.rsa.com/rsalabs/node.asp?id=2009}
* {@link http://en.wikipedia.org/wiki/Related_key_attack http://en.wikipedia.org/wiki/Related_key_attack}
*
* @param String $iv
* @see Crypt_RC4::setKey()
* @access public
*/
function setIV($iv)
{
}
/**
* Sets MCrypt parameters. (optional)
*
* If MCrypt is being used, empty strings will be used, unless otherwise specified.
*
* @link http://php.net/function.mcrypt-module-open#function.mcrypt-module-open
* @access public
* @param optional Integer $algorithm_directory
* @param optional Integer $mode_directory
*/
function setMCrypt($algorithm_directory = ”, $mode_directory = ”)
{
if ( CRYPT_RC4_MODE == CRYPT_RC4_MODE_MCRYPT ) {
$this->mcrypt = array($algorithm_directory, $mode_directory);
$this->_closeMCrypt();
}
}
/**
* Encrypts a message.
*
* @see Crypt_RC4::_crypt()
* @access public
* @param String $plaintext
*/
function encrypt($plaintext)
{
return self::toHex($this->_crypt($plaintext, CRYPT_RC4_ENCRYPT));
}
/**
* Decrypts a message.
*
* $this->decrypt($this->encrypt($plaintext)) == $this->encrypt($this->encrypt($plaintext)).
* Atleast if the continuous buffer is disabled.
*
* @see Crypt_RC4::_crypt()
* @access public
* @param String $ciphertext
*/
function decrypt($ciphertext)
{
$ciphertext = self::fromHex($ciphertext);
return $this->_crypt($ciphertext, CRYPT_RC4_DECRYPT);
}
/**
* Encrypts or decrypts a message.
*
* @see Crypt_RC4::encrypt()
* @see Crypt_RC4::decrypt()
* @access private
* @param String $text
* @param Integer $mode
*/
function _crypt($text, $mode)
{
if ( CRYPT_RC4_MODE == CRYPT_RC4_MODE_MCRYPT ) {
$keyStream = $mode == CRYPT_RC4_ENCRYPT ? ‘encryptStream’ : ‘decryptStream’;
if ($this->$keyStream === false) {
$this->$keyStream = mcrypt_module_open($this->mode, $this->mcrypt[0], MCRYPT_MODE_STREAM, $this->mcrypt[1]);
mcrypt_generic_init($this->$keyStream, $this->key, ”);
} else if (!$this->continuousBuffer) {
mcrypt_generic_init($this->$keyStream, $this->key, ”);
}
$newText = mcrypt_generic($this->$keyStream, $text);
if (!$this->continuousBuffer) {
mcrypt_generic_deinit($this->$keyStream);
}
return $newText;
}
if ($this->encryptStream === false) {
$this->setKey($this->key);
}
switch ($mode) {
case CRYPT_RC4_ENCRYPT:
$keyStream = $this->encryptStream;
list($i, $j) = $this->encryptIndex;
break;
case CRYPT_RC4_DECRYPT:
$keyStream = $this->decryptStream;
list($i, $j) = $this->decryptIndex;
}
$newText = ”;
for ($k = 0; $k < strlen($text); $k++) {
$i = ($i + 1) & 255;
$j = ($j + $keyStream[$i]) & 255;
$temp = $keyStream[$i];
$keyStream[$i] = $keyStream[$j];
$keyStream[$j] = $temp;
$temp = $keyStream[($keyStream[$i] + $keyStream[$j]) & 255];
$newText.= chr(ord($text[$k]) ^ $temp);
}
if ($this->continuousBuffer) {
switch ($mode) {
case CRYPT_RC4_ENCRYPT:
$this->encryptStream = $keyStream;
$this->encryptIndex = array($i, $j);
break;
case CRYPT_RC4_DECRYPT:
$this->decryptStream = $keyStream;
$this->decryptIndex = array($i, $j);
}
}
return $newText;
}
/**
* Treat consecutive “packets” as if they are a continuous buffer.
*
* Say you have a 16-byte plaintext $plaintext.  Using the default behavior, the two following code snippets
* will yield different outputs:
*
* <code>
*    echo $rc4->encrypt(substr($plaintext, 0, 8));
*    echo $rc4->encrypt(substr($plaintext, 8, 8));
* </code>
* <code>
*    echo $rc4->encrypt($plaintext);
* </code>
*
* The solution is to enable the continuous buffer.  Although this will resolve the above discrepancy, it creates
* another, as demonstrated with the following:
*
* <code>
*    $rc4->encrypt(substr($plaintext, 0, 8));
*    echo $rc4->decrypt($des->encrypt(substr($plaintext, 8, 8)));
* </code>
* <code>
*    echo $rc4->decrypt($des->encrypt(substr($plaintext, 8, 8)));
* </code>
*
* With the continuous buffer disabled, these would yield the same output.  With it enabled, they yield different
* outputs.  The reason is due to the fact that the initialization vector’s change after every encryption /
* decryption round when the continuous buffer is enabled.  When it’s disabled, they remain constant.
*
* Put another way, when the continuous buffer is enabled, the state of the Crypt_DES() object changes after each
* encryption / decryption round, whereas otherwise, it’d remain constant.  For this reason, it’s recommended that
* continuous buffers not be used.  They do offer better security and are, in fact, sometimes required (SSH uses them),
* however, they are also less intuitive and more likely to cause you problems.
*
* @see Crypt_RC4::disableContinuousBuffer()
* @access public
*/
function enableContinuousBuffer()
{
$this->continuousBuffer = true;
}
/**
* Treat consecutive packets as if they are a discontinuous buffer.
*
* The default behavior.
*
* @see Crypt_RC4::enableContinuousBuffer()
* @access public
*/
function disableContinuousBuffer()
{
if ( CRYPT_RC4_MODE == CRYPT_RC4_MODE_INTERNAL ) {
$this->encryptIndex = $this->decryptIndex = array(0, 0);
$this->setKey($this->key);
}
$this->continuousBuffer = false;
}
/**
* Dummy function.
*
* Since RC4 is a stream cipher and not a block cipher, no padding is necessary.  The only reason this function is
* included is so that you can switch between a block cipher and a stream cipher transparently.
*
* @see Crypt_RC4::disablePadding()
* @access public
*/
function enablePadding()
{
}
/**
* Dummy function.
*
* @see Crypt_RC4::enablePadding()
* @access public
*/
function disablePadding()
{
}
/**
* Class destructor.
*
* Will be called, automatically, if you’re using PHP5.  If you’re using PHP4, call it yourself.  Only really
* needs to be called if mcrypt is being used.
*
* @access public
*/
function __destruct()
{
if ( CRYPT_RC4_MODE == CRYPT_RC4_MODE_MCRYPT ) {
$this->_closeMCrypt();
}
}
/**
* Properly close the MCrypt objects.
*
* @access prviate
*/
function _closeMCrypt()
{
if ( $this->encryptStream !== false ) {
if ( $this->continuousBuffer ) {
mcrypt_generic_deinit($this->encryptStream);
}
mcrypt_module_close($this->encryptStream);
$this->encryptStream = false;
}
if ( $this->decryptStream !== false ) {
if ( $this->continuousBuffer ) {
mcrypt_generic_deinit($this->decryptStream);
}
mcrypt_module_close($this->decryptStream);
$this->decryptStream = false;
}
}
// @function fromHex 把十六进制数转换成字符串
function toHex($sa , $len = 0){
$buf = “”;
if( $len == 0  )
$len = strlen($sa) ;
for ($i = 0; $i < $len; $i++)
{
$val = dechex(ord($sa{$i}));
if(strlen($val)< 2)
$val = “0″.$val;
$buf .= $val;
}
return $buf;
}
// @function fromHex 把十六进制数转换成字符串
function fromHex($sa){
$buf = “”;
$len = strlen($sa) ;
for($i = 0; $i < $len; $i += 2){
$val = chr(hexdec(substr($sa, $i, 2)));
$buf .= $val;
}
return $buf;
}
}

PHP用CURL伪造IP和来源

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, “http://localhost/test/test.php”);
curl_setopt($ch, CURLOPT_HTTPHEADER, array(‘X-FORWARDED-FOR:8.8.8.8′, ‘CLIENT-IP:8.8.8.8′));  //构造IP
curl_setopt($ch, CURLOPT_REFERER, “http://www.gosoa.com.cn/ “);   //构造来路
curl_setopt($ch, CURLOPT_HEADER, 1);
$out = curl_exec($ch);
curl_close($ch);

这样看来利用”HTTP_X_FORWARDED_FOR”这个属性获取客户端IP的方法就不再可取了.-_-# 但如果不用这种方法.那么那些真正使用了代理服务器的人.我们又不能再获取到他们的真实IP地址(因为某些代理服务器会在”X_FORWARDED_FOR”这个HTTP头里加上访问用户真正的IP地址).呵.现实就是这样,某种东西都有有得必有失…

function getClientIp() {
    if (!empty($_SERVER["HTTP_CLIENT_IP"]))
        $ip = $_SERVER["HTTP_CLIENT_IP"];
    else if (!empty($_SERVER["HTTP_X_FORWARDED_FOR"]))
        $ip = $_SERVER["HTTP_X_FORWARDED_FOR"];
    else if (!empty($_SERVER["REMOTE_ADDR"]))
        $ip = $_SERVER["REMOTE_ADDR"];
    else
        $ip = "err";
    return $ip;
}

window下扩展开发 (php5.3.5+vs2010)

开发环境的搭建
首先我们需要一个 PHP 的源码包,这个可以到http://www.php.net/downloads.php 去下载,记得我们是要源码包(Complete Source Code)而不是PHP 的二进制代码包(Windows Binaries)。本文所采用是 PHP 5.3.5 的源码包。
除此之外我们还需要一个 php5ts.lib 。这在PHP 二进制代码包的 dev 目录(php4ts.lib 则是直接放在二进制代码包的根目录)下可以找到。
将该源码包解压到某个目录(假定是D:\Work\PHP\work\php5,以后我们以 $PHP 指代该源码根目录),我们可以看到main、Zend、win32、TSRM、ext 等目录。在 ext 目录下有 ext_skel 和 ext_skel_win32.php 两个文件。
Ext_skel 是在 xNix 环境下的一个用于构建PHP 扩展,生成 PHP 扩展框架的自动化脚本。由于是在 xNix 环境下使用的,并且使用方法也比较简单,故本文不再赘述。具体使用方法可参见源码包根目录(即 $PHP)下的README.EXT_SKEL 文件。ext_skel_win32.php 顾名思义是用来创建 Win32 环境下扩展框架的的脚本。这个脚本需要 Cygwin (http://www.cygwin.com/) 的支持。使用方法和ext_skel 大同小异。本文所采用的是第三种方法:使用 VC 的向导手动创建一个项目文件。这种方法好处就是不需要 Cygwin 的支持,但在编译该扩展的 xNix 版本时仍然需要通过ext_skel 来创建一个相应的框架。
我们在这里使用的 IDE 是 VC++ 2010 Express Edition 。如果你的扩展将来需要分发到更多的地方,建议你使用 VC++ 6.0,这样可增加一定的兼容性。PHP 扩展在 VC++ 6.0 和 VC++ 2010里面的操作都差不多,但在 VC++ 2010 中需要进行一些额外的设置。
现在让我们打开 VC++ 2010,在菜单中选择 【File】 -> 【New】 -> 【Project】 来创建这个扩展的项目文件。
在【项目类型(Project Types)】中选择“Virual C++”,项目【模版(Templates)】为“Win32 Project”。在本例中我们的扩展名字为 phpmore,位于 $PHP\ext目录下。
提示:虽然一个扩展项目的存放位置并没有具体规定,但放到 $PHP\ext 目录下是一个惯例,这会避免很多不必要的麻烦。
在出现的 【Win32 应用程序向导(Win32 Application Wizard)】中点击左面的【应用程序设置(Application Settings)】,设置【程序类型(Application Type)】为“DLL”,并且将其设置为【空项目(Empty Project)】。
点击【完成(Finish)】就创建了该扩展的项目文件。此时你应该会在 $PHP\ext\phpmore 目录下找到该扩展的“解决方案(solution)”文件。在$PHP\ext\phpmore\ phpmore 目录下找到扩展的“项目(Project)”文件。
提示:按照 VS 2010 的说法,一个“解决方案(solution)”是由多个“项目(Project)”组成的,因此产生这样的目录结构是十分合理的。但对 PHP 扩展而言,由于需要在各个系统平台下运行,如果把所有平台的项目文件都放在扩展的根目录下面,就会给人一种非常凌乱的感觉。一个值得推荐的解决方法就是为每个平台都建立一个目录,各自包含相应的项目文件,而把源代码文件(*.c 和 *.h 等)放在扩展根目录或其他一个单独的目录。本文为了简单叙述起见,不再额外处理,但在实际应用过程中请注意源代码目录的合理分配。
现在我们将扩展的源代码文件(phpmore.c 和 phpmore.h ,当然此时是空文件)新建/添加到 phpmore 扩展的项目文件当中。
提示:在 VC++ 2010 中添加源代码文件时默认的后缀名为 .cpp,此时需要主动为文件添加上 .c 的扩展名。否则 VC 的编译器会将其默认为 C++ 代码而进行编译(当然这种设置也是可以改变的),这样就可能会产生一些编译错误。
为了能够很方便的引用 PHP 代码的头文件以及对项目进行编译,我们还需要对项目文件进行一些设置。请通过菜单【项目(Project)】-> 【phpmore 属性(Properties)】进入项目的属性设置页。这里我们先对项目的【Release】版进行配置。
先转到【C++】属性的【General】页填入“Additional Include Directories”:
$PHP;$PHP\main;$PHP\win32;$PHP\TSRM;$PHP\Zend。我们这里输入的绝对路径,但实际开发过程中最好填入相对路径。
再转到【C++】属性的【Preprocessor】页补充一些“Preprocessor Definitions”: ZEND_WIN32;PHP_WIN32;ZTS=1; ZEND_DEBUG=0; COMPILE_DL_PHPMORE 。前面3个是在 Win32 环境下开发所必加的预定义;ZEND_DEBUG=0表示扩展不创建为Debug 版本(因为现在是在配置Release 版本嘛~);COMPILE_DL_PHPMORE 用于是否将本扩展编译为一个“外部扩展(定义见文首)”。
在【C++】属性里面还需要设置的有:【Code Generation】页的“运行库(Runtime Library)”请设置为“Multi-threaded DLL (/MD)”;【Advanced】页的“编译方式(Compile As)”请设置为“Compile as C Code (/TC)”
此外还需要在【连接器(Linker)】属性的【Input】页添加一个“Additional Dependencies”: php5ts.lib 。你可以把 php5ts.lib 放到一个 VC++ 能找到的地方,比如项目文件的目录。
这样,整个扩展项目文件的Release 版本就配置好了。对于 Debug 版本可以有针对性的作一些改动。不过需要注意,一般的 PHP 二进制代码包不允许加载 Debug 版本的扩展,只有将 PHP 编译为 Debug 版本才能加载 Debug 版本的扩展。
提示:如果需要扩展在多种PHP版本中都可布署,那可以先设置一个基本配置(就像上例不设置 php5ts.lib),然后再创建一个继承自基本配置的新的配置-比如Release_PHP5-在这个 Release_PHP5 中额外设置一下 php5ts.lib 就可以了。有的扩展还不事先预定义 ZTS,而是额外再创建一个 Release_TS 的配置,道理是一样的。
在编译过程中会提示你找不到config.w32.h 这个文件 按以下步骤来操作
下载2个必要的包
http://www.php.net/extra/bindlib_w32.zip
http://www.php.net/extra/win32build.zip
把 这2个包的内容放一起,例如解压缩到 D:\win32build

请使用 Visual Studio Tools 下的 Visual Studio 命令提示 操作
进入D:\php-src\
执行buildconf.bat
建立一个临时环境变量,执行set path=%path%;D:\win32build\bin

执行 cscript /nologo configure.js –with-php-build=”../win32build” –without-libxml –disable-odbc
如果想 要No Thread Safe 模式就在上面的命令最后加上参数 –disable-zts

然后看看是不是main下面多了一个 config.w32.h~
还有一点,config.w32.h 里面 #define PHP_COMPILER_ID 改成和你正在用的 PHP 编译版本相同的编译器ID,例如VC6或者VC9,不然编译出来的扩展没法载入,说实话,这个ID的判断真的很傻很天真….
OK,现在万事俱备,只欠编码了,让我们这就开始吧!
所有的扩展都大致由4个部分组成:引用相关的头文件、Zend 模块的声明与相关函数实现、get_module() 函数的实现以及导出函数的声明和实现。

开发环境的搭建
首先我们需要一个 PHP 的源码包,这个可以到http://www.php.net/downloads.php 去下载,记得我们是要源码包(Complete Source Code)而不是PHP 的二进制代码包(Windows Binaries)。本文所采用是 PHP 5.3.5 的源码包。除此之外我们还需要一个 php5ts.lib 。这在PHP 二进制代码包的 dev 目录(php4ts.lib 则是直接放在二进制代码包的根目录)下可以找到。
将该源码包解压到某个目录(假定是D:\Work\PHP\work\php5,以后我们以 $PHP 指代该源码根目录),我们可以看到main、Zend、win32、TSRM、ext 等目录。在 ext 目录下有 ext_skel 和 ext_skel_win32.php 两个文件。Ext_skel 是在 xNix 环境下的一个用于构建PHP 扩展,生成 PHP 扩展框架的自动化脚本。由于是在 xNix 环境下使用的,并且使用方法也比较简单,故本文不再赘述。具体使用方法可参见源码包根目录(即 $PHP)下的README.EXT_SKEL 文件。ext_skel_win32.php 顾名思义是用来创建 Win32 环境下扩展框架的的脚本。这个脚本需要 Cygwin (http://www.cygwin.com/) 的支持。使用方法和ext_skel 大同小异。本文所采用的是第三种方法:使用 VC 的向导手动创建一个项目文件。这种方法好处就是不需要 Cygwin 的支持,但在编译该扩展的 xNix 版本时仍然需要通过ext_skel 来创建一个相应的框架。
我们在这里使用的 IDE 是 VC++ 2010 Express Edition 。如果你的扩展将来需要分发到更多的地方,建议你使用 VC++ 6.0,这样可增加一定的兼容性。PHP 扩展在 VC++ 6.0 和 VC++ 2010里面的操作都差不多,但在 VC++ 2010 中需要进行一些额外的设置。
现在让我们打开 VC++ 2010,在菜单中选择 【File】 -> 【New】 -> 【Project】 来创建这个扩展的项目文件。
在【项目类型(Project Types)】中选择“Virual C++”,项目【模版(Templates)】为“Win32 Project”。在本例中我们的扩展名字为 phpmore,位于 $PHP\ext目录下。
提示:虽然一个扩展项目的存放位置并没有具体规定,但放到 $PHP\ext 目录下是一个惯例,这会避免很多不必要的麻烦。
在出现的 【Win32 应用程序向导(Win32 Application Wizard)】中点击左面的【应用程序设置(Application Settings)】,设置【程序类型(Application Type)】为“DLL”,并且将其设置为【空项目(Empty Project)】。点击【完成(Finish)】就创建了该扩展的项目文件。此时你应该会在 $PHP\ext\phpmore 目录下找到该扩展的“解决方案(solution)”文件。在$PHP\ext\phpmore\ phpmore 目录下找到扩展的“项目(Project)”文件。
提示:按照 VS 2010 的说法,一个“解决方案(solution)”是由多个“项目(Project)”组成的,因此产生这样的目录结构是十分合理的。但对 PHP 扩展而言,由于需要在各个系统平台下运行,如果把所有平台的项目文件都放在扩展的根目录下面,就会给人一种非常凌乱的感觉。一个值得推荐的解决方法就是为每个平台都建立一个目录,各自包含相应的项目文件,而把源代码文件(*.c 和 *.h 等)放在扩展根目录或其他一个单独的目录。本文为了简单叙述起见,不再额外处理,但在实际应用过程中请注意源代码目录的合理分配。
现在我们将扩展的源代码文件(phpmore.c 和 phpmore.h ,当然此时是空文件)新建/添加到 phpmore 扩展的项目文件当中。
提示:在 VC++ 2010 中添加源代码文件时默认的后缀名为 .cpp,此时需要主动为文件添加上 .c 的扩展名。否则 VC 的编译器会将其默认为 C++ 代码而进行编译(当然这种设置也是可以改变的),这样就可能会产生一些编译错误。
为了能够很方便的引用 PHP 代码的头文件以及对项目进行编译,我们还需要对项目文件进行一些设置。请通过菜单【项目(Project)】-> 【phpmore 属性(Properties)】进入项目的属性设置页。这里我们先对项目的【Release】版进行配置。见图四。
先转到【C++】属性的【General】页填入“Additional Include Directories”: $PHP;$PHP\main;$PHP\win32;$PHP\TSRM;$PHP\Zend。我们这里输入的绝对路径,但实际开发过程中最好填入相对路径。
再转到【C++】属性的【Preprocessor】页补充一些“Preprocessor Definitions”: ZEND_WIN32;PHP_WIN32;ZTS=1; ZEND_DEBUG=0; COMPILE_DL_PHPMORE 。前面3个是在 Win32 环境下开发所必加的预定义;ZEND_DEBUG=0表示扩展不创建为Debug 版本(因为现在是在配置Release 版本嘛~);COMPILE_DL_PHPMORE 用于是否将本扩展编译为一个“外部扩展(定义见文首)”。
在【C++】属性里面还需要设置的有:【Code Generation】页的“运行库(Runtime Library)”请设置为“Multi-threaded DLL (/MD)”;【Advanced】页的“编译方式(Compile As)”请设置为“Compile as C Code (/TC)”
此外还需要在【连接器(Linker)】属性的【Input】页添加一个“Additional Dependencies”: php5ts.lib 。你可以把 php5ts.lib 放到一个 VC++ 能找到的地方,比如项目文件的目录。当然你若采用的是 PHP 4的源码包,请相应地把php5ts.lib 替换为 php4ts.lib 。
这样,整个扩展项目文件的Release 版本就配置好了。对于 Debug 版本可以有针对性的作一些改动。不过需要注意,一般的 PHP 二进制代码包不允许加载 Debug 版本的扩展,只有将 PHP 编译为 Debug 版本才能加载 Debug 版本的扩展。
提示:如果需要扩展在多种PHP版本中都可布署,那可以先设置一个基本配置(就像上例不设置 php5ts.lib),然后再创建一个继承自基本配置的新的配置-比如Release_PHP5-在这个 Release_PHP5 中额外设置一下 php5ts.lib 就可以了。有的扩展还不事先预定义 ZTS,而是额外再创建一个 Release_TS 的配置,道理是一样的。
OK,现在万事俱备,只欠编码了,让我们这就开始吧!
所有的扩展都大致由4个部分组成:引用相关的头文件、Zend 模块的声明与相关函数实现、get_module() 函数的实现以及导出函数的声明和实现。

为了简单叙述起见,我先列出本文例子的代码:

phpmore.h :

01 #ifndef PHPMORE_H
02 #define PHPMORE_H
03 extern zend_module_entry phpmore_module_entry;
04 #define phpext_phpmore_ptr &phpmore_module_entry
05
06 /* declaration of functions to be exported */
07 ZEND_FUNCTION(welcome_to_phpmore);
08 PHP_MINFO_FUNCTION(phpmore);
09
10 #define PHPMORE_VERSION "0.1.0"
11 #endif

phpmore.c :

01 #define _USE_32BIT_TIME_T 1
02 #include "php.h"
03 #include "phpmore.h"
04
05 zend_function_entry phpmore_functions[] =
06 {
07 ZEND_FE(welcome_to_phpmore, NULL)
08 {NULL, NULL, NULL}
09 };
10
11 zend_module_entry phpmore_module_entry =
12 {
13 STANDARD_MODULE_HEADER,
14 "PHP&More",
15 phpmore_functions,
16 NULL,
17 NULL,
18 NULL,
19 NULL,
20 PHP_MINFO(phpmore),
21 PHPMORE_VERSION,
22 STANDARD_MODULE_PROPERTIES
23 };
24
25 #if COMPILE_DL_PHPMORE
26 ZEND_GET_MODULE(phpmore)
27 #endif
28
29 PHP_MINFO_FUNCTION(phpmore)
30 {
31 php_info_print_table_start();
32 php_info_print_table_header(2, "PHP&More", "enabled");
33 php_info_print_table_row(2, "Version", PHPMORE_VERSION);
34 php_info_print_table_end();
35 }
36
37 ZEND_FUNCTION(welcome_to_phpmore)
38 {
39 zend_printf("Welcome to PHP&More!");
40 }

所有扩展都必须至少包含有 php.h ,这是一切的基础,因此必须首先在代码中引用(添加 #define _USE_32BIT_TIME_T 1 这一行是为了去掉 VC++ 2005 中 64 位时间格式的支持,在 VS.NET 2003 或 VC++ 6.0 中均无需这样做)。

接下来是扩展的 Zend 函数块的声明。定义了一个名为 phpmore_functions ,每一个元素都是一个 zend_function_entry 结构的 Zend 函数数组。该数组用来声明本扩展一共对外(即 PHP 脚本)提供了多少可用的(导出)函数。由于没有其他地方可以主动提供(导出)函数的个数,因此数组的最后一个元素必须为 {NULL, NULL, NULL},以便 Zend Engine 可以获知函数数组的元素列表是否结束。

然后就是整个扩展模块的声明。这是一个扩展“最高”层次的声明。全方位地提供了 Zend Engine 所需要的各种信息。上面所声明的导出函数列表也仅仅是用来填充它的一个字段而已。除此之外,这个模块声明还负责提供扩展名称(就是将来在 phpinfo() 函数中出现的那个扩展的名字,本例为“PHP&More”)、导出函数列表(本例为phpmore_functions)、模块启动函数(PHP_MINIT_FUNCTION,在模块第一次加载时被调用,本例为 NULL)、模块关闭函数(PHP_MSHUTDOWN_FUNCTION,在模块卸载关闭时被调用,本例为 NULL)、请求启动函数(在每个请求启动时被调用,本例为 NULL)、请求关闭函数(PHP_RINIT_FUNCTION,在每个请求关闭时被调用,本例为 NULL)、模块信息函数(PHP_RSHUTDOWN_FUNCTION,用于在 phpinfo() 中显示扩展的信息,本例为“PHP_MINFO_FUNCTION(phpmore)”)和模块版本(本例为 PHPMORE_VERSION ,定义在 phpmore.h )等其他信息。这几个模块函数的调用关系及顺序见图:

PHP 生存周期

模块声明后面就是 get_module() 函数的实现。这个函数的声明没有手动写出,而是使用了一个宏 ZEND_GET_MODULE(phpmore) 来声明。这也是在扩展开发中常用的一种手段,我们应该尽力地去使用宏。get_module() 函数用于向 Zend Engine 报告这是个外部扩展,这也可以使得我们能够通过 dl() 函数来手动加载它。

剩下的两段代码便是我们前面声明函数的具体实现。一个是模块信息函数,一个是对外导出的 welcome_to_phpmore 函数。模块信息函数对外输出了本扩展的启用状态和版本号,而 welcome_to_phpmore 函数则在 PHP 脚本调用 welcome_to_phpmore() 时对外输出字符串“Welcome to PHP&More!”。

一个扩展的大致结构就是这样。简单编译后我们就得到了一个 phpmore.dll 的文件。相应更改更改 php.ini 及重新启动 Web 服务器后,就可以启用这个扩展了。

php性能分析

1.缘起

关于PHP,很多人的直观感觉是PHP是一种灵活的脚本语言,库类丰富,使用简单,安全,非常适合WEB开发,但性能低下。PHP的性能是否真的就 如同大家的感觉一样的差呢?本文就是围绕这么一个话题来进行探讨的。从源码、应用场景、基准性能、对比分析等几个方面深入分析PHP之性能问题,并通过真 实的数据来说话。

2.从原理分析PHP性能

从原理分析PHP的性能,主要从以下几个方面:内存管理、变量、函数、运行机制来进行分析。

2.1内存管理

类似Nginx的内存管理方式,PHP在内部也是基于内存池,并且引入内存池的生命周期概念。在内存池方面,PHP对PHP脚本和扩展的所有内存相关操作都进行了托管。对大内存和小内存的管理采用了不同的实现方式和优化,具体可以参考以下文档:https://wiki.php.net/internals/zend_mm。在内存分配和回收的生命周期内,PHP采用一次初始化申请+动态扩容+内存标识回收机制,并且在每次请求结束后直接对内存池进行重新mask。

2.2变量

总所周知,PHP是一种弱变量类型的语言,所以在PHP内部,所有的PHP变量都对应成一种类型Zval,其中具体定义如下:

大话PHP之性能

图一PHP变量

在变量方面,PHP做了大量的优化工作,比如说Reference counting和copy on writer机制。这样能够保证内存使用上的优化,并且减少内存拷贝次数(请参考http://blog.xiuwz.com/2011/11/09 /php-using-internal-zval/)。在数组方面,PHP内部采用高效的hashtable来实现。

2.3函数

在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函数在内部也是对应一个函数指针。

2.4运行机制

在话说PHP性能的时候,很多人都会说“C/C++是编译型,JAVA是半编译型,PHP是解释型”。也就是说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是非常类似的,都是先产生中间码,然后运行在不同虚拟机上。

2.5动态运行

从上面的几个分析来看,PHP在内存管理、变量、函数、运行机制等几个方面都做了大量的工作,所以从原理来看,PHP不应该存在性能问题,性能至少也应该和Java比较接近。

这个时候就不得不谈PHP动态语言的特性所带来的性能问题了,由于PHP是动态运行时,所以所有的变量、函数、对象调用、作用域实现等等都是在执行 阶段中才确定的。这个从根本上决定了PHP性能中很难改变的一些东西:在C/C++等能够在静态编译阶段确定的变量、函数,在PHP中需要在动态运行中确 定,也就决定了PHP中间码不能直接运行而需要运行在Zend Engine上。

说到PHP变量的具体实现,又不得不说一个东西了:Hashtable。Hashtable可以说在PHP灵魂之一,在PHP内部广泛用到,包含变量符号栈、函数符号栈等等都是基于hashtable的。

以PHP变量为例来说明下PHP的动态运行特点,比如说代码:

$var = “hello, blog.xiuwz.com”;

?>

该代码的执行结果就是在变量符号栈(是一个hashtable)中新增一个项

大话PHP之性能

当要使用到该变量时候,就去变量符合栈中去查找(也就是变量调用对出了一个hash查找的过程)。

同样对于函数调用也基本上类似有一个函数符号栈(hashtable)。

其实关于动态运行的变量查找特点,在PHP的运行机制中也能看出一些。PHP代码通过解释、编译后的流程下图:

大话PHP之性能

图3 PHP运行实例

从上图可以看出,PHP代码在compile之后,产出的了类符号表、函数符号表、和OPCODE。在真正执行的时候,zend Engine会根据op code去对应的符号表中进行查找,处理。

从某种程度上,在这种问题的上,很难找到解决方案。因为这是由于PHP语言的动态特性所决定的。但是在国内外也有不少的人在寻找解决方案。因为通过这样,能够从根本上完全的优化PHP。典型的列子有facebook的hiphop(https://github.com/facebook/hiphop-php)。

2.6结论

从上面分析来看,在基础的内存管理、变量、函数、运行机制方面,PHP本身并不会存在明显的性能差异,但由于PHP的动态运行特性,决定了PHP和 其他的编译型语言相比,所有的变量查找、函数运行等等都会多一些hash查找的CPU开销和额外的内存开销,至于这种开销具体有多大,可以通过后续的基准 性能和对比分析得出。

因此,也可以大体看出PHP不太适合的一些场景:大量计算性任务、大数据量的运算、内存要求很严格的应用场景。如果要实现这些功能,也建议通过扩展的方式实现,然后再提供钩子函数给PHP调用。这样可以减低内部计算的变量、函数等系列开销。

3.基准性能

对于PHP基准性能,目前缺少标准的数据。大多数同学都存在感性的认识,有人认为800QPS就是PHP的极限了。此外,对于框架的性能和框架对性能的影响很没有响应的权威数字。

本章节的目的是给出一个基准的参考性能指标,通过数据给大家一个直观的了解。

具体的基准性能有以下几个方面:

1.裸PHP性能。完成基本的功能。

2.裸框架的性能。只做最简单的路由分发,只走通核心功能。

3.标准模块的基准性能。所谓标准模块的基准性能,是指一个具有完整服务模块功能的基准性能。

3.1环境说明

测试环境:

Uname -a

Linux db-forum-test17.db01.baidu.com 2.6.9_5-7-0-0 #1 SMP Wed Aug 12 17:35:51 CST 2009 x86_64 x86_64 x86_64 GNU/Linux

Red Hat Enterprise Linux AS release 4 (Nahant Update 3)

8 Intel(R) Xeon(R) CPU E5520 @ 2.27GHz

软件相关:

Nginx:

nginx version: nginx/0.8.54 built by gcc 3.4.5 20051201 (Red Hat 3.4.5-2)

Php5:(采用php-fpm)

PHP 5.2.8 (cli) (built: Mar 6 2011 17:16:18)

Copyright (c) 1997-2008 The PHP Group

Zend Engine v2.2.0, Copyright (c) 1998-2008 Zend Technologies

with eAccelerator v0.9.5.3, Copyright (c) 2004-2006 eAccelerator, by eAccelerator

bingo2:

PHP框架。

其他说明:

目标机器的部署方式:

大话PHP之性能

脚本。

测试压力机器和目标机器独立部署。

3.2裸PHP性能

最简单的PHP脚本。

require_once ‘./actions/indexAction.php’;

$objAction = new indexAction();

$objAction->init();

$objAction->execute();

?>

Acitons/indexAction.php里面的代码如下

class indexAction

{

public function execute()

{

echo ‘hello, world!’;

}

}

?>

通过压力工具测试结果如下:

大话PHP之性能

3.3裸PHP框架性能

为了和3.2的对比,基于bingo2框架实现了类似的功能。代码如下

require_once ‘Bingo/Controller/Front.php’;

$objFrontController = Bingo_Controller_Front::getInstance(array(

‘actionDir’ => ‘./actions’,

));

$objFrontController->dispatch();

压力测试结果如下:

大话PHP之性能

从该测试结果可以看出:框架虽然有一定的消耗,但对整体的性能来说影响是非常小的。

3.4标准PHP模块的基准性能

所谓标准PHP模块,是指一个PHP模块所必须要具体的基本功能:

路由分发。

自动加载。

LOG初始化&Notice日志打印。所以的UI请求都一条标准的日志。

错误处理。

时间校正。

自动计算每个阶段耗时开销。

编码识别&编码转化。

标准配置文件的解析和调用

采用bingo2的代码自动生成工具产生标准的测试PHP模块:test。

测试结果如下:

大话PHP之性能

3.5结论

从测试数据的结论来看,PHP本身的性能还是可以的。基准性能完全能够达到几千甚至上W的QPS。至于为什么在大多数的PHP模块中表现不佳,其实 这个时候更应该去找出系统的瓶颈点,而是简单的说OK,PHP不行,那我们换C来搞吧。(下一个章节,会通过一些例子来对比,采用C来处理不见得有特别的 优势)

通过基准数据,可以得出以下几个具体的结论:

1.PHP本身性能也很不错。简单功能下能够达到5000QPS,极限也能过W。

2.PHP框架本身对性能影响非常有限。尤其是在有一定业务逻辑和数据交互的情况下,几乎可以忽略。

3.一个标准的PHP模块,基准性能能够达到2000QPS(80 cpu idle)。

4.对比分析

很多时候,大家发现PHP模块性能不行的时候,就来一句“ok,我们采用C重写吧”。在公司内,采用C/C++来写业务逻辑模块的现象到处都有,在前几年甚至几乎全部都是采用C来写。那时候大家写的真是一个痛苦:调试难、敏捷不要谈。

http://sd.csdn.net/a/20111130/308320.html

http://www.php100.com/html/webkaifa/PHP/PHPyingyong/2011/1201/9391.html

php soap例子

<?xml version="1.0" encoding="UTF-8"?>
<wsdl:definitions xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:tns="http://localhost/interface/" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="soap" targetNamespace="http://localhost/interface/">
  <wsdl:types>
    <xsd:schema targetNamespace="http://localhost/interface/">
      <xsd:element name="HelloWorld">
        <xsd:complexType>
          <xsd:sequence>
            <xsd:element name="in" type="xsd:string"/>
          </xsd:sequence>
        </xsd:complexType>
      </xsd:element>
      <xsd:element name="HelloWorldResponse">
        <xsd:complexType>
          <xsd:sequence>
            <xsd:element name="out" type="xsd:string"/>
          </xsd:sequence>
        </xsd:complexType>
      </xsd:element>
      <xsd:element name="Add">
      	<xsd:complexType>
      		<xsd:sequence>
      			<xsd:element name="in" type="xsd:int"></xsd:element>
      		</xsd:sequence>
      	</xsd:complexType>
      </xsd:element>
      <xsd:element name="AddResponse">
      	<xsd:complexType>
      		<xsd:sequence>

      			<xsd:element name="out" type="xsd:int"></xsd:element>
      		</xsd:sequence>
      	</xsd:complexType>
      </xsd:element>
    </xsd:schema>
  </wsdl:types>
   <wsdl:message name="AddRequest">   	<wsdl:part name="a" type="xsd:int"></wsdl:part>
  	<wsdl:part name="b" type="xsd:int"></wsdl:part>
  </wsdl:message>
  <wsdl:message name="AddResponse">
  	<wsdl:part name="c" type="xsd:int"></wsdl:part>
  </wsdl:message>
  <wsdl:portType name="TestSoap">     <wsdl:operation name="Add">
    	<wsdl:input message="tns:AddRequest"></wsdl:input>
    	<wsdl:output message="tns:AddResponse"></wsdl:output>
    </wsdl:operation>
  </wsdl:portType>
  <wsdl:binding name="soapSOAP" type="tns:TestSoap">
  	<soap:binding style="document"
  		transport="http://schemas.xmlsoap.org/soap/http" />
  	<wsdl:operation name="Add">
  		<soap:operation soapAction="http://localhost/interface/Add" />
  		<wsdl:input>
  			<soap:body use="literal"
  				namespace="http://localhost/interface/" />
  		</wsdl:input>
  		<wsdl:output>
  			<soap:body use="literal"
  				namespace="http://localhost/interface/" />
  		</wsdl:output>
  	</wsdl:operation>
  </wsdl:binding>
  <wsdl:service name="TestSoap">
    <wsdl:port binding="tns:soapSOAP" name="soapSOAP">
      <soap:address location="http://localhost/interface/myservice.php"/>
    </wsdl:port>
  </wsdl:service>
</wsdl:definitions>
客户端调用

nginx apache 执行php脚本限制

Apache环境规则内容如下:Apache执行php脚本限制 把这些规则添加到.htaccess文件中

RewriteEngine on RewriteCond % !^$

RewriteRule uploads/(.*).(php)$ – [F]

RewriteRule data/(.*).(php)$ – [F]

RewriteRule templets/(.*).(php)$ –[F]

nginx环境规则内容如下:nginx执行php脚本限制

LNMP有一个缺点就是目录权限设置上不如Apache,有时候网站程序存在上传漏洞或类似pathinfo的漏洞从而导致被上传了php木马,而给网站和服务器带来比较大危险。建议将网站目录的PHP权限去掉,当访问上传目录下的php文件时就会返回403错误。

首先要编辑nginx的虚拟主机配置,在fastcgi的location语句的前面按下面的内容添加:

location ~ /(data|uploads|templets)/.*\.(php|php5)?$ {

deny all;

}