一、单例设计模式介绍

  所谓类的单例设计模式,就是采取一定的方法保证在整个的软件系统中,对某个类只能存在一个对象实例, 并且该类只提供一个取得其对象实例的方法(静态方法)

  例如:Hibernate的SessionFactory,它充当数据存储源的代理,并负责创建Session对象。SessionFactory并不是轻量级的,一般情况下,一个项目通常只需要一个SessionFactory就够,这里就会使用到单例模式

二、单例设计模式的七种方式

  (1)饿汉式(静态常量)

    步骤:① 构造器私有化(防止new)

       ② 在类的内部创建对象

         ③ 向外暴露一个静态的公共方法。getInstance

    代码实现:

 1 /**
2 * 单例设计模式
3 * 饿汉式(静态变量)
4 */
5 public class Singleton01 {
6 //构造器私有化,防止外部创建对象
7 private Singleton01() {
8 }
9
10 //在本类内部创建对象实例
11 private final static Singleton01 instance = new Singleton01();
12
13 //对外提供公有静态方法返回实例对象
14 public static Singleton01 getInstance() {
15 return instance;
16 }
17 }
18
19
20 public class SingletonTest01 {
21 public static void main(String[] args) {
22 Singleton01 singleton01 = Singleton01.getInstance();
23 Singleton01 singleton02 = Singleton01.getInstance();
24 System.out.println(singleton01.equals(singleton02));//true
25 }
26 }

    输出结果:

    

    分析:

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

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

    这种方式基于类装载机制避免了多线程的同步问题,不过,instance在类装载时就实例化,在单例模式中大多数都是调用getInstance方法, 但是导致类装载的原因有很多种,因此不能确定有其他的方式(或者其他的静态方法)导致类装载,这时候初始化instance就没有达到懒加载的效果

    结论:这种单例模式可用,但是可能造成内存浪费

  (2)饿汉式(静态代码块)

    与上面步骤相似,不过将类实例化的过程放在了静态代码块中

    代码实现:

 1 /**
2 * 单例设计模式
3 * 饿汉式(静态代码块)
4 */
5 public class Singleton02 {
6 //构造方法私有化,防止外部new
7 private Singleton02() {
8 }
9
10 //本类内部声明对象
11 private static Singleton02 instance;
12
13 //在静态代码块中创建单例对象
14 static {
15 instance = new Singleton02();
16 }
17
18 //提供公有方法getInstance返回实例
19 public static Singleton02 getInstance() {
20 return instance;
21 }
22 }
23
24 public class Singleton02Test {
25 public static void main(String[] args) {
26 Singleton02 singleton02 = Singleton02.getInstance();
27 Singleton02 singleton03 = Singleton02.getInstance();
28 System.out.println(singleton02.equals(singleton03));//true
29 }
30 }

    输出结果:

    

    分析:

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

    结论:这种单例模式可用,但是可能造成内存浪费

  (3)懒汉式(线程不安全)

    为了解决内存浪费的问题,我们将getInstance的执行流程改为调用方法再返回实例,通俗的讲就是懒加载

    代码实现:

 1 /**
2 * 单例设计模式
3 * 懒汉式(线程不安全)
4 * */
5 public class Singleton03 {
6 private static Singleton03 instance;
7
8 private Singleton03() {
9 }
10
11 /**
12 * 当使用到该方法时再去创建实例
13 * */
14 public static Singleton03 getInstance() {
15 if (instance == null) {
16 instance = new Singleton03();
17 }
18 return instance;
19 }
20 }
21
22 public class Singleton03Test {
23 public static void main(String[] args) {
24 Singleton03 singleton03 = Singleton03.getInstance();
25 Singleton03 singleton04 = Singleton03.getInstance();
26 System.out.println(singleton03.equals(singleton04));//true
27 }
28 }

    运行结果:

    

    分析:

    起到了懒加载的效果,但是只能在单线程下使用

    如果在多线程下,一个线程进入了 if (singleton == null)判断语句块,还未来得及往下执行,另一个线程也通过了这个判断语句,这时便会产生多个实例,所以在多线程环境下不可使用这种方式

    结论:在实际开发中,不要使用这种方式

  (4)懒汉式(线程安全,同步方法)

    要解决线程不安全的问题,我们可以将getInstance方法改成同步执行,一个线程访问一个对象中的synchronized同步代码块时,其他试图访问该对象的线程将被阻塞

    代码实现:

 1 /**
2 * 单例设计模式
3 * 懒汉式(线程安全,同步方法)
4 * */
5 public class Singleton04 {
6 private static Singleton04 instance;
7
8 private Singleton04() {
9 }
10
11 /**
12 * 当使用到该方法时再去创建实例,加入同步代码,解决线程不安全问题
13 * */
14 public static synchronized Singleton04 getInstance() {
15 if (instance == null) {
16 instance = new Singleton04();
17 }
18 return instance;
19 }
20 }
21
22
23 public class Singleton04Test {
24 public static void main(String[] args) {
25 Singleton04 instance01 = Singleton04.getInstance();
26 Singleton04 instance02 = Singleton04.getInstance();
27 System.out.println("懒汉式(线程安全,同步方法):" + instance01.equals(instance02));//true
28 }
29 }

    运行结果:

    

     分析:

    优点:解决了线程安全问题

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

    结论:在实际开发中,不推荐使用这种方式

  (5)懒汉式(双重检查)

    为了同时解决线程安全和懒加载的问题,这里需要使用volatile关键字以及synchronized代码块

    volatile关键字详细解读

    代码实现:

 1 /**
2 * 单例设计模式
3 * 懒汉式(双重检查)
4 */
5 public class Singleton05 {
6 //使instance的变动立即写入到主存中
7 private static volatile Singleton05 instance;
8
9 private Singleton05() {
10 }
11
12 //提供一个静态的公有方法,加入双重检查代码,解决线程安全问题, 同时解决懒加载问题,保证了效率
13 public static Singleton05 getInstance() {
14 //解决懒加载问题
15 if (instance == null) {
16 //解决线程安全问题,保证每次只有一个线程进入该代码块
17 synchronized (Singleton05.class) {
18 if (instance == null) {
19 instance = new Singleton05();
20 }
21 }
22 }
23 return instance;
24 }
25 }
26
27 public class Singleton05Test {
28 public static void main(String[] args) {
29 Singleton05 instance01 = Singleton05.getInstance();
30 Singleton05 instance02 = Singleton05.getInstance();
31 System.out.println("懒汉式(双重检查):" + instance01.equals(instance02));
32 }
33 }

    运行结果:

    

    分析:

    Double-Check(双重检查)概念是多线程开发中常使用到的,如代码中所示,我们进行了两次 if (singleton == null)检查,这样就可以保证线程安全了

    这样,实例化代码只用执行一次,后面再次访问时,判断 if (singleton == null),直接 return 实例化对象,也避免的反复进行方法同步,线程安全,懒加载,效率较高

    结论:在实际开发中,推荐使用这种单例设计模式

  (6)静态内部类

    代码实现:

 1 /**
2 * 单例设计模式
3 * 静态内部类
4 */
5 public class Singleton06 {
6
7 //构造器私有化
8 private Singleton06() {
9 }
10
11 //静态内部类,该类内部有一个静态属性Singleton06
12 private static class SingletonInstance {
13 private static final Singleton06 INSTANCE = new Singleton06();
14 }
15
16 //提供getInstance方法直接返回实例
17 public static Singleton06 getInstance() {
18 return SingletonInstance.INSTANCE;
19 }
20 }
21
22 public class Singleton06Test {
23 public static void main(String[] args) {
24 Singleton06 instance01 = Singleton06.getInstance();
25 Singleton06 instance02 = Singleton06.getInstance();
26 System.out.println("静态内部类:" + instance01.equals(instance02));//true
27 }
28 }

    运行结果:

    

    分析:

    这种方式采用了类装载的机制来保证初始化实例时只有一个线程

    静态内部类方式在Singleton类被装载时并不会立即实例化,而是在需要实例化时,调用getInstance方法,才会装载SingletonInstance类,从而完成Singleton的实例化

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

    优点:避免了线程不安全,利用静态内部类特点实现延迟加载,效率高

    结论:推荐使用

  (7)枚举

    代码实现:

 1 /**
2 * 单例设计模式
3 * 枚举
4 */
5 public enum Singleton07 {
6 INSTANCE;//属性
7 public void sayOK(){
8 System.out.println("OK ");
9 }
10 }
11
12 public class Singleton07Test {
13 public static void main(String[] args) {
14 Singleton07 instance = Singleton07.INSTANCE;
15 Singleton07 instance01 = Singleton07.INSTANCE;
16 System.out.println("枚举:" + instance.equals(instance01));
17 instance.sayOK();
18 }
19 }

    运行结果:

    

    分析:

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

    这种方式是《Effective Java》作者 Josh Bloch  提倡的方式

    结论:推荐使用

