单例模式我在上学期看一些资料时候学习过，没想到这学期的软件体系结构就有设计模式学习，不过看似篇幅不大，介绍得比较简单，在这里我总结下单例模式，一来整理之前的笔记，二来也算是预习复习课程了。

概述

单例模式 (Singleton Pattern) 是 Java 中最简单的设计模式之一，属于一种创建型模式。

单例模式保证对于每一个类加载器，一个类仅有一个唯一的实例对象，并提供一个全局的唯一访问点。

优缺点

优点：

  1. 减少内存开销。
  2. 避免对资源的多重占用。
  3. 严格控制客户程序访问其唯一的实例。
  4. 单例类的子类都是单例类。
  5. 比较容易改写为允许一定数目对象的类。

缺点：

  1. 不适用于变化的对象。
  2. 由于没有抽象层，难以扩展。
  3. 职责过重，一定程度上违背了“单一职责原则”。

核心思路

  1. 构造器私有化。
  2. 私有的静态常量成员。
  3. 公开的静态方法getInstance()，返回静态实例对象。
  4. 确保每次访问的实例对象都是同一个对象。
  5. 多线程中要保证线程安全。

实现方式

实现单例方式有五种：饿汉式、懒汉式、双重校验锁(DCL)、静态内部类、枚举。

饿汉式

优点：在类加载的时候就完成实例化，避免了线程同步问题。

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

  1. public class Singleton1 {
  2.     private static final Singleton1 INSTANCE = new Singleton1();
  4.     private Singleton1() {
  5.         System.out.println("饿汉式，可用");
  6.     }
  8.     public static Singleton1 getInstance() {
  9.         return INSTANCE;
  10.     }
  11. }

懒汉式

优点：达到了懒加载的效果。

缺点：线程不安全。

  1. 对于普通懒汉式，线程不安全。

    原因：在进入if (instance == null) 时，可能一个线程进入后就切换到了另一个线程，而此时并未创建实例对象，这个线程又再次进入了if代码块。

    1. public class Singleton2 {
    2.     private static Singleton2 instance;
    4.     private Singleton2() {
    5.         System.out.println("懒汉式，线程不安全，多线程不可用");
    6.     }
    8.     public static Singleton2 getInstance() {
    9.         if (instance == null) {
    10.             instance = new Singleton2();
    11.         }
    12.         return instance;
    13.     }
    14. }

  2. 对方法添加synchronized保证线程安全。

    synchronized保证了getInstance()线程安全，但对方法进行同步效率不高。

    1. public class Singleton3 {
    2.     private static Singleton3 instance;
    4.     private Singleton3() {
    5.         System.out.println("懒汉式(synchronized方法)，效率太低");
    6.     }
    8.     public static synchronized Singleton3 getInstance() {
    9.         if (instance == null) {
    10.             instance = new Singleton3();
    11.         }
    12.         return instance;
    13.     }
    14. }

  3. 改进方案2，使用synchronized代码块。

    使用了synchronized代码块改进，但又出现了和方案1一样的线程安全问题。

    1. public class Singleton4 {
    2.     private static Singleton4 instance;
    4.     private Singleton4() {
    5.         System.out.println("懒汉式(synchronized代码块)，线程不安全，多线程不可用");
    6.     }
    8.     public static Singleton4 getInstance() {
    9.         if (instance == null) {
    10.             synchronized (Singleton4.class) {
    11.                 // 此处若有线程阻塞，其它线程就仍可以进入到了前面if
    12.                 instance = new Singleton4();
    13.             }
    14.         }
    15.         return instance;
    16.     }
    17. }

双重校验锁(DCL)

针对上一个改进，使用两个if (instance == null) 。

这里先别管实现的Serializable接口和readResolve()方法，这两个用于后面的序列化测试。

另外，此处的volatile声明是很重要的，volatile变量有两种特性。

