设计模式--单例模式Singleton

最新推荐文章于 2024-06-19 15:37:55 发布
最新推荐文章于 2024-06-19 15:37:55 发布
阅读量402 收藏
点赞数 1
分类专栏： java 设计模式 文章标签： 单例模式 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63622279/article/details/128933666
版权

设计模式--单例模式Singleton

单例设计模式

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

单例设计模式的八种方式:

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

1. 饿汉式（静态常量）

“饿汉式” ，就是你可以试着想想一下，一个饿汉的行为，肯定是见到了食物就去吃。即无论是否需要实例对象，都会在内存中去自动加载一份。

优缺点说明：

  1. 优点：写法实现简单，在类装载的时候就完成了实例化。避免了线程同步的问题。
  2. 缺点：在类装载时完成实例化，若一直没有使用过这个实例，则会造成内存资源的浪费。

这种单例模式可以使用，可能会造成资源的浪费。

代码实现：

package com.robin.singleton.type1;

public class SingletonTest1 {
    public static void main(String[] args) {
        // 测试单例模式--饿汉式（静态常量）
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println("instance1======"+instance1.hashCode());
        System.out.println("instance2======"+instance2.hashCode());
        // instance1 与 instance2 哈希值一致，是同一个对象实例
    }
}

// 单例模式----饿汉式（静态常量）

class Singleton{
    // 私有构造器，防止外部以 new 的方式创建对象
    private Singleton(){}

    // 类加载时，即创建唯一的一份对象
    private final static Singleton instance = new Singleton();

    // 对外提供一个公共的返回 singleton 实例对象
    public static Singleton getInstance(){
        return instance;
    }
}

2. 饿汉式（静态代码块）

与上面第一种方式类似，只不过是将类实例化的过程放到了静态代码块中，优缺点与上面一致。

代码实现：

package com.robin.singleton.type2;

public class SingletonTest2 {
    public static void main(String[] args) {
        // 测试单例模式--饿汉式（静态代码块）
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println("instance1======"+instance1.hashCode());
        System.out.println("instance2======"+instance2.hashCode());
        // instance1 与 instance2 哈希值一致，是同一个对象实例
    }
}

// 单例模式----饿汉式（静态代码块）

class Singleton{
    // 私有构造器，防止外部以 new 的方式创建对象
    private Singleton(){}

    private static Singleton instance ;

    // 在静态代码块中-->类加载时，完成instance的初始化
    static {
        instance = new Singleton();
    }

    // 对外提供一个公共的返回 singleton 实例对象
    public static Singleton getInstance(){
        return instance;
    }
}

3. 懒汉式（线程不安全）

“懒汉式”，当饿极了才去吃东西。即当需要时，才将类实例对象创建并且加载到内存中。

优缺点：

  1. 实现了延迟加载，但只能在单线程下使用。
  2. 在多线程下，会产生多个实例。
  3. 实际开发中，不要使用这种方式。

代码实现：

package com.robin.singleton.type3;

public class SingletonTest3 {
    public static void main(String[] args) {
        // 测试单例模式--懒汉式（线程不安全）
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println("instance1======"+instance1.hashCode());
        System.out.println("instance2======"+instance2.hashCode());
        // instance1 与 instance2 哈希值一致，是同一个对象实例

    }

}

// 单例模式----饿汉式（静态代码块）

class Singleton {
    // 私有构造器，防止外部以 new 的方式创建对象
    private Singleton() {
    }

    private static Singleton instance;


    // 当使用到时，才去初始化实例对象（懒汉式）
    // 对外提供一个公共的返回 singleton 实例对象
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

多线程测试：

package com.robin.singleton.type3.threadSingleton;

public class TestThreadSingleton {
    public static void main(String[] args) {
        System.out.println("~~~~~多线程测试~~~~~");
        // 多线程测试懒汉式的线程不安全的写法
        for (int i = 0; i < 100; i++) {
            // 匿名内部类+lambda表达式
            new Thread(() -> {
                System.out.println(Singleton.getInstance().hashCode());
            }).start();
        }
        // hashCode 都乱了。线程不安全
    }
}

// 懒汉式（线程不安全）
class Singleton{
    // 私有构造器
    private Singleton(){}

    private static Singleton instance;

