设计模式--单例

简介

当希望一个类在程序中只会有一个实例存在的时候，单例模式便会派上用场。为了限制该类对象被随意的创建，我们将构造方法声明为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也被保证实例化一次。