<?xml version="1.0" encoding="GB2312"?>  
<rss version="2.0" 
xmlns:dc="http://purl.org/dc/elements/1.1/" 
xmlns:sy="http://purl.org/rss/1.0/modules/syndication/" 
xmlns:admin="http://webns.net/mvcb/" 
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"> 
  
<channel> 
<title><![CDATA[Zee的博客]]></title> 
<link>http://zeeslo.bokee.com/index.html</link> 
<description><![CDATA[我现在过的还好。                                                                                                                                                                                                                                                         本BLOG涉及到的文章基本上都是转载,若涉及到版权问题,请及时和本人联系.留言即可.]]></description> 
<dc:language>zh-cn</dc:language> 
<dc:creator>gl625@163.com</dc:creator> 
<dc:date>2008-07-23T09:50:57Z</dc:date> 
<admin:generatorAgent rdf:resource="http://blog.bokee.com.com" /> 

<item> 
<title><![CDATA[更换BLOG公告-Zee]]></title> 
<link>http://zeeslo.bokee.com/6787430.html</link> 
<description><![CDATA[谢谢长期以来关心和支持我的朋友,未谋面的网友.<br /><br />因为想拥有自己的空间域名,所以更换空间.<br /><br />从今天起,此BLOG不再更新.<br /><br />新个人网址:<br /><br /><b>7点测试<br />www.7dtest.com</b>
]]></description> 
<guid isPermaLink="false">6787430@http://zeeslo.bokee.com/</guid> 
<dc:subject>Zee生活</dc:subject> 
<dc:date>2008-08-25T09:55:22Z</dc:date> 
</item> 
<item> 
<title><![CDATA[帮助你开发更快web页面的15个工具]]></title> 
<link>http://zeeslo.bokee.com/6766227.html</link> 
<description><![CDATA[<div id="news_content"><p>下面是15个很有用的工具，能够帮助你开发更快的web工具</p>
<p>&amp;#160;</p>
<h3>1. <a title="YSlow for Firebug" href="http://developer.yahoo.com/yslow/">YSlow for Firebug</a></h3>
<p><a href="http://developer.yahoo.com/yslow/"><img height="200" width="550" alt="YSlow for Firebug - Screenshot" src="http://images.sixrevisions.com/2008/06/12-01_yslow.png" /></a></p>
<p><em>YSlow</em> 能够评价一个网站的性能，基于Yahoo! Developer Network 的 <a href="http://developer.yahoo.com/performance/rules.html">best practices for  high performance web sites</a> . 每一条规则都从A-F打分，综合评定你的网站是否合理的进行了性能优化。比如你是否合理减少了每个页面HTTP request的次数，是否队CSS和JS文件进行了压缩等。你可以阅读
<a title="Ajax performance analysis" href="http://www.ibm.com/developerworks/web/library/wa-aj-perform/">Ajax performance analysis</a> 来学习如何使用 YSlow .</p>
<h3>2. <a title="Firebug - Web Development Evolved" href="http://www.getfirebug.com/">Firebug</a></h3>
<p><a href="http://www.getfirebug.com/"><img height="200" width="550" alt="Firebug - Screen shot" src="http://images.sixrevisions.com/2008/06/12-02_firebug.png" /></a></p>
<p>&amp;#160;</p>
<p><em>Firebug</em> 是一个优秀的基于浏览器的web开发工具，调试，测试，分析web页面，firefox用户一定不会陌生。</p>
<h3>3. <a title="Fiddler Web Debugger - A free web debugging tool" href="http://www.fiddler2.com/fiddler2/">Fiddler 2</a></h3>
<p><a href="http://www.fiddler2.com/fiddler2/"><img height="200" width="550" alt="Fiddler 2 - Screen shot" src="http://images.sixrevisions.com/2008/06/12-03_fiddler.png" /></a></p>
<p><em>Fiddler 2</em> 是一个基于浏览器的HTTP调试工具 ，帮助你分析进入和出去的traffic。用户可以进行设置，查看报表和调试细节。可以阅读MSDN上的 “<a title="Fiddler PowerToy - Part 2: HTTP Performance" href="http://msdn.microsoft.com/en-us/library/bb250442%28VS.85%29.aspx">Fiddler PowerToy - Part 2:  HTTP Performance</a>” 学习如何分析HTTP request。</p>
<h3>4. <a title="Cuzillion" href="http://stevesouders.com/cuzillion/">Cuzillion</a></h3>
<p><a href="http://stevesouders.com/cuzillion/"><img height="200" width="550" alt="Cuzillion - Screen shot" src="http://images.sixrevisions.com/2008/06/12-04_cuzillion.png" /></a></p>
<p><em>Cuzillion</em> 是一个很酷的工具，帮助你查看页面组件的交互，目标是帮助你在结构化页面的时候快速检查，测试和编辑web页面。它会给你提供线索在一些基础性的问题上。可以配合YSlow一起使用.</p>
<h3>5. <a title="Free Websites Performance, Availability, Traffic Monitoring" href="http://mon.itor.us/">mon.itor.us</a></h3>
<p><a href="http://mon.itor.us/"><img height="200" width="550" alt="mon.itor.us - Screen shot" src="http://images.sixrevisions.com/2008/06/12-05_monitorus.png" /></a></p>
<p><em>monitor.us</em> 是一个基于web的免费服务，提供给你一套工具来监控性能状况，网站是否可链接，以及traffic情况。</p>
<h3>6. <a title="alphaWorks : IBM Page Detailer : Overview" href="http://www.alphaworks.ibm.com/tech/pagedetailer"><span class="hilite1">IBM</span> <span class="hilite2">Page</span> <span class="hilite3">Detailer</span></a></h3>
<p><a href="http://www.alphaworks.ibm.com/tech/pagedetailer"><img height="200" width="550" alt="IBM Page Detailer - Screen shot" src="http://images.sixrevisions.com/2008/06/12-06_ibm_page_detailer.png" /></a></p>
<p>The <em><span class="hilite1">IBM</span> <span class="hilite2">Page</span> <span class="hilite3">Detailer</span></em> 是一个直接可视化查看正在下载的web组件的工具。</p>
<h3>7. <a title="http://www.hpl.hp.com/research/linux/httperf/" href="http://www.hpl.hp.com/research/linux/httperf/">Httperf</a></h3>
<p><em>Httperf</em> 是一个开源工具，调节Linux下 HTTP server
性能。</p>
<h3>8. <a title="Pylot | Open Source Web Performance Tool" href="http://www.pylot.org/">Pylot</a></h3>
<p><a href="http://www.pylot.org/"><img height="200" width="550" alt="Pylot - Screen shot" src="http://images.sixrevisions.com/2008/06/12-08_pylot.png" /></a></p>
<p><em>Pylot</em> 是一个开源性能和扩展工具。</p>
<h3>9. <a title="Learn About PushToTest TestMaker — PushToTest" href="http://www.pushtotest.com/Docs/downloads/features.html">PushToTest TestMaker</a></h3>
<p><a href="http://www.pushtotest.com/Docs/downloads/features.html"><img height="200" width="550" alt="PushToTest TestMaker - Screen shot" src="http://images.sixrevisions.com/2008/06/12-09_pushtotest.png" /></a></p>
<p><em>PushToTest TestMaker</em> 是一个免费开源的平台来测试扩展和性能的工具。类似Pylot。</p>
<h3>10. <a title="Wbox HTTP testing tool" href="http://hping.org/wbox/">Wbox HTTP testing tool</a></h3>
<p><a href="http://hping.org/wbox/"><img height="200" width="550" alt="Wbox HTTP testing tool - Screen shot" src="http://images.sixrevisions.com/2008/06/12-11_wbox.png" /></a></p>
<p><em>Wbox</em> is 是一个简单的免费工具，来测试 HTTP 软件，在 GPL (v2) 下. </p>
<h3>11. <a title="Home - load testing tool - stress testing tool - WebLOAD" href="http://www.webload.org/">WebLOAD</a></h3>
<p><a href="http://www.webload.org/"><img height="200" width="550" alt="WebLOAD - Screen shot" src="http://images.sixrevisions.com/2008/06/12-12_webload.png" /></a></p>
<p><em>WebLOAD</em> is 是一个开源专业工具，使用JavaScript测试性能和代码。</p>
<h3>12. <a title="DBMonster - The dbMonster home page - About" href="http://dbmonster.kernelpanic.pl/manual/index.html">DBMonster</a></h3>
<p><a href="http://dbmonster.kernelpanic.pl/manual/index.html"><img height="200" width="550" alt="DBMonster - Code Screen shot" src="http://images.sixrevisions.com/2008/06/12-13_dbmonster.png" /></a></p>
<p><em>DBMonster</em> 是一个开源应用，帮助你调节数据库和表索引，并且监控数据库的性能那。支持的数据库包括： MySQL, PostgreSQL, Oracle,
MSSQL and (probably) any database that supports the JDBC driver.</p>
<h3>13. <a title="OctaGate SiteTimer" href="http://www.octagate.com/service/SiteTimer/">OctaGate SiteTimer</a></h3>
<p><a href="http://www.octagate.com/service/SiteTimer/"><img height="200" width="550" alt="OctaGate SiteTimer - Screen shot" src="http://images.sixrevisions.com/2008/06/12-10_octagate_sitetimer.png" /></a></p>
<p>The <em>OctaGate SiteTimer</em> 是一个简单的下载时间检测工具。可视化的看出页面所有内容被下载的现状。</p>
<h3>14. <a title="Web Page Analyzer - free website optimization tool website speed test check website performance report from web site optimization" href="http://www.websiteoptimization.com/services/analyze/">Web  <span class="hilite2">Page</span> Analyzer</a></h3>
<p><a href="http://www.websiteoptimization.com/services/analyze/"><img height="200" width="550" alt="Web Page Analyzer - Screen shot" src=http://images.sixrevisions.com/2008/06/12-14_web_analyzer.png" /></a></p>
<p>The <em>Web <span class="hilite2">Page</span> Analyzer</em> 是一个可以扩展的简单基于web的测试工具，帮助你查看网站情况。</p>
<h3>15. <a title="Site-Perf.com - Know all about your site performance" href="http://site-perf.com/">Site-Perf.com</a></h3>
<p><a href="http://site-perf.com/"><img height="200" width="550" alt="Site-Perf.com - Screen shot" src="http://images.sixrevisions.com/2008/06/12-15_siteperf.png" /></a></p>
<p><em>Site-Perf.com</em> 是一个免费的基于web的测试服务，帮助你查看网站的加载时间。</p></div>
]]></description> 
<guid isPermaLink="false">6766227@http://zeeslo.bokee.com/</guid> 
<dc:subject>Zee生活</dc:subject> 
<dc:date>2008-07-23T09:50:55Z</dc:date> 
</item> 
<item> 
<title><![CDATA[使用Eclipse Callisto分析应用程序]]></title> 
<link>http://zeeslo.bokee.com/6764923.html</link> 
<description><![CDATA[Eclipse（Eclipse  3.2）的最新版本带有<a target="_blank" href="http://www.eclipse.org/callisto">Callisto</a>，一套丰富的针对Eclipse 3.2的可选插件。Callisto包括一个功能强大的分析工具，此工具称为Eclipse<a target="_blank" href="http://www.eclipse.org/tptp">测试与性能工具平台</a>，简称TPTP。TPTP提供了一套功能全面的开源性能－测试和分析工具，包括集成的<a target="_blank" href="http://www.onjava.com/pub/a/onjava/2006/08/16/profiling-with-eclipse-callisto.html##">应用程序</a>监控、测试、跟踪和分析功能，以及静态代码分析工具。对于在各类Java应用程序中找出和识别性能问题，分析工具的价值是不可估计的。在本文中，我们将探讨如何使用TPTP来保证获得高质量和高性能的代码（甚至是在单元和集成测试中）。<h3>安装TPTP</h3>
<p>　　安装TPTP最容易的方式是使用Remote Update站点（参见图1）。打开Remote Update窗口（Help -&amp;gt;
Software Updates -&amp;gt; Find and Install），然后选择Callisto Discovery
Site。Eclipse将建议安装Callisto插件集。TPTP工具列在“Testing and
Performance”下面。最容易也是最耗时的选择，就是安装所有建议的插件。即使不安装整个Callisto工具集，您仍然需要安装一些其他
TPTP需要的组件，例如&amp;quot;Charting and Reporting&amp;quot;、&amp;quot;Enabling Features&amp;quot;和&amp;quot;<a target="_blank" href="http://www.onjava.com/pub/a/onjava/2006/08/16/profiling-with-eclipse-callisto.html##">Data</a> Tool  Performance&amp;quot;。</p><p align="center">    <img width="435" height="454" border="0" alt="使用Eclipse Callisto分析应用程序图-1" src="http://dev2dev.bea.com.cn/images/image061122001.gif" /></p>
<p>　　  <em>图 1.从远程站点安装TPTP</em></p>
<h3>分析Java应用程序</h3>
<p>　　测试与性能工具平台基本上是一套分析工具。分析应用程序通常涉及到观察应用程序在压力之下的处理方式。这样做的一种常见方式是对已部署的应用程
序运行一组负载测试，然后使用分析工具来记录应用程序的行为。接着，可以对结果进行研究来调查任何性能问题。这些事情通常是在项目结束时进行的，因为此时
应用程序几乎已经准备好进入生产阶段了。</p>
<p>　　TPTP非常适合这类任务。一个典型的用例是使用像JMeter这样的工具来运行负载测试，然后使用TPTP归纳工具记录和分析性能统计数据。</p>
<p>　　然而，这并非使用TPTP分析应用程序的唯一方式。通常，越早进行测试，后面遇到的问题就越少。借助TPTP，您可以在很多上下文中分析代码，包括JUnit测试用例、<a target="_blank" href="http://www.onjava.com/pub/a/onjava/2006/08/16/profiling-with-eclipse-callisto.html#">Java 应用程序</a>和web应用程序。而且它很好地集成到了Eclipse IDE中。所以，没有理由不在早期开始初步性能测试和分析工作。</p>
<p>　　TPTP让您可以测试应用程序行为的几个方面，包括内存使用（创建了多少对象，这些对象的大小如何）、执行统计数据（应用程序在哪些地方所花的时间较多）和测试覆盖（测试期间执行代码的确切数量）。每个方面均可提供有关应用程序性能的独立信息。</p>
<p>　　不管怎么说，内存泄漏可能而且的确存在于Java中。创建（并保存）不必要的对象会增加对内存的需求，并加重垃圾收集器的工作负担，这都会损害
应用程序的性能。而且，如果运行应用程序的服务器的持续正常运行时间很长，累积下来的内存泄漏可能最终导致应用程序崩溃或服务器停止运行。这些都是留心应
用程序内存泄漏情况的充分理由。</p>
<p>　　根据80-20经验法则，80%的性能问题出现在20%的代码中。或者，换句话说，只要把精力集中在应用程序中执行最经常的部分上，就可以花费相对较少的气力使性能有实质性的提高。在这种情况下，执行统计数据就可以派上用场了。</p>
<p>　　除此以外，TPTP还提供一些基本的测试覆盖数据。尽管这些统计数据不如Cobertura或Clover这样的专用工具提供的完整，您仍然可以通过它们快速了解性能测试正在有效地测试哪些方法。</p>
<p>　　在本文中，我讨论的测试种类同样是没有经过优化的。优化涉及到使用像缓冲这样的技术对应用程序性能进行微调。这是一项对技术要求很高的操作，最好留到项目的最后完成。</p>
<p>　　这里所讨论的这种初步性能测试和分析仅仅包括，确保应用程序从一开始就正确执行，以及没有编码错误或糟糕的编码实践会在后面的阶段中对性能产生不利的影响。事实上，修复内存泄漏和避免不必要的对象创建并不是优化——这只不过是调试，而且同样应该尽可能早地完成。</p>
<p>　　让我们通过使用一些单元测试来分析一个类的方式开始。可以分析常规的单元或集成测试，或者编写针对性更强的面向性能的测试。通常，您应该尝试分
析与生产代码最接近的代码。许多人使用模拟对象来代替DAO对象进行单元测试，使用这项功能强大的技术可以加速开发生命周期。如果使用这类方法，一定要使
用这些测试来运行分析工具，它可以揭示有关内存使用和测试覆盖的有用信息。然而，性能测试的价值是有限的，因为对于与数据库相关的应用程序来说，其性能往
往是由数据库的性能所决定的，所以在这个上下文中，应该进行所有重要的性能测试。简而言之，不要忘了分析基于实际数据库而运行的集成测试。</p>
<p>　　出于本文的需要，我们将对以下类进行测试，这个类代表了一个到库目录的简单接口。</p>  
<pre class="code">interface Catalog {<br />    List&amp;lt;Book&amp;gt; findBooksByAuthor(String name);<br />    List&amp;lt;Book&amp;gt; findAllBooks();<br />}<br /></pre> 
<p>　　基本的单元测试如下：</p>
<pre class="code">public class CatalogTest extends TestCase {<br />    ...<br />    public Catalog getCatalog() {<br />        ...<br />    }<br /><br />    public void testFindBooksByAuthor() {<br />        List&amp;lt;Book&amp;gt; books = getCatalog().findBooksByAuthor(&amp;quot;Lewis&amp;quot;);<br />    }<br /><br />    public void testLoadFindBooksByAuthor() {<br />        for(int i = 0; i &amp;lt; 10; i++) {<br />            List&amp;lt;Book&amp;gt; books<br />                = getCatalog().findBooksByAuthor(&amp;quot;Lewis&amp;quot;);<br />        }<br />    }<br /><br />    public void testFindAll() {<br />        List&amp;lt;Book&amp;gt; books = getCatalog().findAllBooks();<br />    }<br />}<br /></pre>
<p>　　您需要做的第一件事情就是建立一个分析。在Eclipse主菜单中选择&amp;quot;Run  -&amp;gt; Profile&amp;quot;，这将打开一个向导，您可以在其中配置不同种类的测试分析，如图2所示。</p><p align="center">  <img width="480" height="320" border="0" alt="使用Eclipse Callisto分析应用程序图-2" src="http://dev2dev.bea.com.cn/images/image061122002.gif" /></p>  
<p>　　<em>图 2. 创建一个TPTP分析</em></p>
<p>　　在这个例子中，我们感兴趣的是JUnit测试分析。双击这一项；向导应该为每个单元测试类创建新的项。TPTP相当灵活，您可以在此屏幕中配置
各个选项。例如，在Test选项卡上，可以单独分析单元测试类，也可以按照项目或软件包对它们进行分组。在Arguments选项卡上，可以指定运行时参
数，而在Environment选项卡上可以定义环境变量。在Destination选项卡中，可以指定一个外部文件，用于保存分析数据以供以后使用。但
是，最有用的是Monitor选项卡（参见图3），可以在上面指定要记录和研究的性能相关数据：</p><ul type="disc"><li><em>Basic Memory Analysis（基本内存分析）：</em>这个选项用于记录内存使用的统计数据，包括对象实例的数量和已经使用的全部内存。</li><li><em>Execution Time Analysis（执行时间分析）：</em>这个选项用于记录性能数据——即应用程序分别在每个方法上所花的时间长短。</li><li><em>Method Code Coverage（方法代码覆盖）：</em>这个选项用于通知在测试期间执行了哪些类和方法。</li></ul><p align="center"><img width="450" height="276" border="0" alt="使用Eclipse Callisto分析应用程序图-3" src="http://dev2dev.bea.com.cn/images/image061122003.gif" /></p>
<p>　　  <em>图 3: 在Monitor选项卡上定义要记录数据的类型。</em></p>
<p>　　您可以直接从这个窗口运行分析工具，也可以使用位于要分析的测试类上的上下文菜单，方法是选择Profile As菜单项（参见图4）。</p><p align="center">  <img width="450" height="547" border="0" alt="使用Eclipse Callisto分析应用程序图-4" src="http://dev2dev.bea.com.cn/images/image061122004.gif" /></p>  
<p>　　<em>图 4:可以使用上下文菜单运行TPTP分析工具。</em></p>
<p>　　运行分析具可能要花上一段时间，这取决于测试用例的大小。完成之后，Eclipse将显示一个Profiling  Monitor视图，可以在其中显示每种类型分析的结果的详细信息（参见图5）。</p>
<p>　　<br clear="all" /> </p><p align="center">  <img width="450" height="267" border="0" alt="使用Eclipse Callisto分析应用程序图-5" src="http://dev2dev.bea.com.cn/images/image061122005.gif" /></p>  
<p>　　<em>图 5: 分析结果</em></p>
<p>　　Memory  Statistics视图显示了应用程序创建的对象的数量。结果可以按照软件包来组织（以树视图的形式），或者显示为类或实例的一个列表。这些<a target="_blank" href="http://www.onjava.com/pub/a/onjava/2006/08/16/profiling-with-eclipse-callisto.html?page=3#">数据</a>可以让您了解每种类型创建了多少个对象；应该对创建的对象（特别是高级对象，例如域对象）不正常的高数量持怀疑态度。</p>
<p>　　用于检测内存泄漏的另一个有用工具是Object
References视图。为了获得这些数据，您需要激活引用收集。启动分析之后，点击monitoring项，然后在上下文菜单中选择Collect
Object References（参见图6）。接下来，通过上下文菜单（Open with -&amp;gt; Object
References）打开Object
References视图。您将获得一个类的列表，它带有对每个类的引用的次数。这可以为可能的内存泄漏提供一些线索。</p><p align="center">  <img width="400" height="580" border="0" alt="使用Eclipse Callisto分析应用程序图-6" src="http://dev2dev.bea.com.cn/images/image061122006.gif" /></p>  
<p>　　<em>图 6: 激活引用收集</em></p>
<p>　　如图7所示，从Execution  Statistics视图可以清楚地了解到<a target="_blank" href="http://www.onjava.com/pub/a/onjava/2006/08/16/profiling-with-eclipse-callisto.html?page=3#">应用程序</a>执
行到了哪里。&amp;quot;organization by&amp;quot;软件包可以帮助您找出执行时间最长的类和方法。点击一个方法将打开Method Invocation
Details视图，它将显示有关方法被调用次数、调用地点以及它本身调用了哪些其他方法的更详细信息。尽管与一些可以向下发掘到源代码本身的商业工具相
比，这个视图与源代码视图的集成度没有那么高，但是它还是可以给出一些重要线索，帮助您找出执行错误的方法。</p><p align="center">  <img width="450" height="342" border="0" alt="使用Eclipse Callisto分析应用程序图-7" src="http://dev2dev.bea.com.cn/images/image061122007.gif" /></p>  
<p>　　<em>图 7: Execution Statistics视图</em></p>
<p>　　Coverage
Statistics视图（参见图8）提供的信息是关于，您刚刚运行的测试用例使用了（因此至少在某种程度上测试了）哪些方法。覆盖统计数据是一项优秀的
功能，尽管它们提供的信息的详细程度还无法与像Cobertura、Clover和jcoverage这样的专业覆盖工具相提并论（它们可以提供行精度的
覆盖数据，以及行和分支覆盖的统计数据）。尽管如此，它也有自身的优点，那就是可以提供<a target="_blank" href="http://www.onjava.com/pub/a/onjava/2006/08/16/profiling-with-eclipse-callisto.html?page=4#">实时的</a>覆盖结果，而目前，只有商业的代码覆盖工具，例如Clover和jcoverage，才能提供行级别的覆盖报告和完整的IDE集成。</p>
<p align="center">  <img width="450" height="341" border="0" alt="使用Eclipse Callisto分析应用程序图-8" src="http://dev2dev.bea.com.cn/images/image061122008.gif" /></p>
<p>　　<em>图 8: Coverage Statistics视图</em></p><h3>静态分析工具</h3>
<p>　　在TPTP工具箱中，另一件有趣的工具就是<a target="_blank" href="http://en.wikipedia.org/wiki/Static_code_analysis">静态分析</a>工具。<a target="_blank" href="http://www.onjava.com/pub/a/onjava/2006/08/16/profiling-with-eclipse-callisto.html?page=4#">Java</a>静态分析工具，例如<a target="_blank" href="http://pmd.sourceforge.net/">PMD</a>，允许通过基于一组代码预定义规则和最佳实践检查来检查代码，从而自动验证代码质量。现在，TPTP也包含一个静态分析工具。除了提供它自己的一组静态分析规则之外，这个工具还可以提供一个一致的接口，其他工具厂商可以在这个接口中集成他们自己的规则。</p>
<p>　　要对代码进行静态分析，需要创建分析配置。在Java视图或Analysis图标中，使用上下文菜单打开Analysis窗口，它现在应该出现
在工具栏上（参见图9）。分析配置决定了要分析的代码（Scope）和应该遵循的规则（Rules）。有71条规则可供选择，例如&amp;quot;Avoid
casting primitive types to lower precision&amp;quot;和&amp;quot;Always provide a break at
the end of every case statement&amp;quot;。您还可以使用预定义的规则，例如&amp;quot;Java Quick Code
Review&amp;quot;（在这里，71条规则中只有19条适用）。</p><p align="center">  <img width="450" height="330" border="0" alt="使用Eclipse Callisto分析应用程序图-9" src="http://dev2dev.bea.com.cn/images/image061122009.gif" /></p>  
<p>　　<em>图 9:建立静态分析规则</em></p>
<p>　　要分析代码，使用工具栏中的Analysis图标。分析不是实时完成的，就像一些其他的类似工具一样，例如Checkstyle。然而，给出的
结果很清晰（参见图10）：错误在源代码视图中标出，并且按照错误类型，以树视图的形式在Analysis Results视图中列出。&amp;quot;Quick
Fix&amp;quot;是一项优雅的特性，它出现在错误类型的上下文菜单中，而且如果可能，它可以自动为您纠正问题。</p><p align="center">  <img width="400" height="330" border="0" alt="使用Eclipse Callisto分析应用程序图-10" src="http://dev2dev.bea.com.cn/images/image061122010.gif" /></p>  
<p>　　<em>图 10: 静态代码分析结果</em></p>
<h3>结束语</h3>
<p>　　Eclipse测试与性能工具平台是Eclipse IDE工具箱中极具价值的部分。它支持的性能测试的范围很宽，这有助于从第一个单元测试开始，就确保获得高质量和高性能的代码。</p>
<p>　　TPTP无疑还比不上一些可用的商业工具，例如OptimizeIt和JProbe，后者的报告和分析功能要更加完善，而且表示通常更加精练。
然而，商业的分析工具往往非常昂贵，而且很难在最严峻的环境中来验证它们的使用情况。尽管TPTP还相对较为不成熟，它仍然可算作一款功能强大的产品，毋
庸置疑，它可以提供对于许多项目来说不可或缺的有价值的分析<a target="_blank" href="http://www.onjava.com/pub/a/onjava/2006/08/16/profiling-with-eclipse-callisto.html?page=4##">数据</a>。</p><br /><p><br /></p><p>From BEA CN<br /></p>
]]></description> 
<guid isPermaLink="false">6764923@http://zeeslo.bokee.com/</guid> 
<dc:subject>Zee生活</dc:subject> 
<dc:date>2008-07-21T12:59:28Z</dc:date> 
</item> 
<item> 
<title><![CDATA[使用Eclipse Callisto分析应用程序]]></title> 
<link>http://zeeslo.bokee.com/6764922.html</link> 
<description><![CDATA[Eclipse（Eclipse  3.2）的最新版本带有<a target="_blank" href="http://www.eclipse.org/callisto">Callisto</a>，一套丰富的针对Eclipse 3.2的可选插件。Callisto包括一个功能强大的分析工具，此工具称为Eclipse<a target="_blank" href="http://www.eclipse.org/tptp">测试与性能工具平台</a>，简称TPTP。TPTP提供了一套功能全面的开源性能－测试和分析工具，包括集成的<a target="_blank" href="http://www.onjava.com/pub/a/onjava/2006/08/16/profiling-with-eclipse-callisto.html##">应用程序</a>监控、测试、跟踪和分析功能，以及静态代码分析工具。对于在各类Java应用程序中找出和识别性能问题，分析工具的价值是不可估计的。在本文中，我们将探讨如何使用TPTP来保证获得高质量和高性能的代码（甚至是在单元和集成测试中）。<h3>安装TPTP</h3>
<p>　　安装TPTP最容易的方式是使用Remote Update站点（参见图1）。打开Remote Update窗口（Help -&amp;gt;
Software Updates -&amp;gt; Find and Install），然后选择Callisto Discovery
Site。Eclipse将建议安装Callisto插件集。TPTP工具列在“Testing and
Performance”下面。最容易也是最耗时的选择，就是安装所有建议的插件。即使不安装整个Callisto工具集，您仍然需要安装一些其他
TPTP需要的组件，例如&amp;quot;Charting and Reporting&amp;quot;、&amp;quot;Enabling Features&amp;quot;和&amp;quot;<a target="_blank" href="http://www.onjava.com/pub/a/onjava/2006/08/16/profiling-with-eclipse-callisto.html##">Data</a> Tool  Performance&amp;quot;。</p><p align="center">    <img width="435" height="454" border="0" alt="使用Eclipse Callisto分析应用程序图-1" src="http://dev2dev.bea.com.cn/images/image061122001.gif" /></p>
<p>　　  <em>图 1.从远程站点安装TPTP</em></p>
<h3>分析Java应用程序</h3>
<p>　　测试与性能工具平台基本上是一套分析工具。分析应用程序通常涉及到观察应用程序在压力之下的处理方式。这样做的一种常见方式是对已部署的应用程
序运行一组负载测试，然后使用分析工具来记录应用程序的行为。接着，可以对结果进行研究来调查任何性能问题。这些事情通常是在项目结束时进行的，因为此时
应用程序几乎已经准备好进入生产阶段了。</p>
<p>　　TPTP非常适合这类任务。一个典型的用例是使用像JMeter这样的工具来运行负载测试，然后使用TPTP归纳工具记录和分析性能统计数据。</p>
<p>　　然而，这并非使用TPTP分析应用程序的唯一方式。通常，越早进行测试，后面遇到的问题就越少。借助TPTP，您可以在很多上下文中分析代码，包括JUnit测试用例、<a target="_blank" href="http://www.onjava.com/pub/a/onjava/2006/08/16/profiling-with-eclipse-callisto.html#">Java 应用程序</a>和web应程序。而且它很好地集成到了Eclipse IDE中。所以，没有理由不在早期开始初步性能测试和分析工作。</p>
<p>　　TPTP让您可以测试应用程序行为的几个方面，包括内存使用（创建了多少对象，这些对象的大小如何）、执行统计数据（应用程序在哪些地方所花的时间较多）和测试覆盖（测试期间执行代码的确切数量）。每个方面均可提供有关应用程序性能的独立信息。</p>
<p>　　不管怎么说，内存泄漏可能而且的确存在于Java中。创建（并保存）不必要的对象会增加对内存的需求，并加重垃圾收集器的工作负担，这都会损害
应用程序的性能。而且，如果运行应用程序的服务器的持续正常运行时间很长，累积下来的内存泄漏可能最终导致应用程序崩溃或服务器停止运行。这些都是留心应
用程序内存泄漏情况的充分理由。</p>
<p>　　根据80-20经验法则，80%的性能问题出现在20%的代码中。或者，换句话说，只要把精力集中在应用程序中执行最经常的部分上，就可以花费相对较少的气力使性能有实质性的提高。在这种情况下，执行统计数据就可以派上用场了。</p>
<p>　　除此以外，TPTP还提供一些基本的测试覆盖数据。尽管这些统计数据不如Cobertura或Clover这样的专用工具提供的完整，您仍然可以通过它们快速了解性能测试正在有效地测试哪些方法。</p>
<p>　　在本文中，我讨论的测试种类同样是没有经过优化的。优化涉及到使用像缓冲这样的技术对应用程序性能进行微调。这是一项对技术要求很高的操作，最好留到项目的最后完成。</p>
<p>　　这里所讨论的这种初步性能测试和分析仅仅包括，确保应用程序从一开始就正确执行，以及没有编码错误或糟糕的编码实践会在后面的阶段中对性能产生不利的影响。事实上，修复内存泄漏和避免不必要的对象创建并不是优化——这只不过是调试，而且同样应该尽可能早地完成。</p>
<p>　　让我们通过使用一些单元测试来分析一个类的方式开始。可以分析常规的单元或集成测试，或者编写针对性更强的面向性能的测试。通常，您应该尝试分
析与生产代码最接近的代码。许多人使用模拟对象来代替DAO对象进行单元测试，使用这项功能强大的技术可以加速开发生命周期。如果使用这类方法，一定要使
用这些测试来运行分析工具，它可以揭示有关内存使用和测试覆盖的有用信息。然而，性能测试的价值是有限的，因为对于与数据库相关的应用程序来说，其性能往
往是由数据库的性能所决定的，所以在这个上下文中，应该进行所有重要的性能测试。简而言之，不要忘了分析基于实际数据库而运行的集成测试。</p>
<p>　　出于本文的需要，我们将对以下类进行测试，这个类代表了一个到库目录的简单接口。</p>  
<pre class="code">interface Catalog {<br />    List&amp;lt;Book&amp;gt; findBooksByAuthor(String name);<br />    List&amp;lt;Book&amp;gt; findAllBooks();<br />}<br /></pre> 
<p>　　基本的单元测试如下：</p>
<pre class="code">public class CatalogTest extends TestCase {<br />    ...<br />    public Catalog getCatalog() {<br />        ...<br />    }<br /><br />    public void testFindBooksByAuthor() {<br />        List&amp;lt;Book&amp;gt; books = getCatalog().findBooksByAuthor(&amp;quot;Lewis&amp;quot;);<br />    }<br /><br />    public void testLoadFindBooksByAuthor() {<br />        for(int i = 0; i &amp;lt; 10; i++) {<br />            List&amp;lt;Book&amp;gt; books<br />                = getCatalog().findBooksByAuthor(&amp;quot;Lewis&amp;quot;);<br />        }<br />    }<br /><br />    public void testFindAll() {<br />        List&amp;lt;Book&amp;gt; books = getCatalog().findAllBooks();<br />    }<br />}<br /></pre>
<p>　　您需要做的第一件事情就是建立一个分析。在Eclipse主菜单中选择&amp;quot;Run  -&amp;gt; Profile&amp;quot;，这将打开一个向导，您可以在其中配置不同种类的测试分析，如图2所示。</p><p align="center">  <img width="480" height="320" border="0" alt="使用Eclipse Callisto分析应用程序图-2" src="http://dev2dev.bea.com.cn/images/image061122002.gif" /></p>  
<p>　　<em>图 2. 创建一个TPTP分析</em></p>
<p>　　在这个例子中，我们感兴趣的是JUnit测试分析。双击这一项；向导应该为每个单元测试类创建新的项。TPTP相当灵活，您可以在此屏幕中配置
各个选项。例如，在Test选项卡上，可以单独分析单元测试类，也可以按照项目或软件包对它们进行分组。在Arguments选项卡上，可以指定运行时参
数，而在Environment选项卡上可以定义环境变量。在Destination选项卡中，可以指定一个外部文件，用于保存分析数据以供以后使用。但
是，最有用的是Monitor选项卡（参见图3），可以在上面指定要记录和研究的性能相关数据：</p><ul type="disc"><li><em>Basic Memory Analysis（基本内存分析）：</em>这个选项用于记录内存使用的统计数据，包括对象实例的数量和已经使用的全部内存。</li><li><em>Execution Time Analysis（执行时间分析）：</em>这个选项用于记录性能数据——即应用程序分别在每个方法上所花的时间长短。</li><li><em>Method Code Coverage（方法代码覆盖）：</em>这个选项用于通知在测试期间执行了哪些类和方法。</li></ul><p align="center"><img width="450" height="276" border="0" alt="使用Eclipse Callisto分析应用程序图-3" src="http://dev2dev.bea.com.cn/images/image061122003.gif" /></p>
<p>　　  <em>图 3: 在Monitor选项卡上定义要记录数据的类型。</em></p>
<p>　　您可以直接从这个窗口运行分析工具，也可以使用位于要分析的测试类上的上下文菜单，方法是选择Profile As菜单项（参见图4）。</p><p align="center">  <img width="450" height="547" border="0" alt="使用Eclipse Callisto分析应用程序图-4" src="http://dev2dev.bea.com.cn/images/image061122004.gif" /></p>  
<p>　　<em>图 4:可以使用上下文菜单运行TPTP分析工具。</em></p>
<p>　　运行分析工具可能要花上一段时间，这取决于测试用例的大小。完成之后，Eclipse将显示一个Profiling  Monitor视图，可以在其中显示每种类型分析的结果的详细信息（参见图5）。</p>
<p>　　<br clear="all" /> </p><p align="center">  <img width="450" height="267" border="0" alt="使用Eclipse Callisto分析应用程序图-5" src="http://dev2dev.bea.com.cn/images/image061122005.gif" /></p>  
<p>　　<em>图 5: 分析结果</em></p>
<p>　　Memory  Statistics视图显示了应用程序创建的对象的数量。结果可以按照软件包来组织（以树视图的形式），或者显示为类或实例的一个列表。这些<a target="_blank" href="http://www.onjava.com/pub/a/onjava/2006/08/16/profiling-with-eclipse-callisto.html?page=3#">数据</a>可以让您了解每种类型创建了多少个对象；应该对创建的对象（特别是高级对象，例如域对象）不正常的高数量持怀疑态度。</p>
<p>　　用于检测内存泄漏的另一个有用工具是Object
References视图。为了获得这些数据，您需要激活引用收集。启动分析之后，点击monitoring项，然后在上下文菜单中选择Collect
Object References（参见图6）。接下来，通过上下文菜单（Open with -&amp;gt; Object
References）打开Object
References视图。您将获得一个类的列表，它带有对每个类的引用的次数。这可以为可能的内存泄漏提供一些线索。</p><p align="center">  <img width="400" height="580" border="0" alt="使用Eclipse Callisto分析应用程序图-6" src="http://dev2dev.bea.com.cn/images/image061122006.gif" /></p>  
<p>　　<em>图 6: 激活引用收集</em></p>
<p>　　如图7所示，从Execution  Statistics视图可以清楚地了解到<a target="_blank" href="http://www.onjava.com/pub/a/onjava/2006/08/16/profiling-with-eclipse-callisto.html?page=3#">应用程序</a>执
行到了哪里。&amp;quot;organization by&amp;quot;软件包可以帮助您找出执行时间最长的类和方法。点击一个方法将打开Method Invocation
Details视图，它将显示有关方法被调用次数、调用地点以及它本身调用了哪些其他方法的更详细信息。尽管与一些可以向下发掘到源代码本身的商业工具相
比，这个视图与源代码视图的集成度没有那么高，但是它还是可以给出一些重要线索，帮助您找出执行错误的方法。</p><p align="center">  <img width="450" height="342" border="0" alt="使用Eclipse Callisto分析应用程序图-7" src="http://dev2dev.bea.com.cn/images/image061122007.gif" /></p>  
<p>　　<em>图 7: Execution Statistics视图</em></p>
<p>　　Coverage
Statistics视图（参见图8）提供的信息是关于，您刚刚运行的测试用例使用了（因此至少在某种程度上测试了）哪些方法。覆盖统计数据是一项优秀的
功能，尽管它们提供的信息的详细程度还无法与像Cobertura、Clover和jcoverage这样的专业覆盖工具相提并论（它们可以提供行精度的
覆盖数据，以及行和分支覆盖的统计数据）。尽管如此，它也有自身的优点，那就是可以提供<a target="_blank" href="http://www.onjava.com/pub/a/onjava/2006/08/16/profiling-with-eclipse-callisto.html?page=4#">实时的</a>覆盖结果，而目前，只有商业的代码覆盖工具，例如Clover和jcoverage，才能提供行级别的覆盖报告和完整的IDE集成。</p>
<p align="center">  <img width="450" height="341" border="0" alt="使用Eclipse Callisto分析应用程序图-8" src="http://dev2dev.bea.com.cn/images/image061122008.gif" /></p>
<p>　　<em>图 8: Coverage Statistics视图</em></p><h3>静态分析工具</h3>
<p>　　在TPTP工具箱中，另一件有趣的工具就是<a target="_blank" href="http://en.wikipedia.org/wiki/Static_code_analysis">静态分析</a>工具。<a target="_blank" href="http://www.onjava.com/pub/a/onjava/2006/08/16/profiling-with-eclipse-callisto.html?page=4#">Jva</a>静态分析工具，例如<a target="_blank" href="http://pmd.sourceforge.net/">PMD</a>，允许通过基于一组代码预定义规则和最佳实践检查来检查代码，从而自动验证代码质量。现在，TPTP也包含一个静态分析工具。除了提供它自己的一组静态分析规则之外，这个工具还可以提供一个一致的接口，其他工具厂商可以在这个接口中集成他们自己的规则。</p>
<p>　　要对代码进行静态分析，需要创建分析配置。在Java视图或Analysis图标中，使用上下文菜单打开Analysis窗口，它现在应该出现
在工具栏上（参见图9）。分析配置决定了要分析的代码（Scope）和应该遵循的规则（Rules）。有71条规则可供选择，例如&amp;quot;Avoid
casting primitive types to lower precision&amp;quot;和&amp;quot;Always provide a break at
the end of every case statement&amp;quot;。您还可以使用预定义的规则，例如&amp;quot;Java Quick Code
Review&amp;quot;（在这里，71条规则中只有19条适用）。</p><p align="center">  <img width="450" height="330" border="0" alt="使用Eclipse Callisto分析应用程序图-9" src="http://dev2dev.bea.com.cn/images/image061122009.gif" /></p>  
<p>　　<em>图 9:建立静态分析规则</em></p>
<p>　　要分析代码，使用工具栏中的Analysis图标。分析不是实时完成的，就像一些其他的类似工具一样，例如Checkstyle。然而，给出的
结果很清晰（参见图10）：错误在源代码视图中标出，并且按照错误类型，以树视图的形式在Analysis Results视图中列出。&amp;quot;Quick
Fix&amp;quot;是一项优雅的特性，它出现在错误类型的上下文菜单中，而且如果可能，它可以自动为您纠正问题。</p><p align="center">  <img width="400" height="330" border="0" alt="使用Eclipse Callisto分析应用程序图-10" src="http://dev2dev.bea.com.cn/images/image061122010.gif" /></p>  
<p>　　<em>图 10: 静态代码分析结果</em></p>
<h3>结束语</h3>
<p>　　Eclipse测试与性能工具平台是Eclipse IDE工具箱中极具价值的部分。它支持的性能测试的范围很宽，这有助于从第一个单元测试开始，就确保获得高质量和高性能的代码。</p>
<p>　　TPTP无疑还比不上一些可用的商业工具，例如OptimizeIt和JProbe，后者的报告和分析功能要更加完善，而且表示通常更加精练。
然而，商业的分析工具往往非常昂贵，而且很难在最严峻的环境中来验证它们的使用情况。尽管TPTP还相对较为不成熟，它仍然可算作一款功能强大的产品，毋
庸置疑，它可以提供对于许多项目来说不可或缺的有价值的分析<a target="_blank" href="http://www.onjava.com/pub/a/onjava/2006/08/16/profiling-with-eclipse-callisto.html?page=4##">数据</a>。</p><br /><p><br /></p><p>From BEA CN<br /></p>
]]></description> 
<guid isPermaLink="false">6764922@http://zeeslo.bokee.com/</guid> 
<dc:subject>Zee生活</dc:subject> 
<dc:date>2008-07-21T12:58:56Z</dc:date> 
</item> 
<item> 
<title><![CDATA[SQL Server Buffer Manager 对象]]></title> 
<link>http://zeeslo.bokee.com/6737709.html</link> 
<description><![CDATA[<b>uffer Manager</b> 对象提供了计数器，用于监视 SQL Server 如何使用： <ul><li>
内存存储数据页、内部数据结构和过程缓存。<br /> </li><li>
计数器监视 SQL Server 读取和写入数据库页时的物理 I/O。 <br /> </li></ul> <p>监视 SQL Server 使用的内存和计数器有助于确定：  </p> <ul><li>
是否存在物理内存不足的瓶颈。如果 SQL Server 无法将经常访问的数据存储在缓存中，则必须从磁盘检索数据。 <br /> </li><li>
是否可以通过添加更多内存或增加数据缓存或 SQL Server 内部结构的可用内存来提高查询性能。<br /> </li><li>
SQL Server 需要从磁盘读取数据的频率。与其他操作（例如内存访问）相比，物理 I/O 会消耗大量时间。尽可能减少物理 I/O 可以提高查询性能。<br /> </li></ul> <p>还可以使用地址窗口化扩展插件 (AWE) 计数器来监视 SQL Server 中的 AWE 活动。例如，可以确保 SQL Server 有足够的内存分配给 AWE，以使其正确运行。有关详细信息，请参阅<a href="http://msdn.microsoft.com/zh-cn/library/ms187499.aspx" onclick="function onclick(event) {
javascript:
    Track("ctl00_rs1_mainContentContainer_ctl00|ctl00_rs1_mainContentContainer_ctl01", this);
}" id="ctl00_rs1_mainContentContainer_ctl01">内存体系结构</a>、<a href="http://msdn.microsoft.com/zh-cn/library/ms175581.aspx" onclick="function onclick(event) {
javascript:
    Track("ctl00_rs1_mainContentContainer_ctl00|ctl00_rs1_mainContentContainer_ctl02", this);
}" id="ctl00_rs1_mainContentContainer_ctl02">使用 AWE</a>或 <a href="http://msdn.microsoft.com/zh-cn/library/ms190731.aspx" onclick="function onclick(event) {
javascript:
    Track("ctl00_rs1_mainContentContainer_ctl00|ctl00_rs1_mainContentContainer_ctl03", this);
}" id="ctl00_rs1_mainContentContainer_ctl03">awe enabled 选项</a>。</p> <p>下表描述了 SQL Server <b>Buffer Manager</b> 性能对象。</p> <h3 class="subHeading"><!----></h3><table width="100%" border="1" style="background-color: rgb(204, 204, 204);"><tbody><tr> <th>
SQL Server Buffer Manager 计数器
          </th> <th>
