设计模式（单例模式）

最新推荐文章于 2024-05-21 10:23:42 发布
最新推荐文章于 2024-05-21 10:23:42 发布
阅读量85 收藏
点赞数
分类专栏： 设计模式系列 文章标签： java python c++ c语言 c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/prefect_start/article/details/104356369
版权

设计模式类型：

设计模式分为三种类型，共23 种：

  1. 创建型模式：单例模式、抽象工厂模式、原型模式、建造者模式、工厂模式。
  2. 结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。
  3. 行为型模式：模版方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式（Interpreter 模式）、状态模式、策略模式、职责链模式(责任链模式)。

单例模式

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

比如Hibernate 的SessionFactory，它充当数据存储源的代理，并负责创建Session 对象。SessionFactory 并不是轻量级的，一般情况下，一个项目通常只需要一个SessionFactory 就够，这是就会使用到单例模式。

单例模式有八种方式：

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

代码如下：

package com.design.models.singleton;
/**
 * @ClassName : Singleton  //类名
 * @Description : 单例模式（饿汉式 静态变量）  //描述
 * @Author : swq  //作者
 * @Date: 2020-02-17 12:56  //时间
 */
public class SingletonTest{
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();

        System.out.println(instance == instance2);
        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());

    }
}

//创建对象
 class Singleton {
    //1、构造器私有化
    private Singleton(){
    }
    //2、使用静态变量创建对象
    private final static Singleton INSTANCE = new Singleton();
    //3、提供public方法
    public static Singleton getInstance(){
        return INSTANCE;
    }
}
//运行结果
//true
//1163157884
//1163157884

优缺点说明：

  1. 优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。
  2. 缺点：在类装载的时候就完成实例化，没有达到Lazy Loading 的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费
  3. 这种方式基于classloder 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，在单例模式中大多数都是调用getInstance 方法，但是导致类装载的原因有很多种，因此不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance 就没有达到lazy loading 的效果。
  4. 结论：这种单例模式可用，可能造成内存浪费。
饿汉式（静态代码块）

代码

package com.design.models.singleton;
/**
 * @ClassName : Singleton  //类名
 * @Description : 单例模式（饿汉式 静态代码块）  //描述
 * @Author : swq  //作者
 * @Date: 2020-02-17 12:56  //时间
 */
public class SingletonTest02{
    public static void main(String[] args) {
        Singleton02 instance = Singleton02.getInstance();
        Singleton02 instance2 = Singleton02.getInstance();

        System.out.println(instance == instance2);
        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());
    }
}

//创建对象
 class Singleton02 {
    //1、构造器私有化
    private Singleton02(){
    }
    //2、创建静态变量
    private static Singleton02 INSTANCE;
    //3、在静态代码块中创建对象
    static {
        INSTANCE = new Singleton02();
    }
    //4、提供public方法
    public static Singleton02 getInstance(){
        return INSTANCE;
    }
}
//运行结果
//true
//1163157884
//1163157884

优缺点说明：

  1. 这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。优缺点和上面是一样的。
  2. 结论：这种单例模式可用，但是可能造成内存浪费
懒汉式(线程不安全)

代码：

package com.design.models.singleton.type1;
/**
 * @ClassName : Singleton  //类名
 * @Description : 单例模式（懒汉式 线程不安全）  //描述
 * @Author : swq  //作者
 * @Date: 2020-02-17 12:56  //时间
 */
public class SingletonTest03{
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();

        System.out.println(instance == instance2);
        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());

    }
}

//创建对象
 class Singleton {
    //1、构造器私有化
    private Singleton(){
    }
    //2、创建静态变量
    private static Singleton INSTANCE;
    //3、提供public方法
    public static Singleton getInstance(){ 
        if (INSTANCE == null){ //判断INSTANCE是否为null  如果为null 则为变量赋值
            INSTANCE = new Singleton();
        }
        return INSTANCE;
    }
}
//运行结果
//true
//1163157884
//1163157884

优缺点说明：

  1. 起到了Lazy Loading 的效果，但是只能在单线程下使用。
  2. 如果在多线程下，一个线程进入了if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式
  3. 结论：在实际开发中，不要使用这种方式。
懒汉式(线程安全，同步方法)

代码：

package com.design.models.singleton.type2.type1;
/**
 * @ClassName : Singleton  //类名
 * @Description : 单例模式（懒汉式 同步方法 线程安全）  //描述
 * @Author : swq  //作者
 * @Date: 2020-02-17 12:56  //时间
 */
public class SingletonTest04{
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();

        System.out.println(instance == instance2);
        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());

    }
}

