设计模式—单例设计模式

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

单例设计模式

1.概述

定义： 确保一个类最多只有一个实例，并提供一个全局访问点
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

2.结构

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

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

3.实现

3.1 预加载（饿汉式）

预加载：顾名思义，就是预先加载。再进一步解释就是还没有使用该单例对象，但是，该单例对象就已经被加载到内存了。

package com.lxg.pattern.singleton;

/**
 * 饿汉式：预加载
 * 静态成员变量
 */
public class Singleton1 {
    //定义静态成员变量获取本类的实例
    private static final Singleton1 INSTANCE = new Singleton1();

    //私有构造方法，避免通过new关键字来实例化对象，保证只存在一个实例
    private Singleton1(){}

    //提供一个公共的访问类，让外界获取该对象
    public static Singleton1 getINSTANCE() {
        return INSTANCE;
    }
}

第二种初始化实例方式：使用静态代码块

package com.lxg.pattern.singleton;

/**
 * 饿汉式的第二种实现方式：
 * 使用静态代码块的方式
 */
public class Singleton2 {

    //声明Singleton2类型的静态常量成员变量，但是没有初始化，在静态代码块中对其进行初始化
    private static final Singleton2 INSTANCE;

    //在静态代码块中对成员常量初始化
    static {
        INSTANCE = new Singleton2();
    }
    //私有化构造方法，避免外部使用new关键字创建实例
    private Singleton2(){}

    //定义公共方法，对外提供获取单例实例的接口
    public static Singleton2 getINSTANCE() {
        return INSTANCE;
    }
}

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

3.2 预加载（饿汉式）——枚举方式

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

package com.lxg.pattern.singleton;

/**
 * 枚举方式实现单例
 * 枚举类型实现单例模式是极力推荐的实现模式。因为枚举是线程安全的，并且只会装载一次，设计者充分
 * 利用了枚举的这个特性来实现单例模式，枚举的写法非常简单，而且枚举类型是所用单例实现中唯一不会被
 * 破坏的单例实现模式。
 *
 * 枚举类型属于饿汉式方式，即预加载模式，在不考虑内存空间的情况下，使用枚举方式是比较好的一种方式
 */
public enum Singleton6 {
    INSTANCE;
}

3.3 懒加载（懒汉式）

为了避免内存的浪费，我们可以采用懒加载，即用到该单例对象的时候再创建。

package com.lxg.pattern.singleton;

/**
 * 懒汉式 懒加载 lazy loading
 */
public class Singleton3 {
    //声明Singleton类型的变量
    private static Singleton3 instance; //只是声明，并没有赋值

    //私有化构造方法
    private Singleton3(){}
  
    /**
     * 第一种方式：
     *  对外提供获取单例的接口方法,下面这种方法存在线程安全问题。
     */
    public static Singleton3 getInstance() {
        if(instance==null){
            instance = new Singleton3();
        }
        return instance;
    }
}

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

3.4 懒加载（懒汉式）——解决线程安全问题

通过在getInstance()方法上添加了synchronized关键字来解决线程安全问题：

package com.lxg.pattern.singleton;

/**
 * 懒汉式 懒加载 lazy loading
 */
public class Singleton3 {
    //声明Singleton类型的变量
    private static Singleton3 instance; //只是声明，并没有赋值

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

    /**
     * 第二种方式：
     * 使用synchronized同步关键字来解决线程安全问题
     * synchronized加载getInstace()函数上确实保证了线程的安全。
     * 但是，如果要经常的调用getInstance()方法，不管有没有初始化实例，都会唤醒和阻塞线程。
     * @return
     */
    public static synchronized Singleton3 getInstance() {
    	if(instance==null){
            instance = new Singleton3();
        }
        return instance;
    }
}

分析

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

3.5 懒加载（懒汉式）——双重检查

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

package com.lxg.pattern.singleton;

import java.io.Serializable;

/**
 * 懒汉式的双重检查锁方式
 *
 */
public class Singleton4 implements Serializable {

    //使用volatile 关键字可以保证可见性和有序性
    private static volatile Singleton4 instance;

    private Singleton4(){}

