【设计模式】-1.单例模式-你真的了解单例模式吗，单例模式使用详解

最新推荐文章于 2022-09-20 10:54:47 发布
最新推荐文章于 2022-09-20 10:54:47 发布
阅读量214 收藏
点赞数 2
分类专栏： Java高级 设计模式 文章标签： java 单例模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52314655/article/details/124319112
版权

23种设计模式持续更新—1.单例模式

文章目录

创建者模式之单例模式

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

单例模式的实现

饿汉式

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

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

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

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

饿汉式(静态代码块方式)

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

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

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

    static {
        instance = new Singleton();
    }

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

该方式在成员位置声明Singleton类型的静态变量，而对象的创建是在静态代码块中，也是对着类的加载而创建。所以和饿汉式的方式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类的对象，这样就实现了懒加载的效果。但是，如果是多线程环境，会出现线程安全问题。

懒汉式(线程安全)

/**
 * 懒汉式
 *  线程安全
 */
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的时候才会出现线程安全问题，一旦初始化完成就不存在了

懒汉式(双重检查锁)

对于 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在实例化对象的时候会进行优化和指令重排序操作。
JVM在运行优化时会出现缓存机制，频繁读取的数据会进入缓存导致数据被修改后不能很好的被其他线程感知，可能instance 已经不为空了，但是由于存在的不可见性导致，代码继续执行从而导致单例的不唯一，而指令重排也是JVM的自身优化机制，代码可能不会按照编写的顺序执行，而是根据执行速度把认为可能不影响结果并且可以提高执行速度的执行进行顺序调整，顺序的调整可能导致多个实例被创建
要解决双重检查锁模式带来空指针异常的问题，只需要使用 volatile 关键字, volatile 关键字可以使其对其对象不走缓存进行实时更新来保证可见性，并且通过读写屏障防止voatile之前的指令被重排来保证有序性。

/**
 * 双重检查方式
 */
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 关键字之后的双重检查锁模式是一种比较好的单例实现模式，能够保证在多线程的情况下线程安全也不会有性能问题。

懒汉式(静态内部类)

静态内部类单例模式中实例由内部类创建，由于 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 类的唯一性。
静态内部类单例模式是一种优秀的单例模式，是开源项目中比较常用的一种单例模式。在没有加任何锁的情况下，保证了多线程下的安全，并且没有任何性能影响和空间的浪费

枚举方式

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

/**
 * 枚举方式
 */
//枚举类创建
enum Singleton {
    INSTANCE;
    String args;
    public  String motheds(){
        return args;
    }
}

//枚举类实例化
public static void main(String[] args) {
        Singleton singleton=Singleton.INSTANCE;
        singleton.motheds();
}

存在的问题

破坏单例模式：

使上面定义的单例类（Singleton）可以创建多个对象，枚举方式除外。有两种方式，分别是序列化和反射。
创建一个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;
    }
}

使用序列化来破坏单例

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\\Think\\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\\Think\\Desktop\\a.txt"));
        //将instance对象写出到文件中
        oos.writeObject(instance);
    }
}

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

使用反射来破坏单例

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

解决方案

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

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

查看ObjectInputStream类执行流程，如果readResolve可执行就会返回方法的返回值

