qileilove

blog已经转移至github,大家请访问 http://qaseven.github.io/

数据库中模式的意义

概念
　　模式，也称为逻辑模式，是数据库中全体数据的逻辑特征和特征描述，是所有用户的公用数据视图。一个数据库只有一个模式，而外模式不是唯一也不可能是唯一的，模式是数据库逻辑上的视图。数据库模式以某一种数据模型为基础。定义模式时不仅要定义数据的逻辑结构，而且要定义与数据有关的安全性、完整性要求，定义这些数据之间的联系。
　　分类
　　外模式
　　外模式又称子模式或用户模式，属于用户级别。它是某个或某几个用户所看到的数据视图，类似于命名空间，是与某一应用有关的数据的逻辑模式。外模式反应了数据库的用户观。
　　概念模式
　　概念模式又称逻辑模式，属于概念级。它是由数据库设计者综合所有用户的数据，按照统一的观点构造的全局逻辑结构，是对数据库中全部数据的逻辑结构和特征的总体描述，是所有用户的公共数据视图。反应了数据库的整体观。
　　内模式
　　又称存储模式，对应于物理级。它是数据库中全体数据的内部表示或底层描述，是数据库最低一级的逻辑描述，它描述了数据在存储介质上的存储方式和物理结构。反应了数据库的存储观。

posted @ 2014-02-25 10:36 顺其自然EVO 阅读(214) | 评论 (0) | 编辑 收藏

TDD的iOS开发初步以及Kiwi使用入门

     摘要: Kiwi　　测试驱动开发(Test Driven Development，以下简称TDD)是保证代码质量的不二法则，也是先进程序开发的共识。Apple一直致力于在iOS开发中集成更加方便和可用的测试，在Xcode 5中，新的IDE和SDK引入了XCTest来替代原来的SenTestingKit，并且取消了新建工程时的“包括单元测试”的可选项（同样待遇的还有使用AR...  阅读全文

posted @ 2014-02-25 10:34 顺其自然EVO 阅读(637) | 评论 (0) | 编辑 收藏

Facebook 的移动端 A/B 测试框架

　两年前，我们重写了我们移动端（iOS，Android）的应用，使用了原生的开发栈（native development stacks）代替我们以前定制开发的 Web 栈(custom web-stack)。这给了我们在关于项目在那里/怎样下载、缓存、释放等等方面一个更好的控制。它分别深入地和操作系统整合在一起，提供在底层调整修改所有系统的一整套工具。
　　测试是我们开发的一个重要部分，但在转换到原生的之后，我们没有了 A/B 测试的能力。并不是每个测试都可以用到生产中，但即使是失败的测试也能帮助我们理解如何才能更好地改进。失去的这部分能力变成了一个我们要应对的挑战。
　　A/B 测试
　　要把我们的应用移植到 iOS 和 Android 上，需要来自不同团队的人来进行协作，每四周就要产生一个新的修复一些 bug 和带有一些新特性的二进制软件包。在我们发布一些更新之后，对于我们很重要的事情是要去明白：
　　● 新特性的使用情况
　　● bug 修复后的运行情况和稳定性
　　● 用户界面改进之后用户是怎么使用这个应用及在哪里花的时间多
　　为了去了解这些事情，我们需要一个移动端进行 A/B 测试的基础组件，这个组件能让我们的用户分别使用不同版本的应用（版本 A 和版本 B），这些版本在除某些特别需要测试的部分外，其他各层面都是一样的。所以我们创造了 Airlock，一个可以让我们比较不同版本应用的度量数据（metric data）和进行各种各样测试的测试框架，这帮助我们决定采用那个版本或者后续如何迭代。
　　从一点一滴中建成
　　我们尽可能从最简单的试验开始：使用已有的 Web-Stack A/B 分箱（binning system）系统。我们构造了一个测试：把聊天按钮换成文字"Chat"的试验。当应用启动的的时候，它会发送一个到我们服务器上的网络请求，询问这个试验的参数。当有回应返回后，我们就会更新按钮。一些员工会有按钮，另一些员工会有文字"Chat"。我们期望这仅仅会影响信息发送的数量（看起来不会太多），其他的东西不会受影响。
　　曝光日志
　　当这个版本的应用公开发布了，我们等待数据能稳定下来，然后发现看到文字"Chat" 的版本会更热衷于使用这个应用。是不是我们发现了什么秘密，或者诱惑般的魔法？沮丧地说，并不是。我们遇到了很多 bug，其中一个很大的问题是，某个组件并不能正确地缓冲数值。由于这是个大的系统，基础设施（the infrastructure）必须要是 "防弹的"，不然收集到的数据就没用了。
　　从服务器开始的数据管道决定某个人的版本是属于那种变体的。然后，数据就会被打包，接着发送到设备上，设备分析返回的信息然后保存。接着，这个值会被用于重新配置 UI，然后最终在屏幕上显示。问题是我们在依靠服务器对我们数据分析的分类。一个简单的 bug 就导致了一大群用户在使用有别于我们期望的的变种版本。服务器还在坚持："我告诉了设备去显示字符串！" 但在某处地方这个语句变得有点令人模糊（一个在客户端存贮逻辑上的 bug）。
　　一个试验的部署图：
　　上面图表展示了一个试验的部署。浅绿色的条柱是试验用户的数量，黑绿色的条柱是实际被影响的用户数。我们可以看到，服务器和设备的数据区别还是很大的: 在第一天，大多数用户收到这个配置，但大多数用户没有留意到我们试验。
　　当问题不仅仅是设备收到返回的数据，而需要加上我们的数据分析需要知道什么时候收到信息，然后把它正确地显示在 UI 上时，问题变得更大了。即使信息能正确地到达，在 UI 不正确时也有一个延迟。我们通过
　　添加双向握手（wo-way handshake）解决了这个问题。设备请求用于试验的数据，服务器记录它发出的回应。因此，即使某用户没有看到我们想让他看到的，我们仍然可以进行正确性分析（但也必须意识到选择性偏差（selection bias）的问题，还有分发时由于某些原因变得不平均）。
　　可伸缩性
　　在进行了几个月这样的"课程"之后，我们必须将支持两个试验的系统升级支持整个应用的系统。这个促使 Airlock 发生变革的试验是以前我们原想着进化和简化我们应用内的导航模块而开发的。在经历这几个月之后，我们把这个应用改变了很多，你可以去下载 Facebook for iPhone 来体验一下，这里面很多是测试的功劳。
　　随后，Airlock 被用于支持更多的试验，其请求的参数，数据的记录、客户端计算等等都快速地变多。Airlock 充分地被用于测试原生的应用，使得我们的应用运行得前所未有的轻快，伴随着测试的自由，再测试，和评估测试结果，我们期望能建造更好的测试和创造更好的用户体验。

posted @ 2014-02-25 10:32 顺其自然EVO 阅读(217) | 评论 (0) | 编辑 收藏

jmeter 目录介绍




















posted @ 2014-02-24 11:01 顺其自然EVO 阅读(513) | 评论 (0) | 编辑 收藏

QA 应该更新的测试工具