三、总结

  多线程环境下建议使用枚举,静态内部类,双重检查等方式实现单例模式

  单线程环境下可以使用懒汉式和饿汉式的方法实现单例模式

单例设计模式(Singleton)的更多相关文章

  1. 单例设计模式Singleton之懒加载模式(懒汉模式)【原】

    单例设计模式Singleton之懒加载模式(懒汉模式) SingletonLazy.java类 package kingtool; import kingtool.http.IPTool; publi ...

  2. Java学习笔记——单例设计模式Singleton

    单例设计模式:singleton 解决的问题: 确保程序在运行过程中,某个类的实例instance只有一份. 特点: 1 构造函数私有化 2 自己内部声明自己 3 提供一个public方法,负责实例化 ...

  3. Java学习笔记(二十四):单例设计模式singleton

    为什么要使用singleton设计模式? 假设设计了一个操作数组的工具类(Tools),里面有一个锤子的方法(Hammer),如果不使用singleton设计模式,每次想调用Hammer方法都需要ne ...

  4. 单例设计模式singleton

    简单引入 单例设计模式作为最简单,最常用的设计模式.一般是这两中写法,这两种写法教科书所谓的标准写法,但是实际上存在不少问题.后面介绍标准写法,以规避这些问题. 1.懒汉式: /** * 问题在于,当 ...

  5. Java设计模式—单例设计模式(Singleton Pattern)全然解析

    转载请注明出处:http://blog.csdn.net/dmk877/article/details/50311791 相信大家都知道设计模式,听的最多的也应该是单例设计模式,这种模式也是在开发中用 ...

  6. 转:java单例设计模式

    本文转自:http://www.cnblogs.com/yinxiaoqiexuxing/p/5605338.html 单例设计模式 Singleton是一种创建型模式,指某个类采用Singleton ...

  7. 小菜学习设计模式(二)—单例(Singleton)模式

    前言 设计模式目录: 小菜学习设计模式(一)—模板方法(Template)模式 小菜学习设计模式(二)—单例(Singleton)模式 小菜学习设计模式(三)—工厂方法(Factory Method) ...

  8. 设计模式的征途—1.单例(Singleton)模式

    单例模式属于创建型模式的一种,创建型模式是一类最常用的设计模式,在软件开发中应用非常广泛.创建型模式将对象的创建和使用分离,在使用对象时无需关心对象的创建细节,从而降低系统的耦合度,让设计方案更易于修 ...

  9. java singleton(单例设计模式)

    单例设计模式的主要作用是: 1.控制资源的使用,我们对资源使用线程同步来实现并发访问. 2.节约资源,我们对一个类只进行一个实例化进行全局的资源访问,节约了内存. 3.作为通信媒介,也是数据共享,可以 ...

  10. Java基础 static限定符的使用 以及【 static实现的 singleton(单例)设计模式】

    static实现的 singleton(单例)设计模式 /** static实现的 singleton设计模式 , 使得一个类只能够创建一个static对象 */ 模板设计结构: package Co ...

