设计模式（一）——单例设计模式

设计模式大家一定不陌生，Java语言中我们经常会有意无意的就使用到一些设计模式，那么设计模式到底是什么，为什么要使用设计模式呢？

其实设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。说白了就是整理写法，让代码更系统化，优化代码量，使用更方便。

使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。

设计模式分为很多种，今天先跟大家分享一下最基础常用的一种设计模式——单例设计模式。首先了解下什么是单例设计模式：
它是一种对象创建模式，它用于产生一个对象的具体实例，它可以确保系统中一个类只产生一个实例。

使用单例设计模式有什么好处：
一、对于频繁使用的对象，可以省略创建对象所花费的时间，这对于那些重量级对象而言，是非常可观的一笔系统开销
二、由于new操作的次数减少，因而对系统内存的使用频率也会降低 ，这将减轻GC（垃圾回收器）压力，缩短GC停顿时间。

单例模式严格来说共有6中写法，其中饿汉式与懒汉式是最基本的两种，大家是一定需要掌握的，后面4中也是在这基础上进行优化的，下面我们就先来了解饿汉式：

/**
 * 饿汉式
 */
public class HungrySingleton {

    //一开始就创建对象
    private static final HungrySingleton mHungrySingleton = new HungrySingleton();

    //构造方法私有，外部就无法通过构造方法创建对象
    private HungrySingleton(){}

    //向外部暴露公有的静态方法，返回实例
    public static HungrySingleton getInstance(){
        return mHungrySingleton;
    }
}

可以看到，饿汉式单例设计模式，一开始他就会创建这个类的实例，然后将默认构造方法设为私有的private，这样外部就无法通过构造方法创建对象了，最后它会创建一个公有的、静态的，返回值为类对象本身的getInstance方法，这个方法是暴露给外部使用的。

这样每次外部通过getInstance方法得到的对象就是这个类中一开始就实例化出来的对象，所以叫单例模式。

但是饿汉式存在一个缺点：
无法对Instance实例做延时加载。即它一开始就会直接创建一个对象，即使不使用时，单例仍然会被创建

所以我们能不能对饿汉式进行优化呢？让它可以在我们需要使用这个对象时在创建呢？所以便有了下面这种写法，懒汉式：

/**
 * 懒汉式
 */
public class LazySingleton {

    //并不直接实例对象
    private static LazySingleton mLazySingleton;

    //构造方法私有
    private LazySingleton() {

    }

    public static LazySingleton getInstance() {

        //第一次调用时会判断这个对象有没有被实例化
        if (mLazySingleton == null) {
            //为空就实例化
            mLazySingleton = new LazySingleton();
        }
        //不为空说明已经实例化过了，直接返回该对象
        return mLazySingleton;
    }
}

相比较饿汉式，我们做了2处优化：
一、并不直接实例对象。
二、调用getInstance()方法时会进行一个为空判断，保证不会每次调用getInstance()方法都会new一个对象。

但是懒汉式也有缺点：
它在多线程并发下这样的实现是无法保证实例是唯一的。
什么意思呢？比如有多个线程同时调用了getInstance()方法，它们同时进入判断是否为空，为空创建对象，就有可能同时创建了多个对象。

针对懒汉式的缺点，又出现了第3种写法，懒汉式线程安全：
就是在为空判断时加上synchronize同步锁，此处有两种方式使用synchronize同步锁：

/**
 * 懒汉式线程安全
 */
public class LazySafetySingleton {

    private static LazySafetySingleton mLazySafetySingleton;

    //构造方法私有
    private LazySafetySingleton() {

    }

    //第一种：方法中声明synchronized关键字
    public static synchronized LazySafetySingleton getInstance() {
        if (mLazySafetySingleton == null) {
            mLazySafetySingleton = new LazySafetySingleton();
        }
        return mLazySafetySingleton;
    }


    //第二种：同步代码块实现
    public static LazySafetySingleton getInstance() {
        synchronized (LazySafetySingleton.class) {
            if (mLazySafetySingleton == null) {
                mLazySafetySingleton = new LazySafetySingleton();
            }
        }
        return mLazySafetySingleton;
    }
}

解决了线程安全的缺点，但是又来一个缺点：
如果有多个线程同时调用了getInstance()方法，第一个进去会将对象锁上，后面的就必须等待第一个执行完才能进去第二个，当调用这个方法的线程很多时，就限定了访问速度，这样就会导致性能上的缺陷。

为了解决这个问题，下面介绍单例设计模式的第四种写法，DCL模式（ DoubleCheckedLock双检锁模式）：

/**
 * DCL模式
 */
public class DclSingleton {

    //使用volatile关键字
    private static volatile DclSingleton mDclSingleton = null;

    private DclSingleton(){

    }

    public static DclSingleton getInstance(){

        //避免不必要的同步
        if (mDclSingleton == null){
            //首次初始化对象的时候同步
            synchronized (DclSingleton.class){
                //第一次调用时初始化
                if (mDclSingleton == null){
                    //这行代码在不同编译器上的行为是无法预知的
                    mDclSingleton = new DclSingleton();
                }
            }
        }
        //之后的获取不需要同步锁
        return mDclSingleton;
    }
}

可以看到我们在这里使用了volatile关键字，因为JVM（java虚拟机）的即时编译器中存在指令重排序的优化（这里不做深究，大家只要知道因为多线程可能导致其中几行代码不是顺序执行），所以加上volatile关键字来解决这个问题。

这里我们仅仅是在首次初始化对象的时候进行了同步，从而使代码即正确又保证了执行效率。

接着是第五种，也是最推荐使用的一种，静态内部类模式：

/**
 * 静态内部类模式
 */
public class StaticInnerSingleton {

    private StaticInnerSingleton(){

    }

    public static StaticInnerSingleton getInstance(){
        return SingletonHolder.mStaticInnerSingleton;
    }

    //静态内部类
    private static class SingletonHolder{

        private static final StaticInnerSingleton mStaticInnerSingleton = new StaticInnerSingleton();
    }
}

静态内部类中使用了static和final，保证了其唯一性，也就是线程安全，它没有性能缺陷，是最推荐使用的一种单例设计模式。

最后一种模式，单例枚举设计模式（java5之后才能实现）：

public enum EnumSingleton{
    INSTANCE;
}

因为枚举的三个特性，自由序列化，线程安全，保证单例。简简单单的一点代码就实现了一个线程安全，懒加载的单例。是不是完美的应用了enum的性质？

优势：写法简单，线程安全
劣势：枚举类型的内存消耗要远大于其他类型，在性能上是比较耗内存的。

以上就是此次分享给大家的全部内容，供大家参考，有问题或者更好的建议也欢迎大家提出来。