设计模式——创建型模型——单列模式(8种实现)

前言：
👏作者简介：我是笑霸final，一名热爱技术的在校学生。
📝个人主页：个人主页1 || 笑霸final的主页2
📕系列专栏：计算机基础专栏
📧如果文章知识点有错误的地方，请指正！和大家一起学习，一起进步👀
🔥如果感觉博主的文章还不错的话，👍点赞👍 + 👀关注👀 + 🤏收藏🤏

一、单例模式定义

单例模式（Singleton Pattern）：属于创建类型的一种常用的软件设计模式。通过单例模式的方法创建的类在当前进程中只有一个实例

特点

• a、单例类只能有一个实例。
• b、单例类必须自己创建自己的唯一实例。
• c、单例类必须给所有其他对象提供这一实例。
• 单例模式保证了全局对象的唯一性，比如系统启动读取配置文件就需要单例保证配置的一致性。

二、单列模式分类

设计模式代码仓库

• 1.饿汉式（静态常量）【可用】

• 2.饿汉式（静态代码块）【可用】

  饿汉式都可能造成内存的浪费

• 3.懒汉式（线程不安全）【不可用】

• 4.懒汉式（线程安全，同步方法）【不可用】

• 5.懒汉式（线程安全，同步代码块）【不可用】[

• 6.双重检查【推荐使用】

• 7.静态内部类【推荐使用】

• 8.枚举【推荐使用】[枚举]

三、饿汉式【可用】

下面两种方式都可用 但是都可能造成内存的浪费

3.1饿汉式（静态常量）

• 饿汉式(静态变量)【可用】
  ====================================================================
• 优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了步问题
• 缺点：在类装载的时候就完成实例化，没有达到Lazy Loading（懒加载）的效果。
• 如至终从未使用过这个实例，则会造成内存的浪费

class Singleton1{/*** 1.构造器私有化，防止外部new*/private Singleton1(){}/*** 在内部创建实例对象* 在内加载的时候创建对象实例*/private final static Singleton1 instance=new Singleton1();/*** 对外提供一个共有的静态方法返回这个实例*/public static Singleton1 getInstance(){return instance;}
}

3.2饿汉式（静态代码块）

• 饿汉式(静态代码块)【可用】================================================================
• 优缺点：和饿汉式(静态变量)类似
• 只不过将类实例化的过程放在了静态代码块中，
• 也是在类装载的时候，就执行静态代码块中的代码，
• 初始化类的实例。优缺点和上面是一样的。

class Singleton2{/*** 1.构造器私有化，防止外部new*/private Singleton2(){}/*** 在静态代码块中创建实例对象*/private static  Singleton2 instance;static {instance=new Singleton2();}/*** 对外提供一个共有的静态方法返回这个实例*/public static Singleton2 getInstance(){return instance;}}

四、懒汉式【不可用】

4.1懒汉式（线程不安全）【不可用】

• 懒汉式（线程不安全 ）【不可用】========================================================================
• 优点：起到了Lazy Loading的效果，但是只能在单线程下使用。
• 缺点：如果在多线程下，一个线程进入了if (singleton == null)判断语块，
• 还未往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例在多线程环境下不可使用这种方式

class Singleton3{private Singleton3(){}private static  Singleton3 instance;/*** 提供一个静态公有方法，当使用该方法时。才去创建instance*/public static  Singleton3 getInstance(){if(instance==null){//没有创建才去创建instance = new Singleton3();}//返回实例return instance;}}

4.2懒汉式（线程安全，同步方法）【不可用】

• 懒汉式（线程安全 ,同步方法）【不可用】========================================================================
• 优点：解决了线程不安全问题
• 缺点：效率太低了，每个线程在想获得类的实例时候，
• 执行getlnstance()方法都要‘synchronized同步’。而其实这个方法只执行一次实例化代码就够了，
• 后面的想获得该直接return就行了。方法进行同步效率太低
• 结论:在实际开发中，效率低 不推荐使用这种方式

class Singleton4{private Singleton4(){}private static  Singleton4 instance;/*** 提供一个静态公有方法，加入了同步处理的代码 ，解决线程安全问题* 当使用该方法时。才去创建instance*/public static synchronized Singleton4 getInstance(){if(instance==null){//没有创建才去创建instance = new Singleton4();}//返回实例return instance;}}

4.3 懒汉式（线程安全 ,同步代码块）【不可用】

• 懒汉式（线程安全 ,同步代码块）【不可用】========================================================================
• 但是这种同步并不能起到线程同步的作用。跟第Singleton3实现方式遇到的情形一致，
• 假如一个线程进入了if (singleton == null)判断语句块，还未来得及往下执行，
• 另一个线程也通过了这个判断语句，这时便会产生多个实例。

class Singleton5{private Singleton5(){}private static  Singleton5 instance;/*** 提供一个静态公有方法，加入了同步处理的代码 ，解决线程安全问题* 当使用该方法时。才去创建instance*/public static  Singleton5 getInstance(){if(instance==null){synchronized(Singleton5.class){instance = new Singleton5();}}//返回实例return instance;}}

五、双重检查

• 双重检查=========================================================================

优点说明:

• Double-Check概念是多线程开发中常使用到的，如代码中所示，
• 我们进行次if (singleton == null)检查，这样就可以保证线程安全了
• 这样，实例化代码只用执行一次，后面再次访问时，判断if (singleton =null)直接return实例化对象，
• 也避免的反复进行方法同步
• 线程安全;延迟加载;效率较高
• 结论: 在实际开发中，推荐使用这种单例设计模式

class Singleton6{private static volatile Singleton6 instance;private Singleton6(){}/*** 提供一个静态公有方法，加入双重检查的代码 ，解决线程安全问题，同时解决懒加载问题* 也保证了效率*/public static synchronized Singleton6 getInstance(){if(instance==null){synchronized(Singleton6.class){if(instance==null){instance = new Singleton6();}}}//返回实例return instance;}}

volatile

volatile 是Java提供的一种轻量级的同步机制。Java 语言包含两种内在的同步机制：同步块（或方法）和 volatile 变量，相比于synchronized（synchronized通常称为重量级锁），volatile更轻量级，因为它不会引起线程上下文的切换和调度。但是volatile 变量的同步性较差（有时它更简单并且开销更低），而且其使用也更容易出错。

下面简单总结一下volatile的作用：

• 它会强制将对缓存的修改操作立即写入主存，让所有的线程可见；

• 它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成；

• 如果是写操作，它会导致其他CPU中对应的缓存行无效。

六、静态内部类

• 这种方式跟饿汉式方式采用的机制类似，但又有不同。
• 两者都是采用了类装载的机制来保证初始化实例时只有一个线程。
• 不同的地方在饿汉式方式是只要Singleton类被装载就会实例化，
• 没有Lazy-Loading的作用，而静态内部类方式在Singleton类被装载时并不会立即实例化，
• 而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的实例化。
• 类的静态属性只会在第一次加载类的时候初始化，
• 所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。

class Singleton7 {private Singleton7() {}/*** 静态内部类*/private static class SingletonInstance {private static final Singleton7 INSTANCE = new Singleton7();}public static Singleton7 getInstance() {return SingletonInstance.INSTANCE;}}

• 特点：
• 1.外部类装载时 静态内部类不会立即被装载
• 2.调用getInstance() 静态内部类才会被装载而且只会装载一次
• 优点：避免了线程不安全，延迟加载，效率高。

七、枚举

借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象

public class Enumeration {public static void main(String[] args) {Singleton singleton1 = Singleton.INSTANCE;Singleton singleton2 = Singleton.INSTANCE;System.out.println(singleton1==singleton2);System.out.println(singleton1.hashCode());System.out.println(singleton2.hashCode());}
}/*** 枚举========================** 借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象*/
enum Singleton{//属性INSTANCE;public void sayOK(){}
}

八、适用场景：

单例模式只允许创建一个对象，因此节省内存，加快对象访问速度，因此对象需要被公用的场合适合使用，如多个模块使用同一个数据源连接对象等等。如：

• 需要频繁实例化然后销毁的对象。
• 创建对象时耗时过多或者耗资源过多，但又经常用到的对象。
• 有状态的工具类对象。
• 频繁访问数据库或文件的对象。

功有所不全,力有所不任,才有所不足。欢迎大家指正文中错误
设计模式代码仓库 欢迎start====》设计模式代码仓库