单例模式(Singleton)是一种常用的设计模式,顾名思义,单例就是在整个系统中,指定一个类只存在一个实例化对象。
单例的创建方式
- 饿汉式,即类被加载后,就创建当前类的一个实例,不管这个类是否使用到。
public class Singleton {
//私有化一个实例对象
private static final Singleton INSTANCE = new Singleton();
//私有构造方法,使其它类无法创建当前类的实例,保证唯一性
private Singleton(){}
//公共方法,返回实例化对象的引用,其它类只有通过此方法获取当前类的实例,并且获得的都是同一个对象
public static Singleton getInstance(){
return INSTANCE;
}
}
饿汉式是最简单的写法,同时也保证了线程安全(由虚拟机保证),类加载的时候,就实例化了一个对象。
- 懒汉式,即类被使用到的时候,才去创建这个类的对象。
public class Singleton {
//创建一个指向空的引用,不进行初始化
private static Singleton INSTANCE = null;
private Singleton(){}
public static Singleton getInstance(){
//判断是否实例化,没有就创建一个对象
if (INSTANCE == null){
INSTANCE = new Singleton();
}
return INSTANCE;
}
}
懒汉式的这种写法是存在线程不安全的,当多线程访问getInstance()方法时,若线程1进入if块中,但还没有创建对象,此时线程2也进入getInstance()方法,它去判断INSTANCE是否是空,发现还是没有实例化,所以它也进入了if块里。这样线程1和线程2都会去实例化,创建的也就是两个对象了。
解决上面的问题,就需要使用synchronized关键字,给方法加锁,保证同一时刻只有一个线程进入getInstance()方法中
public class Singleton {
private static Singleton INSTANCE = null;
private Singleton(){}
//使用synchronized加锁
public static synchronized Singleton getInstance(){
if (INSTANCE == null){
INSTANCE = new Singleton();
}
return INSTANCE;
}
}
但是synchronized虽然保证线程安全,但同样带来效率下降的问题。
所以可以将实例化对象的代码用synchronized块包住,这样性能上比直接使用synchronized锁住getInstance()更优
public class Singleton {
private static Singleton INSTANCE = null;
private Singleton(){}
public static Singleton getInstance(){
if (INSTANCE == null){
//使用synchronized同步块
synchronized(Singleton.class){
INSTANCE = new Singleton();
}
}
return INSTANCE;
}
}
但是上面的写法虽然性能变优了,可是它却是线程不安全的,原因在于,会存在线程1和线程2先后进入if块中,此时线程1持有锁,然后线程1创建了一个对象后释放锁,而线程2在if块中,所以它自然地持有锁,也创建另一个对象。即if的判断和实例化过程被分开了,没有同步统一起来。
所以就有了双重检查
public class Singleton {
//使用volatile来禁止指令重排
private static volatile Singleton INSTANCE = null;
private Singleton(){}
public static Singleton getInstance(){
if (INSTANCE == null){
synchronized(Singleton.class){
//双重检查
if (INSTANCE == null){
INSTANCE = new Singleton();
}
}
}
return INSTANCE;
}
}
这里使用volatile是为了禁止JVM指令重排。
简单的讲,是创建一个对象时,首先向内存申请一块空间,其次调用类的构造方法,最后是将引用和对象建立联系。指令重排意味着可能后两步顺序颠倒,即先建立联系,再调用构造方法。若这个类有将其它类作为成员变量,会出现其它线程使用这个对象的成员变量还是null的情形。
所以最后懒汉式的标准写法是使用静态内部类
public class Singleton {
private Singleton(){}
//静态内部类
private static class HoldSingleton {
//实例化对象
private static final Singleton INSTANCE = new Singleton();
}
public static Singleton getInstance(){
return HoldSingleton.INSTANCE;
}
}
一方面和饿汉式一样,由JVM保证线程安全,即只有类加载时实例化一个对象。另一方面是,外部类加载时,不会直接加载内部类,由此实现懒汉式的需求。
- 枚举单例
创建单例更完美的写法是使用枚举,主要是在线程安全上,还解决了反序列化,原因是枚举没有构造方法,可以防止反序列化,即无法通过反射来实例化新的对象。
public enum Singleton {
INSTANCE;
public Singleton getInstance(){
return INSTANCE;
}
}