【设计模式】单例设计模式

最新推荐文章于 2024-10-31 17:24:07 发布
最新推荐文章于 2024-10-31 17:24:07 发布
阅读量143 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 单例设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/daemon_slp/article/details/108140263
版权

一、单例设计模式介绍

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

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

二、单例设计模式八种方式

  • 饿汉式（静态常量）
  • 饿汉式（静态代码块）
  • 懒汉式（线程不安全）
  • 懒汉式（线程安全，同步方法）
  • 懒汉式（线程安全，同步代码块）
  • 双重检查
  • 静态内部类
  • 枚举

三、饿汉式（静态常量）

1.创建步骤

  • 构造器私有化

  • 类的内部创建对象

  • 向外部暴露一个静态的公共方法

  • 代码实现

    package com.slp.pattern.singleton.v1;

/**
 * @ClassName Singleton
 * @Description TODO
 * @Author sanglp
 * @Date 2020/8/17 8:39
 * @Version 1.0
 **/
public class Singletonv1 {
    public static void main(String[] args) {
        //测试
        Singleton singleton = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton==singleton2); //true
        System.out.println(singleton.hashCode());
        System.out.println(singleton2.hashCode());
    }
}

class Singleton{
    //1.构造方法私有化，外部不能new
    private Singleton(){

    }

    //2.本类内部创建对象实例
    private final static Singleton instance = new Singleton();

    //3、对外提供一个共有的静态方法，返回实例对象
    public static Singleton getInstance(){
        return instance;
    }
}
2.优缺点
  • 优点：这种写法比较简单，就是在类装载的时候就完成实例化，避免了线程同步问题
  • 缺点：在类装载的时候就完成实例化，没有达到lazy loading的效果，如果从始至终从未使用过这个实例，则会造成内存的浪费
  • 这种方式基于classloader机制避免了多线程的同步问题，不过，instance在类装载时就实例化，在单例模式中大多数都是调用getInstance方法，但是导致类装载的原因又很多种，因此不能确定有其他的方式导致类装载，这时候初始化instance就没有达到lazy loading的效果
  • 这种单例模式可用，可能造成内存浪费

四、饿汉式（静态代码块）

1.创建步骤

  • 构造方法私有化，外部不能new

  • 本类内部创建对象实例

  • 对外提供一个共有的静态方法，返回实例对象

  • 代码

    package com.slp.pattern.singleton.v2;

/**
 * @ClassName Singletonv2
 * @Description TODO
 * @Author sanglp
 * @Date 2020/8/17 8:52
 * @Version 1.0
 **/
public class Singletonv2 {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton == singleton2);
        System.out.println(singleton.hashCode());
        System.out.println(singleton2.hashCode());

    }
}
class Singleton{
    //1.构造方法私有化，外部不能new
    private Singleton(){

    }

    //2.本类内部创建对象实例
    private  static Singleton instance ;
    static{
        instance = new Singleton();
    }
    //3、对外提供一个共有的静态方法，返回实例对象
    public static Singleton getInstance(){
        return instance;
    }
}
    2.优缺点
    • 与上面一种方式类似，只不过是将类实例化的过程放在了静态代码框中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。优缺点和上面的一致
    • 这种单例模式可用，但是可能造成内存浪费

五、懒汉式（线程不安全）

1.示例代码
package com.slp.pattern.singleton.v3;

/**
 * @ClassName Singletonv3
 * @Description 懒汉式，线程不安全
 * @Author sanglp
 * @Date 2020/8/17 8:59
 * @Version 1.0
 **/
public class Singletonv3 {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);
        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());
    }
}

class Singleton{
    private static Singleton instance;
    //构造器私有化
    private Singleton(){}
    //提供静态的私有方法，当使用到该方法时才去创建instance 即懒汉式
    public static Singleton getInstance(){
        if (instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}
2.优缺点
  • 起到了Lazy Loading的效果，但是只能在单线程下使用
  • 如果在多线程下，一个线程进入了if(singleton == null )判断语句块，另一个线程也通过了这个判断语句，这时便会产生多个实例，所以在多线程环境下这种方式不能使用
  • 实际开发中，不要是有这种方式

六、懒汉式（线程安全。同步方法）

1.代码示例
package com.slp.pattern.singleton.v4;

/**
 * @ClassName Singletonv4
 * @Description 懒汉式，线程安全，使用同步方法
 * @Author sanglp
 * @Date 2020/8/17 9:08
 * @Version 1.0
 **/
public class Singletonv4 {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);
        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());
    }
}

