设计模式小结-单例模式(Singleton Pattern)

前言：作为一个程序员，哪怕是刚入行的程序员，对于设计模式都会有所认识，那设计模式到底是什么呢？笔者的理解是，每一种设计模式是对于一种重复性工作的解决方式，能够简化工作效率，提高编码能力，当然了，这只是笔者自己对于设计模式的一点点理解。

设计模式遵循六大原则，这个是通用的原则，本文就不作具体的原则介绍了，这里只是简单介绍一下，设计模式遵循的总原则：开闭原则，就是在设计代码的时候，尽量做到，代码能够很好的支持可扩展性，达到"接口"的作用,在实现新功能的时候，不需要去修改之前的代码，只需要实现这个"接口"，就能达到目的，便于代码的维护以及功能升级。

设计模式的分类：总的来说，设计模式按照类型来分的话，分为三类：

    1. 创建性模式：单例模式，工厂模式，抽象工厂模式，建造者模式，原型模式

    2. 结构性模式：适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式

    3. 行为性模式：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式

本文讲解单例模式

单例模式是指：在java程序中，单例模式能够唯一保证在一个jvm中只存在一个该类型的对象实例。熟悉spring的程序员来说，单例模式的最好应用就是spring 中 bean 的创建了，在spring 中，所有的bean默认都是单例类型的，在ContextLoaderLister启动webApplicationContext的时候，系统应用中所有的通过xml方式；注解方式：例如@Service；java configuration:@Configuration实现的bean都会被创建成单例对象。

单例模式的好处：

        1. 在整个应用系统中，某些对象需要频繁不断的创建和销毁，这对于系统来说，是很大的内存消耗，给gc带来了很大的压力。

        2. 有些系统中，某些对象只允许被创建一次

        3. 可以设置系统全局的访问点，达到优化和共享资源访问的功能

单例模式的坏处：

        1. 单例模式一般没有暴露接口，很难去扩展，要想实现新功能或者维护，只能够去修改源代码

单例模式的具体实现过程(正确的实现)：单例模式其实是使用内部类来实现的，这只是其中的一种实现方式

package com.ctp.ghub.designpattern.singleton;

/**
 * Created by Administrator on 2018/6/30 0030.
 */
public class Singleton {

    //确保当前类不能够被实例化
    private Singleton(){
    }

    //内部类来实例化该对象
    private static class SingletonFactory{
        private static final Singleton singleton = new Singleton();
    }

    //获取实例
    public static Singleton getSingleton(){
        return SingletonFactory.singleton;
    }
}

还有一种写法，直接利用类的静态变量，在类被jvm加载的时候，作为类的一个变量实例化，存储在jvm内存的方法区内

package com.ctp.ghub.designpattern;

/**
 * @author chengtianping
 * @description 单例模式，并且是线程安全的，spring 中的bean 就是单例模式
 * @date 2018/6/29
 */
public class SingletonPattern {

    private static final SingletonPattern singleton = new SingletonPattern();

    //确保当前类不能够被实例化
    private SingletonPattern(){
    }

    public static SingletonPattern getSingleton(){
        return singleton;
    }

    //类中其他方法最好也定义成静态的
}

错误的写法：

package com.ctp.ghub.designpattern.singleton;

/**
 * Created by Administrator on 2018/6/30 0030.
 */
public class Singleton {

    private static Singleton singleton = null;

    private Singleton(){
    }

    public static Singleton getSingleton(){
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

这种是在单线程的情况下，完全可以满足要求，但是在多线程的情况下，就会出现错误了，肯定会出现多个对象被实例化了

一种解决方式：加锁

package com.ctp.ghub.designpattern.singleton;

/**
 * Created by Administrator on 2018/6/30 0030.
 */
public class Singleton {

    private static Singleton singleton = null;

    private Singleton(){
    }

    public static synchronized Singleton getSingleton(){
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

这种方式太消耗性能，每次在调用getSingleton的时候都要对该方法加锁，范围太大

修改方式2：

package com.ctp.ghub.designpattern.singleton;

/**
 * Created by Administrator on 2018/6/30 0030.
 */
public class Singleton {

    private static Singleton singleton = null;

    private Singleton(){
    }

    public static Singleton getSingleton(){
        if(singleton == null){
            synchronized (singleton){
                singleton = new Singleton();   
            }
        }
        return singleton;
    }
}

这种修改方式其实也有问题，在java中对象的创建和赋值是分开来的，也就是说，new Singleton()和singleton = new Singleton()是两个步骤，而且并不能保证这两个顺序。

例如a，b线程同来进入这个方法，a线程先获得到锁，判断singleton是空，然后他执行了singleton = new Singleton(),但是jvm内部的优化机制，jvm先在堆区域分配了内存空间并赋值给singleton，但是此时其实并没有实例化Singleton类，a释放了该锁，b进入锁块，由于此时singleton已经不为空，直接释放锁并return 这个方法，此时调用这个方法的程序使用了该对象，就报空指针错误了。