/***
* 懒汉模式 1
* 可以延迟加载，但线程不安全。
* @author admin
*
*/
public class TestSinleton1 {
private static TestSinleton1 sinleton;
private TestSinleton1(){ }
public static TestSinleton1 getSinleton(){
if(sinleton==null){
return new TestSinleton1();
}
return sinleton;
}
}
/***
* 懒汉模式变种 2
* @author admin
* 使用了synchronized关键字，既可以延迟加载，又线程安全，但是执行效率低。
*/
class TestSinleton2{
private static TestSinleton2 sinleton;
private TestSinleton2(){ }
public synchronized static TestSinleton2 getSinleton(){
if(sinleton==null){
return new TestSinleton2();
}
return sinleton;
}
}
/***
* 饿汉模式 3
* @author admin
* 基于classload机制，静态变量在类装载时进行初始化
* 可以避免线程安全问题，但是没有延迟加载。
*/
class TestSinleton3{
private static TestSinleton3 sinleton = new TestSinleton3();
private TestSinleton3(){
}
public static TestSinleton3 getSinleton(){
return sinleton;
}
}
/***
* 恶汉变种模式 4
* @author admin
* 基于静态 代码块，在实例化或者第一次调用时执行
* 既可以延迟加载，又线程安全
*/
class TestSinleton4{
private static TestSinleton4 sinleton =null;
static{
sinleton = new TestSinleton4();
}
public static TestSinleton4 getSinleton(){
return sinleton;
}
}
/***
* 双重校验锁 5
* @author admin
* 懒汉模式的优化版，拥有线程安全、高效率以及延迟加载等特性。但是这种方式需要jdk1.5以上，且在一些平台和编译器下有错。
*/
class TestSinleton5{
private static volatile TestSinleton5 sinleton;
private TestSinleton5(){ }
public static TestSinleton5 getSinleton(){
if(sinleton==null){
synchronized (TestSinleton5.class) {
if(sinleton==null){ sinleton = new TestSinleton5();
}
}
}
return sinleton;
}
}
/***
* 静态内部类 6
* @author admin
* 恶汉模式的优化版，在类被装载时，静态内部类并没有被实例化，
* 只有getInstance()时才 会装载 SingletonHolder 类，静态内部类方式也能很好地，实现线程安全、高效率和延迟加载特性。
*/
class TestSinleton6{
private static class SingletonHolder {
private static final TestSinleton6 sinleton = new TestSinleton6();
}
private TestSinleton6(){}
public static final TestSinleton6 getSinleton(){
return SingletonHolder.sinleton;
} }
/***
* 枚举7
* @author admin
*避免多线程同步问题
*/
enum TestSinleton7 {
SINLETON;
}