设计模式--单例模式

暗武逢天

已于 2023-04-20 10:06:05 修改

阅读量609

点赞数

文章标签：单例模式 java 开发语言设计模式

于 2023-04-19 22:42:39 首次发布

本文链接：https://blog.csdn.net/m0_51406695/article/details/130253801

版权

文章详细介绍了Java中实现单例模式的八种方法，包括饿汉式（静态常量和静态代码块）、懒汉式（线程不安全和线程安全的同步方法及代码块）、双重检查、静态内部类以及枚举方式。每种方式的优缺点都被讨论，强调了线程安全和懒加载的重要性，推荐使用双重检查和静态内部类或枚举实现单例模式。

摘要由CSDN通过智能技术生成

介绍

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

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

单例模式的八种实现方式

饿汉式(静态常量)

public class HungryMan1 {
    //1 构造器私有话 外部不能直接new对象调用
    private HungryMan1(){}

    //2 本类内部创建对象实例
    private final static HungryMan1 instance = new HungryMan1();
    //3 提供一个公有的静态方法 返回实例对象
    public static HungryMan1 getInstance(){
        return instance;
    }
}

public class HungryManTest {
    public static void main(String[] args) {
        HungryMan1 instanbce = HungryMan1.getInstance();
        HungryMan1 instabce2 = HungryMan1.getInstance();
        System.out.println(instanbce == instabce2);
        System.out.println(instanbce.hashCode());
        System.out.println(instabce2.hashCode());
    }
}

测试结果

优缺点说明:

(1) 优点: 这种写法比较简单, 就是在类装载的时候就完成了实例化避免了线程同步问题

(2) 缺点: 在类装载的时候就完车实例化没有达到lazy loading(懒加载)的效果如果从始至终从未使用过这个实例则会造成内存浪费

(3) 这种方式基于classloader(类装载器)机制避免了线程同步问题不过,instance在类装载时就实例化在单例模式中大多数都是调用getInstance方法但是导致类装载的原因有很多种因此不能确定有其他的方式(或者其他的静态方法) 导致类装载这时候初始化instance就没有达到lazy loading的效果

(4) 结论: 推荐使用,但是可能会造成内存浪费

在jdk java.lang.Runtime#getRuntime()的源码中就是使用的饿汉式的单例模式

饿汉式(静态代码块)

public class HungryMan2 {
    private HungryMan2(){}

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

    //2 本类内部创建对象实例
    private final static HungryMan2 instance;
    //3 提供一个公有的静态方法 返回实例对象
    public static HungryMan2 getInstance(){
        return instance;
    }
}

测试同 "饿汉式静态常量"一致

优缺点说明

(1) 这种方式和上面的方法类似只不过将类实例化的过程放在了静态代码块中,也是在类装载的时候就执行了静态代码块中的代码初始化类的实例优缺点和上面是一样的

(2) 结论:推荐使用,但是可能造成内存浪费

懒汉式(线程不安全)

public class LazyMan1 {
    private static LazyMan1 instance;

    private LazyMan1(){};

    //提供一个静态的公有方法 当使用到该方法时 才会去创建 instance
    public static LazyMan1 getInstance(){
        if(instance==null){
            instance = new LazyMan1();
        }
        //等价于 jdk8 Optional写法
//        Optional.ofNullable(instance).orElseGet(()->new LazyMan1());
        return instance;
    }
}

测试同 "饿汉式静态常量"一致

优缺点说明

(1) 解决了lazy loading的问题但是只能在单线程下使用如果是多线程可能会造成线程安全问题

(2) 如果再多线程下一个线程进入了 if(instance==null)的判断语句块还没来的及往下执行另一个线程也通过了这个判断语句,此时就会产生多个实例所以在多线程环境下不可以使用这种方式

(3) 结论: 在实际开发中不要使用这种方式

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

public class LazyMan2 {
    private static LazyMan2 instance;

    private LazyMan2(){};

    //提供一个静态的公有方法 加入同步处理的代码 解决线程安全问题
    public static synchronized LazyMan2 getInstance(){
        if(instance==null){
            instance = new LazyMan2();
        }
        return instance;
    }
}

测试同 "饿汉式静态常量"一致

优缺点说明

(1) 解决了线程不安全问题

(2) 效率低每个线程在想获得类的实例的时候执行getInstance()方法都要进行同步而其实这个方法只需要执行一次实例化代码就可以了后面的想获得该类实例直接return就可以了方法进行同步效率太低

(3) 结论: 在实际开发中不推荐使用

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

public class LazyMan3 {
    private static LazyMan3 instance;

    private LazyMan3(){};

    //提供一个静态的公有方法 加入同步处理的代码 解决线程安全问题
    public static LazyMan3 getInstance(){
        if(instance==null){
            synchronized(LazyMan3.class){
                instance = new LazyMan3();
            }
        }
        return instance;
    }
}

测试同 "饿汉式静态常量"一致

优缺点说明

(1) 这种方式本意是想对懒汉式(线程安全同步方法)的改进,因为同步方法效率太低改为同步产生实例化的代码块

(2) 但是这种同步不能起到线程同步的作用跟懒汉式(线程不安全) 遇到的情形一致假如一个线程进入了 if(instance==null) 判断语句块还没来得及往下执行另一个线程也通过了这个判断语句这时便会产生多个实例

(3) 结论: 在实际开发中不要用这种方式

双重检查

public class LazyMan4 {
    private static volatile LazyMan4 instance;

    private LazyMan4(){};

    //提供一个静态的公有方法 加入双重检查代码 解决线程安全问题 同时解决懒加载问题
    public static synchronized LazyMan4 getInstance(){
        if(instance==null){
            synchronized(LazyMan4.class){
                if(instance==null){
                    instance = new LazyMan4();
                }
            }
        }
        return instance;
    }
}

测试同 "饿汉式静态常量"一致

优缺点说明

(1) double-check 概念是多线程开发中常使用到的如代码中所示进行了两次 if(instance==null)检查这样就可以保证线程安全了

(2) 这样实例化代码只用执行一次后面再次访问时判断 if(instance==null),直接return实例化对象也避免的反复进行方法同步

(3) 线程安全延迟加载效率较高

(4) 结论: 在实际开发中推荐使用

静态内部类

public class LazyMan5 {
    private LazyMan5(){};

    //书写静态内部类 该类中有一个静态属性 LazyManInstance
    private static class LasyManInstance{
        private static final LazyMan5 INSTANCE = new LazyMan5();
    }

    //提供一个静态公有方法 直接返回LazyManInstance.INSTANCE
    public static synchronized LazyMan5 getInstance(){
        return LasyManInstance.INSTANCE;
    }
}

测试同 "饿汉式静态常量"一致

优缺点说明

(1) 这种方式采用了类装载的机制来保证初始化实例时只有一个线程

(2) 静态内部类方式在LazyMan5类被装载时并不会立即实例化而是在需要实例时调用 getInstance方法才会装载LazyManInstance类从而完成LazyMan5的实例化

(3) 类的静态属性只会在第一次加载类的时候初始化所以在这里是jvm帮我们保证了线程的安全性在类进行初始化时别的线程是无法进入的

(4) 解决了线程安全问题利用静态内部类特点实现延迟加载效率高

(5)结论: 推荐使用

枚举

public class HungryManTest {
    public static void main(String[] args) {
        LazyMan6 in = LazyMan6.INSTANCE;
        LazyMan6 in2 = LazyMan6.INSTANCE;
        in.sayHello();
        System.out.println(in==in2);
    }
}
enum LazyMan6 {
    INSTANCE;
    public void sayHello(){
        System.out.println("hello world!");
    }
}

测试: