史上最全讲解单例模式以及分析源码中的应用

智数浮尘
• 阅读 586

1、单例模式介绍

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

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

2、单例模式的种类

  • 饿汉式（静态常量）
  • 饿汉式（静态代码块）
  • 懒汉式（线程不安全）
  • 懒汉式（线程安全，同步方法）
  • 懒汉式（线程安全，同步代码块）
  • 双重检查
  • 静态内部类
  • 枚举

1、饿汉式（静态常量）

步骤：

  • 构造方法私有化
  • 内的内部创建对象
  • 向外暴露一个静态的公共方法
public class Singleton01 {
    
    private static final Singleton01 INSTANCE = new Singleton01();

    /**
     * 构造方法私有化，防止new
     */
    private Singleton01(){

    }

    /**
     * 提供一个公有的静态方法，返回实例对象
     * @return INSTANCE
     */
    public static Singleton01 getINSTANCE() {
        return INSTANCE;
    }

    public static void main(String[] args) {
        Singleton01 instance1 = Singleton01.getINSTANCE();
        Singleton01 instance2 = Singleton01.getINSTANCE();
        System.out.println(instance1 == instance2);
        System.out.println("instance1.hashCode = " + instance1.hashCode());
        System.out.println("instance2.hashCode = " + instance2.hashCode());
    }
}

优缺点：

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

缺点：在类装载的时候就完成实例化，没有达到Lazy Loading 的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费

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

破坏单例的情形
  • 反射破坏单例：利用反射创建实例对象
  • 反序列化破坏单例：前提是实现了implements Serializable接口
  • Unsafe 破坏单例：这种情形是不能避免的
1、反射破坏单例
利用反射获取类的构造方法
private static void reflection(Class<?> clazz) throws NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
    Constructor<?> constructor = clazz.getDeclaredConstructor();
    constructor.setAccessible(true);
    System.out.println("反射创建实例:" + constructor.newInstance());
}

如何避免呢？

调用的时候加一层判断，如果创建了，则返回原实例或者抛出异常
private Singleton1() {
    if (INSTANCE != null) {
        throw new RuntimeException("单例对象不能重复创建");
    }
    System.out.println("private Singleton1()");
}
2、反序列化破坏单例
通过对象输出流将对象转成为字节流，再通过ByteArrayInputStream方法将字节流转为对象
private static void serializable(Object instance) throws IOException, ClassNotFoundException {
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    ObjectOutputStream oos = new ObjectOutputStream(bos);
    oos.writeObject(instance);
    ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray()));
    System.out.println("反序列化创建实例:" + ois.readObject());
}

如何避免呢？

//方法名是固定的
public Object readResolve() {
    return INSTANCE;
}
3、Unsafe 破坏单例
通过反射调用JDK内置的Unsafe方法破坏单例
private static void unsafe(Class<?> clazz) throws InstantiationException {
    Object o = UnsafeUtils.getUnsafe().allocateInstance(clazz);
    System.out.println("Unsafe 创建实例:" + o);
}

如何避免呢？

暂时还没有找到解决的方法，大佬们知道如何解决吗？

总结：这种单例模式可用，可能造成内存浪费，启动就创建对象实例

2、饿汉式（静态代码块）

public class Singleton02 {

    private static final Singleton02 INSTANCE ;

    /**
     * 在静态代码块中，创建单例对象
     */
    static {
        INSTANCE = new Singleton02();
    }

    /**
     * 构造方法私有化，防止new
     */
    private Singleton02(){

    }

    /**
     * 提供一个公有的静态方法，返回实例对象
     * @return INSTANCE
     */
    public static Singleton02 getINSTANCE() {
        return INSTANCE;
    }

    public static void main(String[] args) {
        Singleton02 instance1 = Singleton02.getINSTANCE();
        Singleton02 instance2 = Singleton02.getINSTANCE();
        System.out.println(instance1 == instance2);
        System.out.println("instance1.hashCode = " + instance1.hashCode());
        System.out.println("instance2.hashCode = " + instance2.hashCode());
    }
}

优缺点：

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

总结：这种单例模式可用，但是可能造成内存浪费

3、懒汉式（线程不安全）

public class Singleton03 {

    private static Singleton03 INSTANCE ;

    /**
     * 构造方法私有化，防止new
     */
    private Singleton03(){

    }

