创建者模式之单例模式

最新推荐文章于 2023-05-19 09:00:00 发布
最新推荐文章于 2023-05-19 09:00:00 发布
阅读量285 收藏
点赞数 1
分类专栏： 设计模式 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52038897/article/details/124177055
版权

创建者模式的主要关注点是"怎样创建对象"，主要特点是"将对象的创建与使用分离"

这样降低了系统耦合度，使用者不需要关注对象的创建细节。

创建者模式分为：

  • 单例模式
  • 工厂方法模式
  • 抽象工程模式
  • 原型模式
  • 建造者模式

今天先学习一下单例模式

什么是单例设计模式（Singleton Pattern）

单例设计模式是Java中最简单的设计模式之一。属于创建型模式，提供了创建对象的最佳方式。

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

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

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

单例模式的实现

饿汉式

类加载就会导致该单实例对象被创建

静态变量方式
/**
 * 单例模式-饿汉式-静态变量方式
 * 该方式在成员位置声明Singleton类的对象instance。实例对象是随着类的加载而创建的。如果该对象足够大的话，而一直不使用会造成内存的浪费。
 */
public class Singleton {

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

    // 2.在本类中创建本类对象
    private static Singleton instance = new Singleton();

    // 3.提供外界一个公共的访问方式，让外界获取该对象
    public static Singleton getInstance() {
        return instance;
    }


}
静态代码块方式
/**
 * 单例模式-饿汉式-静态代码块
 * 同方式一，也存在浪费问题
 */
public class Singleton {

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

    // 声明Singleton类型的变量
    private static Singleton instance; // null

    // 在静态代码块中进行赋值
    static {
        instance = new Singleton();
    }

    public static Singleton getInstance() {
        return instance;
    }

}

以上两种方式在类的加载时就会创建对象，但如果实例化的对象长时间不被使用，则都会带来一定的内存开销。因此并不推荐饿汉式的声明方式。

懒汉式

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

方式一（线程不安全）
/**
 * 单例模式-懒汉式-方式1（线程不安全）
 */
public class Singleton {

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

    // 声明Singleton类型的变量instance
    private static Singleton instance;  //  只是声明一个该类型的变量，并没有赋值

    // 对外提供访问方式
    public static Singleton getInstance() { // 每调用这个方法，都会创建一个对象
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

}

方式一当有多个先线程在获取单例方法中等待CPU执行权时，导致有多个对象被实例化

方式二（线程安全）
/**
 * 单例模式-懒汉式-方式2（线程安全）
 */
public class Singleton {

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

    // 声明Singleton类型的变量instance
    private static Singleton instance;  //  只是声明一个该类型的变量，并没有赋值

    // 对外提供访问方式
    public static synchronized Singleton getInstance() { // 每调用这个方法，都会创建一个对象
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

}

这种方法一改方式一，在getInstance方法上加了同步锁，使得线程安全，但由于直接给方法上锁，使得锁粒度过高，大大降低了程序的性能

方式三（双重检查锁）
/**
 * 单例模式-懒汉式-双重检查锁
 */
public class Singleton {

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

    // volatile关键字保证可见性和有序性，解决多线程带来的空指针问题
    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;
    }
}

在判断为空后，Singleton加上类锁，再进行一次判断，为空则实例化对象。此方法也是一种常见的单例模式的实现方式

方式四（静态内部类）
/**
 * 静态内部类方式
 */
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类的唯一性。静态内部类单例模式是一种优秀的单例模式，是开源项目中比较常用的一种单例模式。它利用了JVM的特性，在没有加任何锁的情况下，保证了多线程下的安全，并且没有任何性能影响和间的浪费。

枚举方式

单元素的枚举类型已经成为实现Singleton的最佳方法

这句话是Joshua Bloch前辈在《Effective Java》一书中提到的。此方式不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。

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

public class Client {

