设计模式（10）——对象性能模式（1）——单例模式（8种写法）

最新推荐文章于 2023-12-26 10:25:55 发布
最新推荐文章于 2023-12-26 10:25:55 发布
阅读量196 收藏
点赞数
分类专栏： Java设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34805255/article/details/96560270
版权
本文详细介绍了单例模式的8种实现方式，包括饿汉式、懒汉式、双重检查+volatile、静态内部类和枚举等，并分析了各自的线程安全、内存浪费和性能特点。最后，探讨了单例模式在实际开发中的应用和选择建议。
摘要由CSDN通过智能技术生成

目录

0.对象性能模式

1.基本介绍

2.八种写法解读

2.1 饿汉式（静态常量）

2.2 饿汉式（静态代码块）

2.3 懒汉式（线程不安全）

2.4 懒汉式（线程安全，同步方法）

2.5 懒汉式（线程不安全，同步代码块）

2.6.双重检查+volatile

2.7 静态内部类

2.8 枚举

3.单例模式在JDK源码中应用的分析

4.总结

0.对象性能模式

  • 面向对象很好地解决了“抽象”的问题，但是必不可免地要付出一定的代价，对于通常情况来讲，面向对象的成本大都可以忽略不计，但是某些情况，面向对象所带来的成本必须谨慎处理
  • 典型模式
    • 单例模式
    • 享元模式

1.基本介绍

  • 简单来说，就是采用一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法
  • 单例模式有8种写法：
    • 1.饿汉式（静态常量）
    • 2.饿汉式（静态代码块）
    • 3.懒汉式（线程不安全）
    • 4.懒汉式（线程安全，同步方法）
    • 5.懒汉式（线程安全，同步代码块）
    • 6.双重检查
    • 7.静态内部类
    • 8.枚举

2.八种写法解读

2.1 饿汉式（静态常量）

（1）创建步骤

  • 1.构造函数私有化
  • 2.类的内部创建对象
  • 3.向外暴露一个静态的公共方法：getInstance

（2）代码实现

public class Singleton01 {

    public static void main(String[] args){
        Singleton instance = Singleton.getInstance();
        Singleton instance01 = Singleton.getInstance();

        System.out.println(instance == instance01);
        System.out.println("Instance.hashCode="+instance.hashCode());
        System.out.println("Instance.hashCode1="+instance01.hashCode());
    }

}


class Singleton {

    //1.构造器私有化，以保证外部不能new对象
    private Singleton(){

    }

    //2.在本类内部创建对象实例(在类加载的时候就创建对象实例)
    private final static Singleton instance = new Singleton();

    //3.提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance(){
        return instance;
    }
}

分析此写法优缺点：

  • 优点：
    • 在类装载的时候就完成实例化，避免了线程同步问题
  • 缺点：
    • 在这种方式基于类加载机制避免了多线程的同步问题，不过，instance在类加载时就实例化，在单例模式中大多数都是会调用getinstance方法，但是导致类加载的原因有很多种，因此不能确定是否有其他的方式（或其他的静态方法）导致类加载，这时候初始化instance就没有达到懒加载的效果，造成内存的浪费
  • 结论：
    • 这种单例模式可用，可能造成内存浪费

2.2 饿汉式（静态代码块）

代码实现：

public class Singleton02 {

    public static void main(String[] args){
        Singleton instance = Singleton.getInstance();
        Singleton instance01 = Singleton.getInstance();

        System.out.println(instance == instance01);
        System.out.println("Instance.hashCode="+instance.hashCode());
        System.out.println("Instance.hashCode1="+instance01.hashCode());
    }

}


class Singleton {

    //1.构造器私有化，以保证外部不能new对象
    private Singleton(){

    }

    //2.在本类内部创建对象实例(在类加载的时候就创建对象实例)
    private  static Singleton instance;

    static {  //在静态代码块中，创建单例对象
        instance = new Singleton();
    }

    //3.提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance(){
        return instance;
    }
}

分析优缺点：

  • 这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类加载的时候，就执行静态代码块中的代码，初始化类的实例，优缺点和上面是一样的

结论：

  • 这种单例模式可用，但是可能造成内存浪费

2.3 懒汉式（线程不安全）

代码实现：

package cn.cqu.Singleton.type1;

public class Singleton03 {

    public static void main(String[] args){

        System.out.println("懒汉式1：线程不安全");
        Singleton instance = Singleton.getInstance();
        Singleton instance01 = Singleton.getInstance();

        System.out.println(instance == instance01);
        System.out.println("Instance.hashCode="+instance.hashCode());
        System.out.println("Instance.hashCode1="+instance01.hashCode());
    }

}


