单例模式的几种实现方式

最新推荐文章于 2025-02-19 09:09:01 发布
原创 最新推荐文章于 2025-02-19 09:09:01 发布 · 934 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

1.饿汉

  • 如果应用程序总是创建并使用单例实例或在创建和运行时开销不大
class Single {
    private Single(){}

    private static Single single= new Single();

    public static Single getInstance(){
        return single;
    }
}

2.懒汉

  • 如果开销比较大，希望用到时才创建就要考虑延迟实例化
  • Singleton的初始化需要某些外部资源(比如网络或存储设备)
class Single {
    private Single(){}

    private static Single single= null;

    public static Single getInstance(){
        if ( single == null ) {
            synchronized (Single.class) {
                if ( single == null ) {
                    single = new Single();
                }
            }

        }
        return single;
    }
}

3.静态内部类

class Single {
    private Single(){}

    private static class SingleHandler{
        private static Single single = new Single();
    }

    public static Single getInstance(){
        return Single.SingleHandler.single;
    }
}

4.枚举

public class Single {

    private Single(){}

    public enum SingleEnum {
        singleHandler;
        private Single single;
        private SingleEnum () {
            single = new Single();
        }

        public Single getSingle() {
            return single;
        }
    }

    public static Single getInstacne() {
        return SingleEnum.singleHandler.getSingle();
    }
}

5.单例出现的问题，序列化与反序列化

  • 如果对实现了Serializable的对象进行序列化后，再反序列化，类中会不只一个实例了，因为反序列化时会重新生成一个对象。
  • 将对象写入流时需要指定要使用的替代对象的可序列化类，应使用准确的签名来实现此特殊方法：Object writeReplace() throws ObjectStreamException;
  • 在从流中读取类的一个实例时需要指定替代的类应使用的准确签名来实现此特殊方法：Object readResolve() throws ObjectStreamException;
  • 上述两个方法的只要出现，就会履盖以下两个方法（这两个方法本质的意义就是用来替换序列与反序列的对象），虽然会执行它们，但最后得到的结果却是writeReplace、readResolve两个方法写入或读出的对象
  • 所以只需要在单例类中加上readResolve方法就能避免此问题
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Run {
    public static void main(String[] args) throws Exception {
        Single instance = Single.getInstance();
        System.out.println(instance.hashCode());
        System.out.println(copyInstance(instance).hashCode());
    }

    private static Single copyInstance(Single instance) throws Exception{
        FileOutputStream fos = new FileOutputStream("d:/a.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(instance);
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:/a.txt"));
        Single single2 = (Single)ois.readObject();
        oos.close();
        ois.close();
        return single2;
    }
}


class Single implements Serializable{
    private static final long serialVersionUID = 1L;

    private Single(){}

    private static Single single= null;

    public static Single getInstance(){
        if ( single == null ) {
            synchronized (Single.class) {
                if ( single == null ) {
                    single = new Single();
                }
            }

        }
        return single;
    }

    private Object readResolve() {
        return single;
    }

}

6.单例出现的问题，反射

  • 通过反射获取构造函数，然后调用setAccessible(true)就可以调用私有的构造函数
  • 如果要抵御这种攻击，可以修改构造器，让它在被要求创建第二个实例的时候抛出异常
public class Run {
    public static void main(String[] args) throws Exception {
        //使用反射方式直接调用私有构造器
        Class<Single> clazz = (Class<Single>)Class.forName("com.lebron.test.single.Single");
        Constructor<Single> con = clazz.getDeclaredConstructor(null);
        con.setAccessible(true);//绕过权限管理，即在true的情况下，可以通过构造函数新建对象
        Single instance = con.newInstance();
        Single instance2 = con.newInstance();
        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());

    }
}

class Single{
    private static boolean flag = false;  
    private Single(){
        synchronized (Single.class) {
            if (!flag) {
                flag = true;
            } else {
                throw new RuntimeException("单例模式被侵犯！");
            }

        }
    }

    private static Single single;

    public static Single getInstance(){
        if ( single == null ) {
            synchronized (Single.class) {
                if ( single == null ) {
                    single = new Single();
                }
            }

        }
        return single;
    }

}

7.总结可以避免序列化反序列化和反射的单例代码

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.lang.reflect.Constructor;