    /**
     * 提供一个静态的公有方法，当使用到该方法时，才去创建instance
     * @return INSTANCE
     */
    public static Singleton03 getINSTANCE() {
        if (INSTANCE == null) {
            INSTANCE = new Singleton03();
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        //模拟1000个线程访问
        for (int i = 0; i < 1000; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("instance.hashCode= " + Singleton03.getINSTANCE().hashCode());
                }
            }).start();
        }
    }
}

优缺点：

达到了Lazy Loading 的效果，但是只能在单线程下使用。

如果在多线程下，一个线程进入了if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式。

结论：在实际开发中，不要使用这种方式.

4、懒汉式（线程安全，同步方法）

public class Singleton04 {

    private static Singleton04 INSTANCE ;

    /**
     * 构造方法私有化，防止new
     */
    private Singleton04(){

    }

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

    public static void main(String[] args) {
        for (int i = 0; i < 1000; i++) {
            new Thread(() ->{
                System.out.println("instance.hashCode= " + Singleton03.getINSTANCE().hashCode());
            }).start();
        }
    }
}

优缺点：

解决了线程安全问题，给公有方法加上了锁

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

结论：在实际开发中，不推荐使用这种方式

5、懒汉式（线程安全，同步代码块）

public class Singleton05 {

    private static Singleton05 INSTANCE ;

    /**
     * 构造方法私有化，防止new
     */
    private Singleton05(){

    }

    /**
     * 提供一个静态的公有方法，加入同步处理的代码，解决线程安全问题
     * @return INSTANCE
     */
    public static Singleton05 getINSTANCE() {
        if (INSTANCE == null) {
            //同步代码块
            synchronized (Singleton03.class){
                INSTANCE = new Singleton05();
            }
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 1000; i++) {
            new Thread(() ->{
                System.out.println("instance.hashCode= " + Singleton03.getINSTANCE().hashCode());
            }).start();
        }
    }
}

优缺点：

通过试图同步代码块来提高效率，解决线程安全

但事实上不可行，如果在多线程下，一个线程进入了if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式。

6、双重检查

public class Singleton06 {

    private static volatile Singleton06 INSTANCE ;

    /**
     * 构造方法私有化，防止new
     */
    private Singleton06(){

    }

    /**
     * 提供一个静态的公有方法，加入双重检查代码，解决线程安全问题, 同时解决懒加载问题
     * @return INSTANCE
     */
    public static Singleton06 getINSTANCE() {
        if (INSTANCE == null) {
            //同步代码块
            synchronized (Singleton03.class){
                if (INSTANCE == null) {
                    INSTANCE = new Singleton06();
                }
            }
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 1000; i++) {
            new Thread(() ->{
                System.out.println("instance.hashCode= " + Singleton06.getINSTANCE().hashCode());
            }).start();
        }
    }
}

为何必须加 volatile：

  • INSTANCE = new Singleton4() 不是原子的，分成 3 步：创建对象、调用构造、给静态变量赋值，其中后两步可能被指令重排序优化，变成先赋值、再调用构造
  • 如果线程1 先执行了赋值，线程2 执行到第一个 INSTANCE == null 时发现 INSTANCE 已经不为 null，此时就会返回一个未完全构造的对象

优缺点：

Double-Check 概念是多线程开发中常使用到的，如代码中所示，我们进行了两次if (singleton == null)检查，这样就可以保证线程安全了。

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

线程安全；延迟加载；效率较高

总结：在实际开发中，推荐使用这种单例设计模式

7、静态内部类

public class Singleton07 {

    /**
     * 构造方法私有化，防止new
     */
    private Singleton07(){

    }

    /**
     * 写一个静态内部类,该类中有一个静态属性Singleton
     */
    public static class SingletonClass{
        private static final Singleton07 INSTANCE = new Singleton07();
    }

    /**
     * 提供一个静态的公有方法，加入双重检查代码，解决线程安全问题, 同时解决懒加载问题
     * @return INSTANCE
     */
    public static Singleton07 getINSTANCE() {
        return SingletonClass.INSTANCE;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 1000; i++) {
            new Thread(() ->{
                System.out.println("instance.hashCode= " + Singleton07.getINSTANCE().hashCode());
            }).start();
        }
    }
}

优缺点：

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

静态内部类方式在Singleton 类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance 方法，才会装载SingletonClass 类，从而完成Singleton 的实例化。

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

优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高

结论：推荐使用

8、枚举

public enum Singleton08 {
    INSTANCE;

    public void sayHello(){
        System.out.println("你好，枚举单例模式！");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() ->{
                INSTANCE.sayHello();
                System.out.println("instance.hashCode = "+INSTANCE.hashCode());
            }).start();
        }
    }
}

