单例设计模式：
单例：某个类只能有唯一的一个实例对象。 如何实现单例？
1、饿/恶汉式
不管我们使用者是否需要这个对象，它都上来先给你创建好这个唯一的对象。 （1）枚举类型
@Test
public void test1(){
SingleEnum s1
= SingleEnum
.INSTANCE
;
SingleEnum s2
= SingleEnum
.INSTANCE
;
System
.out
.println(s1
== s2
);
}
enum SingleEnum
{
INSTANCE
;
可见s1和s2是同一个对象。
（2）形式二
①构造器私有化②用一个全局的静态的常量，来保存这个唯一的实例对象
@Test
public void test3(){
SingleClass s1
= SingleClass
.INSTANCE
;
SingleClass s2
= SingleClass
.INSTANCE
;
System
.out
.println(s1
==s2
);
}
class SingleClass{
public static final SingleClass INSTANCE
= new SingleClass();
private SingleClass(){
}
（3）形式三①构造器私有化②用一个私有的静态的常量，来保存这个唯一的实例对象③提供一个静态方法，来返回这个常量对象
@Test
public void test4(){
Single s1
= Single
.getInstance();
Single s2
= Single
.getInstance();
System
.out
.println(s1
== s2
);
}
class Single{
private static final Single INSTANCE
= new Single();
private Single(){
}
public static Single
getInstance(){
return INSTANCE
;
}
}
2、懒汉式
延迟创建对象。当使用者来或者这个对象，要用到对象时，我再创建。（1）形式一：见下面，考虑线程安全问题和性能问题
@Test
public void test5(){
LazyClass s1
= LazyClass
.getInstance();
LazyClass s2
= LazyClass
.getInstance();
System
.out
.println(s2
== s1
);
}
LazyClass s1
;
LazyClass s2
;
@Test
public void test6(){
Thread t1
= new Thread(){
public void run(){
s1
= LazyClass
.getInstance();
}
};
Thread t2
= new Thread(){
public void run(){
s2
= LazyClass
.getInstance();
}
};
t1
.start();
t2
.start();
try {
t1
.join();
t2
.join();
} catch (InterruptedException e
) {
e
.printStackTrace();
}
System
.out
.println(s1
);
System
.out
.println(s2
);
System
.out
.println(s1
== s2
);
}
}
class LazyClass{
private static LazyClass instance
;
private LazyClass(){
}
public static LazyClass
getInstance(){
if(instance
== null
){
synchronized(LazyClass
.class){
if(instance
== null
){
try {
Thread
.sleep(100);
} catch (InterruptedException e
) {
e
.printStackTrace();
}
instance
= new LazyClass();
}
}
}
return instance
;
}
}
（2）形式二：内部类形式
class Lazy{
private Lazy(){
}
private static class Inner{
public static final Lazy INSTANCE
= new Lazy();
}
public static Lazy
getInstance(){
return Inner
.INSTANCE
;
}
}
