单例模式你会几种写法?(转)

前言

只有光头才能变强

回顾前面:

本来打算没那么快更新的,这阵子在刷Spring的书籍。在看Spring的时候又经常会看到“单例”,“工厂”这些字样。

所以,就先来说说单例和工厂设计模式啦,这两种模式也是很常见的,我看很多面经都会遇到这两种模式~

本文主要讲解单例设计模式,如果有错的地方希望能多多包涵,并不吝在评论区指正!

一、单例模式概述

单例模式定义很简单:一个类中能创建一个实例,所以称之为单例!

那我们什么时候会用到单例模式呢??

  • 那我们想想既然一个类中只能创建一个实例了,那么可以说这是跟类的状态与对象无关的了。
  • 频繁创建对象、管理对象是一件耗费资源的事,我们只需要创建一个对象来用就足够了!

学过Java Web的同学可能就知道:

  • Servlet是单例的
  • Struts2是多例的
  • SpringMVC是单例的

那既然多例是频繁创建对象、需要管理对象的,那Struts2为什么要多例呢??

  • 主要由于设计层面上的问题,Struts2是基于Filter拦截类的,ognl引擎对变量是注入的。所以它要设计成多例的~

能使用一个对象来做就不用实例化多个对象!这就能减少我们空间和内存的开销~

那有可能有的人又会想了:我们使用静态类.doSomething()和使用单例对象调用方法的效果是一样的啊。

  • 没错,效果就是一样的。使用静态类.doSomething()体现的是基于对象,而使用单例设计模式体现的是面向对象

二、编写单例模式的代码

编写单例模式的代码其实很简单,就分了三步:

  • 将构造函数私有化
  • 在类的内部创建实例
  • 提供获取唯一实例的方法

2.1饿汉式

根据上面的步骤,我们就可以轻松完成创建单例对象了。


public class Java3y {

    // 1.将构造函数私有化,不可以通过new的方式来创建对象
    private Java3y(){}

    // 2.在类的内部创建自行实例
    private static final Java3y java3y = new Java3y();

    // 3.提供获取唯一实例的方法
    public static Java3y getJava3y() {
        return java3y;
    }
}

这种代码我们称之为:“饿汉式”:

  • 一上来就创建对象了,如果该实例从始至终都没被使用过,则会造成内存浪费

2.2简单懒汉式

既然说一上来就创建对象,如果没有用过会造成内存浪费:

  • 那么我们就设计用到的时候再创建对象

public class Java3y {

    // 1.将构造函数私有化,不可以通过new的方式来创建对象
    private Java3y(){}

    // 2.1先不创建对象,等用到的时候再创建
    private static Java3y java3y = null;

    // 2.1调用到这个方法了,证明是要被用到的了
    public static Java3y getJava3y() {

        // 3. 如果这个对象引用为null,我们就创建并返回出去
        if (java3y == null) {
            java3y = new Java3y();
        }

        return java3y;
    }
}

上面的代码行不行??在单线程环境下是行的,在多线程环境下就不行了

要解决也很简单,我们只要加锁就行了:

2.3双重检测机制(DCL)懒汉式

上面那种直接在方法上加锁的方式其实不够好,因为在方法上加了内置锁在多线程环境下性能会比较低下,所以我们可以将锁的范围缩小


public class Java3y {

    private Java3y() {
    }

    private static Java3y java3y = null;

    public static Java3y getJava3y() {
        if (java3y == null) {
            // 将锁的范围缩小,提高性能
            synchronized (Java3y.class) {
                java3y = new Java3y();
            }
        }
        return java3y;
    }
}

那上面的代码可行吗??不行,因为虽然加了锁,但还是有可能创建出两个对象出来的:

  • 线程A和线程B同时调用getJava3y()方法,他们同时判断java==null,得出的结果都是为null,所以进入了if代码块了
  • 此时线程A得到CPU的控制权-->进入同步代码块-->创建对象-->返回对象
  • 线程A完成了以后,此时线程B得到了CPU的控制权。同样是-->进入同步代码块-->创建对象-->返回对象
  • 很明显的是:Java3y类返回了不止一个实例!所以上面的代码是不行的!

