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关键字修饰,是则抛出异常。
元素反编译后在静态代码块中初始化,静态代码块的初始化时线程安全的。
枚举类的序列化和反序列化机制是特殊定制的,不会反序列化出多个对象的情况。
枚举类内都是常量,无法是更改,安全。