ZYang's Blog
首页 标签 归档

单例模式

2021-03-20 17:21 | 本篇文章共2k字，预计阅读8分钟

本文最后更新于 <span id="expire-date"></span> 天前，文中部分描述可能已经过时。

#设计模式 #单例模式

一、什么是单例模式

就如同他的名字一样，**’单例’**，就是只有一个实例。也就是说一个类在全局中最多只有一个实例存在，不能在多了，在多就不叫单例模式了。

单例模式（Singleton Pattern），它是 Java 中最简单的设计模式之一，属于创建型模式的一种，它提供了一种创建对象的最佳方式。

这种模式的意义在于保证一个类仅有一个实例，并提供一个访问它的全局访问点，避免重复的创建对象，节省系统资源。

二、实现思路

1、实现思路

创建一个类，将其默认构造方法私有化，使外界不能通过new Object来获取对象实例，同时提供一个对外获取对象唯一实例的方法。

2、用在哪里

单例模式一般用在对实例数量有严格要求的地方，比如数据池，线程池，缓存，session回话等等。

3、在Java中构成的条件

  • 静态变量
  • 静态方法
  • 私有构造器

二、单例模式的两种形态

1、懒汉模式

这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。这种方式 lazy loading 很明显，不要求线程安全，在多线程不能正常工作。

线程不安全

public class Singleton {

    private static Singleton instance = null;

    private Singleton() {
        System.out.println(Thread.currentThread().getName() + "创建了该对象！");
    }

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

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                Singleton.getInstance();
            }).start();
        }
    }
}

image-20210320161904359

2、饿汉模式

这种方式比较常用，但容易产生垃圾对象。优点：没有加锁，执行效率会提高。缺点：类加载时就初始化，浪费内存。它基于 classloader 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。

线程安全

public class Singleton {

    private static Singleton instance = new Singleton();

    private Singleton() {
        System.out.println(Thread.currentThread().getName() + "创建了该对象！");
    }

    public static Singleton getInstance() {
        return instance;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                Singleton.getInstance();
            }).start();
        }
    }
}

image-20210320162018904

三、懒汉模式优化成线程安全

1、加synchronized关键字

此方法是最简单又有效的方法，不过对性能上会有所损失。比如两个线程同时调用这个实例，其中一个线程要等另一个线程调用完才可以继续调用。而线程不安全往往发生在这个实例在第一次调用的时候发生，当实例被调用一次后，线程是安全的，所以加synchronized就显得有些浪费性能。

public class Singleton {

    private static Singleton instance = null;

    private Singleton() {
        System.out.println(Thread.currentThread().getName() + "创建了该对象！");
    }

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

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                Singleton.getInstance();
            }).start();
        }
    }
}

image-20210320162223640

2、用”双重检查加锁”

上个方法说到，线程不安全往往发生在这个实例在第一次调用的时候发生，当实例被调用一次后，线程是安全的。那有没有方法只有在第一次调用的时候才用synchronized关键字，而第一次后就不用synchronized关键字呢？答案是当然有的，就是用volatile来修饰静态变量，保持其可见性。

1、单重检查锁

public class Singleton {

    private static Singleton instance = null;

    private Singleton() {
        System.out.println(Thread.currentThread().getName() + "创建了该对象！");
    }

    public static Singleton getInstance() {

        if (instance == null) {
            synchronized (Singleton.class) {
                instance = new Singleton();
            }
        }
        return instance;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                Singleton.getInstance();
            }).start();
        }
    }
}

image-20210320162924905

2、双重检查锁

public class Singleton {

    private static Singleton instance = null;

    private Singleton() {
        System.out.println(Thread.currentThread().getName() + "创建了该对象！");
    }

    public static Singleton getInstance() {

        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                Singleton.getInstance().hashCode();
            }).start();
        }
    }
}

注意：在执行instance = new Singleton();时，可能会出现CPU指令重排！

new 的过程会分为三个步骤：

1、在堆中开辟一块内存空间M；

2、根据Singleton类模板创建Singleton对象；

3、把Singleton对象赋值给instance。

理论上：1->2->3

实际上：1->3->2

image-20210320164625374

3、volatile + 双重检查锁

public class Singleton {

    private volatile static Singleton instance = null;

    private Singleton() {
        System.out.println(Thread.currentThread().getName() + "创建了该对象！");
    }

    public static Singleton getInstance() {

        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                Singleton.getInstance().hashCode();
            }).start();
        }
    }
}

3、用”静态内部类”

静态内部类的优点是：外部类加载时并不需要立即加载内部类，内部类不被加载则不去初始化INSTANCE，故而不占内存。即当SingleTon第一次被加载时，并不需要去加载SingleTonHoler，只有当getInstance()方法第一次被调用时，才会去初始化INSTANCE,第一次调用getInstance()方法会导致虚拟机加载SingleTonHoler类，这种方法不仅能确保线程安全，也能保证单例的唯一性，同时也延迟了单例的实例化。

public class Singleton {

    private Singleton() {
        System.out.println(Thread.currentThread().getName() + "创建了该对象！");
    }

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static final Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                Singleton.getInstance().hashCode();
            }).start();
        }
    }
}

image-20210320165200230

4、枚举

这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。不过，由于 JDK1.5 之后才加入 enum 特性，用这种方式写不免让人感觉生疏，在实际工作中，也很少用。

public enum Singleton {

    INSTANCE;


    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                Singleton instance = Singleton.INSTANCE;
            }).start();
        }
    }
}

四、应用

单例模式在Java中的应用也很多，例如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() {}
    
    ...
    
}

很清晰的看到，使用了饿汉式方式创建单例对象！

五、总结

  • 饿汉模式：性能好，写法简单，推荐使用；
  • 加synchronized关键字：性能差，不过对懒汉模式比较直接有效；
  • volatile-双重验证加锁：性能好，对Java版本有要求，要求Java5以上版本；
  • 静态内部类：性能好，无需加锁，由JVM类加载保证。
  • 枚举：还没被广泛采用，它更简洁，自动支持序列化机制，绝对防止多次实例化。

本文作者：ZYang

本文链接： https://luziyangde.cn/2021/03/20/%E5%8D%95%E4%BE%8B%E6%A8%A1%E5%BC%8F/

文章默认使用 CC BY-NC-SA 4.0 协议进行许可，使用时请注意遵守协议。

更新于 2022-12-04 11:23

# 设计模式# 单例模式
下一篇
小鲸鱼历险记（六）【DockerFile】