基于反射、序列化、多线程及单例安全性角度看常用的三种JAVA单例模式

1、理论基础

1、定义：
    使一个类只能创建一个对象的设计模式叫单例模式，这样的类叫做单例类。
2、常用的三个
    饿汉单例
    懒汉单例
    枚举单例 

2、饿汉式单例：

/*
 * 饿汉式单例
 * 
 * 加abstract:
 *    抽象类无法创建对象，通过反射也不行，本类中和本类外都不行
 *    但可以创建子类对象
 *    类的反序列化底层调用了反射创建对象，枚举类除外
 */
public abstract class Student {
        /*
        * 创建一个可供外部访问的对象
        * static:外部无法创建对象访问stu，只能通过类名，要通过类名访问stu，必须加static
        *            而且可以防止序列化后再反序列化产生多个对象，因为static变量不能被序列
        *   
        * final:防止外部使用Student.stu=null;将对象删除
        *
        * volatile:对一个变量的写操作先行发生于后面对这个变量的读操作；
        *    防止多线程情况下new Student()时指令重排造成对象混乱
        *    new  Student()按顺序实际干了四件事：
        *         1、 检查Student类是否加载，没有则先加载类
        *         2、 给Student对象分配内存
        *         3、 利用构造函数初始化Studnet，完成实例化
        *         4、 将Studnet对象指向分配的内存空间，此时Student开始不为null
        *    jvm为了性能优化进行指令重排可能打乱3和4执行顺序，造成对象未实例化但不为null的中间
        *    态，单线程情况下没有问题，多线程情况下就可能对象错乱
        * 
        * new Student(){};   
        *  抽象类无法创建对象，只能通过子类的实例指向父类的引用创建对象
        * 	此处创建的是匿名子类的对象，外部调用的也是匿名子类对象。
        * 通过该对象访问属性和方法时，由于子类中啥都没有，访问的依然是父类，即本类的属性和方法。
        * 
        */
	public static final  Student stu=new Student() {};
        /*
        * 构造器私有，防止外部创建本类的子类，包括匿名子类  
        *          只要能够创建子类，就能够通过子类访问父类的属性和方法     
        *
        */
	private Student() {	
	}
}

3、懒汉式单例

/*
 * 懒汉式单例
 * 
 * 加abstract:
 *    抽象类无法创建对象，通过反射也不行，本类中和本类外都不行
 *    类的反序列化底层调用了反射创建对象，枚举类除外
 */
public  abstract class Student {
        /*
        * 创建一个可供外部访问的对象
        * static:外部无法创建对象访问stu，只能通过类名，要通过类名访问stu，必须加static
        *            而且可以防止序列化后再反序列化产生多个对象，因为static变量不能被序列化
        * volatile:防止多线程情况下指令重排造成对象错乱
        *           其实如果不进行第一层的锁校验，可以不加volatile 
        *           因为一个线程获得锁标记的时候，其他所有线程都在等待锁标记       
        */
	private  static  volatile Student stu;
        /*
        * 构造器私有，防止外部创建本类的子类，包括匿名子类  
        *          只要能够创建子类，就能够通过子类访问父类的属性和方法     
        *
        */
	private Student() {	
	}
        /*
        *synchronized:
        *          防止多线程环境下创建多个对象
        * static:
        *          通过类名调用该方法
        * 
        * new Student(){};   
        *  抽象类无法创建对象，只能通过子类的实例指向父类的引用创建对象
        * 	此处创建的是匿名子类的对象，外部调用的也是匿名子类对象。
        *  通过该对象访问属性和方法时，由于子类中啥都没有，访问的依然是父类，即本类的属性和方法。
        */
	public static Student getStu() {
		if(stu==null) {	//防止每次都抢锁，降低性能		
			synchronized (""){
				//如果对象为空，则创建一个对象
				if(stu==null)
					stu=new SingleInstance() {};		
			}
		}
		return stu;
	}
}

4、枚举类单例

/*
 * 枚举类单例（无参枚举类）
 * 
 * 枚举类中每个常量都是一个该枚举类的一个对象
 * 
 * 该枚举类Student只有一个对象STU,通过反射，序列化再反序列化，new 构造器
 * 都无法创建对象，枚举类再内部有相应的机制进行控制
 * 
 */
public  enum Student {
	STU()
}
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
/*
 * 枚举类单例(带参枚举类)
 * 
 * 枚举类中每个常量都是一个该枚举类的一个对象
 * 
 * 该枚举类Student只有一个对象STU,通过反射，序列化再反序列化，new 构造器
 * 都无法创建对象，枚举类再内部有相应的机制进行控制
 * 
 */
public  enum Student {
	STU("lucy");
	private String name;
	private Student(String name) {
		this.name=name;
	}
}

5、对比

饿汉式单例：
    abstract防止创建本类示例，可以完全消除反射影响
    static可以完全消除反序列化影响
    private防止外部通过创建子类实例。
    final可以防止外界更改唯一的单例类的实例。
    无法禁止jVM底层指令重排产生多个对象。

懒汉式单例：
    abstract防止创建本类示例，可以完全消除反射影响。
    static可以完全消除反序列化影响。
    private防止外部通过创建子类实例。
    需要考虑并发问题，synchronized影响性能，双层校验不美观。
    volatile防止多线程情况下的对象错乱。
    外界可以更改唯一的单例类的实例，不安全。

##注意：
    懒汉式和饿汉式的static关键字相当于禁止了反序列化，不适用于必须单例类需要反序列化的场景。
    由于想要完全杜绝反射的影响，使用了abstract字，导致本类实例化只能通过匿名子类，严格意义上不算
是本类的单例。但确实达到了本类单例的效果。

枚举类单例：
    enum:反射创建对象会检查类是否由enum关键字修饰，是则抛出异常。
    元素反编译后在静态代码块中初始化，静态代码块的初始化时线程安全的。
    枚举类的序列化和反序列化机制是特殊定制的，不会反序列化出多个对象的情况。
    枚举类内都是常量，无法是更改，安全。