public class LazyUnSafeSingle {
/** 优点：懒加载启动快，资源占用小，使用时才实例化，无锁。
* 缺点：非线程安全。
*/
private static LazyUnSafeSingle single = null;
private LazyUnSafeSingle (){
}
public static LazyUnSafeSingle getInstance(){
if(single == null){
single = new LazyUnSafeSingle();
}
return single;
}
public class LazySafeSingle {
/** 优点：懒加载启动快，资源占用小，使用时才实例化，加锁。
* 缺点：synchronized 为独占排他锁，并发性能差。即使在创建成功以后，获取实例仍然是串行化操作。
*/
private static LazySafeSingle single = null;
private LazySafeSingle(){
}
public static synchronized LazySafeSingle getInstance(){
if (single == null){
single = new LazySafeSingle();
}
return single;
}
}
public class LazySafeDoubleCheckLockSingle {
/** 优点：懒加载，线程安全。
* 缺点：实例必须有 volatile 关键字修饰，其保证初始化完全,（这里体现的是有序性）。
*/
private volatile static LazySafeDoubleCheckLockSingle single = null;
private LazySafeDoubleCheckLockSingle(){
}
public static LazySafeDoubleCheckLockSingle getInstance(){
if(single == null){
synchronized(LazySafeDoubleCheckLockSingle.class){
if(single == null){
single = new LazySafeDoubleCheckLockSingle();
}
}
}
return single;
}
}
public class UnLazySafeSingle {
/** 优点：饿汉模式天生是线程安全的，使用时没有延迟。
* 缺点：启动时即创建实例，启动慢，有可能造成资源浪费。
*/
private static UnLazySafeSingle single = new UnLazySafeSingle();
private UnLazySafeSingle(){
};
public static UnLazySafeSingle getInstance(){
return single;
}
}
public class HolderSingle {
/**
* 优点：将懒加载和线程安全完美结合的一种方式（无锁）
* 类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例，没有绑定关系，而且只有被调用到才会装载，从而实现了延迟加载
*/
private HolderSingle() {}
private static class Holder{
/**
* 静态初始化器，由JVM来保证线程安全
*/
private static HolderSingle single = new HolderSingle();
}
public static HolderSingle getInstance(){
return Holder.single;
}
}
