欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

单例模式的五种写法

程序员文章站 2022-07-13 23:42:16
...

单例模式的五种写法(转载)

作者:长木木弓

原文链接:https://www.cnblogs.com/zzjlxy-225223/p/11272775.html

1. 什么是单例模式

单例模式就是保证一个类只有一个实例,而且自行实例化并向整个系统提供这个实例。

2. 单例模式的特点

  1. 保证一个类只有一个实例;
  2. 在类中自己实例化自己;
  3. 向整个系统提供这个实例。

3. 单例模式的优点

  1. 由于单例模式只生成一个实例,所以能减少系统性能的开销;
  2. 避免对共享资源的多重占用导致的性能损耗,如日志文件,应用配置;
  3. 提供了对唯一实例的受控访问,加快对象访问速度,比如多线程的线程池的设计,方便对池中的线程进行控制。

4. 单例模式的五种实现

4.1 饿汉式

/**
 * 饿汉式单例模式
 */
public class Singleton01 {
    /** 类加载时,立即加载这个对象,也是叫饿汉的原因
     *  这也保证了线程的安全
     *  ----------------->在类中自己实例化自己
     */
    private static Singleton01 singleton01 = new Singleton01();

    /** 私有构造器
     *  ----------------->保证一个类只有一个实例
     */
    private Singleton01() {
    }

    /** 因为不需要加同步代码块就能保证线程安全,所以效率会高
     *  ----------------->向整个系统提供这个实例
     * @return 返回实例
     */
    public Singleton01 getSingleton01() {
        return singleton01;
    }
}

可以看出,饿汉式的优点有:线程安全,调用效率高;但因为加载类时立即实例化,所以没有延时加载的优势,并且当没有用到这个实例的话,就会白白实例化个对象,浪费资源。

4.2 懒汉式

package com.hwj.Singleton;

/**
 * 懒汉式单例模式
 */
public class Singleton02 {
    /**
     *  提供静态属性,加载类时不会实例化对象
     */
    private static Singleton02 singleton02;

    /**
     * 私有构造器
     */
    private Singleton02() {
    }

    /**
     *  第一次调用才会实例化对象,并且之后不会再实例化,直接返回第一次是创建的对象
     *  通过添加关键字 synchronized 来保证线程安全,但因为线程等待的缘故,效率会降低
     *  只有用到才创建对象,所以叫懒汉式,故而资源利用率提高了
     * @return
     */
    public static synchronized Singleton02 getSingleton02() {
        if (singleton02 == null) {
            singleton02 = new Singleton02();
        }
        return singleton02;
    }
}

可以看出,懒汉式单例模式的优点有:资源利用率高了,有延时加载的优势,线程安全;但调用效率低。

4.3 静态内部类式

/**
 * 静态内部类式单例模式
 */
public class Singleton03 {
    /** 只有第一次调用getInstance()方法时,虚拟机才加载 Inner,并初始化instance,具有延时加载的优势
     *  只有一个线程可以获得对象的初始化锁,其他线程无法进行初始化,所以线程安全且保证了对象的唯一性
     */
    private static class Inner {
        private static Singleton03 instance = new Singleton03();
    }

    /**
     * 私有构造器
     */
    private Singleton03() {
    }


    public static Singleton03 getInstance() {
        return Inner.instance;
    }
}

总结下,静态内部类方式的优点有线程安全,具有延时加载的优势,而且没有使用同步代码,资源利用率也高。

4.4 双重锁式

/**
 * 双重锁式单例模式
 */
public class Singleton04 {

    /**
     *  提供静态属性,加载类时不会实例化对象
     *  volatile修饰的变量不允许线程内部缓存和重排序
     */
    private volatile static  Singleton04 singleton04;

    /**
     *  私有化构造器
     */
    private Singleton04() {
    }

    /** 双重锁式单例模式,进行了两次的判断。
     *  第一次是为了避免创建不必要的实例;
     *  第二次是为了进行同步,避免多线程问题。
     * @return 返回实例
     */
    public static Singleton04 getSingleton04() {
        if (singleton04 == null) {
            synchronized (Singleton04.class){
                if (singleton04 == null) {
                    singleton04 = new Singleton04();
                }
            }
        }
        return singleton04;
    }
}

由于singleton04= new Singleton04()对象的创建在JVM中可能会进行重排序,在多线程访问下存在风险,使用volatile修饰signleton04实例变量能有效解决该问题。

总结:双重锁式既保证了线程安全,又比直接上锁提高了执行效率,具有延迟加载的优势,资源利用率高。

4.5 枚举式

/**
 * 枚举式单例模式
 */
public enum  Singleton05 {
    // 这个枚举元素,本身就是单例对象
    INSTANCE;
    // 添加自己需要的操作
    public void singletonOperation(){
    }
}

总结:实现简单,枚举本身就是单例,由 JVM 从根本上提供保障,避免通过反射和反序列化的漏洞!但没有延迟加载!

5.如何选择

下面来说说如何选择上面几种单例模式的:

  1. 占用资源少,不需要延时加载,枚举式好于饿汉式;
  2. 占用资源多,需要延时加载,静态内部类式好于懒汉式。
相关标签: 个人笔记