设计模式-单例模式

aabbcyao

已于 2023-07-27 14:32:48 修改

阅读量38

点赞数

分类专栏：设计模式文章标签：设计模式单例模式 java

于 2023-07-24 16:57:48 首次发布

本文链接：https://blog.csdn.net/weixin_46932727/article/details/131897301

版权

设计模式专栏收录该内容

5 篇文章 0 订阅

订阅专栏

文章介绍了Java中实现单例模式的多种方法，包括饿汉式（静态常量和静态代码块）、懒汉式（线程不安全和线程安全的实现）、双重检查、静态内部类以及使用枚举的方式。每种方式的优缺点都有所阐述，其中推荐使用的是双重检查和静态内部类实现，以及枚举方式，因为它们既保证了线程安全又实现了延迟加载。

摘要由CSDN通过智能技术生成

单例模式简介

单例模式：确保在整个软件系统中，保证一个类仅有一个对象实例，并提供一个取得这个对象实例的全局访问点

JDK中的java.lang.Runtime就是经典的单例模式(饿汉式)

1、饿汉式

静态常量

public class Singleton01 {
    // 定义静态变量
    private final static Singleton01 instance = new Singleton01();
    // 构造方法私有化
    private Singleton01() {}
    // 唯一外部能访问到的静态方法，用该方法返回实例对象
    public static Singleton01 getInstance() {
        return instance;
    }
}

// 测试
public class Test {
    public static void main(String[] args) {
        Singleton01 singleton_a = Singleton01.getInstance();
        Singleton01 singleton_b = Singleton01.getInstance();
        System.out.println(singleton_a.equals(singleton_b));
        System.out.println("查看hashcode是否一致：");
        System.out.println("singleton_a的哈希值：" + singleton_a.hashCode());
        System.out.println("singleton_b的哈希值：" + singleton_b.hashCode());
    }
}

true
查看hashcode是否一致：
singleton_a的哈希值：356573597
singleton_b的哈希值：356573597

优点：在类加载的时候就已经完成实例化，避免了线程同步问题
缺点：在类加载的时候就已经完成实例化，如果不使用该实例，则会造成内存浪费

静态代码块

public class Singleton02 {
    // 创建实例变量
    private static Singleton02 instance;
    // 在静态代码块里面创建实例
    static {
        instance = new Singleton02();
    }
    // 私有化构造器
    private Singleton02() {}
    // 唯一外部可访问的方法
    public static Singleton02 getInstance() {
        return instance;
    }
}

// 测试
public class Test {
    public static void main(String[] args) {
        Singleton02 singleton_a = Singleton02.getInstance();
        Singleton02 singleton_b = Singleton02.getInstance();
        System.out.println(singleton_a.equals(singleton_b));
        System.out.println("查看hashcode是否一致：");
        System.out.println("singleton_a的哈希值：" + singleton_a.hashCode());
        System.out.println("singleton_b的哈希值：" + singleton_b.hashCode());
    }
}

true
查看hashcode是否一致：
singleton_a的哈希值：356573597
singleton_b的哈希值：356573597

这种方式跟上一种方式大同小异。都是在类装载的时候就已经完成了实例化，一旦没有使用该实例，很可能会造成资源的浪费

2、懒汉式

线程不安全

public class Singleton03 {
    // 创建实例变量
    private static Singleton03 instance;
    // 构造方法私有化
    private Singleton03() {}
    // 当调用getInstance的时候才会去实例化
    public static Singleton03 getInstance() {
        if (instance == null) {
            instance = new Singleton03();
        }
        return instance;
    }
}

// 测试
public class Test {
    public static void main(String[] args) {
        Singleton03 singleton_a = Singleton03.getInstance();
        Singleton03 singleton_b = Singleton03.getInstance();
        System.out.println(singleton_a.equals(singleton_b));
        System.out.println("查看hashcode是否一致：");
        System.out.println("singleton_a的哈希值：" + singleton_a.hashCode());
        System.out.println("singleton_b的哈希值：" + singleton_b.hashCode());
    }
}

true
查看hashcode是否一致：
singleton_a的哈希值：356573597
singleton_b的哈希值：356573597

虽然有了lazy-loading，但是仅限于单线程下使用。因为多线程下可能会有多个线程同时进入判定if (instance == null)，这样一定会产生多个实例，所以在多线程下不适用。在实际开发中，不推荐使用这种方式创造单例

线程安全

对上一种方式的getInstance()方法加上synchronized锁，来解决线程不安全的问题

public class Singleton04 {
    // 创建实例变量
    private static Singleton04 instance;
    // 构造方法私有化
    private Singleton04() {}
    // 当调用getInstance的时候才会去实例化
    public static synchronized Singleton04 getInstance() {
        if (instance == null) {
            instance = new Singleton04();
        }
        return instance;
    }
}

// 测试
public class Test {
    public static void main(String[] args) {
        Singleton04 singleton_a = Singleton04.getInstance();
        Singleton04 singleton_b = Singleton04.getInstance();
        System.out.println(singleton_a.equals(singleton_b));
        System.out.println("查看hashcode是否一致：");
        System.out.println("singleton_a的哈希值：" + singleton_a.hashCode());
        System.out.println("singleton_b的哈希值：" + singleton_b.hashCode());
    }
}