一是保证了此变量对所有线程的可见性。“可见性”指的是当一条线程修改了这个变量的值，新值对于其它线程来说是可以立即知道的。

二是禁止指令重排序优化。但volatile变量的运行在并发编程下并非是安全的，因为不能保证原子性。详细请自己去看相关资料。

  1. import java.io.Serializable;
  3. public class Singleton5 implements Serializable {
  4.     private static final long serialVersionUID = 1L;
  5.     private static volatile Singleton5 instance;
  7.     private Singleton5() {
  8.         System.out.println("懒汉式优化(Double Check Lock)双重校验锁，推荐用");
  9.     }
  11.     public static Singleton5 getInstance() {
  12.         if (instance == null) {
  13.             // 未被初始化，但是无法确定这时其他线程是否已经对其初始化，因此添加对象锁进行互斥
  14.             synchronized (Singleton5.class) {
  15.                 // 再一次进行检查，因为有可能在当前线程阻塞的时候，其他线程对instance进行初始化
  16.                 if (instance == null) {
  17.                     // 此时还未被初始化的话，在这里初始化可以保证线程安全
  18.                     instance = new Singleton5();
  19.                 }
  20.             }
  21.         }
  22.         return instance;
  23.     }
  25.     // 如果该对象被用于序列化,该方法可以保证对象在序列化前后保持一致
  26.     private Object readResolve() {
  27.         return getInstance();
  28.     }
  29. }

静态内部类

静态内部类方式在类被加载时并不会立即实例化。

而是在需要实例化时，调用getInstance()方法，才会装载内部类，从而完成对象实例化。

  1. import java.io.Serializable;
  3. public class Singleton6 implements Serializable {
  4.     private static final long serialVersionUID = 1L;
  6.     private Singleton6() {
  7.         System.out.println("饿汉式优化(静态内部类)，推荐用");
  8.     }
  10.     private static class SingletonInstance {
  11.         private static final Singleton6 INSTANCE = new Singleton6();
  12.     }
  14.     public static Singleton6 getInstance() {
  15.         return SingletonInstance.INSTANCE;
  16.     }
  18.     // 如果该对象被用于序列化,该方法可以保证对象在序列化前后保持一致
  19.     private Object readResolve() {
  20.         return getInstance();
  21.     }
  22. }

枚举

枚举方法不仅保证了线程安全问题，还提供了序列化机制。

  1. public enum Singleton7 {
  2.     INSTANCE;
  4.     private Singleton7() {
  5.         System.out.println("枚举，最好方法");
  6.     }
  8.     public static Singleton7 getInstance() {
  9.         return INSTANCE;
  10.     }
  11. }

测试