    public static void main(String[] args) {
        
        Singleton instance = Singleton.INSTANCE;
        Singleton anotherInstance = Singleton.INSTANCE;
        System.out.println(instance == anotherInstance);
        
    }
}


true

进程已结束,退出代码0

枚举方式属于饿汉式，在不考虑浪费内存空间的情况下，可首选枚举法。上面提到了，枚举方式可以避免反序列化重新创建新的对象，那么看来单例是可以被破坏的，下面就来分析分析

存在的问题

上面的方式，枚举除外，都可以创建多个对象。有两种实现方式：序列化和反射

序列化

采用懒汉式静态内部类方式创建单例（要继承序列化接口）

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;
    }

}


public class Client {

    public static void main(String[] args) throws Exception {

        writeObject2File();
        readObjectFromFile();
        readObjectFromFile();

    }

    // 从文件中写对象
    public static void readObjectFromFile() throws Exception {
        // 1.创建对象输入流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("C:\\Users\\Lin\\Desktop\\demo.txt"));
        // 2.读取对象
        Singleton instance = (Singleton) ois.readObject();
        System.out.println(instance);
        // 3.释放资源
        ois.close();

    }

    // 从文件中读对象
    public static void writeObject2File() throws Exception {
        // 1.获取对象
        Singleton instance = Singleton.getInstance();
        // 2.创建对象输出流对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\Lin\\Desktop\\demo.txt"));
        // 3.写对象
        oos.writeObject(instance);
        // 4.释放资源
        oos.close();
    }

}

tech.maiquer.signleton.destroy.demo1.Singleton@312b1dae
tech.maiquer.signleton.destroy.demo1.Singleton@7530d0a

进程已结束,退出代码0

说明：将单例对象流读取写到桌面的demo文件中，再读取文件取出对象打印出来，发现两次地址并不统一，说明序列化破坏了单例

反序列破解解决方法

只需要在Singleton类中增加readResolve方法

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

测试：

tech.maiquer.signleton.destroy.demo1.Singleton@3764951d
tech.maiquer.signleton.destroy.demo1.Singleton@3764951d

进程已结束,退出代码0

现在就解决了序列化破坏单例的问题了

反射

先同样使用懒汉式静态内部类的方式构造单例：

public class Singleton {

    private Singleton() {
    }

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

    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }

}

public class Client {

    public static void main(String[] args) throws Exception {

        // 1.获取Singleton的字节码对象
        Class clazz = Singleton.class;
        // 2.获取无参构造方法对象
        Constructor cons = clazz.getDeclaredConstructor();
        // 3.开启访问
        cons.setAccessible(true);
        // 4.创建Singleton对象
        Singleton s1 = (Singleton) cons.newInstance();
        Singleton s2 = (Singleton) cons.newInstance();

        System.out.println(s1 == s2);

    }

}

通过反射，拿到对象构造器，无视private权限

打印结果如下：

false

进程已结束,退出代码

发现反射毫无感情的破坏了单例（我单例不要面子的吗…）或许这就是暴力美学吧~~~

解决反射

魔高一尺，道高一丈

既然反射可以任性的获取构造器构造实例，我们拦不住。那就加一个flag标志，限制该类只能创建一个实例

同样以懒汉式静态内部类为例：

public class Singleton {

    // 初始化为false
    private static boolean flag = false;

    private Singleton() {

        synchronized (Singleton.class) { // 方法同步锁，使线程安全

            if (flag) { // 如果flag为真，则说明已经创建过实例了
                throw new RuntimeException("唯一实例已被创建，不能再创建啦！！！");
            }
            // 实例被创建了 则将flag设为真、
            flag = true;

        }

    }

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

    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }

}

客户端测试：

Exception in thread "main" java.lang.reflect.InvocationTargetException
	at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
	at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
	at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
	at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
	at tech.maiquer.signleton.destroy.demo2.Client.main(Client.java:17)
Caused by: java.lang.RuntimeException: 唯一实例已被创建，不能再创建啦！！！
	at tech.maiquer.signleton.destroy.demo2.Singleton.<init>(Singleton.java:13)
	... 5 more

进程已结束,退出代码1

可见，程序出发了运行时异常，告诉我们唯一实例已存在，休想再贪

JDK源码实例