public class Run {
    public static void main(String[] args) throws Exception {
        Single instance = Single.getInstance();
        System.out.println(instance.hashCode());
        System.out.println(copyInstance(instance).hashCode());

        //使用反射方式直接调用私有构造器
        Class<Single> clazz = (Class<Single>)Class.forName("com.lebron.test.single.Single");
        Constructor<Single> con = clazz.getDeclaredConstructor(null);
        con.setAccessible(true);//绕过权限管理，即在true的情况下，可以通过构造函数新建对象
        Single instance1 = con.newInstance();
        Single instance2 = con.newInstance();
        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());

    }

    private static Single copyInstance(Single instance) throws Exception{
        FileOutputStream fos = new FileOutputStream("d:/a.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(instance);
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:/a.txt"));
        Single single2 = (Single)ois.readObject();
        oos.close();
        ois.close();
        return single2;
    }
}

class Single implements Serializable{
    private static final long serialVersionUID = 1L;
    private static boolean flag = false;  
    private Single(){
        synchronized (Single.class) {
            if (!flag) {
                flag = true;
            } else {
                throw new RuntimeException("单例模式被侵犯！");
            }

        }
    }

    private static Single single;

    public static Single getInstance(){
        if ( single == null ) {
            synchronized (Single.class) {
                if ( single == null ) {
                    single = new Single();
                }
            }

        }
        return single;
    }

    private Object readResolve() {
        return single;
    }
}

喜欢这篇文章的朋友，欢迎长按下图关注公众号lebronchen，第一时间收到更新内容。
扫码关注

Python 单例模式几种实现方式
The @MMiL algoDves & programming space
07-20 138
本文介绍了Python单例模式的5种实现方式：1）模块导入法（推荐的最简方式）；2）重写__new__方法；3）元类控制；4）线程安全单例；5）单例装饰器。重点分析了各方法的线程安全性、初始化控制等特性，并给出对比表格。文章指出模块导入法是简单场景的首选方案，多线程环境需结合锁机制，同时提醒注意单例的可变状态同步问题。最后给出了一个综合线程安全和避免重复初始化的完善方案，适用于需要严格控制的场景。
单例模式7种实现
最新发布
shinecjj的博客
06-30 367
枚举方式是处理单例模式的推荐方法，因为它提供了更强的保证。枚举类型的构造器默认是私有的，所以无法通过其他类进行实例化，同时又保证了序列化时的单例特性。因此，它是实现单例的最佳方式。优点：这种方式也是懒加载的，同时保证了线程安全，且写法优雅。当getInstance()方法被调用时，才加载SingletonHolder类，从而创建Singleton的实例。优点：这种方式比较简单，在类加载时就完成了初始化，避免了线程同步问题。但它是饿汉式的，即在类加载时就创建了实例，即使没有用到这个实例。
单例模式
07-23 618
UML step1: 创建一个 Singleton 类。 SingleObject.java public class SingleObject { //创建 SingleObject 的一个对象 private static SingleObject instance = new SingleObject(); //让构造函数为 private，这样该类就不
深入理解单例模式的几种实现方式
weixin_30340617的博客
12-27 216
前言 单例模式是一种很常用的设计模式，其定义是单例对象的类只允许有一个实例存在。在使用spring自动创建对象时默认就是单例的。 使用场景 需要频繁的对对象进行创建与销毁，如果工具类对象 一、饿汉式（静态变量） public class Singleton1 { private static final Singleton1 INSTANCE = new Singlet...
JAVA：单例模式五种实现方式详细介绍
永远保持随时离开的技术能力！
02-19 896
单例模式五种实现方式
C++ 单例模式的几种实现方式研究
08-26
"C++ 单例模式的几种实现方式研究" 单例模式是设计模式中最常应用的一种模式，也是面试官最喜欢的题目。但是，如果没有学过设计模式的人，可能不会想到要去应用单例模式，面对单例模式适用的情况。 单例模式的主要...
单例模式几种实现方式和代码
last_kunshen的博客
08-17 1579
一、饿汉式 不管需不需要这个对象，在类初始化时，这个对象都会被创建出来 不存在线程安全问题 1.直接实例化： /** * 1.饿汉式直接实例化 * @author kun */ public class Singleton1 { public static final Singleton1 INSTANCE = new Singleton1(); private Singleton1(){ } } 2.枚举:表示该类型的对象是有限的几个，限定为一个就成了单例 /**
单例模式的几种实现
程序员七哥
06-15 2798
单例模式的几种实现
Java单例模式四种实现方式详解
描述中提到了四种单例模式的实现方式，分别是最简单的静态常量方式、线程安全的同步方法方式、双重检查锁定方式以及静态内部类方式。 在开始详细解释之前，需要明确单例模式的几个关键点： 1. 私有构造函数：防止...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值