class Singleton {

    //1.构造器私有化，以保证外部不能new对象
    private Singleton(){

    }

    //2.在本类内部创建对象实例
    private  static Singleton instance;


    //3.提供一个公有的静态方法，返回实例对象
    //  当使用到该方法时，才实例化对象
    public static Singleton getInstance(){
        if(null == instance){
            instance = new Singleton();
        }
        return instance;
    }
}

分析优缺点：

优点：

  • 起到了懒加载的效果

缺点：

  • 线程不安全，只能在单线程下使用
  • 如果在多线程下，一个线程进入了判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例，所以在多线程环境下不可使用这种方式

结论：

  • 在实际开发中，不要使用这种方式

2.4 懒汉式（线程安全，同步方法）

代码实现：

public class Singleton04 {

    public static void main(String[] args){

        System.out.println("懒汉式2：线程安全,同步方法");
        Singleton instance = Singleton.getInstance();
        Singleton instance01 = Singleton.getInstance();

        System.out.println(instance == instance01);
        System.out.println("Instance.hashCode="+instance.hashCode());
        System.out.println("Instance.hashCode1="+instance01.hashCode());
    }

}


class Singleton {

    //1.构造器私有化，以保证外部不能new对象
    private Singleton(){

    }

    //2.在本类内部创建对象实例
    private  static Singleton instance;


    //3.提供一个公有的静态方法，返回实例对象，并且为该方法加入了同步处理的代码
    //  当使用到该方法时，才实例化对象
    public static synchronized Singleton getInstance(){
        if(null == instance){
            instance = new Singleton();
        }
        return instance;
    }
}

分析优缺点：

优点：

  • 解决了线程不安全问题

缺点：

  • 效率太低，每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步，而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行了，方法进行同步效率太低

结论：

  • 在实际开发中，不推荐使用这种方式

2.5 懒汉式（线程不安全，同步代码块）

代码实现：

class Singleton {

    //1.构造器私有化，以保证外部不能new对象
    private Singleton(){

    }

    //2.在本类内部创建对象实例
    private  static Singleton instance;


    //3.提供一个公有的静态方法，返回实例对象
    //  当使用到该方法时，才实例化对象
    public static  Singleton getInstance(){
        if(null == instance){
            synchronized(Singleton.class){
                instance = new Singleton();
            }
        }
        return instance;
    }
}

缺点：

  • 这种方式，本意是想对第四种方式实现方式的改进，因为前面同步方法效率太低改为同步产生实例化的代码块
  • 但是这种同步并不能起到线程同步的作用，跟第三种方式遇到的情形一致，假如一个线程进入了还未来得及往下执行，另一个线程也通过这个判断语句，这时便会产生多个实例

结论：

  • 在实际开发中，不能使用这种方式

2.6.双重检查+volatile

代码实现：

public class Singleton06 {

    public static void main(String[] args){

        System.out.println("懒汉式4：线程安全,双重检查");
        Singleton instance = Singleton.getInstance();
        Singleton instance01 = Singleton.getInstance();

        System.out.println(instance == instance01);
        System.out.println("Instance.hashCode="+instance.hashCode());
        System.out.println("Instance.hashCode1="+instance01.hashCode());
    }

}


class Singleton {

    //1.构造器私有化，以保证外部不能new对象
    private Singleton(){

    }

    //2.在本类内部创建对象实例
    private  static volatile Singleton instance;