true
查看hashcode是否一致：
singleton_a的哈希值：356573597
singleton_b的哈希值：356573597

这种方式虽然解决了线程不安全的问题，但是效率实在太低。我们都知道加synchronized锁是一个非常沉重的同步行为。其实，实例化的行为只要进行一次就够了，后面的线程想要获得实例，直接return就行了，根本没有必要排队获取锁然后再去进行判断。所以在实际开发中，这种方式也是不推荐的

同步代码块

在上一种方式的基础上，将锁分到真正需要同步的实例化

public class Singleton05 {
    // 创建实例变量
    private static Singleton05 instance;
    // 构造方法私有化
    private Singleton05() {}
    // 当调用getInstance的时候才会去实例化
    public static Singleton05 getInstance() {
        if (instance == null) {
            synchronized (Singleton05.class) {
                instance = new Singleton05();
            }
        }
        return instance;
    }
}

指标不治本，排队获取锁的现象在多线程的情况下还是太频繁了，不推荐

3、双重检查

public class Singleton06 {
    // 创建实例变量（volatile保证线程间的可见性）
    private static volatile Singleton06 instance;
    // 构造方法私有化
    private Singleton06() {}
    // double-check保证线程安全
    public static synchronized Singleton06 getInstance() {
        if (instance == null) {
            synchronized (Singleton06.class) {
                if (instance == null) {
                    instance = new Singleton06();
                }
            }
        }
        return instance;
    }
}

// 测试
public class Test {
    public static void main(String[] args) {
        Singleton06 singleton_a = Singleton06.getInstance();
        Singleton06 singleton_b = Singleton06.getInstance();
        System.out.println(singleton_a.equals(singleton_b));
        System.out.println("查看hashcode是否一致：");
        System.out.println("singleton_a的哈希值：" + singleton_a.hashCode());
        System.out.println("singleton_b的哈希值：" + singleton_b.hashCode());
    }
}

true
查看hashcode是否一致：
singleton_a的哈希值：356573597
singleton_b的哈希值：356573597

volatile保证了多个线程之间对于实例变量的可见性，double-check保证线程的安全，实例化只执行一次。这种方式线程安全，延迟加载，效率较高。推荐使用

4、静态内部类

public class Singleton07 {
    // 创建实例变量（volatile保证线程间的可见性）
    private static volatile Singleton07 instance;
    // 构造方法私有化
    private Singleton07() {}
    // 静态内部类
    private static class SingletonInstance {
        private static final Singleton07 INSTANCE = new Singleton07();
    }
    // 当调用getInstance的时候才会去实例化
    public static Singleton07 getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

public class Test {
    public static void main(String[] args) {
        Singleton07 singleton_a = Singleton07.getInstance();
        Singleton07 singleton_b = Singleton07.getInstance();
        System.out.println(singleton_a.equals(singleton_b));
        System.out.println("查看hashcode是否一致：");
        System.out.println("singleton_a的哈希值：" + singleton_a.hashCode());
        System.out.println("singleton_b的哈希值：" + singleton_b.hashCode());
    }
}

true
查看hashcode是否一致：
singleton_a的哈希值：356573597
singleton_b的哈希值：356573597

静态内部类方式在主类被装载的时候并不会立即实例化，而是在getInstance()之后，才会去装载SingletonInstance这个静态内部类。所以这种方式是采用类装载机制来保证实例化时只有一个线程（JVM保证在类进行初始化的时候，其他线程是无法进入的，且类的静态属性只会在第一次加载类的时候初始化）

保证了线程安全，利用静态内部类的特点实现延迟加载，效率高，推荐使用

5、枚举

public enum Singleton08 {
    INSTANCE;
    public void HelloSingleton() {
        System.out.println("hello singleton!");
    }
}

// 测试
public class Test {
    public static void main(String[] args) {
        Singleton08 singleton_a = Singleton08.INSTANCE;
        Singleton08 singleton_b = Singleton08.INSTANCE;
        System.out.println(singleton_a == singleton_b);
        System.out.println("查看hashcode是否一致：");
        System.out.println("singleton_a的哈希值：" + singleton_a.hashCode());
        System.out.println("singleton_b的哈希值：" + singleton_b.hashCode());

        singleton_a.HelloSingleton();
    }
}

true
查看hashcode是否一致：
singleton_a的哈希值：356573597
singleton_b的哈希值：356573597
hello singleton!

Effective Java作者Josh Bloch提倡：借助JDK1.5新添加的枚举来实现单例模式，这种方式不仅能够避免多线程同步问题，而且还能防止反序列化重新创建新的对象，推荐使用

总结

单例模式有8种方式：

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

由于这是本人跟着某谷学习设计模式的学习笔记，仅供参考，如有错误，恳请各位大佬批评指正！

aabbcyao

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
设计模式-单例模式

饿汉式（静态常量）饿汉式（静态代码块）懒汉式（线程不安全）懒汉式（线程安全，同步方法）懒汉式（线程安全，同步代码块）双重检查静态内部类枚举由于这是本人跟着某谷学习设计模式的学习笔记，仅供参考，如有错误，恳请各位大佬批评指正！
复制链接

扫一扫

专栏目录