单例模式是创建型模式之一。其主要是指一个类只有一个对象实例。
单例模式:使用一个私有构造函数、一个私有静态变量以及一个公有静态函数来实现的。
私有构造函数保证不能通过构造函数来创建对象实例,只能通过公有静态函数返回唯一的私有静态变量。
![类图](https://i-blog.csdnimg.cn/blog_migrate/5fb456fbd7750a5289d64add8b47eee1.png)
单例模式的创建方式:
1.懒汉式----线程不安全
- 私有静态变量uniqueInstance被延迟实例化
- 优点:如果没有用到该类,就不会实例化uniqueInstance,从而节约资源
- 缺点:在多线程环境下是不安全的,如果多个线程能够同时进入if(uniqueInstance==null),并且此时uniqueInstance为null,那么会有多个线程执行uniqueInstance=new Singleton();语句,会导致多次实例化uniqueInstance。
public class Singleton {
//持有私有化静态对象实例
private static Singleton uniqueInstance;
//私有化构造方法 防止被实例化
private Singleton() {
}
public static Singleton getUniqueInstance() {
if (uniqueInstance == null) {
uniqueInstance = new Singleton();
}
return uniqueInstance;
}
}
2.饿汉式----线程安全
- 线程不安全主要是由于uniqueInstance被多次实例化,采取直接实例化uniqueInstance的方式就不会产生线程不安全问题。
- 但是直接实例化的方式也丢失了延迟实例化带来的节约资源的好处。
public class Singleton {
//持有私有化静态对象实例
private static Singleton uniqueInstance = new Singleton();
//私有化构造器防止被实例化
private Singleton() {
}
public static Singleton getUniqueInstance() {
return uniqueInstance;
}
}
3.懒汉式----线程安全
- 只需要getUniqueInstance()方法加锁,那么在一个时间点只能由一个线程能够进入该方法,从而避免了多次实例化uniqueInstance的问题。
- 但是当一个线程进入该方法之后,其它试图进入该方法的线程必须等待,因此性能上有一定的损耗。
public class Singleton {
//持有私有化静态对象实例
private static Singleton uniqueInstance;
//私有化构造方法 防止被实例化
private Singleton() {
}
public static synchronized Singleton getUniqueInstance() {
if (uniqueInstance == null) {
uniqueInstance = new Singleton();
}
return uniqueInstance;
}
}
4.双重校验锁----线程安全
- uniqueInstance只需要被实例化一次,之后就可以直接使用了。
- 加锁操作只需要对实例化那部分的代码进行,只有当uniqueInstance没有被实例化时,才需要加锁。
- 双重校验锁先判断uniqueInstance是否已实例化,如果没有被实例化,那么才对实例化语句进行加锁。
public class Singleton {
private volatile static Singleton uniqueInstance;
/**
* volatile关键字的使用,为什么?
* Instance采用关键字volatile修饰是非常有必要的,Instance = new Singleton();该语句的具体执行分为三步:
* 1.为Instance分配内存空间
* 2.初始化Instance
* 3.将Instance指向分配的内存地址
* !!!!!!
* 由于JVM具有指令重排的特性,执行顺序很有可能变成1-3-2。
* 指令重排在单线程环境下不会出现问题;但是在多线程环境下,会导致一个线程获得还没有初始化的实例。
* 例如:线程T1执行了1和3步骤,此时T2就调用了getInstance()方法,然后发现Instance不为空,故返回了Instance;
* 但此时Instance却还没有被初始化,导致出现问题。
* 如果我们用volatile关键字修饰Instance;volatile禁止了JVM指令重排,那么Instance在实例化过程中,就会严格按照顺序进行执行,从而避免上述出现的问题,
* 保证了在多线程环境下也能正常执行。
*/
private Singleton() {
}
public static Singleton getUniqueInstance() {
//先判断对象是否已经实例化过,如果没有实例化过才进行加锁
//第一次校验
if (uniqueInstance == null) {
synchronized (Singleton.class) {
//第二次校验
if (uniqueInstance == null) {
uniqueInstance = new Singleton();
}
}
}
return uniqueInstance;
}
}
如果只使用一个if语句实现,在uniqueInstance=null的情况下,如果两个线程同时执行if语句,那么两个线程就会同时进入if语句块内,一个线程获得锁实例化成功后释放锁,另一个正在等待锁的线程抢到锁,再次进行实例化。虽然在if语句块内有加锁操作,但是两个线程都会执行uniqueInstance=new Singleton();这条语句,就会进行两次实例化,从而产生两个实例,因此必须使用双重校验锁,也就是使用两个if语句。
if (uniqueInstance == null) {
synchronized (Singleton.class) {
uniqueInstance = new Singleton();
}
}
uniqueInstance使用volatile关键字修饰也是很有必要的,uniqueInstance=new Singleton();这段代码分为三步执行:
①、分配内存空间
②、初始化对象
③、将uniqueInstance指向分配的内存地址
但是由于JVM具有指令重排的特性,有可能执行顺序变成了①-③-②,这在单线程情况下自然没有问题,但是在多线程环境下,有可能会获得一个还没有进行初始化的实例,以至于程序出错。因此,使用volatile可以禁止JVM的指令重排,保证在多线程环境下也能正常运行。
5.静态内部类实现
- 当Singleton类加载时,静态内部类SingletonHolder没有被加载进内存,只有当调用getUniqueInstance()方法,从而触发SingletonHolder.INSTANCE时,SingletonHolder才会被加载,此时初始化INSTANCE实例。
- 这种方式不仅具有延迟初始化的好处,而且虚拟机提供了对线程安全的支持。
public class Singleton {
//私有化构造方法 防止被实例化
private Singleton() {
}
public static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
public static Singleton getUniqueInstance() {
return SingletonHolder.INSTANCE;
}
}
6.枚举实现
- 单例模式的最佳实践,实现简单,在面对复杂的序列化和反射攻击时,能够防止实例化多次。
public enum Singleton {
uniqueInstance;
}
在该实现中,该Singleton在每次序列化时,都会创建一个新的实例,为了保证每次只创建一个实例,必须声明所有字段都是transient,并且提供一个readResolve()方法。
public class Singleton implements Serializable {
private static Singleton uniqueInstance;
private Singleton() {
}
public static synchronized Singleton getUniqueInstance() {
if (uniqueInstance == null) {
uniqueInstance = new Singleton();
}
return uniqueInstance;
}
}
若不使用枚举实现单例模式,会出现反射攻击。因为通过 setAccessible() 方法可以将私有构造函数的访问级别设置为 public,然后调用构造函数从而实例化对象,若要防止这种攻击,需要在构造函数中添加防止实例化第二个对象的代码。