1.设计模式之单例模式

最新推荐文章于 2024-07-12 15:51:39 发布
最新推荐文章于 2024-07-12 15:51:39 发布
阅读量108 收藏
点赞数 1
分类专栏： 23种设计模式 文章标签： java 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43478625/article/details/120084540
版权

单例模式

1.1 单例设计模式介绍

所谓类的单例设计模式，就是采用一定的方法保证在整个软件系统内，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法(静态方法)
比如Hibernate的SessionFactory,它充当数据存储源的代理，并负责创建Session对象。SessionFactory并不是轻量级的，一般情况下，一个项目通常只需要一个SessionFactory就够，这时就会使用到单例模式

1.2 单例设计模式八种方式

  1. 饿汉式(静态常量)
  2. 饿汉式(静态代码块)
  3. 懒汉式(线程不安全)
  4. 懒汉式(线程安全，同步方法)
  5. 懒汉式(线程安全，同步代码块)
  6. DCL单例(双重检查)
  7. 静态内部类
  8. 枚举

1.3 饿汉式(静态常量)

步骤如下:

  1. 构造器私有化
  2. 类的内部创建对象
  3. 向外暴露一个静态的公共方法。getInstance
  4. 代码实现
public class Demo1 {
    public static void main(String[] args) {
        SingletonDemo instance1 = SingletonDemo.getInstance();
        SingletonDemo instance2 = SingletonDemo.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println("instance1.hashCode() = " + instance1.hashCode());
        System.out.println("instance2.hashCode() = " + instance2.hashCode());
    }


}

class SingletonDemo {

    public static final SingletonDemo INSTANCE = new SingletonDemo();

    private SingletonDemo() {
    }

    public static SingletonDemo getInstance(){
        return INSTANCE;
    }

}

在这里插入图片描述
优缺点说明

  1. 优点: 这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。（如果是懒加载，在多线程调用getInstance()方法，则可能会创建多个实例,这种写法在类加载的时候创建实例，就避免了这个问题）
  2. 缺点: 在类装载的时候就完成实例化，没有达到Lazy Loading的效果。如果从始至终从未使用过这个实例，会造成内存的浪费
  3. 这种方式基于ClassLoader机制避免了多线程的同步问题，不过，instance在类装载时就实例化，在单例模式中大多数都是调用getInstance方法，但是导致类装载的原因有很多种，因此不能确定有其他的方式(或者其他的静态方法)导致类装载，这时候初始化instance就没有达到lazy loading的效果
  4. 结论: 这种单例模式可用，可能造成内存浪费

1.4 饿汉式(静态代码块)

代码演示

public class Demo2 {

    public static void main(String[] args) {
        SingletonDemo instance1 = SingletonDemo.getInstance();
        SingletonDemo instance2 = SingletonDemo.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println("instance1.hashCode() = " + instance1.hashCode());
        System.out.println("instance2.hashCode() = " + instance2.hashCode());
    }

}
class SingletonDemo{

    private static final SingletonDemo INSTANCE;

    static {
        INSTANCE = new SingletonDemo();
    }

    private SingletonDemo(){}

    public static SingletonDemo getInstance() {

        return INSTANCE;
    }

}

**优缺点说明: **

  1. 这种方式和上面的方式其实类似，只不过类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。优缺点和上面是一样的。
  2. 结论: 这种单例模式可用，但是可能造成内存浪费

1.5 懒汉式(线程不安全)

public class Demo3 {

    public static void main(String[] args) {
        SingletonDemo instance1 = SingletonDemo.getInstance();
        SingletonDemo instance2 = SingletonDemo.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println("instance1.hashCode() = " + instance1.hashCode());
        System.out.println("instance2.hashCode() = " + instance2.hashCode());
    }
}

class SingletonDemo {

    private static SingletonDemo instance;

    private SingletonDemo() {

    }

    public static SingletonDemo getInstance() {
        if (instance != null) {
            return instance;
        }

        instance = new SingletonDemo();
        return instance;
    }

}

**优缺点说明: **

  1. 起到了Lazy Loading的效果，但是只能在单线程下使用
  2. 如果在多线程下，一个线程进入了if (instance == null) 判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便产生了多个实例。所以在多线程环境下不可以使用这种方式
  3. 结论: 在实际开发中，不要使用这种方式

1.6 懒汉式(线程安全，同步方法)

public class Demo4 {

    public static void main(String[] args) {
        SingletonDemo instance1 = SingletonDemo.getInstance();
        SingletonDemo instance2 = SingletonDemo.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println("instance1.hashCode() = " + instance1.hashCode());
        System.out.println("instance2.hashCode() = " + instance2.hashCode());
    }
}

class SingletonDemo {

    private static SingletonDemo instance;

    private SingletonDemo() {

    }

    public static synchronized SingletonDemo getInstance() {
        if (instance != null) {
            return instance;
        }

        instance = new SingletonDemo();
        return instance;
    }

}