优缺点：

借助JDK1.5 中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象，绝对防止多次实例化。

3、单例模式在JDK 应用的源码分析

1、饿汉式

JDK 中，java.lang.Runtime 就是经典的单例模式(饿汉式)
public class Runtime {
    private static Runtime currentRuntime = new Runtime();

    /**
     * Returns the runtime object associated with the current Java application.
     * Most of the methods of class <code>Runtime</code> are instance
     * methods and must be invoked with respect to the current runtime object.
     *
     * @return  the <code>Runtime</code> object associated with the current
     *          Java application.
     */
    public static Runtime getRuntime() {
        return currentRuntime;
    }

    /** Don't let anyone else instantiate this class */
    private Runtime() {}
    
    ······
}

2、双检锁懒汉式单例

System类中的Console对象的创建就是用的双重检锁
private static volatile Console cons = null;
/**
     * Returns the unique {@link java.io.Console Console} object associated
     * with the current Java virtual machine, if any.
     *
     * @return  The system console, if any, otherwise <tt>null</tt>.
     *
     * @since   1.6
     */
public static Console console() {
    if (cons == null) {
        synchronized (System.class) {
            if (cons == null) {
                cons = sun.misc.SharedSecrets.getJavaIOAccess().console();
            }
        }
    }
    return cons;
}

3、内部类懒汉式单例

Collections类中的ReverseComparator.REVERSE_ORDER 就是内部类懒汉式单例
private static class ReverseComparator
    implements Comparator<Comparable<Object>>, Serializable {

    private static final long serialVersionUID = 7207038068494060240L;

    static final ReverseComparator REVERSE_ORDER
        = new ReverseComparator();

    public int compare(Comparable<Object> c1, Comparable<Object> c2) {
        return c2.compareTo(c1);
    }

    private Object readResolve() { return Collections.reverseOrder(); }

    @Override
    public Comparator<Comparable<Object>> reversed() {
        return Comparator.naturalOrder();
    }
}

4、内部类懒汉式单例

Collections 中的 EmptyNavigableSet 就是内部类懒汉式单例
private static class EmptyNavigableSet<E> extends UnmodifiableNavigableSet<E>
    implements Serializable {
    private static final long serialVersionUID = -6291252904449939134L;

    public EmptyNavigableSet() {
        super(new TreeSet<E>());
    }

    private Object readResolve()        { return EMPTY_NAVIGABLE_SET; }
}

5、枚举饿汉式单例

Comparators.NaturalOrderComparator.INSTANCE 枚举饿汉式单例
class Comparators {
    private Comparators() {
        throw new AssertionError("no instances");
    }

    /**
     * Compares {@link Comparable} objects in natural order.
     *
     * @see Comparable
     */
    enum NaturalOrderComparator implements Comparator<Comparable<Object>> {
        INSTANCE;

        @Override
        public int compare(Comparable<Object> c1, Comparable<Object> c2) {
            return c1.compareTo(c2);
        }

        @Override
        public Comparator<Comparable<Object>> reversed() {
            return Comparator.reverseOrder();
        }
    }
    ......
}

4、注意事项和细节说明

单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能。

当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用new

单例模式使用的场景：

  • 需要频繁的进行创建和销毁的对象
  • 创建对象时耗时过多或耗费资源过多(即：重量级对象)
  • 但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session 工厂等)

5、总结

