单例模式

概述

单例模式是比较简单的设计模式，使用也是非常的广泛。看一下关于单例模式的定义：

确保一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

它的定义包含了三个要点：

• 一个类只有一个实例：外部程序无法通过new关键字来创建实例，构造方法用private修饰
• 自行实例化：由类本身创建实例对象，为了外界可以访问这个实例，需要定义成静态的私有成员变量。
• 提供实例： 因为无法提供new来床架对象，只能提供一个公有静态方法，返回创建的对象实例。

来看一下单例模式的通用代码：

饿汉式单例

class Singleton {
    private static final Singleton singletonTest = new Singleton();  //创建实例
    private Singleton() {}   //构造方法私有

    public static Singleton getInstance(){
        return singletonTest ;  //返回实例
    }
}

public class SingletonTest{
    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance() ;
        Singleton s2 = Singleton.getInstance();

        System.out.println(s1 == s2);  //true
    }
}

上面这种写法是最简单的写法，但是有一个问题，就是在类加载的时候就创建了实例，而不管是否需要创建这个实例，没有做到延迟加载 ，增加了负载。

懒汉式单例

为了解决上面的问题，对上面的通用代码进行如下改进，当系统需要该实例的时候，才产生实例对象，并返回，代码如下：

class LazySingleton{

    private static  LazySingleton  singleton = null ;

    private LazySingleton(){}

    public static LazySingleton getInstance(){
        if(singleton == null ){
            singleton = new LazySingleton() ;
        }
        return  singleton ;
    }
}

通过上面的代码发现，在类加载的时候并没有进行类的初始化操作，只有在第一次调用getInstance()方法时，才进行了实例化操作，实现了延迟加载的功能。那么问题又来了，啥问题问题，上面的类在单线程环境是没有问题的，但是在多线程环境中是不安全的无法保证实例的唯一性，那么在改进一下，看下面代码：

class LazySingleton{

    private static  LazySingleton  singleton = null ;

    private LazySingleton(){}

    public static synchronized LazySingleton getInstance(){
        if(singleton == null ){
            singleton = new LazySingleton() ;
        }
        return  singleton ;
    }
}

在getInstance的方法上添加了synchronized关键字，来保证线程之间的同步，确保实例的唯一性。看起来已经解决了上面的问题，但是新的问题其实又出现了，什么问题呢？ 就是每次访问getInstance()方法时都进进行线程锁定的判断，在多线程高并发的环境下，使得系统的性能大大的降低了，那么有什么办法来解决这个问题吗？ 当然有，看下面代码：

class LazySingleton{

    private static  LazySingleton  singleton = null ;

    private LazySingleton(){}

    public static LazySingleton getInstance(){
        if(singleton == null ){
            synchronized (LazySingleton.class){
                singleton = new LazySingleton() ;
            }

        }
        return  singleton ;
    }
}

最初为了保证线程之间的同步问题，给getInstance()的整个方法加了锁，其实要保证同步的罪魁祸首其实是 singleton=new LazySingleton()这句，只要保证了它的同步，产生的实例就是唯一的，所以使用synchronized块，来保证线程之间的同步。 这样在完成了singleton初始化之后，便不会在进入synchronized中，系统的性能便不会受影响了。 程序看起来已经很完美了，事实确实是这样吗？ 当然不是，再次被打脸了，分析一下，假设现在有两个线程A ,B 都执行到了 if() 出，线程A先执行了，获得了锁，此时完成了singleton的初始化操作，释放锁 ，B开始执行，因为B并不知道此时singleton已经完成了实例的创建，会再次创建一个实例。 好的，我们在改进一下 ：

class LazySingleton{

    private volatile static  LazySingleton  singleton = null ;

    private LazySingleton(){}

    public static LazySingleton getInstance(){
        if(singleton == null ){
            synchronized (LazySingleton.class){
                if(singleton == null){
                    singleton = new LazySingleton() ;
                }
            }

        }
        return  singleton ;
    }
}

在synchronized块中，又进行了一次条件判断，这种方式称为双重检查锁定。 另外在变量的声明中添加了volatile关键字。关于volatile简单说两句，由于singleton使用了volatile修饰，一旦一个线程对改变做了修改，会马上由工作内存写回到主内存中，被其他线程所读取，工作内存可以理解为被线程独享，主内存可以理解为线程共享，被volatile修饰的成员变量可以确保多个线程都能够正确的处理，但是该代码只能在jdk1.5及以上的版本中才能正确执行。现在9都快要发布了， 相信现在还运行在1.5以下的程序应该不是很多了，应该影响不大， 这里只是提一下。 volatile关键字会禁止指令重排序优化，屏蔽到java虚拟机所做的一下代码优化，可能会导致运行效率降低， 这看起来也不是一个非常完美的实现方式。

饿汉式单例和懒汉式单例的比较

• 饿汉式单例在类加载时就完成了初始化操作，因此无须考虑多线程的并发访问问题，正是由于它一开始就进行了实例化操作，从资源的利用和加载的时间上考虑可能比懒汉式要差一点
• 懒汉式单例实现了延迟加载，但是在多线程并发访问的情况下对性能还是有一定的影响。

既然饿汉式和懒汉式都存在自己的问题，有没有一种方式能解决它们的问题呢，当然有，看下面代码:

通过使用静态内部类实现单例

public class StaticInnerClass {
    private StaticInnerClass(){}
    private static class InnerClass{
        private static final StaticInnerClass singleton = new StaticInnerClass() ;
    }

    public static StaticInnerClass getInstance(){
        return InnerClass.singleton ;
    }
}

调用getInstance()方法时，才进行实例的初始化操作，由于是static变量只会进行一次初始化操作，有JVM来保证线程的安全性。 即实现了延迟加载，有可以保证线程的安全。

枚举实现单例

//单例类
class Resource{
    public Resource(){
        System.out.println("resouce 构造方法");
    }
}

//枚举类生成Resource的单个实例
public enum EnumSingleton{
    INSTANCE ;

    private Resource resource ;
    private EnumSingleton(){
        System.out.println("EnumSingleton 构造方法执行");
        resource = new Resource() ;
    }

    public Resource getInstance(){
        return  resource ;
    }
}

//测试类及运行结果
public class Test {
    public static void main(String[] args) {
        Resource s1 = EnumSingleton.INSTANCE.getInstance() ;
        Resource s4 = EnumSingleton.INSTANCE.getInstance() ;
        Resource s3 = EnumSingleton.INSTANCE.getInstance() ;
        Resource s2 = EnumSingleton.INSTANCE.getInstance() ;

        if(s1==s2 && s2 ==s3 && s3==s4 && s1 ==s4){
            System.out.println("同一个引用");
        }
    }
}

//运行结果
EnumSingleton 构造方法执行
resouce 构造方法
同一个引用

在枚举类中构造方法私有化，外部无法访问，在访问枚举实例时会执行构造方法，实例化Resouce对象，枚举实例都是static final类型的，只能被实例化一次。这也是effective java中推荐的方式。

单例模式的优点：

• 在内存中只有一个实例，减少了内存的开支，无须频繁的创建、销毁
• 减少了系统的性能开销，避免了资源的多重占用

缺点：

• 没有接口，扩展相对比较困难，违背了单一职责的原则

使用场景：

要求一个类有且仅有一个对象，只允许有一个公共的访问节点。 可以使用单例模式。

---

少年听雨歌楼上，红烛昏罗帐。  
壮年听雨客舟中，江阔云低，断雁叫西风。
感谢支持！
                                        ---起个名忒难

---