03 创建型模式之单例模式（Singleton Pattern）

最新推荐文章于 2022-07-15 16:11:52 发布

wyaoyao93

最新推荐文章于 2022-07-15 16:11:52 发布

阅读量150

点赞数

分类专栏：设计模式 java

本文链接：https://blog.csdn.net/wyaoyao93/article/details/110918644

版权

java 同时被 2 个专栏收录

51 篇文章 0 订阅

订阅专栏

设计模式

17 篇文章 1 订阅

订阅专栏

文章目录

1 介绍

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

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

1.1 单例模式结构

单例模式的主要有以下角色：

单例类。只能创建一个实例的类
访问类。使用单例类

1.2 单例模式的实现

饿汉式：类加载就会导致该单实例对象被创建
懒汉式：类加载不会导致该单实例对象被创建，而是首次使用该对象时才会创建

1.3 单例模式实现基本要求

私有构造：不允许外部构造
需要提供一个静态方法获取该对象的实例，因为外部不能new该对象的实例

2 饿汉式

2.1 静态变量方式

package study.wyy.design.singleton.demo1;

/**
 * @author by wyaoyao
 * @Description
 * @Date 2020/12/9 12:27 下午
 */
public class Singleton {


    /**
    * 私有构造，不允许外部通过构造方法创建该类对象
    */
    private Singleton() {
    }

    private static Singleton instance = new Singleton();

    /****
     * 对外提供静态方法获取该对象, 因为外部不能new该对象的实例，
     * 所以需要提供一个静态方法获取该对象的实例
     *
     */
    public static Singleton getInstance() {
        return instance;
    }
}

测试

package study.wyy.design.singleton.demo1;

/**
 * @author by wyaoyao
 * @Description
 * @Date 2020/12/9 12:40 下午
 */
public class Test {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println("instance1的地址：" + instance1);
        System.out.println("instance2的地址：" + instance2);
        System.out.println(instance1 == instance2);
    }
}

输出: 可见是同一个对象

instance1的地址：study.wyy.design.singleton.demo1.Singleton@135fbaa4
instance2的地址：study.wyy.design.singleton.demo1.Singleton@135fbaa4
true

说明

该方式在成员位置声明Singleton类型的静态变量，并创建Singleton类的对象instance。
instance对象是随着类的加载而创建的。如果该对象足够大的话，而一直没有使用就会造成内存的浪费。
由于静态成员位置声明Singleton类型的实例private static Singleton instance = new Singleton();，只会在类被加载的时候创建该对象，保证了线程的安全

2.2 静态代码块方式

package study.wyy.design.singleton.demo2;

/**
 * @author by wyaoyao
 * @Description
 * @Date 2020/12/9 12:46 下午
 */
public class Singleton {

    /**
     * 私有构造，不允许外部通过构造方法创建该类对象
     */
    private Singleton() {
    }

    /****
     * 在成员位置生命该类的对象
     */
    private static Singleton instance;

    /****
     * 在静态代码块中实例化改对
     */
    static {
        instance = new Singleton();
    }

    /****
     * 对外提供静态方法获取该对象, 因为外部不能new该对象的实例，
     * 所以需要提供一个静态方法获取该对象的实例
     *
     */
    public static Singleton getInstance() {
        return instance;
    }
}

测试

package study.wyy.design.singleton.demo2;


/**
 * @author by wyaoyao
 * @Description
 * @Date 2020/12/9 12:40 下午
 */
public class Test {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println("instance1的地址：" + instance1);
        System.out.println("instance2的地址：" + instance2);
        System.out.println(instance1 == instance2);
    }
}

instance1的地址：study.wyy.design.singleton.demo2.Singleton@135fbaa4
instance2的地址：study.wyy.design.singleton.demo2.Singleton@135fbaa4
true

说明：

该方式在成员位置声明Singleton类型的静态变量，
- 而对象的创建是在静态代码块中，也是对着类的加载而创建。
饿汉式的方式1基本上一样，当然该方式也存在内存浪费问题
由于是在静态代码块中实例对象，只会在类加载的时候执行一次，也是线程安全的。

3 懒汉式

饿汉是在类加载的时候该单实例对象被创建，懒汉式而是首次使用该对象时才会创建，当我们没有使用该对象的时候不会去创建该对象实例，不会造成内存的浪费。

3.1 方式1–线程不安全

package study.wyy.design.singleton.demo3;

/**
 * @author by wyaoyao
 * @Description
 * @Date 2020/12/9 12:55 下午
 * 懒汉式实现单例模式，线程不安全
 */
public class Singleton {

    /****
     * 私有构造，不允许外部创建该对象实例
     */
    private Singleton(){
    }

    /****
     * 在成员位置声明该类的对象，但未实例化
     */
    private static Singleton instance;

    public static Singleton getInstance() {
        if(null == instance){
            // 如果第一次调用getInstance方法，此时instance还未实例化，进行实例化
            instance = new Singleton();
        }
        // 返回该类实例
        return instance;
    }
}

测试

public class Test {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println("instance1的地址：" + instance1);
        System.out.println("instance2的地址：" + instance2);
        System.out.println(instance1 == instance2);
    }
}