/**
 * 懒汉式（线程安全，同步方法）
 */
class Singleton{
    private static Singleton instance;
    //构造器私有化
    private Singleton(){}
    //提供静态的私有方法，加入同步代码块的处理，解决线程安全问题
    public static synchronized Singleton getInstance(){
        if (instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}
2.优缺点
  • 解决了线程安全问题
  • 效率太低，每个线程在想获得类的实例时候，执行getInstance方法都要进行同步，而这个方法实际上只执行一次实例化代码就行了，后面的想获得该类实例，直接return就行了。方法进行同步效率太低
  • 实际开发中，不推荐这种方式

七、懒汉式（线程安全，同步代码块）

1.代码示例
package com.slp.pattern.singleton.v5;

/**
 * @ClassName Singletonv5
 * @Description 懒汉式 线程安全。同步代码块
 * @Author sanglp
 * @Date 2020/8/17 9:15
 * @Version 1.0
 **/
public class Singletonv5 {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        Singleton singleton1 = Singleton.getInstance();
        System.out.println(singleton == singleton1);
        System.out.println(singleton.hashCode());
        System.out.println(singleton1.hashCode());
    }
}

class Singleton{
    private static Singleton singleton;
    private Singleton(){

    }
    public static Singleton getInstance(){
        if(singleton == null ){
            synchronized (Singleton.class){
                singleton = new Singleton();
            }
        }
        return singleton;
    }
}
  • 不推荐使用

八、双重检查

1.代码示例
package com.slp.pattern.singleton.v6;

/**
 * @ClassName Singletonv6
 * @Description 双重检查
 * @Author sanglp
 * @Date 2020/8/17 9:20
 * @Version 1.0
 **/
public class Singletonv6 {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        Singleton singleton1 = Singleton.getInstance();
        System.out.println(singleton == singleton1);
        System.out.println(singleton.hashCode());
        System.out.println(singleton1.hashCode());
    }
}
//懒汉式（线程安全，同步方法）
class Singleton{
    private static  Singleton singleton;
    //构造方法私有化
    private Singleton(){

    }

    /**
     * 提供一个静态的公有方法，加入双重检查代码，解决线程安全问题，同时解决线程安全问题，保证了效率 推荐使用
     * @return
     */
    public static synchronized Singleton getInstance(){
        if(singleton == null){
            synchronized (Singleton.class){
                if (singleton == null){
                    singleton = new Singleton();
                }
            }
        }
    return singleton;
    }
}
2.优缺点
  • Double-check概念是多线程开发中常使用到的，如上所示，我们进行了两次if(singleton == null )检查，这样就能保证线程安全了
  • 这样，实例化代码中只执行一次，后面再次方式是将直接return实例化对象，也避免了反复进行方法同步
  • 线程安全：延迟加载，效率较高
  • 结论：在实际开发中，推荐使用这种单例设计模式

九、静态内部类

1.示例代码
package com.slp.pattern.singleton.v7;

/**
 * @ClassName Singletonv7
 * @Description 静态内部类
 * @Author sanglp
 * @Date 2020/8/17 10:18
 * @Version 1.0
 **/
public class Singletonv7 {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        Singleton singleton1 = Singleton.getInstance();
        System.out.println(singleton == singleton1);
        System.out.println(singleton.hashCode());
        System.out.println(singleton1.hashCode());
    }
}

/**
 * 静态内部类完成，推荐使用
 */
class Singleton{
    private static  volatile Singleton instance;
    //构造器私有化
    private Singleton(){

    }

    /**
     * 写一个内部静态类，该类中有一个静态属性，Singleton
     */
    private static class SingletonInstance{
        private static final Singleton INSTANCE = new Singleton();
    }

    /**
     * 提供一个静态的公有方法，直接返回SingletonInstance.INSTANCE;
     * @return
     */
    public static synchronized Singleton getInstance(){
        return SingletonInstance.INSTANCE;
    }
}
2.优缺点
  • 这种方式采用了类装载的机制来保证初始化实例只有一个线程
  • 静态内部类方式在Singlton类被装载的时候并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的实例化
  • 类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的
  • 避免了线程不安全，利用静态内部类特点实现延迟加载，效率高
  • 推荐使用

十、枚举类

1.示例代码
package com.slp.pattern.singleton.v8;

/**
 * @ClassName Singletonv8
 * @Description 枚举类实现单例
 * @Author sanglp
 * @Date 2020/8/17 10:27
 * @Version 1.0
 **/
