php性能优化

请记住你的php脚本性能,很多时候依赖于你的php版本、你的web server环境和你的代码的复杂度

  • 使用输出缓冲区

当你的脚本尝试着渲染的时候,php会使用内存缓存区保存所有的数据。缓存区可能让你的页面看起来很慢,原因是缓冲区填满所有要响应的数据之后再把结果响应给用户。幸运的是,你能够做一下改变,迫使php强行在缓冲区填满之前把数据响应给用户,这样就会让你的网站看起来更快一些。

  • 避免写setters和getters
当你写php类的时候,你可以直接操作对象属性,这样能帮助你节省时间和提升你的脚本性能。而不是setters和getters。
下面是一些案例:dog类通过使用setName()和getName()方式来操作name属性
class dog {
    public $name = '';
 
 public function setName($name) {
    $this->name = $name;
 }
 
 public function getName() {
    return $this->name;
 }
}
注意:setName()和getName()除了存储和返回name属性外,没做任何工作。
$rover = new dog();
$rover->setName('rover');
echo $rover->getName();

直接设置和访问name属性,性能能提升100%,而且也能缩减开发时间!

$rover = new dog();
$rover->name = 'rover';
echo $rover->name;
  • 没有原因不要copy变量

不要为了使代码更加”干净”,常常把已经定义的变量重新赋值给另一个变量。这实际上就导致了双重内存的消耗(当改变变量的时候),这就导致脚本的性能下降。比如一个用户把一个512KB的变量在额外插入给另一个变量,那么就会导致1MB的内存被消耗掉。

$description = strip_tags($_POST['description']);
echo $description;

上面的代码没有任何原因,复制了一遍变量。你仅需要使用内联的方式简单输出变量,而不用额外的消耗内存。

echo strip_tags($_POST['description']);

MYSQL强制使用索引和禁止使用索引

1、mysql强制使用索引:force index(索引名或者主键PRI)

例如:

select * from table force index(PRI) limit 2;(强制使用主键)

select * from table force index(ziduan1_index) limit 2;(强制使用索引”ziduan1_index”)

select * from table force index(PRI,ziduan1_index) limit 2;(强制使用索引”PRI和ziduan1_index”)

2、mysql禁止某个索引:ignore index(索引名或者主键PRI)

例如:

select * from table ignore index(PRI) limit 2;(禁止使用主键)

select * from table ignore index(ziduan1_index) limit 2;(禁止使用索引”ziduan1_index”)

select * from table ignore index(PRI,ziduan1_index) limit 2;(禁止使用索引”PRI,ziduan1_index”)


网站性能优化实践总结

本文提到的网站性能指网站的响应速度,这也符合绝大部分人对于网站性能的理解:访问快速的网站性能好,反之,访问速度越慢,则网站性能越差。本文总结的优化方法是宏观的工程层面的方法,并不包含微观的语言语法层面的方法,例如,JS、CSS的语法优化,这一部分同样影响网站的性能,但语言语法层面的优化更多的是取决于开发人员的编程水平。

什么样的网站响应速度快呢?其实很容易想到,网站加载资源的速度越快,网站响应速度越快;网站需要加载的资源越少,网站响应速度越快。这就分别对应网站性能优化的两大方向:资源缓存、资源合并压缩。当浏览器完成资源的加载后,需要进一步解析资源,才能渲染出最终的网页,所以,浏览器的解析机制也是网站性能优化的一个方向。各种优化方法都可以归类到这三个大方向中。

1.资源缓存

1.1 使用CDN

将网站的静态资源分离,如静态HTML、图片Image、样式CSS、脚本JS等,把静态资源部署到CDN中,可以明显加快这部分资源的加载速度。

1.2 利用HTTP缓存机制

HTTP缓存会把浏览器加载过的资源缓存到本地,下次加载时,只要缓存的资源没有过期,就可以直接使用本地的资源,减少了HTTP请求次数,加快了资源加载速度。具体做法是设置HTTP Header 中的Cache-Control参数。HTTP 1.0 中使用Pragma和Expires两个参数进行缓存,不过早已不推荐使用。

2. 资源的合并压缩

2.1 减少HTTP请求

用一个HTTP请求去加载一个10M的文件,和把这个文件拆分成1M的10个文件,用10个HTTP请求并行去加载,哪一种方式能更快完成加载?既然提到减少HTTP请求可以提高网站响应速度,那么结论貌似应该是用一个HTTP请求的方式更快。其实正确的答案是:不一定!

我做了一个小实验:有两个html文件,index1.html和index2.html,index1.html中用1个<script>标签加载一个2M的js文件bundle.js,index2.html中用6个<script>标签分别加载bundle1.js, bundle2.js …… bundle6.js,这6个js文件由bundle.js平均拆分得到。分别请求index1.html和index2.html 10次,得到加载bundle.js的时间和加载bundle1.js 到 bundle6.js的时间(以最后一个js文件加载完成为结束时间),计算平均加载时间分别为:1.07s 和 1.87s。

实验结论证明了,一个HTTTP请求加载一个合并后的资源文件,比多个HTTTP请求并发加载多个资源文件效率高。但结论只是针对平均加载时间而言,对于单次的比较,完全可能出现相反的结论,例如我的实验过程中,单一HTTTP请求加载时间的最大值为2.36s,超过了第二种加载方式的平均时间1.87s。可能有些人会比较疑惑,为什么并行的效率反而比串行的要低呢?其实,HTTP请求加载资源的瓶颈在带宽,而不是请求的数量,在一个请求已经利用带宽很充分的情况下,增加新的请求并不能减少整体的资源加载时间。

其实,减少HTTP请求来提高网站性能主要是基于以下2个原因:

1) HTTP连接的建立是比较耗时的,一般需要上百ms,每个HTTP请求还有一定的网络延时,需要的HTTP请求越多,这两部分产生的耗时也就越多。当然,HTTP 1.1 对keep-alive的默认支持,可以实现连接的复用,很大程度上优化了这个问题。

2)每个HTTP请求都需要附带额外的数据,比如请求和响应中的头信息,Cookie信息。当请求的资源很小时,附带的额外数据可能比实际的资源还大。

2.2 JS文件

合并压缩JS文件,一方面JS文件数量减少,需要的HTTP请求数也就减少了;另一方面,压缩JS文件可以极大地减小文件体积。可以使用webpack等Web构建工具对JS文件进行压缩合并。

要注意,压缩合并JS文件并不是要把所有的JS文件都打包到一个JS文件中。一般的做法是按照“基础代码”+“页面代码”分别打包。“基础代码”指各个页面或路由(对单页面而言)都要用到的通用代码,“页面代码”是只在某个具体页面或路由中才会用到的代码。这样就可以实现JS代码按需加载,避免页面首屏加载时,因为单一JS文件过大,而影响首屏显示时间。对单页面应用来说,还可以有一个vendor.js的文件,这个文件中的内容是一些用到频率比较高的第三方库(如ECharts等),但这些库并不是每个路由都会用到的,所以并不会被打包到“基础代码”中。将这样的第三方库从各个路由页面对应的JS文件中拆分,一是可以减少所有JS文件的整体大小,因为本来可能是A、B等多个文件都会包含的代码,现在则只需要一份;二是vendor.js只需要被加载一次,后续打开其他路由时,就可以不需要再次加载这部分代码了,起到了资源预加载的作用。

2.3 CSS文件

对CSS文件进行合并压缩,基本原理和做法同JS文件。

2.4 图片

1) 使用WebP格式的图片。WebP是一种支持有损压缩和无损压缩的图片文件格式,派生自图像编码格式 VP8。根据 Google 的测试,无损压缩后的 WebP 比 PNG 文件少了 45% 的文件大小,即使这些 PNG 文件经过其他压缩工具压缩之后,WebP 还是可以减少 28% 的文件大小。

2)使用字体图标IconFont。可以任意设置Icon图形的大小和颜色(只能是单色,因为本质上是给字体设置颜色)。

3)使用CSS Sprites将多张图片合并成一张,从而减少HTTP请求数量。

4)使用Base64直接把图片编码成字符串写入CSS文件,也是从减少HTTP请求数量考虑。但需要注意,Base64编码的图片最好是小图片(最好几十字节级别的),因为图片经过Base64编码后,一般会比原文件更大些。而且太长的Base64编码字符串也会影响CSS的整体可读性。

5)对于需要大量图片的网站,应该把图片资源单独部署,并使用不同的域名来访问。因为图片资源占带宽很大,如果把图片和其他资源部署到一台服务器或一个集群中,服务器端的出口带宽会受到很大影响。使用不同的域名加载图片资源,可以更好的利用浏览器并行下载的特性,因为浏览器对于一个域名下的最大并行请求数是有限制的。

2.5 服务器端开启gzip

服务端开启gzip压缩,可以减少资源文件在网络传输过程中的体积大小。

3.浏览器加载、解析、渲染机制

浏览器的工作原理非常繁琐和复杂,要想仔细了解,可以参考这篇经典的文章How browers work。

结合文章和我自己实验验证,简单来说的话,当浏览器载入一个HTML文件后,

1)会先将加载HTML中引用的所有外部资源(JS、CSS文件等)的请求放到一个队列中,然后浏览器通过多个线程(具体由浏览器设置决定)并发加载这些资源。

2)紧接着对HTML进行自上而下的解析。

3)当解析到<script>标签时,如果标签内是内嵌到HTML中的JS代码,会直接执行这部分代码;如果标签引用了外部的JS文件,且这个文件此时还没有下载完成,解析过程会被阻塞,直到JS文件下载完成,然后解析执行JS代码,之后才会继续HTML的解析过程;如果标签引用了外部的JS文件,但此时这个JS文件已经下载完成,则会直接执行这部分JS代码,并不会阻塞HTML的解析(可以理解成此时JS代码的执行本就属于HTML解析这个<script>标签的过程)。

4) 当解析到<link>标签时,不管<link>中引用的外部CSS资源是否加载完成,都不会阻塞HTML继续向下解析。

这里有2个需要注意的地方:

1)因为JS的加载会阻塞HTML向下解析,所以多个JS文件中代码的执行顺序,是和他们在HTML中的位置顺序保持一致的。例如HTML中,从上向下依次引入a.js, b.js, a.js的文件大小远大于b.js,这样b.js文件很可能先完成加载,但是并不会先于a.js中的代码执行,因为在a.js加载、解析、并执行完成前,HTML的解析是处于阻塞的,b.js所在的<script>标签自然也不会被解析执行。如果不希望加载外部JS文件阻塞HTML的解析,可以使用script标签的defer或async属性,这里就不再展开。

2)所有引用的外部脚本或样式文件,在HTML开始解析前,就已经加入到浏览器的请求队列中,所以多个外部资源开始加载的起始时间一般不会相差很大,除非请求的外部资源数量很多,超过了浏览器的并发请求数。

基于浏览器工作原理的常用优化性能的方法有2个:

1)引用外部CSS文件的link标签,一般会写在<head>内,这是为了能尽早的使<body>内的元素获取样式,优化视觉显示效果。

2)引用外部JS文件的script标签,一般会写在<body>底部,这是为了避免HTML的解析被阻塞,从而使页面元素更快的显示出来。需要注意,虽然script写在<body>底部,但这不意味着<body>内的其他元素都解析完成后才开始加载这些JS文件,这些JS文件依然会在HTML开始解析前,就被加入到请求队列中。