　2013，一个即忙碌又精彩的一年。虽然它已经过去，但是总想写点什么总结一下。作为一名QA，过去一年是我的软件质量知识体系和自动化测试知识体系收获最丰的一年，让我对于软件质量和自动化测试有了一个更高层次的认识。所以我写下了一些自己更新了的知识，以及在和其他公司的QA交谈之后发现的一些他们应该更新的知识。借此希望能对各位看官起到一些提示或者补充作用，当然我也希望各位与我进行联系，并共同探讨未来的QA到底应该具有什么样的能力和知识体系。
　　Web应用程序视觉感知测试
　　视觉感知测试，对于很多QA，包括我在2013以前对于它的认知都是手动测试领域的一个成员。在这个Web系统爆炸的年代，Web UI界面布局测试，多浏览器测试，CSS的refactor等都成为了Web UI测试的痛中之痛，特别是大型Web应用的功能回归测试量太大，从而导致很多时候根本无法完成，所以很少会有团队去做全方位的UI界面布局回归测试，特别是对于使用Agile流程开发的团队就更加困难。
　　为了缓解这样的困境，不断地有人思考怎么自动化UI测试，我以前的公司就有人尝试在手机上做自动UI测试，但是最后也没有什么成效。最几年，Web应用程序发展得如火如荼，所以在去年，就有两个工程师，一个来自于Google，一个来自于ThoughtWorks就在尝试解决Web应用程序测试上的这个问题。不过他们的思路和以前不一样，不是想做一个全自动的UI测试框架，而是基于Agile的持续集成和持续部署的概念上，使用半自动的方法来减少UI回归测试的时间，从而减少WEB应用程序UI回归测试的时间。
　　来自Google的工具是Dpxdt,而来自ThoughtWorks的是Viff. 这两个工具的基本原理都是类似的，只是使用了不同的语言开发，以及适用的范围有点区别。
　　Dpxdt是基于Python和PhantomJS开发的一个Web Service系统，其中PhantomJS可以理解为一个没有UI的浏览器。用户使用其提供的RESTFul API可以十分方便的对比两个页面，而且它还提供一个功能十分强大的报表系统。 对于全部是静态页面的Web系统来说非常适用，不过对于需要手动导航，比如需要进行输入，点击等之后才能进行比较的页面，它现在的版本并不适合。它还提供了一个方式可以把他很方便的部署到GWS上，所以对于国内在GFW下的用户可以暂时不用考虑这个功能。
　　Viff是基于NodeJS和Selenium开发的一个本地工具。通过编写JavaScript代码来调用Selenium API, 并在真实的浏览器中进行截图比较。所以它比较适合动态的Web系统，因为可以编写代码模拟用户输入和点击操作。由于它底层使用的是Selenium作为驱动，所以他支持多种浏览器，比如IE，Chrome，Firefox等。在最新的Selenium中加入了对Android和iOS的支持，不过现在还不是很稳定，所以Viff还支持Android和iOS上的浏览器测试。如果对你来说搭建多浏览器环境比较困难，比如需要同时测试IE8，IE9，IE10等，可以选择BrowserStack。
　　BrowserStack是一个商业产品，他同时通过Web界面和API接口提供多浏览器环境给客户进行Web测试，Viff可以使用期API进行进行多浏览器截图。对于Viff，由于编写JavaScript代码也需要一定的门槛，所以对于没有代码能力的使用者在测试静态网页的时候应该选择Dpxdt，但是如果你有一定的代码能力，建议选用Viff。现在Viff正在开发Web Service功能，这样以后就可以作为一个Service进行部署和使用。
　　不过现在这两个工具都还不是很成熟，还存在一些Bug，其中Viff还在继续开发新的功能中，不过基本使用还是可以的。如果在使用这两个工具的过程中发现任何Bug，请通过Github的Issues跟踪功能来及时反馈给作者，帮助这两个开源系统越来越好。我在BQConf上有一个Perceptual Testing的演讲,有兴趣的可以听一听。
　　下图为实施了视觉感知测试之后对于Web系统回归测试的时间示意图：

