单例设计模式

单例设计模式

简介

​ 单例模式是设计模式中最简单的形式之一。 单例设计模式通常来讲，就是确保一个类在一个应用程序中只能存在一个实例，并提供一个访问它的全局访问点。一般我们会提供一个静态方法来供全局访问。

应用场景

1. 各种资源池类（pool）对象。如：线程池，数据库连接池，HTTP连接池
2. 缓存（cache）
3. 对话框，前端经常使用的模态框
4. 注册表等
5. 容器对象，例如：SpringIOC容器等

构建方式

在Java语言中，由两种构建方式：

• 懒汉式，指代全局的单例实例会在第一次被使用的时候才进行构建。
  • 优点：符合了按需加载，当需要用到的时候才构建，避免了资源的浪费
  • 缺点：如果单例对象消耗资源很大，那么构建的时候可能很长，这样会造成时间上的开销。
• 饿汉式，指代全局的单例实例在类加载的时候就进行构建。
  • 优点：可以在应用程序启动的时候就创建，这样即使是再庞大的对象，将创建时候都消耗在了程序启动阶段，在运行阶段减少了对象创建对于时间上的开销。
  • 缺点：如果该对象在应用中没有被用到，极大程度上的浪费了内存。

总而言之，两种方式优缺点都是相对的，具体方式还是需要看具体业务场景。

单例实现

​ 接下来分析一下各种单例的实现。

1. 饿汉式

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

上述这种方式采用静态常量方式进行创建，由于静态常量在内存中，对于每个对象来说，只会共享一份，避免多线竞争的问题。属于线程安全的单例模式。

2. 饿汉式

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

这种方式跟第一种类似，只是将创建地点放在静态代码块中。

3. 静态内部类

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

这种方式也是跟上述的两种方式有些类似，都是利用JVM加载类，来确保线程的安全性。在类加载的时候，是天然线程隔离的。

唯一不同的是，这里采用的懒加载机制（Lazy-loading），当调用getInstance方法时，JVM才会去加载SingletonInner这个静态内部类。所以它能保证（延迟加载+线程安全）。

4.枚举

public enum Singleton{
    INSTANCE;
    public void something(){
        
    }
}

上述实现方式是依托JDK5中的新特性，枚举来实现的，这种方式是天然线程安全的，利用JVM的特性来实现。枚举天生具有final属性，它既不能被创建，也不能被扩展。实质上就是一个final的类，每个被导出来的类都是静态final的属性。跟前面几种实现方式都是类似的，都是利用JVM保证线程安全。

5. 懒汉式

public class Singleton{
   	
    private static Singleton singleton;
    private Singleton{}
    
    public static Singleton getInstance{
        // 非线程安全，当多线程竞争的时候，会出现多个Singleton实例。
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

这种方式属于懒加载模式的单例实现，但是不是线程安全的，在多线程的场景下，会创建多个Singleton对象。singleton == null并不能保证多线程的先来后到。

上述改进：

public class Singleton{
   	
    private volatile static Singleton singleton;
    private Singleton{}
    
    public static Singleton getInstance{
        // 非线程安全，当多线程竞争的时候，会出现多个Singleton实例。
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

加上volatile关键字后，只能保证多线程下singleton变量都会读取最新值，并不能保证线程同步。

再改进：

public class Singleton{
   	
    private volatile static Singleton singleton;
    private Singleton{}
    
    public static synchronized  Singleton getInstance{
        // 非线程安全，当多线程竞争的时候，会出现多个Singleton实例。
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

加上同步关键字，这样可以保证线程安全，但是降低了性能。

6. 双重检查锁（Double-Check）

public class Singleton{
   	
    private volatile static Singleton singleton;
    private Singleton{}
    
    public static  Singleton getInstance{
     
        if(singleton == null){
            // 这里锁的是Singleton.class 是因为Singleton在JVM中只会存在一份。不能使用this替代
            synchronized(Singleton.class){
                if(singleton == null){
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

这种方式属于懒加载的一种实现，当第一次调用getInstance时，才会创建单例对象。两次singleton == null用来保证多线程下的，只有一个线程能够顺利创建单例对象。

这里也是用到了同步加锁，但是它比其他的同步方式要高效，为什么呢？因为这里的锁，阻塞在第二次singleton == null，当多线程中，有一个线程进入到第二个singleton == null，那么其他的线程都会被阻塞，当后续的线程进入到第一个singleton == null会直接跳过。从而保证大部分的线程不会进入锁等待。相较于锁方法，效率明显提高。

单例可靠保证

上述的几种实现方式，为了防止对象被外部实例化，都对构造器进行了私有化，当然这样无可厚非，确实应该这样做，但是Java提供的反射机制其实是可以破坏这种束缚的。当使用者调用AccessibleObject.setAccessible方法时，可以强行创建对象。为了抵御这种攻击，我们可以进一步优化我们的代码，让对象再第二次被创建时，抛出异常。

public class Singleton{
    private final static Singleton INSTANCE = new Singleton();
    private Singleton{
        if(INSTANCE ! = null){
            // 抛出一个异常
        }
    }
    
    public static Singleton getInstance{
        return  INSTANCE;
    }
}

当然还需要注意一点，当对象被序列化与反序列时，单例仍然容易被破坏。为了遏制这种破坏，我们可以选择重写readResolve方法

public class Singleton{
    private final static Singleton INSTANCE = new Singleton();
    private Singleton{
        if(INSTANCE ! = null){
            // 抛出一个异常
        }
    }
    
    public static Singleton getInstance{
        return  INSTANCE;
    }
    
    public Object readResolve(){
        return INSTANCE;
    }
}

对象在进行反序列化时，当对象实现了serializable或者externalizable接口，且重写readResolve方法的话，会直接调用readResolve方法来获取实例。那么我们就直接返回INSTANCE，防止单例被破坏。

最后需要主要的是，防止程序中出现多个类加载器来加载单例对象，不同的类加载器加载的同一个对象是不相同，如果程序中出现多个类加载器的情况下，应该指定专门的类加载器加载单例对象。

总结

​ 上述的实现方式各有千秋，但是最常用的还是第一种和第三种实现方式，Netty源码中就是大量使用第一种方式，方便快捷，没那么多条条道道。枚举方式很少看见，下面的几种实现感觉都不怎么好，实现起来考虑点也多。