JAVA：单例模式五种实现方式详细介绍

奋斗的狍子007

于 2025-02-19 09:09:01 发布

阅读量693

点赞数 17

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

本文链接：https://blog.youkuaiyun.com/a79800/article/details/144368087

版权

JAVA设计模式专栏收录该内容

5 篇文章

订阅专栏

一、前言

单例模式（Singleton Pattern），作为一种经典的设计模式，其核心理念在于确保某个类在程序运行期间仅存在一个实例，并对外提供一个全局访问点。这一模式在Java等编程语言中得到了广泛应用，特别是在需要严格控制资源访问、优化内存使用以及确保数据一致性的场景中。

单例模式实现方式注意点：

①.私有构造函数

②.静态方法返回单例类的对象

③.保证单例类对象只有一个，要注意多线程场景

④.如果单例对象在反序列化时，不会重新创建对象

二、单例模式5种写法

1. 饿汉模式

1.1 代码示例

/**
 * 饿汉模式
 */
public class Singleton1 {
    private static final Singleton1 instance = new Singleton1();

    private Singleton1() {}

    public static Singleton1 getInstance() {
        return instance;
    }
}

1.2 详细说明
在类加载时就创建了一个实例。由于类加载是线程安全的（在Java中，类加载是由ClassLoader及其子类负责，而这些类是线程安全的），因此这种方式是线程安全的。

缺点：如果实例在程序运行过程中没有被使用到，会一直占用内存空间。初始化时机过早，可能会导致资源浪费。

2.懒汉模式(不安全)

2.1 代码示例

/**
 * 懒汉
 */
public class Singleton2 {
    private static Singleton2 instance;

    private Singleton2() {}

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

2.2 详细说明

在第一次调用getInstance()方法时才创建实例。这种方式节省了内存空间，因为只有在需要时才会创建实例。

缺点：由于没有同步机制，所以是线程不安全的。

2.3 不安全创建代码示例

public class TestSingleton {


    public static void main(String[] args) {
        Runnable task = () -> {
             Singleton2 instance = Singleton2.getInstance();
            System.out.println("线程" + Thread.currentThread().getName() + ",instance的hashCode=" + instance.hashCode());
        };

        for (int i = 0; i < 100; i++) {
            new Thread(task,"" + i).start();
        }
    }

}

在这里插入图片描述

3.懒汉模式(安全)

3.1 代码示例

public class Singleton3 {
    private static Singleton3 instance;

    private Singleton3() {}

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

3.2 详细说明

使用同步方法（Synchronized Method）来保证线程安全。

缺点：每次调用getInstance()方法时都需要同步，虽然保证了线程安全，但性能较差。

4. 双重校验锁模式

4.1 代码示例

/**
 * 双重校验锁模式
 */
public class Singleton4 {
    private static volatile Singleton4 instance;

    private Singleton4() {}

    public static Singleton4 getInstance() {
        if (instance == null) {
            synchronized (Singleton4.class) {
                if (instance == null) {
                    instance = new Singleton4();
                }
            }
        }
        return instance;
    }
}

4.2 详细说明

在懒汉模式的基础上，使用双重检查锁定来减少同步的开销。首先检查实例是否已经存在，如果不存在则进入同步块，再次检查实例是否存在（防止多个线程同时通过第一次检查），然后创建实例。
这种方式既保证了线程安全，又提高了性能

5. 静态内部类模式

5.1 代码示例

/**
 * 静态内部类模式
 */
public class Singleton5 {
    private Singleton5() {}

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

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