创建型模式之单例模式

已于 2022-06-01 08:11:19 修改
阅读量478 收藏 2
点赞数
分类专栏： 设计模式 文章标签： 单例模式 java 开发语言
于 2022-05-10 00:55:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49107940/article/details/124678530
版权

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

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

特点：

1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。

意图： 保证一个类仅有一个实例，并提供一个访问它的全局访问点。

主要解决： 一个全局使用的类频繁地创建与销毁。

何时使用： 当您想控制实例数目，节省系统资源的时候。

如何解决： 判断系统是否已经有这个单例，如果有则返回，如果没有则创建。
关键代码： 构造函数是私有的。

单例模式的实现过程中，需要注意三点：

单例类的构造函数为私有
提供一个自身的静态私有成员变量
提供一个公有的静态方法

优点：

1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
2、避免对资源的多重占用（比如写文件操作）。

缺点：

没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

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

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

单例模式的实现

单例设计模式分类两种：

​ 饿汉式：类加载就会导致该单实例对象被创建。

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

饿汉式

实例1

饿汉式：静态成员变量方式
单例类

/**
 * 单例模式
 *  饿汉式：静态成员变量方式
 */
public class Singleton {
    //私有构造方法
    private Singleton(){};
    //私有静态对象
    private static Singleton singleton = new Singleton();
    //提供公共的访问方法，让外界获取该对象
    public static Singleton getInstance(){
        return singleton;
    }
}

测试类

/**
 * 测试类
 */
public class Client {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();

        System.out.println(singleton1 == singleton2);
    }
}

测试结果
在这里插入图片描述
说明：

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

饿汉式：静态代码块

单例类

/**
 * 单例模式
 * 饿汉式：静态代代码块
 */
public class Singleton {
    //私有构造方法
    private Singleton(){};
    //声明对象
    private static Singleton singleton;

    static {
        singleton = new Singleton();
    }

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

测试类

/**
 * 测试类
 */
public class Client {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();

        System.out.println(singleton1 == singleton2);
    }
}

测试结果
在这里插入图片描述
说明：

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

懒汉式

实例3

懒汉式：线程不安全

