[ZT]Design Patterns

from http://homeofcox-cs.blogspot.com/2010/08/design-patterns.html

Design Patterns
Design Patterns - Elements of Reusable Object-Oriented Software. This is a classical book. The authors won ACM 2010 SIGSOFT outstanding research award for their contribution to software engineering for. The four authors are classed the GoF (Gang of Four). The design patterns in their book is called the GoF patterns.

Design patterns are solutions abstracted from repeatedly occurring design problems and can be reused in similar situations. Each has a pattern name, associated problem, solution and consequence.

Some design patterns are bounded to languages features, so is easier to implement in some languages than the others. For example, the Template pattern is easy to do in C++ and Java, since C++ provides template and Java provides generics.

In this book, designed patterns are divided into 3 categories based on purpose. The following notes are extracted from the book.

A. Creational

Class:

1. Factory method
Define an interface for creating an object, but let subclasses decide which class to instantiate. It lets a class defer instantiation to subclasses.

Object:

2. Abstract Factory
Provide an interface for creating families of related or dependent objects w/o specifying their concrete classes.

Isn't this the interface concept in C++/Java? Obviously it's related to polymorphism.

3. Builder
Separate the construction of a complex object from its representation so that the same construction process can create different representations.

4. Prototype
Specify the kinds of objects to create using a prototypical instance, and create new objects by copying this prototype.

5. Singleton
Ensure a class only has one instance, and provide a global point of access to it.

B. Structural

Class:

6. Adapter (class)
Convert the interface of a class into another interface clients expect. It lets classes work together that couldn't otherwise because of incompatible interfaces.

Object:

7. Adapter (object)

8. Bridge
Decouple an abstraction from its implementation so that the two can vary independently.

This is the abstraction and encapsulation principles of OOP.

9. Composite
Compose objects into tree structures to represent part-whole hierarchies. It lets clients treat individual objects and compositions of objects uniformly.

OOP uses inheritance for IS-A relationship, and uses composition for HAS-A relationship.

10. Decorator
Attach additional responsibilities to an object dynamically. It provides a flexible alternative to subclassing for extending functionality.

11. Facade
Provide a unified interface to a set of interfaces in a subsystem. Facade defines a higher-level interface that makes the subsystem easier to use.

12. Flyweight
Use sharing to support large numbers of fine-grained objects efficiently.

13. Proxy
Provide a surrogate or placeholder for another object to control access to it.

C. Behavioral

Class:

14. Interpreter
Given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language.

Sounds related to compiler/interpreter.

15. Template method
Define the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template method lets subclasses redefine certain steps of an algorithm w/o changing the algorithm's structure.

Object:

16. Chain of Responsibility
Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. Chain the receiving objects and pass the request along the chain until an object handles it.

One example to this is to catch a series of exceptions in C++/Java.

17. Command
Encapsulate a request as an object, thereby letting you parameterize clients with different requests, queue or log requests, and support undoable operations.

18. Iterator
Provide a way to access the elements of an aggregate object sequentially w/o exposing its underlying representation.

This occurs abundantly in C++/Java.

19. Mediator
Define an object that encapsulates how a set of objects interact. It promotes loose coupling by keeping objects from referring to each other explicitly, and it lets you vary their interaction independently.

20. Memento
W/o violating encapsulation, capture and externalize an object's internal state so that the object can be restored to this state later.

21. Observer
Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.

For example, Java uses wait(), notify() and notifyAll() methods for threads communication.

22. State
Allow an object to alter its behavior when its internal state changes. It will appear to change it class.

One example for this is the workflow state management as in my work.

23. Strategy
Define a family of algorithms, encapsulate each one, and make them interchangeable. It lets the algorithm vary independently from clients that use it.

24. Visitor
Represent an operation to be performed on the elements of an object structure. Visitor lets you define a new operation w/o changing the classes of the elements on which it operates.

The famous MVC is not included in list because it's a combination of multiple patterns. Use Smalltalk MVC as an example. The VC relationship uses the Strategy pattern. MVC also uses Factory method to specify the default controller class for a view, and Decorator pattern to add scrolling to a view.

