GOF23之一【单例模式】详细全解

最新推荐文章于 2024-10-01 18:51:18 发布

江西昊仔

最新推荐文章于 2024-10-01 18:51:18 发布

阅读量132

点赞数 1

分类专栏： GOF23 文章标签： java

本文链接：https://blog.csdn.net/lyh1023812/article/details/117264626

版权

GOF23 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

单例模式

核心作用：保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。

优点：

由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决
单例模式可以在系统设置全局的访问点，优化环共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理

常见的应用场景

– Windows的Task Manager（任务管理器）就是很典型的单例模式
– windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。
– 项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，每次new一个对象去读取。
– 网站的计数器，一般也是采用单例模式实现，否则难以同步。
– 应用程序的日志应用，一般都何用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。
– 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。
– 操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统。
– Application 也是单例的典型应用（Servlet编程中会涉及到）
– 在Spring中，每个Bean默认就是单例的，这样做的优点是Spring容器可以管理
– 在servlet编程中，每个Servlet也是单例
– 在spring MVC框架/struts1框架中，控制器对象也是单例

常见的五种单例模式实现方式

主要：

饿汉式（线程安全，调用效率高。但，不可以延时加载。）
懒汉式（线程安全，调用效率不高。但，可以延时加载。）+

其他：

双重检测锁式（由于JVM底层内部模型原因，偶尔会出问题。不建议使用）
静态内部类式 (线程安全，调用效率高。但是，可以延时加载)
枚举单例 (线程安全，调用效率高，不能延时加载，天然的防止反射和反序列化漏洞！)

【饿汉式】【立即加载】是不管你用不用，先帮你创建一个对象

class Simple {
    // 饿汉模式--单例
    // 三点：1.私有构造方法；2.私有内置静态本类实例；3.公开静态方法返回实例
    private Simple(){
    }
    private static Simple s = new Simple();
    public static synchronized Simple getSimple(){
        return s;
    }

}

class Test {
    public static void main(String[] args) {
        Simple s1 = Simple.getSimple();
        Simple s2 = Simple.getSimple();
        System.out.println( s1 == s2 );  // 结果为true，同一个对象。
    }
}

饿汉式单例模式代码中，static变量会在类装载时初始化，此时也不会涉及多个线程对象访问该对象的问题。
虚拟机保证只会装载一次该类，肯定不会发生并发访问的问题。因此，可以省略synchronized关键字
饿汉式问题：如果只是加载本类，而不是要调用getSimple()，甚至永远没有调用，则会造成资源浪费！

【懒汉式】【延迟加载】等你需要时，再帮你创建一个对象

class Simple2{
    // 懒汉模式--单例
    // 1.私有构造方法；2.私有内置静态本类变量；3.公开静态方法；4.延迟加载实例
    private Simple2(){
    }
    private static Simple2 s;
    public static synchronized Simple2 getSimple2(){
        if( null == s ){
            s = new Simple2();
        }
        return s;
    }
}

1.延迟加载: 是指不会在第一时间就把对象创建好来占用内存,而是什么时候需要用到,什么时候才去创建
2.线程安全问题: 是指共享资源有线程并发的数据隐患,可以通过加锁synchronized的方式[同步代码块/同步方法]
3.懒汉式问题：– 资源利用率高了。但是，每次调用getSimple2()方法都要同步，并发效率较低。

【双重检测锁实现】【延迟加载】

class Simple3 {
    // 1.私有构造方法；2.私有内置静态本类变量；3.公开静态方法；4.延迟加载
    private Simple3(){
    }
    private static Simple3 s=null;

    public static synchronized Simple3 getSimple3(){
        if (s == null) {
            Simple3 sc;
            synchronized (Simple3.class) { //锁一
                sc = s;
                if (sc == null) {
                    synchronized (Simple3.class) {//锁二
                        if(sc == null) {
                            sc = new Simple3();
                        }
                    }
                    s = sc;
                }
            }
        }
        return s;
    }
}

这个模式将同步内容下放到if内部，提高了执行的效率不必每次获取对象时都进行同步，只有第一次才同步创建了以后就没必要了。
双重检测锁实现问题：由于编译器优化原因和JVM底层内部模型原因，偶尔会出问题。不建议使用

【静态内部类式】【延迟加载】

class Simple4{
    // 1.私有构造方法；2.私有内置静态本类变量；3.公开静态方法；
    private Simple2(){
    }
    // 2.私有静态内部类
    private static class Simple4Class {
        private static final Simple4Class s = new Simple4Class();
    }
    // 3.公开静态方法
    public static Simple4 getSimple4(){
        return Simple4Class.s;
    }
}

外部类没有static属性，则不会像饿汉式那样立即加载对象。
只有真正调用getSimple4(),才会加载静态内部类。加载类时是线程安全的。 s是static final类型，保证了内存中只有这样一个实例存在，而且只能被赋值一次，从而保证了线程安全性.
静态内部类式:兼备了并发高效调用和延迟加载的优势！

【枚举单例】【没有延时加载】

public enum Simple5 {
	//这个枚举元素，本身就是单例对象！
	INSTANCE;
	//添加自己需要的操作！
	public void getSimple5(){

	}
}
public class Test {
    public static void main(String[] args){
        System.out.println( Simple5.INSTANCE == Simple5.INSTANCE);
    }
}

优点：实现简单。枚举本身就是单例模式。由JVM从根本上提供保障！避免通过反射和反序列化的漏洞！
缺点：无延迟加载

防止破解

反射可以破解上面几种(不包含枚举式)实现方式！（防止破解：可以在构造方法中手动抛出异常控制）
反序列化可以破解上面几种(不包含枚举式)实现方式！（防止破解：可以通过定义readResolve()防止获得不同对象。反序列化时，如果对象所在类定义了readResolve()，实际是一种回调，定义返回哪个对象）

public class SingletonDemo01 implements Serializable {
    private static SingletonDemo01 s;

    //1.私有化构造器
    private SingletonDemo01() throws Exception{
        if(s!=null){
            //通过手动抛出异常，避免通过反射创建多个单例对象！
            throw new Exception("只能创建一个对象");
        }
    } 

    public static synchronized SingletonDemo01 getInstance() throws Exception{
        if(s==null){
            s = new SingletonDemo01();
        }
        return s;
    }

    //反序列化时，如果对象所在类定义了readResolve()，（实际是一种回调），定义返回哪个对象。
    private Object readResolve() throws ObjectStreamException {
        return s;
    }
}