　移动测试
　　最近几年由于iOS和Android设备越来越普及，移动应用的出现了井喷，大部分都是个人开发者或者小型公司开发的个人应用或者手游。而且随着iOS和Android的设备和SDK的初步成熟，大量的大型商业公司已经或者准备开发移动应用。对于商业移动应用，稳定性非常重要。对于稳定性，测试就非常重要。由于智能系统越来越复杂和成熟，其上面的应用程序的功能也越来越多，所以自动化测试也就越来越重要。自动iOS在2007年和Android在2008年发布以来，基于这两个系统的自动化测试工具就初步发展起来。一般情况下最好使用和应用程序开发使用的语言来写功能测试，但是由于商业应用的业务需求越来越复杂，所以我倾向于使用基于BDD和SBE的测试工具来做业务测试。比如Calabash就是一个十分好用的基于Cucumber[2]的BDD移动测试工具，它同时支持Android和iOS。其Android的实现是基于robotium，而iOS的实现是基于Frank和UISpec。使用Calabash，测试人员可以使用自然语言来编写的cucumber测试脚本，然后通过在PC上运行cucumber脚本来测试iOS和Android设备上的应用程序。如果你的公司拥有大量的手动测试人员，并且希望进行移动自动化测试，ThoughtWorks针对这样的公司开发了一套全新的移动自动化测试工具：Lever，他和Calabash一样，同时支持Android和iOS。测试人员只需要通过打开一个网页，通过选择移动应用界面上的特定组件和对其的操作来进行组成自动化测试步骤，多个测试步骤可以形成一个测试场景，最终完成各种自动化测试案例并运行。由于Lever不是开源产品，也没有公开的详细资料，所以如果你想了解其详细功能和内容，可以BQConf上的Lever的专题演讲。
　　Web服务器性能测试
　　敏捷开发在当今软件行业里面扮演着越来越重要的角色，软件测试也随着逐步敏捷起来。由于软件系统，特别是服务器系统越来越复杂，规模也越来越大。开发人数也达到几十，甚至几百人，而且大规模使用第三方的软件库，比如Spring，Rails，Hibernate，.Net等。如果使用不当，将会引起很严重的性能问题甚至是稳定性问题，所以性能问题在当前的软件开发中已经越来越明显了。常规的持续集成验证了构建是否满足了功能设计要求，而持续性能测试增加了另外一重验证标准，程序是否满足了性能要求，从而是性能问题尽早被发现。持续性能测试主要的优点就是可以在代码改变以后可以快速的知道性能变化，比如如果发现性能问题，可以让提交这个Commit程序员去修复这个问题，因为他还能记住这个Commit。如果等到最后发布之前才发现，那么这个程序员可能已经不记得这个Commit，或者已经离开了公司，有可能导致修复这个问题的难度大大增加。如果这个是一个设计上的错误，那么团队就可以尽早修复它并避免以后的功能受其影响。
　　比如铁道部的12306购票系统上线后的第一个春节就遇到了严重的性能问题，面对预料中的高访问量，系统在春运期间经常长时间无法访问，导致大量用户无法购票。像这样严重的性能问题是在开发的时候是可以预见的，不过还是出现在产品环境上，由此可见系统在构架上没有对性能进行有效的设计，在测试上没有进行有效的性能测试（由于12306产生这个性能问题的原因很复杂，我们这里不做过多讨论，比如各种组织和利益等原因，也不讨论怎么解决。）。当这个性能问题出现的时候，根本无法在短时间内修复，导致了如此严重的性能问题维持了很长一段时间。在第二年的春运里面，系统才增加了排队系统，有效的缓解了性能问题，不过还是会时不时出现无法访问的情况。由于12306是中国唯一的网上火车票购票系统，就算出现这样严重的性能问题，人们还是只有继续使用它。但是如果有多个购票网站，一旦某个出现了性能问题而导致客户长时间无法访问，那么就会带来大量的客户流失，造成巨大的损失。因此性能测试对拥有大量用户软件系统十分重要，而且需要越早发现性能问题，越早修复越好，因为等到发布前，就算测试出性能问题，也有可能因为构架问题而无法修复。
　　让性能测试成为敏捷开发的一等公民对于更好的进行敏捷开发和高质量的持续部署越来越重要。持续性能测试不应该只是说说，特别是对于大型服务器项目和开发人员众多的情况下，持续性能测试将成为必不可少的组成部分。持续性能测试应该被看做持续交付的重要步骤，应该和回归测试一样，可以做到更频繁的高性能持续交付。在2013年5月发布的ThoughtWorks技术雷达中，让性能测试成为敏捷开发一等公民已经被列入了ADOPT。对于当今的软件系统，特别是对于大型服务器系统，并且它又拥有大量用户的情况下，持续性能测试将成为一个必不可少的组成部分。让我们一起去实践持续性能测试，比如新一代的性能测试工具Gatling 就是一个很好的试验田，通过它，我们可以很好的实践对于服务器系统的持续性能测试。
　　Web自动化功能测试
　　在过去几年，由于Web2.0的出现导致了Web的第二春的到来，并且我知道的公司和客户们都非常重视Web自动化测试，并且使用率也很高。但是我发现很多测试人员还在使用Selenium IDE或QTP等。对于Selenium，我认识的一般的测试人员只会使用Selenium IDE进行测试录制，然后使用“重播”进行测试。对于通过Selenium IDE录制的脚本是非常难以维护的，导致测试步骤的更改之后一般只能重新录制。对于开发中的项目的其Cost非常高，所以在实际中使用的效果很不好。
　　对于当前广泛使用的Agile的开发模型，Selenium IDE的方法基本不可用，所以需要更新到Selenium WebDriver（Selenium 2.0）。Selenium WebDriver提供了一套支持各种语言的WebDriver API，比如Java，Ruby, Python等。通过这套API用户可以启动各种不同的浏览器，比如IE，Chrome，Firefox等，并且通过API可以让浏览器访问不同的网页，模拟点击和输入等，获取网页中的内容等。使用WebDriver API比老的Selenium IDE带来了更多的好处，更为适合Agile开发，测试流程更为灵活，维护更为方便，测试流程更为清晰易读，断言也更为多样化等。但是对于测试人员也有一个麻烦，就是至少需要学习一门语言来开发测试案例。驱动Selenium WebDriver的测试可以使用xUnit或者各种BDD框架。
　　如果你们使用的是Ruby On Rails开发的Web系统，或者你想尝试一种新的快速的开发方式，你还有一个选择就是Watir。Watir是一个使用Ruby开发的测试API，和WebDriver API类似，而且它自带和Rails集成的组件，所以对于Rails的Web系统它有天生的优势。
　　由于Web Service的流行以及用户UI的需求越来越复杂，Web开发已经由MVC的模型发展到MVP和MVVM模型。由此一来前端的逻辑复杂程度和代码量（如Javascript等）就会大大增加，由此带来的问题就是测试量也会大大增加。对于如此大量的Javascript代码逻辑层的测试，并不适合使用做UI层功能测试的Selenium。所以我们应该在Javascript层做自动化测试。基于Javascript的自动测试框架很多，由于我倾向于Agile和BDD，所以我倾向于Jasmine，Mocha和Karma。其中Jasmine是一个支持BDD的自动化测试框架，而Macha是新的基于NodeJS开发的支持BDD的自动化测试框架。而Karma是一个自动化测试运行环境，它也是基于NodeJS开发的，Jasmine和Macha都可以在其上面运行。Karma支持多种browser，比如Firefox，Chrome， IE等，而且它使用也比较简单。
　Windows 应用程序测试
　　虽然Web从上个世纪90年代开始崛起，到现在的空前盛世，但是任然有很多公司仍在开发和维护Windows应用程序。并且Windows应用程序的开发也从C++和MFC时代进入了.Net 和Silverlight时代。但是Windows应用程序的测试一直都是一个不大不小的问题，虽然有很多商用且成熟的自动测试系统，比如Test Complete和QTP等，不过大部分是基于录制或者Action模型来创建测试，更没有提供现代流行的脚本支持，比如QTP使用的是VBScript，更不用说BDD的支持。在Agile的时代，测试工具API化才是一个正确的选择，如果能支持DSL那就更好了。使用API后，可以获得良好的可维护性，并且可以更为容易实现CI和CD。幸好有一帮志士开发了一套针对Windows应用程序的免费自动化测试框架White，以及.Net的BDD框架SpecFlow。White封装了Microsoft's UIAutomation Library，并提供了一套简单易用的API。它支持Win32, WinForms, WPF, Silverlight and SWT (Java) platforms的应用程序，并且通过MicroSoft Windows SDK里面的Inspect工具可以非常容易的找到应用程序中UI控件的ID来进行自动化测试。
　　Web安全
　　安全，一个即神秘又兴奋还忧心的话题。其中安全世界里面的东西太多太多了，比如服务器安全，移动安全，网络安全，杀毒软件，入侵检测等等，不过今天我只想说说Web的安全。Web，在前面我已经用了各种的词汇来描述它的现状。正是由于它当前这种现状，我们不得不特别关注它。所以有一批黑客发起了一个关注Web安全的公益性项目OWASP(Open Web Application Security Project)。在这个项目里面，有各种关于Web安全的资料，比如文档有《OWASP安全编码规范快速参考指南》，《OWASP测试指南》 和 《OWASP安全风险Top 10 》2013年版等, 以及各种安全测试和培训工具，比如ZAP和WebGoat等。其中ZAP是一款简单易用并且免费的Web安全扫描工具，使用在针对网站渗透测试过程中的检测网站步骤中，并且很容易的和maven以及CI进行集成。由于它是由java开发的，所以也支持多种操作系统，比如Windows和MacOS等。而WebGoat是一个漏洞百出的J2EE Web应用程序，这些漏洞是故意设计用来演示Web应用程序安全课程的。这个应用程序提供了一个让用户可以真实去实践和学习的平台，让用户可以真实看到漏洞以及尝试去修复这个漏洞。
　　除了上面介绍的免费工具和练习平台以外其实还有很多其他的免费和商业版本的工具和平台，比如w3af,Burp,metasploit,Google’s Gruyere等。我暂时还没有用过这些，有兴趣的同学可以自己去学习研究。最后如果大家想学习和使用这些工具，并练习Web的安全问题，比如OWASP Top 10，可以使用Maven公司的Web Security Dojo就可以非常方便的进行。
　　总结
　　对于测试人员，需要了解各种测试方法，测试策略和测试工具，随着软件行业的迅速发展也需要更新它们，比如视觉感知测试, 移动测试，性能测试等等。但是随着Agile越来越普及，持续集成和持续部署的广泛使用，以及BDD的兴起，学习脚本将会成为测试人员的一门必修课。不要再犹豫了，更新自己吧，要知道不进则退哦。

