单例模式-Singleton

单例（Singleton）是一种常用的设计模式。在Java应用中，单例模式能保证在一个JVM中，该对象只有一个实例对象存在。这样的模式有几个好处：

1. 有些大型类的对象创建比较复杂，系统开销大，可以考虑使用单例模式。

2. 省去了new操作符，降低了系统内存的使用频率，减轻GC压力。

3. 有些类控制着整个业务流程，如果可以创建多个对象的话，系统就乱了。只有使用单例模式，才能保证核心引擎独立控制整个流程。

 

先写一个饿汉式的单例模式：这种模式的好处就是不会产生线程安全问题

private class Singleton {           
    private static Singleton instance = new Singleton(); 
    
    private Singleton() {}

    public static Singleton getInstance() {
        return instance;           
    }
}

通过这个简单的代码，可以看出单例模式有以下特性：

1. 构造函数私有化：防止对象在外部被创建

2. 公有的获取实例的函数getInstance()：可以从外部通过Singleton.getInstance()获取实例

3. 私有且静态的Singleton类型成员变量

本人认为饿汉式单例模式已经够用了，因为使用单例模式就为了使用它的实例对象，在类加载时创建和在使用时创建没有很大区别

下面介绍一下懒汉式单例模式：可能会有线程安全性问题

public class Singleton {  
  
    private static Singleton instance = null;  
  
    private Singleton() {}  

    public static Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }
        return instance;  
    }
}

为解决线程安全问题，可以对方法加上synchronized，得到下面的单例模式：

public class Singleton {  
  
    private static Singleton instance = null;  
  
    private Singleton() {}  

    public static synchronized Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }
        return instance;  
    }
}

此方式类似于：

public class Singleton {  
  
    private static Singleton instance = null;  
  
    private Singleton() {}  

    public static Singleton getInstance() {  
        synchronized(instance) {
            if (instance == null) {  
                instance = new Singleton();  
            }
        }
        return instance;  
    }
}

但是，此方法由于每次调用getInstance()时都会访问一次锁（为对象加锁），但是实际的情况是只有第一次调用时才应该加锁，因此效率低下，可以使用两次判断（double check）方式提高锁效率：

public class Singleton {  
  
    private static Singleton instance = null;  
  
    private Singleton() {}  

    public static Singleton getInstance() {  
        if(instance == null) {
            synchronized(instance) {
                if (instance == null) {  
                    instance = new Singleton();  
                }
            }
        }
        return instance;  
    }
}

此方法类似于：

public class Singleton {  
  
    private static Singleton instance = null;  
  
    private Singleton() {}  

    public static Singleton getInstance() {  
        if (instance == null) {
            buildInstance();
        }
        return instance;  
    }

    private static synchronized void buildInstance() {
        if (instance == null) {  
            instance = new Singleton();  
        }
    }
}

由于JVM内部的类加载机制能够保证当一个类被加载的时候，加载过程是线程互斥的。这样，我们可以使用内部类来维护单例的实现：当我们第一次调用getInstance()的时候，JVM能够帮我们保证instance只被创建一次，这样我们就不用担心线程安全问题。同时该方法只会在第一次调用的时候使用互斥机制，这样又解决了效率低的问题。这样我们可以得到下面的单例模式：

public class Singleton {  
  
    private Singleton() { } 
 
    private static class SingletonFactory {  
        private static Singleton instance = new Singleton();  
    } 
  
    public static Singleton getInstance() {  
        return SingletonFactory.instance;  
    } 
}

追加：只有一个元素的枚举即是单例

public enum Singleton {
    SINGLETON
}