设计模式之单例模式

        写作缘由：对于一个有逼格的程序猿，23种设计模式应该不在话下，为了挤身逼格程序猿之列，决定系统的学习设计模式

        关于设计模式（主要是思想方面）

               001.定义：

                               是一套反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结

               002.目的：

                               为了可重用代码、让代码更容易被他人理解、保证代码可靠性

        设计模式之最简单模式 ------> 单例模式：

               001.定义：

                               确保单例类只有一个实例，并且这个单例类提供一个函数接口让其他类获取到这个唯一的实例

               002.生活情景：

                              古代皇帝，有且只能有一个，多个则会出问题...

                              男人娶老婆，有且只能有一个，多了则会...

               003.编程情景：

                              如果某个类，创建时需要消耗很多资源，即new出这个类的代价很大；或者是这个类占用很多内存，如果创建太多这个类实例会导致内存占用太多，简单点比如：

                              配置文件、工具类、线程池、缓存、日志等等，这些需要保证整个应用中有且只有一个实例

               004.分类：饿汉式、懒汉式（代码已经做了详细说明） 

 

public class Singleton {
    //-----------------------------饿汉模式----------------------------
    /**
     * 饿汉式的特点是加载类的时候比较慢，要创建类的唯一的实例，但是运行时获取
     * 对象的速度比较快
     * 线程安全
     */
    //1.将构造方法私有化，不允许外部直接创建对象
    private Singleton() {

    }

    //2.创建类的唯一实例，使用private、static 修饰
    /**
     * 静态成员属于类所有，在类加载的时候他就会执行，不管用户是否去调用这个实例，
     * 它都已经加载了，只要类加载了它就加载了。所以我们称之为饿汉模式，它要早些吃饱
     */
    private static Singleton instance = new Singleton();

    //3.提供一个用于获取实例的方法，使用public、static 修饰
    public static Singleton getInstance() {
        return instance;
    }

    //-----------------------------懒汉模式----------------------------
    /**
     * 懒汉式的特点是加载类的时候比较快，但是在运行时获取对象的速度比较慢，
     * 因为在用户第一次获取的时候会去创建唯一的实例的过程
     * 线程不安全
     */
    
    //1.将构造方法私有化，不允许外部直接创建对象
    private Singleton() {

    }

    //2.声明类的唯一实例，使用private、static 修饰
    /**
     * 在第一个用户获取时才会去创建实例，后期用户再次获取时不会再次创建
     * 实例，所以称之为懒汉式
     */
    private static Singleton instance;

    //3.提供一个用于获取实例的方法，使用public、static 修饰
    public static Singleton getInstance() {
        if (null == instance) {
            synchronized (Singleton.class) {
                if (null == instance) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

             005.分析：

                           根据你的具体需求选择不同的单例模式

                           针对懒汉式：

                                  双重非空判断保证了程序的健壮性：

                                         第一次判断是为了避免不必要的创建

                                         第二次判断是确保在此之前没有其他线程进入到sychronized块创建了新实例

                                 然而问题来了，主要是在instance=new Singleton();这段代码上。这段代码会编译成多条指令，大致上做了3件事:

                                 （1）给Singleton实例分配内存
                                 （2）调用Singleton()构造函数，初始化成员字段
                                 （3）将instance对象指向分配的内存（此时instance就不是null啦~）

              上面的（2）和（3）的顺序无法得到保证的，也就是说，JVM可能先初始化实例字段再把 instance指向具体的内存实例，也可能先把 instance指向内存实例再对实例进行初始化成员字段。考虑这种情况：一开始，第一个线程执行 instance=new Singleton();这句时，JVM先指向一个堆地址，而此时，又来了一个线程2，它发现 instance不是 null，就直接拿去用了，但是堆里面对单例对象的初始化并没有完成，最终出现错误~

              下面这种模式可以解决这种问题：

public class Singleton {
    
    private volatile static Singleton instance;

    //将默认的构造函数私有化，防止其他类手动
    private Singleton() {
    }

    public static Singleton getInstance() {
        if (instance == null) {
            sychronized(Singleton.class) {
                if (instance == null)
                    instance = new Singleton();
            }
        }
        return instatnce;
    }
}

            分析：

                   这里只是对 instance变量加了一个 volatile关键字 volatile关键字的作用是：线程每次使用到被 volatile关键字修饰的变量时，都会去堆里拿最新的数据。换句话说，就是每次使用instance时，保证了instance是最新的（ volatile不做详细介绍，可以自行查找资料）。

    

           注意：

                   用不用 volatile，这里给出建议性的选择，在两个或者更多的线程访问的成员变量上使用volatile。当要访问的变量已在synchronized代码块中，或者为常量时，不必使用

 

            006.参考博文：

                    点击查看参考博文

                    
                    点击查看参考博文