java重开之设计模式-（二）单例模式

最新推荐文章于 2024-08-03 21:02:21 发布

还怕大雨吗-

最新推荐文章于 2024-08-03 21:02:21 发布

阅读量142

点赞数 1

分类专栏： java设计模式文章标签： java

本文链接：https://blog.csdn.net/qsy190557020/article/details/119937249

版权

java设计模式专栏收录该内容

2 篇文章 0 订阅

订阅专栏

单例模式

单例设计模式介绍

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

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

八种实现方式

1）懒汉式（静态常量）

步骤：
- 创建构造器私有化
- 本类内部创建对象实例
- 提供公共的静态方法，返回实例 (getInstance)
代码实现：

package singleton;

/**
 * @description 生产者
 * @author -还怕大雨吗
 * @date 2021/8/26 9:52
 * @version 1.0
 */
public class SingletonTest2 {
    /***
     * 1、首先构造器私有化。
     */
    private SingletonTest2(){}
    /***
     * 2、本类内部创建对象实例
     */
    private final static SingletonTest2 SINGLETON_TEST_2n = new SingletonTest2();
    /***
     * 3、提供一个公共的静态方法，返回实例
     */
    public static SingletonTest2 getInstance(){
        return SINGLETON_TEST_2n;
    }
}

package singleton;

/**
 * @description 消费者
 * @author -还怕大雨吗
 * @date 2021/8/26 9:46
 * @version 1.0
 */
public class SingletonTest1 {
    public static void main(String[] args) {

        SingletonTest2 instance = SingletonTest2.getInstance();
        SingletonTest2 instance1 = SingletonTest2.getInstance();
        System.out.println("instance1 = " + instance1);
        System.out.println("instance = " + instance);
        System.out.println(instance==instance1);
        System.out.println("instance1.hashCode() = " + instance1.hashCode());
        System.out.println("instance.hashCode() = " + instance.hashCode());
    }


}

//日志
instance1 = singleton.SingletonTest2@4554617c
instance = singleton.SingletonTest2@4554617c
true
instance1.hashCode() = 1163157884
instance.hashCode() = 1163157884

Process finished with exit code 0

优缺点：
- 优点：写法较为简单，就是在类装载的时候就完成了实例化，避免了线程同步的问题
- 缺点：在类装载的时候就完成了实例化，没有达到Lazy Loading的效果，如果从开始到结束都没有使用到这个实例，则会造成内存浪费
- 这种方式基于ClassLoder机制避免了多线程的同步问题，不过，Instance在类装载的时候就实例化，在单例模式中大多数使用的都是调用GetInstance方法，但是导致类装载的原因有很多种，因此不能确定有其他方式（或者其他的静态方法）导致类装载，这时候初始化Instance就没有达到Lazy Loading的效果
- 这种单例模式可用，也比较简单，但是可能会造成内存浪费

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

步骤
- 将静态常量赋值换成了静态代码块赋值
代码实现
- 与静态常量相比较，换成了静态代码块

package singleton.type2;

/**
 * @description TODO
 * @author -还怕大雨吗
 * @date 2021/8/26 9:52
 * @version 1.0
 */
public class SingletonTest3 {
    /***
     * 1、首先构造器私有化。
     */
    private SingletonTest3(){

    }

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

    /***
     * 2、本类内部创建对象实例
     */
    private static SingletonTest3 SINGLETON_TEST_3n;


    /***
     * 3、提供一个公共的静态方法，返回实例
     */
    public static SingletonTest3 getInstance(){
        return SINGLETON_TEST_3n;
    }
}

优缺点说明
- 这种方式和静态常量相似，只不过将类实例化的过程放在了静态代码块中，也是在类装在的时候，就执行了静态代码块中的代码，初始化类的实例，优缺点都一样，
- 可用，但是可能会造成内存浪费

3）懒汉式（线程不安全–不推荐）

基本步骤
- 构造器私有化
- 创建对象实例，
- 提供公共静态方法，判断实例是否被创建，没有被创建的时候才去创建实例
优缺点
- 起到了Lazy Loading的效果，但是只能在单线程下使用
- 如果在多线程下，一个线程进入了if语句块，还没来的及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例，所有不能在多线程下使用
- 在实际开发中不能使用
代码实现

/***
     * 1、首先构造器私有化。
     */
    private IdlerTest2(){

    }

    /***
     * 2、本类内部创建对象实例
     */
    private static IdlerTest2 idlerTest2;

    /***
     * 3、提供一个公共的静态方法，返回实例
     */
    public static IdlerTest2 getInstance(){
        if (idlerTest2 == null){
            idlerTest2 = new IdlerTest2();
        }
        return idlerTest2;
    }

package singleton.type3;

/**
 * @description TODO
 * @author -还怕大雨吗
 * @date 2021/8/26 14:56
 * @version 1.0
 */
public class IdlerTest1 {
    public static void main(String[] args) {
        IdlerTest2 instance = IdlerTest2.getInstance();
        IdlerTest2 instance1 = IdlerTest2.getInstance();

        System.out.println("比较后 = " + (instance1 == instance));
        System.out.println("instance.hashCode() = " + instance.hashCode());
        System.out.println("instance1.hashCode() = " + instance1.hashCode());
    }


}

比较后 = true
instance.hashCode() = 1163157884
instance1.hashCode() = 1163157884

4）懒汉式（线程安全。同步方法–不推荐）