线程安全测试

  1. public class TestSafety {
  2.     static Singleton1 s1_a;
  3.     static Singleton1 s1_b;
  4.     static Singleton2 s2_a;
  5.     static Singleton2 s2_b;
  6.     static Singleton3 s3_a;
  7.     static Singleton3 s3_b;
  8.     static Singleton4 s4_a;
  9.     static Singleton4 s4_b;
  10.     static Singleton5 s5_a;
  11.     static Singleton5 s5_b;
  12.     static Singleton6 s6_a;
  13.     static Singleton6 s6_b;
  14.     static Singleton7 s7_a;
  15.     static Singleton7 s7_b;
  17.     public static void getS1_A() {
  18.         s1_a = Singleton1.getInstance();
  19.     }
  21.     public static void getS1_B() {
  22.         s1_b = Singleton1.getInstance();
  23.     }
  25.     public static void getS2_A() {
  26.         s2_a = Singleton2.getInstance();
  27.     }
  29.     public static void getS2_B() {
  30.         s2_b = Singleton2.getInstance();
  31.     }
  33.     public static void getS3_A() {
  34.         s3_a = Singleton3.getInstance();
  35.     }
  37.     public static void getS3_B() {
  38.         s3_b = Singleton3.getInstance();
  39.     }
  41.     public static void getS4_A() {
  42.         s4_a = Singleton4.getInstance();
  43.     }
  45.     public static void getS4_B() {
  46.         s4_b = Singleton4.getInstance();
  47.     }
  49.     public static void getS5_A() {
  50.         s5_a = Singleton5.getInstance();
  51.     }
  53.     public static void getS5_B() {
  54.         s5_b = Singleton5.getInstance();
  55.     }
  57.     public static void getS6_A() {
  58.         s6_a = Singleton6.getInstance();
  59.     }
  61.     public static void getS6_B() {
  62.         s6_b = Singleton6.getInstance();
  63.     }
  65.     public static void getS7_A() {
  66.         s7_a = Singleton7.getInstance();
  67.     }
  69.     public static void getS7_B() {
  70.         s7_b = Singleton7.getInstance();
  71.     }
  73.     public static void main(String[] args) {
  74.         Thread t1_a = new Thread(TestSafety::getS1_A);
  75.         Thread t1_b = new Thread(TestSafety::getS1_B);
  76.         t1_a.start();
  77.         t1_b.start();
  78.         try {
  79.             Thread.sleep(1000);
  80.         } catch (InterruptedException e) {
  81.             e.printStackTrace();
  82.         }
  83.         System.out.println("s1_a == s1_b ? " + (s1_a == s1_b));
  84.         System.out.println();
  86.         Thread t2_a = new Thread(TestSafety::getS2_A);
  87.         Thread t2_b = new Thread(TestSafety::getS2_B);
  88.         t2_a.start();
  89.         t2_b.start();
  90.         try {
  91.             Thread.sleep(1000);
  92.         } catch (InterruptedException e) {
  93.             e.printStackTrace();
  94.         }
  95.         System.out.println("s2_a == s2_b ? " + (s2_a == s2_b));
  96.         System.out.println();
  98.         Thread t3_a = new Thread(TestSafety::getS3_A);
  99.         Thread t3_b = new Thread(TestSafety::getS3_B);
  100.         t3_a.start();
  101.         t3_b.start();
  102.         try {
  103.             Thread.sleep(1000);
  104.         } catch (InterruptedException e) {
  105.             e.printStackTrace();
  106.         }
  107.         System.out.println("s3_a == s3_b ? " + (s3_a == s3_b));
  108.         System.out.println();
  110.         Thread t4_a = new Thread(TestSafety::getS4_A);
  111.         Thread t4_b = new Thread(TestSafety::getS4_B);
  112.         t4_a.start();
  113.         t4_b.start();
  114.         try {
  115.             Thread.sleep(1000);
  116.         } catch (InterruptedException e) {
  117.             e.printStackTrace();
  118.         }
  119.         System.out.println("s4_a == s4_b ? " + (s4_a == s4_b));
  120.         System.out.println();
  122.         Thread t5_a = new Thread(TestSafety::getS5_A);
  123.         Thread t5_b = new Thread(TestSafety::getS5_B);
  124.         t5_a.start();
  125.         t5_b.start();
  126.         try {
  127.             Thread.sleep(1000);
  128.         } catch (InterruptedException e) {
  129.             e.printStackTrace();
  130.         }
  131.         System.out.println("s5_a == s5_b ? " + (s5_a == s5_b));
  132.         System.out.println();
  134.         Thread t6_a = new Thread(TestSafety::getS6_A);
  135.         Thread t6_b = new Thread(TestSafety::getS6_B);
  136.         t6_a.start();
  137.         t6_b.start();
  138.         try {
  139.             Thread.sleep(1000);
  140.         } catch (InterruptedException e) {
  141.             e.printStackTrace();
  142.         }
  143.         System.out.println("s6_a == s6_b ? " + (s6_a == s6_b));
  144.         System.out.println();
  146.         Thread t7_a = new Thread(TestSafety::getS7_A);
  147.         Thread t7_b = new Thread(TestSafety::getS7_B);
  148.         t7_a.start();
  149.         t7_b.start();
  150.         try {
  151.             Thread.sleep(1000);
  152.         } catch (InterruptedException e) {
  153.             e.printStackTrace();
  154.         }
  155.         System.out.println("s7_a == s7_b ? " + (s7_a == s7_b));
  156.         System.out.println();
  157.     }
  158. }