    public static Singleton4 getInstance() {
        /**
         * 使用双重检查解决了单例、性能、线程安全问题，但是在多线程环境中由于JVM在实例化对象的时候会进行
         * 优化和指令的重排序操作，可能会导致空指针异常问题，这时候需要使用volatile关键字，可以保证可见性
         * 和有序性
         */
        //第一次判断，如果instance的值不为null,不需要抢占锁，再返回对象
        if(instance==null){
            synchronized (Singleton4.class){
                //第二次判断
                if(instance==null){
                    instance = new Singleton4();
                }
            }
        }
        return instance;
    }
}

分析

双重检查锁模式是一种非常好的单例实现模式，解决了单例、性能、线程安全问题，上面的双重检测锁模式看上去完美无缺，其实是存在问题，在多线程的情况下，可能会出现空指针问题，出现问题的原因是JVM在实例化对象的时候会进行优化和指令重排序操作。
要解决双重检查锁模式带来空指针异常的问题，只需要使用 volatile 关键字, volatile 关键字可以保证可见性和有序性。
添加 volatile 关键字之后的双重检查锁模式是一种比较好的单例实现模式，能够保证在多线程的情况下线程安全也不会有性能问题。

3.6 懒加载（懒汉式）——静态内部类

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

package com.lxg.pattern.singleton;

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

    private static boolean flag = false;

    //私有化构造器
    private Singleton5(){
    }

	//定义静态内部类，私有化属性
    private static class SingletonHolder{
        private static final Singleton5 INSTANCE = new Singleton5();
    }

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

分析

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

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

4.存在的问题及解决方法

4.1 问题一：序列化和反序列化能够破坏单例模式

问题演示

实现Serializable接口，使得单例类可以序列化

package com.lxg.pattern.singleton;

import java.io.Serializable;

/**
 * 懒汉式的双重检查锁方式
 *
 */
public class Singleton4 implements Serializable {

    //使用volatile 关键字可以保证可见性和有序性
    private static volatile Singleton4 instance;

    private Singleton4(){}

    public static Singleton4 getInstance() {
        /**
         * 使用双重检查解决了单例、性能、线程安全问题，但是在多线程环境中由于JVM在实例化对象的时候会进行
         * 优化和指令的重排序操作，可能会导致空指针异常问题，这时候需要使用volatile关键字，可以保证可见性 和有序性
         */
        //第一次判断，如果instance的值不为null,不需要抢占锁，再返回对象
        if(instance==null){
            synchronized (Singleton4.class){
                //第二次判断
                if(instance==null){
                    instance = new Singleton4();
                }
            }
        }
        return instance;
    }
}

通过序列化和反序列化能够破坏单例

package com.lxg.pattern.singleton;

import java.io.*;
import java.lang.reflect.Constructor;

/**
 * 测试类
 */
public class Client {
    public static void main(String[] args) throws Exception {
        /**
         * 使用序列化破坏单例模式
         */
        //写对象
        writeObject2File();
        //读对象
        readObjectFromFile();
        readObjectFromFile();


    }

    /**
     * 向文件中写对象
     * @throws Exception
     */
    public static void writeObject2File() throws Exception{
        //获取Singleton对象
        Singleton4 instance = Singleton4.getInstance();
        //创建对象输出流对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("a.txt"));
        //写对象
        oos.writeObject(instance);
        //释放资源
        oos.close();
    }

    public static void readObjectFromFile() throws Exception {
        //创建对象输入流
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("a.txt"));
        //读取对象
        Singleton4 instance = (Singleton4) ois.readObject();

        System.out.println(instance);
        //释放资源
        ois.close();
    }

}

运行结果，明显不是同一个实例，破坏了单例模式

com.lxg.pattern.singleton.Singleton4@568db2f2
com.lxg.pattern.singleton.Singleton4@378bf509

问题解决

在类中实现readResolve()方法可以解决序列化和反序列化破坏单例的问题,因为在序列化的方法readObject()中定义会对类进行检查，检查是否有定义readResolve()方法，如果有则返回该方法的返回值作为反序列化的对象。

package com.lxg.pattern.singleton;

public class Singleton5 {

    private static boolean flag = false;

    //私有化构造器
    private Singleton5(){}

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

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

    /**
     * 定义此方法，当反序列化的时候，将该方法的返回值直接返回，解决
     * 了序列化和反序列化破坏单例的问题。
     * @return
     */
    public Object readResolve(){
        return SingletonHolder.INSTANCE;
    }
}

4.2 问题二：反射能够破坏单例模式

问题演示

通过反射来创建单例对象的演示

package com.lxg.pattern.singleton;

import java.io.*;
import java.lang.reflect.Constructor;