A new comer at OOD can start with the simplest and most common patterns:
Creational: Abstract Factory, Factory
Structural: Adapter, Composite, Decorator
Behavioral: Observer, Strategy, Template(! Yeah, this is behavioral, not structural)

Seems like I already had experience with at least these design patterns:
Creational: Singleton, Factory
Structural: Adapter, Bridge, Composite
Behavioral: Interpreter, Template, Chain of Responsibility, Iterator, Observer, State

[1] Amazon: Design patterns. By Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides. QA 76.64 .D47 1994.
[2] Wiki - design patterns. Short but comprehensive list of design patterns from different sources.
[3] Design pattern implementation in C# and VB.NET. Good link with real code examples. E.g., load balancer using the Singleton pattern.

[ZT]Log4j源代码阅读—Logger创建

from http://blog.csdn.net/ifeegoo/archive/2009/01/09/3736210.aspx

Log4j源代码阅读—Logger创建 收藏
一、 Log4j中Logger的层次结构

     Log4j中的Logger是以一个双向树的结构来组织的,但是Log4j却不是用通常使用的叶子结点和树枝结点来组织的。Log4j中使用了虚拟结点(ProvisionNode)和Logger(Logger)结点两种组织树的结构。

     用户真正创建的Logger结点用真正的Logger结点表示,而Logger结点的祖先却可能不是真正的Logger,为了提升Log4j的效率这里用一个简单的Vector来代替。

     ProvisionNode继承至Vector,并提供了一个接受一个Logger的构造方法。在Log4j的层次结构中仅仅是一个站位符。注意:ProvisionNode保存所有子Logger的实例。

     如果一个Logger的父Logger为虚拟结点(ProvisionNode),则其父Logger为RootLogger。

二、 Log4j中层次结构的作用

    1、 使每一个层次中确定的结点只有一个Logger实例,减少Logger的内存消耗。
    2、 使层次底层的Logger可以基层其祖先的等级。不用每个Logger都设置等级,并在底层Logger没有设置等级的情况下,可以一次性从祖先Logger中直接将Logger关闭(将祖先Logger的等级设为OFF)。

    实现方法:从自己开始向祖先方法访问各Logger的等级,直到访问到一个不为空的。如果父Logger为虚拟结点(ProvisionNode),则其父Logger为RootLogger。
    3、 使层次底层的Logger可以基层其祖先的Appender。不用每个Logger都设置Appender,并在底层Logger没有设置Appender的情况下,可以一次性从祖先Logger中直接将更换Logger的Appender。

    实现方法:从自己开始向祖先方法访问各Logger的Appenders。如果继承属性(additive)为false,则在调用了自己所有的Appender后,就直接跳出循环。

三、 Log4j中Logger的创建

    1、 所有Logger的创建最总都会发送到接口LoggerRepository的getLogger()方法中。Log4j中对此接口的实现是Hierarchy。Hierarchy中提供的创建过程如下:

    2、 判断在Logger容器中是否已经存在此名称的Logger。可能有如下三种情况

        1)、不存在,已用工厂方法创建一个新Logger,设置Logger的repository属性,将Logger放入Logger容器中,调用updateParents()方法更新Logger的层次结构。

        2)、存在且类型为Logger,直接返回该Logger。

        3)、存在且类型为ProvisionNode,设置Logger的repository属性,将Logger放入Logger容器中,调用updateChildren()方法和updateParents()方法更新Logger的层次结构。

    3、 updateParents(Logger)方法。更新父Logger的层次结构。

    尝试取得祖先Logger的实例,可能存在如下情况

        1)、如果父Logger存在,且类型为Logger,则设置为本Logger的父Logger。跳出循环。

        2)、如果父Logger存在,且类型为ProvisionNode,则将本Logger添加到ProvisionNode中,然后继续循环。

        3)、如果父Logger不存在,就创建相应的ProvisionNode,则将本Logger添加到ProvisionNode中,然后继续循环。

        注意:当时2、3情况时继续循环非常重要,这是维系Logger等级的一个重要方法。这样的结果是“ProvisionNode保存所有子Logger的实例。”

    4、 updateChildren(ProvisionNode,Logger)方法。

    遍历ProvisionNode中所有的Logger,将所有没有正常连接到自己真正的父Logger上的Logger的父Logger设置为新建的用以替代ProvisionNode的Logger。