以上就是从资源缓存、资源合并压缩和浏览器解析原理三个维度出发,常用的优化网站性能的实践方法


php程序优化的方法

1、 用单引号代替双引号来包含字符串,这样做会更快一些。因为 PHP 会在双引号包围的 字符串中搜寻变量,单引号则不会,注意:只有 echo 能这么做,它是一种可以把多个字符 串当作参数的“函数”(译注:PHP 手册中说 echo 是语言结构,不是真正的函数,故把函数 加上了双引号)。

2、如果能将类的方法定义成 static,就尽量定义成 static,它的速度会提升将近 4 倍。

3、$row[‘id’] 的速度是$row[id]的 7 倍。

4、echo 比 print 快,并且使用 echo 的多重参数(译注:指用逗号而不是句点)代替字符串 连接,比如 echo $str1,$str2。

5、在执行 for 循环之前确定最大循环数,不要每循环一次都计算最大值,最好运用 foreach 代替。

6、注销那些不用的变量尤其是大数组,以便释放内存。

7、尽量避免使用__get,__set,__autoload。

8、require_once()代价昂贵。

9、include 文件时尽量使用绝对路径,因为它避免了 PHP 去 include_path 里查找文件的速 度,解析操作系统路径所需的时间会更少。

10、如果你想知道脚本开始执行(译注:即服务器端收到客户端请求)的时刻,使用 $_SERVER[‘REQUEST_TIME’] 要好于 time()

11、函数代替正则表达式完成相同功能。

12、str_replace 函数比 preg_replace 函数快,但 strtr 函数的效率是 str_replace 函数的四倍。

13、如果一个字符串替换函数,可接受数组或字符作为参数,并且参数长度不太长,那么 可以考虑额外写一段替换代码, 使得每次传递参数是一个字符, 而不是只写一行代码接受数 组作为查询和替换的参数。

14、使用选择分支语句(译注:即 switch case)好于使用多个 if,else if 语句。

15、用@屏蔽错误消息的做法非常低效,极其低效。

16、打开 apache 的 mod_deflate 模块,可以提高网页的浏览速度。

17、数据库连接当使用完毕时应关掉,不要用长连接。

18、错误消息代价昂贵。

19、在方法中递增局部变量,速度是最快的。几乎与在函数中调用局部变量的速度相当。

20、递增一个全局变量要比递增一个局部变量慢 2 倍。

21、递增一个对象属性(如:$this->prop++)要比递增一个局部变量慢 3 倍。

22、递增一个未预定义的局部变量要比递增一个预定义的局部变量慢 9 至 10 倍。

23、仅定义一个局部变量而没在函数中调用它,同样会减慢速度(其程度相当于递增一个局 部变量)。PHP 大概会检查看是否存在全局变量。

24、方法调用看来与类中定义的方法的数量无关,因为我(在测试方法之前和之后都)添加了 10 个方法,但性能上没有变化。

25、派生类中的方法运行起来要快于在基类中定义的同样的方法。

26、调用带有一个参数的空函数,其花费的时间相当于执行 7 至 8 次的局部变量递增操作。 类似的方法调用所花费的时间接近于 15 次的局部变量递增操作。

27、Apache 解析一个 PHP 脚本的时间要比解析一个静态 HTML 页面慢 2 至 10 倍。尽量 多用静态 HTML 页面,少用脚本。

28、除非脚本可以缓存,否则每次调用时都会重新编译一次。引入一套 PHP 缓存机制通常 可以提升 25%至 100%的性能,以免除编译开销。

29、尽量做缓存,可使用 memcached。memcached 是一款高性能的内存对象缓存系统, 可用来加速动态 Web 应用程序,减轻数据库负载。对运算码 (OP code)的缓存很有用,使 得脚本不必为每个请求做重新编译。

30、 当操作字符串并需要检验其长度是否满足某种要求时, 你想当然地会使用 strlen()函数。 此函数执行起来相当快,因为它不做任何计算,只返回在 zval 结构(C 的内置数据结构,用 于存储 PHP 变量)中存储的已知字符串长度。但是,由于 strlen()是函数,多多少少会有些 慢,因为函数调用会经过诸多步骤,如字母小写化(译注:指函数名小写化,PHP 不区分函 数名大小写)、哈希查找,会跟随被调用的函数一起执行。在某些情况下,你可以使用 isset() 技巧加速执行你的代码。 (举例如下) if (strlen($foo) < 5) { echo “Foo is too short”$$ } (与下面的技巧做比较) if (!isset($foo{5})) { echo “Foo is too short”$$ } 调用 isset()恰巧比 strlen()快,因为与后者不同的是,isset()作为一种语言结构,意味着它 的执行不需要函数查找和字母小写化。 也就是说, 实际上在检验字符串长度的顶层代码中你 没有花太多开销。

31、当执行变量$i 的递增或递减时,$i++会比++$i 慢一些。这种差异是 PHP 特有的,并不 适用于其他语言, 所以请不要修改你的 C 或 Java 代码并指望它们能立即变快, 没用的。 ++$i 更快是因为它只需要 3 条指令(opcodes),$i++则需要 4 条指令。后置递增实际上会产生一 个临时变量,这个临时变量随后被递增。而前置递增直接在原值上递增。这是最优化处理的 一种,正如 Zend 的 PHP 优化器所作的那样。牢记这个优化处理不失为一个好主意,因为 并不是所有的指令优化器都会做同样的优化处理, 并且存在大量没有装配指令优化器的互联 网服务提供商(ISPs)和服务器。

32、并不是事必面向对象(OOP),面向对象往往开销很大,每个方法和对象调用都会消耗很 多内存。

