java中单例模式singleton

单例模式：在上下文中只有一个对象的实例。

应用场景：线程池，缓存等一个系统只需要一个的场景。

三种常见单例模式：

1. 延迟加载

public class Singleton {
    private static Singleton uniqueInstance;

    private Singleton() {}

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

使用时通过调用类的静态方法来获取：

Singleton singleton =Singleton.getInstance();

存在问题：多线程同步问题

多线程在第一次生成对象时，存在同时执行 if (uniqueInstance == null) 判断的可能，从而同时多次 new实例

改进：

public class SynSingleton {
    private static SynSingleton uniqueInstance;

    private SynSingleton() {}

    public static synchronized SynSingleton getInstance() {
        if (uniqueInstance == null)
            uniqueInstance = new SynSingleton();
        return uniqueInstance;
    }
}

如此通过synchronized代码块的方式，实现同步。

2. 急切实例化

上述方式每次在获取对象时，都要做同步synchronized操作，开销较大，而同步操作仅在第一次new时有效（随后每次调用均不做new操作，相当于只读不写），因此可以在类加载时就new对象，随后则不在做new操作，改进如下：

public class UrgSingleton {
    private static UrgSingleton uniqueInstance = new UrgSingleton();
    private UrgSingleton() {}

    public static UrgSingleton getInstance() {
        return uniqueInstance;
    }
}

延迟实例化与急切实例化的优缺点也较明显：

如果此对象开销较大，而整个过程又没有利用，则急切实例化出来的对象，白白消耗了资源。

而延时实例化同步问题，存在开销较大的情况，于是有了 下面的双重检查加锁方式。

3. 双重检查加锁

public class DoubleSynSingleton {
    private static volatile DouleSynSingleton uniqueInstance;

    private DoubleSynSingleton() {}
    public static DoubleSynSingleton getInstance() {
        if (uniqueInstance == null) {
            synchronized(DoubleSynSingleton.class) {
                if(uniqueInstance == null)
                    uniqueInstance = new DoubleSynSingleton();
            }
        }
        return uniqueInstance;
    }
}

如上所示，仅当第一次new对象时，使用synchronized方法，随后获取对象实例时都在外层的 if (uniqueInstance == null) 判断后完成退出，不要随后的同步代码块。如此，性能得到提升。