四、 Log4j中Log层次总揽

    1、 如果一个Logger的所有父Logger类型为Logger:本Logger的父Logger直接指向父Logger。

    2、 如果一个Logger的所有父Logger类型为ProvisionNode:本Logger的父Logger指向RootLogger。

    3、 如果一个Logger的父Logger类型为ProvisionNode,但是祖先Logger中存在Logger。本Logger的父Logger指向所有祖先中最近的一个Logger。

五、 Log4j中Log的打印过程

    以Info()方法解析Log的打印过程。使用ConsoleAppender和PatternLayout。

    1、 首先调用LoggerRepository接口的isDisabled()方法,通过和设置的Threshold等级比较,判断本层次的Log等级(在Info()方法中是Level.INFO_INT)能否打印。如果不可以就直接退出。

    2、 调用getEffectiveLevel()方法遍历Logger的等级结构,找出本Logger的等级。并和本层次的Log等级(在Info()方法中是Level.INFO)比较,判断本Logger能否打印这个层次的Log。如果可以打印就调用forcedLog()方法。forcedLog()方法通过传入得参数生成一个LoggingEvent实例,然后调用callAppenders()方法。

    3、 callAppenders(LoggingEvent)方法通过AppenderAttachableImpl类,先遍历本Logger中所有的Appender并调用相应的doAppend()方法。如果本Logger关闭了继承开关,就直接退出循环,否则依次遍历所有祖先的Appender。最后判断写Log的次数,如果等于0就打印没有Appender错误履历。

    4、 AppenderAttachableImlp类实现了AppenderAttachable接口,并提供了一个Appender的聚集,和遍历聚集的方法appendLoopOnAppenders(LoggingEvent)。通过调用该方法可以以LoggingEvent为参数调用聚集中所有的Appender的doAppend方法打印履历。

    5、 ConsoleAppender的doAppend()方法的实现在其祖先类AppenderSkeleton上,在doAppend()方法中,首先判断Appender是否已经关闭,如果已经关闭就打印一条错误履历并返回。然后比较Appender的Threshold等级,如果不通过就直接返回。调用Filter对象进行Log过滤。如果不通过就直接放回。然后调用append()方法。

    6、 append()方法在ConsoleAppender的父类WriterAppender类中实现,它调用了本地的两个方法,checkEntryCoditions()判断Appender是否关闭,是否有Layout,输出的字符串是否为空。subAppned()方法实现真正的打印。

    7、 subAppend()方法首先调用Layout格式化输出字符串,然后输出。在判断Layout是否忽略Throwable,如果不忽略掉用event.getThrowableStrRep()方法获取堆栈信息,然后答应。最后判断Appender是否要立即刷新输入,如果是就刷新输出。

    8、 Over,结束一次完整的Log打印过程。不过怎么少了解释器的调用????

    9、 原来,还有Layout没有看。在PatternLayout类的format()方法中,PatternLayout类会将LoggingEvent交给PatternConverter抽象类的format()方法来处理。这个抽象类的format方法中,调用了抽象方法convert(),这个方法最简单的实现时在PatternParser.java的BasicPatternConverter类中。在BasicPatternConverter的convert方法的末尾调用了LoggingEvent的getRenderedMessage()方法,看名字就知道了,在这里进行对象的解释。

    10、 在LoggingEvent.getRenderedMessage()方法中,首先判断message是否是个字符串,如果是就直接返回String,如果不是就判断Logger的容器是否实现了RendererSupport接口。如果Logger容器实现了RendererSupport接口,就调用接口的getRendererMap()方法获取Renderer的一个聚集RendererMap,并调用他的findAndRender()方法。

    11、 RendererMap中的findAndRender()方法中,用message的class对象去掉用get()方法,以获取也这个类对应的Renderer。get()方法会从下向上依次查找RendererMap中是否有对应的Renderer,如果有就直接退出,否则返回defaultRenderer实例(调用对象的toString()方法)。

    12、 获取Renderer实例后,根据“面对抽象编程,而不面对实现编程。”显然我们使用ObjectRenderer接口,调用方法doRender(),解析对象,并返回一个String对象。

    13、 over!

