Cool eye

BlogJava 首页 新随笔 联系 聚合 管理
  63 Posts :: 4 Stories :: 3 Comments :: 0 Trackbacks

2011年7月27日 #

这个网站提供了在线的网页编辑设计工具,可视化的,很人性化,功能很强大,每个注册用户都会获得一个二级域名的网 站,还可以绑定一级域名并 且不需要备案, 你可以在线的编辑你的网站文件,也可以创建网页文件,还可以上传图片css和js文件,也提供了css编辑和js编辑,不过里面最好的还是网页编辑工具, 编辑完了到代码视图copy出网页代码,很方便。这个网站主要是做网站的,不过我们程序员可以利用里面的编辑工具。
地址:http://imaiyi.com
试用地址:http://imaiyi.com/tryhtmleditor.htm
来几个截图:











posted @ 2011-07-27 08:01 joeyeezhang 阅读(1385) | 评论 (0)编辑 收藏

2007年1月16日 #

 

1.Duplicated Code
代码重复几乎是最常见的异味了。他也是Refactoring 的主要目标之一。代码重复往
往来自于copy-and-paste 的编程风格。与他相对应OAOO 是一个好系统的重要标志
(请参见我的duplicated code 一文:http://www.erptao.org/download.php?op=viewsdownload&sid=6)。


2.Long method
它是传统结构化的“遗毒“。一个方法应当具有自我独立的意图,不要把几个意图
放在一起,我的《大类和长方法》一文中有详细描述。


3.Large Class
大类就是你把太多的责任交给了一个类。这里的规则是One Class One Responsibility。

4.Divergent Change
一个类里面的内容变化率不同。某些状态一个小时变一次,某些则几个月一年才变
一次;某些状态因为这方面的原因发生变化,而另一些则因为其他方面的原因变一次。
面向对象的抽象就是把相对不变的和相对变化相隔离。把问题变化的一方面和另一
方面相隔离。这使得这些相对不变的可以重用。问题变化的每个方面都可以单独重用。
这种相异变化的共存使得重用非常困难。


5.Shotgun Surgery
这正好和上面相反。对系统一个地方的改变涉及到其他许多地方的相关改变。这些
变化率和变化内容相似的状态和行为通常应当放在同一个类中。


6.Feature Envy
对象的目的就是封装状态以及与这些状态紧密相关的行为。如果一个类的方法频繁
用get 方法存取其他类的状态进行计算,那么你要考虑把行为移到涉及状态数目最多的
那个类。


7.Data Clumps
某些数据通常像孩子一样成群玩耍:一起出现在很多类的成员变量中,一起出现在
许多方法的参数中…..,这些数据或许应该自己独立形成对象。


8.Primitive Obsession
面向对象的新手通常习惯使用几个原始类型的数据来表示一个概念。譬如对于范围,
他们会使用两个数字。对于Money,他们会用一个浮点数来表示。因为你没有使用对象
来表达问题中存在的概念,这使得代码变的难以理解,解决问题的难度大大增加。
好的习惯是扩充语言所能提供原始类型,用小对象来表示范围、金额、转化率、邮
政编码等等。


9.Switch Statement
基于常量的开关语句是OO 的大敌,你应当把他变为子类、state 或strategy。


10. Parallel Inheritance Hierarchies
并行的继承层次是shotgun surgery 的特殊情况。因为当你改变一个层次中的某一个
类时,你必须同时改变另外一个层次的并行子类。


11. Lazy Class
一个干活不多的类。类的维护需要额外的开销,如果一个类承担了太少的责任,应
当消除它。


12. Speculative Generality
一个类实现了从未用到的功能和通用性。通常这样的类或方法唯一的用户是test
case。不要犹豫,删除它。


13. Temporary Field
一个对象的属性可能只在某些情况下才有意义。这样的代码将难以理解。专门建立
一个对象来持有这样的孤儿属性,把只和他相关的行为移到该类。最常见的是一个特定
的算法需要某些只有该算法才有用的变量。


14. Message Chain
消息链发生于当一个客户向一个对象要求另一个对象,然后客户又向这另一对象要
求另一个对象,再向这另一个对象要求另一个对象,如此如此。这时,你需要隐藏分派。


15. Middle Man
对象的基本特性之一就是封装,而你经常会通过分派去实现封装。但是这一步不能走得太远,如果你发现一个类接口的一大半方法都在做分派,你可能需要移去这个中间
人。


16. Inappropriate Intimacy
某些类相互之间太亲密,它们花费了太多的时间去砖研别人的私有部分。对人类而
言,我们也许不应该太假正经,但我们应当让自己的类严格遵守禁欲主义。


17. Alternative Classes with Different Interfaces
做相同事情的方法有不同的函数signature,一致把它们往类层次上移,直至协议一
致。


18. Incomplete Library Class
要建立一个好的类库非常困难。我们大量的程序工作都基于类库实现。然而,如此
广泛而又相异的目标对库构建者提出了苛刻的要求。库构建者也不是万能的。有时候我
们会发现库类无法实现我们需要的功能。而直接对库类的修改有非常困难。这时候就需
要用各种手段进行Refactoring。


19. Data Class
对象包括状态和行为。如果一个类只有状态没有行为,那么肯定有什么地方出问题
了。


20. Refused Bequest
超类传下来很多行为和状态,而子类只是用了其中的很小一部分。这通常意味着你
的类层次有问题。


21. Comments
经常觉得要写很多注释表示你的代码难以理解。如果这种感觉太多,表示你需要
Refactoring。

卖艺网提供
posted @ 2007-01-16 17:48 joeyeezhang 阅读(177) | 评论 (0)编辑 收藏

2007年1月5日 #

1.什么是xp编程(极限编程):

XP是勇气,交流,反馈和简单。
XP是软件开发过程中的纪律,它规定你:必须在编程前些测试,必须两个人一起编程,必须遵守编程规范……。
XP是把最好的实践经验提取出来,形成了一个崭新的开发方法。

2. XP适用范围:

极限编程,也被叫做XP,适用于中小型团队在需求不明确或者迅速变化的情况下进行软件开发的轻量级方法学。
推荐使用范围为10人左右的团队

3.XP工作模式体现:

一、工作环境
二、立式晨会
三、结对编程
四、测试驱动开发
五、重构
六、持续集成
七、频繁地发布小版本

4.结对编程:

开发任务会细化分解为很多Task,一个Task的开发周期一般不超过2天。
每个Task的Owner会寻找一个Partner进行结对开发。
Task开发的次序由程序员们自己协商。他可以先作为Partner和其他Owner一起开发某个Task,然后再找另一个程序员作为Partner来共同开发自己承担的Task。
结对开发时,Task的Owner主要负责编码, Partner负责在一旁看Owner编程并在其编写有错误提出自己的意见,当其遇到困难时一起讨论、互相帮助完成任务

5.测试驱动开发:

在动手编码之前,必须先写功能测试脚本、单元测试脚本。
写好测试脚本后,开始编码、重构、运行单元测试、集成、运行功能测试,以此循环

6.重构:

减少重复设计,优化设计结构,提高技术上的重用性和可扩展性。
XP提倡毫不留情的重构。
任何人可以重构任何代码,前提是重构后的代码一定要通过100%测试单元测试后才能被Check-in

7.持续集成:

测试先行是持续集成的一个重要前提。
持续集成指不断地把完成的功能模块整合在一起。目的在于不断获得客户反馈以及尽早发现BUG。
随时整合,越频繁越好;集成及测试过程的自动化程度越高越好。
每次只有一个新增加部分在整合,而且必须运行功能测试

8.频繁地发布小版本:

发布过程应该尽可能地自动化、规范化。
不断地发布可用的系统可以告诉客户你在做正确的事情。
客户使用发布的系统,可以保证频繁地反馈和交流。
保证客户有足够的依据调控开发过程(增加、删除或改变需求)。
降低开发风险。
随着开发的推进,发布越来越频繁。
所有的发布都要经过功能测试。

9.XP的关键词:

测试优先原则
结对编程
持续集成
频繁小版本
不断重构
立式晨会
交流和沟通,“只有没有沟通不够的项目,没有沟通过度的项目”
分解任务、制定计划是关键一环

10.XP作用:

一、平稳的工作效率

平稳的工作效率指团队和个人在很长的时期内保持一定的开发效率。
保证了项目速度和计划过程的有效性和准确性;
保证了程序员可以持续地完成任务,团队可以持续地向客户交付可运行的系统;
结对编程已经加大了工作强度,并且和其它XP的规则一起提高了工作效率,使少加班和维持平稳的工作效率可能而且可行。
提倡平稳的工作效率,体现了XP以人为本的价值观。
二、高质量

测试优先、并坚持单元测试、每个版本进行功能测试的原则是保证了高质量的一个关键;
充分的沟通交流进一步减少了写低质量代码的风险;
结对开发模式在互相学习中会产出高质量的代码
三、Open

结对开发、每一处修改都需要测试等等规则使得实现集体拥有代码, “我们”的代码,而不是“我”的代码;
充分的沟通交流可以将每个人的知识、思想共享;
让每个人都知道项目的设计、计划、进展情况等信息;
大家都知道每个人都在做什么和怎么做;
四、对人的挑战
暴露自己的缺点,人的本性
懒惰
自尊
封闭
……

克服自己的缺点
高效率
不怕告诉别人自己不会,乐于问人
懂得尊重别人,乐于帮助别人
……

11.受益于XP:

一个曾经在XP模式下工作过的人,回到传统开发模式下才深刻体会到XP给他带来的财富。
在传统开发模式下他坚持每天有计划、总结,坚持测试驱动开发……
发现他总是按时下班甚至提前下班,可是同事们越来越多且越来越晚下班,是自己不认真?是同事们爱表现?……
都不是!!
是XP给他带来的受益终身的开发方式,他的同事bug量远远比他多,他只有不多的几个;同事们任务总是延时,而自己都是轻松按时完成……


卖艺网提供
posted @ 2007-01-05 09:33 joeyeezhang 阅读(334) | 评论 (0)编辑 收藏

2007年1月4日 #

给你一个标准的定义:
在RUP中,迭代被定义为:迭代包括产生产品发布(稳定、可执行的产品版本)的全部开发活动和要使用该发布必需的所有其他外围元素。

这个定义太学究气,半天看不明白。这样解释可能更容易理解:
我们开发一个产品,如果不太复杂,会采用瀑布模型,简单的说就是先需求定义,然后构建框架,然后写代码,然后测试,最后发布一个产品。
这样,几个月过去了,直到最后一天发布时,大家才能见到一个产品。

这样的方式有明显的缺点,假如我们对用户的需求判断的不是很准确时——这是很常见的问题,一点也不少见——你工作了几个月甚至是几年,当你把产品拿给客户看时,客户往往会大吃一惊,这就是我要的东西吗?

迭代的方式就有所不同,假如这个产品要求6个月交货,我在第一个月就会拿出一个产品来,当然,这个产品会很不完善,会有很多功能还没有添加进去,bug很多,还不稳定,但客户看了以后,会提出更详细的修改意见,这样,你就知道自己距离客户的需求有多远,我回家以后,再花一个月,在上个月所作的需求分析、框架设计、代码、测试等等的基础上,进一步改进,又拿出一个更完善的产品来,给客户看,让他们提意见。
就这样,我的产品在功能上、质量上都能够逐渐逼近客户的要求,不会出现我花了大量心血后,直到最后发布之时才发现根本不是客户要的东西。

这样的方法很不错,但他也有自己的缺陷,那就是周期长、成本很高。在应付大项目、高风险项目——就比如是航天飞机的控制系统时,迭代的成本比项目失败的风险成本低得多,用这种方式明显有优势。
如果你是给自己的单位开发一个小MIS,自己也比较清楚需求,工期上也不过花上个把月的时间,用迭代就有点杀鸡用了牛刀,那还是瀑布模型更管用,即使是做得不对,顶多再花一个月重来,没什么了不起
卖艺网
posted @ 2007-01-04 16:49 joeyeezhang 阅读(210) | 评论 (0)编辑 收藏

ExtremeProgramming(极限编程,简称XP)是由KentBeck在1996年提出的。KentBeck在九十年代初期与WardCunningham共事时,就一直共同探索着新的软件开发方法,希望能使软件开发更加简单而有效。Kent仔细地观察和分析了各种简化软件开发的前提条件、可能行以及面临的困难。1996年三月,Kent终于在为DaimlerChrysler所做的一个项目中引入了新的软件开发观念——XP。
XP是一个轻量级的、灵巧的软件开发方法;同时它也是一个非常严谨和周密的方法。它的基础和价值观是交流、朴素、反馈和勇气;即,任何一个软件项目都可以从四个方面入手进行改善:加强交流;从简单做起;寻求反馈;勇于实事求是。XP是一种近螺旋式的开发方法,它将复杂的开发过程分解为一个个相对比较简单的小周期;通过积极的交流、反馈以及其它一系列的方法,开发人员和客户可以非常清楚开发进度、变化、待解决的问题和潜在的困难等,并根据实际情况及时地调整开发过程。
什么是软件开发

软件开发的内容是:需求、设计、编程和测试!

需求:不仅仅是用户需求,应该是开发中遇到的所有的需求。比如,你首先要知道做这个项目是为了解决什么问题;测试案例中应该输入什么数据……为了清楚地知道这些需求,你经常要和客户、项目经理等交流。

设计:编码前,肯定有个计划告诉你要做什么,结构是怎样等等。你一定要按照这个来做,否则可能会一团糟。

编程:如果在项目截止日,你的程序不能跑起来或达不到客户的要求,你就拿不到钱。

测试:目的是让你知道,什么时候算是完成了。如果你聪明,你就应该先写测试,这样可以及时知道你是否真地完成了。否则,你经常会不知道,到底有哪些功能是真正完成了,离预期目标还差多远。

软件开发中,客户和开发人员都有自己的基本权利和义务。
客户:
定义每个用户需求的商业优先级;
制订总体计划,包括用多少投资、经过多长时间、达到什么目的;
在项目开发过程中的每个工作周,都能让投资获得最大的收益;
通过重复运行你所指定的功能测试,准确地掌握项目进展情况;
能随时改变需求、功能或优先级,同时避免昂贵的再投资;能够根据各种变化及时调整项目计划;
能够随时取消项目;项目取消时,以前的开发工作不是一堆垃圾,已开发完的功能是合乎要求的,正在进行或未完成的的工作则应该是不难接手的。

开发人员:
知道要做什么,以及要优先做什么;
工作有效率;
有问题或困难时,能得到客户、同事、上级的回答或帮助;
对工作做评估,并根据周围情况的变化及时重新评估;
积极承担工作,而不是消极接受分配;
一周40小时工作制,不加班。

这就是软件开发,除此之外再还有其它要关心的问题!


灵巧的轻量级软件开发方法

一套软件开发方法是由一系列与开发相关的规则、规范和惯例。重量级的开发方法严格定义了许多的规则、流程和相关的文档工作。灵巧的轻量级开发方法,其规则和文档相对较少,流程更加灵活,实施起来相对较容易。

在软件工程概念出现以前,程序员们按照自己喜欢的方式开发软件。程序的质量很难控制,调试程序很繁琐,程序员之间也很难读懂对方写的代码。1968年,EdsgerDijkstra给CACM写了一封题为GOTOStatementConsideredHarmful的信,软件工程的概念由此诞生。程序员们开始摒弃以前的做法,转而使用更系统、更严格的开发方法。为了使控制软件开发和控制其它产品生产一样严格,人们陆续制定了很多规则和做法,发明了很多软件工程方法,软件质量开始得到大幅度提高。随着遇到的问题更多,规则和流程也越来越精细和复杂。

到了今天,在实际开发过程中,很多规则已经难于遵循,很多流程复杂而难于理解,很多项目中文档的制作过程正在失去控制。人们试图提出更全面更好的一揽子方案,或者寄希望于更复杂的、功能更强大的辅助开发工具(CaseTools),但总是不能成功,而且开发规范和流程变得越来越复杂和难以实施。

为了赶进度,程序员们经常跳过一些指定的流程,很少人能全面遵循那些重量级开发方法。

失败的原因很简单,这个世界没有万能药。因此,一些人提出,将重量级开发方法中的规则和流程进行删减、重整和优化,这样就产生了很多适应不同需要的轻量级流程。在这些流程中,合乎实际需要的规则被保留下来,不必要的复杂化开发的规被抛弃。而且,和传统的开发方法相比,轻量级流程不再象流水生产线,而是更加灵活。

ExtremeProgramming(XP)就是这样一种灵巧的轻量级软件开发方法。


为什么称为“Extreme”(极限)

“Extreme”(极限)是指,对比传统的项目开发方式,XP强调把它列出的每个方法和思想做到极限、做到最好;其它XP所不提倡的,则一概忽略(如开发前期的整体设计等)。一个严格实施XP的项目,其开发过程应该是平稳的、高效的和快速的,能够做到一周40小时工作制而不拖延项目进度。

XP的软件开发是什么样

1极限的工作环境

为了在软件开发过程中最大程度地实现和满足客户和开发人员的基本权利和义务,XP要求把工作环境也做得最好。每个参加项目开发的人都将担任一个角色(项目经理、项目监督人等等)并履行相应的权利和义务。所有的人都在同一个开放的开发环境中工作,最好是所有人在同一个大房子中工作,还有茶点供应;每周40小时,不提倡加班;每天早晨,所有人一起站着开个短会;墙上有一些大白板,所有的Story卡、CRC卡等都贴在上面,讨论问题的时候可以在上面写写画画;下班后大家可以一起玩电脑游戏……。

2极限的需求

客户应该是项目开发队伍中的一员,而不是和开发人员分开的;因为从项目的计划到最后验收,客户一直起着很重要的作用。开发人员和客户一起,把各种需求变成一个个小的需求模块(UserStory),例如“计算年级的总人数,就是把该年级所有班的人数累加。”;这些模块又会根据实际情况被组合在一起或者被分解成更小的模块;它们都被记录在一些小卡片(StoryCard)上,之后分别被程序员们在各个小的周期开发中(Iteration,通常不超过3个星期)实现;客户根据每个模块的商业价值来指定它们的优先级;开发人员要做的是确定每个需求模块的开发风险,风险高的(通常是因为缺乏类似的经验)需求模块将被优先研究、探索和开发;经过开发人员和客户分别从不同的角度评估每个模块后,它们被安排在不同的开发周期里,客户将得到一个尽可能准确的开发计划;客户为每个需求模块指定验收测试(功能测试)。

每发布一次开发的软件(经过一个开发周期),用户都能得到一个可以开始使用的系统,这个系统全面实现了相应的计划中的所有需求。而在一些传统的开发模式中,无论什么功能,用户都要等到所有开发完成后才能开始使用。

3极限的设计

从具体开发的角度来看,XP内层的过程是一个个基于测试驱动的开发(TestDrivenDevelopment)周期,诸如计划和设计等外层的过程都是围绕这些展开的。每个开发周期都有很多相应的单元测试(UnitTest)。刚开始,因为什么都没有实现,所以所有的单元测试都是失败的;随着一个个小的需求模块的完成,通过的单元测试也越来越多。通过这种方式,客户和开发人员都很容易检验,是否履行了对客户的承诺。XP提倡对于简单的设计(SimpleDesign),就是用最简单的方式,使得为每个简单的需求写出来的程序可以通过所有相关的单元测试。XP强调抛弃那种一揽子详细设计方式(BigDesignUpFront),因为这种设计中有很多内容是你现在或最近都根本不需要的。XP还大力提倡设计复核(Review)、代码复核以及重整和优化(Refectory),所有的这些过程其实也是优化设计的过程;在这些过程中不断运行单元测试和功能测试,可以保证经过重整和优化后的系统仍然符合所有需求。

4极限的编程

既然编程很重要,XP就提倡两个人一起写同一段程序(PairProgramming),而且代码所有权是归于整个开发队伍(CollectiveCodeOwnership)。程序员在写程序和重整优化程序的时候,都要严格遵守编程规范。任何人都可以修改其他人写的程序,修改后要确定新程序能通过单元测试。

5极限的测试

既然测试很重要,XP就提倡在开始写程序之前先写单元测试。开发人员应该经常把开发好的模块整合到一起(ContinuousIntegration),每次整合后都要运行单元测试;做任何的代码复核和修改,都要运行单元测试;发现了BUG,就要增加相应的测试(因此XP方法不需要BUG数据库)。除了单元测试之外,还有整合测试,功能测试、负荷测试和系统测试等。所有这些测试,是XP开发过程中最重要的文档之一,也是最终交付给用户的内容之一。


XP中的重要惯例和规则

1项目开发小组(Team)

在XP中,每个对项目做贡献的人都应该是项目开发小组中的一员。而且,这个小组中必须至少有一个人对用户需求非常清晰,能够提出需求、决定各个需求的商业价值(优先级)、根据需求等的变化调整项目计划等。这个人扮演的是“客户”这个角色,当然最好就是实际的最终用户,因为整个项目就是围绕最终用户的需求而展开的。程序员是项目开发小组中必不可少的成员。小组中可以有测试员,他们帮助客户制订验收测试;有分析员,帮助客户确定需求;通常还有个Coach(教练),负责跟踪开发进度、解决开发中遇到的一些问题、推动项目进行;还可以又一个项目经理,负责调配资源、协助项目内外的交流沟通等等。项目小组中有这么多角色,但并不是说,每个人做的工作是别人不能插手或干预的,XP鼓励每个人尽可能地为项目多做贡献。平等相处,取长补短;这就是最好的XP开发小组。

2计划项目(PlanningGame)、验收测试、小规模发布(SmallReleases)

XP开发小组使用简单的方式进行项目计划和开发跟踪,并以次预测项目进展情况和决定未来的步骤。根据需求的商业价值,开发小组针对一组组的需求进行一系列的开发和整合,每次开发都会产生一个通过测试的、可以使用的系统。

计划项目

XP的计划过程主要针对软件开发中的两个问题:预测在交付日期前可以完成多少工作;现在和下一步该做些什么。不断的回答这两个问题,就是直接服务于如何实施及调整开发过程;与此相比,希望一开始就精确定义整个开发过程要做什么事情以及每件事情要花多少时间,则事倍功半。针对这两个问题,XP中又两个主要的相应过程:

软件发布计划(ReleasePlanning)。客户阐述需求,开发人员估算开发成本和风险。客户根据开发成本、风险和每个需求的重要性,制订一个大致的项目计划。最初的项目计划没有必要(也没有可能)非常准确,因为每个需求的开发成本、风险及其重要性都不是一成不变的。而且,这个计划会在实施过程中被不断地调整以趋精确。

周期开发计划(IterationPlanning)。开发过程中,应该有很多阶段计划(比如每三个星期一个计划)。开发人员可能在某个周期对系统进行内部的重整和优化(代码和设计),而在某个周期增加了新功能,或者会在一个周期内同时做两方面的工作。但是,经过每个开发周期,用户都应该能得到一个已经实现了一些功能的系统。而且,每经过一个周期,客户就会再提出确定下一个周期要完成的需求。在每个开发周期中,开发人员会把需求分解成一个个很小的任务,然后估计每个任务的开发成本和风险。这些估算是基于实际开发经验的,项目做得多了,估算自然更加准确和精确;在同一个项目中,每经过一个开发周期,下一次的估算都会有更过的经验、参照和依据,从而更加准确。这些简单的步骤对客户提供了丰富的、足够的信息,使之能灵活有效地调控开发进程。每过两三个星期,客户总能够实实在在地看到开发人员已经完成的需求。在XP里,没有什么“快要完成了”、“完成了90%”的模糊说法,要不是完成了,要不就是没完成。这种做法看起来好象有利有弊:好处是客户可以马上知道完成了哪些、做出来的东西是否合用、下面还要做些什么或改进什么等等;坏处是客户看到做出来的东西,可能会很不满意甚至中止合同。实际上,XP的这种做法是为了及早发现问题、解决问题,而不是等到过了几个月,用户终于看到开发完的系统了,然后才告诉你这个不行、那个变了、还要增加
哪个内容等等。

验收测试

客户对每个需求都定义了一些验收测试。通过运行验收测试,开发人员和客户可以知道开发出来的软件是否符合要求。XP开发人员把这些验收测试看得和单元测试一样重要。为了不浪费宝贵的时间,最好能将这些测试过程自动化。

频繁地小规模发布软件(SmallReleases)

每个周期(Iteration)开发的需求都是用户最需要的东西。在XP中,对于每个周期完成时发布的系统,用户都应该可以很容易地进行评估,或者已经能够投入实际使用。这样,软件开发对于客户来说,不再是看不见摸不着的东西,而是实实在在的。XP要求频繁地发布软件,如果有可能,应该每天都发布一个新版本;而且在完成任何一个改动、整合或者新需求后,就应该立即发布一个新版本。这些版本的一致性和可靠性,是靠验收测试和测试驱动的开发来保证的。

3简单设计,PairProgramming,测试驱动开发,重整和优化

XP程序员不但做为一个开发小组共同工作,还以两个人为一个小开发单元编写同一个程序。开发人员们进行简单的设计,编写单元测试后再编写符合测试要求的代码,并在满足需求的前提下不断地优化设计。

简单设计

XP中让初学者感到最困惑的就是这点。XP要求用最简单的办法实现每个小需求,前提是按照这些简单设计开发出来的软件必须通过测试。这些设计只要能满足系统和客户在当下的需求就可以了,不需要任何画蛇添足的设计,而且所有这些设计都将在后续的开发过程中就被不断地重整和优化。

在XP中,没有那种传统开发模式中一次性的、针对所有需求的总体设计。在XP中,设计过程几乎一直贯穿着整个项目开发:从制订项目的计划,到制订每个开发周期(Iteration)的计划,到针对每个需求模块的简捷设计,到设计的复核,以及一直不间断的设计重整和优化。整个设计过程是个螺旋式的、不断前进和发展的过程。从这个角度看,XP是把设计做到了极致。

PairProgramming

XP中,所有的代码都是由两个程序员在同一台机器上一起写的——这是XP中让人争议最多、也是最难实施的一点。这保证了所有的代码、设计和单元测试至少被另一个人复核过,代码、设计和测试的质量因此得到提高。看起来这样象是在浪费人力资源,但是各种研究表明事实恰恰相反。——这种工作方式极大地提高了工作强度和工作效率。

很多程序员一开始是被迫尝试这点的(XP也需要行政命令的支持)。开始时总是不习惯的,而且两个人的效率不会比一个人的效率高。这种做法的效果往往要坚持几个星期或一两个月后才能很显著。据统计,在所有刚开始PairProgramming的程序员中,90%的人在两个月以后都很认为这种工作方式更加高效。

项目开发中,每个人会不断地更换合作编程的伙伴。因此,PairProgramming不但提高了软件质量,还增强了相互之间的知识交流和更新,增强了相互之间的沟通和理解。这不但有利于个人,也有利于整个项目、开发队伍和公司。从这点看,PairProgramming不仅仅适用于XP,也适用于所有其它的软件开发方法。

测试驱动开发

反馈是XP的四个基本的价值观之一——在软件开发中,只有通过充分的测试才能获得充分的反馈。XP中提出的测试,在其它软件开发方法中都可以见到,比如功能测试、单元测试、系统测试和负荷测试等;与众不同的是,XP将测试结合到它独特的螺旋式增量型开发过程中,测试随着项目的进展而不断积累。另外,由于强调整个开发小组拥有代码,测试也是由大家共同维护的。即,任何人在往代码库中放程序(CheckIn)前,都应该运行一遍所有的测试;任何人如果发现了一个BUG,都应该立即为这个BUG增加一个测试,而不是等待写那个程序的人来完成;任何人接手其他人的任务,或者修改其他人的代码和设计,改动完以后如果能通过所有测试,就证明他的工作没有破坏愿系统。这样,测试才能真正起到帮助获得反馈的作用;而且,通过不断地优先编写和累积,测试应该可以基本覆盖全部的客户和开发需求,因此开发人员和客户可以得到尽可能充足的反馈。

重整和优化(Refactoring)

XP强调简单的设计,但简单的设计并不是没有设计的流水帐式的程序,也不是没有结构、缺乏重用性的程序设计。开发人员虽然对每个USERSTORY都进行简单设计,但同时也在不断地对设计进行改进,这个过程叫设计的重整和优化(Refactoring)。这个名字最早出现在MartinFowler写的《Refactoring:ImprovingtheDesignofExistingCode》这本书中。

Refactoring主要是努力减少程序和设计中重复出现的部分,增强程序和设计的可重用性。Refactoring的概念并不是XP首创的,它已经被提出了近30年了,而且一直被认为是高质量的代码的特点之一。但XP强调,把Refactoring做到极致,应该随时随地、尽可能地进行Refactoring,只要有可能,程序员都不应该心疼以前写的程序,而要毫不留情地改进程序。当然,每次改动后,程序员都应该运行测试程序,保证新系统仍然符合预定的要求。

4频繁地整合,集体拥有代码(CollectiveCodeOwnership),编程规范

XP开发小组经常整合不同的模块。为了提高软件质量,除了测试驱动开发和PairProgramming以外,XP要求每个人的代码都要遵守编程规范,任何人都可以修改其他人写的代码,而且所有人都应该主动检查其他人写的代码。

频繁地整合(Integration)

在很多项目中,开发人员往往很迟才把各个模块整合在一起。在这些项目中,开发人员经常在整合过程中发现很多问题,但不能肯定到底是谁的程序出了问题;而且,只有整合完成后,开发人员才开始稍稍使用整个系统,然后就马上交付给客户验收。对于客户来说,即使这些系统能够通过终验收测试,因为使用时间短,客户门心里并没有多少把握。

为了解决这些问题,XP提出,整个项目过程中,应该频繁地,尽可能地整合已经开发完的USERSTORY(每次整合一个新的USERSTORY)。每次整合,都要运行相应的单元测试和验收测试,保证符合客户和开发的要求。整合后,就发布一个新的应用系统。这样,整个项目开发过程中,几乎每隔一两天,都会发布一个新系统,有时甚至会一天发布好几个版本。通过这个过程,客户能非常清楚地掌握已经完成的功能和开发进度,并基于这些情况和开发人员进行有效地、及时地交流,以确保项目顺利完成。

集体拥有代码(CollectiveCodeOwnership)

在很多项目开发过程中,开发人员只维护自己的代码,而且很多人不喜欢其他人随意修改自己的代码。因此,即使可能有相应的比较详细的开发文档,但一个程序员却很少、也不太愿意去读其他程序员的代码;而且,因为不清楚其他人的程序到底实现了什么功能,一个程序员一般也不敢随便改动其他人的代码。同时,因为是自己维护自己的代码,可能因为时间紧张或技术水平的局限性,某些问题一直不能被发现或得到比较好的解决。针对这点,XP提倡大家共同拥有代码,每个人都有权利和义务阅读其他代码,发现和纠正错误,重整和优化代码。这样,这些代码就不仅仅是一两个人写的,而是由整个项目开发队伍共同完成的,错误会减少很多,重用性会尽可能地得到提高,代码质量是非常好。

为了防止修改其他人的代码而引起系统崩溃,每个人在修改后都应该运行测试程序。(从这点,我们可以再次看到,XP的各个惯例和规则是怎样有机地结合在一起的。)

编程规范

XP开发小组中的所有人都遵循一个统一的编程标准,因此,所有的代码看起来好像是一个人写的。因为有了统一的编程规范,每个程序员更加容易读懂其他人写的代码,这是是实现CollectiveCodeOwnership的重要前提之一。

5Metaphor(系统比喻),不加班

XP过程通过使用一些形象的比喻让所有人对系统有个共同的、简洁的认识。XP认为加班是不正常的,因为这说明关于项目进度的估计和安排有问题。

Metaphor(系统比喻)

为了帮助每个人一致清楚地理解要完成的客户需求、要开发的系统功能,XP开发小组用很多形象的比喻来描述系统或功能模块是怎样工作的。比如,对于一个搜索引擎,它的Metaphor可能就是“一大群蜘蛛,在网上四处寻找要捕捉的东西,然后把东西带回巢穴。”

不加班

大量的加班意味着原来的计划是不准确的,或者是程序远不清楚自己到底什么时候能完成什么工作。而且,开发管理人员和客户也因此无法准确掌握开发速度;开发人员也因此非常疲劳。XP认为,如果出现大量的加班现象,开发管理人员(比如Coach)应该和客户一起确定加班的原因,并及时调整项目计划、进度和资源。


XP中一些基本概念的简介

UserStory:开发人员要求客户把所有的需求写成一个个独立的小故事,每个只需要几天时间就可以完成。开发过程中,客户可以随时提出新的UserStory,或者更改以前的UserStory。

StoryEstimates和开发速度:开发小组对每个UserStory进行估算,并根据每个开发周期(Iteration)中的实际情况反复计算开发速度。这样,开发人员和客户能知道每个星期到底能开发多少UserStory。

ReleasePlan和ReleaseScope:整个开发过程中,开发人员将不断地发布新版本。开发人员和客户一起确定每个发布所包含的UserStory。

Iteration(开发周期)和IterationPlan:在一个Release过程中,开发人员要求客户选择最有价值的UserStory作为未来一两个星期的开发内容。

TheSeed:第一个开发周期(Iteration)完成后,提交给客户的系统。虽然这不是最终的产品,但它已经实现了几个客户认为是最重要的Story,开发人员将逐步在其基础上增加新的模块。

ContinuousIntegration(整合):把开发完的UserStory的模块一个个拼装起来,一步步接近乃至最终完成最终产品。

验收测试(功能测试):对于每个UserStory,客户将定义一些测试案例,开发人员将使运行这些测试案例的过程自动化。

UnitTest(单元测试):在开始写程序前,程序员针对大部分类的方法,先写出相应的测试程序。

Refactoring(重整和优化):去掉代码中的冗余部分,增加代码的可重用性和伸缩性。


小结

XP的一个成功因素是重视客户的反馈——开发的目的就是为了满足客户的需要。XP方法使开发人员始终都能自信地面对客户需求的变化。XP强调团队合作,经理、客户和开发人员都是开发团队中的一员。团队通过相互之间的充分交流和合作,使用XP这种简单但有效的方式,努力开发出高质量的软件。XP的设计简单而高效;程序员们通过测试获得客户反馈,并根据变化修改代码和设计,他们总是争取尽可能早地将软件交付给客户。XP程序员能够勇于面对需求和技术上的变化。

XP很象一个由很多小块拼起来的智力拼图,单独看每一小块都没有什么意义,但拼装好后,一幅美丽的图画就会呈现在你面前。
卖艺网
posted @ 2007-01-04 16:25 joeyeezhang 阅读(183) | 评论 (0)编辑 收藏

说到为什么我喜欢在实验室推广XP,我们先来看看几个软件过程

  首先是RUP,RUP有什么特点呢?迭代性开发,用例驱动,使用UML对软件建模,提倡事先设计好以组件为核心的体系结构(以体系结构为中心),不断的评估和测试软件质量,(使用用例)控制软件的变化。在这些原则的基础上,把软件人员分成各种角色(分析,开发,管理,测试,工具支持,配置)等等,在软件开发过程中的各种产品叫做工件(Artifact)。

  再看TSP,TSP把人员分成小组领导者、开发经理、计划经理、质量/生产经理,以及技术支持经理(注意这点和RUP的雷同),要求各个人员严格记录在软件开发过程中的每一步,比如程序的Bug率,使用的时间等等。

  最后一个是XP,XP的特点,双人编程,简单用例(User Story),Refactoring,以周为基础的迭代。持续集成,现场客户,测试驱动,自动化测试,代码同步。同样的,XP也把人员分成测试,交流人员,设计师,技术作者,客户,程序员等等。

  OK,说了这么多长篇大论,是为了把几个软件过程拿出来比较。所有的软件过程无非是为了避免风险,保证项目的成功。

  拿交通工具做比方的话,TSP就好比坐火车,由于TSP是CMM那帮子人搞的,所以TSP不强调迭代性开发。TSP强调的是质量管理和控制,通过每个人自觉自愿的记录每天的行为,从而的得到严格的项目的数据,缺乏了这种严格控制,TSP就好比火车没有轨道,一点用处也没有。而在我们实验室一帮懒懒散散的学生中搞数据,要他们每天填表,从而知道项目消耗了多少人时,Bug率为多少,不要做梦了吧,所以TSP那套方式肯定是行不通的。

  再看XP和RUP的差别,迭代性开发,两者都强调,不过两者的含义不同,在RUP中,每次迭代,强调产生的是一个个工件,比如完成了用例。而在XP中,产生的是可用的软件。为什么RUP的迭代里面可能没有产生可用的软件呢?因为RUP强调的是用例驱动和体系结构为中心,所以RUP花在设计体系结构和用例上的时间会比较多,这样带来的好处是软件的后期变更会比较少。而XP本身强调的是拥抱变化,不管三七二十一,先开发出来一个能用的再说,如果客户不满意(别忘了,XP是现场客户),Refactoring之。所以在XP的开头的时候,根本就不提倡太复杂的用例(客户在现场嘛,不懂客户的意思,现场交流啊),也不提倡过多的设计(测试驱动嘛,通不过的话Refactoring之)。

  然而RUP没有现场客户的概念,所以清晰的用例描述是RUP中很重要的一环。只有这些用例在客户和团队之间达成了共识,才能做下一步的工作,同样的,需求的变更也必须通过用例来体现,RUP很强调变更管理,就是这个意思。

  而在我们实验室做现在这个项目,不是和客户交流的问题,而是没有客户!!!

  所以,在这种程度下,我们的用例,不是要让客户理解,而是我们自己理解就足够了。而体系结构,由于你们现在不用考虑分布式,并发,事务等等一系列东西。这些东西都由J2EE做了。

  此外RUP在我们实验室很难办的一件事情是对各个阶段产生的工件的质量监控,同学们互相哈哈哈,很难对一个文档性的东西进行评价。

     那么要改善我们现在做的项目,最重要的是做什么呢?第一是,小迭代,我们现在整个软件开发周期太长了,应该缩短到2-6周以内。第二,测试,我们现在的测试很多都是手动的,需要自动化这个测试过程。第三是,快速构建,持续集成。整个软件的部署周期不能像现在这么长,不能由同学们手工构建,而必须是自动化的部署。这些都是在XP中强调的。

     RUP的不同就好比是做BUS和自己开小汽车的不同,尽管细微,但是,开小汽车更需要小心翼翼的调整方向,而公交车毕竟有线路。
   
  如果在一个大公司做部门经理的话,我更愿意采用RUP那套方式,辅之于XP的各种实践,然而在实验室,我只有退而求其次,因地制宜,XP能推广多少是多少,一些很难推广的东西比如风险管理,BUG管理只能暂时放弃了。

爱卖艺

posted @ 2007-01-04 11:54 joeyeezhang 阅读(155) | 评论 (0)编辑 收藏

软件项目经理的基本职责:

1. 制定项目计划,并根据各种变化修改项目计划
2. 实施 项目的管理、开发、质量保证 过程,确保客户的成本、进度、绩效和质量目标.
3. 制定有效的项目决策过程
4. 确保在项目生命周期中遵循是实施公司的管理和质量政策
5. 选择一个能够精确衡量项目成本、进度、质量、绩效的项目距阵
6. 风险管理
7. 招聘和培训必须的项目成员
8. 确定项目的人员组织结构.
9. 定期举行项目评估(review)会议
10.为项目所有成员提供足够的设备、有效的工具和项目开发过程
11.有效管理项目资源
爱卖艺
posted @ 2007-01-04 11:15 joeyeezhang 阅读(1156) | 评论 (0)编辑 收藏

2006年12月26日 #

首先要理解线程首先需要了解一些基本的东西,我们现在所使用的大多数操作系统都属于多任务,分时操作系统。正是由于这种操作系统的出现才有了多线程这个概念。我们使用的windows,linux就属于此列。什么是分时操作系统呢,通俗一点与就是可以同一时间执行多个程序的操作系统,在自己的电脑上面,你是不是一边听歌,一边聊天还一边看网页呢?但实际上,并不上cpu在同时执行这些程序,cpu只是将时间切割为时间片,然后将时间片分配给这些程序,获得时间片的程序开始执行,不等执行完毕,下个程序又获得时间片开始执行,这样多个程序轮流执行一段时间,由于现在cpu的高速计算能力,给人的感觉就像是多个程序在同时执行一样。
一般可以在同一时间内执行多个程序的操作系统都有进程的概念.一个进程就是一个执行中的程序,而每一个进程都有自己独立的一块内存空间,一组系统资源.在进程概念中,每一个进程的内部数据和状态都是完全独立的.因此可以想像创建并执行一个进程的系统开像是比较大的,所以线程出现了。在java中,程序通过流控制来执行程序流,程序中单个顺序的流控制称为线程,多线程则指的是在单个程序中可以同时运行多个不同的线程,执行不同的任务.多线程意味着一个程序的多行语句可以看上去几乎在同一时间内同时运行.(你可以将前面一句话的程序换成进程,进程是程序的一次执行过程,是系统运行程序的基本单位)

线程与进程相似,是一段完成某个特定功能的代码,是程序中单个顺序的流控制;但与进程不同的是,同类的多个线程是共享一块内存空间和一组系统资源,而线程本身的数据通常只有微处理器的寄存器数据,以及一个供程序执行时使用的堆栈.所以系统在产生一个线程,或者在各个线程之间切换时,负担要比进程小的多,正因如此,线程也被称为轻负荷进程(light-weight process).一个进程中可以包含多个线程.

多任务是指在一个系统中可以同时运行多个程序,即有多个独立运行的任务,每个任务对应一个进程,同进程一样,一个线程也有从创建,运行到消亡的过程,称为线程的生命周期.用线程的状态(state)表明线程处在生命周期的哪个阶段.线程有创建,可运行,运行中,阻塞,死亡五中状态.通过线程的控制与调度可使线程在这几种状态间转化每个程序至少自动拥有一个线程,称为主线程.当程序加载到内存时,启动主线程.

[线程的运行机制以及调度模型]
java中多线程就是一个类或一个程序执行或管理多个线程执行任务的能力,每个线程可以独立于其他线程而独立运行,当然也可以和其他线程协同运行,一个类控制着它的所有线程,可以决定哪个线程得到优先级,哪个线程可以访问其他类的资源,哪个线程开始执行,哪个保持休眠状态。
下面是线程的机制图:
image

线程的状态表示线程正在进行的活动以及在此时间段内所能完成的任务.线程有创建,可运行,运行中,阻塞,死亡五中状态.一个具有生命的线程,总是处于这五种状态之一:
1.创建状态
使用new运算符创建一个线程后,该线程仅仅是一个空对象,系统没有分配资源,称该线程处于创建状态(new thread)
2.可运行状态
使用start()方法启动一个线程后,系统为该线程分配了除CPU外的所需资源,使该线程处于可运行状态(Runnable)
3.运行中状态
Java运行系统通过调度选中一个Runnable的线程,使其占有CPU并转为运行中状态(Running).此时,系统真正执行线程的run()方法.
4.阻塞状态
一个正在运行的线程因某种原因不能继续运行时,进入阻塞状态(Blocked)
5.死亡状态
线程结束后是死亡状态(Dead)

同一时刻如果有多个线程处于可运行状态,则他们需要排队等待CPU资源.此时每个线程自动获得一个线程的优先级(priority),优先级的高低反映线程的重要或紧急程度.可运行状态的线程按优先级排队,线程调度依据优先级基础上的"先到先服务"原则.
线程调度管理器负责线程排队和CPU在线程间的分配,并由线程调度算法进行调度.当线程调度管理器选种某个线程时,该线程获得CPU资源而进入运行状态.

线程调度是先占式调度,即如果在当前线程执行过程中一个更高优先级的线程进入可运行状态,则这个线程立即被调度执行.先占式调度分为:独占式和分时方式.
独占方式下,当前执行线程将一直执行下去,直 到执行完毕或由于某种原因主动放弃CPU,或CPU被一个更高优先级的线程抢占
分时方式下,当前运行线程获得一个时间片,时间到时,即使没有执行完也要让出CPU,进入可运行状态,等待下一个时间片的调度.系统选中其他可运行状态的线程执行
分时方式的系统使每个线程工作若干步,实现多线程同时运行

另外请注意下面的线程调度规则(如果有不理解,不急,往下看):
①如果两个或是两个以上的线程都修改一个对象,那么把执行修改的方法定义为被同步的(Synchronized),如果对象更新影响到只读方法,那么只度方法也应该定义为同步的
②如果一个线程必须等待一个对象状态发生变化,那么它应该在对象内部等待,而不是在外部等待,它可以调用一个被同步的方法,并让这个方法调用wait()
③每当一个方法改变某个对象的状态的时候,它应该调用notifyAll()方法,这给等待队列的线程提供机会来看一看执行环境是否已发生改变
④记住wait(),notify(),notifyAll()方法属于Object类,而不是Thread类,仔细检查看是否每次执行wait()方法都有相应的notify()或notifyAll()方法,且它们作用与相同的对象 在java中每个类都有一个主线程,要执行一个程序,那么这个类当中一定要有main方法,这个man方法也就是java class中的主线程。你可以自己创建线程,有两种方法,一是继承Thread类,或是实现Runnable接口。一般情况下,最好避免继承,因为java中是单根继承,如果你选用继承,那么你的类就失去了弹性,当然也不能全然否定继承Thread,该方法编写简单,可以直接操作线程,适用于单重继承情况。至于选用那一种,具体情况具体分析。


eg.继承Thread

public class MyThread_1 extends Thread
{
public void run()
{
//some code
}
}



eg.实现Runnable接口

public class MyThread_2 implements Runnable
{
public void run()
{
//some code
}
}




当使用继承创建线程,这样启动线程:

new MyThread_1().start()



当使用实现接口创建线程,这样启动线程:

new Thread(new MyThread_2()).start()



注意,其实是创建一个线程实例,并以实现了Runnable接口的类为参数传入这个实例,当执行这个线程的时候,MyThread_2中run里面的代码将被执行。
下面是完成的例子:

public class MyThread implements Runnable
{

public void run()
{
System.out.println("My Name is "+Thread.currentThread().getName());
}
public static void main(String[] args)
{
new Thread(new MyThread()).start();
}
}




执行后将打印出:
My Name is Thread-0

你也可以创建多个线程,像下面这样

new Thread(new MyThread()).start();
new Thread(new MyThread()).start();
new Thread(new MyThread()).start();




那么会打印出:
My Name is Thread-0
My Name is Thread-1
My Name is Thread-2


看了上面的结果,你可能会认为线程的执行顺序是依次执行的,但是那只是一般情况,千万不要用以为是线程的执行机制;影响线程执行顺序的因素有几点:首先看看前面提到的优先级别


public class MyThread implements Runnable
{

public void run()
{
System.out.println("My Name is "+Thread.currentThread().getName());
}
public static void main(String[] args)
{
Thread t1=new Thread(new MyThread());
Thread t2=new Thread(new MyThread());
Thread t3=new Thread(new MyThread());
t2.setPriority(Thread.MAX_PRIORITY);//赋予最高优先级
t1.start();
t2.start();
t3.start();
}
}



再看看结果:
My Name is Thread-1
My Name is Thread-0
My Name is Thread-2



线程的优先级分为10级,分别用1到10的整数代表,默认情况是5。上面的t2.setPriority(Thread.MAX_PRIORITY)等价与t2.setPriority(10)
然后是线程程序本身的设计,比如使用sleep,yield,join,wait等方法(详情请看JDKDocument)

public class MyThread implements Runnable
{
public void run()
{
try
{
int sleepTime=(int)(Math.random()*100);//产生随机数字,
Thread.currentThread().sleep(sleepTime);//让其休眠一定时间,时间又上面sleepTime决定
//public static void sleep(long millis)throw InterruptedException (API)
System.out.println(Thread.currentThread().getName()+" 睡了 "+sleepTime);
}catch(InterruptedException ie)//由于线程在休眠可能被中断,所以调用sleep方法的时候需要捕捉异常
{
ie.printStackTrace();
}
}
public static void main(String[] args)
{
Thread t1=new Thread(new MyThread());
Thread t2=new Thread(new MyThread());
Thread t3=new Thread(new MyThread());
t1.start();
t2.start();
t3.start();
}
}



执行后观察其输出:

Thread-0 睡了 11
Thread-2 睡了 48
Thread-1 睡了 69




上面的执行结果是随机的,再执行很可能出现不同的结果。由于上面我在run中添加了休眠语句,当线程休眠的时候就会让出cpu,cpu将会选择执行处于runnable状态中的其他线程,当然也可能出现这种情况,休眠的Thread立即进入了runnable状态,cpu再次执行它。
[线程组概念]
线程是可以被组织的,java中存在线程组的概念,每个线程都是一个线程组的成员,线程组把多个线程集成为一个对象,通过线程组可以同时对其中的多个线程进行操作,如启动一个线程组的所有线程等.Java的线程组由java.lang包中的Thread——Group类实现.
ThreadGroup类用来管理一组线程,包括:线程的数目,线程间的关系,线程正在执行的操作,以及线程将要启动或终止时间等.线程组还可以包含线程组.在Java的应用程序中,最高层的线程组是名位main的线程组,在main中还可以加入线程或线程组,在mian的子线程组中也可以加入线程和线程组,形成线程组和线程之间的树状继承关系。像上面创建的线程都是属于main这个线程组的。
借用上面的例子,main里面可以这样写:

public static void main(String[] args)
{
/***************************************
ThreadGroup(String name)
ThreadGroup(ThreadGroup parent, String name)
***********************************/
ThreadGroup group1=new ThreadGroup("group1");
ThreadGroup group2=new ThreadGroup(group1,"group2");
Thread t1=new Thread(group2,new MyThread());
Thread t2=new Thread(group2,new MyThread());
Thread t3=new Thread(group2,new MyThread());
t1.start();
t2.start();
t3.start();
}




线程组的嵌套,t1,t2,t3被加入group2,group2加入group1。
另外一个比较多就是关于线程同步方面的,试想这样一种情况,你有一笔存款在银行,你在一家银行为你的账户存款,而你的妻子在另一家银行从这个账户提款,现在你有1000块在你的账户里面。你存入了1000,但是由于另一方也在对这笔存款进行操作,人家开始执行的时候只看到账户里面原来的1000元,当你的妻子提款1000元后,你妻子所在的银行就认为你的账户里面没有钱了,而你所在的银行却认为你还有2000元。
看看下面的例子:

class BlankSaving //储蓄账户
{
private static int money=10000;
public void add(int i)
{
money=money+i;
System.out.println("Husband 向银行存入了 [¥"+i+"]");
}
public void get(int i)
{
money=money-i;
System.out.println("Wife 向银行取走了 [¥"+i+"]");
if(money<0)
System.out.println("余额不足!");
}
public int showMoney()
{
return money;
}
}


class Operater implements Runnable
{
String name;
BlankSaving bs;
public Operater(BlankSaving b,String s)
{
name=s;
bs=b;



}
public static void oper(String name,BlankSaving bs)
{



if(name.equals("husband"))
{
try
{
for(int i=0;i<10;i++)
{
Thread.currentThread().sleep((int)(Math.random()*300));
bs.add(1000);
}
}catch(InterruptedException e){}
}else
{
try
{



for(int i=0;i<10;i++)
{
Thread.currentThread().sleep((int)(Math.random()*300));
bs.get(1000);
}
}catch(InterruptedException e){}
}
}
public void run()
{
oper(name,bs);
}
}
public class BankTest
{
public static void main(String[] args)throws InterruptedException
{
BlankSaving bs=new BlankSaving();
Operater o1=new Operater(bs,"husband");
Operater o2=new Operater(bs,"wife");
Thread t1=new Thread(o1);
Thread t2=new Thread(o2);
t1.start();
t2.start();
Thread.currentThread().sleep(500);
}



}




下面是其中一次的执行结果:



---------first--------------
Husband 向银行存入了 [¥1000]
Wife 向银行取走了 [¥1000]
Wife 向银行取走了 [¥1000]
Husband 向银行存入了 [¥1000]
Wife 向银行取走了 [¥1000]
Husband 向银行存入了 [¥1000]
Wife 向银行取走了 [¥1000]
Husband 向银行存入了 [¥1000]
Wife 向银行取走了 [¥1000]
Husband 向银行存入了 [¥1000]
Husband 向银行存入了 [¥1000]
Wife 向银行取走了 [¥1000]
Husband 向银行存入了 [¥1000]
Husband 向银行存入了 [¥1000]
Wife 向银行取走了 [¥1000]
Wife 向银行取走了 [¥1000]
Husband 向银行存入了 [¥1000]
Wife 向银行取走了 [¥1000]
Wife 向银行取走了 [¥1000]
Husband 向银行存入了 [¥1000]


看到了吗,这可不是正确的需求,在husband还没有结束操作的时候,wife就插了进来,这样很可能导致意外的结果。解决办法很简单,就是将对数据进行操作方法声明为synchronized,当方法被该关键字声明后,也就意味着,如果这个数据被加锁,只有一个对象得到这个数据的锁的时候该对象才能对这个数据进行操作。也就是当你存款的时候,这笔账户在其他地方是不能进行操作的,只有你存款完毕,银行管理人员将账户解锁,其他人才能对这个账户进行操作。
修改public static void oper(String name,BlankSaving bs)为public static void oper(String name,BlankSaving bs),再看看结果:

Husband 向银行存入了 [¥1000]
Husband 向银行存入了 [¥1000]
Husband 向银行存入了 [¥1000]
Husband 向银行存入了 [¥1000]
Husband 向银行存入了 [¥1000]
Husband 向银行存入了 [¥1000]
Husband 向银行存入了 [¥1000]
Husband 向银行存入了 [¥1000]
Husband 向银行存入了 [¥1000]
Husband 向银行存入了 [¥1000]
Wife 向银行取走了 [¥1000]
Wife 向银行取走了 [¥1000]
Wife 向银行取走了 [¥1000]
Wife 向银行取走了 [¥1000]
Wife 向银行取走了 [¥1000]
Wife 向银行取走了 [¥1000]
Wife 向银行取走了 [¥1000]
Wife 向银行取走了 [¥1000]
Wife 向银行取走了 [¥1000]
Wife 向银行取走了 [¥1000]




当丈夫完成操作后,妻子才开始执行操作,这样的话,对共享对象的操作就不会有问题了。
[wait and notify]
你可以利用这两个方法很好的控制线程的执行流程,当线程调用wait方法后,线程将被挂起,直到被另一线程唤醒(notify)或则是如果wait方法指定有时间得话,在没有被唤醒的情况下,指定时间时间过后也将自动被唤醒。但是要注意一定,被唤醒并不是指马上执行,而是从组塞状态变为可运行状态,其是否运行还要看cpu的调度。
事例代码:

class MyThread_1 extends Thread
{
Object lock;
public MyThread_1(Object o)
{
lock=o;
}
public void run()
{
try
{
synchronized(lock)
{
System.out.println("Enter Thread_1 and wait");
lock.wait();
System.out.println("be notified");
}
}catch(InterruptedException e){}
}
}
class MyThread_2 extends Thread
{
Object lock;
public MyThread_2(Object o)
{
lock=o;
}
public void run()
{
synchronized(lock)
{
System.out.println("Enter Thread_2 and notify");
lock.notify();
}
}
}
public class MyThread
{
public static void main(String[] args)
{
int[] in=new int[0];//notice
MyThread_1 t1=new MyThread_1(in);
MyThread_2 t2=new MyThread_2(in);
t1.start();
t2.start();
}
}

执行结果如下:
Enter Thread_1 and wait
Enter Thread_2 and notify
Thread_1 be notified


可能你注意到了在使用wait and notify方法得时候我使用了synchronized块来包装这两个方法,这是由于调用这两个方法的时候线程必须获得锁,也就是上面代码中的lock[],如果你不用synchronized包装这两个方法的得话,又或则锁不一是同一把,比如在MyThread_2中synchronized(lock)改为synchronized(this),那么执行这个程序的时候将会抛出java.lang.IllegalMonitorStateException执行期异常。另外wait and notify方法是Object中的,并不在Thread这个类中。最后你可能注意到了这点:int[] in=new int[0];为什么不是创建new Object而是一个0长度的数组,那是因为在java中创建一个0长度的数组来充当锁更加高效。

Thread作为java中一重要组成部分,当然还有很多地方需要更深刻的认识,上面只是对Thread的一些常识和易错问题做了一个简要的总结,若要真正的掌握java的线程,还需要自己多做总结

posted @ 2006-12-26 22:45 joeyeezhang 阅读(140) | 评论 (0)编辑 收藏

2006年12月22日 #

synchronized 关键字,它包括两种用法:synchronized 方法和 synchronized 块。
1. synchronized 方法:通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如:
public synchronized void accessVal(int newVal);
synchronized 方法控制对类成员变量的访问:每个类实例对应一把锁,每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行,否则所属线程阻塞,方法一旦执行,就独占该锁,直到从该方法返回时才将锁释放,此后被阻塞的线程方能获得该锁,重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例,其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态(因为至多只有一个能够获得该类实例对应的锁),从而有效避免了类成员变量的访问冲突(只要所有可能访问类成员变量的方法均被声明为 synchronized)。
在 Java 中,不光是类实例,每一个类也对应一把锁,这样我们也可将类的静态成员函数声明为 synchronized ,以控制其对类的静态成员变量的访问。
synchronized 方法的缺陷:若将一个大的方法声明为synchronized 将会大大影响效率,典型地,若将线程类的方法 run() 声明为 synchronized ,由于在线程的整个生命期内它一直在运行,因此将导致它对本类任何 synchronized 方法的调用都永远不会成功。当然我们可以通过将访问类成员变量的代码放到专门的方法中,将其声明为 synchronized ,并在主方法中调用来解决这一问题,但是 Java 为我们提供了更好的解决办法,那就是 synchronized 块。
2. synchronized 块:通过 synchronized关键字来声明synchronized 块。语法如下:
synchronized(syncObject)
synchronized 块是这样一个代码块,其中的代码必须获得对象 syncObject (如前所述,可以是类实例或类)的锁方能执行,具体机制同前所述。由于可以针对任意代码块,且可任意指定上锁的对象,故灵活性较高。

notify()及notifyAll()是Object的方法,与Object的wait()方法配合使用,而且这三个方法必须在同步块中调用.

如下:
在线程1中执行如下代码
...
synchronized(obj1)      //1.进入同步块
{
    try {
    ...
    obj1.wait();        //2.进入暂停状态
    }catch (InterruptedException exp) {}
}

1.当前同步对象(monitor)为obj1,obj1是任一实例,若是同步方法,则同步对象是this.进入同步块后,obj1为锁定状态,锁定状态对obj1本身无任何影响,而其它线程执行到同一代码时,因不能获得锁,处于Block状态,一旦解锁,被block的线程自动继续执行.
2.调用obj1.wait()有两个作用,一是使线程进入等待状态,二是解锁obj1,这时被block的线程将获得锁.线程1要退出等待必须要由其它线程显式的调用obj1.notify()或notifyAll()方法.

...
synchronized(obj1)
{
    ...
    obj1.notify();    //3. 向wait的线程发通知信息
    ...
}
...

若其它线程执行到此时,线程1处于wait状态,则wait状态解除,解除后,若线程1若得到锁就能继续执行,若有多个线程处于obj1的wait状态,notify将随机选一个线程激活,而notifyAll是同时解除所有的wait状态.
notifyAll()让等待某个对象K的所有线程离开阻塞状态,
notify()随机地选取等待某个对象K的线程,让它离开阻塞状态。

notify(),notifyAll()非常有用,在一个synchronized(lockObj)块中当调用lockObj.wait()时,线程就已经将锁放开来了,这时当另外一个线程调用lockObj.notify()时,等待的线程就会继续执行下去了。这是一种非常高效的线程同步机制。如果没有他,用sleep()来同步的话就太浪费时间了。
一个简单的例子:
thread1 receive data
thread2 pase received data
lockObj是buf
当buf中没有数据时,thread2中调用buf.wait释放锁,让thread1有机会执行。
当thread1收到数据时,调用buf.notify()通知thread1去处理收到的数据。

如果在同步块入口点阻塞,不须其它线程调用notify(),调了也没效果,同步块能自动获得锁

如果是wait造成了阻塞,须用notfiy()激活,这两个方法是配合使用

notify、notifyAll、wait :
主要是为了解决持有监视器钥匙的线程暂停等待另一线程完成时可能发生死锁的问题。wait()方法使调用线程等待,直到发生超时或另一线程调用同一对象的notify()或notifyAll()方法。wait() 方法的用法如下:wait()或wait(long timeoutPeriodInMilliseconds)前者等待被通知,后者等待超时或通知。线程调用wait()方法时,释放所持有的钥匙让另一等待线程进入监视区。notify()方法只唤醒一个等待线程,而notifyAll()唤醒所有等待该监视器的线程。注意,这些方法只能在监视区内调用。否则会输出一种RuntimeException类型的IllegaMonitorStateException异常状态。
够详细清楚的吧。
      总之wait()让线程等待,notify()和notifyall()激活某个等待线程,其实就是撤销该线程的中断状态,从而使他们有机会再次运行
       有时会遇到如下问题,程序的一部分在写数据,另一部分读数据,但有时会出现读部分超前写部分,
这就是典型的产生者/消耗者问题.
   .wait:是一个线程睡眠,直到在相同的对象上调用notify或notifyAll
   .notify:启动第一个在相同对象调用wait的线程
   .notifyAll:启动在相同的对象调用wait的所有线程

爱卖艺

posted @ 2006-12-22 23:02 joeyeezhang 阅读(266) | 评论 (0)编辑 收藏

2006年12月21日 #

线性表,链表,哈希表是常用的数据结构,在进行Java开发时,JDK已经为我们提供了一系列相应的类来实现基本的数据结构。这些类均在java.util包中。本文试图通过简单的描述,向读者阐述各个类的作用以及如何正确使用这些类。

Collection
List
│├LinkedList
│├ArrayList
│└Vector
│ └Stack
Set
Map
├Hashtable
├HashMap
└WeakHashMap

Collection接口
  Collection是最基本的集合接口,一个Collection代表一组Object,即Collection的元素(Elements)。一些Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类,Java SDK提供的类都是继承自Collection的“子接口”如List和Set。
  所有实现Collection接口的类都必须提供两个标准的构造函数:无参数的构造函数用于创建一个空的Collection,有一个Collection参数的构造函数用于创建一个新的Collection,这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection。
  如何遍历Collection中的每一个元素?不论Collection的实际类型如何,它都支持一个iterator()的方法,该方法返回一个迭代子,使用该迭代子即可逐一访问Collection中每一个元素。典型的用法如下:
    Iterator it = collection.iterator(); // 获得一个迭代子
    while(it.hasNext()) {
      Object obj = it.next(); // 得到下一个元素
    }

  由Collection接口派生的两个接口是List和Set。

List接口
  List是有序的Collection,使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引(元素在List中的位置,类似于数组下标)来访问List中的元素,这类似于Java的数组。
和下面要提到的Set不同,List允许有相同的元素。
  除了具有Collection接口必备的iterator()方法外,List还提供一个listIterator()方法,返回一个ListIterator接口,和标准的Iterator接口相比,ListIterator多了一些add()之类的方法,允许添加,删除,设定元素,还能向前或向后遍历。
  实现List接口的常用类有LinkedList,ArrayList,Vector和Stack。

LinkedList类
  LinkedList实现了List接口,允许null元素。此外LinkedList提供额外的get,remove,insert方法在LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈(stack),队列(queue)或双向队列(deque)。
  注意LinkedList没有同步方法。如果多个线程同时访问一个List,则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List:
    List list = Collections.synchronizedList(new LinkedList(...));

ArrayList类
  ArrayList实现了可变大小的数组。它允许所有元素,包括null。ArrayList没有同步。
size,isEmpty,get,set方法运行时间为常数。但是add方法开销为分摊的常数,添加n个元素需要O(n)的时间。其他的方法运行时间为线性。
  每个ArrayList实例都有一个容量(Capacity),即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加,但是增长算法并没有定义。当需要插入大量元素时,在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。
  和LinkedList一样,ArrayList也是非同步的(unsynchronized)。

Vector类
  Vector非常类似ArrayList,但是Vector是同步的。由Vector创建的Iterator,虽然和ArrayList创建的Iterator是同一接口,但是,因为Vector是同步的,当一个Iterator被创建而且正在被使用,另一个线程改变了Vector的状态(例如,添加或删除了一些元素),这时调用Iterator的方法时将抛出ConcurrentModificationException,因此必须捕获该异常。

Stack 类
  Stack继承自Vector,实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop方法,还有peek方法得到栈顶的元素,empty方法测试堆栈是否为空,search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。

Set接口
  Set是一种不包含重复的元素的Collection,即任意的两个元素e1和e2都有e1.equals(e2)=false,Set最多有一个null元素。
  很明显,Set的构造函数有一个约束条件,传入的Collection参数不能包含重复的元素。
  请注意:必须小心操作可变对象(Mutable Object)。如果一个Set中的可变元素改变了自身状态导致Object.equals(Object)=true将导致一些问题。

Map接口
  请注意,Map没有继承Collection接口,Map提供key到value的映射。一个Map中不能包含相同的key,每个key只能映射一个value。Map接口提供3种集合的视图,Map的内容可以被当作一组key集合,一组value集合,或者一组key-value映射。

Hashtable类
  Hashtable继承Map接口,实现一个key-value映射的哈希表。任何非空(non-null)的对象都可作为key或者value。
  添加数据使用put(key, value),取出数据使用get(key),这两个基本操作的时间开销为常数。
Hashtable通过initial capacity和load factor两个参数调整性能。通常缺省的load factor 0.75较好地实现了时间和空间的均衡。增大load factor可以节省空间但相应的查找时间将增大,这会影响像get和put这样的操作。
使用Hashtable的简单示例如下,将1,2,3放到Hashtable中,他们的key分别是”one”,”two”,”three”:
    Hashtable numbers = new Hashtable();
    numbers.put(“one”, new Integer(1));
    numbers.put(“two”, new Integer(2));
    numbers.put(“three”, new Integer(3));

  要取出一个数,比如2,用相应的key:
    Integer n = (Integer)numbers.get(“two”);
    System.out.println(“two = ” + n);

  由于作为key的对象将通过计算其散列函数来确定与之对应的value的位置,因此任何作为key的对象都必须实现hashCode和equals方法。hashCode和equals方法继承自根类Object,如果你用自定义的类当作key的话,要相当小心,按照散列函数的定义,如果两个对象相同,即obj1.equals(obj2)=true,则它们的hashCode必须相同,但如果两个对象不同,则它们的hashCode不一定不同,如果两个不同对象的hashCode相同,这种现象称为冲突,冲突会导致操作哈希表的时间开销增大,所以尽量定义好的hashCode()方法,能加快哈希表的操作。
  如果相同的对象有不同的hashCode,对哈希表的操作会出现意想不到的结果(期待的get方法返回null),要避免这种问题,只需要牢记一条:要同时复写equals方法和hashCode方法,而不要只写其中一个。
  Hashtable是同步的。

HashMap类
  HashMap和Hashtable类似,不同之处在于HashMap是非同步的,并且允许null,即null value和null key。,但是将HashMap视为Collection时(values()方法可返回Collection),其迭代子操作时间开销和HashMap的容量成比例。因此,如果迭代操作的性能相当重要的话,不要将HashMap的初始化容量设得过高,或者load factor过低。

WeakHashMap类
  WeakHashMap是一种改进的HashMap,它对key实行“弱引用”,如果一个key不再被外部所引用,那么该key可以被GC回收。

总结
  如果涉及到堆栈,队列等操作,应该考虑用List,对于需要快速插入,删除元素,应该使用LinkedList,如果需要快速随机访问元素,应该使用ArrayList。
  如果程序在单线程环境中,或者访问仅仅在一个线程中进行,考虑非同步的类,其效率较高,如果多个线程可能同时操作一个类,应该使用同步的类。
  要特别注意对哈希表的操作,作为key的对象要正确复写equals和hashCode方法。
  尽量返回接口而非实际的类型,如返回List而非ArrayList,这样如果以后需要将ArrayList换成LinkedList时,客户端代码不用改变。这就是针对抽象编程。

posted @ 2006-12-21 22:48 joeyeezhang 阅读(148) | 评论 (0)编辑 收藏

仅列出标题  下一页