posted @ 2014-02-24 10:39 顺其自然EVO 阅读(495) | 评论 (0) | 编辑 收藏

关于配置测试的探讨

　1. 常规测试流程
　　2. 存在问题
　　既然不知道最佳配置（Tomcat实例数），怎么保证配置测试之前的测试是可靠的？你给线上推荐用4实例,但是出具的测试报告却是基于2实例的,如何保证准确性呢?
　　3. 新流程
　　4. 配置测试做法

　5.例子
　　(1) 1 tomcat实例
　　(2) 2 tomcat实例
　　(3) 3 tomcat实例

posted @ 2014-02-24 10:33 顺其自然EVO 阅读(154) | 评论 (0) | 编辑 收藏

mongodb的java测试用例

mongodb java驱动包下载：https://github.com/mongodb/mongo-java-driver/downloads
　　本测试用例包括：查询数据库、查询聚类集合、查询数据、添加数据、添加多条数据、删除数据、修改数据操作，更多操作请使用者以此类推。
　　完整工程下载地址：http://download.csdn.net/detail/linyu19872008/6913607
　　工程目录结构如图：
　　mongodb数据库管理类：
import com.mongodb.Mongo;
/**
* mongodb管理器
*
* @author jacklin
*
*/
public class MongodbManager {
private static Mongo mg = null;
/**
* 获取mongodb
*
* @return
*/
public synchronized static Mongo getMongo() {
if (mg == null) {
try {
mg = new Mongo("localhost", 27017);
} catch (Exception e) {
e.printStackTrace();
}
}
return mg;
}
}
　　mongodb测试用例：
import java.util.ArrayList;
import java.util.List;
import com.mongodb.BasicDBObject;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;
import com.mongodb.Mongo;
import com.mongodb.util.JSON;
import com.sun.mongodb.manager.MongodbManager;
/**
* mongodb测试用例
*
* @author jacklin
*
*/
public class Testcase {
public static void main(String[] args) {
// // 查询所有的Database
// showDatabase();
// // 查询所有的聚集集合
// showCollections();
// // 查询数据
// find();
// // 添加数据
// add();
// // 添加多条数据
// addList();
// // 删除数据
// remove();
// // 修改数据
// modify();
}
/**
* 修改数据
*/
public static void modify() {
Mongo mg = MongodbManager.getMongo();
DB db = mg.getDB("test");
DBCollection users = db.getCollection("user");
DBObject userOld = new BasicDBObject();
userOld.put("name", "jack");
userOld.put("age", 24);
DBObject userNew = new BasicDBObject();
userNew.put("name", "jacky");
userNew.put("age", 26);
System.out.println(users.update(userOld, userNew));
}
/**
* 删除数据
*/
public static void remove() {
Mongo mg = MongodbManager.getMongo();
DB db = mg.getDB("test");
DBCollection users = db.getCollection("user");
DBObject user = new BasicDBObject();
user.put("name", "hoojo");
System.out.println(users.remove(user));
}
/**
* 添加多条数据
*/
public static void addList() {
Mongo mg = MongodbManager.getMongo();
DB db = mg.getDB("test");
DBCollection users = db.getCollection("user");
List<DBObject> list = new ArrayList<DBObject>();
DBObject user1 = new BasicDBObject("name", "lucy");
user1.put("age", 21);
DBObject user2 = new BasicDBObject("name", "lily");
user2.put("age", 22);
list.add(user1);
list.add(user2);
// 添加List集合
System.out.println(users.insert(list).getN());
}
/**
* 添加单条数据
*/
public static void add() {
Mongo mg = MongodbManager.getMongo();
DB db = mg.getDB("test");
DBCollection users = db.getCollection("user");
DBObject user = new BasicDBObject();
user.put("name", "jack");
user.put("age", 24);
System.out.println(users.save(user).getN());
}
/**
* 查询数据
*/
public static void find() {
Mongo mg = MongodbManager.getMongo();
DB db = mg.getDB("test");
DBCollection users = db.getCollection("user");
// 查询所有的数据
DBCursor cur = users.find();
while (cur.hasNext()) {
System.out.println("data:" + cur.next());
}
System.out.println("count:" + cur.count());
System.out.println("cursorId:" + cur.getCursorId());
System.out.println("json:" + JSON.serialize(cur));
}
/**
* 查询所有的聚集集合
*/
public static void showCollections() {
Mongo mg = MongodbManager.getMongo();
DB db = mg.getDB("test");
for (String name : db.getCollectionNames()) {
System.out.println("collectionName: " + name);
}
}
/**
* 查询所有的Database
*/
public static void showDatabase() {
Mongo mg = MongodbManager.getMongo();
for (String name : mg.getDatabaseNames()) {
System.out.println("dbName: " + name);
}
}
}

posted @ 2014-02-24 10:32 顺其自然EVO 阅读(366) | 评论 (0) | 编辑 收藏

Zookeeper读写性能测试

