设计模式学习笔记——单例模式

最新推荐文章于 2024-10-07 18:07:23 发布
最新推荐文章于 2024-10-07 18:07:23 发布
阅读量119 收藏
点赞数
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37649025/article/details/110785016
版权

单例模式

单例设计模式，就是采取一定的方法保证在整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法（静态方法）。

单例模式的八种实现方式

  1. 饿汉式（静态常量）
  2. 饿汉式（静态代码块）
  3. 懒汉式（线程不安全）
  4. 懒汉式（线程安全，同步方法）
  5. 懒汉式（线程安全，同步代码块）
  6. 双重检查——推荐使用
  7. 静态内部类——推荐使用
  8. 枚举——推荐使用

饿汉式（静态常量）

实现步骤：

  1. 私有化构造器
  2. 创建静态实例
  3. 对外暴露一个获取实例的静态方法

代码实现：

package com.test.singleton;

/**
 * @Author: junwe
 * @Date: 2020/12/6 16:25
 */
public class SingletonTest1 {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println(instance1.hashCode() == instance2.hashCode());
    }

}

/**
 * 饿汉式-静态常量
 */
class Singleton {

    /**
     * 私有化构造器，外部类不能new对象
     */
    private Singleton() {}

    // 类被加载的时候创建对象实例
    private final static Singleton INSTANCE = new Singleton();

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

运行结果：

image-20201206164127497

优点：写法简单，在类加载的时候就完成了实例化。避免了线程同步的问题。

缺点：在类加载的时候就完成实例化，没有达到lazy loading的效果。如果这个类一直未被使用，则会造成资源浪费。

结论：这种单例模式可用，但是可能造成内存浪费。

饿汉式（静态代码块）

代码实现：

package com.test.singleton.test2;

/**
 * @Author: junwe
 * @Date: 2020/12/6 16:55
 */
public class SingletonTest2 {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println(instance1.hashCode() == instance2.hashCode());
    }

}

/**
 * 饿汉式-静态代码块
 */
class Singleton {

    /**
     * 私有化构造器，外部类不能new对象
     */
    private Singleton() {}

    private static Singleton INSTANCE;

    /**
     * 静态代码块执行的时候创建对象实例
     */
    static {
        INSTANCE = new Singleton();
    }

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

执行结果：

image-20201206170453533

优缺点同饿汉式（静态常量）

懒汉式（线程不安全）

代码实现：

package com.test.singleton.test3;

/**
 * @Author: junwe
 * @Date: 2020/12/6 17:21
 */
public class SingletonTest3 {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new GetInstanceThread()).start();
        }
    }
}

/**
 * 懒汉式-线程不安全
 */
class Singleton {

    /**
     * 私有化构造器，外部类不能new对象
     */
    private Singleton() {
    }

    private static Singleton INSTANCE;

    /**
     * 提供一个公有的静态方法返回对象实例
     * 当使用到该方法时才创建实例
     *
     * @return
     */
    public static Singleton getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new Singleton();
        }
        // 打印出实例的hashcode值
        System.out.println(INSTANCE.hashCode());
        return INSTANCE;
    }
}

class GetInstanceThread implements Runnable{

    @Override
    public void run() {
        Singleton.getInstance();
    }
}

运行结果：

image-20201206175647624

优缺点：

  1. 起到了lazy loading的效果，但是只能在单线程下使用。
  2. 如果在多线程下，一个线程进入了if(INSTANCE == null) ，还未来得及往下执行，另外一个线程也通过了这个判断语句，这时就会产生多个实例。所以在多线程环境下不可以使用这种方式。

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

代码实现：

package com.test.singleton.test4;

/**
 * @Author: junwe
 * @Date: 2020/12/6 21:15
 */
public class SingletonTest4 {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new GetInstanceThread()).start();
        }
    }
}

/**
 * 懒汉式-同步方法
 */
class Singleton {

    /**
     * 私有化构造器，外部类不能new对象
     */
    private Singleton() {
    }

