C++---单例模式

最新推荐文章于 2025-05-29 22:26:01 发布

cyy_0802

最新推荐文章于 2025-05-29 22:26:01 发布

阅读量466

点赞数

CC 4.0 BY-SA版权

分类专栏： C++

本文链接：https://blog.csdn.net/cyy_0802/article/details/86738525

C++ 专栏收录该内容

3 篇文章

订阅专栏

本文介绍了单例模式的概念，解释了为何使用单例模式，以及单例模式带来的好处，如减少内存开销和GC压力。同时，文章讨论了全局变量与单例模式的区别，并列举了七种单例模式实现方式，包括懒汉式和饿汉式及其线程安全的实现策略。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

（一）单例模式简介：

单例模式（数学与逻辑学中，singleton定义为"有且仅有一个元素的集合"），是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，保证一个类仅有一个实例，并提供一个访问它的全局访问点。

（二）为什么要用单例模式呢？

在我们的系统中，有一些对象其实我们只需要一个，比如说：线程池、缓存、对话框、注册表、日志对象、充当打印机、显卡等设备驱动程序的对象。事实上，这一类对象只能有一个实例，如果制造出多个实例就可能会导致一些问题的产生，比如：程序的行为异常、资源使用过量、或者不一致性的结果。

（三）简单来说使用单例模式可以带来下面几个好处:

对于频繁使用的对象，可以省略创建对象所花费的时间，这对于那些重量级对象而言，是非常可观的一笔系统开销；
由于 new 操作的次数减少，因而对系统内存的使用频率也会降低，这将减轻 GC 压力，缩短 GC 停顿时间。

为什么不使用全局变量确保一个类只有一个实例呢？

我们知道全局变量分为静态变量和实例变量，静态变量也可以保证该类的实例只存在一个。只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。

但是，如果说这个对象非常消耗资源，而且程序某次的执行中一直没用，这样就造成了资源的浪费。利用单例模式的话，我们就可以实现在需要使用时才创建对象，这样就避免了不必要的资源浪费。 不仅仅是因为这个原因，在程序中我们要尽量避免全局变量的使用，大量使用全局变量给程序的调试、维护等带来困难。

要点：

单例类只能有一个实例;
单例类必须自行（自己给自己）创建这个实例;
单例类必须向整个系统提供这个对象的实例。

从具体实现角度来说，三个步骤：

①通过new一个静态私有变量

private static Singleton instanc=new Singleton( );

②构造方法私有化

private Singleton(){ }

③新建一个静态的公共的函数用于创建或获取它本身的静态私有对象的方法（静态，不能依赖对象调用，不能返回类类型）

public static Singleton getIntance()

{ return 这个对象; }

一共有七中单例模式：

①饿汉式（浪费资源）

②饱汉式（数据不安全）-----解决办法：方法中加锁

③加同步锁

④加双重锁

⑤饿汉式（饿汉式的变种，由饿汉式改变而来）

将静态变量放在了一个静态内部类中（达到延时效果）

返回类名.变量名
（1）懒汉方式又称为延时加载，用的时候才生成。（考虑线程安全）

在第一次调用的时候才生成。
懒汉式单例是不安全的
要保证线程安全需要对getInstance()方法进行改造将介绍三种方式来确保线程安全

/*将方法设为同步*/
calss Signalton
{
   public:
       static Signalton* getInstance()
       {   
           if(instance == NULL)
           {
               instance = new Signalton();
           }
           return instance；
       }
   private:
       Signalton(){}
       Signalton(const Signalton&);
       Singleton& operator=(const Singleton&);
       static Signalton*instance;
}
Signalton*  Signalton::instance = NULL;
/*双锁机制：避免在已经存在实例时每次都进行锁操作，提高性能*/
calss Signalton
{
   public:
       static Signalton* getInstance()
       {
           if(instance == NULL)
           {
               //lock();
               if(instance == NULL)
               {
               instance = new Signalton();
               }
               //unlock();
           }
           return instance；
       }
   private:
       Signalton(){}
       Signalton(const Signalton&);
       Singleton& operator=(const Singleton&);
       static Signalton*instance;
}
Signalton*  Signalton::instance = NULL;
/*静态内部类,这种比上面1、2都好一些，既实现了线程安全，又避免了同步带来的性能影响。*/
calss Signalton
{
   public:
      static Signalton* getInstance()
       {
           static Signalton instance;
           return instance；
       }
   private:
       Signalton(){}
       Signalton(const Signalton&);
       Singleton& operator=(const Singleton&);
}
Signalton*  Signalton::instance = NULL;

（2）饿汉方式又称为贪婪加载，一开始就生成，及时不用的时候也生成。

calss Signalton
{
   public:
       Signalton* getInstance()
       {
          return instance;
       }
   private:
       Signalton(){}
       Signalton(const Signalton&);
       Singleton& operator=(const Singleton&);
       static Signalton*instance;
}
Signalton*  Signalton::instance = new Signalton();