关于Zookeeper，之前有过几篇文章已经介绍过了，因此本文不赘述。 本次小编对单机部署的Zookeeper的读、写进行了一次简单性能测试。 性能测试脚本由java完成，具体请看代码清单：
package com.kiven.test;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import org.apache.log4j.PropertyConfigurator;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.Watcher.Event.KeeperState;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.ZooKeeper;
public class Test{
/**
* server列表, 以逗号分割
*/
protected static String hosts = "172.16.217.148:2181";
/**
* 连接的超时时间, 毫秒
*/
private final int SESSION_TIMEOUT = 5000;
private CountDownLatch connectedSignal = new CountDownLatch(1);
protected static ZooKeeper zk;
private static String nodePath = "/Test/test1";
//static String data = "a very long string about data to set to zookeeper";
static int threads = 10;    //线程数
static int runs = 1000;     //迭代次数
static int start = 0;       //none
static int size = 1024*4;   //写入数据的大小,单位：字节
static byte[] testdata;     //测试数据
public static void main(String[] args) throws Exception {
PropertyConfigurator.configure("log4j.properties");
//生成写入的数据，大小size字节
testdata = new byte[size];
for(int i=0;i&lt;size;i++){
testdata[i] = 'A';
}
Test test = new Test();
//连接
test.connect();
WorkerStat[] statArray = new WorkerStat[threads];
Thread[] threadArray = new Thread[threads];
WorkerStat mainStat = new WorkerStat();
mainStat.runs = runs * threads;
long begin = System.currentTimeMillis();
for (int i = 0; i &lt; threads; i++) {
statArray[i] = new WorkerStat();
statArray[i].start = start + i * runs;
statArray[i].runs = runs;
threadArray[i] = new SetterThread(statArray[i]);
threadArray[i].start();
}
for (int i = 0; i &lt; threads; i++) {
threadArray[i].join();
}
mainStat.setterTime = System.currentTimeMillis() - begin;
begin = System.currentTimeMillis();
for (int i = 0; i &lt; threads; i++) {
threadArray[i] = new GetterThread(statArray[i]);
threadArray[i].start();
}
for (int i = 0; i &lt; threads; i++) {
threadArray[i].join();
}
mainStat.getterTime = System.currentTimeMillis() - begin;
WorkerStat totalStat = new WorkerStat();
System.out.println("Test over!!");
System.out.println("Thread("+threads+")\truns\tset time(ms)\tget time(ms)");
for (int i = 0; i &lt; threads; i++) {
totalStat.runs = totalStat.runs + statArray[i].runs;
totalStat.setterTime = totalStat.setterTime + statArray[i].setterTime;
totalStat.getterTime = totalStat.getterTime + statArray[i].getterTime;
}
System.out.println("Total\t\t" + totalStat.runs + "\t"+ totalStat.setterTime + "\t\t" + totalStat.getterTime);
System.out.println("Avg\t\t" + runs + "\t" + totalStat.setterTime/ threads + "\t\t" + totalStat.getterTime / threads);
System.out.println("TPS\t\t\t" + 1000 * totalStat.runs/ totalStat.setterTime + "\t\t" + 1000 * totalStat.runs/ totalStat.getterTime);
System.out.println("\nMain\t\t" + mainStat.runs + "\t"+ mainStat.setterTime + "\t\t" + mainStat.getterTime);
System.out.println("TPS\t\t" + 1000 * mainStat.runs/ mainStat.setterTime + "\t\t" + 1000 * mainStat.runs/ mainStat.getterTime);
}
private static class WorkerStat {
public int start, runs;
public long setterTime, getterTime;
public WorkerStat() {
start = runs = 0;
setterTime = getterTime = 0;
}
}
private static class SetterThread extends Thread {
private WorkerStat stat;
SetterThread(WorkerStat stat) {
this.stat = stat;
}
public void run() {
long begin = System.currentTimeMillis();
for (int i = stat.start; i &lt; stat.start + stat.runs; i++) {
//写入节点数据
try {
zk.setData(nodePath, testdata, -1);
} catch (Exception e) {
e.printStackTrace();
}
}
long end = System.currentTimeMillis();
stat.setterTime = end - begin;
}
}
private static class GetterThread extends Thread {
private WorkerStat stat;
GetterThread(WorkerStat stat) {
this.stat = stat;
}
public void run() {
long begin = System.currentTimeMillis();
for (int i = stat.start; i &lt; stat.start + stat.runs; i++) {
//读取节点数据
try {
zk.getData(nodePath, false, null);
} catch (Exception e) {
e.printStackTrace();
}
}
long end = System.currentTimeMillis();
stat.getterTime = end - begin;
}
}
//===============================================================================
/**
* 连接zookeeper server
*/
public void connect() throws Exception {
zk = new ZooKeeper(hosts, SESSION_TIMEOUT, new ConnWatcher());
// 等待连接完成
connectedSignal.await();
}
/**
*
* @author Kiven
*
*/
public class ConnWatcher implements Watcher{
public void process(WatchedEvent event) {
// 连接建立, 回调process接口时, 其event.getState()为KeeperState.SyncConnected
if (event.getState() == KeeperState.SyncConnected) {
// 放开闸门, wait在connect方法上的线程将被唤醒
connectedSignal.countDown();
}
}
}
/**
以下为各个参数的详细说明:
path. znode的路径.
data. 与znode关联的数据.
acl. 指定权限信息, 如果不想指定权限, 可以传入Ids.OPEN_ACL_UNSAFE.
指定znode类型. CreateMode是一个枚举类, 从中选择一个成员传入即可.
*/
/**
* 创建持久化节点
*/
public void create(String Path, byte[] data) throws Exception {
zk.create(Path, data, Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
System.out.println("创建节点:"+Path);
System.out.println("=================");
}
/**
*
*获取节点信息
*@author kiven
*@createDate 2013-01-16 15:17:22
*@param path
*@throws KeeperException
*@throws InterruptedException
*/
public void getChild(String path) throws KeeperException, InterruptedException{
try{
List list=zk.getChildren(path, false);
if(list.isEmpty()){
System.out.println(path+"中没有节点");
}else{
System.out.println(path+"中存在节点");
for(String child:list){
System.out.println("节点为："+child);
}
}
}catch (KeeperException.NoNodeException e) {
e.printStackTrace();
}
}
/**
* 设置节点数据
* @throws Exception
*/
public void setData(String path,String data) throws Exception{
zk.setData(path, data.getBytes(), -1);
System.out.println("set Data:"+"testSetData");
}
/**
* 读取节点数据
* @throws Exception
*/
public void getData() throws Exception{
System.out.println("get Data:");
zk.getData(nodePath, false, null);
}
/**
* 删除节点
* @param path
* @throws Exception
*/
public void delete(String path) throws Exception{
System.out.println("删除节点:"+path);
//如果版本号与znode的版本号不一致，将无法删除，是一种乐观加锁机制；如果将版本号设置为-1，不会去检测版本，直接删除；
zk.delete(path, -1);
}
/**
* 关闭连接
*/
public void close() {
try {
zk.close();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
　　相关功能代码中都已经注释清楚。我们看一下测试下来的结果： 写入数据： 
　　读取数据：
　　由上两张图我们可以得知：
　　1、写入（set）数据时，单个线程执行是最快的，而读取（get）数据则是4或5个线程并发是最快的。
　　2、每个节点存储的数据不能超过1M（在Zookeeper默认配置的情况下，如果写入的数据为1M会报错，无法写入数据，所以所有应用写入的数据必须<1M）
　　3、单个写入数据的体积越大，处理速度越慢，响应时间越长。
　　4、会管应用中写入的数据最大的是16方画面合成的时候，此时写入的数据可能大于4K，另外16方画面合成时候zk节点存放的数据（json）是包含大量空格和换行的（在zk节点中，空格和换行也是占大小的），因此建议压缩json数据。
　　5、测试过程中产生的log文件对磁盘的消耗和占用较大，建议定时删除历史log和shapshot

posted @ 2014-02-21 11:14 顺其自然EVO 阅读(3282) | 评论 (0) | 编辑 收藏

　1.在AndroidManifest清单文件中进行配置

　1.在AndroidManifest清单文件中进行配置
<application
android:allowBackup="true"
android:debuggable="true" >
<!--配置资源包-->
<uses-library android:name="android.test.runner" />
</application>
<!-- 配置要进行单元测试的包targetPackage-->
<instrumentation
android:name="android.test.InstrumentationTestRunner"
android:label="My Text"
android:targetPackage="edu.qust.text" >
</instrumentation>
　　2.定义一个继承自AndroidTestCase的测试类
public class Text extend AndroidTestCase{
public void testAdd throws Exception{
}
}

posted @ 2014-02-21 11:13 顺其自然EVO 阅读(1056) | 评论 (0) | 编辑 收藏

JAVA 内存管理总结

　1. java是如何管理内存的
　　Java的内存管理就是对象的分配和释放问题。（两部分）
　　分配 ：内存的分配是由程序完成的，程序员需要通过关键字new 为每个对象申请内存空间 (基本类型除外)，所有的对象都在堆 (Heap)中分配空间。
　　释放 ：对象的释放是由垃圾回收机制决定和执行的，这样做确实简化了程序员的工作。但同时，它也加重了JVM的工作。因为，GC为了能够正确释放对象，GC必须监控每一个对象的运行状态，包括对象的申请、引用、被引用、赋值等，GC都需要进行监控。
　　2. 什么叫java的内存泄露
　　在Java中，内存泄漏就是存在一些被分配的对象，这些对象有下面两个特点，首先，这些对象是可达的，即在有向图中，存在通路可以与其相连（也就是说仍存在该内存对象的引用）；其次，这些对象是无用的，即程序以后不会再使用这些对象。如果对象满足这两个条件，这些对象就可以判定为Java中的内存泄漏，这些对象不会被GC所回收，然而它却占用内存。
　　3. JVM的内存区域组成
　　java把内存分两种：一种是栈内存，另一种是堆内存1。在函数中定义的基本类型变量和对象的引用变量都在函数的栈内存中分配；2。堆内存用来存放由new创建的对象和数组以及对象的实例变量 在函数（代码块）中定义一个变量时，java就在栈中为这个变量分配内存空间，当超过变量的作用域后，java会自动释放掉为该变量所分配的内存空间；在堆中分配的内存由java虚拟机的自动垃圾回收器来管理
　　堆和栈的优缺点
　　堆的优势是可以动态分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的。
　　缺点就是要在运行时动态分配内存，存取速度较慢； 栈的优势是，存取速度比堆要快，仅次于直接位于CPU中的寄存器。
　　另外，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。
　　4. Java中数据在内存中是如何存储的
　　a) 基本数据类型
　　Java的基本数据类型共有8种，即int, short, long, byte, float, double, boolean, char(注意，并没有string的基本类型)。这种类型的定义是通过诸如int a = 3； long b = 255L；的形式来定义的。如int a = 3；这里的a是一个指向int类型的引用，指向3这个字面值。这些字面值的数据，由于大小可知，生存期可知(这些字面值定义在某个程序块里面，程序块退出后，字段值就消失了)，出于追求速度的原因，就存在于栈中。
　　另外，栈有一个很重要的特殊性，就是存在栈中的数据可以共享。比如：我们同时定义：
　　int a=3;
　　int b =3;
　　编译器先处理int a = 3；首先它会在栈中创建一个变量为a的引用，然后查找有没有字面值为3的地址，没找到，就开辟一个存放3这个字面值的地址，然后将a指向3的地址。接着处理int b = 3；在创建完b这个引用变量后，由于在栈中已经有3这个字面值，便将b直接指向3的地址。这样，就出现了a与b同时均指向3的情况。    定义完a与b的值后，再令a = 4；那么，b不会等于4，还是等于3。在编译器内部，遇到时，它就会重新搜索栈中是否有4的字面值，如果没有，重新开辟地址存放4的值；如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响到b的值。
　　b)    对象
　　在Java中，创建一个对象包括对象的声明和实例化两步，下面用一个例题来说明对象的内存模型。
　　假设有类Rectangle定义如下：
public class Rectangle {
double width;
double height;
public Rectangle(double w,double h){
w = width;
h = height;
}
}
　　(1)声明对象时的内存模型
　　用Rectangle rect；声明一个对象rect时，将在栈内存为对象的引用变量rect分配内存空间，但Rectangle的值为空，称rect是一个空对象。空对象不能使用，因为它还没有引用任何"实体"。
　　(2)对象实例化时的内存模型
　　当执行rect=new Rectangle(3,5)；时，会做两件事：　在堆内存中为类的成员变量width,height分配内存，并将其初始化为各数据类型的默认值；接着进行显式初始化（类定义时的初始化值）；最后调用构造方法，为成员变量赋值。  返回堆内存中对象的引用（相当于首地址）给引用变量rect,以后就可以通过rect来引用堆内存中的对象了。
　c)    创建多个不同的对象实例
　　一个类通过使用new运算符可以创建多个不同的对象实例，这些对象实例将在堆中被分配不同的内存空间，改变其中一个对象的状态不会影响其他对象的状态。例如：
　　Rectangle r1= new Rectangle(3,5);
　　Rectangle r2= new Rectangle(4,6);
　　此时，将在堆内存中分别为两个对象的成员变量width、height分配内存空间，两个对象在堆内存中占据的空间是互不相同的。如果有：
　　Rectangle r1= new Rectangle(3,5);
　　Rectangle r2=r1;
　　则在堆内存中只创建了一个对象实例，在栈内存中创建了两个对象引用，两个对象引用同时指向一个对象实例。
　　d)    包装类
　　基本型别都有对应的包装类：如int对应Integer类，double对应Double类等，基本类型的定义都是直接在栈中，如果用包装类来创建对象，就和普通对象一样了。例如：int i=0；i直接存储在栈中。  Integer i（i此时是对象） = new Integer(5)；这样，i对象数据存储在堆中，i的引用存储在栈中，通过栈中的引用来操作对象。
　　e)    String
　　String是一个特殊的包装类数据。可以用用以下两种方式创建：String str = new String("abc")；String str = "abc";
　　第一种创建方式，和普通对象的的创建过程一样；
　　第二种创建方式，Java内部将此语句转化为以下几个步骤：
　　(1) 先定义一个名为str的对String类的对象引用变量：String str；
　　(2) 在栈中查找有没有存放值为"abc"的地址，如果没有，则开辟一个存放字面值为"abc"
　　地址，接着创建一个新的String类的对象o，并将o的字符串值指向这个地址，而且在栈
　　这个地址旁边记下这个引用的对象o。如果已经有了值为"abc"的地址，则查找对象o，并
　　回o的地址。
　　(3) 将str指向对象o的地址。
　　值得注意的是，一般String类中字符串值都是直接存值的。但像String str = "abc"；这种
　　合下，其字符串值却是保存了一个指向存在栈中数据的引用。
　　为了更好地说明这个问题，我们可以通过以下的几个代码进行验证。
　　String str1="abc"；
　　String str2="abc"；
　　System.out.println(s1==s2)；//true
　　注意，这里并不用str1.equals(str2)；的方式，因为这将比较两个字符串的值是否相等。==号，根据JDK的说明，只有在两个引用都指向了同一个对象时才返回真值。而我们在这里要看的是，str1与str2是否都指向了同一个对象。
　　我们再接着看以下的代码。
　　String str1= new String("abc")；
　　String str2="abc"；
　　System.out.println(str1==str2)；//false
　　创建了两个引用。创建了两个对象。两个引用分别指向不同的两个对象。
　　以上两段代码说明，只要是用new()来新建对象的，都会在堆中创建，而且其字符串是单独存值的，即使与栈中的数据相同，也不会与栈中的数据共享。
　　f)    数组
　　当定义一个数组，int x[]；或int []x；时，在栈内存中创建一个数组引用，通过该引用（即数组名）来引用数组。x=new int[3]；将在堆内存中分配3个保存int型数据的空间，堆内存的首地址放到栈内存中，每个数组元素被初始化为0。
　　g)    静态变量
　　用static的修饰的变量和方法，实际上是指定了这些变量和方法在内存中的"固定位置"－static storage，可以理解为所有实例对象共有的内存空间。static变量有点类似于C中的全局变量的概念；静态表示的是内存的共享，就是它的每一个实例都指向同一个内存地址。把static拿来，就是告诉JVM它是静态的，它的引用（含间接引用）都是指向同一个位置，在那个地方，你把它改了，它就不会变成原样，你把它清理了，它就不会回来了。         那静态变量与方法是在什么时候初始化的呢？对于两种不同的类属性，static属性与instance属性，初始化的时机是不同的。instance属性在创建实例的时候初始化，static属性在类加载，也就是第一次用到这个类的时候初始化，对于后来的实例的创建，不再次进行初始化。         我们常可看到类似以下的例子来说明这个问题：
class Student{
static int numberOfStudents=0;
Student()
{
numberOfStudents++;
}
}
　　每一次创建一个新的Student实例时,成员numberOfStudents都会不断的递增,并且所有的Student实例都访问同一个numberOfStudents变量,实际上int numberOfStudents变量在内存中只存储在一个位置上。
　　5. Java的内存管理实例
　　Java程序的多个部分(方法，变量，对象)驻留在内存中以下两个位置：即堆和栈，现在我们只关心3类事物：实例变量，局部变量和对象：
　　实例变量和对象驻留在堆上
　　局部变量驻留在栈上
　　让我们查看一个java程序，看看他的各部分如何创建并且映射到栈和堆中：
　　public class Dog {
　　Collar c;
　　String name;
　　//1. main()方法位于栈上
　　public static void main(String[] args) {
　　//2. 在栈上创建引用变量d,但Dog对象尚未存在
　　Dog d;
　　//3. 创建新的Dog对象，并将其赋予d引用变量
　　d = new Dog();
　　//4. 将引用变量的一个副本传递给go()方法
　　d.go(d);
　　}
　　//5. 将go()方法置于栈上，并将dog参数作为局部变量
　　void go(Dog dog){
　　//6. 在堆上创建新的Collar对象，并将其赋予Dog的实例变量
　　c =new Collar();
　　}
　　//7.将setName()添加到栈上，并将dogName参数作为其局部变量
　　void setName(String dogName){
　　//8. name的实例对象也引用String对象
　　name=dogName;
　　}
　　//9. 程序执行完成后，setName()将会完成并从栈中清除，此时，局部变量dogName也会消失，尽管它所引用的String仍在堆上
　　}
6. 垃圾回收机制：
　　（问题一：什么叫垃圾回收机制？） 垃圾回收是一种动态存储管理技术，它自动地释放不再被程序引用的对象，按照特定的垃圾收集算法来实现资源自动回收的功能。当一个对象不再被引用的时候，内存回收它占领的空间，以便空间被后来的新对象使用，以免造成内存泄露。 （问题二：java的垃圾回收有什么特点？） JAVA语言不允许程序员直接控制内存空间的使用。内存空间的分配和回收都是由JRE负责在后台自动进行的，尤其是无用内存空间的回收操作(garbagecollection,也称垃圾回收)，只能由运行环境提供的一个超级线程进行监测和控制。 （问题三：垃圾回收器什么时候会运行？） 一般是在CPU空闲或空间不足时自动进行垃圾回收，而程序员无法精确控制垃圾回收的时机和顺序等。 （问题四：什么样的对象符合垃圾回收条件？） 当没有任何获得线程能访问一个对象时，该对象就符合垃圾回收条件。 （问题五：垃圾回收器是怎样工作的？） 垃圾回收器如发现一个对象不能被任何活线程访问时，他将认为该对象符合删除条件，就将其加入回收队列，但不是立即销毁对象，何时销毁并释放内存是无法预知的。垃圾回收不能强制执行，然而Java提供了一些方法（如：System.gc()方法），允许你请求JVM执行垃圾回收，而不是要求，虚拟机会尽其所能满足请求，但是不能保证JVM从内存中删除所有不用的对象。 （问题六：一个java程序能够耗尽内存吗？） 可以。垃圾收集系统尝试在对象不被使用时把他们从内存中删除。然而，如果保持太多活的对象，系统则可能会耗尽内存。垃圾回收器不能保证有足够的内存，只能保证可用内存尽可能的得到高效的管理。 （问题七：如何显示的使对象符合垃圾回收条件？） （1） 空引用 ：当对象没有对他可到达引用时，他就符合垃圾回收的条件。也就是说如果没有对他的引用，删除对象的引用就可以达到目的，因此我们可以把引用变量设置为null，来符合垃圾回收的条件。
　　StringBuffer sb = new StringBuffer("hello");
　　System.out.println(sb);
　　sb=null;
　　（2） 重新为引用变量赋值：可以通过设置引用变量引用另一个对象来解除该引用变量与一个对象间的引用关系。
　　StringBuffer sb1 = new StringBuffer("hello");
　　StringBuffer sb2 = new StringBuffer("goodbye");
　　System.out.println(sb1);
　　sb1=sb2;//此时"hello"符合回收条件
　　（3） 方法内创建的对象：所创建的局部变量仅在该方法的作用期间内存在。一旦该方法返回，在这个方法内创建的对象就符合垃圾收集条件。有一种明显的例外情况，就是方法的返回对象。
public static void main(String[] args) {
Date d = getDate();
System.out.println("d = " + d);
}
private static Date getDate() {
Date d2 = new Date();
StringBuffer now = new StringBuffer(d2.toString());
System.out.println(now);
return d2;
}
　　（4） 隔离引用：这种情况中，被回收的对象仍具有引用，这种情况称作隔离岛。若存在这两个实例，他们互相引用，并且这两个对象的所有其他引用都删除，其他任何线程无法访问这两个对象中的任意一个。也可以符合垃圾回收条件。
public class Island {
Island i;
public static void main(String[] args) {
Island i2 = new Island();
Island i3 = new Island();
Island i4 = new Island();
i2.i=i3;
i3.i=i4;
i4.i=i2;
i2=null;
i3=null;
i4=null;
}
}
　　（问题八：垃圾收集前进行清理------finalize()方法） java提供了一种机制，使你能够在对象刚要被垃圾回收之前运行一些代码。这段代码位于名为finalize()的方法内，所有类从Object类继承这个方法。由于不能保证垃圾回收器会删除某个对象。因此放在finalize()中的代码无法保证运行。因此建议不要重写finalize();
　　7.    final问题：
　　final使得被修饰的变量"不变"，但是由于对象型变量的本质是"引用"，使得"不变"也有了两种含义：引用本身的不变?，和引用指向的对象不变。?         引用本身的不变：
　　final StringBuffer a=new StringBuffer("immutable");
　　final StringBuffer b=new StringBuffer("not immutable");
　　a=b;//编译期错误
　　final StringBuffer a=new StringBuffer("immutable");
　　final StringBuffer b=new StringBuffer("not immutable");
　　a=b;//编译期错误
　　引用指向的对象不变：
　　final StringBuffer a=new StringBuffer("immutable");
　　a.append(" broken!"); //编译通过
　　final StringBuffer a=new StringBuffer("immutable");
　　a.append(" broken!"); //编译通过
　　可见，final只对引用的"值"(也即它所指向的那个对象的内存地址)有效，它迫使引用只能指向初始指向的那个对象，改变它的指向会导致编译期错误。至于它所指向的对象的变化，final是不负责的。这很类似==操作符：==操作符只负责引用的"值"相等，至于这个地址所指向的对象内容是否相等，==操作符是不管的。在举一个例子：
public class Name {
private String firstname;
private String lastname;
public String getFirstname() {
return firstname;
}
public void setFirstname(String firstname) {
this.firstname = firstname;
}
public String getLastname() {
return lastname;
}
public void setLastname(String lastname) {
this.lastname = lastname;
}
}
public class Name {
private String firstname;
private String lastname;
public String getFirstname() {
return firstname;
}
public void setFirstname(String firstname) {
this.firstname = firstname;
}
public String getLastname() {
return lastname;
}
public void setLastname(String lastname) {
this.lastname = lastname;
}
}
　　编写测试方法：
public static void main(String[] args) {
final Name name = new Name();
name.setFirstname("JIM");
name.setLastname("Green");
System.out.println(name.getFirstname()+" "+name.getLastname());
}
public static void main(String[] args) {
final Name name = new Name();
name.setFirstname("JIM");
name.setLastname("Green");
System.out.println(name.getFirstname()+" "+name.getLastname());
}
　　理解final问题有很重要的含义。许多程序漏洞都基于此----final只能保证引用永远指向固定对象，不能保证那个对象的状态不变。在多线程的操作中,一个对象会被多个线程共享或修改，一个线程对对象无意识的修改可能会导致另一个使用此对象的线程崩溃。一个错误的解决方法就是在此对象新建的时候把它声明为final，意图使得它"永远不变"。其实那是徒劳的。     Final还有一个值得注意的地方：
    先看以下示例程序：