    private static Singleton INSTANCE;

    /**
     * 提供一个公有的静态方法返回对象实例
     * 当使用到该方法时才创建实例
     * 加入同步代码，解决线程不安全问题
     * @return
     */
    public static synchronized Singleton getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new Singleton();
        }
        System.out.println(INSTANCE.hashCode());
        return INSTANCE;
    }
}

class GetInstanceThread implements Runnable{

    @Override
    public void run() {
        Singleton.getInstance();
    }
}

运行结果：

image-20201206212127219

优缺点：

  1. 解决了线程不安全的问题。
  2. 效率低，每个线程在获得类的实例的时候，执行getInstance()方法都要进行同步。其实这个方法只执行一次实例化代码就好了，后面的想获取该类实例可以直接return。方法进行同步效率太低。

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

代码实现：

package com.test.singleton.test4;

/**
 * @Author: junwe
 * @Date: 2020/12/6 21:15
 */
public class SingletonTest4 {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new GetInstanceThread()).start();
        }
    }
}

/**
 * 懒汉式-同步代码块
 */
class Singleton {

    /**
     * 私有化构造器，外部类不能new对象
     */
    private Singleton() {
    }

    private static Singleton INSTANCE;

    /**
     * 提供一个公有的静态方法返回对象实例
     * 当使用到该方法时才创建实例
     * 加入同步代码块，不能解决线程安全问题
     *
     * @return
     */
    public static Singleton getInstance() {
        if (INSTANCE == null) {
            synchronized (Singleton.class) {
                INSTANCE = new Singleton();
            }
        }
        System.out.println(INSTANCE.hashCode());
        return INSTANCE;
    }
}

class GetInstanceThread implements Runnable {

    @Override
    public void run() {
        Singleton.getInstance();
    }
}

执行结果：

image-20201206213436894

优缺点：

  1. 这种方法的本意是对懒汉式（线程安全，同步方法）的改进，改为同步产生实例化的代码块。
  2. 但是这种同步并不能起到线程同步的作用。如果一个线程进入了if (INSTANCE == null)判断，还没来得级往下执行，另一个线程也通过了这个判断，这时就会产生多个实例。

双重检查

代码实现：

package com.test.singleton.test5;

/**
 * @Author: junwe
 * @Date: 2020/12/6 21:45
 */
public class SingletonTest4 {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new GetInstanceThread()).start();
        }
    }
}

/**
 * 懒汉式-双重锁
 */
class Singleton {

    /**
     * 私有化构造器，外部类不能new对象
     */
    private Singleton() {
    }

    /**
     * volatile：禁止指令重排，保证内存可见性
     */
    private static volatile Singleton INSTANCE;

    /**
     * 提供一个公有的静态方法返回对象实例
     * 当使用到该方法时才创建实例
     * 双重锁，解决线程安全问题，同时解决懒加载问题
     * 同时保证高效
     * @return
     */
    public static Singleton getInstance() {
        if (INSTANCE == null) {
            synchronized (Singleton.class) {
                if (INSTANCE == null) {
                    INSTANCE = new Singleton();
                }
            }
        }
        System.out.println(INSTANCE.hashCode());
        return INSTANCE;
    }
}

class GetInstanceThread implements Runnable {

    @Override
    public void run() {
        Singleton.getInstance();
    }
}

执行结果：

image-20201206215515577

优缺点：

  1. 实例化代码只执行一次，后面再次访问时，判断if (INSTANCE == null)，直接返回实例化对现象，避免了反复进行方法同步。
  2. 线程安全：延迟加载、效率高。
  3. 推荐使用这种单例模式

静态内部类

代码实现：

package com.test.singleton.test6;


/**
 * @Author: junwe
 * @Date: 2020/12/6 22:02
 */
public class SingletonTest5 {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new GetInstanceThread()).start();
        }
    }
}

/**
 * 静态内部类
 */