    // 懒汉式，当需要时进行加载（调用getInstance()方法）获得实例对象
    // 提供对外公共的 getInstance()
    public static Singleton getInstance(){
        if (instance==null){
            // 线程睡眠1s进行测试
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            instance = new Singleton();
        }
        return instance;
    }
}

在这里插入图片描述

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

代码实现：

package com.robin.singleton.type4;

public class SingletonTest4 {
    public static void main(String[] args) {
        // 测试单例模式--懒汉式（线程安全）
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println("instance1======"+instance1.hashCode());
        System.out.println("instance2======"+instance2.hashCode());
        // instance1 与 instance2 哈希值一致，是同一个对象实例
    }
}

// 单例模式----懒汉式（线程安全）
class Singleton{
    // 私有构造器，防止外部以 new 的方式创建对象
    private Singleton(){}

    private static Singleton instance ;

    // 对外提供一个公共的返回 singleton 实例对象的方法getInstance()
    // 使用同步方法 synchronized 线程同步锁
    public static synchronized Singleton getInstance(){
        if (instance==null){
            instance = new Singleton();
        }
        return instance;
    }
}

线程测试：

package com.robin.singleton.type4.threadSingleton;

public class TestThreadSingleton {
    public static void main(String[] args) {
        System.out.println("多线程测试【懒汉式单例模式】");
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                System.out.println(Singleton.getInstance().hashCode());
            }).start();
        }
        // 哈希值没有乱，线程安全
        // 但是同步锁 synchronized 比较耗费时间，效率不高
    }
}

// 懒汉式（线程安全）
class Singleton{

    // 私有化构造器
    private Singleton(){}
    // 静态变量
    private static Singleton instance;
    // 向外提供getInstance()方法，需要时才创建
    // synchronized 线程同步锁
    public static synchronized Singleton getInstance(){
        if (instance==null){
            // 为了线程测试，线程中断休眠1s
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            instance = new Singleton();
        }
        return instance;
    }
}

在这里插入图片描述

优缺点：

  1. 优点：通过synchronized同步方法解决了多线程的安全问题
  2. 缺点：效率较低，因为同步锁的问题，内次都需要进行锁，无论实例是否存在

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

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

代码实现：

package com.robin.singleton.type5;

public class SingletonTest5 {
    public static void main(String[] args) {
        // 测试单例模式--懒汉式（线程不安全）
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println("instance1======"+instance1.hashCode());
        System.out.println("instance2======"+instance2.hashCode());
        // instance1 与 instance2 哈希值一致，是同一个对象实例
    }
}

// 单例模式----懒汉式（线程不安全，妄图通过减小同步代码块的方式来提高效率）
class Singleton{
    // 私有构造器，防止外部以 new 的方式创建对象
    private Singleton(){}

    private static Singleton instance ;

    // 对外提供一个公共的返回 singleton 实例对象的方法getInstance()
    public static  Singleton getInstance(){
        if (instance==null){
            // 妄图通过减小同步代码块的方式来提高效率,会导致线程不安全
            synchronized(Singleton.class){
                instance = new Singleton();
            }
        }
        return instance;
    }
}

多线程测试：

package com.robin.singleton.type5.threadSingleton;

public class SingletonTest5 {
    public static void main(String[] args) {
        // 测试单例模式--懒汉式（线程不安全）
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                System.out.println(Singleton.getInstance().hashCode());
            }).start();
        }
    }
}

// 单例模式----懒汉式（线程不安全，妄图通过减小同步代码块的方式来提高效率）
class Singleton{
    // 私有构造器，防止外部以 new 的方式创建对象
    private Singleton(){}

    private static Singleton instance ;

    // 对外提供一个公共的返回 singleton 实例对象的方法getInstance()
    public static  Singleton getInstance(){
        if (instance==null){
            // 妄图通过减小同步代码块的方式来提高效率，会导致线程不安全
            synchronized(Singleton.class){
                // 线程休眠1s
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                instance = new Singleton();
            }

        }
        return instance;
    }
}

在这里插入图片描述

妄图通过减小同步代码块的方式来提高效率，但会导致多线程还是存在安全问题，只能在单线程下使用，不推荐使用。

6. 双重检查

通过双重检查保证线程安全，两次 if(singleton==null)。实例化代码只执行一次，避免反复进行方法同步。

