java中单例模式介绍与反思
众所周知，在java中单例模式实现有7种，分别如下：
1、懒汉模式（线程不安全）
public class Singleton{
private static Singleton instance;
private Singleton(){};
public static Singleton getInstance(){
if(instance == null ){
instance = new Singleton();
}
return instance;
}
}
这种模式采用懒加载lazy loading但是在多线程下不安全
2、懒汉模式（线程安全）
public class Singleton{
private static Singleton instance;
private Singleton(){};
public static synchronized Singleton getInstance(){
if(instance == null ){
instance = new Singleton();
}
return instance;
}
}
懒加载，线程安全，但效率极其低下，同步锁锁的是对象，每次取对象都加锁，因此效率低下
3、饿汉模式
public class Singleton{
private static Singleton instance= new Singleton();
private Singleton(){};
public static Singleton getInstance(){
return instance;
}
}
这种方式基于classloader机制避免了多线程同步问题，不过instance在类装载时就实例化，没有达到懒加载效果
4、饿汉模式变种
public class Singleton{
private static Singleton instance = null;
static{
instance= new Singleton()；
}
private Singleton(){};
public static Singleton getInstance(){
return instance;
}
}
等同于第三种
5、静态内部类
public class Singleton{
private Singleton(){};
public static synchronized Singleton getInstance(){
return SingletonInnerClass.instance;
}
private static class SingletonInnerClass(){
private static Singleton instance = new Singleton();
}
}
利用classloader机制保证初始化实例时只有一个实例，与第三种第四种差别是达到了懒加载效果（第三种第四种方法只要singleton类被装载了那么instance就会被实例化，而这种方式SingletonInnerClass类没有被主动使用，只有被显示调用getInstance时才会显示装载SingletonInnerClass类，从而实现懒加载）在实例化instance很消耗资源，想让他延迟加载，另外不希望在singleton类加载时就实例化，这种方式就显得很合理 。推荐使用
6、双重校验锁
public class Singleton{
private static Singleton instance;
private Singleton(){};
public static synchronized Singleton getInstance(){
if(instance == null){
synchronized(Singleton.class){
if(instance == null){
instance = new Singleton();
}
}
}
return instance;
}
}
不管性能如何优越，使用了synchronized修饰符，就会对性能多少造成影响
7、枚举
public enum SIngleton{
INSTANCE;
public void whateverMethod(){}
}
这种方式是Effective Java提倡方式，不仅能避免多线程同步问题，还能防止反序列化重新创建新的对象，但因为可读性原因不推荐
由此七方法也介绍完毕，但也有几个问题需要反思
1、如何在反射状态下保证单例？
2、如何在反序列化中保证单例？
对于第一个问题我们可以采取以下方式
public class Singleton3{
private static boolean initialized = false;
private Singleton3(){
synchronized(Singleton3.class){
if(initialized == false){
initialized = !initialized ;
}else{
throw new RuntimeException("单例已破坏");
}
}
}
static class SingletonHolder{
private static final Singleton3 instance = new Singleton3();
}
public static Singleton3 getInstance(){
return SingletonHolder.instance;
}
}
这就保证了反射无法破坏其单例
对于第二个问题我们需要提供readResolve()方法的实现，来代替从流中读取对象，这就确保了序列化和反序列化过程中没人可以创建新的实例
public class Singleton4 implements Serializable{
private static boolean initialized = false;
private Singleton4(){
synchronized(Singleton4.class){
if(initialized == false){
initialized = !initialized ;
}else{
throw new RuntimeException("单例已破坏");
}
}
}
static class SingletonHolder{
private static final Singleton4 instance = new Singleton4();
}
public static Singleton4 getInstance(){
return SingletonHolder.instance;
}
private Object readResolve(){
return getInstance();
}
}
本文给出了多种单例模式，一般从静态内部类和保证反射，序列化状态下单例选择，根据实际情况三选一即可，并不是非要选择最后一种作为单例实现