/***

* 懒汉模式 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;

}