有的同学可能觉得我瞎吹比,明明加锁了还不行?我们来测试一下:


public class TestDemo {

    public static void main(String[] args) {

        // 线程A
        new Thread(() -> {

            // 创建单例对象
            Java3y java3y = Java3y.getJava3y();
            System.out.println(java3y);

        }).start();

        // 线程B
        new Thread(() -> {
            // 创建单例对象
            Java3y java3y = Java3y.getJava3y();
            System.out.println(java3y);
        }).start();

        // 线程C
        new Thread(() -> {
            // 创建单例对象
            Java3y java3y = Java3y.getJava3y();
            System.out.println(java3y);
        }).start();

    }
}

可以看到,打印出的对象不单单只有一个的!

厉害的程序员又想到了:进入同步代码块时再判断一下对象是否存在就稳了吧

  • 所以,有了下面的代码

public class Java3y {

    private Java3y() {
    }

    private static Java3y java3y = null;

    public static Java3y getJava3y() {
        if (java3y == null) {

            // 将锁的范围缩小,提高性能
            synchronized (Java3y.class) {

                // 再判断一次是否为null
                if (java3y == null) {
                    java3y = new Java3y();
                }
            }
        }
        return java3y;
    }
}

其实还不稳!这里会有重排序的问题

本来想测试重排序问题的效果的,一直没测试出来~~~有相关测试代码的希望可以告诉我怎么能测出来....

要解决也十分简单,加上我们的volatile关键字就可以了,volatile有内存屏障的功能

具体可参考资料:

所以说,完整的DCL代码是这样子的:



public class Java3y {
    private Java3y() {
    }

    private static volatile Java3y java3y = null;

    public static Java3y getJava3y() {
        if (java3y == null) {

            // 将锁的范围缩小,提高性能
            synchronized (Java3y.class) {

                // 再判断一次是否为null
                if (java3y == null) {
                    java3y = new Java3y();
                }
            }
        }
        return java3y;
    }
}

再说明:

2.4静态内部类懒汉式

还可以使用静态内部类这种巧妙的方式来实现单例模式!它的原理是这样的:

  • 当任何一个线程第一次调用getInstance()时,都会使SingletonHolder被加载和被初始化,此时静态初始化器将执行Singleton的初始化操作。(被调用时才进行初始化!)
  • 初始化静态数据时,Java提供了的线程安全性保证。(所以不需要任何的同步)

public class Java3y {

    private Java3y() {
    }

    // 使用内部类的方式来实现懒加载
    private static class LazyHolder {
        // 创建单例对象
        private static final Java3y INSTANCE = new Java3y();
    }

    // 获取对象
    public static final Java3y getInstance() {
        return LazyHolder.INSTANCE;
    }

}

静态内部类这种方式是非常推荐使用的!很多人没接触过单例模式的都不知道有这种写法,这种写法很优化也高效!

参考资料:

2.5枚举方式实现

使用枚举就非常简单了:


public enum Java3y3y {

    JAVA_3_Y_3_Y,
}

那这种有啥好处??枚举的方式实现:

  • 简单,直接写就行了
  • 防止多次实例化,即使是在面对复杂的序列化或者反射攻击的时候(安全)!

这种也较为推荐使用!

三、总结

总的来说单例模式写法有5种:

  • 饿汉式
  • 简单懒汉式(在方法加锁)
  • DCL双重检测加锁(进阶懒汉式)
  • 静态内部类实现懒汉式(最推荐写法)
  • 枚举方式(最安全、简洁写法)

明天估计写的是工厂模式了,敬请期待哦~~~

参考资料:

作者:Java3y
链接:https://juejin.im/post/5afbedd5f265da0b886d999d
来源:掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

原文地址:https://www.cnblogs.com/jiangwz/p/9213170.html

时间: 2024-11-10 15:48:14

单例模式你会几种写法?(转)的相关文章

OOAD之单例模式Singleton的6种写法

1  主要作用是保证在Java应用程序中,一个类Class只有一个实例存在. 一 :第一种 饿汉式(预加载) 1 public class Singleton { 2 private Singleton(){}////在自己内部定义自己一个实例,注意这是private 3 private static Singleton instance = new Singleton(); 4 5 public static Singleton getInstance() { 6 return instanc

Android设计模式之单例模式的七种写法

一 单例模式介绍及它的使用场景 单例模式是应用最广的模式,也是我最先知道的一种设计模式.在深入了解单例模式之前.每当遇到如:getInstance()这样的创建实例的代码时,我都会把它当做一种单例模式的实现. 事实上常常使用的图片载入框架ImageLoader的实例创建就是使用了单例模式.由于这个ImageLoader中含有线程池.缓存系统.网络请求,非常消耗资源,不应该创建多个对象,这时候就须要用到单例模式. ImageLoader的创建代码例如以下: ImageLoader.getInsta

Java:单例模式的七种写法

转载出处:http://cantellow.javaeye.com/blog/838473 第一种(懒汉,线程不安全): 1 public class Singleton {   2     private static Singleton instance;   3     private Singleton (){}    4     public static Singleton getInstance() {   5     if (instance == null) {   6    

1.18 单例模式的七种写法(转的 虽然看不懂但是感觉可能有用)

转载请注明出处:http://cantellow.iteye.com/blog/838473 单例模式有以下特点: 1.单例类只能有一个实例. 2.单例类必须自己创建自己的唯一实例. 3.单例类必须给所有其他对象提供这一实例. 第一种(懒汉,线程不安全): public class Singleton { private static Singleton instance; private Singleton (){} public static Singleton getInstance()

【设计模式】C++单例模式的几种写法

单例模式是最简单的设计模式,就让我像玩简单的游戏一样写下去吧. v1: 简单模式 和这个版本有过一面之缘,但不敢苟同. class Singleton { private: Singleton() {} public: static Singleton * getIns() { static Singleton * ins = new Singleton(); return ins; } }; 问题:何时析构不明确:最重要的是调用多次getIns函数会产生多个static Singleton指针

单例模式几种写法

第一种(懒汉,线程不安全): Java代码 public class Singleton { private static Singleton instance; private Singleton (){} public static Singleton getInstance() { if (instance == null) { instance = new Singleton(); } return instance; } } 这种写法lazy loading很明显,但是致命的是在多线程

Java:单例模式的七种写法 (转)

第一种(懒汉,线程不安全): 1 public class Singleton {   2     private static Singleton instance;   3     private Singleton (){}    4     public static Singleton getInstance() {   5     if (instance == null) {   6         instance = new Singleton();   7     }   8

单例模式的八种写法比较

单例模式是最常用到的设计模式之一,熟悉设计模式的朋友对单例模式都不会陌生.一般介绍单例模式的书籍都会提到 饿汉式 和 懒汉式 这两种实现方式.但是除了这两种方式,本文还会介绍其他几种实现单例的方式,让我们来一起看看吧. 简介 单例模式是一种常用的软件设计模式,其定义是单例对象的类只能允许一个实例存在. 许多时候整个系统只需要拥有一个的全局对象,这样有利于我们协调系统整体的行为.比如在某个服务器程序中,该服务器的配置信息存放在一个文件中,这些配置数据由一个单例对象统一读取,然后服务进程中的其他对象

C# 单例模式的五种写法

C# 单例模式的五种写法及优劣分析,见下文: [单例模式及常见写法](http://blog.csdn.net/jiankunking/article/details/50867050)