经验之谈：一般情况下，不建议使用第 1 种和第 2 种懒汉方式，建议使用第 3 种饿汉方式。只有在要明确实现 lazy loading 效果时，才会使用第 5 种登记方式。如果涉及到反序列化创建对象时，可以尝试使用第 6 种枚举方式。如果有其他特殊的需求，可以考虑使用第 4 种双检锁方式。
设计模式
点赞
收藏
评论区
推荐文章
3A网络 3A网络
•
2年前
Golang 常见设计模式之单例模式
之前我们已经看过了Golang常见设计模式中的装饰和选项模式，今天要看的是Golang设计模式里最简单的单例模式。单例模式的作用是确保无论对象被实例化多少次，全局都只有一个实例存在。根据这一特性，我们可以将其应用到全局唯一性配置、数据库连接对象、文件访问对象等。Go语言实现单例模式的方法有很多种，下面我们就一起来看一下。饿汉式饿汉式实现单例模式非
1215
0
0
Wesley13 Wesley13
•
3年前
java设计模式1
1：单例模式简介　　单例模式是一种常用的软件设计模式，它确保某个类只有一个实例，而且自行实例化并向整个系统提供唯一的实例。总而言之就是在系统中只会存在一个对象，其中的数据是共享的　　特点：　　　　单例类只能有一个实例，所以一般会用static进行修释。　　　　单例类必须自己创建自己的唯一实例。也就是在类中要new一个自己。　　　　单例类必
976
0
0
Wesley13 Wesley13
•
3年前
java 23种设计模式（五、单例模式）
作为对象的创建模式，单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。单例模式的结构　　单例模式的特点：单例类只能有一个实例。单例类必须自己创建自己的唯一实例。单例类必须给所有其他对象提供这一实例。　　饿汉式单例类publicclassEagerSingleton
961
0
0
Wesley13 Wesley13
•
3年前
java中饿汉与懒汉的故事（单例设计模式）
java中的单例设计模式关于设计模式，这其实是单独存在的东西，它不属于java，但是在java中使用较多，所以今天我就给大家介绍下单例设计模式中的饿汉和懒汉这俩朴素的打工人。首先我先说明下单例设计模式是啥（如果不想了解，可以直接划下去看饿汉和懒汉）：类的单例设计模式就是采用一定的方法保证在整个软件系统中，对某个类只能存在一
829
0
0
红烧土豆泥 红烧土豆泥
•
4年前
创建型模式之单例设计模式
什么是单例设计模式？顾名思义，只有一个实例。单例模式它主要是确保一个类只有一个实例，并且可以提供一个全局的访问点。废话少说，直接上干货了单例模式之饿汉式所谓饿汉式，顾名思义，“它很饿”。所以说，它一旦被加载进来，就会直接实例化一个对象。例如：languageclassSingleton{privatestaticfin
1653
0
0
Wesley13 Wesley13
•
3年前
JAVA设计模式之单例设计模式
    单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的类一个类只有一个实例。即一个类只有一个对象实例。　　在JAVA中实现单例，必须了解JAVA内存机制，JAVA中实例对象存在于堆内存中，若要实现单例，必须满足两个条件：　　1.限制类实例化对象。即只能产生一个对象。
971
0
0
Wesley13 Wesley13
•
3年前
Java单例模式
什么是单例模式　　单例模式是在程序中，一个类保证只有一个实例，并提供统一的访问入口。为什么要用单例模式节省内存节省计算如对象实例中的一样的，那就不用每次都创建一个对象方便管理因为单例提供一个统一的访问入口，不需要创建N多个对象，很多工具类都用了单例实现，如日志、字符串工具类
839
0
0
Wesley13 Wesley13
•
3年前
PHP单例模式（精讲）
首先我们要明确单例模式这个概念，那么什么是单例模式呢？单例模式顾名思义，就是只有一个实例。作为对象的创建模式，单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类我们称之为单例类。单例模式的要点有三个：一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例
954
0
0
Stella981 Stella981
•
3年前
C#设计模式(1)——单例模式（Singleton）
单例模式即所谓的一个类只能有一个实例,也就是类只能在内部实例一次,然后提供这一实例，外部无法对此类实例化。单例模式的特点：1、只能有一个实例；2、只能自己创建自己的唯一实例；3、必须给所有其他的对象提供这一实例。普通单例模式（没有考虑线程安全）　　///<summary///单例模式
899
0
0
Wesley13 Wesley13
•
3年前
(面试常问)4种单例设计模式的总结(内含代码以及分析)
单例设计模式:  单例模式,是一种常见的软件设计模式.在它的核心结构中只包含了一个被称为单例的特殊类.通过单例模式可以保证系统中只有该类的一个实例对象.优点:  实例控制:单例模式会阻止其它对象实例化其自己的单例对象的副本,从而确保所有对象都访问的是唯一的实例   灵活性:因为类控制了实例化过程,所以类可以很灵活的更改实
864
0
0
Wesley13 Wesley13
•
3年前
23种设计模式（1）：单例模式
定义：确保一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。类型：创建类模式类图：!23种设计模式（1）：单例模式第1张|快课网(http://static.oschina.net/uploads/img/201407/05200605_0dij.gif"23种设计模式（1）：单例模式
826
0
0
智数浮尘
智数浮尘
Lv1
燕山雪花大如席，片片吹落轩辕台。
文章
4
粉丝
0
获赞
0
热门文章
基于vue实现swipe轮播组件
如何在企业工作中应用知识管理，解决企业的问题？
Centos 磁盘挂载