    //3.提供一个公有的静态方法，加入双重检查的代码，返回实例对象
    //  当使用到该方法时，才实例化对象
    public static  Singleton getInstance(){
        if(null == instance){
            synchronized(Singleton.class){
                if(null == instance){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

分析：

  • 双检查机制是多线程开发中经常使用到的，如代码中所示，我们进行了两次的检查，这样可以保证线程安全了
    • 当第一次判断不通过（即instance已经被实例化过）的时候，线程直接跳到return语句，避免了反复进行方法同步，保证了效率
    • 当通过第一次判断进入同步代码块中的第二次判断时，这时候再次检查保证了，多个都通过第一次检查的线程不会重复创建多个实例，解决了线程安全的问题
  • 线程安全，懒加载，效率高

结论：

  • 在实际开发中推荐使用

注意：

  • 双检查必须将实例引用instance定义为volatile才是线程安全的，下面是仅有双检查锁，无volatile的分析：
class Singleton {

    //1.构造器私有化，以保证外部不能new对象
    private Singleton(){

    }

    //2.在本类内部创建对象实例
    private  static Singleton instance;


    //3.提供一个公有的静态方法，加入双重检查的代码，返回实例对象
    //  当使用到该方法时，才实例化对象
    public static  Singleton getInstance(){
        if(null == instance){
            synchronized(Singleton.class){
                if(null == instance){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

首先此种使用双检查锁，不使用volatile的写法有问题——内存读写指令重排序（reorder）不安全（关于指令重排序的解释，见我的另一篇博客：volatile详解）

原因解释：

  • 某一个线程执行到第一次检测时，读取到的instance不为null时，instance的引用对象可能没有完成初始化
  • instance = new Singleton();在底层执行时可以分为以下三个步骤（伪代码）:
memory = allocate();  //1.分配对象内存空间
instance(memory);     //2.为该内存空间初始化对象
instance = memory;    //3.将对象引用指向刚分配并初始化对象的内存

步骤2和步骤3不存在数据依赖关系，而且无论重排前还是重排后程序的执行结果在单线程中并没有改变，因此这种重排优化是允许的，所以可能出现以下优化顺序：

memory = allocate();  //1.分配对象内存空间
instance = memory;    //3.将对象引用指向刚分配并初始化对象的内存
instance(memory);     //2.为该内存空间初始化对象

但是指令重排只会保证串行语义的执行的一致性（单线程)，但并不会关系多线程间的语义一致性

  • 所以当一条线程正在new对象的时候，但它的底层按照上述1，3，2的顺序执行，
  • 当执行完步骤3时，这时CPU调度另一个线程来创建对象，
  • 此时访问instance不为null，直接返回该instance，
  • 但是实际该instance实例并未完成初始化，此时如果被返回直接使用，就会造成异常，即造成了线程安全问题

而volatile能禁止指令重排序，所以使用volatile可以保证线程安全，这种正确的写法是双检查锁+volatile

2.7 静态内部类

代码实现：

public class Singleton07 {

    public static void main(String[] args){

        System.out.println("懒汉式5：线程安全,静态内部类");
        Singleton instance = Singleton.getInstance();
        Singleton instance01 = Singleton.getInstance();

        System.out.println(instance == instance01);
        System.out.println("Instance.hashCode="+instance.hashCode());
        System.out.println("Instance.hashCode1="+instance01.hashCode());
    }

}

class Singleton {

    //1.构造器私有化，以保证外部不能new对象
    private Singleton(){

    }

    //2.创建一个静态内部类，并且它的属性为Singleton实例
    private static class SingletonInstance{
        private static final Singleton instance = new Singleton();
    }


    //3.提供一个公有的静态方法，返回实例对象
    //  当使用到该方法时，才加载SingletonInstance，进行实例化对象
    public static  Singleton getInstance(){
        return SingletonInstance.instance;
    }
}

分析：

静态内部类的特点说明：

  • 1.上述的外部类Singleton被加载的时候，静态内部类SingletonInstance不会被加载
  • 2.当我们使用getInstance方法时，使用到内部类SingletonInstance的属性instance时，该内部类才会被加载，并且在类加载时，线程是安全的（JVM底层的加载机制保证了线程安全，在类进行初始化的时候，别的线程是无法进入的）

通过静态内部类的特点，保证了线程安全，实现了懒加载，效率高

结论：

  • 在实际开发中，推荐使用

2.8 枚举

代码实现：

public class Singleton08 {

    public static void main(String[] args){

        System.out.println("枚举方式实现");
        Singleton instance = Singleton.INSTANCE;
        Singleton instance01 = Singleton.INSTANCE;

        System.out.println(instance == instance01);
        System.out.println("Instance.hashCode="+instance.hashCode());
        System.out.println("Instance.hashCode1="+instance01.hashCode());

        instance.sayOK();
    }

}

enum  Singleton {
    INSTANCE;//属性

    public void sayOK(){
        System.out.println("ok!");
    }
}

分析：

  • 1.这借助JDK1.5中添加的枚举来实现单例模式，不仅能避免多线程同步的问题，而且还能防止反序列化重新创建新的对象
  • 2.这种方式是Effective Java的作者提倡的方式

结论：

  • 在实际开发中，推荐使用

3.单例模式在JDK源码中应用的分析

4.总结

  • 1.单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能
  • 2.当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用new
  • 3.单例模式使用的场景：
    • 需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多（即，重量级对象），但又经常用到的对象、
    • 工具类对象、
    • 频繁访问数据库或文件的对象（比如数据源、session工厂等）
喵的波波鱼
关注
专栏目录
设计模式（二）——单例模式详解
壹升茉莉清的博客
09-02 359
单例模式是属于创建模式的一种设计模式，在内存中创建对象只会创建一次对象。在我们开发中频繁的创建同一个对象并且作用不变的时候，为了减少频繁的创建对象使得内存飙升带来的问题，我们可以使用单例模式进行解决。单例模式只会创建一个对象，让所有的调用者都共享这一个对象。
Java设计模式——单例模式
流楚丶格念的博客
08-11 1649
第二次判断防止多线程创建多个实例，假如A和B 两个线程同时争抢synchronized锁，A先争抢到锁，B 等待，A线程instance赋值实例化对象，释放锁，B线程获取到到锁，如果没有第二次判断的话，直接又会创建对象，那么就不符合单例要求。，此时2 ，3发生重排序，选执行3，则instance已经不为 null，但是指向的对象还未初始化完成，如果此时B对象判断instance 不为null就会直接返回一个未初始 化完成的对象。第一次判断没有锁，如果install不为null直接返回单实例对象，提高效率。.
“对象性能”模式
LOGBOOK
03-10 157
“对象性能”模式 面向对象很好的解决了“抽象”的问题，但是必不可免地要付出一定的代价。对于通常情况来讲，面向对象的成本大都可以忽略不计。但是某些情况，面向对象所带来的成本必须谨慎处理。 典型模式 Singleton FlyWeight Singleton单件模式 保证一个类仅有一个实例，并提供一个该实例的全局访问点。 动机 在软件系统中，经常有这样的一个特殊的类，必须保证他们在系统...
对象性能模式——单件模式和亨元模式
zw1996的博客
08-11 242
单件模式； 之前的模式都是与项目整体的设计相关的，什么高内聚，松耦合、多态，隔离。但是对象性能模式不是从这些方面的设计模式、而是从软件的性能方面入手的、其实与公司代码里面很多类对象实现的那种单例是一个意思、唯一的目的就是如果这个类的对象在项目中要经常高频率的时候，那么如果常规的话就需要去不断new对象，那么就耗内存不利于项目的性能。因此就 出现了对象性能模式这两种模式、目的就是达到在整个项目中不需...
设计模式（十二）——对象性能模式-FlyWeight
caicaptain
05-24 133
对象模式所属类别简介-对象性能模式 面向对象很好的解决了“抽象”的问题，但是不可避免要付出一定的代价，虚函数会占用内存信息但是一般都可以忽略不计。不过有些情况还是需要注意。对象性能模式包括：singleton、flyweight 对象性能当前模式简介动机-FlyWeight 在软件系统采用纯碎对象方案的问题在于大量细粒度的对象会很快充斥在系统中，从而带来很高的运行时代价（内存需求方面的代价） 使用FlyWeight-享元模：复用之前的new出来的对象。 需求 建造一个房子，然后展示。再建造一个一样的房子，展
卓越性能代码_开启win10隐藏的“超级性能模式”
热门推荐
weixin_39964528的博客
12-19 2万+
​微软总是悄悄给Windows 10 加一些新功能，又不大肆宣传，导致很多朋友感觉Windows 10不过是换了一套UI的Windows 7甚至XP。今天来分享一个隐藏起来的"超级模式"–>卓越性能大家都知道Windows系统有3种电源选项，节能、平衡、高性能，不同模式对应电脑将发挥多大的潜力和吃多少电。目前"卓越性能"模式只在部分企业版和工作站版上才能直接打开。其他版本也不要急，下面就教你...
设计模式 单例模式的8种写法及分析
cong____cong的博客
03-06 248
设计模式分类 创建型模式:单例模式、抽象工厂模式、原型模式、建造者模式、工厂模式。 结构型模式: 适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。 行为型模式: 模版方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式(Interpreter 模式)、状态模式、策略模式、职责链模式(责任链模式)。 单例模式 ...
设计模式（一）——单例模式
QQ是一枚程序媛
07-30 654
目录 单例模式的定义： 单例模式的特点： 单例类的优缺点： 单例模式的写法(懒汉式、饿汉式) 懒汉模式和饿汉模式的区别 使用注意事项： 适用场景： 应用场景举例： 单例模式的定义： 单例模式是常用的设计模式之一，在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的类一个类只有一个实例。即一个类只有一个对象实例。（引自百度百科）。...
Java设计模式精讲——单例模式
程序员光剑
10-05 632
在面向对象编程中，单例模式（Singleton pattern）是一种常用的设计模式，它保证某个类只能有一个实例，并提供一个全局访问点。由于创建单例实例的开销较大，因此对一些需要频繁创建或者没有其他更优雅的方式时，可以使用单例模式。例如：数据库连接池、线程池、日志对象等。对于某些项目来说，由于系统架构或功能模块化导致某些类需要经常被创建，并且这些类需要共享一些相同的数据，所以需要单例模式。例如：Spring中的Bean工厂模式就是通过用单例模式实现应用上下文的依赖注入的。
WIN10 卓越性能模式开启方法
03-12
WIN10 卓越性能模式开启代码，避免报毒，就文本文档打开直接复制，管理员运行CMD，复制回车即可
一遍看懂：设计模式——单例模式原理详解
m0_66194642的博客
09-21 291
干货，代码配讲解它不香吗
设计模式(一) ——单例模式 （6种实现、优缺点、以及应用场景）
猿兄
02-13 2222
目录 一、单例模式的定义 二、单例模式的设计要素 三、单例模式的6种实现及优缺点 （一）懒汉式（线程不安全） （二）饿汉式（线程安全） （三）懒汉式（线程安全） （四）双重检查锁实现（线程安全） （五）静态内部类实现（线程安全） （六）枚举类实现（线程安全） 防止反序列化 四、单例模式的应用场景 一、单例模式的定义 定义：确保一个类只有一个实例，并提供该实例的全局访...
高性能单例模式
a6697238的博客
10-30 386
转载 http://blog.csdn.net/generalfu/article/details/8142463面试的时候，常常会被问到这样一个问题：请您写出一个单例模式（Singleton Pattern）吧。好吧，写就写，这还不容易。顺手写一个：public final class EagerSingleton { private static EagerSingl
卓越性能代码_教你Win10启用卓越性能模式，效果明显！
weixin_39981624的博客
11-21 2644
本文授权转载自公众号：labulac当Windows 10更新到内部版本17333后，一些朋友可能发现，以往电源管理模式有节能、标准和高性能三个选项，现在装完系统默认启用的是标准选项，剩下的两个模式被隐藏了当然我们也可以将这些电源模式找回来。可能微软是想不需要用户进行手动操作，让系统自动判断，选择最佳的电源管理方案不过对于渴望性能的用户而言，适合自己的电源管理方案还是非常有必要的如何查看...
卓越性能代码_Windows10中隐藏一个非常棒的功能——开启卓越性能模式
weixin_39636253的博客
12-19 2100
微软在Windows10 1803以后的版本中，内置隐藏了一个新的功能，开启卓越性能模式。这个功能其实就是添加了一项电源计划模式，但是开启这个功能后，能最大程度的利用你的电脑配置，发挥出你的全部性能，让电脑更加流畅。开启方法：1、鼠标右键点击开始菜单-在打开的超级菜单上点击”windows powershell(管理员)(A)；2、在打开后“windows powershell”窗口中，输入命令代...
如何开启win10高性能模式，触发win10隐藏电源管理模式，自制开启win10高性能模式的桌面小工具。
m0_68285995的博客
10-04 4756
很多小伙伴打开电源设置却找不到高性能这一选项，只有平衡模式，这是因为被Windows隐藏了，需要手动开启。今天我们就来自制一个桌面小工具方便开启高性能模式。4.输入这行代码然后保存退出。（代码:powercfg -s 8c5e7fda-e8bf-4a96-9a85-a6e23a8c635c）高性能模式是Windows提供的一种电源管理模式，该模式下可以最大限度的发挥出电脑硬件的性能，尤其是CPU和显卡。2.将文件名改为高性能.bat（名字可自定义，但文件扩展名一定改为.bat），点击是确认更改。
Windows10/11高性能模式开启教程
最新发布
李佑辰
12-26 7425
大部分用户windows10和11高性能模式都被隐藏了，并且没有隐藏选项。本教程教大家如何开启！
卓越性能代码_Win10如何开启卓越模式？学会输入这串代码，电脑性能大幅提升...
weixin_39984201的博客
12-19 1万+
自己的电脑性能如何总是被用户所关注的，那么今天就是来给大家介绍一个Win10的模式，输入一串代码后即可开启该模式——卓越模式。该模式开启之后，完全可以用来代替"高性能"模式，尤其是对于喜欢超频、玩硬件的用户来说还是比较推荐使用的，比较该模式下电脑的性能的确有所提升，所以接下来就来教大家如何开启该模式。首先我们在搜索栏中输入"windows powershell"，点击"以管理员身份运行"。然后我们...
Java单例模式深度解析：七种实现方式与线程安全
"Java设计模式之单例模式的七种写法，Tom老师的公开课文档，深入分析单例模式，适合研究设计模式的学习者。" 在软件开发中，单例模式是一种常用的设计模式，它的核心目标是确保类只有一个实例，并提供一个全局访问...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值