单例模式写法详解

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;
}
}
posted @ 2020-10-20 14:46  开心的鱼a1  阅读(101)  评论(0编辑  收藏  举报