设计模式笔记01——设计原则

介绍

自行实例化并向整个系统提供这个实例。这个类称为单例类
单例只有一个实例对象
单例自己创建自己实例，构造函数为私有
单例提供唯一的实例给外部引用

实现方式

单例模式实现由很多种形式，我们并不进行列举，直说一些比较常用的。单例模式最常见的莫过于懒汉式和饿汉式了，这也是最简单的两种实现方式，其他的实现方式还有双重检查加锁、Lazy initialization holder class模式、枚举等

饿汉式

这种形式的单例最为简单且直接。那就是用final关键字全局声明的时候直接实例化，然后将构造函数进行私有化就可以完成一个单例了。

    private static final UserInfo instance = new UserInfo();

    public static UserInfo getInstance() {
        return instance;
    }

    private UserInfo() {
    }

说明

这种实现非常简单且直接，同时带来的就是资源的消耗，无论需不需要用的到这个对象都会被实例化。

懒汉式

相对于饿汉式来说，懒汉式只有在首次需要用到单例的时候才会被实例化，如果不需要那么就不会被实例化。

    private static UserInfo instance = null;

    public static UserInfo getInstance() {
        if (instance == null) {
            instance = new UserInfo();
        }
        return instance;
    }

    private UserInfo() {
    }

当getInstance被调用的时候首先对instance对象进行判空，随后实例化返回instance对象。

所谓懒汉和饿汉是一个形象说法，第一种由于声明直接实例化，就像一个饿了的大汉一样看到吃的就直接去吃；懒汉呢就是需要时候再去获取吃的。

说明

懒汉式相较于前面的饿汉式节省了内存的开销，当需要单例对象的时候才会实例化单例对象。但是对于多线程并发调用getInstance的时候，大家就会发现其实这时候并不能保证getInstance中只实例化了一个instance对象，后面的很多中实现其实也就是为了解决这个问题个出现的。

线程安全

为了解决并发调用现象，我们可以使用synchronized关键字，例如：

    private static  UserInfo instance = null;

    public static synchronized UserInfo  getInstance() {
        if (instance == null) {
            instance = new UserInfo();
        }
        return instance;
    }

    private UserInfo() {
    }

那么这个实现可以防止并发请求的时候进行了多次实例化。但是这样就会导致多个线程被同时阻挡在getInstance方法，影响线程执行性能。

为了提高性能，减少被挡线程的可能性，我们对上面的实现进行了修改

    private static  UserInfo instance = null;

    public static synchronized UserInfo  getInstance() {
        if (instance == null) {
            synchronized (UserInfo.class){
                instance = new UserInfo();
            }
        }
        return instance;
    }

    private UserInfo() {
    }

那么这样就会不至于所有调用getInstance方法的线程都会被阻塞，而且在一定程度上完成了上面的需求。但是这样我们就会发现依然无法完全避免单例对象被重复实例化，原因在于首次调用getInstance发放被synchronized阻挡的线程数超过1的时候，就会导致额外的实例化操作。

双重检查加锁

首先介绍一个关键字——volatile，这个关键字应该不算陌生，我发现很多单例中都或多或少见过。
volatile关键字标记的变量意味着线程共享内存！也就是在多线程程序中其实调用该对象是同一个内存位置，以保证各个线程调用获取到的是实时数据
这样结合线程锁配合使用，不但可以保证线程安全，而且可以保证实例的唯一性
注意：volatile可能屏蔽掉虚拟机优化内容，从而可能降低虚拟机运行效率

范例

结合上面的线程并发方案，我们的实现可以修改为：

    private static volatile  UserInfo instance = null;

    public static synchronized UserInfo  getInstance() {
        if (instance == null) {
            synchronized (UserInfo.class){
                if (instance == null) {
                    instance = new UserInfo();
                }
            }
        }
        return instance;
    }

    private UserInfo() {
    }

其实和上面的最后实现没什么不一样，唯一的不同是多了一个关键字volatile的修饰。这个volatile修饰可以保证当我们的getInstance中synchronized被挡住线程超过1的时候，线程1执行实例化之后线程2继续接着向下执行，这时候线程2就会获取instance对象真实情况，然后进行下面的程序执行。
这种单例实现是目前看到比较多的，因为没什么难度，而且比较实用。但是不太建议一个系统中过多使用，如果项目中单例过多，那么也会导致性能缺陷，上面也提到了volatile关键字会屏蔽一些虚拟机的优化方案

Lazy initialization holder class模式

这个模式综合使用了Java的类级内部类和多线程缺省同步锁的知识，很巧妙地同时实现了延迟加载和线程安全

介绍

Lazy Initialization Holder Class 模式主要是利用了java虚拟机类装载机制，保证了getInstance方法调用前不会被装载，第一次被调用之后内部类才会被装载，而这时候同时会装载类的静态域

利用了类级内部静态类的加载，从而延迟了内部静态类的装载，即延迟了instance对象的实例化过程！这是一个饿汉式的类级内部类实现方式

因为java装载静态内容只会初始化一次，因此保证了线程安全，其次也做到了延迟加载的目的

使用场景

这种实现方式更多的强调一种使用场景的可能性，而非单例类独立为整个系统提供服务。例如：一个系统内部某个模块内部的配置项，在这个过程中可以使用这种方式，当该模块未启用的时候，其实没有任何额外的资源开销，但是一旦模块被调用的时候，java虚拟机就会加载相关类，这时候连带着静态内部类也被加载（有且只加载一次，而且这个由java虚拟机控制），这时候利用静态内部加载的配置内容进行模块初始化等操作。

这种方式在公共库、SDK开发中比较喜欢用到，尤其是对于平台类的SDK开发。原因就是一个SDK中可能存在多个模块，而且这些模块在没有被初始化的时候希望不要打扰集成APP的业务和实现，乃至SDK某部分模块的使用。

枚举

使用枚举来实现单实例控制会更加简洁，而且无偿地提供了序列化机制，并由JVM从根本上提供保障，绝对防止多次实例化，是更简洁、高效、安全的实现单例的方式

枚举属于引用数据类型还是基本数据类型？这个问题在java中相比很多人都说不清楚，其实我也讲不明白，但是我记得C#语言中属于基本数据类型。
即使不是基本数据类型那么他也不会是普通引用数据类型，因为枚举的值是固定的，而且不能够被手动实例化创建。也正是因为这个所以也成为了一个天然的常量装载机制。
当然枚举单例用的很少，因为对象之所以被广泛应用就在于其操作可以依据特定条件发生变化，例如全局配置项。如果用了枚举操作起来不是很方便，而且很多单例是需要外界数据交互的，例如：当前登录账户，当前设置项等

总结

单例模式实现方式很多种，无论哪一种都存在一些缺点，依据使用场景做出选择。

日常项目使用比较多的还是属于双重检查加锁，在模块比较多的时候，需要通过外部初始化固定模块的情况下我们可以采用模块独立的Lazy initialization holder class模式 这种方式相对而言比较可靠，当然也可以使用双重检查加锁，但是上面也提到了java虚拟机会屏蔽一些优化内容，可能会影响性能，因此对于单例比较多的时候避免频繁使用双重检查加锁！
当然Lazy initialization holder class模式实现一般相较而言比较麻烦一些。