33、并非要用类实现所有的数据结构,数组也很有用。

34、不要把方法细分得过多,仔细想想你真正打算重用的是哪些代码?

35、当你需要时,你总能把代码分解成方法。

36、尽量采用大量的 PHP 内置函数。

37、如果在代码中存在大量耗时的函数,你可以考虑用 C 扩展的方式实现它们。

38、 评估检验(profile)你的代码。 检验器会告诉你, 代码的哪些部分消耗了多少时间。 Xdebug 调试器包含了检验程序,评估检验总体上可以显示出代码的瓶颈。

39、mod_zip 可作为 Apache 模块,用来即时压缩你的数据,并可让数据传输量降低 80%。

40、在可以用 file_get_contents 替代 file、fopen、feof、fgets 等系列方法的情况下,尽量 用 file_get_contents,因为他的效率高得多!但是要注意 file_get_contents 在打开一个 URL 文件时候的 PHP 版本问题;

41、尽量的少进行文件操作,虽然 PHP 的文件操作效率也不低的;

42、优化 Select SQL 语句,在可能的情况下尽量少的进行 Insert、Update 操作(在 update 上,我被恶批过);

43、尽可能的使用 PHP 内部函数(但是我却为了找个 PHP 里面不存在的函数,浪费了本可 以写出一个自定义函数的时间,经验问题啊!);

44、 循环内部不要声明变量, 尤其是大变量: 对象(这好像不只是 PHP 里面要注意的问题吧?);

45、多维数组尽量不要循环嵌套赋值;

46、在可以用 PHP 内部字符串操作函数的情况下,不要用正则表达式;

47、foreach 效率更高,尽量用 foreach 代替 while 和 for 循环;

48、用单引号替代双引号引用字符串;

49、“用 i+=1 代替 i=i+1。符合 c/c++的习惯,效率还高”

50、对 global 变量,应该用完就 unset()掉;


浏览器版本判断

  • JS判断
<!DOCTYPE html>
<html>
<head>
    <meta charset=" utf-8">
    <title>判断浏览器版本,解决兼容问题</title>
    <script type="text/javascript">
        var userAgent = navigator.userAgent,
            rMsie = /(msie\s|trident.*rv:)([\w.]+)/,
            rFirefox = /(firefox)\/([\w.]+)/,
            rOpera = /(opera).+version\/([\w.]+)/,
            rChrome = /(chrome)\/([\w.]+)/,
            rSafari = /version\/([\w.]+).*(safari)/;
        var browser;
        var version;
        var ua = userAgent.toLowerCase();
        function uaMatch(ua){
//            alert(11);
            var match = rMsie.exec(ua);
            if(match != null){
                return { browser : "IE", version : match[2] || "0" };
            }
             match = rFirefox.exec(ua);
            if (match != null) {
                return { browser : match[1] || "", version : match[2] || "0" };
            }
             match = rOpera.exec(ua);
            if (match != null) {
                return { browser : match[1] || "", version : match[2] || "0" };
            }
             match = rChrome.exec(ua);
            if (match != null) {
                return { browser : match[1] || "", version : match[2] || "0" };
            }
             match = rSafari.exec(ua);
            if (match != null) {
                return { browser : match[2] || "", version : match[1] || "0" };
            }
            if (match != null) {
                return { browser : "", version : "0" };
            }
        }
        var browserMatch = uaMatch(ua);
        if (browserMatch.browser){
            browser = browserMatch.browser;
            version = browserMatch.version;
        }
        document.write(browser+version);
    </script>
</head>
<body>

</body>
</html>
  • IF条件判断
<!DOCTYPE html>
<html>
<head>
    <meta charset=" utf-8">
    <title>判断浏览器版本,解决兼容问题</title>
</head>
<body>
<!--[if IE]>只有IE6,7,8,9浏览器显示(IE10标准模式不支持)<hr/><![endif]-->

<!--[if !IE]><!-->只有非IE浏览器显示(不包括IE10、IE11)<hr/><!--><![endif]-->

<!--[if IE 9]>IE9浏览器显示<hr/><![endif]-->

<!--[if IE 8]>IE8浏览器显示<hr/><![endif]-->

<!--[if IE 7]>IE7浏览器显示<hr/><![endif]-->

<!--[if IE 6]>IE6浏览器显示<hr/><![endif]-->

<!--[if lt IE 10]>IE10以下版本浏览器显示(不包括IE10)<hr/><![endif]-->

<!--[if lte IE 9]>IE9及IE9以下版本浏览器显示(包括IE9)<hr/><![endif]-->

<!--[if gt IE 6]>IE6以上版本浏览器显示(不含IE6)<hr/><![endif]-->

<!--[if gte IE 7]>IE7及IE7以上版本浏览器显示(包含IE7)<hr/><![endif]-->
</body>
</html>
  • IE浏览器判断
<script type="text/javascript">
    // 用于 IE 的代码:
    //if (window.ActiveXObject)  //此方法判断ie11时会返回false
    if ("ActiveXObject" in window)//故 改成这个判断
    {
        alert('ie');
    }
    // 用于 Mozilla, Firefox, Opera, 等浏览器的代码:
    else
    {
        alert('!ie');
    }
</script>

 

 


PHP设计模式——单例模式

PHP中的对象生存期间是从该脚本开始一直到该脚本结束为止,因此PHP的单例模式只是在一个页面中(这里可能包含很多其他页面,不是狭义的单页面)多次用到该对象时才会起作用,多次用到时不去重复的new对象(多个人做一个项目时,难免会碰到一次请求中多次实例一个对象的情况),将不会耗费不必要的资源(数据控连接操做效果很明显),还有一点就是可以保证整个脚本中都是同一个对象,这种模式是怎么实现的呢,他的实现有几个要注意的点:

1. 首先就是要将__construct()方法定义为私有方法,这样就不能通过new来得到一个新的实例了,单例模式不能在外部进行实例化,这能字自身内部进行实例化;

2. 同样要屏蔽__clone()方法,防止从类外部进行克隆

3. 然后就是定义一个用来保存实例的私有变量和获取私有变量的公有函数getInstance()

<?php
/**
 * 设计模式之单例模式
 * $_instance必须声明为静态的私有变量
 * 构造函数必须声明为私有,防止外部程序new类从而失去单例模式的意义
 * getInstance()方法必须设置为公有的,必须调用此方法以返回实例的一个引用
 * ::操作符只能访问静态变量和静态函数
 * new对象都会消耗内存
 * 使用场景:最常用的地方是数据库连接。
 * 
class Singlemodel{
    /**
     * 保存Singlemodel实例的变量
     * @var Singlemodel $_instance
     */
    private static $_instance = null;

    /**
     * 屏蔽掉通过new来实例化该对象(也可以去掉)
     * 这里来测试数据库连接
     */
    private function __construct(){
        header("Content-Type:text/html;charset=utf-8");
    }

    /**
     * 通过该方法获取实例,防止多次实例化
     */
    public static function getInstance(){
        if(!(self::$_instance instanceof self)){
            self::$_instance = new self();
        }
        return self::$_instance;
    }

    /**
     * 测试1,通过使用单例模式
     */
    public static function testOne(){
        return self::getInstance();
    }

    /**
     * 测试1,通过使用单例模式
     */
    public static function testTwo(){
        return new self();
    }

}
$obj = array();
$begin = microtime(true);
for($i=0;$i<10000;$i++){
    /*
    * 这里进行两次测试,testOne应用了单例模式,testTwo没有应用单例模式,
    * 我们分别看看他们占用的资源和耗费的时间
    */
    $obj[$i] = Singlemodel::testOne();
//    $obj[$i] = Singlemodel::testTwo();
}
echo "程序运行期间最大内存占用:".memory_get_peak_usage()."bytes\r";
echo "程序运行耗时:".floatval(microtime(true) - $begin)."s\r";

5次测试结果平均:

未使用单例模式:
程序运行期间最大内存占用:2341720bytes
程序运行耗时:0.0505061149597s

使用单例模式:
程序运行期间最大内存占用: 613272bytes
程序运行耗时:0.018285036087s

到这里,你要是自己测试过就会发现,当链接次数比较少时,差异是比较小的。其实在一次请求中达到很多次实例化也是比较少的,那么是不是说这个就没作用了呢,当然不是,你想想看,首先,这样可以尽量避免多次实例化,减小资源消耗;其次,就算是这10ms级的差距,在高并发系统中也是很有用的。我们用它好处多多

 


MySql性能优化

  •  为查询缓存优化你的查询

    大多数的MySQL服务器都开启了查询缓存。这是提高性最有效的方法之一,而且这是被MySQL的数据库引擎处理的。当有很多相同的查询被执行了多次的时候,这些查询结果会被放到一个缓存中,这样,后续的相同的查询就不用操作表而直接访问缓存结果了。

// 查询缓存不开启
$r=mysql_query("SELECT username FROM user WHERE date >= CURDATE()");
// 开启查询缓存
$today=date("Y-m-d");
$r=mysql_query("SELECT username FROM user WHERE date >= '$today'");

上面两条SQL语句的差别就是 CURDATE() ,MySQL的查询缓存对这个函数不起作用。所以,像 NOW() 和 RAND() 或是其它的诸如此类的SQL函数都不会开启查询缓存,因为这些函数的返回是会不定的易变的。所以,你所需要的就是用一个变量来代替MySQL的函数,从而开启缓存。

  •  EXPLAIN 你的 SELECT 查询

    使用 EXPLAIN 关键字可以让你知道MySQL是如何处理你的SQL语句的。这可以帮你分析你的查询语句或是表结构的性能瓶颈。
    挑一个你的SELECT语句(推荐挑选那个最复杂的,有多表联接的),把关键字EXPLAIN加到前面。

查看key、rows列可以让我们找到潜在的性能问题。

  •  当只要一行数据时使用 LIMIT 1

    当你查询表的有些时候,你已经知道结果只会有一条结果,但因为你可能需要去fetch游标,或是你也许会去检查返回的记录数。
    在这种情况下,加上 LIMIT 1 可以增加性能。这样一样,MySQL数据库引擎会在找到一条数据后停止搜索,而不是继续往后查少下一条符合记录的数据

  •  为搜索字段建索引

    索引并不一定就是给主键或是唯一的字段。如果在你的表中,有某个字段你总要会经常用来做搜索,那么,请为其建立索引吧。

另外,你应该也需要知道什么样的搜索是不能使用正常的索引的。例如,当你需要在一篇大的文章中搜索一个词时,如: “WHERE post_content LIKE ‘%apple%’”,索引可能是没有意义的。你可能需要使用MySQL全文索引 或是自己做一个索引(比如说:搜索关键词或是Tag什么的)

  •  在Join表的时候使用相当类型的例,并将其索引

    如果你的应用程序有很多 JOIN 查询,你应该确认两个表中Join的字段是被建过索引的。这样,MySQL内部会启动为你优化Join的SQL语句的机制。

    而且,这些被用来Join的字段,应该是相同的类型的。例如:如果你要把 DECIMAL 字段和一个 INT 字段Join在一起,MySQL就无法使用它们的索引。对于那些STRING类型,还需要有相同的字符集才行。(两个表的字符集有可能不一样)