/**
 * 测试类
 */
public class Client {
    public static void main(String[] args) throws Exception {
        /**
         * 通过反射破坏单例模式
         */
        destroySingletonByReflect();//返回结果为false，说明单例模式被破坏了

    }

    /**
     * 通过反射来破坏单例模式
     */
    public static void destroySingletonByReflect() throws Exception {
        //获取Singleton的字节对象
        Class<Singleton5> clazz = Singleton5.class;
        //获取无参构造方法
        Constructor<Singleton5> constructor = clazz.getDeclaredConstructor();
        //取消访问检查
        constructor.setAccessible(true);
        //创建Singleton对象
        Singleton5 s1 = constructor.newInstance();
        Singleton5 s2 = constructor.newInstance();
        System.out.println("s1==s2? : "+(s1==s2));
    }
}

运行结果

false

问题解决

在单例类中对构造器进行限制，当通过反射方式调用构造方法进行创建创建时，直接抛异常。不运行此中操作。

package com.lxg.pattern.singleton;

public class Singleton5 {

    private static boolean flag = false;

    //私有化构造器
    /**
     * 在构造方法中增加判断，解决反射破坏单例的情况
     */
    private Singleton5(){
        synchronized(Singleton5.class){
            if(flag){
                //判断flag的值，如果是true，说明是第一次访问，如果不是，说明是第一次访问。
                throw new RuntimeException("不能创建两个对象");
            }
            //将flag的值设置为true
            flag = true;
        }
    }

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

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

5.JDK源码解析-Runtime类

Runtime类就是使用的单例设计模式。

5.1 Runtime类部分源码

public class Runtime {
	//私有化自身类型的属性变量并初始化，属于饿汉式的单例模式
    private static Runtime currentRuntime = new Runtime();

	//定义接口方法，给外部获取单例实例
    public static Runtime getRuntime() {
        return currentRuntime;
    }