class Something {
final int i;
public void doSomething() {
System.out.println("i = " + i);
}
}
class Something {
final int i;
public void doSomething() {
System.out.println("i = " + i);
}
}
　　对于类变量，Java虚拟机会自动进行初始化。如果给出了初始值，则初始化为该初始值。如果没有给出，则把它初始化为该类型变量的默认初始值。但是对于用final修饰的类变量，虚拟机不会为其赋予初值，必须在constructor (构造器)结束之前被赋予一个明确的值。可以修改为"final int i = 0;"。
　　8.    如何把程序写得更健壮：
　　1、尽早释放无用对象的引用。 好的办法是使用临时变量的时候，让引用变量在退出活动域后，自动设置为null，暗示垃圾收集器来收集该对象，防止发生内存泄露。对于仍然有指针指向的实例，jvm就不会回收该资源,因为垃圾回收会将值为null的对象作为垃圾，提高GC回收机制效率；
　　2、定义字符串应该尽量使用 String str="hello"; 的形式 ，避免使用String str = new String("hello"); 的形式。因为要使用内容相同的字符串，不必每次都new一个String。例如我们要在构造器中对一个名叫s的String引用变量进行初始化，把它设置为初始值，应当这样做：
public class Demo {
private String s;
public Demo() {
s = "Initial Value";
}
}
public class Demo {
private String s;
...
public Demo {
s = "Initial Value";
}
...
}
　　而非
　　s = new String("Initial Value");
　　s = new String("Initial Value");
　　后者每次都会调用构造器，生成新对象，性能低下且内存开销大，并且没有意义，因为String对象不可改变，所以对于内容相同的字符串，只要一个String对象来表示就可以了。也就说，多次调用上面的构造器创建多个对象，他们的String类型属性s都指向同一个对象。
　　3、我们的程序里不可避免大量使用字符串处理，避免使用String，应大量使用StringBuffer ，因为String被设计成不可变(immutable)类，所以它的所有对象都是不可变对象，请看下列代码；
String s = "Hello";
s = s + " world!";
String s = "Hello";
s = s + " world!";
　　在这段代码中，s原先指向一个String对象，内容是 "Hello"，然后我们对s进行了+操作，那么s所指向的那个对象是否发生了改变呢？答案是没有。这时，s不指向原来那个对象了，而指向了另一个 String对象，内容为"Hello world!"，原来那个对象还存在于内存之中，只是s这个引用变量不再指向它了。         通过上面的说明，我们很容易导出另一个结论，如果经常对字符串进行各种各样的修改，或者说，不可预见的修改，那么使用String来代表字符串的话会引起很大的内存开销。因为 String对象建立之后不能再改变，所以对于每一个不同的字符串，都需要一个String对象来表示。这时，应该考虑使用StringBuffer类，它允许修改，而不是每个不同的字符串都要生成一个新的对象。并且，这两种类的对象转换十分容易。
　　4、尽量少用静态变量 ，因为静态变量是全局的，GC不会回收的；
　　5、尽量避免在类的构造函数里创建、初始化大量的对象 ，防止在调用其自身类的构造器时造成不必要的内存资源浪费，尤其是大对象，JVM会突然需要大量内存，这时必然会触发GC优化系统内存环境；显示的声明数组空间，而且申请数量还极大。         以下是初始化不同类型的对象需要消耗的时间：
　　运算操作
　　示例
　　标准化时间
　　本地赋值
　　i = n
　　1.0
　　实例赋值
　　this.i = n
　　1.2
　　方法调用
　　Funct()
　　5.9
　　新建对象
　　New Object()
　　980
　　新建数组
　　New int[10]
　　3100
　　从表1可以看出，新建一个对象需要980个单位的时间，是本地赋值时间的980倍，是方法调用时间的166倍，而新建一个数组所花费的时间就更多了。
　　6、尽量在合适的场景下使用对象池技术 以提高系统性能，缩减缩减开销，但是要注意对象池的尺寸不宜过大，及时清除无效对象释放内存资源，综合考虑应用运行环境的内存资源限制，避免过高估计运行环境所提供内存资源的数量。
　　7、大集合对象拥有大数据量的业务对象的时候，可以考虑分块进行处理 ，然后解决一块释放一块的策略。
　　8、不要在经常调用的方法中创建对象 ，尤其是忌讳在循环中创建对象。可以适当的使用hashtable，vector 创建一组对象容器，然后从容器中去取那些对象，而不用每次new之后又丢弃。
　　9、一般都是发生在开启大型文件或跟数据库一次拿了太多的数据，造成 Out Of Memory Error 的状况，这时就大概要计算一下数据量的最大值是多少，并且设定所需最小及最大的内存空间值。
　　10、尽量少用finalize函数 ，因为finalize()会加大GC的工作量，而GC相当于耗费系统的计算能力。
　　11、不要过滥使用哈希表 ，有一定开发经验的开发人员经常会使用hash表（hash表在JDK中的一个实现就是HashMap）来缓存一些数据，从而提高系统的运行速度。比如使用HashMap缓存一些物料信息、人员信息等基础资料，这在提高系统速度的同时也加大了系统的内存占用，特别是当缓存的资料比较多的时候。其实我们可以使用操作系统中的缓存的概念来解决这个问题，也就是给被缓存的分配一个一定大小的缓存容器，按照一定的算法淘汰不需要继续缓存的对象，这样一方面会因为进行了对象缓存而提高了系统的运行效率，同时由于缓存容器不是无限制扩大，从而也减少了系统的内存占用。现在有很多开源的缓存实现项目，比如ehcache、oscache等，这些项目都实现了FIFO、MRU等常见的缓存算法

posted @ 2014-02-21 10:42 顺其自然EVO 阅读(252) | 评论 (0) | 编辑 收藏

仅列出标题
共394页: First 上一页 145 146 147 148 149 150 151 152 153 下一页 Last 
<2024年11月>
日一二三四五六
272829303112
3456789
10111213141516
17181920212223
24252627282930
1234567

导航

统计

常用链接

留言簿(55)

随笔分类

随笔档案

文章分类

文章档案

搜索

最新评论

阅读排行榜

评论排行榜