jmap+ PermGen space for JVM memory

from http://blog.csdn.net/xiaojianpitt/archive/2008/11/11/3276790.aspx

 PermGen space

PermGen space的全称是Permanent Generation space,是指内存的永久保存区域OutOfMemoryError: PermGen space从表面上看就是内存益出,解决方法也一定是加大内存。说说为什么会内存益出:这一部分用于存放Class和Meta的信息,Class在被 Load的时候被放入PermGen space区域,它和和存放Instance的Heap区域不同,GC(Garbage Collection)不会在主程序运行期对PermGen space进行清理,所以如果你的APP会LOAD很多CLASS的话,就很可能出现PermGen space错误。这种错误常见在web服务器对JSP进行pre compile的时候。 如果你的WEB APP下都用了大量的第三方jar, 其大小 超过了jvm默认的大小(4M)那么就会产生此错误信息了。
解决方法: 手动设置MaxPermSize大小
改正方法:-Xms256m -Xmx256m -XX:MaxNewSize=256m -XX:MaxPermSize=256m

 

修改TOMCAT_HOME/bin/catalina.sh
JAVA_OPTS="-server -XX:PermSize=64M -XX:MaxPermSize=128m
建议:将相同的第三方jar文件移置到tomcat/shared/lib目录下,这样可以达到减少jar 文档重复占用内存的目的。

Sun文档是这样解释的:

java.lang.OutOfMemoryError: PermGen space

The detail message PermGen space indicates that the permanent generation is full. The permanent generation is the area of the heap where class and method objects are stored. If an application loads a very large number of classes, then the size of the permanent generation might need to be increased using the -XX:MaxPermSize option.

Interned java.lang.String objects are also stored in the permanent generation. The java.lang.String class maintains a pool of strings. When the intern method is invoked, the method checks the pool to see if an equal string is already in the pool. If there is, then the intern method returns it; otherwise it adds the string to the pool. In more precise terms, the java.lang.String.intern method is used to obtain the canonical representation of the string; the result is a reference to the same class instance that would be returned if that string appeared as a literal. If an application interns a huge number of strings, the permanent generation might need to be increased from its default setting.

When this kind of error occurs, the text String.intern or ClassLoader.defineClass might appear near the top of the stack trace that is printed.

The jmap -permgen command prints statistics for the objects in the permanent generation, including information about internalized String instances. See 2.6.4 Getting Information on the Permanent Generation.

下面是某人遇到的问题:

SUN JDK+Tomcat 5.5.20运行服务的时候遇到问题,服务器跑几天后就会挂掉,并报java.lang.OutOfMemoryError: PermGen space异常。

发现很多人把问题归因于: spring,hibernate,tomcat,因为他们动态产生类,导致JVM中的permanent heap溢出 。然后解决方法众说纷纭,有人说升级 tomcat版本到最新甚至干脆不用tomcat。还有人怀疑spring的问题,在spring论坛上讨论很激烈,因为spring在AOP时使用CBLIB会动态产生很多类。

但问题是为什么这些王牌的开源会出现同一个问题呢,那么是不是更基础的原因呢?tomcat在Q&A很隐晦的回答了这一点。(Why does the memory usage increase when I redeploy a web application? Because the Classloader (and the Class objects it loaded) cannot be recycled. They are stored in the permanent heap generation by the JVM, and when you redepoy a new class loader is created, which loads another copy of all these classes. This can cause OufOfMemoryErrors eventually. )