public final Object readObject() throws IOException, ClassNotFoundException{
    ...
    // if nested read, passHandle contains handle of enclosing object
    int outerHandle = passHandle;
    try {
        Object obj = readObject0(false);//重点查看readObject0方法
    .....
}
    
private Object readObject0(boolean unshared) throws IOException {
	...
    try {
		switch (tc) {
			...
			case TC_OBJECT:
				return checkResolve(readOrdinaryObject(unshared));//重点查看readOrdinaryObject方法
			...
        }
    } finally {
        depth--;
        bin.setBlockDataMode(oldMode);
    }    
}
    
private Object readOrdinaryObject(boolean unshared) throws IOException {
	...
	//isInstantiable 返回true，执行 desc.newInstance()，通过反射创建新的单例类，
    obj = desc.isInstantiable() ? desc.newInstance() : null; 
    ...
    // 在Singleton类中添加 readResolve 方法后 desc.hasReadResolveMethod() 方法执行结果为true
    if (obj != null && handles.lookupException(passHandle) == null && desc.hasReadResolveMethod()) {
    	// 通过反射调用 Singleton 类中的 readResolve 方法，将返回值赋值给rep变量
    	// 这样多次调用ObjectInputStream类中的readObject方法，继而就会调用我们定义的readResolve方法，所以返回的是同一个对象。
    	Object rep = desc.invokeReadResolve(obj);
     	...
    }
    return obj;
}

反射方式破解单例的解决方法

在参构造的时候就进行判断，如果已经实例化过了就抛出异常使其实例化失败

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

设计模式持续更新

下一篇 2.工厂模式

如果感觉文章还不错 求点赞评论

Alie鱼
关注
专栏目录
枚举实现单例模式
没有伞的孩子只能快跑，如若不跑，只有一个结果：超过你的人回头鄙视你
09-19 458
1.引言 单元素的枚举类型已经成为实现Singleton的最佳方法                       -- 出自 《effective java》 2.单例模式的特点 单例模式三个主要特点： 1、构造方法私有化； 2、实例化的变量引用私有化； 3、获取实例的方法共有； 最近公司在做一个功能，需要做一个缓存，可是项目有点旧，又用不了redis，于是就想到了枚举单例来实现缓存的办法。下面是成功的枚举单例的例子。虽然Singleton只能存在一个，但是单例的map值key,value却可
嵌入式C设计模式---单例设计模式
weixin_42162924的博客
05-04 845
保证一个类仅有一个实例，并提供一个该实例的全局访问点。
Java设计模式-单例模式
Java硬件工程师的博客
02-08 2221
创建者模式概述 创建型模式的主要关注点是“怎样创建对象？”，它的主要特点是“将对象的创建与使用分离”。 这样可以降低系统的耦合度，使用者不需要关注对象的创建细节。 创建型模式分为： 单例模式 工厂方法模式 抽象工程模式 原型模式 建造者模式 1.单例模式概述 单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种
设计模式-单例模式应用场景
暴风君的博客
10-08 1932
好多没怎么使用过的人可能会想，单例模式感觉不怎么用到，实际的应用场景有哪些呢？以下，我将列出一些就在咱们周边和很有意义的单例应用场景。 1. Windows的Task Manager（任务管理器）就是很典型的单例模式（这个很熟悉吧），想想看，是不是呢，你能打开两个windows task manager吗？ 不信你自己试试看哦~ 2. windows的Recycle Bin（回收站）也是典
java 饿汉式单例_java 单例模式（懒汉式与饿汉式）
weixin_39663933的博客
02-12 157
java 单例模式单例模式是一种常用的软件设计模式。在它的可信结构中只包含一个被实例化单例的特殊类。通过单例设计模式可以把整系统中的一个类只有一个实例。单例设计模式又分为两种方式，懒汉式和饿汉式。(1)懒汉式，就是只有当调用getInstance的时候，才会初始化这个单例。(2)饿汉式，就是一旦加载好类，就把单例初始化完成。即是调用getInstance的时候，单例是已经存在了。代码如下：懒汉式单...
单例模式(枚举式)
qq_35289343的博客
11-15 1066
枚举式实现单例模式： 测试枚举式实现单例模式(线程安全、调用效率高、没有延时加载。并且具有天然的防止反射和反序列化漏洞) public enum enumSingleton {     //这个元素，本身就是单例对象     E;     //添加自己需要的操作     public void singletonOperation() {              } } public cla...
java设计模式-单例.pdf
最新发布
05-16
### Java设计模式——单例模式详解 #### 一、单例模式概述 单例模式是设计模式中的一个重要组成部分，属于创建型模式之一。其主要作用是确保某个类仅有一个实例存在，并提供一个全局访问该实例的方法。这在很多场景...
JavaScript设计模式---单例模式详解【四种基本形式】
10-15
以上四种单例模式在JavaScript中都有其适用的场景，开发者可以根据实际需求选择合适的设计模式。单例模式在JavaScript中的应用广泛，比如管理DOM元素、提供全局配置、控制页面的公共资源等。理解并熟练运用单例模式...
JavaScript设计模式之单例模式详解
12-11
这一次重温一下《JavaScript设计模式与开发实践》，开篇为单例模式。 /** * pre 单例模式 * 定义：保证一个类仅有一个实例，并提供一个访问它的全局访问点 * 应用：单例模式是一种常用的模式，有一些对象我们...
C++设计模式-单例模式
06-13
李建忠老师的设计模式-单例模式讲解，示例以C++编程语言呈现。
单例模式（饿汉模式、懒汉模式、DCL单例模式、枚举）
10-01
饿汉模式、懒汉模式、DCL单例模式、枚举；不同情况下使用不同的单例创建模式
单例模式之枚举
HeroNet2010的博客
09-20 627
单例模式之枚举,安全的单例模式
枚举单例模式
海边无限的专栏
10-28 2205
一、什么是单例模式
单例模式 枚举
u010207898的博客
07-16 173
/** * mail 190042477@qq.com * description: 枚举单例模式 */ public enum EnumSingleton { //定义一个枚举的元素，他就是Singleton的一个实例 INSTANCE; } 优点：写法简单/线程安全 ...
单例模式——枚举式
TK_XIEBIN的博客
09-10 221
没有延迟加载，线程安全，效率高 package com.golf; /** * 单例模式——枚举式 * @author 26920 * */ public enum SingletonDemo04 { //枚举式是天然的单例模式 Instatce; }  ...
单例设计模式
m0_51816870的博客
12-18 124
单例模式，是一种常用的软件设计模式。通过单例模式可以保证系统中，应用该模式的类一个类只有一个实例。即一个类只有一个对象实例。 具体的思路是： （1）别人不能new实例，所以要将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。 （2）在该类内部产生一个唯一的实例化对象，并且将其封装为private static类型。 （3）定义一个静态方法返回这个唯一对象。 1.饿汉式 立即加载，就是使用类的时候已经将对象创建完毕（不管以后会不会使用到该实例化对象，先创建了再说。很着急的样子，故
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Alie鱼

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

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

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

打赏作者

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

抵扣说明：

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

余额充值