public class Singletonv8 {
    public static void main(String[] args) {
        Singleton instance = Singleton.INSTANCE;
        Singleton instance1 = Singleton.INSTANCE;
        System.out.println(instance == instance1);
        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());
        instance.sayOK();
    }
}
//使用枚举 可以使用单例  推荐
enum Singleton{
    INSTANCE;//属性
    public void sayOK(){
        System.out.println("ok");
    }
}
2.优缺点
  • 借助JDK1.5中添加的枚举来实现单例模式，不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象
  • 这种方式是Effective Java作者提倡的方式
  • 推荐使用

十一、单例模式在JDK应用的源码分析

1.源码
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. 单例模式保证了系统中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能
  2. 当想实例化一个单例类的时候，必须要记住相应的获取对象的方法，而不是new
  3. 单例模式使用的场景：需要频繁的进行创建和销毁的对象，创建对象时耗时过多或者耗费资源过多。但是又经常用到的对象、工具类对象、频繁访问数据库或文件的对象（比如数据源。session工厂等）
梓莘
关注
专栏目录
设计模式 单例模式 java
12-08
设计模式 单例模式 java
C#设计模式–单例模式
12-22
一、引言 　近在学设计模式的一些...，从“单例”字面意思上理解为——一个类只有一个实例，所以单例模式也是保证一个类只有一个实例的一种实现方法罢了(设计模式其实是帮助我们解决实际开发过程中的方法， 该方法是
JAVA设计模式之单例模式
09-22
单例模式是软件设计模式中的一种经典模式，它在Java编程中被广泛使用，尤其是在需要控制实例化过程，或者确保某类只有一个实例时。本文将深入探讨Java中的单例模式，帮助你理解其原理和应用。 单例模式的核心思想是...
python 设计模式之单例模式
11-29
python 设计模式之单例模式
设计模式单例模式.zip
05-03
单例模式是软件设计模式中的一种经典模式，它在计算机科学中被广泛应用于创建和管理一个类的唯一实例。这个模式的核心思想是确保一个类只有一个实例，并提供一个全局访问点来获取这个唯一的实例。这样的设计可以避免...
Java常用设计模式
Gzzz的博客
10-31 376
单例模式（Singleton） 工厂模式（Factory） 抽象工厂模式（Abstract Factory） 建造者模式（Builder） 原型模式（Prototype） 适配器模式（Adapter） 桥接模式（Bridge） 组合模式（Composite） 装饰器模式（Decorator） 外观模式（Facade） 享元模式（Flyweight） 代理模式（Proxy） 责任链模式 命令模式 解释器模式 迭代器模式 中介者模式 备忘录模式 观察者模式 状态模式 策略模式 模板方法模式 访问者模式
状态模式：封装对象状态并改变行为的设计模式
最新发布
wrxfxdd的博客
10-31 139
状态模式：封装对象状态并改变行为的设计模式
设计模式07-结构型模式(装饰模式/外观模式/代理模式/Java)
XYX_888的博客
10-31 326
1.动机：在不改变一个对象本身功能的基础上给对象增加额外的新行为2.定义：动态地给一个对象增加一些额外的职责，就增加对象功能来说，装饰模式比生成子类实现更为灵活**1.模式动机：**一个客户类需要和多个业务类交互，有时候这些需要交互的业务类会作为一个整体出现，如何简化这种主系统和子系统之间的交互。**2.模式定义：**为子系统中的一组接口提供一个统一的入口，外观模式定义了一个高层接口，这个接口使得子系统更加容易使用，外部与子系统的通信通过一个统一的外观对象进行。
设计模式 - 工厂方法模式
路漫漫其修远兮，吾将上下而求索
10-30 440
工厂方法模式是一种非常实用的设计模式，它通过定义一个创建对象的接口，让子类决定实例化哪一个类。这种方式不仅提高了代码的灵活性和可扩展性，还遵循了开闭原则。在实际开发中，工厂方法模式可以广泛应用于需要创建多种相关对象的场景，尤其是在对象创建逻辑较为复杂的情况下。
Java程序设计基础 第十七章：反射和设计模式
2401_83185143的博客
10-28 566
b. load(InputStream in) / load(Reader in)：自动将流指向文件内容进行加载，一行代表一个集合元素，自动以"=" 、":"进行拆分，符号 左侧作为键的内容，右侧作为值的内容。(2) 类对象：类加载的产物，封装了一个类的所有信息(包名、类名、父类、接口、属性、方法、构造方法)。(3) 反射：通过反射可以获取一个类的 类对象，从而获取该类的信息，直接通过类对象进行一系列操作。(1) 类的对象：基于定义好的一个类，创建该类的实例，即利用 new 创建的实例就为类的对象。
设计模式概述与优化口诀
weixin_39863120的博客
10-28 1028
设计模式是一种在软件开发中为解决常见问题而总结出的可复用解决方案。它们不是具体的代码，而是描述了一套在特定上下文中如何解决某类问题的最佳实践和思维方式。创建型模式：这些模式关注对象的创建机制，以提高灵活性和重用性，常见的如单例模式、工厂模式和建造者模式。结构型模式：这些模式关注如何将类和对象组合成更大的结构，以形成更高效和灵活的系统，典型的包括适配器模式、装饰模式和组合模式。行为型模式：这些模式关注对象之间的交互和职责分配，帮助管理复杂的控制流，常见的有观察者模式、策略模式和命令模式。
设计模式概述
小林的博客
10-30 246
直到1995 年，艾瑞克·伽马（ErichGamma）、理査德·海尔姆（Richard Helm）、拉尔夫·约翰森（Ralph Johnson）、约翰·威利斯迪斯（John Vlissides）等 4 位作者合作出版了《设计模式：可复用面向对象软件的基础》一书，在此书中收录了 23 个设计模式，这是设计模式领域里程碑的事件，导致了软件设计模式的突破。GoF（四人组）书中提供了模板方法、策略、命令、职责链、状态、观察者、中介者、迭代器、访问者、备忘录、解释器等 11 种行为型模式。
设计模式——责任链模式
chuliling0446的博客
10-30 599
责任链模式在处理具有多个处理步骤或不确定处理对象的请求时非常有效，但在使用时需要注意其缺点，合理设计处理链的结构和长度。
设计模式最佳实践代码总结 - 结构型设计模式篇 - 装饰器设计模式最佳实践
lw的博客
10-28 1102
以下是一个使用装饰器模式的示例，我们将创建一个简单的咖啡订单系统，其中Coffee是一个接口，SimpleCoffee是一个基础实现，而CoffeeDecorator是一个装饰器基类，其他装饰器类（如MilkDecorator和SugarDecorator）可以继承自它来添加额外的功能。装饰器模式是一种结构型设计模式，它允许你通过将对象放入包含行为的特殊封装对象中来为原对象动态地添加职责。这种模式可以用来扩展对象的功能，而无需修改原始类。
java装饰器设计模式
weixin_44719499的博客
10-30 248
这种模式通常用于动态地添加功能，特别适合在类或接口上扩展行为。Java装饰器模式通常涉及创建一个装饰器类，该类实现被装饰对象的接口并持有被装饰对象的实例。接口，实现了动态添加日志和加密功能的效果。每个装饰器类都可以叠加，形成一条“装饰链”。我们希望动态添加功能，比如记录消息发送的日志，或对消息内容进行加密。
编程语言的设计模式
weixin_44719499的博客
10-30 430
说明：提供一个接口来创建一系列相关对象，不需要指定具体的类。class Dog:class Cat:print(dog.speak()) # 输出：Woof!
【设计模式系列】代理模式（八）
LHW0621的专栏
10-27 628
代理模式（Proxy Pattern）是一种结构型设计模式，它为其他对象提供一种代理以控制对这个对象的访问。通过引入一个代理对象来间接操作实际对象，可以在不改变实际对象代码的前提下，增加额外的功能操作，如访问控制、延迟初始化、日志记录等。
设计模式(三)
qq_44348970的博客
10-27 435
某些情况，可能会过度地使用继承来扩展对象的功能；由于继承为类型引入的静态特质，使得这种扩展方式缺乏灵活性；随着子类增多， 各种子类的组合会导致更多子类的膨胀需要使用对象功能的扩展，能够根据需要来动态地实现，避免扩展功能的增多带来的子类膨胀。
工厂方法模式 — 设计模式
qq_51134950的博客
10-28 310
例如，假设我们有一个汽车生产工厂的抽象概念。这个抽象工厂有一个生产汽车的方法（工厂方法），但是具体生产哪种汽车（轿车、SUV 或者跑车）由具体的工厂子类来决定。是一种创建对象的设计模式。它属于创建型模式，定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法把类的实例化推迟到子类中进行。
C++实现单例设计模式详解
"C++单例设计模式是一种常用的设计模式，用于确保一个类只有一个实例，并提供全局访问点。它在多种场景下应用广泛，如系统日志、GUI应用、MODEM连接等。虽然可以通过全局变量实现，但这种方法不够优雅且可能导致多个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值