优缺点
- 比上面的多加了一个 synchronized 锁
- 解决了线程不安全的问题，每个线程想要获取类的实例的时候，执行getInstance方法都要进行同步，而其实这个方法只执行一次就可以了，后面的想要获得都是return，方法同步效率太低
- 实际开发不推荐
代码实现

   /***
     * 3、提供一个公共的静态方法，返回实例,给他上锁
     */
    public static synchronized IdlerTest2 getInstance(){
        if (idlerTest2 == null){
            idlerTest2 = new IdlerTest2();
        }
        return idlerTest2;
    }

5）懒汉式（线程安全。同步代码块 – 不能使用）

优缺点
- 这种方法本意是想要对第四种代码进行改进
- 他会遇到和上面一种一样的问题，也会产生多个实例
- 不能使用
代码实现

 /***
     * 3、提供一个公共的静态方法，返回实例,加入同步代码块中，给他上锁
     */
    public static  IdlerTest2 getInstance(){
        if (idlerTest2 == null){
            synchronized (IdlerTest2.class){
                idlerTest2 = new IdlerTest2();
            }
        }
        return idlerTest2;
    }

6）双重检查

优缺点
- Double-Check概念是多线程开发中常使用到的，如代码所示，我们进行了两次检查，这样就可以保证线程安全的
- 实例化代码只用执行一次，后面再次访问的时候，判断if的时候，直接return实例化对象，避免反复进行方法同步
- 线程安全，延迟加载，效率较高
- 在开发中比较推荐
代码实现

  private static volatile IdlerTest2 idlerTest2;
  
/***
     * 3、提供一个公共的静态方法，双重检查，解决线程安全，同时解决懒加载
     */
    public static  IdlerTest2 getInstance(){
        if (idlerTest2 == null){
            synchronized (IdlerTest2.class){
                if (idlerTest2 == null){
                    idlerTest2 = new IdlerTest2();
                }
            }
        }
        return idlerTest2;
    }

7）静态内部类

特点
- 当类加在的时候，静态内部类并不会被装配，只有调用静态内部类里方法的时候才会被装配
- 类装配的时候一定是线程安全的，并且只会装载一次
优缺点
- 这种方式采用了类装载的机制来保证初始化实例时只有一个线程
- 类的静态属性只会在第一次加在类的时候初始化，所以在这里jvm为我们保证了线程安全，类初始化的时候，别的线程无法进入
- 避免了线程不安全，延迟加载，效率高
代码实现

  /***
     * 1、首先构造器私有化。
     */
    private IdlerTest2(){

    }

    /***
     * 2、静态内部类
     */
    public static class IdlerTest2Instance{
        private static  IdlerTest2 idlerTest2 = new IdlerTest2();
    }

    /***
     * 3、提供一个公共的静态方法，双重检查
     */
    public static  IdlerTest2 getInstance(){
        return IdlerTest2Instance.idlerTest2;
    }

8）枚举

优缺点
- 借助JDK1.5中添加的枚举来实现单例模式，不仅能避免多线程同步，而且还能防止反序列化重新创建新的对象
- 是java作者提倡的方式
代码实现

package singleton.type3;

import singleton.type2.SingletonTest3;

/**
 * @description TODO
 * @author -还怕大雨吗
 * @date 2021/8/26 14:56
 * @version 1.0
 */
public enum IdlerTest2 {
    IDLERTEST2;

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

}

   public static void main(String[] args) {
        IdlerTest2 idlertest2 = IdlerTest2.IDLERTEST2;
        IdlerTest2 idlertest21 = IdlerTest2.IDLERTEST2;

        System.out.println("比较后 = " + (idlertest2 == idlertest21));
        System.out.println("idlertest2.hashCode() = " + idlertest2.hashCode());
        System.out.println("idlertest21.hashCode() = " + idlertest21.hashCode());
    }

比较后 = true
idlertest2.hashCode() = 1163157884
idlertest21.hashCode() = 1163157884

在JDK的使用

在JDK中，java.lang.Runtime 是经典的单例模式

代码是不是很熟悉

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7o6eW7qM-1629971657007)(单例模式.assets/1629963710964.png)]

注意事项和细节说明

单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能。
当想要实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是直接使用new
单例模式使用的场景：
需要频繁进行创建和销毁的对象、
创建对象时耗损过多或者耗时过多的（重量级对象）
ashCode() = 1163157884
idlertest21.hashCode() = 1163157884

在JDK的使用

在JDK中，java.lang.Runtime 是经典的单例模式

代码是不是很熟悉
在这里插入图片描述

注意事项和细节说明

单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能。
当想要实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是直接使用new
单例模式使用的场景：
需要频繁进行创建和销毁的对象、
创建对象时耗损过多或者耗时过多的（重量级对象）
经常用到的对象，工具类对象，频繁访问数据库或者文件的对象，比如数据源或者Session工厂等等

还怕大雨吗-

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java重开之设计模式-（二）单例模式

单例模式单例设计模式介绍所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某一个类只能存在一个对象实例，并且该类只提供一个读取其对象实例的方法（静态方法）比如Hibemate的SessionFactory，他充当数据存储源的代理，并负责创建Sessioon对象，SessionFactory并不是轻量级的，一般情况下，一个项目通常只需要一个SessionFactory就够了，这就会用到单例模式八种实现方式1）懒汉式（静态常量）步骤：创建构造器私有化本类内部创建对象实
复制链接

扫一扫

专栏目录