优缺点说明:

  1. 解决了线程安全问题
  2. 效率太低了，每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行了。方法进行同步效率太低
  3. 结论: 在实际开发中，不推荐使用这种方式

1.7 懒汉式(线程安全,同步代码块)

public class Demo5 {

    public static void main(String[] args) {
        SingletonDemo instance1 = SingletonDemo.getInstance();
        SingletonDemo instance2 = SingletonDemo.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println("instance1.hashCode() = " + instance1.hashCode());
        System.out.println("instance2.hashCode() = " + instance2.hashCode());
    }

}

class SingletonDemo {
    private static SingletonDemo instance;

    private SingletonDemo() {}

    public static SingletonDemo getInstance() {
        if (instance == null) {
            synchronized (SingletonDemo.class) {
                instance = new SingletonDemo();
                return instance;
            }
        }
        return instance;
    }

}

优缺点说明:

  1. 这种方式,本意是想对第四种实现方式的改进，因为前面的同步方法效率太低，改为同步产生实例化的代码块
  2. 但是这种同步并不能起到线程同步的作用。跟第三种实现方式遇到的情形一致，假如一个线程进入到了if (instance == null) 判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。
  3. 结论: 在实际开发中，不能使用这种方式。

1.8 DCL(Double Check Lock)

public class Demo6 {

    public static void main(String[] args) {
        SingletonDemo instance1 = SingletonDemo.getInstance();
        SingletonDemo instance2 = SingletonDemo.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println("instance1.hashCode() = " + instance1.hashCode());
        System.out.println("instance2.hashCode() = " + instance2.hashCode());
    }
}

class SingletonDemo {

	//这里加volatile关键字防止指令重排
    private static volatile SingletonDemo instance;

    private SingletonDemo(){}

    public static SingletonDemo getInstance() {
        if (instance == null) {
            synchronized (SingletonDemo.class) {
                if (instance == null) {
                    instance = new SingletonDemo();
                }
            }
        }
        return instance;
    }

}

优缺点说明:

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

1.9 静态内部类

public class Demo7 {

    public static void main(String[] args) {
        SingletonDemo instance1 = SingletonDemo.getInstance();
        SingletonDemo instance2 = SingletonDemo.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println("instance1.hashCode() = " + instance1.hashCode());
        System.out.println("instance2.hashCode() = " + instance2.hashCode());
    }



}

class SingletonDemo {

    private SingletonDemo(){}

    //私有类中的私有变量或常量外部类依旧可以调用
    private static class SingletonInstance {
        private static final SingletonDemo INSTANCE = new SingletonDemo();
    }

    public static SingletonDemo getInstance() {
        return SingletonInstance.INSTANCE;
    }

}

优缺点说明

  1. 这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
  2. 静态内部类方式在 SingletonDemo 类被装载时并不会立即实例化，而是在需要实例化时，调用 getInstance 方法， 才会装载 SingletonInstance类， 从而完成 SingletonDemo 的实例化
  3. 类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，再类进行初始化时，别的线程是无法进入的。
  4. 优点: 避免了线程不安全,利用静态内部类特点实现延迟加载，效率高
  5. 结论: 推荐使用

1.19 枚举

public class Demo8 {

    public static void main(String[] args) {
        SingletonDemo instance1 = SingletonDemo.INSTANCE;
        SingletonDemo instance2 = SingletonDemo.INSTANCE;
        System.out.println(instance1 == instance2);
        System.out.println("instance1.hashCode() = " + instance1.hashCode());
        System.out.println("instance2.hashCode() = " + instance2.hashCode());
    }

}

enum SingletonDemo {
    INSTANCE;

    public void say() {
        System.out.println("hello");
    }
}

在这里插入图片描述
**优缺点说明: **

  1. 这借助JDK1.5 中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新构建新的对象。
  2. 这种方式是 Effective Java 作者 Josh Bloch 提倡的方式
  3. 结论: 推荐使用

1.11 单例模式在JDK 应用的源码分析

1.11.1 单例模式在JDK应用的源码分析

  1. 我们JDK中，java.lang.Runtime就是经典的单例模式(饿汉式)
  2. 源码分析
public class Runtime {
    private static Runtime currentRuntime = new Runtime();

    /**
     * Returns the runtime object associated with the current Java application.
     * Most of the methods of class <code>Runtime</code> are instance
     * methods and must be invoked with respect to the current runtime object.
     *
     * @return  the <code>Runtime</code> object associated with the current
     *          Java application.
     */
    public static Runtime getRuntime() {
        return currentRuntime;
    }

    /** Don't let anyone else instantiate this class */
    private Runtime() {}
}

1.12 单例模式注意事项和细节说明

  1. 单例模式保证了 系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，用单例模式可以提高系统性能
  2. 当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用new
  3. 单例模式使用的场景: 需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即: 重量级对象),但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session工厂等)