JDK中的Runtime类的构造方式就是一种单例，我们一起来看看

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() {}
    
}

通过前面的铺垫，不难看出，这是一个通过饿汉式创建单例的案例

该类有很多好玩的函数，例如exec方法，它可以运行终端命令，例如我要获取我的电脑的网卡信息：

import java.io.IOException;
import java.io.InputStream;

public class RuntimeDemo {

    public static void main(String[] args) throws IOException {

        // 获取Runtime单例
        Runtime runtime = Runtime.getRuntime();

        // 调用runtime的exec方法
        String command = "ipconfig";
        Process process = runtime.exec(command);

        // process对象获取输入流
        InputStream is = process.getInputStream();
        byte[] arr = new byte[1024 * 1024 * 100];

        // 读取数据
        int len = is.read(arr); // 返回读到的字节的个数

        // 打印
        System.out.println(new String(arr, 0, len, "GBK"));

    }

}

打印结果：

Windows IP 配置


以太网适配器 以太网:

   媒体状态  . . . . . . . . . . . . : 媒体已断开连接
   连接特定的 DNS 后缀 . . . . . . . : 

无线局域网适配器 本地连接* 10:

   媒体状态  . . . . . . . . . . . . : 媒体已断开连接
   连接特定的 DNS 后缀 . . . . . . . : 

无线局域网适配器 本地连接* 11:

   媒体状态  . . . . . . . . . . . . : 媒体已断开连接
   连接特定的 DNS 后缀 . . . . . . . : 

以太网适配器 SSTAP 1:

   媒体状态  . . . . . . . . . . . . : 媒体已断开连接
   连接特定的 DNS 后缀 . . . . . . . : 

以太网适配器 VMware Network Adapter VMnet1:

   连接特定的 DNS 后缀 . . . . . . . : 
   本地链接 IPv6 地址. . . . . . . . : fe80::70c5:6a39:2ffc:e4d1%16
   IPv4 地址 . . . . . . . . . . . . : 192.168.35.1
   子网掩码  . . . . . . . . . . . . : 255.255.255.0
   默认网关. . . . . . . . . . . . . : 

以太网适配器 VMware Network Adapter VMnet8:

   连接特定的 DNS 后缀 . . . . . . . : 
   本地链接 IPv6 地址. . . . . . . . : fe80::9506:5df3:8e59:c204%9
   IPv4 地址 . . . . . . . . . . . . : 192.168.221.1
   子网掩码  . . . . . . . . . . . . : 255.255.255.0
   默认网关. . . . . . . . . . . . . : 

以太网适配器 蓝牙网络连接:

   媒体状态  . . . . . . . . . . . . : 媒体已断开连接
   连接特定的 DNS 后缀 . . . . . . . : 

无线局域网适配器 WLAN:

   连接特定的 DNS 后缀 . . . . . . . : 
   IPv4 地址 . . . . . . . . . . . . : 192.168.3.119
   子网掩码  . . . . . . . . . . . . : 255.255.255.0
   默认网关. . . . . . . . . . . . . : 192.168.3.1


进程已结束,退出代码0

结束语：

我是自己最大的敌人 — 拿破仑