说明
          </th> </tr><tr> <td> <p><b>AWE lookup maps/sec</b></p> </td> <td> <p>每秒服务器请求、在缓冲池中查找和映射数据库页的次数。数据库页映射后便成为服务器虚拟地址空间的一部分。</p> </td> </tr><tr> <td> <p><b>AWE stolen maps/sec</b></p> </td> <td> <p>每秒从可用列表中取出和映射缓冲区的次数。</p> </td> </tr><tr> <td> <p><b>AWE unmap calls/sec</b></p> </td> <td> <p>每秒调用取消映射缓冲区的次数。缓冲区取消映射后，将被排除在虚拟服务器地址空间之外。每次调用时可以取消映射一个或多个缓冲区。</p> </td> </tr><tr> <td> <p><b>AWE unmap pages/sec</b></p> </td> <td> <p>每秒取消映射的 SQL Server 缓冲区数。</p> </td> </tr><tr> <td> <p><b>AWE write maps/sec</b></p> </td> <td> <p>每秒必须映射到脏缓冲区中的次数，经过该次数后才能写入磁盘。</p> </td> </tr><tr> <td> <p><b>Buffer Cache Hit Ratio</b></p> </td> <td> <p>在
缓冲区高速缓存中找到而不需要从磁盘中读取的页的百分比。该比率是缓存命中总次数与过去几千页访问以来的缓存查找总次数之比。经过很长时间后，该比率的变
化很小。由于从缓存中读取数据比从磁盘中读取数据的开销小得多，一般希望该比率高一些。通常，可以通过增加 SQL Server
的可用内存量来提高缓冲区高速缓存命中率。</p> </td> </tr><tr> <td> <p><b>Checkpoint pages/sec</b></p> </td> <td> <p>由要求刷新所有脏页的检查点或其他操作每秒刷新到磁盘的页数。</p> </td> </tr><tr> <td> <p><b>Database pages</b></p> </td> <td> <p>缓冲池中有数据库内容的页数。</p> </td> </tr><tr> <td> <p><b>Free list stalls/sec</b></p> </td> <td> <p>每秒必须等待可用页的请求次数。</p> </td> </tr><tr> <td> <p><b>Free pages</b></p> </td> <td> <p>所有可用列表的总页数。</p> </td> </tr><tr> <td> <p><b>Lazy writes/sec</b></p> </td> <td> <p>每秒被缓冲区管理器的惰性编写器写入的缓冲区数。惰性编写器是一个系统进程，用于成批刷新脏的老化的缓冲区（包含更改的缓冲区，必须将这些更改写回磁盘，才能将缓冲区重用于其他页），并使它们可用于用户进程。惰性编写器不需要为创建可用缓冲区而频繁执行检查点。</p> </td> </tr><tr> <td> <p><b>Page life expectancy</b></p> </td> <td> <p>页若不被引用将在缓冲池中停留的秒数。</p> </td> </tr><tr> <td> <p><b>Page lookups/sec</b></p> </td> <td> <p>每秒要求在缓冲池中查找页的请求数。</p> </td> </tr><tr> <td> <p><b>Page reads/sec</b></p> </td> <td> <p>每秒发出的物理数据库页读取数。此统计信息显示的是所有数据库间的物理页读取总数。由于物理 I/O 的开销大，可以通过使用更大的数据缓存、智能索引、更有效的查询或更改数据库设计等方法，将开销降到最低。</p> </td> </tr><tr> <td> <p><b>Page writes/sec</b></p> </td> <td> <p>每秒执行的物理数据库页写入数。</p> </td> </tr><tr> <td> <p><b>Readahead pages/sec</b></p> </td> <td> <p>每秒为预期使用读取的页数。</p> </td> </tr><tr> <td> <p><b>Reserved Pages</b></p> </td> <td> <p>缓冲池保留的页数。</p> </td> </tr><tr> <td> <p><b>Stolen pages</b></p> </td> <td> <p>用于其他服务器用途（包括过程缓存）的页数。</p> </td> </tr><tr> <td> <p><b>Target Pages</b></p> </td> <td> <p>缓冲池中理想的页数。</p> </td> </tr><tr> <td> <p><b>Total Pages</b></p> </td> <td> <p>缓冲池中的页数（包括数据库页、可用页和被盗页）。</p></td></tr></tbody></table>
]]></description> 
<guid isPermaLink="false">6737709@http://zeeslo.bokee.com/</guid> 
<dc:subject>Zee生活</dc:subject> 
<dc:date>2008-06-14T11:33:26Z</dc:date> 
</item> 
<item> 
<title><![CDATA[提升性能的窍门：调优内存分配 ]]></title> 
<link>http://zeeslo.bokee.com/6570576.html</link> 
<description><![CDATA[<table cellspacing="0" cellpadding="0" width="100%" border="0"><tbody><tr><td class="blogcontents2"><table width="100%"><tbody><tr><td align="center"><div class="authorIntro2 padlr5"><table cellspacing="0" cellpadding="0" width="100%" border="0"><tbody><tr><td width="12"><font size="2">&amp;nbsp;</font></td><td valign="top" align="left"><a href="http://dev2dev.bea.com/pub/au/3267" target="_blank"><font color="#0065c9" size="">Henrik St&amp;aring;hl</font></a><font size="2"> 是JRockit团队的产品主管，他于2004年加入BEA。他与JRockit的渊源可追溯到该产品的首次公开发布，他是早期的beta测试人员之一。之前他曾做过开发人员、系统架构师，进行性能测试和调优，负责IT安全性。 </font></td></tr></tbody></table></div><br /><br /><!--bloger基本信息--></td></tr></tbody></table></td></tr><tr><td class="blogcontents"><div id="div_content"><p><font size="2">　　如</font><a href="http://edocs.bea.com/jrockit/geninfo/memman/index.html" target="_blank"><font color="#0065c9" size="2">Memory Management Guide</font></a><font size="2">中所述，JRockit使用了</font><a href="http://edocs.bea.com/jrockit/geninfo/memman/concepts.html#wp999480" target="_blank"><font color="#0065c9" size="2">thread local area (TLA)分配</font></a><font size="2">以避免直接从Java堆分配所有内存所带来的瓶颈。一个TLA的默认大小是2 Kb，这对于一个分配大量内存的Java程序来说太小了，尤其是在JRockit进程使用许多CPU时。此外，JRockit还经常直接从堆分配大型对象。默认情况下，大型对象被定义为大于2 kB的对象，通常是数组。这个常量对于分配大量大型数组的应用程序来说太小了，在涉及到XML时，大型数组并不罕见。</font></p><p><font size="2">　　如果这些常量对于应用程序来说太低，那么内存分配就会成为一个瓶颈。在这种情况下，调优这些常量就会产生显著的性能提升（提升5-10%并不罕见）。</font></p><p><font size="2">　　要查明应用程序中是否存在这种瓶颈，可以</font><a href="http://edocs.bea.com/jrockit/tools/usingjra/jra.html#wp1059297" target="_blank"><font color="#0065c9" size="2">创建JRA记录</font></a><font size="2">并</font><a href="http://edocs.bea.com/jrockit/tools/usingjra/jra.html#wp1057828" target="_blank"><font color="#0065c9" size="2">在JRA工具中加载它</font></a><font size="2">。记录将在</font><a href="http://edocs.bea.com/jrockit/tools/usingjra/looking.html#wp1058881" target="_blank"><font color="#0065c9" size="2">General</font></a><font size="2">选项卡中打开，该选项卡包含有关于</font><a href="http://edocs.bea.com/jrockit/tools/usingjra/looking.html#wp1058493" target="_blank"><font color="#0065c9" size="2">Allocation</font></a><font size="2">的区域。</font></p><p><font size="2">　　下面是来自一个应用程序的示例条目，其中包含有</font><a href="http://edocs.bea.com/jrockit/jrdocs/refman/optionXX.html#wp1020097" target="_blank"><font color="#0065c9" size="2">-XXtlasize</font></a><font size="2">和</font><a href="http://edocs.bea.com/jrockit/jrdocs/refman/optionXX.html#wp1008230" target="_blank"><font color="#0065c9" size="2">-XXlargeobjectlimit</font></a><font size="2">的默认值。</font></p><p align="center"><font size="2"><img height="282" alt="tlasize-default" src="http://dev2dev.bea.com.cn/images/image060704002.jpg" width="533" border="0" /></font></p><h3><font size="2">使用JVM命令行-Xms2g -Xmx2g的结果</font></h3><p><font size="2">　　该记录的生成花费了2分钟，在此期间，分配了220万个TLA和80万个大型对象。这意味着堆锁定几乎达到了20万次/秒。虽然这似乎还处于合理的限制范围内，但是让我们增大TLA大小和大型对象限制，然后看看会有什么结果。</font></p><p align="center"><font size="2">　　<img height="288" alt="tlasize64klol8k.png" src="http://dev2dev.bea.com.cn/images/image060704004.jpg" width="533" border="0" /></font></p><h3><font size="2">使用JVM命令行-Xms2g -Xmx2g -XXtlasize64k -XXlargeobjectlimit8k的结果</font></h3><p><font size="2">　　现在我们获得了6千次/秒的堆锁定，大约是原来的三十分之一。在这个例子中，这仅仅使性能提高了1%左右。这几乎没什么大的影响，但是已足以说明这种思路。此外，在此例中，我还可以对tlasize和largeobjectlimit使用更小的值而获得相同的性能提升。在第一幅屏幕快照中，大型对象的最大大小是2 kB，所以将largeobjectlimit设置为3 kB就已经足够了。</font></p><p><font size="2">　　另一个信息源是JRA工具中的</font><a href="http://edocs.bea.com/jrockit/tools/usingjra/looking.html#wp1056684" target="_blank"><font color="#0065c9" size="2">Lock Profiling</font></a><font size="2">选项卡。使用最近的几个JRockit版本生成的JRA记录包含关于Native lock即JVM内部锁的数据。其中的一个琐是GC:Heap锁，JRA展示了在记录期间竞争该锁的次数。如果数值很大，则表明堆锁定已经成为瓶颈，就需要对tlasize和largeobjectlimit的值进行调优。</font></p><p><font size="2">　　<strong>警告：</strong>将这些值设置得过高会提高对垃圾收集的需求，因为小于这些值的空闲内存区域如果不进行压缩（即在垃圾收集过程中对堆进行碎片整理）就无法使用。</font></p><p><font size="2">　　这些常量的默认值很久以前就已经设定了，而且多年来也都是合理的值。然而，随着更快的CPU和多核芯片的出现，对这些参数进行调优的需求日益增加。我们正寻求在未来的JRockit版本中提供更好的开箱即用设置并/或对其进行动态控制，但是同时这些设置也是进行手动调优的不错的例子。</font></p><p><b><font size="2">原文出处:</font></b><a href="http://dev2dev.bea.com/blog/hstahl/archive/2006/06/running_jrockit.html" target="_blank"><font color="#0065c9" size="2">http://dev2dev.bea.com/blog/hstahl/archive/2006/06/running_jrockit.html</font></a></p></div></td></tr></tbody></table>]]></description> 
<guid isPermaLink="false">6570576@http://zeeslo.bokee.com/</guid> 
<dc:subject>软件测试</dc:subject> 
<dc:date>2007-12-17T22:33:48Z</dc:date> 
</item> 
<item> 
<title><![CDATA[提升性能的窍门：调优内存分配，第2部分——预取]]></title> 
<link>http://zeeslo.bokee.com/6570569.html</link> 
<description><![CDATA[<table cellspacing="0" cellpadding="0" width="100%" border="0"><tbody><tr><td class="blogcontents2"><table width="100%"><tbody><tr><td align="center"><div class="authorIntro2 padlr5"><table cellspacing="0" cellpadding="0" width="100%" border="0"><tbody><tr><td width="12"><font size="2"></font></td><td valign="top" align="left"><a href="http://dev2dev.bea.com/pub/au/3267" target="_blank"><font color="#0065c9" size="2">Henrik St&amp;aring;hl</font></a><font size="2"> 是JRockit团队的产品主管，他于2004年加入BEA。他与JRockit的渊源可追溯到该产品的首次公开发布，他是早期的beta测试人员之一。之前他曾做过开发人员、系统架构师，进行性能测试和调优，负责IT安全性。 </font></td></tr></tbody></table></div><br /><br /><!--bloger基本信息--></td></tr></tbody></table></td></tr><tr><td class="blogcontents"><div id="div_content"><p><font size="2">　　许多Java应用程序占用了大量的内存。在内存占用最多的程序中，我们发现了一些常见任务，例如XML和其他消息处理。内存分配可能成为性能瓶颈，对于大型服务器和具有多个活动线程的应用程序来说尤其如此。JRockit中调优内存分配的常见方法是使用 </font><a href="http://edocs.bea.com/jrockit/jrdocs/refman/optionXX.html#wp1020097" target="_blank"><font color="#0065c9" size="2">-XXtlasize</font></a><font size="2"> 和 </font><a href="http://edocs.bea.com/jrockit/jrdocs/refman/optionXX.html#wp1008230" target="_blank"><font color="#0065c9" size="2">-XXlargeObjectLimit</font></a><font size="2"> 命令行参数。这是改进分配可伸缩性的一种方法，这种方法能够带来显著的性能收益。请参阅我 </font><a href="http://dev2dev.bea.com.cn/bbsdoc/20060704288.html"><font color="#0065c9" size="2">上一篇关于此主题的博客文章</font></a><font size="2">，来获得详细信息。</font></p><p><font size="2">　　和分配大量内存相关的第二个问题是，它通常导致CPU缓存命中失误。如您所知，访问CPU缓存的速度比访问主存储器的速度快了几个数量级，因此必须等待内存浪费CPU周期。在JRockit的最近版本中，我们能够使用预取来加速内存分配。简单地说，这指的是：我们可以告诉CPU提前为我们取回所需的存储区，以使内存在被访问时已经被映射到缓存了。这能够提高内存密集型应用程序的性能，在极端的情况下最高可提高40%的性能。</font></p><p><font size="2">　　如果您有一个占用了大量内存的应用程序，那么您可以随时使用这些标志。但是“大量”是相对而言的，以下是一个示例：</font></p><p align="center"><font size="2"><img height="328" alt="提升性能的窍门：调优内存分配，第2部分——预取 图-1" src="http://dev2dev.bea.com.cn/images/image070124001.jpg" width="628" border="0" /></font></p><p><font size="2">　　这是一张解析基准测试的金融消息的JRA记录的屏幕快照。如您所见，总内存分配（小对象＋大对象）超过了1 GB/s，这是一个非常大的数字。要获得关于生成和查看JRA记录的更多信息，请参阅 </font><a href="http://documentationhttp:/e-docs.bea.com/jrockit/tools/usingjra/index.html" target="_blank"><font color="#0065c9" size="2">文档</font></a><font size="2">。</font></p><p><font size="2">　　下图显示了此示例应用程序在一台双路Intel Xeon 5160（“Woodcrest”）服务器上的性能，对比了进行分配预取和不进行分配预取的情况：</font></p><p align="center"><font size="2"><img height="400" alt="提性能的窍门：调优内存分配，第2部分——预取 图-2" src="http://dev2dev.bea.com.cn/images/image070124002.jpg" width="501" border="0" /></font></p><p><font size="2">　　可以看出，只是简单地添加了几个命令行标志，性能就提高了40%。</font></p><p><font size="2">　　要在Intel x86芯片上应用此特性，只需使用 </font><a href="http://edocs.bea.com/jrockit/jrdocs/refman/optionXX.html#wp1023657" target="_blank"><font color="#0065c9" size="2">-XXallocPrefetch</font></a><font size="2"> 标志和可选的 </font><a href="http://edocs.bea.com/jrockit/jrdocs/refman/optionXX.html#wp1023736" target="_blank"><font color="#0065c9" size="2">-XXallocRedoPrefetch</font></a><font size="2"> 标志运行JRockit。要获得尽可能好的结果，您可能希望在BIOS中<em>禁用</em>硬件预取。实现此操作的具体方式取决于BIOS的品牌，但是参数通常具有诸如“Hardware Prefetcher”、“Adjacent Sector Prefetcher”、“Adjacent Cache Line Prefetcher”或类似的名称。</font></p><p><font size="2">　　我们转移到其他架构中，在AMD Opteron芯片上试用了此特性，但是没有看到收益。这可能是因为Opteron芯片对缓存命中损失不太敏感。预取通常在Itanium上使用，但是对于JRockit on SPARC不可用。</font></p><p><font size="2">　　对于某些应用程序和某些硬件来说，使用这些标志没有获益。而且在个别案例中，我们还发现性能略有下降。下一步，我们将使此特性在x86上被默认支持、调查它在AMD芯片上不产生收益的原因并扩展到SPARC。但是目前，您至少能够享受它在Xeon和Itanium芯片上产生的收益。请试用此特性并 </font><a href="http://forums.bea.com/bea/forum.jspa?forumID=2009" target="_blank"><font color="#0065c9" size="2">告知我们它的运行情况</font></a><font size="2">！</font></p><p><font size="2">　　<b>原文出处：</b></font><a href="http://dev2dev.bea.com/blog/hstahl/archive/2006/11/performance_tip.html" target="_blank"><font color="#0065c9" size="2">http://dev2dev.bea.com/blog/hstahl/archive/2006/11/performance_tip.html</font></a></p></div></td></tr></tbody></table>]]></description> 
<guid isPermaLink="false">6570569@http://zeeslo.bokee.com/</guid> 
<dc:subject>Zee生活</dc:subject> 
<dc:date>2007-12-17T22:28:03Z</dc:date> 
</item> 
<item> 
<title><![CDATA[Tuxedo性能调优经验谈]]></title> 
<link>http://zeeslo.bokee.com/6570563.html</link> 
<description><![CDATA[<br />TUXEDO应用系统对IPC资源的要求<br />一个TUXEDO应用系统在运行时会大量用到IPC资源,包括信号灯,消息队列及共享内存,下面对他们的使用情况及与他们有关的操作系统核心参数分别进行介绍:<br />UBBCONFIG中与IPC资源有关的配置参数<br />主要有: MAXACCESSERS ,REPLYQ,RQADDR,MAXSERVERS,MAXSERVICE,MAXGTT<br />TUXEDO应用系统对IPC资源的要求情况<br />信号灯:<br />一个进程在要存取TUXEDO应用系统的公告板(BB)之前,它要先获取一个信号灯,所以TUXEDO应用系统所需要的最大信号灯数与MAXACCESSERS的值相等.即:<br />MAXACCESSERS = No. of semaphores<br />与信号灯有关的操作系统核心参数有:<br />SEMMNS (maximum number of semaphores in use in the system)<br />SEMMNI (maximum number of active semaphore sets)<br />SEMMSL (maximum number of semaphores per semaphore set)<br />SEMMAP (size of control map used to manage semaphore sets)<br />SEMMNU (number of undo structures in the system)<br />SEMUME (maximum number of undo entries per undo entries)<br />消息队列:<br />TUXEDO应用系统在以下几种情况下会用到操作系统的消息队列<br />1. 每个SERVER都对应一个消息队列,客户端的请求发送到该消息队列中,该SEVER从<br />该消息队列中取请求并处理. <br />2. 如果是本地客户端,那么它也对应一个消息队列,用于接收SERVER的处理结果.如果<br />是远程客户端,那么SERVER的处理结果通过网络传送,不会占用消息队列.<br />3. 如果采用MSSQ方式,那么在个MSSQ中的所有SERVER共用一个请求队列.<br />4. 如果某个SERVER或在MSSQ中设置了REPLYQ=Y,那么它要占用一个消息队列<br />所以一个TUXEDO应用系统需要的最大消息队列为:<br />Number of Queues = (MAXACCESSERS + Number of Servers with Reply Queues +<br />Number of MSSQ Sets - Number of Servers in MSSQ Sets)<br />与消息队列有关的操作系统核心参数必须满足:<br />1. 消息队列的个数要足够多,能够满足系统的最大需求<br />2. 消息的大小必须能满足系统可能出现的最大的消息的大小<br />3. 消息队列的长度要足够长,能容纳下较多的消息个数,使入对操作不用等待或不用等太长<br />的时间<br />与消息队列有关的操作系统核心参数有:<br />MSGMNI (number of unique message queue identifiers)<br />MSGMAP (size of control map to manage message segments)<br />MSGMAX (maximum message size)<br />MSGMNB (maximum message queue length)<br />MSGSSZ (size of a message segment)<br />MSGTQL (number of outstanding messages)<br />MSGSEG (number of message segments in the system)<br />TUXEDO把整个应用系统的配置信息放到共享内存中,一个TUXEDO应用系统所需要的共享内存由以下参数及配置决定:<br />1. MAXSERVERS,MAXSERVICE,MAXGTT的值<br />2. *ROUTING,*GROUP,*NETWORK节的大小<br />与共享内存有关的操作核心参数有:<br />SHMMAX (maximum shared memory segment size) <br />SHMSEG (maximum number of shared memory segments per process) <br />SHMMNI (maximum number of shared memory identifiers in the system)<br />SHMMIN(maximum shared memory segment size) 一般要设为1<br />一个TUXEDO应用系统在运行时所需要的IPC资源的计算<br />一个TUXEDO应用系统在运行时所需要的IPC资源可用tmboot -c 计算出来.如UBBCONFIG的内容为:<br />*RESOURCES<br />IPCKEY 123456<br />DOMAINID simpapp<br />MASTER simple<br />MAXACCESSERS 100<br />MAXSERVERS 50<br />MAXSERVICES 100<br />MODEL SHM<br />*MACHINES<br />MYSERVER LMID=simple<br />APPDIR=&amp;quot;d:\tuxdemo\conn&amp;quot;<br />TUXCONFIG=&amp;quot;d:\tuxdemo\conn\tuxconfig&amp;quot;<br />TUXDIR=&amp;quot;d:\tuxedo65&amp;quot;<br />MAXWSCLIENTS=5<br />*GROUPS<br />GROUP1<br />LMID=simple GRPNO=1<br />GROUP2<br />LMID=simple GRPNO=11<br />*SERVERS<br />DEFAULT:<br />CLOPT=&amp;quot;-A&amp;quot;<br />call SRVGRP=GROUP1 SRVID=2<br />conn SRVGRP=GROUP2 SRVID=12 CONV=Y<br />WSL SRVGRP=GROUP1 SRVID=1116<br />CLOPT=&amp;quot;-A -- -n //XCJ:8888 -m 2 -M 5 -x 6&amp;quot;<br />*SERVICES<br />TOUPPER<br />以上的配置所需要的IPC资源可用tmboot -c计算出,结果如下,可根据计算结果调整操作系统的核心参数.<br />D:\tuxdemo\conn&amp;gt;tmboot -c -y<br />Ipc sizing (minimum /T values only) ...<br />Fixed Minimums Per Processor<br />SHMMIN: 1<br />SHMALL: 1<br />SEMMAP: SEMMNI<br />Variable Minimums Per Processor<br />SEMUME, A SHMMAX<br />SEMMNU, * *<br />Node SEMMNS SEMMSL SEMMSL SEMMNI MSGMNI MSGMAP SHMSEG<br />------ ------ ------ ------ ------ ------ ------ ------<br />XCJ 120 15 115 A + 1 25 50 180K<br />where 1 &amp;lt;= A &amp;lt;= 8.<br />The number of expected application clients per processor should<br />be added to each MSGMNI value.<br />从输出可知道:<br />SEMUME,SEMMNU,SEMMNS的值为120,<br />SEMMSL为15<br />A*SEMMSL=115,所以A=7,SEMMNI=A+1,所以SEMMNI=8<br />MSGMNI为25<br />MSGMAP为50<br />SHMMAX*SHMSEG必须等于180K<br />其他核心参数:<br />在UNIX系统中,对一个用户能拥有的系统资源(如最多能启动的进程数,打开的文件数等)是有限制的.主要有以下参数决定:<br />ULIMIT(maximum file size)<br />TUXEDO用户所能创建的最大文件,应考虑创建的SERVER文件的可能大小及ULOG的大小,一个应为ULIMIT.<br />MAXUP(maximum number of processes per user)<br />TUXEDO用户所能创建的最大进程数,应设的足够大 <br />IPC资源不够时的出错信息<br />如果ULOG中出现类似下面的错误,那么就是操作系统的核心参数值或操作系统的资源不够,应进行调整<br />Clients cannot log into BEA TUXEDO, receive error messages at tpinit:<br />no space in Bulletin Board<br />can't register; table full<br />system init function failed<br />Global transaction fails, client or server reports failure message<br />New servers or WSH cannot be started by BEA TUXEDO as needed, error in log file<br />Message queues become clogged or inaccessible<br />Write access errors, file system or disk is full <br />操作系统核心参数的调整方法<br />不同操作系统,核心参数的调整方法都不太一样,一般由系统管理员来进行调整.这里不作介绍.在UNIX系统中,只要ROOT用户才能对系统的核心参数进行调整.并且一般要重新启动系统所做的调整才能生效.在调整之前最好对原来的参数做一个备份.<br />SOLARISE系统核心参数的调整<br />SOLARISE系统的核心参数保存在文件/etc/system中,可直接对它进行编辑<br />右边为添加的说明.<br />#与共享内存有关的核心参数<br />set shmsys:shminfo_shmmax = 4967295 #Maximum shared memory segment size in bytes.<br />set shmsys:shminfo_shmmin = 1 #<br />set shmsys:shminfo_shmmni = 100 #<br />set shmsys:shminfo_shmseg = 10 # Maximum number of shared memory <br />#segments per process. The maximum amount of <br />#shared memory in bytes to wich a process can <br />#attach is SHMMAX *SHMSEG.<br />#与消息队列有关的核心参数<br />set msgsys:msginfo_msgmni = 600 #Number of unique message queue identifiers.<br />set msgsys:msginfo_msgmax = 10240 #Maximum message size in bytes.<br />set msgsys:msginfo_msgmnb = 6600000 #Maximum message queue length in bytes. <br />set msgsys:msginfo_msgmap = 1200 #(2*msgmni) Number of entries in the control <br />#map used to manage message segments. <br />set msgsys:msginfo_msgseg = 1200 #(2*msgmni) Number of message segments in the <br />#system. <br />*set msgsys:msginfo_msgtql = 400<br />#与信号灯有关的核心参数<br />set semsys:seminfo_semmns = 600 #Maximum number of semaphores in the system.<br />set semsys:seminfo_semmni = 100 =semmns #Maximum number of active semaphore sets.<br />set semsys:seminfo_semmsl = 600 =semmns #Maximum number of semaphores per <br />#semaphore set. <br />set semsys:seminfo_semmap = 600 =semmni<br />set semsys:seminfo_semume = 1 <br />set semsys:seminfo_semmnu = 600 &amp;gt;semmns<br />也可以在SOLARISE的图形化管理界面中进行配置.<br />HP系统核心参数的调整<br />1.使用系统活动监视器(SAM-System Activity Momitor)<br />(1) 运行SAM并选择&amp;quot;内核配置&amp;quot;,系统会显示以下四个单元的标识.<br />子系统<br />可配置参数<br />堆集设备<br />设备驱动程序<br />(2)选择需要修改的单元:可配置参数<br />(3)按系统的提示回答问题<br />(4)系统询问是否重新引导系统,可回答&amp;quot;是&amp;quot;,重新启动系统,使修改生效.<br />2.手工方式<br />(1) 执行下列命令进入重建内核的环境<br /># cd /stand/build<br />(2) 使用下列的命令对当前的系统配置产生一个系统文件,名为system<br />s# /usr/lbin/sysadm/system_prep -s system <br />上面的命令将所有的系统配置信息放到一个文件中,文件名不一定要为system,可<br />使用任何其他的文件名.<br />(3) 对system文件进行修改,如修改已存在的参数,增加未列出的参数等.<br />(4) 使用system文件(如果前面使用其他文件名代替system,那么这里要换为用户定义的文件名),产生conf.c文件,该文件中使用常量对应与内核的可调参数.使用下面的命令执行config程序:<br /># /usr/sbin/config -s system<br />(5) 把驱动器对象连接到基本的内核上以重建内核.<br /># make -f config.mk<br />(6) 保存旧的系统配置文件<br /># mv /stand/system /stand/system.prev<br />(7) 保存旧的内核<br /># mv /stand/vmunix /stand/vmunix.prev<br />(8) 将新的系统配置文件移到相应的目录下<br /># mv ./system /stand/system<br />(9) 将新的内核移到相应的目录下<br /># mv /vmunix_test ./stand/vmunix<br />(10) 重新引导系统并装如新的系统<br /># shutdown -r -y 60<br />AIX系统核心参数的调整<br />在AIX系统中,一般不能对与IPC资源有关的参数进行修改,它们是自适应的.但可对一个用户能打开的最多进程数等其他参数进行修改.可以用SMIT工具进行修改.<br />TUXEDO应用系统的性能优化方法<br />一,如何确定一个TUXEDO应用系统的性能瓶颈<br />一个TUXEDO应用系统的整体性能往往是由很多方面决定的,操作系统,网络,数据库,以及应用系统的设计,程序的编写水平都会影响该TUXEDO应用系统的性能.当性能不好时,主要表现在对客户段的请求响应很慢.这时,如果用tmadmin,中的pq命令察看,会发现有较多的请求在排队.这时就要进行性能调优,而调优首先要确定整个系统的性能瓶颈所在.那么如何确定呢 <br />1, 如果客户端与服务端之间在进行大批量的数据传输.可计算一下它们之间的传输速度,<br />并与FTP工具的速度相比较,来判断网络的速度是不是正常.看网络是不是性能瓶颈.<br />2, 如果客户端与服务端之间的数据传输量较少,但是服务端有大量的数据库操作.则很有<br />可能数据库是性能的瓶颈,可增加该服务的进程数来提高性能. 如果增加该服务的进<br />程数之后,没起多大的作用.而且用数据库的性能分析工具观察发现数据库的压力较大.<br />则数据库是性能的瓶颈,应对数据库的进行性能调优.根据经验,数据库往往是一个应<br />用系统的性能瓶颈.<br />3, 对UNIX操作系统,可用sar,glance(hp)等命令察看.看CPU,IO,内存的利用率是不是正常.<br />对WIND2000系统,可用任务管理器察看系统的资源使用情况.可根据观察到的结果<br />做相应的系统调优.<br />4,采用TUXEDO的性能分析工具txrpt.<br />txrpt可统计出系统内每个SERVICE的在某段特定时间内所处理的请求的总数及平均处<br />理时间,它的使用方法如下: <br />(1)在UBBCONFIG中SERVER节做如下设置:即在CLOPT中加 -r.<br />*SERVERS<br />DEFAULT:<br />CLOPT=&amp;quot;-A -r&amp;quot; <br />或clopt = &amp;quot;-A -e /log/wsl.log -r -- -n //32.22.22.22:9999&amp;quot;<br />说明:如果在DEFAULT的CLOPT中加-r参数是对所有的SERVICE调用都进行统计,<br />如果只在某个SERVER的CLOPT中加-r参数是对该SERVER中的所有的SERVICE调<br />用都进行统计.<br />重编译UBBCONFIG后,并重启动TUXEDO后,以后对SERVICE的调用统计信息会自<br />动写到标准错误输出文件中,默认为stderr.<br />(2)一段时间后,可用txrpt进行性能分析,txrpt的命令格式如下:<br />txrpt [-t] [-n names] [-d mm/dd] [-s time] [-e time]<br />参数说明:<br />-t <br />对输出进行排序,总计处理请求所花的时间越多的排的越靠前.如果不指定,按总 <br />计被调用的次数越多的排的越靠前.<br />-n names <br />只输出指定名称的SERVICE的统计信息,如果有多个,可用,隔开.<br />-d mm/dd<br />限定日期,统计指定日期的信息. 缺省为当前日期.<br />-s time<br />指定统计开始时间:格式为:hr[:min[:sec]].<br />-e time <br />指定统计结束时间:格式为:hr[:min[:sec]].<br />例子:<br />txrpt -nTOUPPER -d11/05 -s11:03 -e14:28 <stderr<br />the report produced looks like the following.<br />START AFTER: Thu Oct 05 11:01:00 2001<br />END BEFORE: Thu Oct 05 14:18:00 2001<br />SERVICE SUMMARY REPORT <br />SVCNAME 11a-12n 13p-14p 14p-15p TOTALS <br />Num/Avg Num/Avg Num/Avg Num/Avg<br />------ -------- -------- -------- -------<br />TOUPPER 2/0.25 3/0.25 1/0.96 6/0.37<br />------- ------- ------- ------- -------<br />TOTALS 2/0.25 3/0.25 1/0.96 6/0.37<br />上面的例子说明: 在11月5号的11:03到14:28这段时间内,TOUPPER被调用了6<br />次,平均每次的处理时间是0.37秒.<br />注意:txrpt只能统计一天内的信息,即由-D指定的日期.注意当用txrpt进行性能统计<br />分析时,ULOGDEBUG环境变量不要设为Y,因为它的输出信息会对txrpt造成干扰.<br />二,提高TUXEDO系统的性能的方法:<br />(1) 同一个SERVER启动多个进程,如果原来某个SERVER所启动的进程数较少,可增<br />加它的进程数,并建议使MIN=MAX,使TUXEDO不用进行进程数的动态管理.<br />如果这些SERVER可配置成MSSQ方式,则应采用MSSQ方式.如下所示:<br />&amp;quot;simpserv&amp;quot; SRVGRP=&amp;quot;GROUP4&amp;quot; SRVID=3 MIN=3 MAX=10<br />RQADDR=&amp;quot;simpserv&amp;quot; REPLYQ=Y<br />(2) 采用多服务单队列MSSQ(multiple servers signle queue)<br />在缺省情况下,TUXEDEO的每一个SERVER对应一个请求队列,该SERVER从该<br />请求队列中取客户端发来的请求,并把处理的结果通过<br />该请求队列返回给客户端,TUXEDO的SERVER可以配置成多个SERVER对应一个<br />请求队列,即MSSQ方式,以提高响应的速度.<br />在下列情况下建议采用MSSQ:<br />1,服务对实时性要求很高.<br />2,某个SERVER需要启动多个进程才能满足需要.<br />3,服务端与客户端之间传送的数据量比较小.<br />采用MSSQ应注意以下几点:<br />1, 客户端与服务端之间传送的数据量比较大,因为数据量很大,会把SERVER的请求<br />队列空间耗尽,使SERVER无法响应客户端的请求,或把处理的结果通过该请求<br />队列返回给客户端.<br />2,不要把包含的SERVICE不一样的SERVER配置成MSSQ.<br />3,很多的SERVER(比如30个)对应一个MSSQ,这时应把他们配置成几个MSSQ(如3<br />个,每个有10个SERVER)效果会更好.<br />4,不要认为MIN,MAX的值越大越好,主要取决于数据库的速度.<br />MSSQ配置的方法如下,注意如果该SERVER中的某个SERVICE调用其他的SERVICE,<br />并有返回结果,则REPLYQ=Y应加上,在下面的配置中,10个 simpserv共用一个请求队<br />列,同时其中的某个SERVICE 可能回调用其他的SERVICE,所以 REPLYQ=Y.<br />&amp;quot;simpserv&amp;quot; SRVGRP=&amp;quot;GROUP1&amp;quot; SRVID=2<br />RQADDR=&amp;quot;simpserv&amp;quot; REPLYQ=Y MIN=10 MAX=10<br />(3)系统内核参数的调整<br />TUXEDO在运行是会大量用到系统的IPC资源,包括共享内存,信号灯,消息队列.一般<br />UNIX系统缺省的值都太小,可对它们进行调整.<br />对由于非正常关闭TUXEDO系统,可能造成TUXEDO系统占用的系统IPC资源无法<br />释放,可用TUXEDO提供的工具ipclean进行回收.<br />(4)合理处理SERICE与SERVER的关系<br />如果从管理维护方面看,一个SERVICE对应一个SERVER是最简单的方式.但这会增<br />加SERVER的数量,使TUXEDO系统对系统的IPC资源要求增大(使系统的性能降低),<br />或超过(使TUXEDO系统无法启动成功).所以需要把多个SERVICE放到一个SERVER<br />中.以降低TUXEDO对系统IPC资源的需求.下面是一些把SERVICE放在一起的原<br />则:<br />1. 有互相调用的SERICE不要放到同一个SERVER中,以免引起死锁现象.<br />2. 执行时间相近的SERVICE可放到同一个SERVER中.<br />3. 同一个SERVER中的SERVICE最好有相同的服务优先级,如果不同,最低的那个<br />的请求可能要很长时间才得到处理.<br />4. 一个SERVER中不要有太多的SERVICE.<br />5. 把多资源要求相近的SERVICE放到同一个SERVER中.<br />6. 可根据业务规则把SERVICE放到同一个SERVER.<br />7. 对一些使用率较高的(如:银行的取款对应的SERVICE)应单独放在一个SERVER中,<br />并采用MSSQ方式.不要把它们与其他的SERVICE放在同一个SERVER中.<br />(5)TUXEDO可对服务设置优先级(0-100),对于比较重要的SERVEICE,可提高它的服务<br />优先级,使它较快得到响应,如下面的例子,在一个银行系统中,挂失服务<br />(LOSTCARD)的优先级比取款服务(WITHDRAWAL)高,可以使它较快得到处理.<br />*SERVICES<br />WITHDRAWAL PRIO=50 <br />LOSTCARD PRIO=80<br />(6)MAXWSCLIENTS的设置<br />MAXWSCLIENTS设置最多允许多少个远程客户端数同时连接到该TUXEDO系统<br />上,与所购买的LICNESE数有关,可设置的比所购买的LICENSE数大一些.当并<br />发连接数大于所购买的LICENSE数时,TUXEDO会报警,(在ULOG中回有信息)<br />当超过10%时,TUXEDO拒绝新的CLIENT端连入.TPINIT()会报错.<br />(7) WSL的配置,WSL进程用于监听远程客户端的连接,它的以下几个选项会影响性能.<br />-m: 最小启动WSH的进程数,缺省为0.可直接设的和-M项的值一样.<br />-M:最小启动WSH的进程数,缺省为MAXWSCLIENTS /x.<br />-x:每个WSH进程可处理的远程客户端数,缺省为10.<br />-c:当客户端与服务端之间传输的数据量(单位为:字节)大与-c指定的值时,自动进行<br />数据压缩,如果网络状况不好,该选项应加上.<br />WSL SRVGRP=GROUP1 SRVID=112<br />CLOPT=&amp;quot;-A -- -n //SERVER:8008 -m 10 -M 10 -x 10 -c 1024&amp;quot;<br />(8)对采用会话通行方式的SERVER,可多划分几个组,也能提高性能.<br />&amp;quot;simpserv&amp;quot; SRVGRP=&amp;quot;GROUP2&amp;quot; SRVID=2<br />RQADDR=&amp;quot;simpserv1&amp;quot; REPLYQ=Y MIN=10 MAX=10 CONV=Y <br />&amp;quot;simpserv&amp;quot; SRVGRP=&amp;quot;GROUP3&amp;quot; SRVID=2<br />RQADDR=&amp;quot;simpserv2&amp;quot; REPLYQ=Y MIN=10 MAX=10 CONV=Y <br />&amp;quot;simpserv&amp;quot; SRVGRP=&amp;quot;GROUP4&amp;quot; SRVID=2<br />RQADDR=&amp;quot;simpserv3&amp;quot; REPLYQ=Y MIN=10 MAX=10 CONV=Y <br />上面的配置的性能比下面的配置要好,当然组的个数也不是越多越好.<br />&amp;quot;simpserv&amp;quot; SRVGRP=&amp;quot;GROUP2&amp;quot; SRVID=2<br />RQADDR=&amp;quot;simpserv3&amp;quot; REPLYQ=Y MIN=30 MAX=30 CONV=Y <br />(9) 如果只有一个数据库,就没必要用XA,TUXEDO 与数据库之间的连接应该尽量在TUXEDO SERVER 的 tpsvrinit()中创建,在tpdone()中断开.<br />(10)选用正确的通讯方式,例如当进行大量的数据传输时,采用会话通讯方式的性能<br />就比采用同步调用方式好.<br />(11)最好把TLOG和QUEUS SPACE创建在磁盘裸设备上, <br />(11) 把QUEUE SPACE创建在内存上比创建在磁盘上的性能要好很多<br />(12) 如果一个SERVER要起很多进程,如60个,最好是分成几个组<br />findmisc SRVGRP=GROUP242 SRVID=700 MIN=10 MAX=10<br />REPLYQ=Y RQADDR=&amp;quot;findmisc1&amp;quot;<br />findmisc SRVGRP=GROUP242 SRVID=700 MIN=10 MAX=10<br />REPLYQ=Y RQADDR=&amp;quot;findmisc2&amp;quot;<br />findmisc SRVGRP=GROUP242 SRVID=700 MIN=10 MAX=10<br />REPLYQ=Y RQADDR=&amp;quot;findmisc3&amp;quot;<br />三,其他方面:<br />1, ULOG文件如果很大,也会影响性能,在一个生产系统中,应把不必要的日志信息<br />去掉,不要往ULOG文件写太多的信息.<br />2, 尽可能不在客户端要开始一个事务.因为客户端的用户可能开始一个事务,然后不往<br />下处理,白白占用数据库资源.同时与在服务端开始 一个事务相比,在客户端开始<br />一个事务还有很多其它的缺点.<br />3, 一个TUXEDO系统可以支持的最大并发连接数是由所购买的LICENSE数决定的.<br />它对系统的性能起决定性的作用.<br />4,TUXEDO的客户端通过tpinit()函数与服务端建立连接,如果客户端对服务端的调<br />用很频繁,如电信的前台收费业务,银行的存取款业务可在客户端启动上就建立一<br />个常连接,到客户端关闭时才用tpterm()断开,对一些调用很少的业务,可在真正<br />要调用服务之前才与服务端建立连接,调用结束后,马上把连接断开.如果所购买<br />的LICENSE数较少,最好所有的调用都采用第二种方式.<br />总之,系统性能的调优是个很复杂的过程,要权衡各个方面的因素,并要靠很多的经验积累.<br />]]></description> 
<guid isPermaLink="false">6570563@http://zeeslo.bokee.com/</guid> 
<dc:subject>软件测试</dc:subject> 
<dc:date>2007-12-17T22:18:44Z</dc:date> 
</item> 
<item> 
<title><![CDATA[BEA WebLogic 调优]]></title> 
<link>http://zeeslo.bokee.com/6559112.html</link> 
<description><![CDATA[<p>注：在下面做的介绍都是以Weblogic8.1为例的，其它版本的Weblogic可能会有些许不同。</p><p>&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp; 1) 设置JAVA参数；</p><p>&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp; a) 编辑Weblogic Server启动脚本文件；</p><p>l&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp; BEA_HOME\user_projects\domains\domain-name\startWebLogic.cmd(startWebLogic.sh on Unix)</p><p>l&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp; BEA_HOME\user_projects\domains\domain-name\startManagedWebLogic.cmd(startManagedWebLogic.sh on Unix)</p><p>b) 编辑set JAVA_OPTIONS命令，如：set JAVA_OPTIONS=-Xms256m –Xmx256m；</p><p>c) 保存，重启即可。</p><p>注：在WebLogic中，为了获得更好的性能，BEA公司推荐最小Java堆等于最大Java堆。</p><p>2) 开发模式 vs. 产品模式；</p><p>开发模式和产品模式的一些参数的默认值不同，可能会对性能造成影响，下面是对性能有影响的参数列表：</p><p>参数<br />&amp;nbsp;开发模式默认值<br />&amp;nbsp;产品模式默认值<br />&amp;nbsp;<br />Execute Queue: Thread Count<br />&amp;nbsp;15 threads<br />&amp;nbsp;25 threads<br />&amp;nbsp;<br />JDBC Connection Pool: MaxCapacity<br />&amp;nbsp;15 connnections<br />&amp;nbsp;25 connections<br />&amp;nbsp;</p><p>&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp; 通过启动管理控制台，在域（如：mydomain）&amp;gt; 配置 &amp;gt; 常规选择产品模式。</p><p>3) 尽量开启本地I/O；</p><p>通过启动管理控制台，在域（如：mydomain）&amp;gt; 服务器 &amp;gt; server实例（如：myserver）&amp;gt; 配置 &amp;gt; 调整选择启用本地I/O。</p><p>注：此值也可通过手动的修改config.xml配置文件。</p><p>4) 调优执行队列线程；</p><p>a) 修改默认执行线程数</p><p>在这里，执行队列的线程数表示执行队列能够同时执行的操作的数量。但此值不是设的越大越好，应该恰到好处的去设置它，太小了，执行队列中将会积累很多待处理的任务，太大了，则会消耗大量的系统资源从而影响整体的性能。在产品模式下默认为25个执行线程。</p><p>为了设置理想的执行队列的线程数，我们可以启动管理控制台，在域（如：mydomain）&amp;gt; 服务器 &amp;gt; server实例（如：myserver）&amp;gt; 监视 &amp;gt; 性能中监控最大负载时执行队列的吞吐量和队列中的等待请求数，据此确定理想的数值。</p><p>&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp; 理想的默认执行线程数是由多方面的因素决定的，比如机器CPU性能、总体体系架构、I/O、操作系统的进程调度机制、JVM的线程调度机制。随着CPU个数的增加，WebLogic可以近乎线性地提高线程数。线程数越多，花费在线程切换的时间也就越多；线程数越小，CPU可能无法得到充分的利用。为获取一个理想的线程数，需要经过反复的测试。在测试中，可以以25*CPU个数为基准进行调整。当空闲线程较少，CPU利用率较低时，可以适当增加线程数的大小（每五个递增）。对于PC Server和Windows 2000，则最好每个CPU小于50个线程，以CPU利用率为90%左右为最佳。</p><p>&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp; 通过启动管理控制台，在域（如：mydomain）&amp;gt; 服务器 &amp;gt; server实例（如：myserver）&amp;gt; Execute Queue &amp;gt; weblogic.kernel.Defalt &amp;gt; 配置中修改线程计数。</p><p>&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp; b) 设定执行队列的溢出条件；</p><p>&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp; Weblogic Server提供给默认的执行队列或用户自定义的执行队列自定义溢出条件的功能，当满足此溢出条件时，服务器改变其状态为“警告”状态，并且额外的再分配一些线程去处理在队列中的请求，而达到降低队列长度的目的。</p><p>&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp; 通过启动管理控制台，在域（如：mydomain）&amp;gt; 服务器 &amp;gt; server实例（如：myserver）&amp;gt; Execute Queue &amp;gt; weblogic.kernel.Defalt &amp;gt; 配置下面几项：</p><p>l&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp; 队列长度：此值表示执行队列中可容纳的最大请求数，默认值是65536，最后不要手动改变此值。</p><p>l&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp; 队列长度阈值百分比：此值表示溢出条件，在此服务器指出队列溢出之前可以达到的队列长度大小的百分比。</p><p>l&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp; 线程数增加：当检测到溢出条件时，将增加到执行队列中的线程数量。如果CPU和内存不是足够的高，尽量不要改变默认值“0”。因为Weblogic一旦增加后不会自动缩减，虽然最终可能确实起到了降低请求的作用，但在将来的运行中将影响程序的性能。</p><p>l&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp; 最大线程数：为了防创建过多的线程数量，可以通过设定最大的线程数进行控制。</p><p>在实际的应用场景中，应根据具体情况适当的调整以上参数。</p><p>c) 设定执行队列监测行为</p><p>Weblogic Server能够自动监测到当一个执行线程变为“阻塞”。变为“阻塞”状态的执行线程将无法完成当前的工作，也无法再执行新请求。如果执行队列中的所有执行线程都变为“阻塞”状态，Weblogic server可能改变状态为“警告”或“严重”状态。如果Weblogic server变为“严重”状态，可以通过Node Manager来自动关闭此服务器并重新启动它。具体请参考：Node Manager Capabilities文档。</p><p>通过启动管理控制台，在域（如：mydomain）&amp;gt; 服务器 &amp;gt; server实例（如：myserver）&amp;gt;配置 &amp;gt; 调整下可配置下面几项：</p><p>l&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp; 阻塞线程最长时间：在此服务器将线程诊断为阻塞线程之前，线程必须连续工作的时间长度(秒)。默认情况下，WebLogic Server 认为线程在连续工作 600 秒后成为阻塞线程。</p><p>l&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp; 阻塞线程计时器间隔：WebLogic Server 定期扫描线程以查看它们是否已经连续工作了 &amp;quot;阻塞线程最长时间&amp;quot; 字段中指定的时间长度的间隔时间(秒)。默认情况下，WebLogic Server 将此时间间隔设置为 600 秒。</p><p>5) 调优TCP连接缓存数；</p><p>WebLogic Server用Accept Backlog参数规定服务器向操作系统请求的队列大小，默认值为50。当系统重载负荷时,这个值可能过小,日志中报Connection Refused,导致有效连接请求遭到拒绝,此时可以提高Accept Backlog 25%直到连接拒绝错误消失。对于Portal类型的应用,默认值往往是不够的。Login Timeout和SSL Login Timeout参数表示普通连接和SSL连接的超时时间,如果客户连接被服务器中断或者SSL容量大,可以尝试增加该值。</p><p>通过启动管理控制台，在域（如：mydomain）&amp;gt; 服务器 &amp;gt; server实例（如：myserver）&amp;gt;配置 &amp;gt; 调整下可配置“接受预备连接”。</p><p>6) 改变Java编译器；</p><p>标准的Java编译器是javac，但编译JSP servlets速度太慢，为了提高编译速度，可以使用sj或jikes编译器取代javac编译器。下面说说更改Java编译器：</p><p>通过启动管理控制台，在域（如：mydomain）&amp;gt; 服务器 &amp;gt; server实例（如：myserver）&amp;gt;配置 &amp;gt; 常规下改变Java 编译器，默认为javac。输入完整路径，如：c:\visualcafe31\bin\sj.exe。然后打开高级选项，在预规划到类路径填写编译 Java 代码时为 Java 编译器类路径预规划的选项，如：BEA_HOME\jdk141_02\jre\lib\rt.jar。</p><p>7) 使用Webogic Server集群提高性能；</p><p>具体关于如何配置Weblogic集群，我就不细说了。详情可参考：Introduction to WebLogic Server Clustering。</p><p>8) Weblogic EJB调优</p><p>由于EJB2.0已经很少项目在用了，EJB3.0再成熟一点，我再补充这一部分吧！</p><p>9) JDBC应用调优</p><p>JDBC Connection Pool的调优受制于WebLogic Server线程数的设置和数据库进程数,游标的大小。通常我们在一个线程中使用一个连接,所以连接数并不是越多越好,为避免两边的资源消耗，建议设置连接池的最大值等于或者略小于线程数。同时为了减少新建连接的开销,将最小值和最大值设为一致。</p><p>增加Statement Cache Size对于大量使用PreparedStatement对象的应用程序很有帮助,WebLogic能够为每一个连接缓存这些对象,此值默认为10。在保证数据库游标大小足够的前提下,可以根据需要提高Statement Cache Size。比如当你设置连接数为25,Cache Size为10时,数据库可能需要打开25*10=250个游标。不幸的是,当遇到与PreparedStatement Cache有关的应用程序错误时,你需要将Cache Size设置为0。</p><p>尽管JDBC Connection Pool提供了很多高级参数,在开发模式下比较有用,但大部分在生产环境下不需调整。这里建议最好不要设置测试表, 同时Test Reserved Connections和Test Released Connections也无需勾上。 当然如果你的数据库不稳定,时断时续,你就可能需要上述的参数打开。</p><p>最后提一下驱动程序类型的选择,以Oracle为例,Oracle提供thin驱动和oci驱动,从性能上来讲,oci驱动强于thin驱动,特别是大数据量的操作。但在简单的数据库操作中,性能相差不大,随着thin驱动的不断改进,这一弱势将得到弥补。而thin驱动的移植性明显强于oci驱动。所以在通常情况下建议使用thin驱动。而最新驱动器由于WebLogic server/bin目录下的类包可能不是最新的,请以Oracle网站为准: <a href="http://www.oracle.com/technology/software/tech/java/sqlj_jdbc/htdocs/jdbc9201.html">http://www.oracle.com/technology/software/tech/java/sqlj_jdbc/htdocs/jdbc9201.html</a>。</p><p>10) JSP调优</p><p>l&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp; 设置jsp-param pageCheckSeconds=-1；</p><p>l&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp; 设置serlet-reload-check=-1或ServletReloadCheckSecs=-1；</p><p>l&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp; 设置jsp-param precompile=true，关闭JSP预编译选项。 </p><p>&amp;nbsp;</p><p />]]></description> 
<guid isPermaLink="false">6559112@http://zeeslo.bokee.com/</guid> 
<dc:subject>软件测试</dc:subject> 
<dc:date>2007-12-07T18:43:15Z</dc:date> 
</item> 
<item> 
<title><![CDATA[SGA]]></title> 
<link>http://zeeslo.bokee.com/6559099.html</link> 
<description><![CDATA[SGA （System Global Area）是Oracle Instance的 基本组成部分，在实例启动时分配。是一组包含一个Oracle实例的数据和控制信息的共享内存结构。主要是用于存储数据库信息的内存区，该信息为数据库进程所共享（PGA不能共享的）。它包含Oracle 服务器的数据和控制信息,它是在Oracle服务器所驻留的计算机的实际内存中得以分配，如果实际内存不够再往虚拟内存中写。<br /><br />SGA几个很重要的特性：<br />1、SGA的构成——数据和控制信息，我们下面会详细介绍；<br />2、SGA是共享的，即当有多个用户同时登录了这个实例，SGA中的信息可以被它们同时访问（当涉及到互斥的问题时，由latch和enquence控制）；<br />3、一个SGA只服务于一个实例，也就是说，当一台机器上有多个实例运行时，每个实例都有一个自己的SGA尽管SGA来自于OS的共享内存区，但实例之间不能相互访问对方的SGA区。<br /><br />它主要包括：<br />1.数据库高速缓存(the database buffer cache)，<br />2.重演日志缓存（the redo log buffer）<br />3.共享池（the shared pool）<br />4.数据字典缓存（the data dictionary cache）以及其它各方面的信息。<br /><br />1.数据高速缓冲区（Data Buffer Cache）<br /><br />&amp;nbsp; &amp;nbsp; 在数据高速缓冲区中存放着Oracle系统最近使用过的数据块（即用户的高速缓冲区），当把数据写入数据库时，它以数据块为单位进行读写，当数据高速缓冲区填满时，则系统自动去掉一些不常被用访问的数据。如果用户要查的数据不在数据高速缓冲区时，Oracle自动从磁盘中去读取。数据高速缓冲区包括三个类型的区：1） 脏的区（Dirty Buffers）：包含有已经改变过并需要写回数据文件的数据块。<br />2） 自由区（Free Buffers）：没有包含任何数据并可以再写入的区，Oracle可以从数据文件读数据块该区。<br />3） 保留区（Pinned Buffers）：此区包含有正在处理的或者明确保留用作将来用的区。<br /><br />2.Redo Log Buffer Cache缓存对于数据块的所有修改。<br />主要用于恢复其中的每一项修改记录都被称为redo 条目。利用Redo条目的信息可以重做修改。<br /><br />3. Shared Pool用于缓存最近被执行的SQL语句和最近被使用的数据定义。<br />它主要由两个内存结构构成：Library cache和Data dictionary cache<br />修改共享池的大小：ALTER SYSTEM SET SHARED_POOL_SIZE = 64M; <br />&amp;nbsp; &amp;nbsp;<br />&amp;nbsp; &amp;nbsp;Libray Cache缓存最近被执行的SQL和PL/SQL的相关信息。实现常用语句的共享，使用LRU算法进行管理，由以下两个结构构成：Shared SQL area、Shared PL/SQL area、Data Dictionary Cache、Data dictionary cache缓存最近被使用的数据库定义。它包括关于数据库文件、表、索引、列、用户、权限以及其它数据库对象的信息。在语法分析阶段，Server Process访问数据字典中的信息以解析对象名和对存取操作进行验证。数据字典信息缓存在内存中有助于缩短响应时间。<br /><br />4.数据字典缓存（the data dictionary cache）<br />它包括的信息有：数据库文件，表，索引，列，用户，权限和其他数据对象，在解析间段，服务器进程查看数据字典来决定对象名称和有效的访问的信息，缓存数据字典信息来提高请求反应时间，大小是由共享池的大小来决定的。<br /><br />]]></description> 
<guid isPermaLink="false">6559099@http://zeeslo.bokee.com/</guid> 
<dc:subject>其他资料</dc:subject> 
<dc:date>2007-12-07T18:23:02Z</dc:date> 
</item> 

</channel> 
</rss> 
