设计模式篇---单例模式

概念

单例模式是结构最简单的设计模式，通过单例模式可以保证在整个系统中的一个类只有一个实例，从而节约系统资源。举个例子，比如windows电脑下的任务管理器只能打开一个，这个就是单例模式，如果不这样做，则会弹出多个窗口，但这些窗口显示的内容完全一样，浪费了资源。

单例模式定义：确保一个类只有一个实例，并提供一个全局访问点来访问这个唯一实例。

单例模式有3个要点：
1、某个类只能有一个实例。
2、该类必须自行创建这个实例。
3、该类必须自行向整个系统提供这个实例。

结构与实现

单例模式只有一个类，类图如下：

单例类拥有一个私有的构造方法，保证外部无法通过new关键字来进行实例化，此外，它还包含一个静态私有成员变量和静态公有的工厂方法，该工厂负责检验实例的存在性并实例化自己，然后存储在成员变量中。
按照被实例化的时机，单例模式可以分为两大类，懒汉模式和饿汉模式。

1、饿汉式
当类加载的时候就进行实例化，这种方式叫做饿汉式。

public class EagerSingleton {
	//static 变量在类加载的时候就已经初始化。
    private static EagerSingleton instance = new EagerSingleton();

    //private 构造，保证外部无法访问
    private EagerSingleton() {
    }

    public static EagerSingleton getInstance() {
        return instance;
    }
}

2、懒汉式
故名思义，比较懒，用的时候在实例化，也叫做延迟加载。直接上doubleCheck。

public class LazySingleton {
    private static volatile LazySingleton instance = null;
    
    private LazySingleton() {
    }

    public static LazySingleton getInstance() {
        //判断是否实例化过，是的话，则直接返回。  步骤一
        if (instance == null) {
            //防止多线程同时访问，造成多次实例化。
            synchronized (LazySingleton.class) {
                //两个线程情况下，A线程走到这里，B线程还在synchronized 外等待，
                // 当B线程进入synchronized后，A线程已经实例化完成，所以需要再次判断，防止多次实例化。
                if (instance == null) {
                // 步骤二
                    instance = new LazySingleton();
                }
            }
        }
        return instance;
    }
}

这里之所以使用volatile来修饰，是为了保证原子性和有序性。
实例化一个对象主要分为三部分
1、先给对象分配一个内存空间。
2、创建该对象的引用
3、将该引用指向该存储空间。

当线程A走到上面代码的步骤二时，仅仅是完成了上面实例化对象三步中的第一步，但线程B这时候走到了上面代码的步骤一，判断不为null，则直接返回，此时对象还未实例化完成，这就发生了错误，所以需要使用volatile来进行修饰。

3、使用静态内部类
使用静态内部类也是懒汉式的方式之一，代码如下

public class InnerClassSingleton {


    private static class InnerClass {
        private static InnerClassSingleton instance = new InnerClassSingleton();
    }

    private InnerClassSingleton() {
    }

    public static InnerClassSingleton getInstance() {
        return InnerClass.instance;
    }
}

只有当第一次调用内部类的时候，才会实例化该变量，从而保证了单例性。

优缺点

优点：
1、单例模式自己对外提供了唯一的实例，可以控制客户的使用。
2、节约系统资源。
缺点：
1、因为没有抽象层，扩展性较差。
2、违背单一职责，该类既创建对象又有业务方法，将对象的创建和使用耦合在了一起。
3、状态丢失。如果实例出来的对象长期不使用，会被垃圾回收，下次会创建出和之前不同的对象。