于是有人对更基础的JVM做了检查,发现了问题的关键。原来SUN 的JVM把内存分了不同的区,其中一个就是permanent区用来存放用得非常多的类和类描述。本来SUN设计的时候认为这个区域在JVM启动的时候就固定了,但他没有想到现在动态会用得这么广泛。而且这个区域有特殊的垃圾收回机制,现在的问题是动态加载类到这个区域后,gc根本没办法回收!

对这个bug最彻底的解决办法就是不要用SUN的JDK,而改用BEA的 JRokit.

 

在tomcat中redeploy时出现outofmemory的错误.

可以有以下几个方面的原因:

1,使用了proxool,因为proxool内部包含了一个老版本的cglib.

2, log4j,最好不用,只用common-logging

3, 老版本的cglib,快点更新到最新版。

4,更新到最新的hibernate3.2
3、 这里以tomcat环境为例,其它WEB服务器如jboss,weblogic等是同一个道理。

 

二、java.lang.OutOfMemoryError: Java heap space
Heap size 设置
JVM堆的设置是指java程序运行过程中JVM可以调配使用的内存空间的设置.JVM在启动的时候会自动设置Heap size的值,
其初始空间(即-Xms)是物理内存的1/64,最大空间(-Xmx)是物理内存的1/4。可以利用JVM提供的-Xmn -Xms -Xmx等选项可
进行设置。Heap size 的大小是Young Generation 和Tenured Generaion 之和。
提示:在JVM中如果98%的时间是用于GC且可用的Heap size 不足2%的时候将抛出此异常信息。
提示:Heap Size 最大不要超过可用物理内存的80%,一般的要将-Xms和-Xmx选项设置为相同,而-Xmn为1/4的-Xmx值。
解决方法:手动设置Heap size
修改TOMCAT_HOME/bin/catalina.sh
在“echo "Using CATALINA_BASE:   $CATALINA_BASE"”上面加入以下行:
JAVA_OPTS="-server -Xms800m -Xmx800m   -XX:MaxNewSize=256m"

三、实例,以下给出1G内存环境下java jvm 的参数设置参考:

JAVA_OPTS="-server -Xms800m -Xmx800m  -XX:PermSize=64M -XX:MaxNewSize=256m -XX:MaxPermSize=128m -Djava.awt.headless=true "


针对Tomcat,如果Tomcat下面有多个应用,尽可能的把lib下共用的jar文件放到Tomcat的lib下,发布速度和运行速度上也有所提升。

 

题外话:经常看到网友抱怨tomcat的性能不如...,不稳定等,其实根据笔者几年的经验,从"互联星空“到现在的房产门户网,我们 均使用tomcat作为WEB服务器,每天访问量百万多,tomcat仍然运行良好。建议大家有问题多从自己程序入手,多看看java的DOC文档。

参考文档:http://blogs.sun.com/jonthecollector/entry/presenting_the_permanent_generation

addon ,http://www.oracle.com/technetwork/java/gc-tuning-5-138395.html

more on this, http://blogs.sun.com/jonthecollector/

你的职场定位准确吗 [ZT]

from http://blog.csdn.net/ycl111/archive/2005/02/02/277668.aspx

