设计模式：创建者模式 - 单例模式

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

文章目录

1.介绍

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

2.单例模式的结构

单例模式的主要有以下角色：

  • 单例类：只能创建一个实例的类
  • 访问类：使用单例类

3.单例模式的实现（饿汉、懒汉）

单例设计模式分类两种：

  • 饿汉式：类加载就会导致该单实例对象被创建
  • ​懒汉式：类加载不会导致该单实例对象被创建，而是首次使用该对象时才会创建

饿汉式-方式1（静态变量方式）

/**
 * 饿汉式
 *      静态变量创建类的对象
 */
public class Singleton {
    //私有构造方法
    private Singleton() {}

    //在成员位置创建该类的对象
    private static Singleton instance = new Singleton();

    //对外提供静态方法获取该对象
    public static Singleton getInstance() {
        return instance;
    }
}

说明：

​该方式在成员位置声明Singleton类型的静态变量，并创建Singleton类的对象instance。instance对象是随着类的加载而创建的。如果该对象足够大的话，而一直没有使用就会造成内存的浪费。

饿汉式-方式2（静态代码块方式）

/**
 * 恶汉式
 *      在静态代码块中创建该类对象
 */
public class Singleton {

    //私有构造方法
    private Singleton() {}

    //在成员位置创建该类的对象
    private static Singleton instance;

    static {
        instance = new Singleton();
    }

    //对外提供静态方法获取该对象
    public static Singleton getInstance() {
        return instance;
    }
}

说明：

​该方式在成员位置声明Singleton类型的静态变量，而对象的创建是在静态代码块中，也是对着类的加载而创建。所以和饿汉式的方式1基本上一样，当然该方式也存在内存浪费问题。

懒汉式-方式1（线程不安全）

/**
 * 懒汉式
 *  线程不安全
 */
public class Singleton {
    //私有构造方法
    private Singleton() {}

    //在成员位置创建该类的对象
    private static Singleton instance;