输出结果：

  1. 饿汉式，可用
  2. s1_a == s1_b ? true
  4. 懒汉式，线程不安全，多线程不可用
  5. 懒汉式，线程不安全，多线程不可用
  6. s2_a == s2_b ? false
  8. 懒汉式(synchronized方法)，效率太低
  9. s3_a == s3_b ? true
  11. 懒汉式(synchronized代码块)，线程不安全，多线程不可用
  12. 懒汉式(synchronized代码块)，线程不安全，多线程不可用
  13. s4_a == s4_b ? false
  15. 懒汉式优化(Double Check Lock)双重校验锁，推荐用
  16. s5_a == s5_b ? true
  18. 饿汉式优化(静态内部类)，推荐用
  19. s6_a == s6_b ? true
  21. 枚举，最好方法
  22. s7_a == s7_b ? true

序列化测试

只对双重校验锁、静态内部类、枚举测试。

默认只有枚举能保证序列化后对象仍相等，其它需要加readResolve()方法才能。

  1. import java.io.FileInputStream;
  2. import java.io.FileOutputStream;
  3. import java.io.ObjectInputStream;
  4. import java.io.ObjectOutputStream;
  5. import java.nio.file.Path;
  6. import java.nio.file.Paths;
  8. public class TestSerializable {
  9.     // 测试序列化后的对象是否相等
  10.     public static void main(String[] args) {
  11.         Singleton5 s5_a = Singleton5.getInstance();
  12.         Singleton5 s5_b = Singleton5.getInstance();
  13.         System.out.println("序列化前：s5_a == s5_b ? " + (s5_a == s5_b));
  14.         Path file5 = Paths.get("object5.txt");
  15.         try (ObjectOutputStream out = new ObjectOutputStream(
  16.                 new FileOutputStream(file5.toFile()))) {
  17.             out.writeObject(s5_a);
  18.         } catch (Exception e) {
  19.             e.printStackTrace();
  20.         }
  21.         try (ObjectInputStream in = new ObjectInputStream(
  22.                 new FileInputStream(file5.toFile()))) {
  23.             s5_b = (Singleton5) in.readObject();
  24.         } catch (Exception e) {
  25.             e.printStackTrace();
  26.         }
  27.         System.out.println("序列化后：s5_a == s5_b ? " + (s5_a == s5_b));
  28.         System.out.println();
  30.         Singleton6 s6_a = Singleton6.getInstance();
  31.         Singleton6 s6_b = Singleton6.getInstance();
  32.         System.out.println("序列化前：s6_a == s6_b ? " + (s6_a == s6_b));
  33.         Path file6 = Paths.get("object6.txt");
  34.         try (ObjectOutputStream out = new ObjectOutputStream(
  35.                 new FileOutputStream(file6.toFile()))) {
  36.             out.writeObject(s6_a);
  37.         } catch (Exception e) {
  38.             e.printStackTrace();
  39.         }
  40.         try (ObjectInputStream in = new ObjectInputStream(
  41.                 new FileInputStream(file6.toFile()))) {
  42.             s6_b = (Singleton6) in.readObject();
  43.         } catch (Exception e) {
  44.             e.printStackTrace();
  45.         }
  46.         System.out.println("序列化后：s6_a == s6_b ? " + (s6_a == s6_b));
  47.         System.out.println();
  49.         Singleton7 s7_a = Singleton7.getInstance();
  50.         Singleton7 s7_b = Singleton7.getInstance();
  51.         System.out.println("序列化前：s7_a == s7_b ? " + (s7_a == s7_b));
  52.         Path file7 = Paths.get("object7.txt");
  53.         try (ObjectOutputStream out = new ObjectOutputStream(
  54.                 new FileOutputStream(file7.toFile()))) {
  55.             out.writeObject(s7_a);
  56.         } catch (Exception e) {
  57.             e.printStackTrace();
  58.         }
  59.         try (ObjectInputStream in = new ObjectInputStream(
  60.                 new FileInputStream(file7.toFile()))) {
  61.             s7_b = (Singleton7) in.readObject();
  62.         } catch (Exception e) {
  63.             e.printStackTrace();
  64.         }
  65.         System.out.println("序列化后：s7_a == s7_b ? " + (s7_a == s7_b));
  66.         System.out.println();
  67.     }
  68. }

