单例模式的五种写法

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

作者：长木木弓

原文链接：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. 占用资源多，需要延时加载，静态内部类式好于懒汉式。