class Singleton {
    /**
     * 私有化构造器，外部类不能new对象
     */
    private Singleton() {
    }

    /**
     * 静态内部类
     * 当外部类Singleton被加载的时候，静态内部类SingletonInstance不会马上被加载，保证lazy loading
     */
    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }

    /**
     * 当调用该方法时，SingletonInstance类会被加载，静态常量INSTANCE仅会被加载一次
     *
     * @return
     */
    public static Singleton getInstance() {
        System.out.println(SingletonInstance.INSTANCE.hashCode());
        return SingletonInstance.INSTANCE;
    }
}

class GetInstanceThread implements Runnable {

    @Override
    public void run() {
        Singleton.getInstance();
    }
}

执行结果：

image-20201206221936806

优缺点：

  1. 采用了类加载机制来保证初始化实例时只有一个线程。
  2. 静态内部类方式在Singleton类被加载时并不会立即被实例化，而是在需要实例化时，调用getInstance()方法时才会加载静态内部类SingletonInstance，从而完成Singleton的实例化。
  3. 类的静态属性只会在类第一次加载的时候初始化，JVM帮我们保证了线程安全。
  4. 优点：线程安全的，利用静态内部类的特点实现延迟加载，效率高。

枚举

代码实现：

package com.test.singleton.test7;

/**
 * @Author: junwe
 * @Date: 2020/12/6 22:30
 */
public class SingletonTest6 {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new GetInstanceThread()).start();
        }
    }
}

enum Singleton {
    INSTANCE;
}

class GetInstanceThread implements Runnable {

    @Override
    public void run() {
        System.out.println(Singleton.INSTANCE.hashCode());
    }
}

运行结果：

image-20201206223358588
原理分析：

对枚举类反编译结果如下