//创建对象
 class Singleton {
    //1、构造器私有化
    private Singleton(){
    }
    //2、创建静态变量
    private static Singleton INSTANCE;
    //3、提供public方法   加锁解决了线程不安全的问题
    public static synchronized Singleton getInstance(){
        if (INSTANCE == null){ //判断INSTANCE是否为null  如果为null 则为变量赋值
            INSTANCE = new Singleton();
        }
        return INSTANCE;
    }
}
//运行结果
//true
//1163157884
//1163157884

优缺点说明：

  1. 解决了线程安全问题。
  2. 效率太低了，每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return 就行了。方法进行同步效率太低。
  3. 结论：在实际开发中，不推荐使用这种方式。
双重检查

代码：

package com.design.models.singleton.type3;
/**
 * @ClassName : Singleton  //类名
 * @Description : 单例模式（双重检查）  //描述
 * @Author : swq  //作者
 * @Date: 2020-02-17 12:56  //时间
 */
public class SingletonTest06{
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();

        System.out.println(instance == instance2);
        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());

    }
}

//创建对象
 class Singleton {
    //1、构造器私有化
    private Singleton(){
    }
    //2、创建静态变量  volatile的作用当别的线程更改变量的值后，会强制更新的主内存中，被其他的线程可见
    private static volatile Singleton INSTANCE;
    //3、提供public方法   
    public static Singleton getInstance(){
        if (INSTANCE == null){ //判断INSTANCE是否为null  
            synchronized (Singleton.class){
                if (INSTANCE == null){
                    INSTANCE = new Singleton();
                }
            }
        }
        return INSTANCE;
    }
}
//运行结果
//true
//1163157884
//1163157884

优缺点说明：

  1. Double-Check 概念是多线程开发中常使用到的，如代码中所示，我们进行了两次if (singleton == null)检查，这样就可以保证线程安全了。
  2. 这样，实例化代码只用执行一次，后面再次访问时，判断if (singleton == null)，直接return 实例化对象，也避免的反复进行方法同步.
  3. 线程安全；延迟加载；效率较高
  4. 结论：在实际开发中，推荐使用这种单例设计模式。
静态内部类

代码：

package com.design.models.singleton.type04;
/**
 * @ClassName : Singleton  //类名
 * @Description : 单例模式（静态内部类）  //描述
 * @Author : swq  //作者
 * @Date: 2020-02-17 12:56  //时间
 */
public class SingletonTest07{
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();

        System.out.println(instance == instance2);
        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());

    }
}

//创建对象
 class Singleton {
    //1、构造器私有化
    private Singleton(){
    }
    //创建静态内部类   1、类在初始化的时候静态内部类不会同时初始化
    //                2、静态内部类在被调用的时候进行初始化，只会被调用一次 是线程安全的。
    private static class SingletonInstance{
        public static final Singleton INSTANCE = new Singleton();
    }

    //3、提供public方法
    public static Singleton getInstance(){
        return SingletonInstance.INSTANCE;
    }
}
//运行结果
//true
//1163157884
//1163157884

优缺点说明：

  1. 这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
  2. 静态内部类方式在Singleton 类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance 方法，才会装载SingletonInstance 类，从而完成Singleton 的实例化。
  3. 类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM 帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
  4. 优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高
  5. 结论：推荐使用.
枚举

代码：

package com.design.models.singleton.type05;
/**
 * @ClassName : Singleton  //类名
 * @Description : 单例模式（枚举）  //描述
 * @Author : swq  //作者
 * @Date: 2020-02-17 12:56  //时间
 */
public class SingletonTest08{
    public static void main(String[] args) {
        Singleton instance = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;

        System.out.println(instance == instance2);
        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());
//        instance.sayOk();
    }
}

//创建对象
 enum Singleton {
    INSTANCE;
    public void sayOk(){
        System.out.println("ok~");
    }
}
//        true
//        1163157884
//        1163157884

优缺点说明：

  1. 这借助JDK1.5 中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。
  2. 这种方式是Effective Java 作者Josh Bloch 提倡的方式
  3. 结论：推荐使用