instance1的地址：study.wyy.design.singleton.demo3.Singleton@135fbaa4
instance2的地址：study.wyy.design.singleton.demo3.Singleton@135fbaa4
true

说明

该方式在成员位置声明Singleton类型的静态变量,但未实例化
当调用getInstance()方法获取Singleton类的对象的时候才创建Singleton类的对象，这样就实现了懒加载的效果
如果是多线程环境，会出现线程安全问题(缺点)

3.2 方式2–线程安全

想解决线程安全，就是加锁。

package study.wyy.design.singleton.demo4;

/**
 * @author by wyaoyao
 * @Description
 * @Date 2020/12/9 3:53 下午
 * 饿汉式，线程安全
 */
public class Singleton {

    /****
     * 构造私有
     */
    private Singleton(){
    }
    
    private static Singleton instance;

    /****
     * synchronized 加锁，保证线程安全
     * @return
     */
    public synchronized static Singleton getSingleton() {
        if (null == instance){
            instance = new Singleton();
        }
        return instance;
    }
}

说明

该方式也实现了懒加载效果，同时又解决了线程安全问题。但是在getInstance()方法上添加了synchronized关键字，导致该方法的执行效果特别低。从上面代码我们可以看出，其实就是在初始化instance的时候才会出现线程安全问题，一旦初始化完成就不存在了。

3.2 方式3–双重检查锁

对于 getInstance() 方法来说，绝大部分的操作都是读操作，读操作是线程安全的，所以我们没必让每个线程必须持有锁才能调用该方法，我们需要调整加锁的时机。由此也产生了一种新的实现模式：双重检查锁模式
在这里插入图片描述

package study.wyy.design.singleton.demo5;

/**
 * @author by wyaoyao
 * @Description
 * @Date 2020/12/9 4:03 下午
 */
public class Singleton {

    /****
     * 构造私有
     */
    private Singleton(){
    }

    private static Singleton instance;