1972年,美国当代营销大师阿尔·里斯与杰克·特劳特在美国《广告时代》杂志上撰写的文章《定位新纪元》,首次提到了“定位”这个概念。而在今天,“定位”两字已是营销学者和营销人员在做营销战略和规划时的专业词汇。定位法则带给营销者们的是一次观念上的革新,如果结合职业生涯,同样也会给我们带来许多启示。

    资源法则。

    资源是成功的基础条件。在生活中,大部分资源以物质形态出现,如金钱以及其他所有能看得见的财产;一些资源以非物质形态出现,如知识、技能、思想、精神、理念以及自身的素质等;还有的资源介于两者之间,如人际关系、父母的传承或特殊的机遇等等。假如月收入是一百块,那就表明所拥有的资源在一百块的水平上;假如月薪是一万块,那就表明所拥有的资源处在一万块的水平,包括能力、朋友圈子以及知识等。资源越使用它,它增值越快。比如说朋友资源,越爱结交朋友的人,朋友就会越多,结交新朋友的机会也越大,成功的机会也越多。

    此外,时间是一种需要特别珍惜的资源。合理地利用时间,做该做的事,就会离成功越来越近。

    领先法则。

    做得更好不如成为第一优越。首创品牌通常可以保持领先地位,原因是它们往往就是该类产品的代名词。在市场经济中,每个人也同样是商品,必须遵守这个法则。可在现实生活中,许多人不想当第一,或者不知如何当第一。他们往往这样想:公司也不是我的,何必干得那么卖力。 还有一种想法:工资又少,待遇又低,等找到待遇好的公司再“玩命”干。

    第一种人,不管干什么工作都不可能是最好的,因为他们没有积极主动地工作;第二种人,他们也许很有才能,但不想发挥。时间一长,很可能养成不好的工作态度,影响以后的职业发展。因此,一定要明确知道自己喜欢干哪类工作,选准方向后,就可以在该行业不断地积累资源,最终走向成功。

    长效法则。

    不要只注重“杀鸡取卵”的短期效果。一个企业有短期的销售目标,也会有长期的发展计划。职场中人也一样,不但要有近期目标,也要有长远打算。许多人之所以不能成功、不能实现自己的梦想,往往并不是缺少能力,而是缺少正确的方向和明确的目标。成功者与平庸者的区别就在于:成功者始终有一个明确的目标、清晰的方向和十足的信心;平庸者却终日浑浑噩噩、优柔寡断,迈不出决定性的第一步。

    牺牲法则。

    人的欲望往往是无限的,如果不能合理地利用自己的欲望,就会变成它的奴隶。人生如果想要成功,就应该学会放弃。

    坦诚法则。

    承认不足并将缺点转化成优点。做事先做人,把自己培养成一个道德高尚的人,不管事业成功与否,最起码人生是成功的。不断地改进自己的短处,才能不断地走向完美。需要注意的是:坦诚法则要灵活运用,否则会弄巧成拙。

    成功法则。

    用“成功”搏取成功。对于刚刚开始奋斗的创业者来说,营造成功者的形象尤其重要。对于形象来说,衣物的质量远比数量更为重要。检查一下衣橱经常会发现,有很多衣服只穿过几次,如果付两倍的价钱买一半的数量时,会发现很合算,并始终觉得自己处于一种最佳状态。

    失败法则。

    失败需要正确面对,在很多情况下,失败并不是什么坏事。从另一方面看,有创造力的思考者会了解失败的潜在价值,会利用失败当作垫脚石,来产生新的创意。在现实生活中,如果非常害怕失败,这样会使孕育创新的机会大为减少。如果一个人很少失败,那表示该人不是很有创造力。

    炒作法则
。

    在生活中,不但要学会在成功法则中展示自己,也要学会如何宣传自己。简单地说,宣传就是为自己营造一个光环,让人们对你产生更好的印象。人的认识活动有一种“润泽性”,比如一个人的某一品质被认为是好的,他就被一种积极的光环所笼罩,反之,该人就被赋予其它不好的品质,这就是“光环效应”。

导致人生失败的31种原因 [ZT]

I should reflect myself.

from http://blog.csdn.net/xiaojianpitt/archive/2009/12/09/4972773.aspx

