Java设计模式之单例模式

今天做了一套java的面试题，里面出现了单例模式的设计，所以把以前的单例模式复习一下，顺便分享给大家
//单例模式 (Singleton)
//如果要保证系统里一个类最多只能存在一个实例时，我们就须要单例模式。这种情况在应用中经常碰到，例如缓存池，
//数据库连接池，线程池，一些应用服务实力等。在多线程的环境中，为了保证实例的唯一性其实并不简单。

/*
 * 最简单的单例模式
 * 为了限制该类的对象被随意的创建，须要保证该类的构造方法时私有的，这样外部类就无法创建该类型的对象了
 * 另外为了方便给客户对象提供次单例对象的使用，我们须要给他提供一个全局访问点
 */

public class SingletonModel {
    private static SingletonModel instance = new SingletonModel();
    
    private SingletonModel(){}
    //提供全局访问点，必须用public static属性
    public static SingletonModel getInstance(){
        return instance;
    }
}

    /*
     * 此时线程是安全的，当多个线程去访问getInstance()方法时，不会初始化多个不同的对象，这是因为
     * JVM在加载此类时，对static属性的初始化只能由一个线程执行且仅依次。
     * 客户使用该单例模式方法也非常简单
     * SingletonModel singleton = Sigleton.getInstance();
     */

/*
 * 单例模式的进阶
 * 如果时处于性能的考虑，在进行初始化类时并不进行实例化对象(static属性在加载类时就会被初始化)，
 * 只有在第一次实例时才去实例化，那么该怎么办呢
 * 延迟创建的单例模式
*/

class UnThreadSafeSingleton{
    private static UnThreadSafeSingleton instance = null;
    private UnThreadSafeSingleton(){}
    
    public static UnThreadSafeSingleton getInstance(){
        if(instance == null){ //这句判断并不是线程安全的
            instance = new UnThreadSafeSingleton();
        }
        return instance;
    }
}

/*
 * 上面的延迟创建实例中是线程不安全的，在高并发的环境中是会出现多个不同的实例对象的，如果这是在c++
 * 编写此模式，因为我们认为创建了一个单实例，忽略了其它线程所产生的对象，不会手动去回收他们，于是就
 * 产生了内存泄漏。
 * 如果要解决这个问题，须要给此方法加上synchronized关键字，代码如下
 */

class ThreadSafeSingleton{
    private static ThreadSafeSingleton instance = null;
    private ThreadSafeSingleton(){}
    
    //这样，在多的线程访问都只会实例化一个对象
    public synchronized static ThreadSafeSingleton getInstance(){
        if(instance == null){
            instance = new ThreadSafeSingleton();
        }
        return instance;
    }
}

/*
 * Double-Check Locking
 * 上面虽然实现的多线程访问的安全，但是在多线程的高并发访问的情况下，给此方法添加synchronized
 * 关键字会使得性能大不如前。
 * 使用关键字synchronized关键字对整个getInstance()方法进行同步是没有必要的:我们只要保证实例化
 * 这个对象的那段逻辑被一个线程执行就可以了，而返回的那段代码是没有必要同步的。按照这个想法实现的
 * 代码如下
 */

class DoubleCheckSingleton{
    private volatile static DoubleCheckSingleton instance = null;
    private DoubleCheckSingleton(){}
    public static DoubleCheckSingleton getInstacne(){
        if(instance == null){
            synchronized(DoubleCheckSingleton.class){
                //Double Check if it is create
                if(instance == null){
                    instance = new DoubleCheckSingleton();
                }
            }
        }
        return instance;
    }
}

    /*
     * 正式由于使用了两次的检查，我们称之为double-check locking
     * 属性instance是被volatile修饰的，因为volatile具有synchronized的可见性特点，也就是说
     * 线程能够自动的发现volatile变量的最新值，这样如果实例化成功那么其它线程就可以发现。
     */
/*
 * Initialization on demand holder懒人加载模式
 * 实现代码如下
 */

class LazyLoadedSingleton{
    
    private LazyLoadedSingleton(){}
    
    private static class LazyHolder{
        private static final LazyLoadedSingleton singletonInstance = new LazyLoadedSingleton();
    }
    public static LazyLoadedSingleton getInstance(){
        return LazyHolder.singletonInstance;
    }
}

    /*
     * 当JVM加载LazyLoadedSingleton类时，由于该类没有static属性，所有加载完成后便即可返回。
     * 只有第一次调用getInstance()方法是，JVM才会加载LazyHolder类，由于它包含一个static属性singletonInstance
     * ，所以会先初始化这个变量，根据前面多讲JVM只能让一个线程来对static进行初始化。这样就实现
     * 了一个既保证线程安全有支持延迟加载的单例模式。
     */