设计模式之单例模式

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

单例模式

23种设计模式中最简单的设计模式，在项目中只需要一个对象且该类只提供一个取得对象实例的方法（静态方法）
一般分为饿汉式和懒汉式，两者各有优缺点，一般来说，我认为饿汉式的优点相对于缺点来说更加显著，代码也更加简单

  • 饿汉式：顾名思义，在类加载时就new出来了单例对象

    • 静态常量
      	public class SingtonTest1 {
	    public static void main(String[] args) {
	        for(int i =0;i<100;i++){
	           new Thread(new Runnable() {
	               public void run() {
	                   Singleton1 instance = Singleton1.getInstance();
	                   System.out.println(instance.hashCode());
	               }
	           }).start();
	
	        }
	
	    }
	
	}
	
	class Singleton1{
	    private final static Singleton1 SINGLETON_1 = new Singleton1();
	
	    private Singleton1() {
	    }
	
	    public static  Singleton1 getInstance(){
	        try {
	            Thread.sleep(1000);
	        } catch (InterruptedException e) {
	            e.printStackTrace();
	        }
	        return SINGLETON_1;
	    }
	}
优缺点说明：
1)优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。
2) 缺点：在类装载的时候就完成实例化，没有达到 Lazy Loading 的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费
3) 这种方式基于 classloder 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，在单例模式中大多数都是调用 getInstance 方法， 但是导致类装载的原因有很多种，因此不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 就没有达到 lazy loading 的效果
4) 结论：这种单例模式可用，可能造成内存浪费
    • 静态代码块
      public class SingletonTest2 {
    public static void main(String[] args) {
        for(int i =0;i<100;i++){
            new Thread(new Runnable() {
                public void run() {
                    Singleton2 instance = Singleton2.getInstance();
                    System.out.println(instance.hashCode());
                }
            }).start();

        }
    }
}

class Singleton2{
    private static Singleton2 singleton2;
    static {
        singleton2 = new Singleton2();
    }
    private Singleton2() {
    }

    public static  Singleton2 getInstance(){
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return singleton2;
    }
}
优缺点说明：
1)这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。优缺点和上面是一样的。
2)结论：这种单例模式可用，但是可能造成内存浪费

  • 懒汉式（线程不安全）

    public class SingletonTest3 {
    public static void main(String[] args) {
        for(int i =0;i<100;i++){
            new Thread(new Runnable() {
                public void run() {
                    Singleton instance = Singleton.getInstance();
                    System.out.println(instance.hashCode());
                }
            }).start();

        }
    }
}

class Singleton{
    private static Singleton singleton;
    private Singleton(){

    }

    public static Singleton getInstance(){
        if(singleton == null){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            singleton = new Singleton();
        }

        return singleton;
    }
}
//打印出来的hashCode不一致，说明懒汉式得出的单例并非单例对象，线程不安全
优缺点说明：

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

  • 懒汉式(线程安全，同步方法)

    	public class SingletonTest3 {
    public static void main(String[] args) {
        for(int i =0;i<100;i++){
            new Thread(new Runnable() {
                public void run() {
                    Singleton instance = Singleton.getInstance();
                    System.out.println(instance.hashCode());
                }
            }).start();

        }
    }
}

class Singleton{
    private static Singleton singleton;
    private Singleton(){

    }

