性能优化_子查询的优化,性能优化之mysql优化 - CSDN
  • 本文为性能优化系列的总纲,主要介绍性能调优专题计划、何为性能问题、性能调优方式及前面介绍的数据库优化、布局优化、Java(Android)代码优化、网络优化具体对应的调优方式。   1、调优专题博客计划 目前...

    本文为性能优化系列的总纲,主要介绍性能调优专题计划、何为性能问题、性能调优方式及前面介绍的数据库优化、布局优化、Java(Android)代码优化、网络优化具体对应的调优方式。

     

    1、调优专题博客计划

    目前性能优化专题已完成以下部分:

    性能优化总纲——性能问题及性能调优方式

    性能优化第四篇——移动网络优化

    性能优化第三篇——Java(Android)代码优化
    性能优化第二篇——布局优化
    性能优化第一篇——数据库性能优化

    性能优化实例

     

    后续计划性能优化——诊断及工具(目前只有关于TraceView的介绍)、性能优化——内存篇、性能优化——JNI篇,性能优化——电量篇。

     

    2、何为性能问题
    在性能测试中存在两个概念:
    (1). 响应时间
    指从用户操作开始到系统给用户以正确反馈的时间。一般包括逻辑处理时间 + 网络传输时间 + 展现时间。对于非网络类应用不包括网络传输时间。

    展现时间即网页或 App 界面渲染时间。

     

    响应时间是用户对性能最直接的感受。

     

    (2). TPS(Transaction Per Second)

    TPS为每秒处理的事务数,是系统吞吐量的指标,在搜索系统中也用QPS(Query Per Second)衡量。TPS一般与响应时间反相关。

     

    通常所说的性能问题就是指响应时间过长、系统吞吐量过低。

     

    对后台开发来说,也常将高并发下内存泄漏归为性能问题。
    对移动开发来说,性能问题还包括电量、内存使用这两类较特殊情况。

     

    3、性能调优方式

    明白了何为性能问题之后,就能明白性能优化实际就是优化系统的响应时间,提高TPS。优化响应时间,提高TPS。方式不外乎这三大类:
    (1) 降低执行时间
    又包括几小类

    a. 利用多线程并发或分布式提高 TPS
    b. 缓存(包括对象缓存、IO 缓存、网络缓存等)
    c. 数据结构和算法优化
    d. 性能更优的底层接口调用,如 JNI 实现
    e. 逻辑优化
    f. 需求优化

     

    (2) 同步改异步,利用多线程提高TPS

     

    (3) 提前或延迟操作,错峰提高TPS

     

    对于数据库优化、布局优化、Java代码部分优化、网络优化都可以归纳到上面的几种方式中。具体见:

    性能优化第四篇——移动网络优化

    性能优化第三篇——Java(Android)代码优化
    性能优化第二篇——布局优化
    性能优化第一篇——数据库性能优化

    性能优化实例 

    展开全文
  • MySQL 高级性能优化实战包含范式设计,索引原理,执行计划,慢查询,锁和事务。旨在帮助程序设计人员架构千万级高并发交易一致性系统时全面,本课程适合Java初中高级程序员、开发经理、项目经理、架构师、CTO。
  • 前端优化是复杂的,针对方方面面的资源都有不同的方式。那么,前端优化的目的是什么 ?  1. 从用户角度而言,优化能够让页面加载得更快、对用户的操作响应得更及时,能够给用户提供更为友好的体验。  2. 从服务商...

    前言:关于优化问题,随着项目经验不断累积,多方查找资料进行拼接合并,形成如下文章,之后遇到类似好的方法,会不断补充完善。

    前端是庞大的,包括 HTML、 CSS、 Javascript、Image 、Flash等等各种各样的资源。前端优化是复杂的,针对方方面面的资源都有不同的方式。那么,前端优化的目的是什么 ?

    1. 从用户角度而言,优化能够让页面加载得更快、对用户的操作响应得更及时,能够给用户提供更为友好的体验。
    2. 从服务商角度而言,优化能够减少页面请求数、或者减小请求所占带宽,能够节省可观的资源。
    总之,恰当的优化不仅能够改善站点的用户体验并且能够节省相当的资源利用。

    大概有如下优化方法:



      具体参考:http://www.cnblogs.com/developersupport/p/webpage-performance-best-practices.html
      一、页面级优化
      1. 减少 HTTP请求数
      这条策略基本上所有前端人都知道,而且也是最重要最有效的。都说要减少 HTTP请求,那请求多了到底会怎么样呢 ?首先,每个请求都是有成本的,既包含时间成本也包含资源成本。一个完整的请求都需要经过 DNS寻址、与服务器建立连接、发送数据、等待服务器响应、接收数据这样一个 “漫长” 而复杂的过程。时间成本就是用户需要看到或者 “感受” 到这个资源是必须要等待这个过程结束的,资源上由于每个请求都需要携带数据,因此每个请求都需要占用带宽。另外,由于浏览器进行并发请求的请求数是有上限的 (具体参见此处 ),因此请求数多了以后,浏览器需要分批进行请求,因此会增加用户的等待时间,会给用户造成站点速度慢这样一个印象,即使可能用户能看到的第一屏的资源都已经请求完了,但是浏览器的进度条会一直存在。
      减少 HTTP请求数的主要途径包括:
      (1). 从设计实现层面简化页面
      如果你的页面像百度首页一样简单,那么接下来的规则基本上都用不着了。保持页面简洁、减少资源的使用时最直接的。如果不是这样,你的页面需要华丽的皮肤,则继续阅读下面的内容。
      (2). 合理设置 HTTP缓存
      缓存的力量是强大的,恰当的缓存设置可以大大的减少 HTTP请求。以有啊首页为例,当浏览器没有缓存的时候访问一共会发出 78个请求,共 600多 K数据 (如图 1.1),而当第二次访问即浏览器已缓存之后访问则仅有 10个请求,共 20多 K数据 (如图 1.2)。 (这里需要说明的是,如果直接 F5刷新页面的话效果是不一样的,这种情况下请求数还是一样,不过被缓存资源的请求服务器是 304响应,只有 Header没有Body ,可以节省带宽 )
      怎样才算合理设置 ?原则很简单,能缓存越多越好,能缓存越久越好。例如,很少变化的图片资源可以直接通过 HTTP Header中的Expires设置一个很长的过期头 ;变化不频繁而又可能会变的资源可以使用 Last-Modifed来做请求验证。尽可能的让资源能够在缓存中待得更久。关于 HTTP缓存的具体设置和原理此处就不再详述了,有兴趣的可以参考下列文章:
    HTTP1.1协议中关于缓存策略的描述
    Fiddler HTTP Performance中关于缓存的介绍
      (3). 资源合并与压缩
      如果可以的话,尽可能的将外部的脚本、样式进行合并,多个合为一个。另外, CSS、 Javascript、Image 都可以用相应的工具进行压缩,压缩后往往能省下不少空间。
      (4). CSS Sprites
      合并 CSS图片,减少请求数的又一个好办法。
      (5). Inline Images

      使用 data: URL scheme的方式将图片嵌入到页面或 CSS中,如果不考虑资源管理上的问题的话,不失为一个好办法。如果是嵌入页面的话换来的是增大了页面的体积,而且无法利用浏览器缓存。使用在 CSS中的图片则更为理想一些。

    .sample-inline-png {
        padding-left: 20px;
        background: white url('data:image/png;base64,iVBORw0KGgoAA
    AANSUhEUgAAABAAAAAQAQMAAAAlPW0iAAAABlBMVEUAAAD///+l2Z/dAAAAM0l
    EQVR4nGP4/5/h/1+G/58ZDrAz3D/McH8yw83NDDeNGe4Ug9C9zwz3gVLMDA/A6
    P9/AFGGFyjOXZtQAAAAAElFTkSuQmCC') no-repeat scroll left top;
    }
      (6). Lazy Load Images(自己对这一块的内容还是不了解)
      这条策略实际上并不一定能减少 HTTP请求数,但是却能在某些条件下或者页面刚加载时减少 HTTP请求数。对于图片而言,在页面刚加载的时候可以只加载第一屏,当用户继续往后滚屏的时候才加载后续的图片。这样一来,假如用户只对第一屏的内容感兴趣时,那剩余的图片请求就都节省了。 有啊首页 曾经的做法是在加载的时候把第一屏之后的图片地址缓存在 Textarea标签中,待用户往下滚屏的时候才 “惰性” 加载。

      2. 将外部脚本置底(将脚本内容在页面信息内容加载后再加载)
      前文有谈到,浏览器是可以并发请求的,这一特点使得其能够更快的加载资源,然而外链脚本在加载时却会阻塞其他资源,例如在脚本加载完成之前,它后面的图片、样式以及其他脚本都处于阻塞状态,直到脚本加载完成后才会开始加载。如果将脚本放在比较靠前的位置,则会影响整个页面的加载速度从而影响用户体验。解决这一问题的方法有很多,在 这里有比较详细的介绍 (这里是译文和 更详细的例子 ),而最简单可依赖的方法就是将脚本尽可能的往后挪,减少对并发下载的影响。
      3. 异步执行 inline脚本(其实原理和上面是一样,保证脚本在页面内容后面加载。)
      inline脚本对性能的影响与外部脚本相比,是有过之而无不及。首页,与外部脚本一样, inline脚本在执行的时候一样会阻塞并发请求,除此之外,由于浏览器在页面处理方面是单线程的,当 inline脚本在页面渲染之前执行时,页面的渲染工作则会被推迟。简而言之, inline脚本在执行的时候,页面处于空白状态。鉴于以上两点原因,建议将执行时间较长的 inline脚本异步执行,异步的方式有很多种,例如使用 script元素的defer 属性(存在兼容性问题和其他一些问题,例如不能使用 document.write)、使用setTimeout ,此外,在HTML5中引入了 Web Workers的机制,恰恰可以解决此类问题。

      4. Lazy Load Javascript(只有在需要加载的时候加载,在一般情况下并不加载信息内容。)

      随着 Javascript框架的流行,越来越多的站点也使用起了框架。不过,一个框架往往包括了很多的功能实现,这些功能并不是每一个页面都需要的,如果下载了不需要的脚本则算得上是一种资源浪费 -既浪费了带宽又浪费了执行花费的时间。目前的做法大概有两种,一种是为那些流量特别大的页面专门定制一个专用的 mini版框架,另一种则是 Lazy Load。YUI 则使用了第二种方式,在 YUI的实现中,最初只加载核心模块,其他模块可以等到需要使用的时候才加载。


      5. 将 CSS放在 HEAD中
      如果将 CSS放在其他地方比如 BODY中,则浏览器有可能还未下载和解析到 CSS就已经开始渲染页面了,这就导致页面由无 CSS状态跳转到 CSS状态,用户体验比较糟糕。除此之外,有些浏览器会在 CSS下载完成后才开始渲染页面,如果 CSS放在靠下的位置则会导致浏览器将渲染时间推迟。
      6. 异步请求 Callback(就是将一些行为样式提取出来,慢慢的加载信息的内容)
      在某些页面中可能存在这样一种需求,需要使用 script标签来异步的请求数据。类似:
      Javascript:

    function myCallback(info){ 
    //do something here 

      HTML:

      cb返回的内容 :
    myCallback('Hello world!');
    像以上这种方式直接在页面上写 <script>对页面的性能也是有影响的,即增加了页面首次加载的负担,推迟了 DOMLoaded和window.onload 事件的触发时机。如果时效性允许的话,可以考虑在 DOMLoaded事件触发的时候加载,或者使用 setTimeout方式来灵活的控制加载的时机。
      7. 减少不必要的 HTTP跳转
      对于以目录形式访问的 HTTP链接,很多人都会忽略链接最后是否带 ’/',假如你的服务器对此是区别对待的话,那么你也需要注意,这其中很可能隐藏了 301跳转,增加了多余请求。具体参见下图,其中第一个链接是以无 ’/'结尾的方式访问的,于是服务器有了一次跳转。
      8. 避免重复的资源请求
      这种情况主要是由于疏忽或页面由多个模块拼接而成,然后每个模块中请求了同样的资源时,会导致资源的重复请求

            9 精简Javascript和CSS

    精简就是将Javascript或CSS中的空格和注释全去掉,

    复制代码
    复制代码
    body {
        line-height: 1;
    }
    ol, ul {
        list-style: none;
    }
    blockquote, q {
        quotes: none;
    }
    复制代码
    复制代码

    精简后版本

    复制代码
    body{line-height:1}ol,ul{list-style:none}blockquote,q{quotes:none}
    复制代码

    统计表明精简后的文件大小平均减少了21%,即使在应用Gzip的文件也会减少5%。

    用来帮助我们做精简的工具很多,主要可以参考如下,

    JS compressors:

    CSS compressors:

    与VS集成比较好的工具如下.


      二、代码级优化
      1. Javascript
      (1). DOM
      DOM操作应该是脚本中最耗性能的一类操作,例如增加、修改、删除 DOM元素或者对 DOM集合进行操作。如果脚本中包含了大量的 DOM操作则需要注意以下几点:
      a. HTML Collection(HTML收集器,返回的是一个数组内容信息)
      在脚本中 document.images、document.forms 、getElementsByTagName()返回的都是 HTMLCollection类型的集合,在平时使用的时候大多将它作为数组来使用,因为它有 length属性,也可以使用索引访问每一个元素。不过在访问性能上则比数组要差很多,原因是这个集合并不是一个静态的结果,它表示的仅仅是一个特定的查询,每次访问该集合时都会重新执行这个查询从而更新查询结果。所谓的 “访问集合” 包括读取集合的 length属性、访问集合中的元素。
      因此,当你需要遍历 HTML Collection的时候,尽量将它转为数组后再访问,以提高性能。即使不转换为数组,也请尽可能少的访问它,例如在遍历的时候可以将 length属性、成员保存到局部变量后再使用局部变量。
      b. Reflow & Repaint
      除了上面一点之外, DOM操作还需要考虑浏览器的 Reflow和Repaint ,因为这些都是需要消耗资源的,具体的可以参加以下文章:
    如何减少浏览器的repaint和reflow?
    Understanding Internet Explorer Rendering Behaviour
    Notes on HTML Reflow

      (2). 慎用 with
    with(obj){ p = 1}; 代码块的行为实际上是修改了代码块中的 执行环境 ,将obj放在了其作用域链的最前端,在 with代码块中访问非局部变量是都是先从 obj上开始查找,如果没有再依次按作用域链向上查找,因此使用 with相当于增加了作用域链长度。而每次查找作用域链都是要消耗时间的,过长的作用域链会导致查找性能下降。
      因此,除非你能肯定在 with代码中只访问 obj中的属性,否则慎用 with,替代的可以使用局部变量缓存需要访问的属性。
      (3). 避免使用 eval和 Function
      每次 eval 或 Function 构造函数作用于字符串表示的源代码时,脚本引擎都需要将源代码转换成可执行代码。这是很消耗资源的操作 —— 通常比简单的函数调用慢 100倍以上。
      eval 函数效率特别低,由于事先无法知晓传给 eval 的字符串中的内容,eval在其上下文中解释要处理的代码,也就是说编译器无法优化上下文,因此只能有浏览器在运行时解释代码。这对性能影响很大。
      Function 构造函数比 eval略好,因为使用此代码不会影响周围代码 ;但其速度仍很慢。
      此外,使用 eval和 Function也不利于Javascript 压缩工具执行压缩。
      (4). 减少作用域链查找(这方面设计到一些内容的相关问题)
      前文谈到了作用域链查找问题,这一点在循环中是尤其需要注意的问题。如果在循环中需要访问非本作用域下的变量时请在遍历之前用局部变量缓存该变量,并在遍历结束后再重写那个变量,这一点对全局变量尤其重要,因为全局变量处于作用域链的最顶端,访问时的查找次数是最多的。
      低效率的写法:
    // 全局变量 
    var globalVar = 1; 
    function myCallback(info){ 
    for( var i = 100000; i--;){ 
    //每次访问 globalVar 都需要查找到作用域链最顶端,本例中需要访问 100000 次 
    globalVar += i; 
    }

      更高效的写法:
    // 全局变量 
    var globalVar = 1; 
    function myCallback(info){ 
    //局部变量缓存全局变量 
    var localVar = globalVar; 
    for( var i = 100000; i--;){ 
    //访问局部变量是最快的 
    localVar += i; 

    //本例中只需要访问 2次全局变量
    在函数中只需要将 globalVar中内容的值赋给localVar 中区
    globalVar = localVar; 
    }
      此外,要减少作用域链查找还应该减少闭包的使用。
      (5). 数据访问
      Javascript中的数据访问包括直接量 (字符串、正则表达式 )、变量、对象属性以及数组,其中对直接量和局部变量的访问是最快的,对对象属性以及数组的访问需要更大的开销。当出现以下情况时,建议将数据放入局部变量:
      a. 对任何对象属性的访问超过 1次
      b. 对任何数组成员的访问次数超过 1次
      另外,还应当尽可能的减少对对象以及数组深度查找。
      (6). 字符串拼接
      在 Javascript中使用"+" 号来拼接字符串效率是比较低的,因为每次运行都会开辟新的内存并生成新的字符串变量,然后将拼接结果赋值给新变量。与之相比更为高效的做法是使用数组的 join方法,即将需要拼接的字符串放在数组中最后调用其 join方法得到结果。不过由于使用数组也有一定的开销,因此当需要拼接的字符串较多的时候可以考虑用此方法。

      关于 Javascript优化的更详细介绍请参考:
    Write Efficient Javascript(PPT)
    Efficient JavaScript
      2. CSS选择符
      在大多数人的观念中,都觉得浏览器对 CSS选择符的解析式从左往右进行的,例如
    #toc A { color: #444; }
      这样一个选择符,如果是从右往左解析则效率会很高,因为第一个 ID选择基本上就把查找的范围限定了,但实际上浏览器对选择符的解析是从右往左进行的。如上面的选择符,浏览器必须遍历查找每一个 A标签的祖先节点,效率并不像之前想象的那样高。根据浏览器的这一行为特点,在写选择符的时候需要注意很多事项,有人已经一一列举了, 详情参考此处。

      3. HTML
      对 HTML本身的优化现如今也越来越多的受人关注了,详情可以参见这篇 总结性文章 。

      4. Image压缩
      图片压缩是个技术活,不过现如今这方面的工具也非常多,压缩之后往往能带来不错的效果,具体的压缩原理以及方法在《 Even Faster Web Sites》第10 章有很详细的介绍,有兴趣的可以去看看。
      总结
      本文从页面级以及代码级两个粒度对前端优化的各种方式做了一个总结,这些方法基本上都是前端开发人员在开发的过程中可以借鉴和实践的,除此之外,完整的前端优化还应该包括很多其他的途径,例如 CDN、 Gzip、多域名、无 Cookie服务器等等,由于对于开发人员的可操作性并不强大,在此也就不多叙述了,详细的可以参考 Yahoo和Google 的这些“金科玉律。
    展开全文
  • 性能优化概述

    2018-02-03 22:38:14
    如何做性能优化 确定优化目标 定位性能瓶颈 制定优化方法 测试优化效果 性能优化目标是什么 吞吐量,越大越好 延时,越低越好 同样的资源下(前提),吞吐量越高越好,响应时间越低越好。通俗的讲就是:多...

    如何做性能优化

    1. 确定优化目标
    2. 定位性能瓶颈
    3. 制定优化方法
    4. 测试优化效果

    性能优化目标是什么

    1. 吞吐量,越大越好
    2. 延时,越低越好

    同样的资源下(前提),吞吐量越高越好,响应时间越低越好。通俗的讲就是:多快好省。

    如何定位系统性能的瓶颈呢

    1. 资源分析
    2. 代码分析

    资源分析

    资源分析以对系统资源的分析为起点,涉及的系统资源有:CPU,内存,磁盘,网卡。通过对资源使用率的分析,判断某项资源是否已经处于或接近极限。

    常用的分析工具有:top,free,vmstat,iostat,iotop,netstat。更多工具见下图:

    来自 Brendan Gregg 的性能观测工具图

    通常资源使用率超过 60% 可能会是问题,为什么呢?因为时间间隔的均值,掩盖了使用率 100% 的短期爆发。

    定位瓶颈之后,可以通过增加资源来提升性能,也可以通过优化系统减少资源占用来优化性能。

    代码分析

    根据2:8原则来说,20%的代码消耗了80%的性能,找到那20%的代码,你就可以优化那80%的性能。

    通常使用 Profiler 工具,来收集程序运行时的信息。如果 CPU 是瓶颈,寻找那些消耗 CPU 最多的代码去优化。如果内存是瓶颈,则优化消耗内存最多的代码。

    常用的 Profiler,有 Linux 的 OProfile/perf,Java 的 JProfiler/JMC。

    常见的性能优化方法

    一般性能优化方法有两种:一是,从代码层面优化,提升某个方法的性能,从而提升单机性能;二是,从系统结构层面优化,通过减少无用功,来减少资源消耗。

    代码层面优化

    1. Buffer:缓解应用系统上下层组件之间的性能差异,比如通常的 IO Buffer。
    2. Cache:通常用于读多写少的情况,也是用来缓解应用系统上下层组件之间的性能差异。比如,应用 local cache,Memcached/Redis。
    3. Batch:网络或磁盘里的批量操作,通过合并小任务或小请求为大任务大请求,来提升数据传输效率低。比如 TCP 中的 nagle 算法,就是通过合并多个小分组来提升网络传输效率的。
    4. Pool:通过减少对象创建,连接建立的开销来提升性能。比如线程池,连接池,对象池。
    5. Concurrency:通过将串行改为并行,能过有效的降低系统延时。在多核系统中,并行处理才能提升 CPU 使用率。
    6. Lock Less:多线程访问共享资源时,通常需要加锁。重量级的锁往往引起线程切换,而线程切换非常耗时。那么可以通过优化锁的使用来提升性能,优化锁有两种方法:
      • 通过减小锁的粒度,分离竞争点来减少竞争。比如 Java 里 HashTable 中锁的粒度是整个对象,ConcurrentHashMap 中锁的粒度只是一个 Segment。
      • 在竞争较少的情况下,使用轻量级锁来代替重量级锁,减少线程切换带来的性能消耗,比如自旋锁代替互斥锁。

    系统架构优化

    可以看看:性能优化案例(一):通过修改路由算法提升系统性能

    如何做性能基准测试

    什么是有效的性能基准测试呢?

    基准测试是指通过设计科学的测试方法、测试工具和测试系统,实现对一类测试对象的某项性能指标进行定量的和可对比的测试。有以下特性:
    1. 可重复:就像科学实验一样,能够被他人重复,才能被认可
    2. 可观测:测试结果能过被分析和理解
    3. 可对比:通过对比,才能知道性能优化的效果
    3. 符合现实:测量结果符合现实情况
    4. 易执行:开发人员能快速地修改系统并测试

    基准测试有三种类型:微基准测试,模拟,回放。从下图可以看出来,回放最接近生产环境。
    基准测试类型

    微基准测试利用人造的工作负载对某类特定的操作做测试,例如执行一种类型文件系统I/O,数据库查询,系统调用。其优势是简单:
    1. 对组件的数量和所牵扯的代码路径做限制,能更容易地研究目标,从而快速地确定性能差异的根源。
    2. 因为来自其他组件的变化以及尽可能的被玻璃了,所以测试通常是可重复的。

    许多基准测试会模拟客户应用程序的工作负载,基于生产环境的工作负载特征,来决定所要模拟的特征。模拟所生成的结果与客户在真实世界所执行的工作负载是相似的。相较于微基准测试。模拟能覆盖复杂系统相互作用的影响,这点是微基准测试可能缺失的。

    回放:用真实捕捉到的客户机的操作,来测试性能。有很多分布式服务框架带有复制线上流量,引流到测试机器的功能。

    做性能测试时,要多去思考性能数据背后的根本原因,避免因各种外界因素的干扰导致测试失真。

    参考资料:

    1. 《性能之巅:洞悉系统,企业与云计算》
    2. Linux Performance
    展开全文
  • https://download.csdn.net/download/qq_30353203/10616634,这是一个JVM体系结构与GC调优PPT,写的非常好。 我的技术公众号,有兴趣可以关注一起交流 ...1 性能调优简介 1.1为什么要进行性能调优? ...

    https://download.csdn.net/download/qq_30353203/10616634,这是一个JVM体系结构与GC调优PPT,写的非常好。

    我的技术公众号,有兴趣可以关注一起交流

    写blog和写代码一样,刚开始都是不完美的,需要不断的修正和重构,如果大家在阅读本blog中发现任何问题和疑问,都欢迎讨论或拍砖。

    1 性能调优简介

    1.1为什么要进行性能调优?

    1.1.1 编写的新应用上线前在性能上无法满足需求,这个时候需要对系统进行性能调优

    1.1.2 应用系统在线上运行后随着系统数据量的不断增长、访问量的不断上升,系统的响应速度通常越来越慢,不满足业务需要,这个时候也需要对系统进行性能调优

    1.2 性能调优包括那些方面?

    1.2.1 谈到系统或产品的性能调优,可以从广义和狭义两个范围来理解。

    从广义的层面来看,就不仅限于程序内部了,因为造成系统性能问题的瓶颈很可能来源于方方面面,而这种情况往往是性能调优很普遍的情况,

    下面就从广义的范围细分成几个角度来进行阐述,见图-1 广义性能调优鱼骨图

    图-1 广义性能调优鱼骨图

    1.2.2从狭义的范畴来看,性能调优主要是指通过修改软件程序逻辑、结构等技术手段提升软件产品的各项性能指标,如响应时间等。本文重要是从狭义的范畴来看。

    从狭义的范畴看,性能调优可以从 硬件(计算机体系机构)、操作系统(OS\JVM)、文件系统、网络通信、数据库系统、中间件、应用程序本身等方面入手。

    这里主要关注JVM、中间件、应用程序的性能调优。

    1.3 性能的参考指标

    执行时间:一段代码从开始运行到运行结束所使用的时间。

    CPU时间:(算法)函数或者线程占用CPU的时间。

    内存分配:程序在运行时占用的内存空间。

    磁盘吞吐量:描述I/O的使用情况。

    网络吞吐量:描述网络的使用情况。

    响应时间:系统对某用户行为或者动作做出响应的时间。响应时间越短,性能好。

    2 性能调优步骤

    2.1性能调优步骤图

    图-2性能调优步骤图

    调优前首先要做的是衡量系统现状,这包括目前系统的请求次数、响应时间、资源消耗等信息,例如B系统目前95%的请求响应时间为1秒。

    在有了系统现状后可设定调优目标,通常调优目标是根据用户所能接受的响应速度或系统所拥有的机器以及所支撑的用户量估算出来的,例如 设定调优目标:95%的请求要在500ms内返回。

    在设定了调优目标后,需要做的是寻找性能瓶颈,这一步最重要的是找出造成目前系统性能不足的最大瓶颈点。找出后,可结合一些工具来找出造成瓶颈点的代码,到此才完成了这个步骤。

    在找到了造成瓶颈点的代码后,开始进行性能调优。通常需要分析其需求或业务场景,然后结合一些优化的技巧确定优化的策略,优化策略或简或繁,选择其中收益比(优化后的预期效果/优化需要付出的代价)最高的优化方案,进行优化。

    优化部署后,继续衡量系统的状况,如已达到目标,则可结束此次调优,如仍未达到目标,则要看是否产生了新的性能瓶颈。或可以考虑继续尝试上一步中制定的其他优化方案,直到达成调优目标或论证在目前的体系结构上无法达到调优目标为止。

    3 性能调优思路

    性能调优的步骤主要有:衡量系统现状、设定调优目标、寻找性能瓶颈、性能调优,验证是否达到调优目标。

    本文档主要关注调优步骤中的 寻找性能瓶颈 和 性能调整(优) 两个关键的阶段阶段,主要思路见下图:图-3 寻找性能瓶颈和性能调优项结构分解图

    图-3 寻找性能瓶颈和性能调优项结构分解图

    4 寻找性能瓶颈

    寻找性能瓶颈分个两部分:寻找过度消耗资源的代码 和 寻找未充分使用资源但程序执行慢的原因和代码。

    通常性能瓶颈的表象是资源消耗过多外部处理系统的性能不足;或者资源消耗不多但程序的响应速度却仍达不到要求。

    这里资源主要是指:消耗在CPU、内存、文件IO、网络IO等方面资源。机器的资源是有限的,当某资源消耗过多时,通常会造成系统的响应速度慢。

    外部处理系统的性能不足主要是指所调用的其他系统提供的功能(如数据库操作的响应速度不够);所调用的其他系统性能不足多数情况下也是资源消耗过多,但程序的性能不足造成的; 数据库操作性能不足通常可以根据数据库的sql执行速度、数据库机器的IOPS、数据库的Active Sessions等分析出来。

    寻找未充分使用资源但程序执行慢的原因和代码:资源消耗不多、但程序的响应速度仍然达不到要求的主要原因是程序代码运行效率不够高、未充分使用资源或程序结构不合理。

    对于Java应用而言,寻找性能瓶颈的方法通常为首先分析资源的消耗,然后结合OS和Java等一些分析工具来查找程序中造成资源消耗过多的代码。

    4.1CPU消耗分析

    在Linux中,CPU主要用于 中断、内核进程以及用户进程的任务处理,优先级为:中断 > 内核进程 > 用户进程,在学习如何分析CPU消耗状况前,有三个重要概念交代一下。

    4.1.1 上下文切换、运行队列、利用率

    4.1.1.1上下文切换

    每个CPU(或多核CPU中的每核CPU)在同一时间只能执行一个线程。 Linux采用的是抢占式调度:即为每个线程分配一定的执行时间,当到达执行时间、线程中有IO阻塞或高优先级线程要执行时,Linux将切换执行的线程,在切换时要存储目前程序的执行状态PCB(Program Control Block),并恢复要执行的线程的状态,这个过程就称为上下文切换。

    对于Java应用,典型的是在进行文件IO操作、网络IO操作、锁等待或线程Sleep时,当前线程会进入阻塞或休眠状态,从而触发上下文切换,上下文切换过多会造成内核占据较多的CPU使用,使得应用的响应速度下降。

    4.1.1.2运行队列

    每个CPU核都维护了一个可运行的线程队列,例如一个4核的CPU, Java应用中启动了8个线程,且这8个线程都处于可运行状态,那么在分配平均的情况下每个CPU中的运行队列里就会有两个线程。通常而言,系统的load主要由CPU的运行队列来决定,假设以上状况维持了1分钟,那么这1分钟内系统的load就会是2,但由于load是个复杂的值,因此也不是绝对的,运行队列值越大,就意味着线程要消耗越长的时间才能执行完。 Linux System and NewWork Performance Monitoring中建议控制在每个CPU核上的运行队列为1-3个。

    4.1.1.3利用率

    CPU利用率为CPU在用户进程、内核进程、中断处理、IO等待以及空闲五个部分使用的百分比,这五个值是用来分析CPU消耗情况的关键指标。 Linux System and NewWork Performance Monitoring 中建议用户进程的CPU消耗/内核的CPU消耗的比例在 65%-70% / 30%-35%

    4.1.2Linux观测CPU消耗状态的工具:perf、top、vmstat、pidstat、sar、pcpu、ps Hh -eo tid

    4.1.2.0 工具 perf 性能测试工具

    sudo apt-get install linux-tools-common

    sudo apt-get install linux-tools-3.13.0-27-generic

    4.1.2.1工具top

    用工具SSH登陆到Linux 上后,在字符界面下输入top命令后即可查看CPU的消耗情况,CPU的信息在TOP视图的上面几行中

    图-4 Top查看CPU使用情况图:第四行被矩形围起来的部分:其中 0.2% us 表示用户进程处理所占的百分比;0.7% sy 表示为内核线程处理所占的百分比; 0.0% ni 表示被nice命令改变优先级的任务所占的百分比;99.0% id 表示CPU的idle空闲时间所占的百分比; 0.0% wa 表示在执行的过程中等待IO所占的百分比; 0.2% hi 表示硬件中断所占的百分比; 0.0% si 表示软件中断所占的百分比。

    图-4 Top查看CPU使用情况图

    linux下查看根据进程查看线程的方法

    1、cat /proc/${pid}/status

    2、pstree -p ${pid}

    3、3.1 top -p ${pid} 再top 中键入[Shift]-[H]组合键。

    3.2 或者直接输入 top -bH -d 3 -p ${pid}

    top -H 手册中说:-H : Threads toggle

    加上这个选项启动top,top一行显示一个线程。否则,它一行显示一个进程。

    1 先用ps + grep找出该死的进程pid,比如 30420

    2 top -H -p 30420,(top然后shift+H可以看出某个线程)所有该进程的线程都列出来了。看看哪个线程pid占用最多,然后将这个pid转换为16进制,如 44bf,注意要小写

    3 jstack 30420 | less,然后查找 nid=0x44bf,,找到了

    4、ps xH

    手册中说:H Show threads as if they were processes

    这样可以查看所有存在的线程。

    5、ps -mp <PID>

    手册中说:m Show threads after processes

    这样可以查看一个进程起的线程数。

    4.1.2.2工具pidstat

    pidstat 是SYSSTAT中的工具.,如需使用pidstat,请先安装SYSSTAT:http://www.icewalkers.com/Linux/Software/59040/sysstat.html

    安装方法: root$ sudo apt-get install sysstat

    SYSSTAT包含工具有:sysstat, sar, sadf, iostat, pidstat,mpstat, nfsiostat and cifsiostat commands for Linux.

    使用例子:

    sar -n DEV 1 100

    sar -n DEV 1 100 | grep lo

    输入pidstat 1 2,在console上将会每隔1秒输出目前活动进程的CPU消耗状况,共输出2次,结果图-5 pidstat使用示例图 所示:

    图-5 pidstat使用示例图

    其中CPU表示的为当前进程所使用到的CPU个数,

    如须查看进程中线程的CPU消耗状况,可以输入 pidstat -p [PID] -t 1 5 这样的方式来查看,执行后的输出如下:

    图-6

    图中的TID即为线程ID,较之top命令方式而言, pidstat的好处为可查看每个线程的具体CPU利用率的状况( 例如%usr 、%system )

    4.1.2.3CPU消耗方面相关工具介绍

    除了top、pidstat外、linux中还可以使用vmstat来采样(例如每秒 vmstat 1)查看CPU的上下文切换、运行队列、利用率的具体信息。
    ps Hh -eo tid,pcpu 方式也可用来查看具体线程的CPU消耗状况;sar来查看一定时间范围内以及历史的cpu消耗状况信息。

    SYSSTAT包含工具有:Sysstat, sar, sadf, iostat, pidstat,mpstat, nfsiostat and cifsiostat commands for Linux.

    The sysstat package contains the sar, sadf, iostat, nfsiostat, cifsiostat, pidstat and mpstat commands for Linux.

    The sar command collects and reports system activity information. The information collected by sar can be saved in a file in a binary format for future inspection. The statistics reported by sar concern I/O transfer rates, paging activity, process-related activities, interrupts, network activity, memory and swap space utilization, CPU utilization, kernel activities and TTY statistics, among others.

    The sadf command may be used to display data collected by sar in various formats (CSV, XML, database-friendly, etc.).

    The iostat command reports CPU utilization and I/O statistics for disks and network filesystems.

    The pidstat command reports statistics for Linux tasks (processes).

    The mpstat command reports global and per-processor statistics. Both UP and SMP machines are fully supported.

    Sysstat has also support for hotplug CPU's, and for National Language (NLS).

    The nfsiostat command reports I/O statistics for network filesystems.

    The cifsiostat command reports I/O statistics for CIFS filesystems.

    当CPU消耗严重时,主要体现在us、sy、wa 或 hi的值变高, wa的值是IO等待造成的,hi的值变高主要为硬件终端造成的,例如网卡接受数据频繁的状况。

    对于Java应用而言,CPU消耗严重主要体现在us、sy两个值上,分别看看Java应用在这两个值高的情况下应如何找到对应造成瓶颈的代码。

    4.1.3 us (CPU的用户进程处理所占的百分比)

    当us值过高时,表示运行的应用消耗了大部分的CPU. 在这种情况下,对于Java应用而言,最重要的是找到具体消耗CPU的线程及锁执行的代码。

    pstack显示每个进程的栈跟踪

    pstree以树结构显示进程

    方法如下:

    首先通过Linux提供的命令(如:top/jps找到java进程pid,然后pidstat通过进程pid找到对应的线程tid)找到消耗CPU严重的线程及其ID,将此线程ID转化为十六进制的值。

    其次通过kill -3 [javapid]或jstack 的方式dump出应用的java线程信息,通过之前转化出的十六进制的值找到对应的nid值的线程。此线程即为消耗CPU的线程,在采样时须多执行几次上述的过程,以确保找到真实的消耗CPU的线程。

    寻找过程:第一步:jps找到java进程号PID=2418, 然后pidstat -p 2418 -t 1 5 | less 找到消耗CPU多的线程号tid=2428,然后将tid=2428(十进制) 转换为十六进制数:97C.

    图-7 jps命令图

    图-8 pidstat 找到消耗CPU高的tid线程ID

    第二步:jstack 2418 > jstack03.txt 将线程dump信息写入文件jstack03.txt, 然后将十六进制的线程数:97C 为79C为查询条件,到jstack03.txt文件中查找到nid= 97C的线程,该线程即为消耗CPU多的线程。

    图-9 线程栈dump信息

    从上可以看出,主要是ConsumeCPUTask的执行消耗了CPU,但由于jstack需要时间,因此基于jstack并不一定能分析出真正的消耗CPU的代码是哪行。

    例如在一个操作中循环调用了很多其他的操作,如其他的操作每次都比较快,但由于循环太多次,造成了CPU消耗,在这种情况下jstack是无法捕捉出来的。最佳方式是通过 intel vtune来进行分析,vtune是商业软件(Intel芯片的一款性能分析软件,用AMD芯片的同学就不能用了)。

    在不使用vtune的情况下,则只能通过认真查看整个线程中执行的动作来分析原因,例如在从上图中,可以看出ConsumeCPUTask一直处于运行状态,可以分析ConsumeCPUTask这个线程具体在做的动作,从其代码可看出真个线程一直处于运行过程中,中途没有IO中断、锁等待现象,因此造成了CPU消耗严重。

    该示例源代码UsHighOfCpuDemo.java下载地址为:见参考部分

    4.1.4 sy (内核线程处理所占的百分比)

    当sy值高时表示Linux花费了更多的时间在进行线程切换,Java应用造成这种现象的主要原因是启动的线程比较多,且这些线程多数都处于不断的阻塞(例如锁等待、IO等待状态)和执行状态的变化过程中,这就导致了操作系统要不断地切换执行的线程,产生大量的上下文切换。在这种状况下,对Java应用而言,最重要的是找出线程不断切换状态的原因,可采用的方法为通过 kill -3 [javapid] 或jstack -l [javapid] 的方式dump出java应用程序的线程信息,查看线程的状态信息以及锁信息,找出等待状态或锁竞争过多的线程。

    第一步运行 [root@localhost example]# java -jar SyHighOfCpuDemo.jar , top图如下: CPU的 sy使用比较高

    图-10

    在用vmstat -n 3 执行一下看一下上下文切换情况

    图-11

    由上可知,CPU在cs(内核线程上下文切换) 以及sy上消耗很大。

    第二步 运行时采用jstack -l 查看程序的线程状况,可以看到启动了很多线程,并且很多的线程都经常处于 TIMED_WAITING(on object monitor)状态、WAITING (on object monitor)和Runnable状态的切换中。

    通过on object monitor对应的堆栈信息,可查找到系统中锁竞争激烈的代码,这是造成系统更多时间消耗在线程上下文切换的原因。

    具体TIMED_WAITING(on object monitor)状态、WAITING (on object monitor)和Runnable状态如下图

    图-12

    图-13

    图-14

    该示例源代码SyHighOfCpuDemo.java下载地址为:见参考

    4.2内存消耗分析

    Java应用对于内存的使用包括两方面 JVM堆内存 和 JVM堆外内存。 Java应用对内存的消耗上主要是在JVM堆内存上。在正式环境中,多数Java应用都会将 -Xms 和 -Xmx设为相同的值,避免运行期要不断申请内存。

    目前Java应用只有在创建线程和使用Direct ByteBuffer 时才会操作JVM堆外的内存JVM,因此在内存消耗方面最值得关注的是JVM内存的消耗状况。对于JVM内存消耗状况分析的方法工具有:JVM(jmap、jstat、mat、visualvm等方法)。JVM内存消耗过多会导致GC执行频繁,CPU消耗增加,应用线程的执行速度严重下降,甚至造成OutOfMemoryError,最终导致Java进程退出。

     sudo -u admin  /opt/taobao/java/bin/jmap -F -dump:live,format=b,file=/home/admin/dumpcrash_20150909_2.log 6606
     sudo -u admin  /opt/company/java/bin/jmap -F -dump:file=/home/user/dumpcrash_xxx.log 1234
     /opt/company/java/bin/jmap -F -dump:file=/home/user/dumpcrash_xxx.log 1234
      jmap -histo 13321> dump_platform.core 
      jmap -dump:live,format=b,file=heap_platform.core 13321
      jmap –dump:file=<文件名>,format=b [pid] 

    分析jmap的dump文件: Eclipse Memory Analyzer http://www.eclipse.org/mat/downloads.php

    对于JVM堆以外的内存方面的消耗,最为值得关注的是swap的消耗 以及 物理内存的消耗,这两方面的消耗都可基于操作系统的命令来查看。

    方法区Method Area内存大小对应的配置参数是:-XX:PermSize -XX:MaxPermSize 这个抛出OutOfMemoryError: PermGen space (常量池或类太多,如反射,CGLib等)

    Java堆Heap内存大小对应的配置参数是:-Xms -Xmx 这个抛出OutOfMemoryError: Java heap space

    虚拟机栈VM stack内存大小对应的配置参数是:-Xss 这个抛出StackOverflowError; OutOfMemoryError:unable to create new native thread

    本地方法栈Native Method stack内存大小对应的配置参数是:-XX:DirectoryByteBuffer -XX:MaxDirectoryByteBuff 这个抛出OutOfMemoryError: sun.misc.Unsafe.allocateMemory(Native Method)

    在Java语言中,对象访问是如何进行的呢?

    对象访问在Java语言中无处不在的,即使最普通的程序行为,也会涉及Java栈、Java堆、方法区这三个最重要内存区域之间的关联关系,如下代码:

    Object obj = new Object();

    假设这句代码出现在方法体中,那“Object obj”这部分的语义将会反映到【Java栈】的本地变量表中,作为一个reference类型数据出现。

    而“new Object()”这部分的语义将会反映到【Java堆】中,形成一块存储了Object类型所有实例数据值(Instance Data,对象中各个实例字段的数据)的结构化内存,根据具体类型以及虚拟机实现的对象内存布局(Object Memory Layout)的不同,这块内存的长度是不固定的。

    另外在Java堆中还必须包含能查找到此对象类型数据(如对象类型、父类、实现的接口、方法等)的地址信息,这些类型数据则存储在【方法区Method Area】中。

    类加载的步骤:

    4.2.1内存消耗分析工具介绍

    在Linux中可通过vmstat、sar、top、pidstat, pmap等方式来查看 swap和物理内存的消耗状况。

    4.2.1.1 vmstat

    在命令行中输入vmstat,其中的信息和内存相关的主要是memory下的swpd、free、buff、cache以及swap下的si 和 so.

    图-15

    其中swpd是指虚拟内存已使用的部分,单位为kb;free表示空闲的物理内存;buffer表示用于缓冲的内存;cache表示用于作为缓存的内存
    swap下的si是指每秒从disk读至内存的数据量;so是指每秒从内存中写入disk的数据量。

    swpd值过高通常是由于物理内存不够用,操作系统将物理内存中的一部分数据转为放入硬盘上进行存储,以腾出足够的空间给当前运行的程序使用。

    在目前运行的程序变化后,即从硬盘上重新读取数据到内存中,以便恢复程序的运行,这个过程会产生swap IO, 因此看swap的消耗情况主要关注的是swapIO的状况,如swapIO发生得较频繁,那么严重影响系统的性能。

    由于Java应用是单进程应用,因此只要JVM的内存设置不是过大,是不会操作到swap区域的。物理内存消耗过高可能是由于JVM内存设置过大、创建的Java线程过多或通过Direct ByteBuffer往物理内存中放置了过多的对象造成的。

    4.2.2.2 sar

    通过sar的-r参数可查看内存的消耗状况,例如sar -r 2 5

    图-16

    物理内存相关的信息主要是kbmemfree、kbmemused、%memused、kbbuffers、kbcached, 当物理内存有空闲时,Linux会使用一些物理内存用于buffer和cache, 以提升系统的运行效率,因此可以认为系统中可用的物理内存为: kbmemfree + kbmemused + kbcached.

    sar相比vmstat的好处是可以查询历史状况,以更加准确地分析趋势状况,例如 sar -r -f /temp/log/sa/sa12

    vmstat 和 sar的共同弱点是不能分析进程所占用的内存量。

    4.2.2.3 top

    通过top可查看进程所消耗的内存量,不过top中看到的Java进程消耗的内存。因为Java进程是包括了JVM已分配的内存加上Java应用所耗费的JVM以外的物理内存,这会导致top中看到Java进程所消耗的内存大小有可能超过 -Xmx 加上 -XX:MaxPermSize设置的内存大小,并且Java程序在启动后也只是占据了-Xms的地址空间,但并没有占据实际的内存,只有在相应的地址空间被使用过后才被计入消耗的内存中。因此纯粹的根据top很难判断出Java进程消耗的内存中有多少是属于JVM的,有多少是属于JVM外的内存。

    一个小技巧是对由于内存满而发生过Full GC的应用而言(不是主动调用System.gc的应用),多数情况下(例如由于产生的对象过大导致执行Full GC并抛出OutOfMemoryError的现象就要出外)可以认为其Java进程中显示出来的内存消耗值即为 JVM -Xmx的值 + 消耗的JVM外的内存值。

    图-17

    4.2.2.4pidstat

    通过 pid也可以查看进程所消耗的内存量,命令格式为: pidstat -r -p [pid] [interval] [times], 例如如下:

    图-18

    查看该进程所占用的物理内存RSS(Resident Set Size)和虚拟内存的大小VSZ(virtual memory size)。

    从以上的几个工具来看,最佳的内存消耗分析方法是结合top或pidstat,以及JVM的内存分析工具来共同分析内存消耗状况。

    下面通过例子分别展示Java应用对物理内存的消耗和对JVM堆内的消耗。

    4.2.2 JVM堆外内存消耗分析

    基于Direct ByteBuffer可以很容易地实现对物理内存的直接操作,而无须耗费JVM heap区。

    例子中,为了更清晰地观察内存的变化情况,放入了多个Thread.sleep,加上 -Xms140 -Xmx140参数执行上面的代码,在执行过程中结合top命令和jstat命令查看java进程占用内存的大小以及JVM heap的变化情况。

    [root@localhost ~]# jps
    4661 jar
    4670 Jps
    [root@localhost ~]# pidstat -r -p 4661 1 100

    jps找到java进程,jstat -gcutil [pid] 1000 10

    代码示例:HighNonHeapOfMemoryDemo.java

    结合上面top和jstat观察到的状态,可以查出 direct bytebuffer消耗的是JVM heap 外的物理内存。但它同样是基于GC方式来释放的,同时也可以看出JVM heap一旦使用后,即使进行了GC,进行中仍然会显示之前其所消耗的内存大小,因此JVM内存中具体的消耗状况必须通过JDK提供的命令才可以准确分析。

    除了Direct Bytebuffer方式对JVM外物理内存的消耗外,创建线程也会消耗一定大小的内存。这一方面取决于-Xss对应值的大小,另一方面也取决于线程stack的深度,当线程退出时,其所占用的内存将自动释放。

    4.2.3JVM堆内存消耗分析(需要重点补充)

    Java应用中除了Direct Bytebuffer、创建线程等操作JVM外物理内存的方法外,大多数都是对于JVM heap区的消耗。

    在Java程序出现内存消耗过多、GC频繁或OutOfMemoryError的情况后,要首先分析其所耗费的是JVM外的物理内存还是JVM heap区。 如为JVM外的物理内存,则要分析程序中线程的数量以及Direct Bytebuffer的使用情况;如果为JVM heap区,则要结合JDK提供的工具或外部的工具分析程序中的具体对象的内存占用情况。

    4.3文件IO消耗分析

    4.3.1 文件IO分析的常用命令

    Linux在操作文件时,将数据放入文件缓存区,直到内存不够或系统要释放内存给用户进程使用时,才写入文件中。因此在查看Linux内存状况时经常会发现可用(free)的物理内存不多,但cached用了很多,这是Linux提升文件IO速度的一种做法,在这种做法下,如物理空闲内存够用,通常在Linux上只有写文件和第一次读取文件时会产生真正的文件IO. 在Linux中要跟踪线程的文件IO的消耗,主要方法是通过pidstat来查找。

    4.3.1.1 pidstat

    输入如:pidstat -d -t -p [pid] 1 100 类似的命令即可查看线程的IO消耗状况,必须在2.6.20以上版本的内核或安装SYSSTAT工具后才会有效,执行后的效果如下图

    图-18

    其中kB_rd/s表示每秒读取的kB数,kB_wr/s表示每秒写入的kB数。

    没有安装pidstat或内核版本不在2.6.20以后的版本的情况,可通过iostat来查看,但iostat只能查看整个系统的文件IO消耗情况,无法跟踪到进程的文件IO消耗情况。

    4.3.1.2 iostat

    直接输入iostat命令,可查看各个设备的IO历史状况,如下图:

    图-19

    在上面的几项指标中,其中Device表示设备卷名称或分区名;tps是每秒的IO请求数,这也是IO消耗情况中值得关注的数字;kB_read/s表示每秒钟读的kB数; kB_wrtn/s 表示每秒钟写的kB数; kB_read总共读取的数量; kB_wrtn总共写入的数量;

    除了上面的方式外,还可通过输入iostat -x xvda 3 5 这样的方式来定时采样查看IO的消耗状况,执行如下:

    图-20

    其中值得关注的主要有: r/s表示每秒钟读的请求数;w/s表示每秒钟写的请求数;await表示平均每次IO操作的等待时间,单位为毫秒;avgqu-sz 表示等待请求的队列的平均长度;svctm表示平均每次设备执行IO操作的时间;%util表示有百分之多少用于IO操作。

    在使用iostat查看IO的消耗时,首先要关注的是CPU中的iowait%所占的百分比,当iowait占据了主要的百分比时,就表示要关注IO方面的消耗状况了,

    这时可以通过iostat -x 方式来详细地查看具体情况,参见下图:

    图-21

    4.3.2 文件IO消耗分析案例

    当文件IO消耗过高时,对于Java应用最重要的是找到造成文件IO消耗高的代码,寻找的最佳方案为通过pidstat直接找到文件IO操作多的线程。之后结合jstack找到对应的Java代码,如没有pidstat,也可直接根据jstack得到的线程信息来分析其中文件IO操作较多的线程。

    Java应用造成文件IO消耗严重主要是多个线程需要进行大量内容写入(例如频繁的日志写入)的动作;或磁盘设备本身的处理速度慢;或文件系统慢;或操作的文件本身已经很大造成的。

    例子,通过往一个文件中不断地增加内容,文件越来越大,造成写速度慢,最终IOWait值高。代码实例见参考中附件:IOWaitHighDemo.jar

    图-22

    从图-22关注从top中的%iowait值偏高可以判断占据了很多CPU, 结合iostat的信息来看,主要是wkB/s比较高主要是写的消耗,并且花费在await上的时间要远大于svctm的时间。至于是什么动作导致了iowait,仍然需要对应用的线程dump来分析,找出其中的IO操作相关的动作。使用pidstat找到IO读写量大的线程ID,然后结合jstack生成的线程dump文件,即可找到相应的消耗文件IO多的动作。

    jstack操作进程线程的dump文件如下:

    图-23

    从上面的线程堆栈中,可看到线程停留在了FileOutputStream.writeBytes(Native Method)这个Native方式上,这个方法所做的动作为将数据写入文件中,也就是所要寻找的IO操作相关的动作。继续跟踪堆栈往上查找,知道查找到系统中的代码,例如例子中的IOWaitHighDemo.java第57行,下图(图-24)是IOWaitHighDemo.java第57行相关代码

    图-24

    展开全文
  • 性能优化

    2017-09-19 10:08:11
    JavaScript性能优化小窍门汇总(含实例) 由 youj 创建,最后一次修改 2016-11-28 在众多语言中,JavaScript已经占有重要的一席之地,利用JavaScript我们可以做很多事情 , 应用广泛。在web应用...

    JavaScript性能优化小窍门汇总(含实例)

    由 youj 创建,最后一次修改 2016-11-28

    在众多语言中,JavaScript已经占有重要的一席之地,利用JavaScript我们可以做很多事情 , 应用广泛。在web应用项目中,需要大量JavaScript的代码,将来也会越来越多。但是由于JavaScript是一个作为解释执行的语言,而且它的单线程机制,决定了性能问题是JavaScript的弱点,也是开发者在写JavaScript的时候需注意的一个问题,因为经常会遇到Web 2.0应用性能欠佳的问题,主因就是JavaScript性能不足,导致浏览器负荷过重。 Javascript性能优化绝不是一种书面的技能,那么应该如何正确的加载和执行 JavaScript代码,从而提高其在浏览器中的性能呢?下面就给大家做一些优化小窍门的知识汇总。


    无论当前 JavaScript 代码是内嵌还是在外链文件中,页面的下载和渲染都必须停下来等待脚本执行完成。JavaScript 执行过程耗时越久,浏览器等待响应用户输入的时间就越长。浏览器在下载和执行脚本时出现阻塞的原因在于,脚本可能会改变页面或JavaScript的命名空间,它们会对后面页面内容造成影响。一个典型的例子就是在页面中使用:

    document.write()
    
    示例:
    <html>
    <head>
        <title>Source Example</title>
    </head>
    <body>
        <p>
        <script type="text/javascript">
            document.write("Today is " + (new Date()).toDateString());
        </script>
        </p>
    </body>
    </html>
    
    当浏览器遇到<script>标签时,当前 HTML 页面无从获知 JavaScript 是否会向<p> 标签添加内容,或引入其他元素,或甚至移除该标签。因此,这时浏览器会停止处理页面,先执行 JavaScript代码,然后再继续解析和渲染页面。同样的情况也发生在使用 src 属性加载 JavaScript的过程中,浏览器必须先花时间下载外链文件中的代码,然后解析并执行它。在这个过程中,页面渲染和用户交互完全被阻塞了。

    不要使用 with() 语句

    这是因为 with() 语句将会在作用域链的开始添加额外的变量。额外的变量意味着,当任何变量需要被访问的时候,JavaScript引擎都需要先扫描with()语句产生的变量,然后才是局部变量,最后是全局变量。 So with() essentially gives local variables all the performance drawbacks of global ones, and in turn derails Javascript optimization. 因此with()语句同时给局部变量和全局变量的性能带来负面影响,最终使我们优化JavaScript性能的计划破产。


    对象属性和数组元素的速度都比变量慢

    谈到JavaScript的数据,一般来说有4种访问方式:数值、变量、对象属性和数组元素。在考虑优化时,数值和变量的性能差不多,并且速度显著优于对象属性和数组元素。

    因此当你多次引用一个对象属性或者数组元素的时候,你可以通过定义一个变量来获得性能提升。(这一条在读、写数据时都有效)虽然这条规则在绝大多数情况下是正确的,但是Firefox在优化数组索引上做了一些有意思的工作,能够让它的实际性能优于变量。但是考虑到数组元素在其他浏览器上的性能弊端,还是应该尽量避免数组查找,除非你真的只针对于火狐浏览器的性能而进行开发。


    避免全局查找

    在一个函数中会用到全局对象存储为局部变量来减少全局查找,因为访问局部变量的速度要比访问全局变量的速度更快些
    function search() {
                //当我要使用当前页面地址和主机域名
                alert(window.location.href + window.location.host);
            }
            //最好的方式是如下这样  先用一个简单变量保存起来
            function search() {
                var location = window.location;
                alert(location.href + location.host);
            }
    


    避免with语句

    和函数类似 ,with语句会创建自己的作用域,因此会增加其中执行的代码的作用域链的长度,由于额外的作用域链的查找,在with语句中执行的代码肯定会比外面执行的代码要慢,在能不使用with语句的时候尽量不要使用with语句。
    with (a.b.c.d) {
                property1 = 1;
                property2 = 2;
            }
            //可以替换为:
            var obj = a.b.c.d;
            obj.property1 = 1;
            obj.property2 = 2;
    

    数字转换成字符串

    般最好用”" + 1来将数字转换成字符串,虽然看起来比较丑一点,但事实上这个效率是最高的,性能上来说:
    (“” +) > String() > .toString() > new String()
    

    通过模板元素clone,替代createElement

    很多人喜欢在JavaScript中使用document.write来给页面生成内容。事实上这样的效率较低,如果需要直接插入HTML,可以找一个容器元素,比如指定一个div或者span,并设置他们的innerHTML来将自己的HTML代码插入到页面中。通常我们可能会使用字符串直接写HTML来创建节点,其实这样做,1:无法保证代码的有效性,2:字符串操作效率低,所以应该是用document.createElement()方法,而如果文档中存在现成的样板节点,应该是用cloneNode()方法,因为使用createElement()方法之后,你需要设置多次元素的属性,使用cloneNode()则可以减少属性的设置次数——同样如果需要创建很多元素,应该先准备一个样板节点。
     var frag = document.createDocumentFragment();
            for (var i = 0; i < 1000; i++) {
                var el = document.createElement('p');
                el.innerHTML = i;
                frag.appendChild(el);
            }
            document.body.appendChild(frag);
            //替换为:
            var frag = document.createDocumentFragment();
            var pEl = document.getElementsByTagName('p')[0];
            for (var i = 0; i < 1000; i++) {
                var el = pEl.cloneNode(false);
                el.innerHTML = i;
                frag.appendChild(el);
            }
            document.body.appendChild(frag);
    

    避免低效率的脚本位置

    HTML 4 规范指出 <script> 标签可以放在 HTML 文档的<head>或<body>中,并允许出现多次。Web 开发人员一般习惯在 <head> 中加载外链的 JavaScript,接着用 <link> 标签用来加载外链的 CSS 文件或者其他页面信息。

    低效率脚本位置示例:
    <html>
    <head>
        <title>Source Example</title>
        <script type="text/javascript" src="script1.js"></script>
        <script type="text/javascript" src="script2.js"></script>
        <script type="text/javascript" src="script3.js"></script>
        <link rel="stylesheet" type="text/css" href="styles.css">
    </head>
    <body>
        <p>Hello world!</p>
    </body>
    </html>
    
    然而这种常规的做法却隐藏着严重的性能问题。在清单 2 的示例中,当浏览器解析到 <script> 标签(第 4 行)时,浏览器会停止解析其后的内容,而优先下载脚本文件,并执行其中的代码,这意味着,其后的 styles.css 样式文件和<body>标签都无法被加载,由于<body>标签无法被加载,那么页面自然就无法渲染了。因此在该 JavaScript 代码完全执行完之前,页面都是一片空白。下图描述了页面加载过程中脚本和样式文件的下载过程。

    脚本位置

    我们可以发现一个有趣的现象:第一个 JavaScript 文件开始下载,与此同时阻塞了页面其他文件的下载。此外,从 script1.js 下载完成到 script2.js 开始下载前存在一个延时,这段时间正好是 script1.js 文件的执行过程。每个文件必须等到前一个文件下载并执行完成才会开始下载。在这些文件逐个下载过程中,用户看到的是一片空白的页面。

    从 IE 8、Firefox 3.5、Safari 4 和 Chrome 2 开始都允许并行下载 JavaScript 文件。这是个好消息,因为<script>标签在下载外部资源时不会阻塞其他<script>标签。遗憾的是,JavaScript 下载过程仍然会阻塞其他资源的下载,比如样式文件和图片。尽管脚本的下载过程不会互相影响,但页面仍然必须等待所有 JavaScript 代码下载并执行完成才能继续。因此,尽管最新的浏览器通过允许并行下载提高了性能,但问题尚未完全解决,脚本阻塞仍然是一个问题。

    由于脚本会阻塞页面其他资源的下载,因此推荐将所有<script>标签尽可能放到<body>标签的底部,以尽量减少对整个页面下载的影响。

    推荐的代码放置位置示例:
    <head>
        <title>Source Example</title>
        <link rel="stylesheet" type="text/css" href="styles.css">
    </head>
    <body>
        <p>Hello world!</p>
        <!-- Example of efficient script positioning -->
        <script type="text/javascript" src="script1.js"></script>
        <script type="text/javascript" src="script2.js"></script>
        <script type="text/javascript" src="script3.js"></script>
    </body>
    </html>
    
    这段代码展示了在 HTML 文档中放置<script>标签的推荐位置。尽管脚本下载会阻塞另一个脚本,但是页面的大部分内容都已经下载完成并显示给了用户,因此页面下载不会显得太慢。这是优化 JavaScript 的首要规则:将脚本放在底部。

    小心使用闭包

    虽然你可能还不知道“闭包”,但你可能在不经意间经常使用这项技术。闭包基本上被认为是JavaScript中的new,当我们定义一个即时函数的时候,我们就使用了闭包,比如:
    document.getElementById('foo').onclick = function(ev) { };
    

    闭包的问题在于:根据定义,在它们的作用域链中至少有三个对象:闭包变量、局部变量和全局变量。这些额外的对象将会导致其他的性能问题。但是Nicholas并不是要我们因噎废食,闭包对于提高代码可读性等方面还是非常有用的,只是不要滥用它们(尤其在循环中)。


    在循环时将控制条件和控制变量合并起来

    提到性能,在循环中需要避免的工作一直是个热门话题,因为循环会被重复执行很多次。所以如果有性能优化的需求,先对循环开刀有可能会获得最明显的性能提升。

    一种优化循环的方法是在定义循环的时候,将控制条件和控制变量合并起来,下面是一个没有将他们合并起来的例子:

    for ( var x = 0; x < 10; x++ ) {
    };
    
    当我们要添加什么东西到这个循环之前,我们发现有几个操作在每次迭代都会出现。JavaScript引擎需要:
    #1:检查 x 是否存在
    #2:检查 x 是否小于 0 <span style="color: #888888;">(这里可能有笔误)</span>
    #3:使 x 增加 1
    
    然而如果你只是迭代元素中的一些元素,那么你可以使用while循环进行轮转来替代上面这种操作:
    var x = 9;
    do { } while( x-- );
    

    使用 XMLHttpRequest(XHR)对象

    此技术首先创建一个 XHR 对象,然后下载 JavaScript 文件,接着用一个动态<script>元素将 JavaScript 代码注入页面。

    通过 XHR 对象加载 JavaScript 脚本:
    var xhr = new XMLHttpRequest();
    xhr.open("get", "script1.js", true);
    xhr.onreadystatechange = function(){
        if (xhr.readyState == 4){
            if (xhr.status >= 200 && xhr.status < 300 || xhr.status == 304){
                var script = document.createElement ("script");
                script.type = "text/javascript";
                script.text = xhr.responseText;
                document.body.appendChild(script);
            }
        }
    };
    xhr.send(null);
    
    此代码向服务器发送一个获取 script1.js 文件的 GET 请求。onreadystatechange 事件处理函数检查readyState 是不是 4,然后检查 HTTP 状态码是不是有效(2XX 表示有效的回应,304 表示一个缓存响应)。如果收到了一个有效的响应,那么就创建一个新的<script>元素,将它的文本属性设置为从服务器接收到的 responseText 字符串。这样做实际上会创建一个带有内联代码的<script>元素。一旦新<script>元素被添加到文档,代码将被执行,并准备使用。

    这种方法的主要优点是,您可以下载不立即执行的 JavaScript 代码。由于代码返回在<script>标签之外(换句话说不受<script>标签约束),它下载后不会自动执行,这使得您可以推迟执行,直到一切都准备好了。另一个优点是,同样的代码在所有现代浏览器中都不会引发异常。

    此方法最主要的限制是:JavaScript 文件必须与页面放置在同一个域内,不能从 CDN 下载(CDN 指”内容投递网络(Content Delivery Network)”,所以大型网页通常不采用 XHR 脚本注入技术。

    注意NodeList

    最小化访问NodeList的次数可以极大的改进脚本的性能
     var images = document.getElementsByTagName('img');
            for (var i = 0, len = images.length; i < len; i++) {
    
            }
    
    编写JavaScript的时候一定要知道何时返回NodeList对象,这样可以最小化对它们的访问

    1、进行了对getElementsByTagName()的调用
    2、获取了元素的childNodes属性
    3、获取了元素的attributes属性
    4、访问了特殊的集合,如document.forms、document.images等等

    要了解了当使用NodeList对象时,合理使用会极大的提升代码执行速度

    避免与null进行比较

    由于JavaScript是弱类型的,所以它不会做任何的自动类型检查,所以如果看到与null进行比较的代码,尝试使用以下技术替换:


    1、如果值应为一个引用类型,使用instanceof操作符检查其构造函数

    2、如果值应为一个基本类型,作用typeof检查其类型

    3、如果是希望对象包含某个特定的方法名,则使用typeof操作符确保指定名字的方法存在于对象上


    尊重对象的所有权

    因为JavaScript可以在任何时候修改任意对象,这样就可以以不可预计的方式覆写默认的行为,所以如果你不负责维护某个对象,它的对象或者它的方法,那么你就不要对它进行修改,具体一点就是说:

    1、不要为实例或原型添加属性
    2、不要为实例或者原型添加方法
    3、不要重定义已经存在的方法
    4、不要重复定义其它团队成员已经实现的方法,永远不要修改不是由你所有的对象,你可以通过以下方式为对象创建新的功能:
    1、创建包含所需功能的新对象,并用它与相关对象进行交互
    2、创建自定义类型,继承需要进行修改的类型,然后可以为自定义类型添加额外功能

    循环引用

    如果循环引用中包含DOM对象或者ActiveX对象,那么就会发生内存泄露。内存泄露的后果是在浏览器关闭前,即使是刷新页面,这部分内存不会被浏览器释放。

    简单的循环引用:
     var el = document.getElementById('MyElement');
            var func = function () {
                //…
            }
            el.func = func;
            func.element = el;
    
    但是通常不会出现这种情况。通常循环引用发生在为dom元素添加闭包作为expendo的时候。
      function init() {
                var el = document.getElementById('MyElement');
                el.onclick = function () {
                    //……
                }
            }
            init();
    

    init在执行的时候,当前上下文我们叫做context。这个时候,context引用了el,el引用了function,function引用了context。这时候形成了一个循环引用。

    下面2种方法可以解决循环引用:


    1、置空dom对象
     function init() {
                var el = document.getElementById('MyElement');
                el.onclick = function () {
                    //……
                }
            }
            init();
            //可以替换为:
            function init() {
                var el = document.getElementById('MyElement');
                el.onclick = function () {
                    //……
                }
                el = null;
            }
            init();
    

    将el置空,context中不包含对dom对象的引用,从而打断循环应用。


    如果我们需要将dom对象返回,可以用如下方法:

     function init() {
                var el = document.getElementById('MyElement');
                el.onclick = function () {
                    //……
                }
                return el;
            }
            init();
            //可以替换为:
            function init() {
                var el = document.getElementById('MyElement');
                el.onclick = function () {
                    //……
                }
                try {
                    return el;
                } finally {
                    el = null;
                }
            }
            init();
    

    2、构造新的context
     function init() {
                var el = document.getElementById('MyElement');
                el.onclick = function () {
                    //……
                }
            }
            init();
            //可以替换为:
            function elClickHandler() {
                //……
            }
            function init() {
                var el = document.getElementById('MyElement');
                el.onclick = elClickHandler;
            }
            init();
    

    把function抽到新的context中,这样,function的context就不包含对el的引用,从而打断循环引用。

    通过javascript创建的dom对象,必须append到页面中

    IE下,脚本创建的dom对象,如果没有append到页面中,刷新页面,这部分内存是不会回收的!

      function create() {
                var gc = document.getElementById('GC');
                for (var i = 0; i < 5000; i++) {
                    var el = document.createElement('div');
                    el.innerHTML = "test";
                    //下面这句可以注释掉,看看浏览器在任务管理器中,点击按钮然后刷新后的内存变化
                    gc.appendChild(el);
                }
            }


    字符串连接

    如果要连接多个字符串,应该少使用+=,如

    s+=a;

    s+=b;

    s+=c;

    应该写成s+=a + b + c;

    而如果是收集字符串,比如多次对同一个字符串进行+=操作的话,最好使用一个缓存,使用JavaScript数组来收集,最后使用join方法连接起来

    var buf = [];
            for (var i = 0; i < 100; i++) {
                buf.push(i.toString());
            }
            var all = buf.join("");
    

    各种类型转换

    var myVar = "3.14159",
            str = "" + myVar, //  to string  
            i_int = ~ ~myVar,  //  to integer  
            f_float = 1 * myVar,  //  to float  
            b_bool = !!myVar,  /*  to boolean - any string with length 
                                    and any number except 0 are true */
            array = [myVar];  //  to array
    
    如果定义了toString()方法来进行类型转换的话,推荐显式调用toString(),因为内部的操作在尝试所有可能性之后,会尝试对象的toString()方法尝试能否转化为String,所以直接调用这个方法效率会更高

    多个类型声明

    在JavaScript中所有变量都可以使用单个var语句来声明,这样就是组合在一起的语句,以减少整个脚本的执行时间,就如上面代码一样,上面代码格式也挺规范,让人一看就明了。

    插入迭代器

    如var name=values[i]; i++;前面两条语句可以写成var name=values[i++]

    使用直接量

    var aTest = new Array(); //替换为
            var aTest = [];
            var aTest = new Object; //替换为
            var aTest = {};
            var reg = new RegExp(); //替换为
            var reg = /../;
            //如果要创建具有一些特性的一般对象,也可以使用字面量,如下:
            var oFruit = new O;
            oFruit.color = "red";
            oFruit.name = "apple";
            //前面的代码可用对象字面量来改写成这样:
            var oFruit = { color: "red", name: "apple" };

    避免双重解释

    如果要提高代码性能,尽可能避免出现需要按照JavaScript解释的字符串,也就是
    1、尽量少使用eval函数
    使用eval相当于在运行时再次调用解释引擎对内容进行运行,需要消耗大量时间,而且使用Eval带来的安全性问题也是不容忽视的。

    2、不要使用Function构造器
    不要给setTimeout或者setInterval传递字符串参数
     var num = 0;
            setTimeout('num++', 10);
            //可以替换为:
            var num = 0;
            function addNum() {
                num++;
            }
            setTimeout(addNum, 10);
    

    缩短否定检测

     if (oTest != '#ff0000') {
                //do something
            }
            if (oTest != null) {
                //do something
            }
            if (oTest != false) {
                //do something
            }
            //虽然这些都正确,但用逻辑非操作符来操作也有同样的效果:
            if (!oTest) {
                //do something
            }
    

    释放javascript对象

    在rich应用中,随着实例化对象数量的增加,内存消耗会越来越大。所以应当及时释放对对象的引用,让GC能够回收这些内存控件。

    对象:obj = null

    对象属性:delete obj.myproperty

    数组item:使用数组的splice方法释放数组中不用的item


    性能方面的注意事项

    1、尽量使用原生方法

    2、switch语句相对if较快

    通过将case语句按照最可能到最不可能的顺序进行组织

    3、位运算较快

    当进行数字运算时,位运算操作要比任何布尔运算或者算数运算快

    4、巧用||和&&布尔运算符

     function eventHandler(e) {
                if (!e) e = window.event;
            }
            //可以替换为:
            function eventHandler(e) {
                e = e || window.event;
            }
    
      if (myobj) {
                doSomething(myobj);
            }
            //可以替换为:
            myobj && doSomething(myobj);

    避免错误应注意的地方

    1、每条语句末尾须加分号

    在if语句中,即使条件表达式只有一条语句也要用{}把它括起来,以免后续如果添加了语句之后造成逻辑错误


    2、使用+号时需谨慎

    JavaScript 和其他编程语言不同的是,在 JavaScript 中,’+'除了表示数字值相加,字符串相连接以外,还可以作一元运算符用,把字符串转换为数字。因而如果使用不当,则可能与自增符’++’混淆而引起计算错误

     var valueA = 20;
            var valueB = "10";
            alert(valueA + valueB);     //ouput: 2010 
            alert(valueA + (+valueB));  //output: 30 
            alert(valueA + +valueB);    //output:30 
            alert(valueA ++ valueB);     //Compile error
    


    3、使用return语句需要注意

    一条有返回值的return语句不要用()括号来括住返回值,如果返回表达式,则表达式应与return关键字在同一行,以避免压缩时,压缩工具自动加分号而造成返回与开发人员不一致的结果

    function F1() {
                var valueA = 1;
                var valueB = 2;
                return valueA + valueB;
            }
            function F2() {
                var valueA = 1;
                var valueB = 2;
                return
                valueA + valueB;
            }
            alert(F1());  //output: 3 
            alert(F2());  //ouput: undefined
    

    ==和===的区别

    避免在if和while语句的条件部分进行赋值,如if (a = b),应该写成if (a == b),但是在比较是否相等的情况下,最好使用全等运行符,也就是使用===和!==操作符会相对于==和!=会好点。==和!=操作符会进行类型强制转换
    var valueA = "1";
            var valueB = 1;
            if (valueA == valueB) {
                alert("Equal");
            }
            else {
                alert("Not equal");
            }
            //output: "Equal"
            if (valueA === valueB) {
                alert("Equal");
            }
            else {
                alert("Not equal");
            }
            //output: "Not equal"
    


    不要使用生偏语法

    不要使用生偏语法,写让人迷惑的代码,虽然计算机能够正确识别并运行,但是晦涩难懂的代码不方便以后维护

    函数返回统一类型

    虽然JavaScript是弱类型的,对于函数来说,前面返回整数型数据,后面返回布尔值在编译和运行都可以正常通过,但为了规范和以后维护时容易理解,应保证函数应返回统一的数据类型

    总是检查数据类型

    要检查你的方法输入的所有数据,一方面是为了安全性,另一方面也是为了可用性。用户随时随地都会输入错误的数据。这不是因为他们蠢,而是因为他们很忙,并且思考的方式跟你不同。用typeof方法来检测你的function接受的输入是否合法

    何时用单引号,何时用双引号

    虽然在JavaScript当中,双引号和单引号都可以表示字符串, 为了避免混乱,我们建议在HTML中使用双引号,在JavaScript中使用单引号,但为了兼容各个浏览器,也为了解析时不会出错,定义JSON对象时,最好使用双引号

    部署

    1、用JSLint运行JavaScript验证器来确保没有语法错误或者是代码没有潜在的问
    2、部署之前推荐使用压缩工具将JS文件压缩
    3、文件编码统一用UTF-8
    4、JavaScript 程序应该尽量放在 .js 的文件中,需要调用的时候在 HTML 中以 <script src=”filename.js”> 的形式包含进来。JavaScript 代码若不是该 HTML 文件所专用的,则应尽量避免在 HTML 文件中直接编写 JavaScript 代码。因为这样会大大增加 HTML 文件的大小,无益于代码的压缩和缓存的使用。另外,<script src=”filename.js”> 标签应尽量放在文件的后面,最好是放在</body>标签前。这样会降低因加载 JavaScript 代码而影响页面中其它组件的加载时间。
    展开全文
  • 网页性能优化

    2019-09-07 22:51:32
    1. 网络加载 ⑴ DNS预加载 通过dns-prefetch属性可以让浏览器提前解析资源或接口对应的服务器IP地址,避免在请求中发起DNS解析请求,节省请求时间。 ⑵ CDN加速 ... 带宽优化,分担网络流量,...
  • 一个优秀开发的必备技能:性能优化,包括:JVM调优、缓存、Sql性能优化等。本文主要讲基于Mysql的索引优化。 首先我们需要了解执行一条查询SQL时Mysql的处理过程: 其次我们需要知道,我们写的SQL在Mysql的执行...
  • 当我们谈到性能优化,更多的同学可能想到的是系统层面的性能优化。比如在一个Web服务程序中,通过Redis或者其它缓存来提升网站访问的速度等。这一方面是编译器为我们做了很多优化工作,另外一方面是觉得系统层面的...
  • 网站性能优化注意点

    2019-05-06 19:32:16
    一、网络传输性能优化 重定向→拉取缓存→DNS查询→建立TCP链接→发起请求→接收响应→处理HTML元素→元素加载完成。 (1)设置浏览器缓存 去除network面板顶部的Disable cache 勾选,查看缓存数据来源(from ...
  • 本文全面讲解性能优化中的所有知识,献上一份 Android性能优化的详细攻略, 含:优化方向、原因 &amp; 具体优化方案,希望你们会喜欢 文章较长,建议预留较长时间阅读 / 收藏 目录 1. 性能优化...
  • MySQL性能优化的最佳20+条经验
  • android性能优化在实际开发中会经常应用到,当项目越来越庞大时,性能优化就显得更加重要,写出性能优化代码不但需要丰富的经验,而且还需要了解其原理,这样才有助于我们写出高性能的代码,今天我们来总结一下日常...
  • 面向程序员的数据库访问性能优化法则   特别说明: 1、 本文只是面对数据库应用开发的程序员,不适合专业DBA,DBA在数据库性能优化方面需要了解更多的知识; 2、 本文许多示例及概念是...
  • 从V8中看JS性能优化

    2020-06-19 10:15:36
    从V8中看JS性能优化 注意:该知识点属于性能优化领域。 性能问题越来越成为前端火热的话题,因为随着项目的逐步变大,性能问题也逐步体现出来。为了提高用户的体验,减少加载时间,工程师们想尽一切办法去优化...
  • Android性能优化总结

    2015-02-17 17:26:34
    性能优化本身是一个很大的主题,涵盖程序的方方面面,任何不慎的操作,都有可能对性能造成比较大的影响,要知道程序的性能是可以累加的,多处的性能低下,会影响整体的性能,其后果可能也是多方面的,本文总结了目前...
  • 数据库性能优化详解

    2018-01-29 16:23:04
    出处: ...1.数据库访问优化法则 ...要正确的优化SQL,我们需要快速定位能性的瓶颈点,也就是说快速找到我们SQL主要的开销在...而大多数情况性能最慢的设备会是瓶颈点,如下载时网络速度可能会是瓶颈点,本地复制
  • 性能优化方法论 在我们历经千辛万苦,通过各种性能分析方法,终于找到引发性能问题的瓶颈后,是不是立刻就要开始优化了呢?别急,动手之前,你可以先看看下面这三个问题。 首先,既然要做性能优化,那要怎么...
  • App性能优化浅谈

    2016-02-18 11:04:23
    前言前段时间给公司的小伙伴们进行了关于app性能优化的技术分享,这里我稍微整理一下也给大家分享一下,关于性能优化这个话题很大,涉及面可以很广,也可以很深入,本人能力有限,不会给大家讲特别难懂,特别底层的...
  • H5性能优化方案

    2016-08-17 18:06:07
    H5性能优化意义对于一个H5的产品,功能无疑很重要,但是性能同样是用户体验中不可或缺的一环。原本H5的渲染性能就不及native的app,如果不把性能优化做起来,将极大地影响用户使用产品的积极性。用户感受当用户能够...
1 2 3 4 5 ... 20
收藏数 991,228
精华内容 396,491
关键字:

性能优化