final enum com/test/singleton/test7/Singleton extends java/lang/Enum {
  // compiled from: SingletonTest6.java
  // access flags 0x4019
  public final static enum Lcom/test/singleton/test7/Singleton; INSTANCE
  // access flags 0x101A
  private final static synthetic [Lcom/test/singleton/test7/Singleton; $VALUES
  // access flags 0x9
  public static values()[Lcom/test/singleton/test7/Singleton;
  // access flags 0x9
  public static valueOf(Ljava/lang/String;)Lcom/test/singleton/test7/Singleton;
  // access flags 0x2
  // signature ()V
  // declaration: void <init>()
  private <init>(Ljava/lang/String;I)V
  // access flags 0x8
  static <clinit>()V
}

可以看到枚举实例被声明为static，构造方法被private修饰。枚举类的实例对象是在类加载的时候创建的。
优缺点：

  1. 借助JDK1.5新增的枚举类来实现单例模式，不仅能避免多线程同步问题，而且还能防止反序列化重新创建对象。
    关于枚举实现单例的详细可以看看这篇博客https://www.cnblogs.com/chiclee/p/9097772.html
稳重的窝瓜
关注
专栏目录
设计模式——设计模式概述
冯Jungle的个人博客
10-12 2万+
软件设计模式（Design pattern），又称设计模式，是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。设计模式主要是为了解决某类重复出现的问题而出现的一套成功或有效的解决方案。设计模式提供一种讨论软件设计的公共语言，使得熟练设计者的设计经验可以被初学者和其他设计者掌握。设计模式还为软件重构提供了目标。 1.设计模式由来 软件设计模式源自于建筑学。积淀了几千年的建筑学工...
单例模式
da_kao_la的博客
04-07 926
单例模式 设计模式是人们在开发中总结抽象的一些常用的程序设计范式。23种设计模式汇总如下图所示： 单例模式是这样一种设计模式，使得一个类只能有一个实例。单例模式主要有以下5种实现方法。 饿汉式 饿汉式单例模式在类加载过程中就实例化类对象，因此称为“饿汉”。由于Java类加载的过程本身是线程安全的，因此饿汉式的优点是无需额外同步即线程安全，并发效率高，但由于无法延迟加载，导致占用空间资源。 pac...
单例、单例模式
03-20 292
简单的实现一个单例： + (instancetype)sharedInstance {           static MyClass *_instance = nil;           static dispatch_once_t predicate;           dispatch_once(&predicate, ^{                   _in
一 单例模式
Ankas
09-11 1177
吹前序 什么是设计模式 单例模式 使用场景 定义 共同构成 实现的类型 饿汉式 静态内部类 懒加载 总结 优点 缺点吹前序作为一名程序员，想要看出与别人的差距，除了必备吹水技能，斗图技能，那就还剩最重要的一点——代码能力了！那么如何才能在众多段子手，老司机中通过自己的代码成功装逼呢，作为程序员的你，必须要了解，学习，使用的杀手锏来了 设计模式什么是设计模式你可以这样理解它： 程序的设计模式通常来说
【单例模式】
最新发布
C384136844的博客
10-07 1299
单例模式是指在内存中只会创建且仅创建一次对象的设计模式。
设计模式-单例模式 C++实现
不很正派的专栏
08-18 355
对于系统中的某些类来说，只有一个实例很重要，例如，一个系统中可以存在多个打印任务，但是只能有一个正在工作的任务；一个系统只能有一个窗口管理器或文件系统；一个系统只能有一个计时工具或ID（序号）生成器。如何保证一个类只有一个实例并且这个实例易于被访问呢？定义一个全局变量可以确保对象随时都可以被访问，但不能防止我们实例化多个对象。一个更好的解决办法是让类自身负责保存它的唯一实例。这个类可以保证没有其他实
C#设计模式–单例模式
12-22
首先我介绍的是设计模式中比较简单的一个模式——单例模式（因为这里只牵涉到一个类） 　二、单例模式的介绍 　说到单例模式，大家第一反应应该是——什么是单例模式？，从“单例”字面意思上理解为——一个类只有...
【狂神说笔记——23种设计模式】
weixin_46055348的博客
06-28 1266
【狂神说笔记——23种设计模式】
设计模式——单例模式 Singleton
iFuMI的博客
06-19 1034
1. 意图： 什么是单例模式？在GOF的《设计模式：可复用面向对象软件的基础》中这样描述：保证一个类仅有一个实例，并提供一个访问它的全局访问点。 2. 单例模式特点： 单例类仅有一个且唯一的实例；单例类必须自己创建该实例； 除此之外，单例模式还有很多有用的特点，比如爱奇艺2016研发工程师面试题中：单例模式的类具有？ A. 没有公有构造方法，有一个公有静态工厂方法和一个静态实例变
黑马程序员 学习笔记——Java 二十三设计模式之单例
huchuan90的专栏
06-08 580
----------------------android培训 、java培训、期待与您交流！ ---------------------- Java 中解决某一问题最行之有效的方法是设计模式。在java 有二十三中设计模式。今天的笔记是二十三设计模式之 单例。 三个要点：一是某各类只能有一个对象实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例 单例设计模式解决在j
设计模式 - 创建型模式_ 单例模式 Singleton Pattern
热门推荐
小工匠
12-06 1万+
单例模式常见的写法有: 懒汉式单例，饿汉式单例，登记式单例(可忽略)。单例模式特点: 单例类只能有一个实例 单例类必须自己创建自己的唯一实例 单例类必须给所有其他对象提供这一对象实例 单例模式确保某各类只有一个实例，而且自行实例化并向整个系统提供这个实例。比如我们常见的线程池 、缓存等等。选择单例模式就是为了避免不一致的状态，避免政出多头。懒汉式单例 特点: - 懒汉式单例在第一次调用的时候
C#单例模式详解：设计与应用
C#设计模式(1)——单例模式是IT领域中一种常用的设计模式，它旨在确保一个类在整个应用生命周期中只有一个实例存在，并提供一个全局访问点，方便管理和控制。本文档将围绕单例模式进行详细介绍。 一、引言 作者在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值