人生的最大悲剧,就是孜孜不倦的努力却终于失败!
美国一位学者曾经分析了数千人的经历,结果是总人数的98%都是失败者。并由此归纳了人们失败的主要原因,有31种之多。当你逐项阅读它们时,要一一检查自己,以求发现将你排斥在成功之外的有多少种。
1、不利的遗传背景:对于生来就脑力不足的人,好主意是不会多的。有一个可用来弥补这种缺点的方法,就是组织个智囊团,求得别人的帮助。不过请注意,在所有31中失败因素中,只有这一种是任何人难以改变的。
2、缺乏明确的生活意向:没有中心意向或明确目标而盲目努力的人是毫无希望的。
3、缺乏中等以上目标的雄心:对于人生漠然、不求上进的人,我们是不存什么奢望的,对于不愿已付出代价的人,也不过如此。
4、教育不充足:这是比较易于改善的。经验证明,最有教养的人,往往是自我造就或自我教育的人。要成为有教养的人,所需要的不仅仅是大学的学位,更要学会能取得生活所需的一切,但又不损害旁人的权利。再有,教育不止包含很多的一般知识,还要包含那些有效又能持久运用的特殊知识。人们并不为他们所懂得的知识付出金钱,而是为了他们用知识去创造的事物去付钱的。
5、缺少自律:纪律是从自制而来的。这表明人们必须控制自己的一切消极品性。在你能控制环境以前,必须先学会控制你自己。自我主宰是你所要解决的最困难的问题。你如果克服了你自己,你更会被你自己克服了。你若走到一面镜子前,你会同时看到你的最好朋友和你的最大敌人。
6、身体不健康:没有任何人能够身体不好而获得辉煌的成就。很多人身体不好的原因,都是可以控制和克服的。主要原因有:
①吃多了不能促进健康的食物。
②错误的思想和自卑的观念。
③性的胡为及滥用。
④缺乏适当的运动。
⑤呼吸新鲜空气不足。等等。
7、儿童期间受到不良环境的影响:“嫩枝弯曲,树乃倾斜”,很多人的犯罪癖性,都是儿童时期接触不良伙伴或邪恶环境造成的。
8、拖延:这是最普遍的失败原因。“拖延老人”站在每个人的阴影里,等候着破坏你的成功机缘。我们有很多人一生都是失败的,为的只是要等待适当的时间到来,才着手作那些值得做的事情。我们应该奉劝一句:别等待了,时间永远不会“正好”的。你站在哪儿就从哪儿开始,就使用你能够拿到的任何工具,更合用的工具会在做着的过程中找到。
9、缺乏坚韧:大多数人都可能做优秀的开始人,却很少有人把已经开始的一切工作妥善地完成。人们总是在遇到第一个挫折时,便全盘撒手放弃。而坚韧,是没有其他任何东西可以替代的。以坚韧为座右铭的人最终会发现,失败的魂灵也会感觉厌倦而一走了之的,因为失败无法与坚韧拼到底。
10、个性消极:以消极的个性拒人于千里之外的,没有成功的希望。成功者,是由积极力量的运用而获得的。而这种力量则又是由别人的协作努力而成的。消极的个性绝不可能诱发别人的协同努力。
11、不能控制性的冲动:性的精力,是驱使人奋起行动的最强有力的刺激素。由于它是最强有力的情绪,所以对它必须加以控制,务必使它进入正当的途径。
12、不能控制无中生有的欲望:人的赌博天性,会驱使千百万人趋于失败。这类例证可由1929年美国华尔街的破产故事而得知,那年竟有千百万人曾想在股票红利上赌博而发财。所以,必须加以控制。
13、没有做确切决定的能力:成功的人能够果断地下定决心,而失败的人则是慢吞吞地做出一项决定。犹豫与拖延是孪生兄弟。遇见其一,往往也遇见另一位。务必在这对兄弟完全抓住你、送你去做失败的苦役以前,就消灭它们。
14、六种基本恐惧之一种或几种:这六种基本恐惧是贫穷、批评、不健康、失恋、衰老、死亡。你必须克服它们,然后才能有效地推销自己。
15、选错了婚姻的配偶:这也是最普遍的一种失败原因。婚姻关系使人们发生了极亲密的接触。除非关系和谐,否则,失败就难以避免。尤其是这种失败,能把成功的一切形象都毁坏。
16、过分谨慎小心:绝对不想碰碰运气的人,往往在别人都选择完了,才捡起残羹。过分谨慎与太不谨慎同样不妥,人生本来就是含有若干机遇成分的。
17、选错了事业上的同伴:这也是最常见的失败原因之一。为自己选择职业或事业时,必须极其留心选择你的领导和同伴,他们应能够激发你的灵感,使自己成为聪明而成功的人。我们都会效仿与我们过从甚密的人,请选择一位值得效仿的领导和同伴吧!
18、迷信与偏见:迷信是恐惧的一种,它也是无知的信号,偏见则是狭隘的一种,成功的人都是胸襟坦荡、无所畏惧的人。
19、选错了行业:没有人在他所不喜欢的行业中能获得成功的。关键是选择一种职业使你能够全心全意地埋首其中。
20、缺乏专注的努力:万事通的人不能精通某一个事物。将你的努力集中在一个主要的目标上吧。
21、浪费习惯:胡乱花钱的人是不能成功的,主要是因为他永远站在窘困的局面中。要养成储蓄一定比例收入的好习惯。你的银行里的存款,能为你发展事业提供一个坚实的基础。没有钱的人,在与人交往中,别人提出什么他都不会接受,因此很容易上当或满足。
22、缺乏热情:没有热情便不能取信于人,尤其是热情具有传染性,有热情而又能控制的人,在任何团体中都受到欢迎。
23、不能容忍:对于任何事情都是固执己见的人,是很少能够上进的。不能容忍,意味着不再能吸收异己的知识。最有害的不容忍的情况,多出现在宗教、种族及政治的不同观念上。
24、不知节制:不知节制的最有害的情况,发生于暴饮暴食、淫欲无度。对自己的任何一种放纵,都会造成成功的致命伤。
25、不能与人合作:由此而失去好职位和好时机的人很多。任何一位消息灵通的商人和成功者都不能容忍这个缺点。
26、拥有并非自己努力而获得的权利:继承并非由自己努力而获得的权利,在他自己往往是祸不是福。爆发的财富比较贫穷更容易招致危险。
27、友谊的欺诈:诚实是没有什么可以代替的。一个人也许由于受到无法控制的环境压力,而一时权宜作伪,并不会受到永久的损害。至于故意选择作伪骗人的人,则是毫无希望的。因为真相迟早会被人得知,于是他就难免身败名裂。
28、自大而好虚荣:这两种个性好似警告别人不可靠近的红灯。它们对成功会有致命的打击。
29、以猜测代替思考:大多数人都是不太关心或太懒于求知真情后,再做正确的思考。他们情愿凭着来自猜测或草率判断的见解而采取行动,因为求知真情是需要付出辛劳的。
30、缺乏资金:这是第一次创办事业的人常常会失败的原因。他们一旦发生了失误,而又没有足够的资金帮助他们渡过难关,彻底的失败便是注定的了。
31:其他:包括使你遭受失败的任何特殊原因。
从这31种失败原因中,你可以看到人生悲剧的描述,几乎所有经过奋斗尝试而失败了的人全在里面了。你如果能找到一位和你很熟的人同你一块阅读此文,并帮助你用31种原因分析你自己,那就可获益。你倘若独自来做,那也是有好处的。不过,多数人不能像别人了解他一样地了解自己。

ooops, been spending some time on this. wondering the skills.

package com.test;

import java.util.ArrayList;

public class Lock {

	private static volatile int xFlag = 0;
	private static volatile Lock xLock = new Lock();

	private static volatile int topPrio = -1;
	private static volatile ArrayList waitingThreads = new ArrayList();

	public static void lock() {
		synchronized (xLock) {
			while (true) {
				if (xFlag == 0 && waitingThreads.isEmpty()) {
					xFlag = 1;
					return;
				} else if (xFlag == 0 && !waitingThreads.isEmpty()) {
					for (Thread t : waitingThreads) {
						if (t.getPriority() > topPrio)
							topPrio = t.getPriority();
					}

					if (Thread.currentThread().getPriority() >= topPrio) {
						xFlag = 1;
						waitingThreads.clear();// reset waitingThreads
						topPrio = -1; // reset topPrio
						xLock.notifyAll();
						return;
					}
					
					try {
						xLock.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					
				} else {
					try {
						waitingThreads.add(Thread.currentThread());
						xLock.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
		}
	}

	public static void unlock() {
		synchronized (xLock) {
			xFlag = 0;
			xLock.notifyAll();
		}
	}

}