一文详细解读Java的单例模式

Java极客技术

发布于 2024-07-31 17:29:43

2440

发布于 2024-07-31 17:29:43

文章被收录于专栏：Java极客技术

每天早上八点，准时推送干货

我们在面试的过程中，会经常的被问到关于设计模式的相关面试题，而且各种设计模式非常的多，了不起接下来就写一下关于设计模式的文章，来总结归纳一下这个设计模式。

单例模式

Java中的单例模式（Singleton Pattern）是一种常用的设计模式，它确保一个类仅有一个实例，并提供一个全局访问点来获取该实例。

单例模式的特点

唯一性：确保一个类只有一个实例。
自我实例化：单例类必须自行创建自己的唯一实例。
全局访问：单例类必须提供一个全局的访问点来获取该实例。

单例模式的实现方式

Java中实现单例模式有多种方式，每种方式都有其特点和适用场景。以下是几种常见的实现方式：

1.饿汉式（Eager Initialization）

在类加载时就完成了初始化，所以类加载较慢，但获取对象的速度快。
线程安全，因为在类加载时就完成了实例的初始化，所以不存在多线程访问问题。

public class SingletonEager {  
    private static final SingletonEager instance = new SingletonEager();  
    private SingletonEager() {}  
    public static SingletonEager getInstance() {  
        return instance;  
    }  
}

2.懒汉式（Lazy Initialization，线程不安全）

在真正需要使用时才进行实例化，实现了延迟加载。
但在多线程环境下可能会创建多个实例，因此线程不安全。

public class SingletonLazyUnsafe {  
    private static SingletonLazyUnsafe instance;  
    private SingletonLazyUnsafe() {}  
    public static SingletonLazyUnsafe getInstance() {  
        if (instance == null) {  
            instance = new SingletonLazyUnsafe();  
        }  
        return instance;  
    }  
}

3.懒汉式（线程安全）

在懒汉式的基础上，通过加锁（如使用synchronized关键字）来保证在多线程环境下的线程安全。
但每次调用getInstance()方法时都会进行加锁操作，影响性能。

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

4.双重检查锁（Double-Checked Locking）

在懒汉式的基础上，通过双重检查锁机制来减少加锁的次数，提高性能并保证线程安全。

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

5.静态内部类

利用类加载机制来保证单例的唯一性，同时实现了延迟加载。
线程安全，且性能较好。

public class SingletonStaticInner {  
    private static class InnerClass {  
        private static final SingletonStaticInner INSTANCE = new SingletonStaticInner();  
    }  
    private SingletonStaticInner() {}  
    public static SingletonStaticInner getInstance() {  
        return InnerClass.INSTANCE;  
    }  
}

6.枚举

利用Java枚举的特性来实现单例模式，天然地保证了线程安全和单例的唯一性。
简洁且自动支持序列化机制，防止反序列化重新创建新的对象。

public enum SingletonEnum {  
    INSTANCE;  
    public void someMethod() {  
        // 方法实现  
    }  
}

Spring中的单例模式体现

在Spring框架中，单例模式（Singleton Pattern）扮演着至关重要的角色，尤其是在Bean的生命周期管理和依赖注入（DI）方面。Spring通过其控制反转（IoC）容器实现了单例模式，使得开发者能够轻松地在应用中管理和使用单例对象。以下是Spring中单例模式的具体体现：

Bean的作用域

Spring容器中的Bean默认就是单例（Singleton）的。这意味着当开发者定义一个Bean时，Spring容器将会创建一个单一的实例，并管理这个实例的生命周期。所有对该Bean的请求都将返回同一个实例。这种方式简化了传统单例实现的复杂性，并确保了线程安全。

依赖注入

Spring使用依赖注入来管理组件（即Beans）之间的依赖关系。当一个Bean被标记为单例时，无论它在应用中的哪个位置被注入，注入的都是同一个实例。这通过@Component、@Service、@Repository等注解实现，这些注解标记的类会被Spring自动注册为Bean，并默认以单例模式管理。

线程安全性

虽然Spring中的单例Bean是全局共享的，但Spring框架通过确保每个Bean的作用域是隔离的，从而保证了线程安全。这意味着每个Bean实例都独立于其他Bean实例，并且不会被其他Bean的线程直接访问或修改其内部状态（除非通过共享资源或方法调用进行显式共享）。

配置和扩展

开发者可以通过Spring的配置文件或注解来配置Bean的作用域。虽然默认是单例的，但也可以配置为其他作用域，如原型（Prototype）、请求（Request）、会话（Session）等。此外，Spring还允许通过实现特定的接口或继承特定的类来扩展单例模式的行为，如实现ApplicationContextAware接口以获取ApplicationContext的引用。

Spring单例Bean的示例

import org.springframework.stereotype.Component;  
  
@Component  
public class SingletonService {  
    // 类的业务逻辑  
    public void performAction() {  
        // 执行某些操作  
    }  
}  
  
// 在其他组件中注入SingletonService  
@Component  
public class AnotherComponent {  
    private final SingletonService singletonService;  
  
    @Autowired  
    public AnotherComponent(SingletonService singletonService) {  
        this.singletonService = singletonService;  
    }  
  
    public void useSingletonService() {  
        singletonService.performAction();  
    }  
}