    //私有化构造器，禁止外部通过new关键字来实例化对象
    private Runtime() {}
}

5.2 Runtime类的使用

public class RuntimeDemo {
    public static void main(String[] args) throws IOException {
        //获取Runtime类对象
        Runtime runtime = Runtime.getRuntime();

        //返回 Java 虚拟机中的内存总量。
        System.out.println(runtime.totalMemory());
        //返回 Java 虚拟机试图使用的最大内存量。
        System.out.println(runtime.maxMemory());

        //创建一个新的进程执行指定的字符串命令，返回进程对象
        Process process = runtime.exec("ipconfig");
        //获取命令执行后的结果，通过输入流获取
        InputStream inputStream = process.getInputStream();
        byte[] arr = new byte[1024 * 1024* 100];
        int b = inputStream.read(arr);
        System.out.println(new String(arr,0,b,"gbk"));
    }
}
Luo_xguan
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#设计模式–单例模式
12-22
一、引言 　近在学设计模式的一些...，从“单例”字面意思上理解为——一个类只有一个实例，所以单例模式也是保证一个类只有一个实例的一种实现方法罢了(设计模式其实是帮助我们解决实际开发过程中的方法， 该方法是
JAVA设计模式之单例模式
09-22
单例模式是软件设计模式中的一种经典模式，它在Java编程中被广泛使用，尤其是在需要控制实例化过程，或者确保某类只有一个实例时。本文将深入探讨Java中的单例模式，帮助你理解其原理和应用。 单例模式的核心思想是...
设计模式之单例模式
个人博客
10-19 94
一、什么是单例模式 单例模式是一种常用的软件设计模式，其定义是单例对象的类只能允许一个实例存在。 二、单例模式-饿汉式 //单例模式 - 饿汉式 public class HungryType { //私有化构造方法 private HungryType(){}; //静态实例化 private static final HungryType hungryType = new HungryType(); //调用方法 返回实例 public stati
设计模式-单例模式
qq_43108252的博客
02-15 392
1.单例模式的定义 确保一个类只有一个实例，并且提供一个全局访问点来访问这唯一实例； 特点： 一个类只有一个实例 必须自己创建这个实例 必须向整个系统提供这个实例 2 实例 2.1 创建方式： 将构造函数私有化，这样能保证只能在类内进行实例化； 实例对象设置为静态； 设置获取实例对象函数； 2.2具体实例 ...
设计模式——单例模式
安歌
11-09 330
单例模式单例模式的定义定义单例模式基本结构单例模式的实现优雅的单例模式惰性单例模式单例模式的应用命名空间管理代码库的模块创建静态变量单例模式的优缺点 单例模式的定义 定义 单例模式又称为单体模式，是只允许实例化一次的对象类。 单例模式基本结构 从广义的定义来说，单例模式只是一个用来划分命名空间并将一系列相关方法和属性组织在一起的对象，并且只能实例化一次。最简单的单例就是一个对象字面量。 var single = { name:'Yimi', getName() {return this.name
快速理解设计模式：单例模式深入
热门推荐
张彦峰的博客
04-21 169万+
单例模式是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。实现方式介绍分析：饿汉式单例模式+懒汉式单例模式（双重检查锁）+静态内部类实现单例模式+注册式单例模式
设计模式单例模式.zip
05-03
单例模式是软件设计模式中的一种经典模式，它在计算机科学中被广泛应用于创建和管理一个类的唯一实例。这个模式的核心思想是确保一个类只有一个实例，并提供一个全局访问点来获取这个唯一的实例。这样的设计可以避免...
常见设计模式-单例模式
07-06
单例模式是设计模式中的一种，其主要目的是确保一个类只有一个实例，并且提供一个全局访问点来获取这个实例。在Java编程中，实现单例模式有多种方式，每种方式都有其优缺点。 1. **饿汉式**： 饿汉式在类加载时即...
ava常用设计模式-单例模式
08-26
ava常用设计模式-单例模式 单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一，有以下特点： 1. 单例类只能有一个实例。 2. 单例类必须自己创建自己的唯一实例。 3. 单例类必须给所有其他对象提供这一...
（javaweb）请求响应postman
2301_79144798的博客
08-08 539
1.Tomcat又称为servlet容器前端浏览器发起请求携带http请求数据，web服务器负责请求协议的解析，Tomcat接收请求数据，并对请求数据进行解析。Tomcat将解析后所有的信息封装到一个对象当中：HttpServletRequest（请求对象）---应用程序从中获取请求数据。HttpServletResponse--通过这个对象设置要响应的数据 --响应信息给浏览器浏览器--服务器：：BS架构（通过浏览器能访问到的网站：京东 淘宝 天猫 唯品会都是BS架构）
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 509
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
springboot民办高校科研项目管理系统-计算机毕业设计源码54009
VX_DZbishe的博客
08-11 537
论文主要是对基于springboot的民办高校科研项目管理系统进行了介绍，包括研究的现状，还有涉及的开发背景，然后还对系统的设计目标进行了论述，还有系统的需求以及整个的设计方案，对系统的设计以及实现，也都论述的比较细致，最后对基于springboot的民办高校科研项目管理系统进行了一些具体测试。本次报告，首先分析了研究的背景、作用、意义，为研究工作的合理性打下了基础。
集合（1）
supercool7的博客
08-12 799
表示不同的类型集合，Collection、Map、List、Set、Queue、Deque等，以及辅助性质的接口Iterator、LinkIterator、Comparator、Comparable这些接口是为迭代和比较元素而准备。对接口的具体实现，主要常用的有：ArrayList、LinkedList、HashMap、HashSet、TreeMap等等。理解Java集合体系可以从三个层次：最上层的接口、中间的抽象类、最后的实现类。是所有集合框架的根接口，包含了对集合进行基本操作的方法。
构造方法，JavaBean，对象内存图，基础数据类型和引用数据类型
最新发布
qq_63126439的博客
08-14 214
栈内存处理完数据之后会退出，指向推内存的箭头都会消失，当没有人指向他的时候，堆内存中的数据也会被移除。带参构造方法和无参数构造方法，两者方法名相同，但参数不同，这叫做构造方法的重载。方法区，新增元空间，把原来的方法区的多种功能进行了拆分。创造对象的时候，虚拟机会自动调用构造方法，作用是给成员变量进行初始化的。只要是看见new就会在堆内存创建新的空间，两个空间是独立的，互不影响。基础数据类型，在变量当中存储真实的数据值，和其他空间没有任何关系。使用其他空间的数值，自己的空间存储的是地址值。
安卓Android & JAVA校招/实习面试合集:多线程、强软弱虚引用、进程、内存管理、Activity、Fragment......
qq_41915623的博客
08-10 519
安卓Android、java面试资料合集：内存管理、多线程、进程、强软弱虚应用、Activity
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值