// 在state中查找company 
$r = mysql_query("SELECT company_name FROM users 
LEFT JOIN companies ON (users.state = companies.state) 
WHERE users.id = $user_id"); 
// 两个 state 字段应该是被建过索引的,而且应该是相当的类型,相同的字符集。
  • 千万不要 ORDER BY RAND()

    想打乱返回的数据行?随机挑一个数据?真不知道谁发明了这种用法,但很多新手很喜欢这样用。但你确不了解这样做有多么可怕的性能问题。

    如果你真的想把返回的数据行打乱了,你有N种方法可以达到这个目的。这样使用只让你的数据库的性能呈指数级的下降。这里的问题是:MySQL会不得不去执行RAND()函数(很耗CPU时间),而且这是为了每一行记录去记行,然后再对其排序。就算是你用了Limit 1也无济于事(因为要排序)

    下面的示例是随机挑一条记录 :

// 千万不要这样做: 
$r = mysql_query("SELECT username FROM user ORDER BY RAND() LIMIT 1"); 

// 这要会更好: 
$r = mysql_query("SELECT count(*) FROM user"); 
$d = mysql_fetch_row($r); 
$rand = mt_rand(0,$d[0] - 1); 
$r = mysql_query("SELECT username FROM user LIMIT $rand, 1");
  •  避免 SELECT *

    从数据库里读出越多的数据,那么查询就会变得越慢。并且,如果你的数据库服务器和WEB服务器是两台独立的服务器的话,这还会增加网络传输的负载。

    所以,你应该养成一个需要什么就取什么的好的习惯。

  • 永远为每张表设置一个ID

    我们应该为数据库里的每张表都设置一个ID做为其主键,而且最好的是一个INT型的(推荐使用UNSIGNED),并设置上自动增加的 AUTO_INCREMENT标志。

    就算是你 users 表有一个主键叫 “email”的字段,你也别让它成为主键。使用 VARCHAR 类型来当主键会使用得性能下降。另外,在你的程序中,你应该使用表的ID来构造你的数据结构。

    而且,在MySQL数据引擎下,还有一些操作需要使用主键,在这些情况下,主键的性能和设置变得非常重要。

    在这里,只有一个情况是例外,那就是“关联表”的“外键”,也就是说,这个表的主键,通过若干个别的表的主键构成。我们把这个情况叫做“外键”。比如:有一个“学生表”有学生的ID,有一个“课程表”有课程ID,那么,“成绩表”就是“关联表”了,其关联了学生表和课程表,在成绩表中,学生ID和课程ID叫“外键”其共同组成主键。

  • 使用 ENUM 而不是 VARCHAR

    ENUM 类型是非常快和紧凑的。在实际上,其保存的是 TINYINT,但其外表上显示为字符串。这样一来,用这个字段来做一些选项列表变得相当的完美。

    如果你有一个字段,比如“性别”,“国家”,“民族”,“状态”或“部门”,你知道这些字段的取值是有限而且固定的,那么,你应该使用 ENUM 而不是 VARCHAR。

  • 固定长度的表会更快

    如果表中的所有字段都是“固定长度”的,整个表会被认为是 “static” 或 “fixed-length”。 例如,表中没有如下类型的字段: VARCHAR,TEXT,BLOB。只要你包括了其中一个这些字段,那么这个表就不是“固定长度静态表”了,这样,MySQL 引擎会用另一种方法来处理。

    固定长度的表会提高性能,因为MySQL搜寻得会更快一些,因为这些固定的长度是很容易计算下一个数据的偏移量的,所以读取的自然也会很快。而如果字段不是定长的,那么,每一次要找下一条的话,需要程序找到主键。

    并且,固定长度的表也更容易被缓存和重建。不过,唯一的副作用是,固定长度的字段会浪费一些空间,因为定长的字段无论你用不用,他都是要分配那么多的空间。

    使用“垂直分割”技术(见下一条),你可以分割你的表成为两个一个是定长的,一个则是不定长的。

  • 尽可能的使用 NOT NULL

    除非你有一个很特别的原因去使用 NULL 值,你应该总是让你的字段保持 NOT NULL。这看起来好像有点争议,请往下看。

    首先,问问你自己“Empty”和“NULL”有多大的区别(如果是INT,那就是0和NULL)?如果你觉得它们之间没有什么区别,那么你就不要使用NULL。(你知道吗?在 Oracle 里,NULL 和 Empty 的字符串是一样的!)

    不要以为 NULL 不需要空间,其需要额外的空间,并且,在你进行比较的时候,你的程序会更复杂。 当然,这里并不是说你就不能使用NULL了,现实情况是很复杂的,依然会有些情况下,你需要使用NULL值

  • 把IP地址存成 UNSIGNED INT

    很多程序员都会创建一个 VARCHAR(15) 字段来存放字符串形式的IP而不是整形的IP。如果你用整形来存放,只需要4个字节,并且你可以有定长的字段。而且,这会为你带来查询上的优势,尤其是当你需要使用这样的WHERE条件:IP between ip1 and ip2。

    我们必需要使用UNSIGNED INT,因为 IP地址会使用整个32位的无符号整形。

    而你的查询,你可以使用 INET_ATON() 来把一个字符串IP转成一个整形,并使用 INET_NTOA() 把一个整形转成一个字符串IP。在PHP中,也有这样的函数 ip2long() 和 long2ip()。
    1 $r = “UPDATE users SET ip = INET_ATON(‘{$_SERVER[‘REMOTE_ADDR’]}’) WHERE user_id = $user_id”;

  •  垂直分割

    “垂直分割”是一种把数据库中的表按列变成几张表的方法,这样可以降低表的复杂度和字段的数目,从而达到优化的目的。

    示例一:在Users表中有一个字段是家庭地址,这个字段是可选字段,相比起,而且你在数据库操作的时候除了个人信息外,你并不需要经常读取或是改写这个字段。那么,为什么不把他放到另外一张表中呢? 这样会让你的表有更好的性能,大家想想是不是,大量的时候,我对于用户表来说,只有用户ID,用户名,口令,用户角色等会被经常使用。小一点的表总是会有好的性能。

    示例二: 你有一个叫 “last_login” 的字段,它会在每次用户登录时被更新。但是,每次更新时会导致该表的查询缓存被清空。所以,你可以把这个字段放到另一个表中,这样就不会影响你对用户 ID,用户名,用户角色的不停地读取了,因为查询缓存会帮你增加很多性能。

    另外,你需要注意的是,这些被分出去的字段所形成的表,你不会经常性地去Join他们,不然的话,这样的性能会比不分割时还要差,而且,会是极数级的下降。

  • 拆分大的 DELETE 或 INSERT 语句

    如果你需要在一个在线的网站上去执行一个大的 DELETE 或 INSERT 查询,你需要非常小心,要避免你的操作让你的整个网站停止相应。因为这两个操作是会锁表的,表一锁住了,别的操作都进不来了。

    Apache 会有很多的子进程或线程。所以,其工作起来相当有效率,而我们的服务器也不希望有太多的子进程,线程和数据库链接,这是极大的占服务器资源的事情,尤其是内存。

    如果你把你的表锁上一段时间,比如30秒钟,那么对于一个有很高访问量的站点来说,这30秒所积累的访问进程/线程,数据库链接,打开的文件数,可能不仅仅会让你的WEB服务Crash,还可能会让你的整台服务器马上掛了。

    所以,如果你有一个大的处理,你定你一定把其拆分,使用 LIMIT 条件是一个好的方法。下面是一个示例:

while (1) { 
    //每次只做1000条 
    mysql_query("DELETE FROM logs WHERE log_date <= '2009-11-01' LIMIT     1000"); 
    if (mysql_affected_rows() == 0) { 
    // 没得可删了,退出! 
    break; 
} 
    // 每次都要休息一会儿 
    usleep(50000); 
}
  •  越小的列会越快

    对于大多数的数据库引擎来说,硬盘操作可能是最重大的瓶颈。所以,把你的数据变得紧凑会对这种情况非常有帮助,因为这减少了对硬盘的访问。

    如果一个表只会有几列罢了(比如说字典表,配置表),那么,我们就没有理由使用 INT 来做主键,使用 MEDIUMINT, SMALLINT 或是更小的 TINYINT 会更经济一些。如果你不需要记录时间,使用 DATE 要比 DATETIME 好得多。

    当然,你也需要留够足够的扩展空间,不然,你日后来干这个事,你会死的很难看。

  • 选择正确的存储引擎

    在 MySQL 中有两个存储引擎 MyISAM 和 InnoDB,每个引擎都有利有弊。

    MyISAM 适合于一些需要大量查询的应用,但其对于有大量写操作并不是很好。甚至你只是需要update一个字段,整个表都会被锁起来,而别的进程,就算是读进程都无法操作直到读操作完成。另外,MyISAM 对于 SELECT COUNT(*) 这类的计算是超快无比的。

    InnoDB 的趋势会是一个非常复杂的存储引擎,对于一些小的应用,它会比 MyISAM 还慢。他是支持“行锁” ,于是在写操作比较多的时候,会更优秀。并且,他还支持更多的高级应用,比如:事务。

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 


mysql 性能分析及explain用法

1. 使用explain语句去查看分析结果
explain select * from test1 where id=1;
会出现:
id  selecttype  table  type possible_keys  key key_len  ref rows  extra各列
其中,
type=const表示通过索引一次就找到了,
key=primary的话,表示使用了主键 
type=all,表示为全表扫描,
key=null表示没用到索引;
type=ref,因为这时认为是多个匹配行,在联合查询中,一般为REF
2. MYSQL中的组合索引
假设表有id,key1,key2,key3,把三者形成一个组合索引,则
如:
  where key1=….
  where key1=1 and key2=2
  where key1=3 and key3=3 and key2=2
根据最左原则,这些都是可以使用索引的哦

  from test where key1=1 order by key3
用explain分析的话,只用到了normal_key索引,但只对where子句起作用,而后面的order by需要排序

3 .使用慢查询分析:
在my.ini中:
long_query_time=1
log-slow-queries=d:\mysql5\logs\mysqlslow.log
把超过1秒的记录在慢查询日志中
可以用mysqlsla来分析之。也可以在mysqlreport中,有如
DMS 分别分析了select ,update,insert,delete,replace等所占的百份比

4 .MYISAM和INNODB的锁定
myisam中,注意是表锁来的,比如在多个UPDATE操作后,再SELECT时,会发现SELECT操作被锁定了,必须等所有UPDATE操作完毕后,再能SELECT 

innodb的话则不同了,用的是行锁,不存在上面问题。
 
5 .MYSQL的事务配置项
innodb_flush_log_at_trx_commit=1
表示事务提交时立即把事务日志写入磁盘,同时数据和索引也更新
innodb_flush_log_at_trx_commit=0
事务提交时,不立即把事务日志写入磁盘,每隔1秒写一次
innodb_flush_log_at_trx_commit=2
事务提交时,立即写入磁盘文件(这里只是写入到内核缓冲区,但不立即刷新到磁盘,而是每隔1秒刷新到盘,同时更新数据和索引 
  • explain用法
EXPLAIN tbl_name
或:
EXPLAIN [EXTENDED] SELECT select_options

前者可以得出一个表的字段结构等等,后者主要是给出相关的一些索引信息,而今天要讲述的重点是后者。

举例
mysql> explain select * from event;
+—-+————-+——-+——+—————+——+———+——+——+——-+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+—-+————-+——-+——+—————+——+———+——+——+——-+
| 1 | SIMPLE | event | ALL | NULL | NULL | NULL | NULL | 13 | |
+—-+————-+——-+——+—————+——+———+——+——+——-+
1 row in set (0.00 sec)

各个属性的含义
id
select查询的序列号

select_type
select查询的类型,主要是区别普通查询和联合查询、子查询之类的复杂查询。

table
输出的行所引用的表。

type
联合查询所使用的类型。
type显示的是访问类型,是较为重要的一个指标,结果值从好到坏依次是:
system > const > eq_ref > ref > fulltext > ref_or_null > index_merge > unique_subquery > index_subquery > range > index > ALL
一般来说,得保证查询至少达到range级别,最好能达到ref。

possible_keys
指出MySQL能使用哪个索引在该表中找到行。如果是空的,没有相关的索引。这时要提高性能,可通过检验WHERE子句,看是否引用某些字段,或者检查字段不是适合索引。

key
显示MySQL实际决定使用的键。如果没有索引被选择,键是NULL。

key_len
显示MySQL决定使用的键长度。如果键是NULL,长度就是NULL。文档提示特别注意这个值可以得出一个多重主键里mysql实际使用了哪一部分。

ref
显示哪个字段或常数与key一起被使用。

rows
这个数表示mysql要遍历多少数据才能找到,在innodb上是不准确的。

Extra
如果是Only index,这意味着信息只用索引树中的信息检索出的,这比扫描整个表要快。
如果是where used,就是使用上了where限制。
如果是impossible where 表示用不着where,一般就是没查出来啥。
如果此信息显示Using filesort或者Using temporary的话会很吃力,WHERE和ORDER BY的索引经常无法兼顾,如果按照WHERE来确定索引,那么在ORDER BY时,就必然会引起Using filesort,这就要看是先过滤再排序划算,还是先排序再过滤划算。

常见的一些名词解释
Using filesort
MySQL需要额外的一次传递,以找出如何按排序顺序检索行。

Using index
从只使用索引树中的信息而不需要进一步搜索读取实际的行来检索表中的列信息。

Using temporary
为了解决查询,MySQL需要创建一个临时表来容纳结果。

ref
对于每个来自于前面的表的行组合,所有有匹配索引值的行将从这张表中读取

ALL
完全没有索引的情况,性能非常地差劲。

index
与ALL相同,除了只有索引树被扫描。这通常比ALL快,因为索引文件通常比数据文件小。

SIMPLE
简单SELECT(不使用UNION或子查询) 


PHP设计模式——注册者模式

注册者模式并不是很常见,它也不是一个典型的创建模式,只是为了利用静态方法更方便的存取数据。

<?php
/**
* Registry class
*/
class Package {

  protected static $data = array();

  public static function set($key, $value) {
    self::$data[$key] = $value;
  }

  public static function get($key) {
    return isset(self::$data[$key]) ? self::$data[$key] : null;
  }

  final public static function removeObject($key) {
    if (array_key_exists($key, self::$data)) {
      unset(self::$data[$key]);
    }
  }
}


Package::set('name', 'Package name');

var_dump(Package::get('name'));
// Package name

 

 

 


PHP设计模式——简单工厂模式

  • ①抽象基类:类中定义抽象一些方法,用以在子类中实现
  • ②继承自抽象基类的子类:实现基类中的抽象方法
  • ③工厂类:用以实例化所有相对应的子类

为什么要用抽象类:

相当于制定一个规范,比如一个商场,规定必须有一个支付的方法,那我们在父类中定义一个抽象支付方法,那么继承之后就必须实现

<?php
/**
 *
 * 定义个抽象的类,让子类去继承实现它
 *
 */
abstract class Operation{
    //抽象方法不能包含函数体
    abstract public function getValue($num1,$num2);//强烈要求子类必须实现该功能函数
}

 

<?php
/**
 * 加法类
 */
class OperationAdd extends Operation {
    public function getValue($num1,$num2){
        return $num1+$num2;
    }
}

/**
 * 减法类
 */
class OperationSub extends Operation {
    public function getValue($num1,$num2){
        return $num1-$num2;
    }
}

/**
 * 乘法类
 */
class OperationMul extends Operation {
    public function getValue($num1,$num2){
        return $num1*$num2;
    }
}

/**
 * 除法类
 */
class OperationDiv extends Operation {
    public function getValue($num1,$num2){

    }
}

/**
 * 求余类(remainder)
 *
 */
class OperationRem extends Operation {
    public function getValue($num1,$num2){
 
    }
}

现在还有一个问题未解决,就是如何让程序根据用户输入的操作符实例化相应的对象呢?
解决办法:使用一个单独的类来实现实例化的过程,这个类就是工厂

<?php
/**
 * 工程类,主要用来创建对象
 * 功能:根据输入的运算符号,工厂就能实例化出合适的对象
 *
 */
class Factory{
    public static function createObj($operate){
        switch ($operate){
            case '+':
                return new OperationAdd();
                break;
            case '-':
                return new OperationSub();
                break;
            case '*':
                return new OperationMul();
                break;
            case '/':
                return new OperationDiv();
                break;
        }
    }
}
$test=Factory::createObj('+');
$result=$test->getValue(23,0);
echo $result;

其他关于关于此模式的笔记:

工厂模式:
以交通工具为例子:要求请既可以定制交通工具,又可以定制交通工具生产的过程
1>定制交通工具
1.定义一个接口,里面包含交工工具的方法(启动 运行 停止)
2.让飞机,汽车等类去实现他们
2> 定制工厂(通上类似)
1.定义一个接口,里面包含交工工具的制造方法(启动 运行 停止)
2.分别写制造飞机,汽车的工厂类去继承实现这个接口