23种设计模式之Singleton

23种设计模式之Singleton

1、Singleton是啥玩意？

单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的类有且只有一个实例。即一个类只有一个对象实例。

2、实现思路：

单例模式要求类能够有返回对象一个引用(永远是同一个)和一个获得该实例的方法（必须是静态方法，通常使用getInstance这个名称）

单例的实现主要是通过以下两个步骤：

a)、将该类的构造方法定义为私有方法，这样其他处的代码就无法通过调用该类的构造方法来实例化该类的对象，只有通过该类提供的静态方法来得到该类的唯一实例；

b)、在该类内提供一个静态方法，当我们调用这个方法时，如果类持有的引用不为空就返回这个引用，如果类保持的引用为空就创建该类的实例并将实例的引用赋予该类保持的引用。

3、具体写法：（以下内容来自的程序猿001：https://www.cnblogs.com/zhaoyan001/p/6365064.html）

    1)、饿汉式（静态常量）[可用]

// 饿汉式单例 public class Singleton1 { // 私有构造 private Singleton1() {} private static Singleton1 single = new Singleton1(); // 静态工厂方法 public static Singleton1 getInstance() { return single; } }

优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。

缺点：在类装载的时候就完成实例化，没有达到Lazy Loading的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费。

    2)、饿汉式（静态代码块）[可用]

public class Singleton { private static Singleton instance; static { instance = new Singleton(); } private Singleton() {} public Singleton getInstance() { return instance; } }

这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。优缺点和上面是一样的。

    3)、懒汉式(线程不安全)[不可用]

public class Singleton { private static Singleton singleton; private Singleton() {} public static Singleton getInstance() { if (singleton == null) { singleton = new Singleton(); } return singleton; } }

这种写法起到了Lazy Loading的效果，但是只能在单线程下使用。如果在多线程下，一个线程进入了if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式。

    4)、懒汉式(线程安全，同步方法)[不推荐用]

public class Singleton { private static Singleton singleton; private Singleton() {} public static synchronized Singleton getInstance() { if (singleton == null) { singleton = new Singleton(); } return singleton; } }

解决上面第三种实现方式的线程不安全问题，做个线程同步就可以了，于是就对getInstance()方法进行了线程同步。

缺点：效率太低了，每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行了。方法进行同步效率太低要改进。

    5)、懒汉式(线程安全，同步代码块)[不可用]

public class Singleton { private static Singleton singleton; private Singleton() {} public static Singleton getInstance() { if (singleton == null) { synchronized (Singleton.class) { singleton = new Singleton(); } } return singleton; } }

由于第四种实现方式同步效率太低，所以摒弃同步方法，改为同步产生实例化的的代码块。但是这种同步并不能起到线程同步的作用。跟第3种实现方式遇到的情形一致，假如一个线程进入了if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。

    6)、双重检查[推荐用]

public class Singleton { private static volatile Singleton singleton; private Singleton() {} public static Singleton getInstance() { if (singleton == null) { synchronized (Singleton.class) { if (singleton == null) { singleton = new Singleton(); } } } return singleton; } }

Double-Check概念对于多线程开发者来说不会陌生，如代码中所示，我们进行了两次if (singleton == null)检查，这样就可以保证线程安全了。这样，实例化代码只用执行一次，后面再次访问时，判断if (singleton == null)，直接return实例化对象。

优点：线程安全；延迟加载；效率较高。

    7)、静态内部类[推荐用]

public class Singleton { private Singleton() {} private static class SingletonInstance { private static final Singleton INSTANCE = new Singleton(); } public static Singleton getInstance() { return SingletonInstance.INSTANCE; } }

    这种方式跟饿汉式方式采用的机制类似，但又有不同。两者都是采用了类装载的机制来保证初始化实例时只有一个线程。不同的地方在饿汉式方式是只要Singleton类被装载就会实例化，没有Lazy-Loading的作用，而静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的实例化。

    类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。

优点：避免了线程不安全，延迟加载，效率高。

8)、枚举[推荐用]

public enum Singleton { INSTANCE; public void whateverMethod() { } }

（以上代码来自的程序猿001： https://www.cnblogs.com/zhaoyan001/p/6365064.html）

9)、下面C#集中单例

public class Singleton { private static object Singleton_Lock = new object(); private Singleton() { } private static Singleton _Singleton = null; public static Singleton CreateInstance() { if (_Singleton == null)//先看看是否初始化过 { lock (Singleton_Lock)//一开始线程都等待这里 { if (_Singleton == null)//还是检测是否为空 { _Singleton = new Singleton(); } } } return _Singleton; } } public class SingletonSecond { private long LResult = 0; private SingletonSecond() { } static SingletonSecond()//CLR运行时候 第一次使用这个类之前，一定会而且只会执行一次 { _SingletonSecond = new SingletonSecond(); } private static SingletonSecond _SingletonSecond = null; public static SingletonSecond CreateInstance() { return _SingletonSecond; } } public class SingletonThird { private SingletonThird() { } private static SingletonThird _SingletonThird = new SingletonThird(); public static SingletonThird CreateInstance() { return _SingletonThird; } }以上C#三种单例的创建，仅供参考

4、为啥不用静态方法？

单例模式比静态方法有很多优势：首先，单例可以继承类，实现接口，而静态类不能（可以集成类，但不能集成实例成员）；其次，单例可以被延迟初始化，静态类一般在第一次加载是初始化；再次，单例类可以被集成，他的方法可以被覆写；最后，或许最重要的是，单例类可以被用于多态而无需强迫用户只假定唯一的实例。举个例子，你可能在开始时只写一个配置，但是以后你可能需要支持超过一个配 置集，或者可能需要允许用户从外部从外部文件中加载一个配置对象，或者编写自己的。你的代码不需要关注全局的状态，因此你的代码会更加灵活。

 

以上观点都是网上搜集来的，说的也很有道理，但对于一成不变的配置信息或者方法，建议还是用静态。

 

此外，静态类在程序启动的时候就已经写入内存并永久存在，而单件在需要使用的时候创建，并且可以提供销毁内存的方法，在使用之后摧毁。而静态类的代码最简洁，单件稍微复杂些静态类是对全局方法、全局变量的分类组织方法。单件有且仅有一个对象。单件类可以被继承。有些时候确实很模糊，使用任何一种方式皆可。静态类改成实例类，需要更改所有的调用接口。单件类接口可以不动，将创建实例交由调用方代码处理即可。

6、对于网上的非议

Q：既然是面向对象编程，就应该用单例

A：这简直是胡扯。虽说“万物一切皆对象”，但也不能为了面向对象而面向对象。如果考虑到你的类需要被继承或者实现某个接口，就需要用单例。否则尽量用静态。

 

Q：静态线程不安全，就应该用单例

A：类是否线程安全和是否静态类没啥关系吧。要看类的内部在处理数据时，有没有做并发处理，单件类也可以做到线程安全。静态方法是安全的 ，但是如果方法中用到了静态变量就变成不安全了。（只看这个类有没有会被多线程修改的数据有这种数据，不管静态类还是单例模式都要加锁，没有这种数据，都不需要加锁）

 

Q： “静态方法常驻内存，实例方法不是，所以静态方法效率高但占内存”，好些大牛都反驳这些观点，认为没什么区别。

A：确实如此，但是你们有没有想过我可以在单例创建时，可以提供销毁内存的方法啊，使用之后直接摧毁。