    //对外提供静态方法获取该对象
    public static Singleton getInstance() {

        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

说明：

​ 从上面代码我们可以看出该方式在成员位置声明Singleton类型的静态变量，并没有进行对象的赋值操作，那么什么时候赋值的呢？当调用getInstance()方法获取Singleton类的对象的时候才创建Singleton类的对象，这样就实现了懒加载的效果。但是，如果是多线程环境，会出现线程安全问题。

懒汉式-方式2（线程安全）

/**
 * 懒汉式
 *  线程安全
 */
public class Singleton {
    //私有构造方法
    private Singleton() {}

    //在成员位置创建该类的对象
    private static Singleton instance;

    //对外提供静态方法获取该对象
    public static synchronized Singleton getInstance() {

        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

说明：

​该方式也实现了懒加载效果，同时又解决了线程安全问题。但是在getInstance()方法上添加了synchronized关键字，导致该方法的执行效果特别低。从上面代码我们可以看出，其实就是在初始化instance的时候才会出现线程安全问题，一旦初始化完成就不存在了。

懒汉式-方式3（双重检查锁）

再来讨论一下懒汉模式中加锁的问题，对于 getInstance() 方法来说，绝大部分的操作都是读操作，读操作是线程安全的，所以我们没必让每个线程必须持有锁才能调用该方法，我们需要调整加锁的时机。由此也产生了一种新的实现模式：双重检查锁模式

/**
 * 双重检查方式
 */
public class Singleton { 

    //私有构造方法
    private Singleton() {}

    private static Singleton instance;

   //对外提供静态方法获取该对象
    public static Singleton getInstance() {
        //第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实例
        if(instance == null) {
            synchronized (Singleton.class) {
                //抢到锁之后再次判断是否为null
                if(instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

双重检查锁模式是一种非常好的单例实现模式，解决了单例、性能、线程安全问题，上面的双重检测锁模式看上去完美无缺，其实是存在问题，在多线程的情况下，可能会出现空指针问题，出现问题的原因是JVM在实例化对象的时候会进行优化和指令重排序操作。

/**
 * 双重检查方式
 */
public class Singleton {

    //私有构造方法
    private Singleton() {}

    private static volatile Singleton instance;

   //对外提供静态方法获取该对象
    public static Singleton getInstance() {
        //第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实际
        if(instance == null) {
            synchronized (Singleton.class) {
                //抢到锁之后再次判断是否为空
                if(instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

小结：

添加 volatile 关键字之后的双重检查锁模式是一种比较好的单例实现模式，能够保证在多线程的情况下线程安全也不会有性能问题。

懒汉式-方式4（静态内部类方式）

静态内部类单例模式中实例由内部类创建，由于 JVM 在加载外部类的过程中, 是不会加载静态内部类的, 只有内部类的属性/方法被调用时才会被加载, 并初始化其静态属性。静态属性由于被 static 修饰，保证只被实例化一次，并且严格保证实例化顺序。

/**
 * 静态内部类方式
 */
public class Singleton {

    //私有构造方法
    private Singleton() {}

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    //对外提供静态方法获取该对象
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

说明：

​第一次加载Singleton类时不会去初始化INSTANCE，只有第一次调用getInstance，虚拟机加载SingletonHolder并初始化INSTANCE，这样不仅能确保线程安全，也能保证 Singleton 类的唯一性。

小结：

​静态内部类单例模式是一种优秀的单例模式，是开源项目中比较常用的一种单例模式。在没有加任何锁的情况下，保证了多线程下的安全，并且没有任何性能影响和空间的浪费。

枚举方式

枚举类实现单例模式是极力推荐的单例实现模式，因为枚举类型是线程安全的，并且只会装载一次，设计者充分的利用了枚举的这个特性来实现单例模式，枚举的写法非常简单，而且枚举类型是所用单例实现中唯一一种不会被破坏的单例实现模式。

/**
 * 枚举方式
 */
public enum Singleton {
    INSTANCE;
}

说明：

​ 枚举方式属于饿汉式方式。

4.存在的问题

破坏单例模式：

使上面定义的单例类可以创建多个对象，枚举方式除外。有两种方式，分别是序列化和反射。

  • 序列化反序列化

Singleton类：

public class Singleton implements Serializable {

    //私有构造方法
    private Singleton() {}

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    //对外提供静态方法获取该对象
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

Test类：

public class Test {
    public static void main(String[] args) throws Exception {
        //往文件中写对象
        //writeObject2File();
        //从文件中读取对象
        Singleton s1 = readObjectFromFile();
        Singleton s2 = readObjectFromFile();

        //判断两个反序列化后的对象是否是同一个对象
        System.out.println(s1 == s2);
    }

    private static Singleton readObjectFromFile() throws Exception {
        //创建对象输入流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("C:\\Users\\Jm\\Desktop\\a.txt"));
        //第一个读取Singleton对象
        Singleton instance = (Singleton) ois.readObject();

        return instance;
    }

    public static void writeObject2File() throws Exception {
        //获取Singleton类的对象
        Singleton instance = Singleton.getInstance();
        //创建对象输出流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\Jm\\Desktop\\a.txt"));
        //将instance对象写出到文件中
        oos.writeObject(instance);
    }
}

上面代码运行结果是 false，表明序列化和反序列化已经破坏了单例设计模式。

  • 反射

Singleton类：

public class Singleton {

    //私有构造方法
    private Singleton() {}
    
    private static volatile Singleton instance;

    //对外提供静态方法获取该对象
    public static Singleton getInstance() {

        if(instance != null) {
            return instance;
        }

        synchronized (Singleton.class) {
            if(instance != null) {
                return instance;
            }
            instance = new Singleton();
            return instance;
        }
    }
}

Test类：

public class Test {
    public static void main(String[] args) throws Exception {
        //获取Singleton类的字节码对象
        Class clazz = Singleton.class;
        //获取Singleton类的私有无参构造方法对象
        Constructor constructor = clazz.getDeclaredConstructor();
        //取消访问检查
        constructor.setAccessible(true);

        //创建Singleton类的对象s1
        Singleton s1 = (Singleton) constructor.newInstance();
        //创建Singleton类的对象s2
        Singleton s2 = (Singleton) constructor.newInstance();

        //判断通过反射创建的两个Singleton对象是否是同一个对象
        System.out.println(s1 == s2);
    }
}

上面代码运行结果是false，表明序列化和反序列化已经破坏了单例设计模式

注意：枚举方式不会出现这两个问题。

5.问题的解决

  • 序列化、反序列方式破坏单例模式的解决方法

在Singleton类中添加readResolve()方法，在反序列化时被反射调用，如果定义了这个方法，就返回这个方法的值，如果没有定义，则返回新new出来的对象。

public class Singleton implements Serializable {

    //私有构造方法
    private Singleton() {}

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    //对外提供静态方法获取该对象
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
    
    /**
     * 下面是为了解决序列化反序列化破解单例模式
     */
    private Object readResolve() {
        return SingletonHolder.INSTANCE;
    }
}
  • 反射方式破解单例的解决方法

当通过反射方式调用构造方法进行创建创建时，如果instance已经初始化，直接抛异常。不运行此中操作。

public class Singleton {

    //私有构造方法
    private Singleton() {
        /*
           反射破解单例模式需要添加的代码
        */
        if(instance != null) {
            throw new RuntimeException();
        }
    }
    
    private static volatile Singleton instance;

    //对外提供静态方法获取该对象
    public static Singleton getInstance() {

        if(instance != null) {
            return instance;
        }

        synchronized (Singleton.class) {
            if(instance != null) {
                return instance;
            }
            instance = new Singleton();
            return instance;
        }
    }
}
Jm呀
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
掌握Spring设计模式：Java工程师必备指南
12-13
作为一个资深Java工程师，我发现《Spring 设计模式总结》PDF非常精彩，它深入剖析了Spring框架中的关键设计模式。例如，简单工厂模式通过BeanFactory展现，实现了松耦合和动态对象创建。工厂方法模式则通过...
JavaScript设计模式之单例模式简单实例教程
12-08
本文实例讲述了JavaScript设计模式之单例模式。分享给大家供大家参考，具体如下： 一、单例模式概念 单例就是保证一个类只有一个实例，实现方法一般是先判断实例存在与否，如果存在直接返回，如果不存在就创建了再...
设计模式：创建型模式--单例模式（Singleton Pattern）
ZZay's
02-26 469
设计模式：创建者模式——单例模式 文章目录设计模式：创建者模式——单例模式1. 概念2. 组成结构3. 实现方式3.1 饿汉式3.1.1 静态变量3.1.2 静态代码块3.1.3 枚举方式3.2 懒汉式3.2.1 非线程安全3.2.2 线程安全3.2.3 双重检查锁3.2.4 静态内部类4. 存在问题4.1 序列化反序列化4.2 反射机制 1. 概念 单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 这种
JAVA设计模式--单例模式
JAVA_SR的博客
09-21 601
单例设计模式
python：水果与设计模式-单例模式
Spuer_Tiger
06-17 1845
单例模式（Singleton Pattern）：属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。（注意：1、单例类只能有一个实例。2、单例类必须自己创建自己的唯一实例。3、单例类必须给所有其他对象提供这一实例。） 意图： 保证一个类仅有一个实例，并提供一个访问它的全局访问点。 主要解决： 一个全局使用的类频繁地创建与销毁。 何时使用： 当您想控制实例
Unity常用设计模式-单例模式：游戏中的独一无二
weixin_51186493的博客
11-07 510
当谈到Unity游戏开发时，设计模式是一个非常重要的主题，其中之一就是单例模式。单例模式是一种创建模式，它确保一个类只有一个实例，并提供一个全局访问点来获取该实例。在Unity中，单例模式经常用于管理全局游戏状态、资源管理、对象池等方面。在本文中，我们将探讨Unity中如何实现单例模式以及其优势。单例模式在Unity游戏开发中非常有用，它可以确保只有一个实例存在，提供全局访问点，节省资源并确保线程安全。通过遵循上述步骤，你可以轻松地在Unity中实现单例模式，并应用它来管理游戏中的全局状态和资源。
Java设计模式-创建型设计模式-单例模式
Fatter$hday的博客
04-26 739
Java设计模式-创建型设计模式-单例模式
设计模式：单例模式和工厂模式
Sinder小德的博客
12-07 3852
单例模式与工厂模式的基本原理和实现，以及单例模式结合工厂模式的基本应用。
《设计模式详解》创建型模式 - 单例模式
萌宅鹿的技术小屋
01-04 996
设计模式详解4.1 单例模式4.1.1 单例模式的结构4.1.2 单例模式的实现饿汉式 1：静态变量饿汉式 2：静态代码块懒汉式 1：线程不安全懒汉式 2：线程安全懒汉式 3：双重检查锁????懒汉式 4：静态内部类????饿汉式 3：枚举????4.1.3 存在的问题序列化破坏单例反射破坏单例4.1.4 JDK 源码 - Runtime 类 教程来源：黑马程序员Java设计模式详解，全网最全23种Java设计模式 创建型模式的主要关注点是：怎样创建对象？，它的主要特点是：将对象的创建与使用分离。 这样
设计模式--单例模式详解
想着百万年薪努力的小赵
04-13 2305
单例模式的定义 单例模式(Singleton Pattern ）是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。单例模式是创建型模式。单例模式在现实生活中应用也非常广泛，例如，公司CEO、部门经理等。J2EE标准中的ServletContext，ServletContextConfig等、Spring框架应用中的ApplicationContext、数据库的连接池等也都是单例形式。 饿汉式单例模式 饿汉式单例模式在类加载的时候就立即初始化，并且创建单例对象。它绝对线程安全，在线程还没 出
创意设计模式：单例设计模式
新华编程特战队
01-09 1697
单例设计模式是一种创建设计模式，它确保一个类只有一个实例，并且所有其他类都可以全局访问。单例设计模式通过在应用程序之间共享单个实例来减少内存使用量。
深入理解JavaScript系列（25）：设计模式之单例模式详解
12-09
从本章开始，我们会逐步介绍在JavaScript里使用的各种设计模式实现，在这里我不会过多地介绍模式本身的理论，而只会关注实现。OK，正式开始。 在传统开发工程师眼里，单例就是保证一个类只有一个实例，实现的方法...
软件设计模式创建型模式实验代码
01-08
），单例模式（网站计算器是web应用程序的一项基本功能,用于统计使用网站的人数,可反应出网站的受欢迎程序,请设计一个简单的web页面（java，asp.net均可），并为该页面设计一个计算器，用来统计当前访问网址的用户数...
[创建型模式] 单例模式（Singleton Pattern）
01-20
单例就是单个对象的意思，指在系统运行期间，一个类最多只能创建一个对象，且该类能自行创建这个对象的一种编码设计模式。 单例模式有两个特点： 在系统的整个生命周期内，单例对象最多只能有一个 单例对象必须由...
单例模式、工厂模式 c++关键字 static
霍迪迪的博客
06-11 997
在头文件中使用extern和static声明变量，可以让多个源文件共享同一变量的声明，但每个使用该声明的源文件需要有一个独立的定义（没有static），以避免多重定义错误。：在文件作用域声明的静态变量（即在函数外部，但用static修饰），其作用范围限制在定义它的源文件内，即它是“内部链接”的。我们可以通过工厂类可以实例化圆形 和正方形，但每次用工厂类的时候，我们不需要每次都实例化一个工厂，因此工厂类就用到了单例模式，使工厂在整个系统的生命周期唯一，避免多次创建。所有类实例共享同一个静态成员变量的副本。
Spring MVC的控制器是不是单例模式
m0_47743175的博客
06-12 362
Spring MVC的控制器是不是单例模式,如果是,有什么问 题,怎么解决？
C++中的单例模式
GOLOJO的博客
06-11 540
单例模式，通过确保类的唯一实例来简化资源管理，并在多个场景中广泛应用，如配置管理、日志记录和数据库连接池。
设计模式之单例模式
最新发布
m0_61990249的博客
06-13 686
单例模式：恶汉模式、懒汉模式、线程安全
设计模式除了单例模式还有哪些
01-17
设计模式除了单例模式，还有很多其他常见的设计模式，例如： 1. 工厂模式（Factory Pattern）：用于创建对象的模式，根据不同的条件返回不同的对象实例。 2. 观察者模式（Observer Pattern）：定义了一种一对多的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Jm呀

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值