【转载】设计模式-单例模式的几种实现

单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的一个类只有一个实例，即一个类只有一个对象实例。 – 百度百科

问题的由来

多个线程要操作同一对象，需要保证对象的唯一性。

解决思路

• 该类的构造方法为私有，防止外部实例化该类的对象
• 该类中要有一个对象实例化过程（只有一次）
• 该类需要提供返回实例对象的方法

解决方案

为了更好的对下面即将介绍的几种实现方式进行比较，我们定义几个考量维度：线程的安全线、是否懒加载、性能。

方法一：饿汉式单例模式【可用】

public class BadmashSingleton {
    // 在类加载的时候即被实例化
    private static BadmashSingleton instance = new BadmashSingleton();
    private BadmashSingleton() {
    }

    public static BadmashSingleton getInstance() {
        return instance;
    }
}

• 线程安全性： 实例在类加载的时候即被实例化，因此线程安全。
• 是否懒加载： 没有延迟加载，如果长时间没用到这个实例，则会造成内存的浪费。
• 性能： 性能比较好

方法二：懒汉式单例模式【多线程有问题】

public class IdlerSingleton {
    private static IdlerSingleton instance = null;
    private IdlerSingleton() {
    }
	// 在使用时才进行加载
    public static IdlerSingleton getInstance() {
        if (null == instance) {
            instance = new IdlerSingleton();
        }
        return instance;
    }
}

• 线程安全性： 单线程下没有问题，多线程下有可能会生成多个实例，因此线程不安全。
  • 问题出现在if (null == instance)这一步，多线程环境中可能会有多个线程同时拿到instance的值为null。
• 是否懒加载： 懒加载
• 性能： 性能比较好

方法三：懒汉式单例模式+同步方法【性能差，不推荐使用】

public class IdlerSynSingleton {
    private static IdlerSynSingleton instance = null;
    private IdlerSynSingleton() {
    }

    public static synchronized IdlerSynSingleton getInstance() {
        if (null == instance) {
        	instance = new IdlerSynSingleton();
        }
        return instance;
    }
}

• 线程安全性： 线程安全
• 是否懒加载： 懒加载
• 性能： synchronized修饰方法，使得多线程执行退化为串行执行，性能差

方法四：懒汉式单例模式+同步代码块【不可用】

该方法是对上面方法的一个优化，将同步方法改为同步代码块。

public class IdlerSynSingleton {
    private static IdlerSynSingleton instance = null;
    private IdlerSynSingleton() {
    }

    public static IdlerSynSingleton getInstance() {
        if (null == instance) {
            synchronized (IdlerSynSingleton.class) {
                instance = new IdlerSynSingleton();
            }
        }
        return instance;
    }
}

• 线程安全性： 单线程下没有问题，多线程下有可能会生成多个实例，因此线程不安全。
  • 问题同样出现在if (null == instance)这一步
• 是否懒加载： 懒加载
• 性能： 性能一般

方法五：DCL单例模式+Volatile【可用】

为了解决方法四存在的线程不安全问题，我们引入双重锁，即Double-Check-Locking。同时引入volatile关键字修饰实例对象，这是为了避免因JVM指令重排序可能导致的空指针异常。因为当线程执行到第一个if (null == instance)时，代码可能读取到instance不为null，但此时instance引用的对象可能还没有完成初始化。

public class DCLSingleton {
    private static volatile DCLSingleton instance = null;
    private DCLSingleton() {
    }

    public static DCLSingleton getInstance() {
        if (null == instance) {
            synchronized (DCLSingleton.class) {
                if (null == instance) {
                    instance = new DCLSingleton();
                }
            }
        }
        return instance;
    }
}

• 线程安全性： 线程安全性
• 是否懒加载： 懒加载
• 性能： 性能比较好

方法六：Holder单例模式【推荐】

声明类时，成员变量中不声明实例变量，而是放到静态内部类中。这种方式和懒汉式有些相似，它们都采用了类装载的机制来保证初始化实例时只有一个线程，不同的是，Holder单例模式是将实例的初始化放到了静态类中去实现，从而实现了懒加载。

public class HolderSingleton {
    private static HolderSingleton instance = null;
    private HolderSingleton() {
    }

    public static HolderSingleton getInstance() {
        return Holder.instance;
    }

    private static class Holder {
        private static HolderSingleton instance = new HolderSingleton();
    }
}

• 线程安全性： 线程安全性
• 是否懒加载： 懒加载
• 性能： 性能好

方法七：Enum单例模式【推荐】

借助了enum枚举类的特性，直接解决了多线程同步问题。

public class EnumSingleton {
    private EnumSingleton() {
    }

    public static EnumSingleton getInstance() {
        return EnumHolder.INSTANCE.getInstance();
    }

    private enum EnumHolder {
        INSTANCE;
        private EnumSingleton instance = null;

        private EnumHolder() {
            instance = new EnumSingleton();
        }

        private EnumSingleton getInstance() {
            return instance;
        }
    }
}

• 线程安全性： 线程安全性
• 是否懒加载： 懒加载
• 性能： 性能好

总结

本文共列举了七种单例模式的实现方式，推荐使用后面两种方式。

---