先把readResolve()方法注释掉；输出结果为：

  1. 懒汉式优化(Double Check Lock)双重校验锁，推荐用
  2. 序列化前：s5_a == s5_b ? true
  3. 序列化后：s5_a == s5_b ? false
  5. 饿汉式优化(静态内部类)，推荐用
  6. 序列化前：s6_a == s6_b ? true
  7. 序列化后：s6_a == s6_b ? false
  9. 枚举，最好方法
  10. 序列化前：s7_a == s7_b ? true
  11. 序列化后：s7_a == s7_b ? true

加上readResolve()方法，枚举不需要，枚举甚至连Serializable接口都不需实现；输出结果如下：

  1. 懒汉式优化(Double Check Lock)双重校验锁，推荐用
  2. 序列化前：s5_a == s5_b ? true
  3. 序列化后：s5_a == s5_b ? true
  5. 饿汉式优化(静态内部类)，推荐用
  6. 序列化前：s6_a == s6_b ? true
  7. 序列化后：s6_a == s6_b ? true
  9. 枚举，最好方法
  10. 序列化前：s7_a == s7_b ? true
  11. 序列化后：s7_a == s7_b ? true

使用场景

  • 文件管理系统
  • 日志记录类
  • 与数据库的连接

应用实例

java.lang.Runtime#getRuntime()