Bruce_Zhang61
关注
专栏目录
构建者与单例模式混合使用的优雅设计
qinbin303647080的专栏
06-30 175
/** * 1 使用一个默认的单例对象实现(字段final修饰，提供静态公共对象，构造函数私有(内部使用构建者对象)，暴露builder对象)，只暴露getter方法 * Created by QINBIN380 on 2021/6/30. */ public class Options { private final List<String> headers; private final String config; public static final .
【设计模式】——建造者模式 单例模式
令狐姑娘
12-17 860
定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。 解释： Director：指挥者，根据小人的需求构建小人对象。在指导中不涉及产品的创建，只负责保证复杂对象各部分被创建或按某种顺序创建。 Builder：是为创建一个Product对象的各个部件指定的抽象接口，类中需要声明一个得到产品建造后结果的方法GetResult。 ConcreteBui
两种设计模式（单例，构造者）
Wandering_sea的博客
09-26 330
设计模式单例模式构造者模式 单例模式 package com.example.demo01; public class User { //设置私有静态方法 获取对象 private static User user = new User(); //设置私有变量 private String name; //私有构造 private User(...
建造者模式与单例模式
zgh27的博客
05-28 601
一、实验目的： 掌握建造者模式（Builder）的特点 分析具体问题，使用建造者模式进行设计。 掌握单例模式（Singleton）的特点 分析具体问题，使用单例模式进行设计。 二、实验环境： eclipse win10 三、实验内容： (写出主要的内容) 实例：KFC套餐 建造者模式可以用于描述KFC如何创建套餐：套餐是一个复杂对象，它一般包含主食（如汉堡、鸡肉卷等）和饮料（如果汁、可乐等）等组成部分，不同的套餐有不同的组成部分，而KFC的服务员可以根据顾客的要求，一步一步装配这些组成部分，构造一份完整
三、创建者模式-单例模式
weixin_42042530的博客
03-17 118
创建型模式的主要关注点是：怎样创建对象？，它的主要特点是：将对象的创建与使用分离。 这样可以降低系统的耦合度，使用者不需要关注对象的创建细节。 创建型模式分为： 单例模式 工厂方法模式 抽象工程模式 原型模式 建造者模式 1、单例模式 1.1 啥叫单例模式 这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。 1.2 单例模式的实现 单例模式的主要有以下角色： 单例类：只能创建一个实例的类 访问类：使用
[创建型模式] 单例模式（Singleton Pattern）
01-20
一个类可以创建多个对象，这是面向对象的语言特性，想要实现单例模式，就要屏蔽这个特性，防止系统可以随意创建类的对象。 要做到这一点，通常做法就是利用private关键字将类的构造方法私有化，使外部调用者无法利用...
JAVA中常用的设计模式：单例模式，工厂模式，观察者模式
08-19
【设计模式概述】 ...总的来说，单例模式、工厂模式和观察者模式都是Java中非常实用的设计模式，它们在实际开发中有着广泛的应用。理解并熟练掌握这些模式，可以帮助开发者编写出更加高效、可维护的代码。
C++中的三大设计模式：单例模式、工厂模式与观察者模式的代码实现
最新发布
09-18
内容概要：本文档介绍了三个经典的软件设计模式——单例模式(Singleton Pattern)、工厂模式(Factory Pattern)以及观察者模式(Observer Pattern)的具体实现，并给出了带有详细注释的C++代码范例。对每个设计模式都有...
设计模式C++学习之单例模式（Singleton）
09-07
单例模式的核心在于控制类的实例化过程，防止多处代码创建多个实例导致资源的浪费或者状态不一致的问题。在C++中，通常通过以下步骤来实现： 1. **私有化构造函数**：为了确保外部不能直接通过new关键字实例化单例...
JavaScript设计模式之单例模式详解
10-19
单例模式是软件工程中常用的设计模式之一，它主要用来确保某一个类只有一个实例存在，并且提供一个全局访问点供外部获取该实例。在JavaScript中实现单例模式需要考虑到函数作用域、闭包、构造函数等概念，其核心思想...
JAVA设计模式（一）单例设计模式与建造者模式
hukuhy的博客
12-01 1081
设计模式，是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结，是前人智慧的结晶。 单例模式：保证一个类只有一个实例被产生。 通常说的单例模式主要有饥汉式和懒汉式（饱汉式）。下面一起来看看吧。饥汉式饥汉式是指在调用该类的实例获取方法时，类已经构造好了实例，可以直接进行返回的方式。public class MySingletonHungry { private static
Java设计模式--单例模式
qq_23587709的博客
03-25 107
一、单例模式简介 单例模式是Java中最简单的设计模式之一。这种设计模式属于创建型模式，它提供了一种创建对象的最佳方式。单例模式类负责创建自己的对象，同时确保只有一个对象被创建，提供了一个访问其唯一对象的方式，可以直接访问，不需要实例化这个对象。 二、单例模式的要素 单例模式类只能有一个实例，需要私有其构造方法，确保只有自己能创建实例。 单例模式类需要给其他对象提供一个访问其实例的全局方法。 三、单例模式的简单实现方式 1.饿汉式 饿汉式是在单例类初始化加载时就创建一个单例对象供外部使用。但这个方式会
C++ 单例模式
qwert55kai的博客
04-11 2405
c++单例模式
【C++】22.单例模式+类型转换
szh0331的博客
05-19 329
总结对比一下饿汉和懒汉的区别懒汉模式需要考虑线程安全和释放的问题 实现相对复杂 饿汉模式不存在以上问题 实现简单懒汉是一种懒加载模式 需要时再初始化对象 不会影响程序的启动 饿汉模式则相反 程序启动阶段就创建初始化实例对象 会导致程序启动慢 影响体验如果有多个单例类 假设有依赖关系(B依赖A) 要求A单例先创建初始化 B再启动 那么就不能用饿汉 因为无法保证初始化顺序 这个用懒汉我们就可以手动控制总结一下:实际中懒汉模式还是更实用一些。
C++设计模式之单例模式
weixin_44958614的博客
04-19 595
#define _CRT_SECURE_NO_WARNINGS #include <iostream> #include <stdlib.h> #include <windows.h> using namespace std; #if 1 /** * 懒汉式 */ class Singelton { public: static Singelton * getInstance() { if (m_sig == NULL) { m_sig = n
Java设计模式之单例模式【创建型】
提笔忘字的帝国
06-10 421
大家好，我是爷爷的茶七里香，最近突然想做一个设计模式的系列，大家都知道设计模式有23种，而设计模式是由前人大量实践总结出来的，它是解决一些问题的最佳解决方案，我们今天就讲下单例模式中相对简单的单例模式吧。要实现单例模式要看以下几点： 测试： 打印结果：这种写法可以避免了性能的浪费也能做到线程安全，但是它并不是懒加载的，因为它是在项目启动就把对象创建好了，如果这个对象一直都用不到，那么就浪费内存了，这种写法用不用就看个人情况吧！ 这种写法可以做到懒加载，但是如果是多线程的情况下会发生什么呢？可能
单例模式运行时类的成员变量地址发生了改变，原因：由于条件编译导致了类在不同的cpp所占内存大小不同
u011342132的博客
04-21 658
在不同的cpp文件（用到类A的）中对A类的内存分布解读不同（有的按照8字节对齐的原则执行了对齐操作，有些没有），导致同一个头文件中定义的类A在不同的cpp所占内存大小不同。 而我这里是由于条件编译宏定义导致了类A在不同的cpp所占内存大小不同。
Java设计模式-建造者模式
BASK2311的博客
03-23 178
当一个复杂的对象装配时,所需要传入的参数比较多的时候,并且会根据不同的参数来装配对象,当参数不同时,装配的对象的内部也不同,可以使用过建造者模式来解决。建造者模式一般是在创建对象比较复杂的情况下使用,当创建对象比较简单的时候,我们可以用构造方法和set方法的方式来创建即可。作者：历河川链接：https://juejin.cn/post/7213285816492113978。
Spring
weixin_50166605的博客
05-22 259
Spring是一个开源的，简化web应用开发的框架 Spring容器管理控制层，Bean,Dao组件,Service组件 IOC 控制反转 AOP 面向切面编程 依赖注入 Spring容器 生命周期 组件化 xml和java注解 一站式 模块：beans context core expression IOC 对象创建使用new关键字（通过java程序创建对象） 但是程序中添加了spring框架 （IOC控制反转） 把对象的创建任务交给spring容器 1.创建spring容器（读取application
单例模式与建造者模式详解
"设计模式之单例模式和建造者模式摘录" 在软件设计中，模式是一种解决常见问题的标准方案，单例模式和建造者模式是其中两种常见的设计模式。 单例模式是一种创建型设计模式，它的核心意图在于确保一个类只有一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Bruce_Zhang61

给萌新一点鼓励吧！

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

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

打赏作者

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

抵扣说明：

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

余额充值