1.饿汉式
饿汉式可以保证多线程下唯一的实例,getInstance性能也比较高,但是无法进行懒加载。
/**
* 饿汉式可以保证多线程下唯一的实例,getInstance性能也比较高,但是无法进行懒加载。
*/
public class Singleton1{
private static Singleton1 instance = new Singleton1();
//私有化构造函数,防止被实例化
private Singleton1(){}
public static Singleton1 getInstance(){
return instance;
}
}
2.懒汉式
懒汉式虽然实现单例的懒加载,但是在多线程下不安全的。因为线程1判断null == instance为true时,还没有* 实例化instance,切换到了线程2运行,线程2判断null == instance也为true。就会实例化多次
/**
* 懒汉式虽然实现单例的懒加载,但是在多线程下不安全的。因为线程1判断null == instance为true时,还没有* 实例化instance,切换到了线程2运行,线程2判断null == instance也为true。就会实例化多次
*/
public class Singleton2{
private static Singleton2 instance = null;
//私有化构造函数,防止被外部实例化
private Singleton2(){}
public static Singleton2 getInstance(){
if( instance == null){
instance = new Singleton2;
}
return instance;
}
}
3.懒汉式 + 同步方法(synchronized)
synchronized 控制了整个方法,容易多线程性能低下。
采用懒汉式 + 数据同步方式既满足了懒加载又能百分之百保证instance实例的唯一性,但是synchronized 关键字天生的排他性导致了getInstance方法只能在同一时刻被一个线程所访问,性能低下
public class Singleton3{
private static Singleton3 instance = null;
//私有化构造函数,防止被外部实例化
private Singleton3(){}
public static synchronized Singleton3 getInstance(){
if( instance == null){
instance = new Singleton3;
}
return instance;
}
}
4.Double-check
double-check 有可能会引起空指针的问题。
关键点在于:根据JVM指令重排序和Happens-Before规则,这两者之间的实例化顺序并无前后关系的约束
那么极有可能instance最先被实例化,而conn并未完成实例化,未完成初始化的实例调用其他方法将会抛出空指针异常。
public class Singleton4{
private static Singleton4 instance = null;
private String conn;
//私有化构造函数,防止被外部实例化
private Singleton4(){
this.conn = "test";
}
public static Singleton4 getInstance(){
if(instance = null){
synchronized(Singleton4.class){
if(instance == null){
instance = new Singleton4();
}
}
}
return instance;
}
}
5.Volatile + double + check
java有用户内存和主内存的区别,对于变量以volatile 声明以保证变量在内存的可见性,即可消除这个空指针隐患
public class Singleton5{
private static Singleton5 instance = null;
private String conn;
//私有化构造函数,防止被外部实例化
private Singleton5(){
this.conn = "test";
}
public static Singleton5 getInstance(){
if(instance = null){
synchronized(Singleton5.class){
if(instance == null){
instance = new Singleton5();
}
}
}
return instance;
}
}
6.Holer方式
即以静态内部类的方式提供示实例
该方法又是同步方法,保证了内存的可见性,JVM的顺序性和原子性。Holder方式是单例设计最好的设计之一
public class Singleton6{
//静态内部类提供实例
private static class Holder{
private static Singleton6 instance = new Singleton6();
}
public static Singleton6 getInstance(){
return Holder.instance;
}
}
7.枚举方法,线程安全,不能懒加载
枚举类型不允许被继承,同样是线程安全且只能被实例化一次,但是枚举不能够懒加载,对于Singleton6主动使用,比如调用其中静态方法则INSTANCE会立即得到实例化
public enum Singleton7{
INSTANCE;
Singleton7(){}
public static void method(){
//调用该方法,则会主动使用Singleton7, INSTANCE则会被实例化
}
public static Singleton7 getInstance(){
return INSTANCE;
}
}
可改造类似用Holder的方式支持懒加载
public class Singleton7_2{
private Singleton7_2(){}
private enum Holder{
INSTANCE;
private Singleton7_2 instance;
Holder(){
this.instance = new Singleton7_2();
}
public Singleton7_2 getInstance(){
return instance;
}
}
public static Singleton7_2 getInstance(){
return Holder.INSTANCE.getINstance();
}
}