简介
当希望一个类在程序中只会有一个实例存在的时候,单例模式便会派上用场。为了限制该类对象被随意的创建,我们将构造方法声明为private,但是这样就无法创建对象了,我们该怎么办呢?接下来就从最简单的单例模式讲起。
最简单的单例
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton() {
//初始化操作
}
public static Singleton getInstance() {
return instance;
}
}
我们在类内部创建一个静态的Singleton变量,通过静态方法返回,这样的代码是线程安全的,因为虚拟机加载这个类的时候会保证static的变量只由一个线程执行一次,在使用该变量之前保证创建完成。
性能更进一步
第一种方法由于在加载类的时候就会创建static变量,占用内存,这不是我们希望看到的,理想情况是当我们需要用到的时候再创建实例,也就是要延迟实例化,我们修改代码如下
public class Singleton {
private static Singleton instance;
private Singleton() {
//初始化操作
}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
但是这样的话又会造成线程不安全的情况,当两个线程都执行if(instance == null)后,假设线程1先进入下一步,得到一个实例,之后线程2就会进入下一步,同样获得一个新的实例,这就会造成存在多个实例,继续修改代码如下
public class Singleton {
private static Singleton instance;
private Singleton() {
//初始化操作
}
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
加锁后就可以实现多线程安全访问,但是又出现一个问题,就是在多线程的情况下对整个方法加锁就会造成性能不够好,我们可以缩小同步的范围来加强性能
public class Singleton {
private volatile static Singleton instance;
private Singleton() {
//初始化操作
}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
instance要用volatile修饰,这样就对synchronized有可见性。
静态内部类
我们需要的是线程安全且延迟实例化的单例,可以根据第一种代码修改,可以声明一个内部类,内部类里面持有一个Singleton实例,在getInstance方法里获得该内部类的实例,也只会在这个时候jvm去加载这个内部类,创建实例。
public class Singleton {
private Singleton() {
//初始化操作
}
private static class SingleHolder {
private static final Singleton instance = new Singleton();
}
public static Singleton getInstance() {
return SingleHolder.instance;
}
}
枚举单例
其实以上的方法有一个共同的缺陷,那就是如果将单例序列化存储到本地在读取回来,那么获得另一个一摸一样的instance,这样也就不是所谓的单例了,而单元素的枚举类型是实现Singleton的最佳方法。
枚举的使用
最基本的使用如下
enum Type {
A,
B,
C;
}
编译器将它变成这样
class Type extends Enum{
public static final Type A;
public static final Type B;
public static final Type C;
...
}
也就是三个静态的Type对象A、B、C。
我们可以把Type看成一个类,它也有构造方法和方法
public class Main {
public static void main(String[] args) {
Type.staticPrint();
Type.A.print();
Type.B.print();
}
enum Type {
A,
B {
@Override
public void print() {
System.out.println("B print()");
}
},
C;
Type() {
System.out.println("init");
}
public static void staticPrint() {
System.out.println("static print()");
}
public void print() {
System.out.println("print()");
}
}
}
输出:
init
init
init
static print()
print()
B print()
可以知道,首先enum会实例化三个静态的Type对象,调用构造方法,构造方法是私有的。我们可以通过Type访问静态的类方法,通过ABC访问实例方法,当然具体的对象如B可以重写父类的实例方法,此外,我们也可以定义抽象方法,这样每个实例ABC都需要实现该方法。
单例的实现
enum Type {
INSTANCE;
private Singleton mInstance;
private Type() {
mInstance = new Singleton();
}
public Singleton getInstance() {
return mInstance;
}
}
我们确定了构造方法是私有的,然后我们访问枚举实例的时候会执行构造方法,同时每个枚举实例都是static final类型的,也就表明只能被实例化一次。在调用构造方法时,我们的单例被实例化。 也就是说,因为enum中的实例被保证只会被实例化一次,所以我们的INSTANCE也被保证实例化一次。