随机推荐

  1. laravel7 手机号验证码登陆

    1"设置路由: //展示手机登录页面 Route::get('admin','admin\AdminController@admin'); 2:html页面 <!DOCTYPE HTM ...

  2. 微信小程序yansongda 支付宝测试

    小程序支付接入文档 1:php 框架composer 安装yansongda插件 composer require yansongda/pay:^2.10 -vvv 2:支付宝沙箱支付获取自己Appi ...

  3. 【数据库】SQL 语句大全

    数据操作 SELECT --从数据库表中检索数据行和列 INSERT --向数据库表添加新数据行 DELETE --从数据库表中删除数据行 UPDATE --更新数据库表中的数据 数据定义 CREAT ...

  4. WOE(weight of evidence, 证据权重)

    1. WOE(weight of evidence, 证据权重) WOE是一种衡量正常样本( Good)和违约样本( Bad)分布的差异方法 WOE=ln(Distr Good/Distr Bad)例 ...

  5. emu8086实现两位数乘法运算

    题目说明:从键盘上输入任意两个不大于2位数的正实数,计算其乘积,结果在屏幕上显示 一.准备材料 DOS功能调用表:https://blog.csdn.net/mybelief321/article/d ...

  6. xss平台搭建

    1. xss平台搭建 l 将xss平台源码放置在网站目录下 l 进入MySQL管理界面中的phpMyAdmin界面,新建一个XSS平台的数据库 l 修改XSS源码文件目录下的config.php中的数 ...

  7. Delaunay三角剖分及MATLAB实例

    https://blog.csdn.net/piaoxuezhong/article/details/68065170 一.原理部分 点集的三角剖分(Triangulation),对数值分析(如有限元 ...

  8. node的内置常量 __dirname和 __filename

    node的内置常量 __ dirname和 __ filename __dirname当前文件(你用node运行的文件)所在的文件夹地址 // dirname.js console.log(__dir ...

  9. Java常见的垃圾收集器有哪些?

    守拙者_6a98关注 2020.04.11 22:06:31字数 2,135阅读 394 实际上,垃圾收集器( GC , Garbage Collector )是和具体 JVM 实现紧密相关的,不同厂 ...

  10. Python包装器

    def func(): print("func body") def f1(arg): print("f1:",arg) def wrapper(b): pri ...