单例类

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

    //声明对象
    private static Singleton singleton;
    //对外提供访问的方法
    public static Singleton getInstance(){
        if (singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

测试类

/**
 * 测试类
 */
public class Client {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();

        System.out.println(singleton1 == singleton2);
    }
}

测试结果
在这里插入图片描述说明：

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

懒汉式：线程安全方式

单例类

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

    //声明对象
    private static Singleton singleton;
    //对外提供访问的方法
    public static synchronized Singleton getInstance(){
        if (singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

测试类

/**
 * 测试类
 */
public class Client {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();

        System.out.println(singleton1 == singleton2);
    }
}

测试结果
在这里插入图片描述
说明：

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

懒汉式：双重检查锁

单例类

/**
 * 单例模式
 * 懒汉式：双重检查锁
 */
public class Singleton {
    //私有构造方法
    private Singleton(){};

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

测试类

/**
 * 测试类
 */
public class Client {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();

        System.out.println(singleton1 == singleton2);
    }
}

测试结果
在这里插入图片描述
说明：

对于 getInstance()方法来说，绝大部分的操作都是读操作，读操作是线程安全的，所以我们没必让每个线程必须持有锁才能调用该方法，我们需要调整加锁的时机。
由此也产生了一种新的实现模式：双重检查锁模式
双重检查锁模式是一种非常好的单例实现模式，解决了单例、性能、线程安全问题。	
上面的双重检测锁模式看上去完美无缺，其实是存在问题，在多线程的情况下，可能会出现空指针问题，出现问题的原因是JVM在实例化对象的时候会进行优化和指令重排序操作。
要解决双重检查锁模式带来空指针异常的问题，只需要使用 `volatile` 关键字, `volatile` 关键字可以保证可见性和有序性。

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

使用双层if的解释说明：
在这里插入图片描述

实例6

懒汉式：使用静态内部类

单例类

/**
 * 单例模式
 * 懒汉式：使用静态内部类
 */
public class Singleton {
    //私有构造方法
    private Singleton(){};

    //静态内部类
    private static class SingletonHolder{
        private static final Singleton SINGLETON = new Singleton();
    }

    //对外提供访问的静态方法
    public static Singleton getInstance(){
        return SingletonHolder.SINGLETON;
    }
}

测试类

/**
 * 测试类
 */
public class Client {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();

        System.out.println(singleton1 == singleton2);
    }
}

测试结果
在这里插入图片描述
说明：

静态内部类单例模式中实例由内部类创建，由于 JVM 在加载外部类的过程中, 是不会加载静态内部类的, 只有内部类的属性/方法被调用时才会被加载, 并初始化其静态属性。
静态属性由于被 static修饰，保证只被实例化一次，并且严格保证实例化顺序。
第一次加载Singleton类时不会去初始化INSTANCE，只有第一次调用getInstance，虚拟机加载SingletonHolder并初始化INSTANCE，这样不仅能确保线程安全，也能保证 Singleton 类的唯一性。

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

实例7

懒汉式：枚举

单例类

/**
 * 单例模式
 * 懒汉式：枚举
 */
public enum Singleton {
    INSTANCE;
}

测试类
在这里插入图片描述
说明：

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

使用单例模式存在的问题

破坏单例模式：

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

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

序列化反序列化破坏

单例类

/**
 * 单例模式
 * 懒汉式：使用静态内部类
 */
public class Singleton implements Serializable {
    //私有构造方法
    private Singleton(){};

    //静态内部类
    private static class SingletonHolder{
        private static final Singleton SINGLETON = new Singleton();
    }

    //对外提供访问的静态方法
    public static Singleton getInstance(){
        return SingletonHolder.SINGLETON;
    }
}

测试类

/**
 * 测试类：
 * 反序列化，破坏单例模式
 */
public class Client {
    public static void main(String[] args) throws Exception{
        //调用writeObject2File方法生成文件
//        writeObject2File();

        Singleton singleton1 = readObjectFromFile();
        Singleton singleton2 = readObjectFromFile();

        System.out.println(singleton1 == singleton2);
    }

    //读取文件
    public static Singleton readObjectFromFile() throws Exception{
        //1.创建对象输入对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("E:\\test\\a.txt"));
        //2.读取对象
        Singleton singleton = (Singleton) ois.readObject();

        //释放资源
        ois.close();
        return singleton;
    }

    //写入文件
    public static void writeObject2File() throws Exception{
        //1.获取singleton对象
        Singleton singleton = Singleton.getInstance();
        //2.创建对象输出流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("E:\\test\\a.txt"));
        //3.将singleton对象写入文件中
        oos.writeObject(singleton);
        //4.释放资源
        oos.close();
    }
}

测试结果，两个对象不相同
在这里插入图片描述
解决方案

单例类加上readResolve方法

//解决序列化反序列化破解单例模式
    private Object readResolve(){
        return SingletonHolder.SINGLETON;
    }

测试结果
在这里插入图片描述

使用反射破坏

单例类

/**
 * 单例模式
 * 懒汉式：使用静态内部类
 */
public class Singleton {
    //私有构造方法
    private Singleton(){};

    //静态内部类
    private static class SingletonHolder{
        private static final Singleton SINGLETON = new Singleton();
    }

    //对外提供访问的静态方法
    public static Singleton getInstance(){
        return SingletonHolder.SINGLETON;
    }
}

测试类

/**
 * 测试类
 * 使用反射破坏单例模式
 */
public class Client {
    public static void main(String[] args) throws Exception {
        //1.获取singleton的字节码对象
        Class<Singleton> clazz = Singleton.class;
        //2.获取无参构造方法对象
        Constructor<Singleton> constructor = clazz.getDeclaredConstructor();
        //3.取消访问检查
        constructor.setAccessible(true);
        //4.创建singleton对象
        Singleton singleton1 = constructor.newInstance();
        Singleton singleton2 = constructor.newInstance();

        System.out.println(singleton1 == singleton2);

    }
}

测试结果
在这里插入图片描述
解决方案

单例类，增加判断，使用异常解决不能创建多个对象

/**
 * 单例模式
 * 懒汉式：使用静态内部类
 */
public class Singleton {
    private static Boolean flag = false;
    //私有构造方法
    private Singleton(){
       synchronized (Singleton.class){
           if (flag){
               throw new RuntimeException("不能创建多个对象");
           }
           flag = true;
       }
    };

    //静态内部类
    private static class SingletonHolder{
        private static final Singleton SINGLETON = new Singleton();
    }

    //对外提供访问的静态方法
    public static Singleton getInstance(){
        return SingletonHolder.SINGLETON;
    }
}

测试结果
在这里插入图片描述
结束！

				不同的列车都在开往更好的方向。
新征程，再出发
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单例模式
zhangxl_good的博客
09-11 135
单例模式是一种创建型设计模式，一个类只能创建一个对象，所以称为单例模式。 那么该如何实现一个单例呢？ 首先需要将构造函数私有化，禁止在类外部实例化对象 其次在类内部定义创建唯一对象的方法，并使用private static final修饰 最后定义一个publicstatic静态方法提供访问单例对象的入口 实现一：饿汉式 ...
创建单例的4种方式
weixin_44852871的博客
08-10 1082
文章目录饿汉式懒汉式静态内部类式双重if判断 饿汉式 public class TestSingleton1 { //饿汉式单例 private static TestSingleton1 instance = new TestSingleton1(); private TestSingleton1(){ } public static TestSingleton1 getInstance(){
设计模式--单例模式
wj_1010的博客
07-14 218
一、单例模式 说到单例模式，大家的第一反应应该是——什么是单例模式。单例模式的定义，官方的定义总结起来就两句话，确保一个类只有一个实例（也就是类的对象），并且提供一个全局的访问点（外部通过这个访问点来访问该类的唯一实例）。 哈哈，是不是有点懵了，没关系，正常！ 单例模式的实现其实只有两行代码，定义里面的这两句话分别对应一句代码。我在这里不解释这个定义，我们用代码来说话。我在这里新建一个控制台...
实现单例模式
qq_43621555的博客
05-24 212
这里我们使用Singletion代表我们将要使用和创建的类。 单例模式： 只能生成一个类的实例Singletion（单例）模式的类型，由于设计模式在面向对象程序设计中起着举足轻重的作用，在常用的设计模式中单例模式是唯一一个能够用短短几十行代码完整实现的模式。 解法一： 只适用于单线程 public class Singleton1 { private static Singleton1 instance = null; public static S
如何写一个完美的单例类
zxm317122667的专栏
04-12 644
设计模式在软件开发中一直是一个非常热门的话题。通常来说，设计模式是一种解决某一类软件开发问题的解决方案。而这篇文章所讲的单例模式就是创建型模式中的一种。单例模式的目的单例模式的主要目的是...
JAVA-设计模式-创建型模式-单例模式
最新发布
08-10
JAVA-设计模式-创建型模式-单例模式
[创建型模式] 单例模式（Singleton Pattern）
01-20
一个类可以创建多个对象，这是面向对象的语言特性，想要实现单例模式，就要屏蔽这个特性，防止系统可以随意创建类的对象。 要做到这一点，通常做法就是利用private关键字将类的构造方法私有化，使外部调用者无法利用...
【设计模式】（四）–创建型模式–单例模式
12-21
【设计模式】（四）–创建型模式–单例模式单例模式的定义饿汉式单例模式懒汉式单例模式饿汉式与懒汉式的区别：单例模式的优点单例模式的缺点Java中其他生成单例的方式使用Spring框架，Spring框架默认就是单例双重...
创建型模式之单例模式(Singleton Pattern)
07-06
4、单例模式(Singleton Pattern) 用意：仅允许生成一个对象时
java设计模式之单例模式
08-29
单例模式是java设计模式中的一种常用的创建型模式，是我们日常开发中最常使用的一种设计模式。它的主要作用是保证系统中一个类只有一个实例。单例模式可以被用来封装一些工具类，例如数据库连接等。 单例模式的定义...
创建型模式——单例模式（Singleton Pattern）
qq_46658171的博客
09-05 666
单例模式（Singleton Pattern）属于创建型模式。 这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。类在内存中只能存在一个实例对象。
设计一个单例模式的类
Liyuan的博客
03-15 1114
package 单例; /** * 这个类设计成单例模式 * * @author 神舟 * */ public class SingleClass { /** * 对象变量 */ private static SingleClass instance; /** * 私有化构造方法 */ private SingleClass() {} /** * 提供...
C++中一个类成员函数调用另一个类成员的方法
热门推荐
青山绿水
10-31 7万+
在C++中一个类成员函数调用另一个类成员的方法主要有：类的组合，友元类，单例模式等，下面主要讲讲这三种方法的实现 方法1：利用类的组合 组合通俗来讲就是类B有类A的属性，如声明一个Person类，再声明一个Teacher类，Person类对象有年龄和姓名成员，而Teacher类对象成员也有年龄和姓名属性，所以我们可以将类Person的对象作为类Teacher的成员变量，那么就实现了Teacher类...
编写一个Singleton类（单例模式）
weixin_30287169的博客
07-20 733
在面试的时候，单例模式是经常被提问到的，编写一个Singleton类，可以更好的向面试官展现出自己对单例模式的理解。下面我列举出四个方式在展示Singleton类 1.简单的方式，但这个有一个缺点，那就是在并发执行时，可能存在多个实例。 1 public class SingletonDemo1 { 2 private static SingletonDemo1 INSTAN...
设计模式--JAVA写一个常用典型的单例模式类
dreamer23的专栏
06-19 2086
单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，确保某个类只有一个实例.而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象等常被设计成单例。一、下面写一个常用的单例类：public class Singleton { private int id; private volatile static Sing...
一个简单的单例模式 类的编写
yuyanfei125的专栏
05-15 2365
class Singleton     {         private static Singleton instance;         // Constructor         protected Singleton() { }         // Methods         public static Singleton Instance()  
Java设计模式（一）之单例模式
zk86547462的博客
09-14 449
一、概述 单例模式的定义就是确保某一个类只有一个实例，并且提供一个全局访问点。属于设计模式三大类中的创建型模式。 单例模式具有典型的三个特点： 只有一个实例。 自我实例化。 提供全局访问点。 二、优缺点 优点：由于单例模式只生成了一个实例，所以能够节约系统资源，减少性能开销，提高系统效率，同时也能够严格控制客户对它的访问。 缺点：也正是因为系统中只有一个实例，这样就导致了单例类的职责过重，违背了“单一职责原则”，同时也没有抽象类，这样扩展起来有一定的困难。 三，实现 饿汉式：线程安全，调用效率高。但是不
单例模式设计
兰天禄的博客
03-19 174
单例模式设计 单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的类一个类只有一个实例。即一个类只有一个对象实例。 努力不需要仪式感 步骤1：在单例类内部定义了一个Singleton类型的静态对象，作为外部共享的唯一实例 步骤2：提供一个公共静态的方法，让客户可以访问它的唯一实例。 步骤3：为了防止在外部...
Singleton单例模式的几种创建方法
hl_java的专栏
04-12 2126
创建单例类有以下几种方式： 饿汉式 懒汉式(加同步锁的懒汉式、加双重校验锁的懒汉式、防止指令重排优化的懒汉式) 登记式单例模式 静态内部类单例模式 枚举类型的单例模式 备注： 其中“枚举类型的单例模式。”最牛逼，可以防止反射调用构造器 饿汉式; public class MyManger { private static MyManger instance...
原型模式和单例模式的区别
05-10
原型模式和单例模式都属于创建型设计模式，但是它们的目的和实现方式有很大的不同。 1. 目的不同： - 原型模式的目的是为了克隆一个对象，以便在不影响原始对象的情况下创建新对象。原型模式适用于创建对象成本较高的情况，可以通过复制已有对象的方式来快速创建新对象。 - 单例模式的目的是确保一个类只有一个实例，并提供全局访问点。单例模式适用于某些场景下只需要一个对象实例，例如线程池、缓存、日志等。 2. 实现方式不同： - 原型模式的实现方式是通过复制已有对象，然后修改其属性来创建新对象。原型模式可以通过深拷贝和浅拷贝来实现。 - 单例模式的实现方式是将类的构造函数私有化，然后通过一个静态方法来获取实例。单例模式可以通过饿汉式和懒汉式来实现。 3. 应用场景不同： - 原型模式适用于需要创建对象成本较高的情况，例如大型数据库连接、网络连接、线程等。 - 单例模式适用于需要全局唯一的对象实例的情况，例如配置文件、日志、线程池等。 综上所述，原型模式和单例模式的区别在于它们的目的、实现方式和应用场景不同。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值