[design pattern](7) Singleton

前言

上面的章节中，咱们介绍了工厂模式，它是建立型模式的一种。本章咱们将会介绍 单例模式 ，它也是建立型模式的一种。单例模式是咱们比较经常使用的一个设计模式，也是最简单的一种设计模式。

单例模式

介绍：确保在一个jvm中某个类有且只有一个实例。

类图：

从上面的类图中，咱们能够总结出如下几点：

• 单例模式须要实现一个私有的构造函数，防止有外部的语句会实例化该类。
• 单例模式须要定义一个静态成员变量，用来指向该类的惟一实例。
• 单例模式须要定义一个静态成员方法，用来返回该类惟一的实例。

单例模式的实现

单例模式的实现方式有8种，下面让咱们分别来看一看这几种实现方式的区别。

饿汉模式

代码：

public class Singleton {
    private Singleton() {}
    private static Singleton singleton = new Singleton();
    public static Singleton initSingleton() {
        return singleton;
    }
}

 

 

• 是不是懒加载：否
• 是否线程安全：是
• 优势：不用加锁，执行效率高。
• 缺点：类加载时就初始化，浪费内存。

饿汉模式（静态代码块初始化）

代码：

public class Singleton {
    private Singleton() {}
    private static Singleton singleton;
    static {
        singleton = new Singleton();
    }
    public static Singleton initSingleton() {
        return singleton;
    }
}

 

 

• 是不是懒加载：否
• 是否线程安全：是
• 优势：不用加锁，执行效率高。
• 缺点：类加载时就初始化，浪费内存。

懒汉模式

import java.util.Objects;

public class Singleton {
    private Singleton() {}
    private static Singleton singleton;
    public static Singleton initSingleton() {
        if (Objects.isNull(singleton)) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

 

 

• 是不是懒加载：是
• 是否线程安全：否
• 优势：不用加锁，执行效率高，第一次调用时初始化，避免了浪费内存。
• 缺点：非线程安全，多线程环境下，可能会产生多个实例。

懒汉模式（线程安全）

import java.util.Objects;

public class Singleton {
    private Singleton() {}
    private static Singleton singleton;
    public static synchronized Singleton initSingleton() {
        if (Objects.isNull(singleton)) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

 

 

• 是不是懒加载：是
• 是否线程安全：是
• 优势：第一次调用时初始化，避免了浪费内存。
• 缺点：实现了synchronized方法，会影响执行效率。

懒汉模式（同步代码块）

import java.util.Objects;

public class Singleton {
    private Singleton() {}
    private static Singleton singleton;
    public static Singleton initSingleton() {
        if (Objects.isNull(singleton)) {
            synchronized (Singleton.class) {
                singleton = new Singleton();
            }
        }
        return singleton;
    }
}

 

 

• 是不是懒加载：是
• 是否线程安全：否
• 优势：第一次调用时初始化，避免了浪费内存。
• 缺点：虽然实现了synchronized代码块，可是若是有多个线程同时实例化，那么有可能会产生多个实例。

双重检查模式

import java.util.Objects;

public class Singleton {
    private Singleton() {}
    private static volatile Singleton singleton;
    public static Singleton initSingleton() {
        if (Objects.isNull(singleton)) {
            synchronized (Singleton.class) {
                if(Objects.isNull(singleton)) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

 

 

• 是不是懒加载：是
• 是否线程安全：是
• 优势：第一次调用时初始化，避免了浪费内存。
• 缺点：暂无

静态内部类

public class Singleton {
    private Singleton() {}
    public static Singleton initSingleton() {
        return SingletonInstance.singleton;
    }

    public static class SingletonInstance {
        private static Singleton singleton = new Singleton();
    }
}

 

 

• 是不是懒加载：是
• 是否线程安全：是
• 优势：第一次调用时初始化，避免了浪费内存，效率高。
• 缺点：暂无

枚举

public enum Singleton {
    INSTANCE;
}

 

 

• 是不是懒加载：是
• 是否线程安全：是
• 优势：第一次调用时初始化，避免了浪费内存，效率高。
• 缺点：暂无