    public static synchronized Singleton getInstance(){
        if(singleton == null){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            singleton = new Singleton();
        }

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

  • 懒汉式(线程安全，同步代码块)

    	public class SingletonTest4 {
    public static void main(String[] args) {
        for(int i =0;i<100;i++){
            new Thread(new Runnable() {
                public void run() {
                    Singleton4 instance = Singleton4.getInstance();
                    System.out.println(instance.hashCode());
                }
            }).start();

        }
    }
}

class Singleton4{
    private static Singleton4 singleton4;
    private Singleton4(){

    }

    public static Singleton4 getInstance(){
        if (singleton4 == null){
            try {
                Thread.sleep(1000);
                synchronized (Singleton4.class){
                    singleton4 = new Singleton4();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
        return singleton4;
    }
}
//看似线程安全，其实线程不安全，不推荐使用

  • 懒汉之双重检查

    	public class SingletonTest5 {
    public static void main(String[] args) {
        for(int i =0;i<100;i++){
            new Thread(new Runnable() {
                public void run() {
                    Singleton5 instance = Singleton5.getInstance();
                    System.out.println(instance.hashCode());
                }
            }).start();

        }
    }
}

class Singleton5{
    private static volatile Singleton5 singleton5;
    private Singleton5(){

    }

    public static Singleton5 getInstance(){
       if (singleton5 == null){
           try {
               Thread.sleep(1000);
               synchronized (Singleton5.class){
                   if (singleton5 == null){
                    singleton5 = new Singleton5();
                   }
               }
           } catch (InterruptedException e) {
               e.printStackTrace();
           }

       }
        return singleton5;
    }

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

  • 懒汉之静态内部类

    	public class SingletonTest7 {
    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(new Runnable() {
                public void run() {
                    Singleton7 instance = Singleton7.getInstance();
                    System.out.println(instance.hashCode());
                }
            }).start();

        }
    }
}

class Singleton7{
    private static Singleton7 singleton7;
    private Singleton7(){

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

  • 枚举

    public class SingletonTest8 {
public static void main(String[] args) {
    for (int i = 0; i < 100; i++) {
        new Thread(new Runnable() {
            public void run() {
                Singleton8 instance = Singleton8.INSTANCE;
                System.out.println(instance.hashCode());
                instance.show();
            }
        }).start();

    }

}
}

enum  Singleton8{
    INSTANCE;
    void show(){
        System.out.println("show");
    }

}
优缺点说明：
1)这借助 JDK1.5 中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。
2)这种方式是 Effective Java 作者 Josh Bloch  提倡的方式
3)结论：推荐使用
lovefive55
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java设计模式之单例模式
Simon学Java
02-09 1045
单例模式是结构最简单的设计模式，在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于被外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。单例模式(Singleton Pattern)定义：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。
JAVA设计模式之单例模式
09-22
单例模式是软件设计模式中的一种经典模式，它在Java编程中被广泛使用，尤其是在需要控制实例化过程，或者确保某类只有一个实例时。本文将深入探讨Java中的单例模式，帮助你理解其原理和应用。 单例模式的核心思想是...
PHP语言设计模式之单例模式
低头赶路，敬事如仪
12-03 755
第1关：饿汉式
设计模式之单例模式(C++)
翟天保的博客
02-09 2万+
介绍设计模式之单例模式
快速理解设计模式：单例模式深入
热门推荐
张彦峰的博客
04-21 169万+
单例模式是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。实现方式介绍分析：饿汉式单例模式+懒汉式单例模式（双重检查锁）+静态内部类实现单例模式+注册式单例模式
java设计模式之单例模式
liu_da_da的博客
06-23 1万+
java设计模式之单例模式
设计模式之单例模式（七种方法超详细）
weixin_63834061的博客
04-22 1万+
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一，这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象，也就是说不能使用new关键字来创建对象。
PHP设计模式之单例模式定义与用法分析
01-03
单例模式（Singleton Pattern 单件模式或单元素模式），是常见的一种设计模式，它有三个特点 1．只能有一个实例 2．必须自行创建这个实例 3．必须给其他对象提供这一实例 下面用PHP代码实现一下 <?PHP /** *...
golang 接口
m0_70982551的博客
07-24 850
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 378
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 530
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
最新发布
訾博（ZiBo）的博客
07-27 460
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 340
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 392
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
学习笔记---java篇（0723）
m0_70630166的博客
07-23 824
java、数据类型、循环、选择等
深入理解设计模式：单例模式解析
"研磨设计模式之单例模式" 在软件工程中，设计模式是一种解决常见问题的可重用方案，而单例模式是其中最常用的一种。单例模式确保一个类只有一个实例，并提供一个全局访问点，使得这个唯一实例可以被整个系统方便地...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值