代码实现：

package com.robin.singleton.type6;

public class SingletonTest6 {
    public static void main(String[] args) {
        // 测试单例模式--双重检查
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println("instance1======"+instance1.hashCode());
        System.out.println("instance2======"+instance2.hashCode());
    }
}

// 单例模式--双重检查
class Singleton{
    private Singleton(){};

    // 使用 volatile 关键字
    private static volatile Singleton instance;

    public static Singleton getInstance(){
        if (instance==null){
            synchronized (Singleton.class){
                if (instance==null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

}

解决了多线程的安全问题，双重检查可以解决懒加载问题，即在使用时才会加载（避免浪费内存资源），同时保证了效率，推荐使用。

7. 静态内部类

静态内部类在使用时才会实例化，避免资源浪费，实现延迟加载。同时JVM保证了线程的安全，在类进行初始化时，只有一个线程才能进入。

代码实现：

package com.robin.singleton.type7;

public class SingletonTest7 {
    public static void main(String[] args) {
        // 测试单例模式--静态内部类的方式
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println("instance1======"+instance1.hashCode());
        System.out.println("instance2======"+instance2.hashCode());
    }
}

// 单例模式--静态内部类的方式
class Singleton{
    private Singleton(){};

    // 私有静态内部类
    private static class SingletonInstance{
        private static final Singleton INSTANCE =new Singleton();
    }

    // 提供公有的外部获取实例的方法 getInstance()
    public static Singleton getInstance(){
        return SingletonInstance.INSTANCE;
    }

}

避免了线程不安全，利用静态内部类的特点实现延迟加载，效率高。

推荐使用+1！

8. 枚举

使用枚举来实现单例模式，既可以避免多线程同步问题，也能防止反序列化重新创建新的对象。推荐使用+1！

代码实现：

package com.robin.singleton.type8;

public class SingletonTest8 {
    public static void main(String[] args) {
        // 测试单例模式--枚举的方式
        Singleton instance1 = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println(instance1==instance2);
        System.out.println("instance1===="+instance1.hashCode());
        System.out.println("instance2===="+instance2.hashCode());
    }
}

// 单例模式--枚举的方式
enum Singleton{
    INSTANCE;
}
杀死一只知更鸟debug
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
嵌入式C语言设计模式 --- 单例模式
EmbedIoT Studio
12-29 2116
单例模式（Singleton Pattern）是软件程序设计中最简单的设计模式之一，单例模式在设计模式分类中，是属于创建型模式，它提供了一种创建对象（实例，变量）的最佳实践方式。顾名思义，单例（也叫单件），也就是在整个程序设计中，只存在一个单一的类（C语言中叫“类型”，通常用结构体类型表示），这个类负责创建一个对象（C语言中叫“定义变量”，通常是指结构体变量）
C#-设计模式-单例模式
Asincereman的专栏
01-14 1021
1、提供了对唯一实例的受控访问。2、由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。3、允许可变数目的实例。
设计模式-创建型-单例模式-Singleton
蒋劲豪的博客
03-15 447
【代码】设计模式——单例模式。
设计模式-1--单例模式（Singleton Pattern）
人生若只能如初见的博客
08-26 975
单例模式是一种创建型设计模式，它旨在确保一个类只有一个实例，并提供一个全局访问点来访问该实例。换句话说，单例模式限制了类的实例化次数为一个，并提供一种在应用程序中共享一个实例的方式。这对于需要只有一个实例来管理某些资源或状态的情况非常有用。
设计模式-01 设计模式单例模式
jxusthusiwen的专栏
04-30 1462
单例模式是一种设计模式，它确保一个类只能被实例化一次。它通过在类内部创建类的唯一实例并提供一个全局访问点来实现这一点。优点：全局访问：单例对象可以从应用程序的任何地方访问。资源节约：它只创建一个对象，从而节省了内存和资源。线程安全性：如果单例对象正确实现，它可以是线程安全的，这意味着它可以在多线程环境中安全地使用。C++11 中的单例模式通过双重检查锁定和 RAII 技术实现线程安全的惰性实例化，确保全局访问和资源管理。在实现上，这比起低版本的来说，预言特性给我们更加灵活的操作性。
JAVA设计模式--单例模式
JAVA_SR的博客
09-21 610
单例设计模式
创建型设计模式-单例模式
Jacks丶的博客
07-21 397
介绍设计模式之单例模式。
C++设计模式---单例模式
专注
06-08 1008
由于是在编译时确定的初始化，因此这种方式是线程安全的（在C++11及以后的版本中），并且不需要额外的同步机制。然而，在大多数情况下，这些缺点都是可以接受的，因为单例对象通常代表一些重要的系统资源或功能，需要尽早地初始化。通过单例模式可以创建一个缓存管理器，确保只有一个缓存实例存在，并且可以被多个线程共享，方便全局访问和统一管理缓存。当需要对资源进行集中管理，以确保线程安全的访问时，单例模式是一个不错的选择。当实例化一个类的成本较高，而且只需要一个实例时，可以使用单例模式来避免重复实例化的开销。
设计模式--单例模式详解
想着百万年薪努力的小赵
04-13 2307
单例模式的定义 单例模式(Singleton Pattern ）是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。单例模式是创建型模式。单例模式在现实生活中应用也非常广泛，例如，公司CEO、部门经理等。J2EE标准中的ServletContext，ServletContextConfig等、Spring框架应用中的ApplicationContext、数据库的连接池等也都是单例形式。 饿汉式单例模式 饿汉式单例模式在类加载的时候就立即初始化，并且创建单例对象。它绝对线程安全，在线程还没 出
大话设计模式--Singleton(单例模式)
03-28
NULL 博文链接：https://linxingliang.iteye.com/blog/1217811
ava常用设计模式-单例模式
08-26
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一，有以下特点： 1. 单例类只能有一个实例。 2. 单例类必须自己创建自己的唯一实例。 3. 单例类必须给所有其他对象提供这一实例。 单例模式有多种实现...
Java设计模式-单例模式详解
11-24
Java设计模式-单例模式详解 单例模式是 Java 设计模式中的一种常用的设计模式，旨在保证一个类仅有一个实例，并提供一个访问它的全局访问点。单例模式的目的是为了保证在一个进程中，某个类有且仅有一个实例。 ...
Design-Patterns-Singleton:单例设计模式示例
05-25
这是单例设计模式的基本示例。 您将在此仓库中找到两个示例。 首先是线程安全的单例，其次不是。 测试的输出是： synchronizedTest Started... Thread 2 instance is : ...
 单例设计模式Singleton1
08-08
单例设计模式Singleton1是Java设计模式中的一种创建型模式，指某个类采用Singleton模式，则在这个类被创建后，只可能产生一个实例供外部访问，并且提供一个全局的访问点。这个模式的核心知识点可以总结为三点： 1. ...
探索设计模式——单例模式详解
strive_mianyang的博客
06-18 1043
单例模式的简单讲解
两种单例模式（保证线程安全）
daima2的博客
06-17 1098
单例模式也叫单个实例，也就是这个类只有且只能有一个实例对象，这样一个类就叫做“单例”；单例模式有很多种，这里只介绍“饿汉模式”和“懒汉模式”两种；
Qt实现单例模式：Q_GLOBAL_STATIC和Q_GLOBAL_STATIC_WITH_ARGS
红军不怕远征难，万水千山只等闲
06-16 994
} \从上述代码可以看出：1）根据不同的 NAME，生成了不同的命名空间，虽然对象创建函数、多线程同步变量guard的名字一样，但是是在不同的命名空间，因此生成的QGlobalStatic也是不一样的，其实这个也是实现技巧。2）QBasicAtomicInt 是 原子操作，是线程安全的，它的介绍在这里就不在赘述了，不明白的地方请自行查阅。3）Q_GLOBAL_STATIC是Q_GLOBAL_STATIC_WITH_ARGS的特例。
设计模式学习之——单例模式
最新发布
m0_70289867的博客
06-19 1050
单例模式
聊聊设计模式-单例模式
09-29
单例模式是一种创建型设计模式，它保证类仅有一个实例，并提供一个全局访问点。在单例模式中，类会自行创建一个实例，并对外提供一个访问该实例的方法。 单例模式有多种实现方式，其中常见的有懒汉式和饿汉式。懒汉...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

杀死一只知更鸟debug

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值