Java设计模式 - 单例模式（创建型模式）的更多相关文章

  1. Java设计模式之创建型模式

    创建型模式分为五类:工厂方法模式.抽象工厂模式.单例模式.建造者模式.原型模式 一.工厂方法模式:接口-实现类.工厂类

  2. Java设计模式_创建型模式_单例模式

    单例模式的实现: 定义一个类,在类中定义该类的静态变量,再定一个一个获取该类的静态变量的方法. UML图:

  3. [C#]设计模式-单例模式-创建型模式

    单例模式用于在整个软件系统当中保持唯一实例,在 C# 当中最能够体现此概念的就是静态类,静态类的生命周期是跟随整个程序,并且在整个程序中仅保有一个实例. 不过在这里我们不再详细阐述单例模式与静态类有什 ...

  4. Java设计模式 - - 单例模式 装饰者模式

    Java设计模式 单例模式 装饰者模式 作者 : Stanley 罗昊 [转载请注明出处和署名,谢谢!] 静态代理模式:https://www.cnblogs.com/StanleyBlogs/p/1 ...

  5. 设计模式（Java版）-创建型模式之简单工厂模式

    前言:这段时间在学习设计模式,本人也是小菜一枚(所以写的如果有错误的地方请大大们给予指出).这个东西也是我一直想学习的,从点点滴滴做起,记录下自己每天的领悟! 一.工厂模式的动机 在软件系统中,经常面 ...

  6. GoF的23种设计模式之创建型模式的特点和分类

    创建型模式的主要关注点是“怎样创建对象?”,它的主要特点是“将对象的创建与使用分离”.这样可以降低系统的耦合度,使用者不需要关注对象的创建细节,对象的创建由相关的工厂来完成.就像我们去商场购买商品时, ...

  7. Typescript玩转设计模式 之 创建型模式

    作者简介 joey 蚂蚁金服·数据体验技术团队 前言 我们团队的工作是用单页面应用的方式实现web工具.涉及到数万到十数万行的前端代码的管理,而且项目周期长达数年. 怎么样很好地管理好这种量级的前端代 ...

  8. 单例模式——创建型模式01

    1. 名称     单例模式(Singleton Pattern):确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例,这个类称为单例类.单例模式是一种对象创建型模式. 2. 问题    ...

  9. 设计模式01 创建型模式 - 单例模式(Singleton Pattern)

    参考 [1] 设计模式之:创建型设计模式(6种) | 博客园 [2] 单例模式的八种写法比较 | 博客园 单例模式(Singleton  Pattern) 确保一个类有且仅有一个实例,并且为客户提供一 ...

  10. Java设计模式之职责型模式总结

    原创作品,可以转载,但是请标注出处地址:http://www.cnblogs.com/V1haoge/p/6548127.html 所谓职责型模式,就是采用各种模式来分配各个类的职责. 职责型模式包括 ...

随机推荐

  1. 集合系列 List（二）：ArrayList

    ArrayList 是 List 集合的列表经典实现,其底层采用定长数组实现,可以根据集合大小进行自动扩容. public class ArrayList<E> extends Abstr ...

  2. python实例：利用jieba库，分析统计金庸名著《倚天屠龙记》中人物名出现次数并排序

    本实例主要用到python的jieba库 首先当然是安装pip install jieba 这里比较关键的是如下几个步骤: 加载文本,分析文本 txt=open("C:\\Users\\Be ...

  3. （五十）c#Winform自定义控件-滑块

    前提 入行已经7,8年了,一直想做一套漂亮点的自定义控件,于是就有了本系列文章. GitHub:https://github.com/kwwwvagaa/NetWinformControl 码云:ht ...

  4. Java 并发编程(一)：摩拳擦掌

    这篇文章的标题原本叫做——Java 并发编程(一):简介,作者名叫小二.但我在接到投稿时觉得这标题不够新颖,不够吸引读者的眼球,就在发文的时候强行修改了标题(也不咋滴). 小二是一名 Java 程序员 ...

  5. react antd 关于selectedRows 的问题

    在table中,经常会用到单选和多选的功.这里会有一个方法, 当触发onchange的时候回有两个数组,[selectedRowKeys, selectedRows],当前选中的keys和每一项, 这 ...

  6. 域渗透-LSA Protection

    简介: 微软在 2014 年 3 月 12 日添加了 LSA 保护策略,用来防止对进程 lsass.exe 的代码注入,这样一来就无法使用 mimikatz 对 lsass.exe 进行注入,相关操作 ...

  7. 【故障公告】再次出现数据库 CPU 居高不下的问题以及找到问题的线索

    非常非常抱歉,今天上午的故障又一次给大家带来麻烦了,再次恳请大家的谅解. 在昨天升级阿里云 RDS SQL Server 实例的配置后(详见昨天的博文),万万没有想到,今天上午更高配置的阿里云 RDS ...

  8. 2019 Multi-University Training Contest 3

    B.Blow up the city solved by F0_0H 210min 题意 给一个DAG,每次询问给定u,v,求使得u或v不能与中心点联通的关键点个数 做法 按照拓扑序建树 新加节点的父 ...

  9. HDU 6357 Hills And Valleys

    Hills And Valleys 题意:给你一个序列, 可以翻转一次区间 [l, r] 求最大 非递减的 序列长度. 题解:枚举翻转区间,然后匹配. 如果不翻转区间, 那么就相当于用b[] = {0 ...

  10. bzoj 4025 二分图 lct

    题目传送门 题解: 首先关于二分图的性质, 就是没有奇环边. 题目其实就是让你判断每个时段之内有没有奇环. 其次 lct 只能维护树,(反正对于我这种菜鸟选手只会维护树), 那么对于一棵树来说, 填上 ...