五种单例模式的实现

单例模式

在有些系统中，为了节省内存资源、保证数据内容的一致性，对某些类要求只能创建一个实例，这就是所谓的单例模式。

单例模式优点和缺点

优点：

单例模式可以保证内存里只有一个实例，减少了内存的开销。
可以避免对资源的多重占用。
单例模式设置全局访问点，可以优化和共享资源的访问。缺点：
单例模式一般没有接口，扩展困难。如果要扩展，则除了修改原来的代码，没有第二种途径，违背开闭原则。
在并发测试中，单例模式不利于代码调试。在调试过程中，如果单例中的代码没有执行完，也不能模拟生成一个新的对象。
单例模式的功能代码通常写在一个类中，如果功能设计不合理，则很容易违背单一职责原则。

单例模式的应用场景

需要频繁创建的一些类，使用单例可以降低系统的内存压力，减少 GC。
某类需要频繁实例化，而创建的对象又频繁被销毁的时候，如多线程的线程池、网络连接池等。
频繁访问数据库或文件的对象。
当对象需要被共享的场合。由于单例模式只允许创建一个对象，共享该对象可以节省内存，并加快对象访问速度。如 Web 中的配置对象、数据库的连接池等。

实现单例的模式的几种方式

饿汉模式
懒汉模式
DCL双端检锁机制
枚举模式
静态内部类模式

实例代码

点击

package com.llh.advance.design;

/**
 * @author lviter
 * 单例模式的四种实现：
 * 1. 饿汉
 * 2. 懒汉
 * 3. DCL双端检锁机制
 * 4. 静态内部类
 * 5. 枚举模式
 */
public class Singleton {
    public static void main(String[] args) {
        SingletonEnum s1 = SingletonEnum.INSTANCE.getInstance();
        SingletonEnum s2 = SingletonEnum.INSTANCE.getInstance();
        System.out.println(s1 == s2);
    }
}

/**
 * 懒汉式--线程不安全
 */
class SingletonLazy {
    private static SingletonLazy singletonLazy = null;

    private SingletonLazy() {
        System.out.println("懒汉式---线程不安全的构造方法");
    }

    public static SingletonLazy getSingletonLazy() {
        if (singletonLazy == null) {
            return new SingletonLazy();
        }
        return singletonLazy;
    }
}

/**
 * 饿汉式
 * 没有加锁，执行效率会提高。缺点是类加载时就初始化，浪费内存
 * 基于classloder机制避免了多线程的同步问题
 */
class SingletonHungry {
    private static final SingletonHungry singletonHungry = new SingletonHungry();

    private SingletonHungry() {
        System.out.println("饿汉式");
    }

    public static SingletonHungry getSingletonHungry() {
        return singletonHungry;
    }
}

/**
 * DCL:double check lock,双端检锁机制--在同步锁前后都增加检查操作
 * 多线程安全，采用双锁机制，安全且在多线程下保持高性能。
 */
class SingletonDcl {

    private volatile static SingletonDcl singletonDcl;

    private SingletonDcl() {
        System.out.println("DCL双端检锁--线程安全，支持高性能");
    }

    /**
     * 同步锁前后都增加检查
     *
     * @return
     */
    public static SingletonDcl getSingletonDcl() {
        if (singletonDcl == null) {
            synchronized (SingletonDcl.class) {
                if (singletonDcl == null) {
                    singletonDcl = new SingletonDcl();
                }
            }
        }
        return singletonDcl;
    }
}

/**
 * 静态内部类的构造方法只会在调用他的时候触发，所以是线程安全的
 */
class SingletonStaticInternal {

    private SingletonStaticInternal() {
        System.out.println("这里是静态内部类的方式");
    }

    private static class holder {
        private static final SingletonStaticInternal instance = new SingletonStaticInternal();
    }

    public static SingletonStaticInternal getInstance() {
        return holder.instance;
    }
}

/**
 * 枚举单例(单例模式的最佳实现方法)
 * 既可以避免多线程同步问题；还可以防止通过反射和反序列化来重新创建新的对象
 */
enum SingletonEnum {
    /**
     * 单例
     */
    INSTANCE;

    public SingletonEnum getInstance() {
        return INSTANCE;
    }

    public void m() {
        System.out.println("枚举类");
    }
}

llh