单例设计模式详解

最新推荐文章于 2022-06-29 10:43:23 发布

菜鸟a小李

最新推荐文章于 2022-06-29 10:43:23 发布

阅读量200

点赞数 1

分类专栏：设计模式 Java 文章标签： java 单例模式开发语言

本文链接：https://blog.csdn.net/qq_46012880/article/details/124544362

版权

Java 同时被 2 个专栏收录

19 篇文章 1 订阅

订阅专栏

设计模式

3 篇文章 0 订阅

订阅专栏

1.核心作用：

保证一个类只有一个实例（对象），并且提供一个访问该实例的全局访问点。

2.常见的应用场景：

1)、windows的任务管理器、回收站

2)、项目中读取配置文件的类；

3)、网站的计数器，一般也是采用单例模式、否则难以同步

4)、应用进程的日志应用，一般都采用单例模式实现，这是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。

5)、数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。

6)、操作系统的文件系统，也是采用大的单例模式实现的具体例子，一个操作系统只能有一个文件系统；

7)、Application也是单例的典型应用（servlet），每个Servlet也是一个单例

8)、在Spring中，每个Bean默认就是单例的，方便Spring-IOC容器的管理

9)、在SpringMVC框架中，控制器对象也是单例。

3.单例模式的优点：

-由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式。

-单例模式可以在系统设置全局的访问点，优化环共享资源访问。例如：我们可以只设计一个单例类，负责所有数据表的映射处理。

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

主要：

1.饿汉式(线程安全，调用效率高。但不能延时加载)

2.懒汉式(线程安全，调用效率不高，但是可以延时加载)

其他：

1.双重检测锁式（由于JVM底层内部模型原因，偶尔会出问题，不建议使用）

2.静态内部类式（线程安全，调用效率高，但是可以延时加载）

3.枚举单例(线程安全，调用效率高，不能延时加载）

5.new()和getInstance()方法的区别

(1) 对象使用之前通过getinstance得到而不需要自己定义，用完之后不需要delete；

(2)new 一定要生成一个新对象，分配内存；getInstance() 则不一定要再次创建，它可以把一个已存在的引用给你使用，这在效能上优于new；

(3) new创建后只能当次使用，而getInstance()可以跨栈区域使用，或者远程跨区域使用。所以getInstance()通常是创建static静态实例方法的。

6.常见的5中单例模式的实现

1.饿汉式

/**

 * 懒汉式单例测试（延时加载，用的时候再加载）

 *

 * 缺点：每次调用getInstance()方法时都要同步，并发效率低

 */

public class SingletonDemo2 {

 

    //类初始化的时候，先不初始化这个对象，等到真正用的时候再创建

    private static SingletonDemo2 s;

 

    //私有化构造器

    private SingletonDemo2() {

    }

 

    //方法同步，调用效率低，但是资源利用率提高

    public static synchronized SingletonDemo2 getInstance() {

        if (s == null) {

            s = new SingletonDemo2();

        }

        return s;

    }

}

2.懒汉式

/**

 * 懒汉式单例测试（延时加载，用的时候再加载）

 *

 * 缺点：每次调用getInstance()方法时都要同步，并发效率低

 */

public class SingletonDemo2 {



    //类初始化的时候，先不初始化这个对象，等到真正用的时候再创建

    private static SingletonDemo2 s;



    //私有化构造器

    private SingletonDemo2() {

    }



    //方法同步，调用效率低，但是资源利用率提高

    public static synchronized SingletonDemo2 getInstance() {

        if (s == null) {

            s = new SingletonDemo2();

        }

        return s;

    }

}

3.双重检查锁式

/**

 * 双重检查锁实现单例模式

 *

 * 这个模式将同步内容下发到if内部，提高了执行的效率，

 * 不必每次获取对象时都进行同步，只有第一次才同步。

  *  

由于编译器优化和jvm底层内部模型等原因，偶尔会出问题，不建议使用

 *

 */

public class SingletonDemo3 {

   

    private SingletonDemo3(){}

   

    private static SingletonDemo3 s = null;



    public static SingletonDemo3 getInstance() {

        if (s == null){

            SingletonDemo3 sc;

            synchronized (SingletonDemo3.class) {

                sc = s;

                if (sc==null){

                    synchronized (SingletonDemo3.class){

                        if (sc==null){

                            sc = new SingletonDemo3();

                        }

                    }

                    s = sc;

                }

            }

        }

        return s;

    }

}

4.静态内部类实现模式

/**

 * 静态内部类实现模式 （线程安全，调用效率高）

 *    

 * 要点：1.外部类没有static属性，不会像饿汉式那样立即加载对象

 *      2.只有真正调用getInstance()方法时，才会加载静态内部类。

 *      加载类时是线程安全的。s是 static final类型，保证了内存中只有这样一个实例存在，

 *      而且只能被赋值一次，从而保证了线程安全性。

 *      3.兼备了并发高效率和延迟加载的优势！

 */

public class SingletonDemo4 {

   

    private static class SingletonClassInstance{

        private static final SingletonDemo4 s = new SingletonDemo4();

    }

    public static SingletonDemo4 getInstance(){

        return SingletonClassInstance.s;

    }

    private SingletonDemo4(){}

}

5.使用枚举实现单例模式

/**

 * 使用枚举实现单例模式

 *  1.避免了反射和反序列化的漏洞

 *  2.天然的线程安全,调用效率高

 *  3.没有延时加载

 */

public enum  SinglentonDemo5 {



    //定义一个枚举类元素，它就代表了Singleton的一个实例

    INSTANCE;

   

    //添加自己需要的操作

    public void SingletonOperation(){

       

    }

}