单例设计模式

定义

单例模式又叫做单态模式或者单件模式。在GOF书中的定义：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

单例模式的目的就是要控制特停的类只产生一个对象，当然也允许在一定情况下灵活的改变对象的个数。一个类的对象的产生是由构造函数来完成的，如果想限制对象的产生，一个办法就是将构造函数变为私有的（至少是受保护的），使得外部的类不能通过引用来产生对象，同时为了保证类的可用性，就必须提供一个自己的对象以及访问这个对象的静态方法。
单例模式可分为有状态和无状态的。有状态的单例对象一般也是可变的单例对象，多个单态对象在一起就可以作为一个状态仓库一样向外提供服务。没有状态的单例对象也就是不变单例对象，仅用作提供工具函数。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机，但只能有一个Printer Spooler，以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。总之，选择单例模式就是为了避免不一致状态，避免政出多头。

实现

1.饿汉试

//饿汉试public class Singleton {    //在类内部定义自己一个实例，使用private只供内部调用，对外不可见    private static Singleton instance = new Singleton();    //私有化空参构造方法    private Singleton(){    }    //静态工厂方法，提供了一个供外部访问得到对象的静态方法    public static Singleton getInstance() {        return instance;    }}

饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，天生就是线程安全的。

2.懒汉式

//懒汉式public class Singleton{    //先声明对象    private static Singleton instance = null;    private Singleton(){    }    //在静态工厂方法内部实例化对象    public static Singleton getInstance(){        if (instance == null) {            instance = new Singleton();        }        return instance;    }}

Singleton通过将构造方法限定为private避免了类在外部被实例化，在同一个虚拟机范围内，Singleton的唯一实例只能通过getInstance()方法访问。

但是以上懒汉式单例的实现没有考虑线程安全问题，它是线程不安全的，并发环境下很可能出现多个Singleton实例，要实现线程安全，有以下三种方式，都是对getInstance这个方法改造。

• 方法一：在getInstance方法上加同步

/在静态工厂方法内部实例化对象，并且使用synchronized关键字    public static synchronized Singleton getInstance(){        if (instance == null) {            instance = new Singleton();        }        return instance;    }

• 方法二：双重锁定

//双重检查锁定不是线程安全的，需要使用volatile关键字    private static volatile Singleton singleton = null;    public static Singleton getInstance(){        if (singleton == null) {            synchronized (Singleton.class) {                if (singleton == null) {                    singleton = new Singleton();                }            }        }        return singleton;    }

在并发环境下的单例实现方式，我们通常可以采用双重检查加锁（Double-Check-Lock）的方式来实现。

• 方法三:静态内部类

public class Singleton{    //内部类    private static class LazyLoad{        private static final Singleton INSTANCE = new Singleton();    }    //空参构造    private Singleton(){    }    public static final Singleton getInatance(){        return LazyLoad.INSTANCE;//外部类调用内部类final属性    }}

使用内部类，即实现了线程安全，又避免了同步带来的性能问题。

饿汉式和懒汉式区别

• 定义区别
  饿汉就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在的了，而懒汉比较懒，只有当调用getInstance的时候，才回去初始化这个单例。

• 线程安全区别
  饿汉式天生就是线程安全的，可以直接用于多线程而不会出现问题。
  懒汉式本身是非线程安全的，为了实现线程安全有几种额外的补救方式。

• 资源加载和性能区别
  饿汉式在类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，都会占据一定的内存，但是相应的，在第一次调用时速度也会更快，因为其资源已经初始化完成。
  而懒汉式顾名思义，会延迟加载，在第一次使用该单例的时候才会实例化对象出来，第一次调用时要做初始化，如果要做的工作比较多，性能上会有些延迟，之后就和饿汉式一样了。

三种懒汉模式的区别
第一种，在方法调用上加了同步，虽然线程安全了，但是每次都要同步，会影响性能，毕竟99%的情况下是不需要同步的。
第二种，在getInstance中做了两次null检查，确保了只有第一次调用单例的时候才会做同步，但是不是线程安全的，如果要用这种方式，需要使用volatile关键字。可以避免了每次都同步的性能损耗。
第三种，利用了classloader的机制来保证初始化instance时只有一个线程，所以也是线程安全的，同时没有性能损耗，所以一般我倾向于使用这一种。