深入理解单例模式：如何确保一个类只有一个实例？

迷南。 2024-02-05 23:47 23阅读 0赞

> 欢迎来到英杰社区  
> [https://bbs.csdn.net/topics/617804998][https_bbs.csdn.net_topics_617804998]

> 欢迎来到阿Q社区  
> [https://bbs.csdn.net/topics/617897397][https_bbs.csdn.net_topics_617897397]

#### 单例模式 ####

*  前言
 *  单例模式
 *   *  饿汉模式
     *  懒汉模式

## 前言 ##

单例模式（Singleton Pattern）是一种常用的设计模式，用于确保一个类只有一个实例，并提供全局访问点。虽然在表面上看起来很简单，但深入理解单例模式可以帮助我们更好地应用它，避免潜在的问题。

在本文中，我们将深入探讨单例模式的核心思想、实现方式和使用场景。首先，我们将介绍单例模式的概念和作用，以及为什么要使用单例模式。其次，我们将讨论几种常见的单例模式实现方式，包括懒汉模式、饿汉模式、双重检查锁定模式和静态内部类模式。我们将比较它们的优缺点，以及在多线程环境下如何确保线程安全。

通过深入理解单例模式，我们可以更好地应用它来解决实际的问题。无论是在多线程环境下确保只有一个实例，还是在需要全局访问点的情况下，单例模式都是一个有力的工具。同时，我们也要注意单例模式可能带来的一些副作用，例如对代码的耦合性增加和单元测试的困难。

在本文中，我们将通过详细的解释、示例代码和实际案例，帮助读者深入理解单例模式，并能够在实践中灵活应用。无论是初学者还是有经验的开发者，都可以从本文中获得对单例模式的全面认识和实践指导。

深入理解单例模式，让我们更好地应用它，提高代码的可维护性和可扩展性。

## 单例模式 ##

单例模式（Singleton Pattern）是一种常见的设计模式，用于确保一个类只有一个实例，并提供全局访问点。

在单例模式中，类的构造函数被私有化，确保外部无法直接创建对象实例。同时，类内部定义一个静态成员变量用于保存唯一实例，并提供一个公共的静态方法用于获取该实例。

以下是一个简单的单例模式的示例代码：

java
    public class Singleton {
        
        private static Singleton instance;
    
        private Singleton() {
        
            // 私有化构造函数
        }
    
        public static Singleton getInstance() {
        
            if (instance == null) {
        
                instance = new Singleton();
            }
            return instance;
        }
    }

在上述代码中，Singleton 类的构造函数被私有化，确保外部无法直接创建对象实例。通过定义一个静态的 instance 变量，在第一次调用 getInstance() 方法时进行实例化，实现了懒加载的效果。之后的调用都直接返回已经创建的实例。

单例模式的优点是实现简单，可以确保一个类只有一个实例，并提供全局访问点，方便其他对象直接使用该实例。此外，由于只有一个实例存在，可以节省资源。

然而，单例模式也有一些缺点。例如，在多线程环境下，需要考虑并发访问的线程安全性，以避免破坏单例的特性。另外，由于单例对象存在全局访问点，可能会导致代码的耦合性增加，不利于单元测试和模块化开发。

在使用单例模式时，需要根据具体的需求和场景来决定是否使用该模式，并考虑线程安全的实现方式。

### 饿汉模式 ###

饿汉模式（Eager Initialization）是一种常见的单例设计模式，在该模式下，单例对象在类加载时就被创建，并在整个应用程序生命周期中保持唯一实例。

实现饿汉模式的关键是将构造函数私有化，确保外部无法直接创建对象实例。同时，类内部定义一个静态成员变量用于保存唯一实例，并在类加载时进行初始化。最后，提供一个公共的静态方法用于获取该实例。

以下是一个简单的饿汉模式的示例代码：

public class Singleton {
        
        private static Singleton instance = new Singleton();
    
        private Singleton() {
        
            // 私有化构造函数
        }
    
        public static Singleton getInstance() {
        
            return instance;
        }
    }

在上述代码中，Singleton 类的构造函数被私有化，确保外部无法直接创建对象实例。同时，通过定义一个静态的 instance 变量，并在类加载时进行初始化，实现了在整个应用程序中只有一个唯一实例的效果。外部通过调用 getInstance() 方法获取该实例。

#include<mutex>
    #include<iostream>
    #include<atomic>
    using namespace std;
    
    /*饿汉模式
    class singleton {
    public:
    //	singleton() = delete;
    	singleton(const singleton& s) = delete;
    	singleton& operator=(const singleton& s) = delete;
    	static singleton* getstatic() {
    		return st;
    	}
    	void print() {
    		cout << "12321" << endl;
    	}
    private:
    	singleton() = default;
    //	singleton(const singleton& s) = default;
    	static singleton* st;
    
    };
    singleton* singleton::st = new singleton;
    int main()
    {
    	singleton* single = singleton::getstatic();
    	single->print();
    
    	return 0;

使用饿汉模式的优点是实现简单，线程安全，因为在类加载时就已经创建了实例。但也有一些缺点，例如如果单例对象比较复杂，初始化时间较长，会导致程序启动时耗费较多时间。此外，如果该单例对象在整个应用程序生命周期中没有被使用，也会造成资源的浪费。

因此，在选择设计模式时，需要根据具体的需求和场景来决定是否使用饿汉模式。

### 懒汉模式 ###

懒汉模式（Lazy Initialization）是一种常见的单例设计模式，与饿汉模式相比，它延迟了单例对象的创建时间，即在第一次使用时才进行实例化。

实现懒汉模式的关键是将构造函数私有化，确保外部无法直接创建对象实例。同时，类内部定义一个静态成员变量用于保存唯一实例，并提供一个公共的静态方法用于获取该实例。在获取实例的方法中，会先判断实例是否已经被创建，如果没有则进行实例化。

以下是一个简单的懒汉模式的示例代码：

public class Singleton {
        
        private static Singleton instance;
    
        private Singleton() {
        
            // 私有化构造函数
        }
    
        public static Singleton getInstance() {
        
            if (instance == null) {
        
                instance = new Singleton();
            }
            return instance;
        }
    }

懒汉模式的优点是实现简单，只有在需要使用单例对象时才进行实例化，可以节省资源。但也存在一些问题，例如在多线程环境下，如果多个线程同时调用 getInstance() 方法，并且实例尚未被创建，可能会导致创建多个实例，破坏了单例的特性。因此，在懒汉模式中需要考虑线程安全的实现方式，例如使用双重检查锁定（Double-Checked Locking）或者静态内部类。

//懒汉模式

class singleton {
        
    public:
    	//	singleton() = delete;
    	singleton(const singleton& s) = delete;
    	singleton& operator=(const singleton& s) = delete;
    	static singleton* getstatic() {
        
    		
    		if (st == nullptr) {
        
    			st = new singleton;
    		}
    		return st;
    	}
    
    	//利用互斥锁解决多线程问题（有问题）
    	static singleton* getstatic() {
        
    		if (st == nullptr) {
        
    			m_mutex.lock();
    			if (st == nullptr) {
        
    
    				st = new singleton;
    			}
    			m_mutex.unlock();
    		}
    		
    		return st;
    	}
    
    	//利用原子变量解决底层问题  
    		static singleton* getstatic() {
        
    			singleton* st = ato.load();
    			if (st == nullptr) {
        
    			m_mutex.lock();
    			st = ato.load();
    			if (st == nullptr) {
        
    				st = new singleton;
    				ato.store(st);
    			}
    			m_mutex.unlock();
    		}
    		return st;
    	}
    		//或者利用·局部静态对象解决多线程问题
    
    	void print() {
        
    	cout << "12321" << endl;
    	}
    private:
    	singleton() = default;
    	//	singleton(const singleton& s) = default;
    	static singleton* st;
    
    	static mutex m_mutex;
    	static atomic<singleton*>  ato;
    
    };
    singleton* singleton::st = nullptr;
    mutex singleton::m_mutex;
    atomic<singleton*> singleton::ato;
    
    int main()
    {
        
    	singleton* single = singleton::getstatic();
    	single->print();
    
    	return 0;
    }

[https_bbs.csdn.net_topics_617804998]: https://bbs.csdn.net/topics/617804998
[https_bbs.csdn.net_topics_617897397]: https://bbs.csdn.net/topics/617897397