古月日月衣羊
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
1.设计模式-单例设计模式1
08-03
1.模式定义/应用场景/类图分析 2.字节码知识/字节码指令重排序 3.类加载机制 4.JVM序列化机制 5.单例模式在Spring框架 & JDK源码中的应用
设计模式之单例模式.pptx
11-24
单例模式是一种常用的软件设计模式，其定义是单例对象的类只能允许一个实例存在。 许多时候整个系统只需要拥有一个的全局对象，这样有利于我们协调系统整体的行为。 比如在某个服务器程序中，该服务器的配置信息存放...
1.单例模式
何鹏飞的博客
05-05 80
单例设计模式 1.什么是单例模式？ 单例模式就是保证系统中一个类只有一个实例。也就是只能自己new自己并且实例唯一并对外提供。 2.模式的作用及应用场景？ 作用：解决一个全局使用的类，频繁创建和销毁。拥有对象的唯一性，并保证内存中对象的唯一。可以节省内存，因为单例共用一个实例，有利于Java的垃圾回收机制。 也就是控制资源使用，通过线程同步来控制资源的并发访问 控制实例产生的数量，达到节约资源的目的; 应用场景举例: 1、统计当前在线人数（网站计数器）：用一个全局对象来记录。 2、打印机（设
沙场点将之单例设计模式
迦南学院
02-02 90
一、介绍 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法(静态方法)。 比如Hibernate的SessionFactory，它充当数据存储源的代理，并负责创建Session对象。SessionFactory并不是轻量级的，一般情况下，一个项目通常只需要一个SessionFactory就够，这是就会使用到单例模式。 二、单例设计模式八种方式 序号 名称 使用 1 饿汉式(静态常量) 单线程下推荐 2 饿
JAVA设计模式之单例模式
一个本科小生的奋斗史
04-16 99万+
本文继续介绍23种设计模式系列之单例模式。 概念： 　　java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、登记式单例。 　　单例模式有以下特点： 　　1、单例类只能有一个实例。 　　2、单例类必须自己创建自己的唯一实例。 　　3、单例类必须给所有其他对象提供这一实例。　　单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例...
快速理解设计模式：单例模式深入
热门推荐
张彦峰的博客
04-21 169万+
单例模式是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。实现方式介绍分析：饿汉式单例模式+懒汉式单例模式（双重检查锁）+静态内部类实现单例模式+注册式单例模式
02. 设计模式之单例模式
JustToFaith
08-21 2809
单例模式 文章目录单例模式设计模式概述设计模式介绍设计模式类型单例设计模式单例设计模式介绍单例模式八种方式1. 饿汉式（静态常量）步骤如下：优缺点说明：2. 饿汉式（静态代码块）代码演示优缺点说明3. 赖汉式（线程不安全）代码演示优缺点说明4. 懒汉式（线程安全，同步方法）代码演示优缺点说明5. 懒汉式（线程安全，同步代码块）代码演示优缺点说明6. 双重检查（DCL）代码演示优缺点说明7. 静态内部类代码演示优缺点说明8. 枚举代码演示优缺点说明单例模式注意事项和细节说明 设计模式概述 设计模式介绍 设
17. 设计模式之单例模式：如何有效进行程序初始化？
卜卦的博客
03-02 1465
设计模式之单例模式：如何有效进行程序初始化？
设计模式之单例模式(C++)
翟天保的博客
02-09 2万+
介绍设计模式之单例模式
PHP语言设计模式之单例模式
低头赶路，敬事如仪
12-03 745
第1关：饿汉式
设计模式之单例模式详解和应用
赵广陆
02-14 1204
目录 1 单例模式的应用场景介绍 2 饿汉式单例模式 2.1 静态方法获得私有成员对象 2.2 利用静态代码块与类同时加载的特性生成单例对象 2.3 优缺点 3 懒汉式单例模式 2.1 加锁 2.2 双重检查锁 2.3 静态内部类 4 反射破坏单例 5 序列化破坏单例（扩展知识） 6 注册式单例模式 6.1 枚举式单例模式 6.2 容器式单例 7 线程单例实现ThreadLocal 8 AbstractFactoryBean源码 9 单例模式小结
js设计模式之单例模式
楠姐的博客
11-09 7705
单例模式也称为单体模式，保证一个类仅有一个实例，并提供一个访问它的全局访问点
Python 115.设计模式_单例模式实现.mp4
02-08
Python 115.设计模式_单例模式实现.mp4
配置Java开发环境
Broken_x的博客
07-10 1463
Java开发环境配置
java版的上门家政系统和PHP版的上门家政有什么区别？
最新发布
baina666的博客
07-12 357
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 428
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 2332
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
java Object 转 Integer
servepeople的博客
07-09 1426
在 Java 中，可以通过多种方法将一个Object转换为Integer。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值