后端技术那点事
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式单例模式
10-10
设计模式之单例模式 懒汉式，饿汉式，同步枷锁
JAVA设计模式之单例模式
热门推荐
一个本科小生的奋斗史
04-16 98万+
本文继续介绍23种设计模式系列之单例模式。 概念： 　　java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、登记式单例。 　　单例模式有以下特点： 　　1、单例类只能有一个实例。 　　2、单例类必须自己创建自己的唯一实例。 　　3、单例类必须给所有其他对象提供这一实例。　　单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例...
设计模式——单例模式
qq_51114283的博客
07-11 2194
创建型模式——单例模式
js设计模式之单例模式
楠姐的博客
11-09 7358
单例模式也称为单体模式，保证一个类仅有一个实例，并提供一个访问它的全局访问点
设计模式之——单例模式
很高兴你能看到这里
06-19 2354
更酷的是，创建对象的职责和管理单例的职责被拆分在两个不同的方法中，这两个方法组合起来才具有单例模式的威力。你学到了吗，少年？
设计模式--单例模式详解
想着百万年薪努力的小赵
04-13 2299
单例模式的定义 单例模式(Singleton Pattern ）是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。单例模式是创建型模式。单例模式在现实生活中应用也非常广泛，例如，公司CEO、部门经理等。J2EE标准中的ServletContext，ServletContextConfig等、Spring框架应用中的ApplicationContext、数据库的连接池等也都是单例形式。 饿汉式单例模式 饿汉式单例模式在类加载的时候就立即初始化，并且创建单例对象。它绝对线程安全，在线程还没 出
软件设计模式——单例模式
wangshiqi666的博客
12-27 1496
单例模式
Java设计模式——单例模式
m0_60500421的博客
08-16 1199
Java设计模式——单例模式
Qt常用设计模式之单例模式
kchmmd的博客
03-18 1202
前言 开发过程中，采用合适的设计模式，可事半功倍。并且方便维护更新。 单例模式 单例模式主要是确保一个类只有一个实例，自行实例化并向系统提供这个实例 。许多时候整个系统只需要拥有一个的全局对象，这样有利于我们协调系统整体的行为。比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息。这种方式简化了在复杂环境下的配置管理。 单例模式分为 "懒汉"和"饿汉"俩种。 单例模式-“懒汉” 懒单例模式的特点就是延迟加载
java设计模式之单例模式
liu_da_da的博客
06-23 1万+
java设计模式之单例模式
详解设计模式之单例模式
q2511130633的博客
06-30 2130
1.单例模式概述 单例设计模式所解决的问题就是：保证类的对象在内存中唯一，即一个类只有一个对象实例 单例模式的结构 单例类。只能创建一个实例的类，对象的创建 访问类。使用单例类，对象的使用 单例模式特点 单例类只能有一个实例。 单例类必须自己创建自己的唯一实例。 单例类必须给所有其他对象提供这一实例 单例模式的优缺点 优点： 在内存中只有一个对象，节省内存空间； 避免频繁的创建销毁对象，可以提高性能； 避免对共享资源的多重占用，简化访问； 为整个系统提供一个全局访问点。 缺点：
设计模式单例模式.zip
05-03
设计模式单例模式
Java设计模式单例模式(Singleton)用法解析
08-25
主要介绍了Java设计模式单例模式(Singleton)用法解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
C#设计模式–单例模式
12-22
首先我介绍的是设计模式中比较简单的一个模式——单例模式（因为这里只牵涉到一个类） 　二、单例模式的介绍 　说到单例模式，大家第一反应应该是——什么是单例模式？，从“单例”字面意思上理解为——一个类只有...
C++设计模式-单例模式
06-13
李建忠老师的设计模式-单例模式讲解，示例以C++编程语言呈现。
jar包增量更新分析
junlaiyan的专栏
05-16 278
借助jdeps分析出jar包的增量文件
Spring-Cloud 微服务
weixin_65127444的博客
05-15 908
先来思考一个问题*通过上一章的操作，我们已经可以实现微服务之间的调用。但是我们把服务提供者的网络地址（ip，端口）等硬编码到了代码中，这种做法存在许多问题：1.一旦服务提供者地址变化，就需要手工修改代码2. 一旦是多个服务提供者，无法实现负载均衡功能3.一旦服务变得越来越多，人工维护调用关系困难那么应该怎么解决呢，这时候就需要通过注册中心动态的实现。
java实现拼图小游戏
monkey108的博客
05-16 639
本文主要提供用java实现的拼图小游戏源代码。
SpringBoot Validation自定义注解之校验指定最小整数
最新发布
thinkers
05-21 36
1，引入核心关键依赖。
java设计模式单例模式
03-14
单例模式是一种常用的设计模式，它保证一个类只有一个实例，并提供一个全局访问点。在Java中，实现单例模式有多种方式，下面是两种常见的实现方式： 1. 饿汉式单例模式： 在类加载时就创建实例，保证了线程安全，但可能会造成资源浪费。 ```java public class Singleton { private static final Singleton instance = new Singleton(); private Singleton() {} public static Singleton getInstance() { return instance; } } ``` 2. 懒汉式单例模式： 在需要时才创建实例，避免了资源浪费，但需要考虑线程安全问题。 ```java public class Singleton { private static Singleton instance; private Singleton() {} public static synchronized Singleton getInstance() { if (instance == null) { instance = new Singleton(); } return instance; } } ``` 以上是两种常见的单例模式实现方式，根据具体需求选择适合的方式。还有其他的实现方式，比如双重检查锁定、静态内部类等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值