    public static Singleton getInstance() {
        //第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实例
        if(null==instance){
            synchronized (Singleton.class){
                //抢到锁之后再次判断是否为null
                if(null==instance){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

双重检查锁模式是一种非常好的单例实现模式，解决了单例、性能、线程安全问题，上面的双重检测锁模式看上去完美无缺，其实是存在问题，在多线程的情况下，可能会出现空指针问题，出现问题的原因是JVM在实例化对象的时候会进行优化和指令重排序操作。

在这里插入图片描述

volatile关键字作用

保证重排序的时，不会把后面的指令放到屏障前面，也不会把前面的返回后面
强制对缓存修改操作，立刻写入主存
如果是写操作，会导致其他cpu中的缓存失效
2和3就保证了不同线程间的可见性
不保证原子性

package study.wyy.design.singleton.demo5;

import java.util.Objects;

/**
 * @author by wyaoyao
 * @Description
 * @Date 2020/12/9 4:03 下午
 */
public class Singleton {

    /****
     * 构造私有
     */
    private Singleton(){
    }

    //private static Singleton instance;
    /****
     * 使用volatile关键字修饰
     */
    private static volatile Singleton instance;

    public static Singleton getInstance() {
        //第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实例
        if(null==instance){
            synchronized (Singleton.class){
                //抢到锁之后再次判断是否为null
                if(null==instance){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

添加 volatile 关键字之后的双重检查锁模式是一种比较好的单例实现模式，能够保证在多线程的情况下线程安全也不会有性能问题。

3.4 方式4（静态内部类方式）

静态内部类单例模式中实例由内部类创建，由于 JVM 在加载外部类的过程中, 是不会加载静态内部类的, 只有内部类的属性/方法被调用时才会被加载, 并初始化其静态属性。静态属性由于被 static 修饰，保证只被实例化一次，并且严格保证实例化顺序。

支持懒加载
线程安全
不会npe

package study.wyy.design.singleton.demo6;

/**
 * @author by wyaoyao
 * @Description
 * @Date 2020/12/9 4:34 下午
 * 懒汉式-方式4（静态内部类方式）
 */
public class Singleton {

    /****
     * 私有构造方法
     */
    private Singleton() {}

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

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

测试

package study.wyy.design.singleton.demo6;

/**
 * @author by wyaoyao
 * @Description
 * @Date 2020/12/9 4:39 下午
 */
public class Test {

    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println("instance1的地址：" + instance1);
        System.out.println("instance2的地址：" + instance2);
        System.out.println(instance1 == instance2);
    }
}

instance1的地址：study.wyy.design.singleton.demo6.Singleton@135fbaa4
instance2的地址：study.wyy.design.singleton.demo6.Singleton@135fbaa4
true

第一次加载Singleton类时不会去初始化INSTANCE，只有第一次调用getInstance，虚拟机加载SingletonHolder
并初始化INSTANCE，这样不仅能确保线程安全，也能保证 Singleton 类的唯一性。

静态内部类单例模式是一种优秀的单例模式，是开源项目中比较常用的一种单例模式。在没有加任何锁的情况下，保证了多线程下的安全，并且没有任何性能影响和空间的浪费。

4 枚举方式实现

枚举类实现单例模式是极力推荐的单例实现模式，因为枚举类型是线程安全的，并且只会装载一次，设计者充分的利用了枚举的这个特性来实现单例模式，枚举的写法非常简单，而且枚举类型是所用单例实现中唯一一种不会被破坏的单例实现模式。

枚举方式属于恶汉式方式。

package study.wyy.design.singleton.demo7;

/**
 * @author by wyaoyao
 * @Description
 * @Date 2020/12/9 4:41 下午
 */
public enum Singleton {
    INSTANCE;
}

5 破坏单例模式

如何使上面定义的单例类（Singleton）可以创建多个对象，枚举方式除外。有两种方式，分别是序列化和反射。

5.1 序列化方式破坏单例

5.1.1 演示

就使用静态内部类的方式来演示
单例类：

public class Singleton implements Serializable {

    /****
     * 私有构造方法
     */
    private Singleton() {}

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

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

演示：

package study.wyy.design.singleton.demo8;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 * @author by wyaoyao
 * @Description
 * @Date 2020/12/9 4:47 下午
 */
public class Test {

    private final static String name = "singleton.txt";
    public static void main(String[] args) throws Exception {
        //往文件中写对象
        //writeObject2File();
        //从文件中读取对象
        Singleton s1 = readObjectFromFile();
        Singleton s2 = readObjectFromFile();

        //判断两个反序列化后的对象是否是同一个对象
        System.out.println(s1 == s2);
    }

    /****
     * 往文件中写对象
     */
    private static void writeObject2File() throws Exception{
        String path = Test.class.getClassLoader().getResource("").getPath();
        //获取Singleton类的对象
        Singleton instance = Singleton.getInstance();
        //创建对象输出流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(path + "/" +name));
        //将instance对象写出到文件中
        oos.writeObject(instance);
        oos.close();
    }

    /****
     * 从文件中读取对象
     */
    private static Singleton readObjectFromFile() throws Exception {
        String path = Test.class.getClassLoader().getResource("").getPath();
        //创建对象输入流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(path + "/" +name));
        //第一个读取Singleton对象
        Singleton instance = (Singleton) ois.readObject();
        return instance;
    }
}

上面代码运行结果是false，表明序列化和反序列化已经破坏了单例设计模式。

5.1.2 解决

在Singleton类中添加readResolve()方法，在反序列化时被反射调用，如果定义了这个方法，就返回这个方法的值，如果没有定义，则返回新new出来的对象。

package study.wyy.design.singleton.demo8;

import java.io.Serializable;

/**
 * @author by wyaoyao
 * @Description
 * @Date 2020/12/9 4:46 下午
 */
public class Singleton implements Serializable {
    /****
     * 私有构造方法
     */
    private Singleton() {}

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

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

    /**
     * 下面是为了解决序列化反序列化破解单例模式
     */
    private Object readResolve() {
        return InstanceHolder.INSTANCE;
    }
}

再次测试：返回为true

5.2 反射方式破坏单例

package study.wyy.design.singleton.demo9;

import study.wyy.design.singleton.demo8.Singleton;

import java.lang.reflect.Constructor;

/**
 * @author by wyaoyao
 * @Description
 * @Date 2020/12/9 4:57 下午
 */
public class Test {

    public static void main(String[] args) throws Exception {
        //获取Singleton类的字节码对象
        Class clazz = Singleton.class;
        //获取Singleton类的私有无参构造方法对象
        Constructor constructor = clazz.getDeclaredConstructor();
        //取消访问检查
        constructor.setAccessible(true);

        //创建Singleton类的对象s1
        Singleton s1 = (Singleton) constructor.newInstance();
        //创建Singleton类的对象s2
        Singleton s2 = (Singleton) constructor.newInstance();

        //判断通过反射创建的两个Singleton对象是否是同一个对象
        System.out.println(s1 == s2);
    }
}

5.2.2 解决

在构造方法的地方抛出异常，运行使用构造方法创建对象

package study.wyy.design.singleton.demo8;

import java.io.Serializable;

/**
 * @author by wyaoyao
 * @Description
 * @Date 2020/12/9 4:46 下午
 */
public class Singleton implements Serializable {
    /****
     * 私有构造方法
     */
    private Singleton() {
        throw new RuntimeException();
    }

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

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

    /**
     * 下面是为了解决序列化反序列化破解单例模式
     */
    private Object readResolve() {
        return InstanceHolder.INSTANCE;
    }
}

枚举方式不会出现这两个问题。

wyaoyao93

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
03 创建型模式之单例模式（Singleton Pattern）

文章目录1 介绍1.1 单例模式结构1.2 单例模式的实现1.3 单例模式实现基本要求2 饿汉式2.1 静态变量方式2.2 静态代码块方式3 懒汉式3.1 方式1--线程不安全3.2 方式2--线程安全3.2 方式3--双重检查锁3.4 方式4（静态内部类方式）4 枚举方式实现5 破坏单例模式5.1 序列化方式破坏单例5.1.1 演示5.1.2 解决5.2 反射方式破坏单例5.2.2 解决1 介绍单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创
复制链接

扫一扫