设计模式之单例模式

设计模式之单例模式

概述

单例模式，是一种常用的软件设计模式，在它的核心结构中只有一个被称为单例的特殊类，通过单例模式可以保证在系统中，使用该模式的类只有一个对象实例。

应用场景

1.Windows系统的任务管理器。
2.Windows系统的回收站。
3.操作系统的文件系统，一个操作系统只能有一个文件系统。
4.数据库连接池的设计与实现。
5.多线程的线程池设计与实现。
6.Spring中创建的Bean实例默认都是单例。
7.Java-Web中，一个Servlet类只有一个实例。

好处

在内存中只有一个实例，节约内存，减小开销，解决了一个全局使用的类频繁创建和销毁的问题

实现要点

单例模式要求类能够返回一个对象的引用（永远是同一个）和提供一个获得该实例的方法（静态方法）。

主要步骤如下：

1.将该类的构造器私有化，这样其他类就不能通过调用该类的构造器实例化该类的对象，只能通过调用该类的静态方法来获得该类的唯一实例。
2.定义一个私有的类的静态实例。
3.提供一个公有的获取实例的静态方法。

追求的目标

1.线程安全。
2.懒加载。
3.调用效率高。

常用写法

1.饿汉模式

public class Hunger {
    private static Hunger hunger=new Hunger();
    private Hunger(){};
    public static Hunger getInstance(){
        return hunger;
    } 
}

饿汉模式，比较常用的写法，在类加载的时候就对实例进行初始化，没有线程安全问题，由于没有使用同步，因此调用效率高，但是由于不是懒加载，因此当实例一直没被使用时，会造成内存浪费。

总结：线程安全，非懒加载，效率高。

2.懒汉模式

（1）简单的线程安全版本

public class Singleton {
 
    // 2.懒汉
    private static Singleton singleton;
 
    private Singleton() {}
 
    public static synchronized Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
 }

线程安全的懒汉模式，在第一次使用的时候才进行初始化，达到了懒加载的效果，由于获取实例的静态方法使用了synchronized修饰，因此不会有线程安全问题，但是此种写法每次获取实例都要进行同步，因此效率低。

总结：线程安全，懒加载，效率低。

（2）双重检测机制（DCL）

错误的双重检测：

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

双重检测机制，在第一次使用的时候才进行初始化，达到了懒加载的效果，在进行初始化的时候会进行同步，因此线程安全，并且只有第一次初始化的时候才进行同步，因此不会有效率方面的问题。

执行双重检查是因为，如果多个线程同时了通过了第一次检查，并且其中一个线程首先通过了第二次检查并实例化了对象，那么剩余通过了第一次检查的线程就不会再去实例化对象。

这样，除了初始化的时候会出现加锁的情况，后续的所有调用都会避免加锁而直接返回，解决了性能消耗的问题。

总结：线程安全，懒加载，效率高。

但是此种写法仍然会有问题，假设有两个线程A，B，线程A在走到第8行时初始化对象，此时线程B走到第5行进行第一次检测，这里，需要介绍下第8行这行代码，这行代码虽然只有一句话，但是被编译后会变成以下3条指令：

memory=allocate();//1.分配对象的内存空间
ctorInstance(memory);//2.初始化对象
instance=memory;//3.将对象指向刚才分配的内存地址

正常情况下，这3条执行时按顺序执行，双重检测机制就没有问题。但是CPU内部会在保证不影响最终结果的前提下对指令进行重新排序（不影响最终结果只是针对单线程，切记），指令重排的主要目的是为了提高效率。在本例中，如果这3条指令被重排成以下顺序：

memory=allocate();//1.分配对象的内存空间
instance=memory;//3.将对象指向刚才分配的内存地址
ctorInstance(memory);//2.初始化对象

如果线程A执行完1和3，instance对象还未完成初始化，但是已经不再指向null。此时线程B抢占到CPU资源，执行第5行的检测结果为false，则执行第12行，从而返回一个还未初始化完成的instance对象，从而导致问题出现。要解决这个问题，只需要使用volatile关键字修饰instance对象即可。

正确的双重检测：

public class Singleton {
    private volatile static Singleton singleton;
    private Singleton(){};
    public static Singleton getInstance(){
        if(singleton==null){
            synchronized (Singleton.class){
                if(singleton==null){
                    singleton=new Singleton();
                }
            }
        }
        return singleton;
    }
}

（3）静态内部类

public class Singleton2 {
    private Singleton2(){};
    public static final class Inner{
        private static final Singleton2 singleton2=new Singleton2();
    }
    public static final Singleton2 getInstance(){
        return Inner.singleton2;
    }
}

总结：线程安全、懒加载、效率高。

（4）枚举

public enum Singleton {
    INSTANCE;
}

枚举，不是很常见的一种写法。很简洁的一种实现方式，提供了序列化机制，保证线程安全，绝对防止多次实例化，即使是在面对复杂的序列化或者反射攻击的时候。

总结：线程安全、非懒加载、效率高。