单例（Singleton）

单例（Singleton）

在大部分时候，我们把类的构造器定义成public访问权限，允许任何类自由创建该类的对象。但是在某些时候，允许其他类自由创建该类的对象没有任何意义，还可能造成系统性能下降。

概念

如果一个类始终只能创建一个实例，则这个类被称为单例类。

在一些特殊场景下，要求不允许自由创建该类的对象，而是只允许为该类创建一个对象。为了避免其他类自由创建该类的实例，我们把该类的构造器使用private修饰，从而把该类的所有构造器隐藏起来。

一旦把构造器隐藏起来，则需要提供一个public方法作为该类的访问点，用于创建该类的对象，且该方法必须使用static修饰（因为调用该方法之前还不存在对象，因此调用该方法的不可能是对象，只能是类）。

除此之外该类还必须缓存已经创建的对象，否则该类无法知道是否曾经创建过对象，也就无法保证只创建一个对象。为此该类需要使用一个属性来保存曾经创建的对象，因为该属性要被上面的静态方法访问，该属性也必须使用static修饰。

这是一个简单的单例例子（懒汉式）。

public class Singletion {
    private static Singletion singletion; // 保存实例
    // 隐藏构造
    private Singletion(){};              
    // 获取实例
    public static Singletion getSingletion() {
        if(singletion==null){
            // 第一次使用 则创建
            singletion = new Singletion();
        }
        return singletion;
    }

    public static void main(String[] args) {
        Singletion singletion1 = Singletion.getSingletion();
        Singletion singletion2 = Singletion.getSingletion();
        System.out.println(singletion1 == singletion2);
    }
}

懒汉式

举例的懒汉式在线程上并不安全。线程优化方案：

在获取方法上加同步锁

public class Singletion {
    private static Singletion singletion;
    private Singletion(){};
    public static synchronized Singletion getSingletion() {
        if(singletion==null){
            singletion = new Singletion();
        }
        return singletion;
    }

}

双重检查锁

public class Singletion {
    private static Singletion singletion;
    private Singletion(){};
    public static synchronized Singletion getSingletion() {
        if(singletion == null){
            synchronized(Singletion.class){
                if(singletion == null){
                    singletion = new Singletion();
                }
            }
        }
        return singletion;
    }
}

静态内部类

public class Singletion {
    private static class LazyHolder{
        private static final Singleton INSTANCE = new Singleton();
    }
    private Singleton(){}
    public static final Singleton getInstance(){
        return LazyHolder.INSTANCE;
    }
}

这种比上面的1,2都好一些，即实现了线程安全，又避免了同步锁带来的性能影响

饿汉式

在类初始化的回收，已经自行实例化；它天生就是线程安全的

public class Singleton{
    private Singleton(){}

    private static final Singleton single = new Singleton();

    public static Single getInstance(){
        reutrn single;
    }
}