Concurrency-with-Modern-Cpp学习笔记 - 单例模式性能比较

最新推荐文章于 2024-08-19 16:22:19 发布
最新推荐文章于 2024-08-19 16:22:19 发布
阅读量238 收藏
点赞数
分类专栏： c++ 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TM1695648164/article/details/119887180
版权

单例模式：线程安全的初始化

开始研究之前，说明一下：我个人并不提倡使用单例模式。

对于单例模式的看法

我只在案例研究中使用单例模式，因为它是以线程安全的方式，初始化变量的典型例子。先来了解一下单例模式的几个严重缺点：

  • 单例是一个经过乔装打扮的全局变量。因此，测试起来非常困难，因为它依赖于全局的状态。
  • 通过MySingleton::getInstance()可以在函数中使用单例，不过函数接口不会说明内部使用了单例，并隐式依赖于对单例。
  • 若将静态对象x和y放在单独的源文件中，并且这些对象的构造方式相互依赖，因为无法保证先初始化哪个静态对象，将陷入静态初始化混乱顺序的情况。这里要注意的是，单例对象是静态对象。
  • 单例模式是惰性创建对象，但不管理对象的销毁。如果不销毁不需要的东西，那就会造成内存泄漏。
  • 试想一下，当子类化单例化，可能实现吗？这意味着什么?
  • 想要实现一个线程安全且快速的单例，非常具有挑战性。

关于单例模式的详细讨论，请参阅Wikipedia中有关单例模式的文章。

我想在开始讨论单例的线程安全初始化前，先说点别的。

双重检查的锁定模式

双重检查锁定模式是用线程安全的方式，初始化单例的经典方法。听起来像是最佳实践或模式之类的方法，但更像是一种反模式。它假设传统实现中有相关的保障机制，而Java、C#或C++内存模型不再提供这种保障。这样，创建单例是原子操作就是一个错误的假设，这样看起来是线程安全的解决方案并不安全。

什么是双重检查锁定模式？实现线程安全单例的，首先会想到用锁来保护单例的初始化过程。

std::mutex myMutex;
class MySingleton
{
public:
    static MySingleton &getInstance()
    {
        std::lock_guard<mutex> myLock(myMutex);
        if (!instance) instance = new MySingleton(); //7
        return *instance;
    }
private:
    MySingleton() = default;
    ~MySingleton() = default;
    MySingleton(const MySingleton &) = delete;
    MySingleton &operator= (const MySingleton &) = delete;
    static MySingleton *instance;
};

MySingleton *MySingleton::instance = nullptr;

程序有毛病么？有毛病：是因为性能损失太大；没毛病：是因为实现的确线程安全。第7行的锁会对单例的每次访问进行保护，这也适用于读取。不过，构造MySingleton之后，就没有必要读取了。这里双重检查锁定模式就发挥了其作用，再看一下getInstance函数。

static MySingleton& getInstance() {
  if (!instance) { // check
    lock_guard<mutex> myLock(myMutex); // lock
    if (!instance) instance = new MySingleton(); // check
  }
  return *instance;
}

第2行没有使用锁，而是使用指针比较。如果得到一个空指针，则申请锁的单例(第3行)。因为，可能有另一个线程也在初始化单例，并且到达了第2行或第3行，所以需要额外的指针在第4行进行比较。顾名思义，其中两次是检查，一次是锁定。

牛B不？牛。线程安全？不安全。

问题出在哪里？第4行中的instance= new MySingleton()至少包含三个步骤：

  1. 为MySingleton分配内存。
  2. 初始化MySingleton对象。
  3. 引用完全初始化的MySingleton对象。

能看出问在哪了么？

​ C++运行时不能保证这些步骤按顺序执行。例如，处理器可能会将步骤重新排序为序列1、3和2。因此，在第一步中分配内存，在第二步中实例引用一个非初始化的单例。如果此时另一个线程t2试图访问该单例对象并进行指针比较，则比较成功。其结果是线程t2引用了一个非初始化的单例，并且程序行为未定义。

性能测试

​ 我要测试访问单例对象的开销。对引用测试时，使用了一个单例对象，连续访问4000万次。当然，第一个访问的线程会初始化单例对象，四个线程的访问是并发进行的。我只对性能数字感兴趣，因此我汇总了这四个线程的执行时间。使用一个带范围(Meyers Singleton)的静态变量、一个锁std::lock_guard、函数std::call_once和std::once_flag以及具有顺序一致和获取-释放语义的原子变量进行性能测试。

展示各种多线程实现的性能数字前，先来看一下串行的代码。C++03标准中，getInstance方法线程不安全。

// singletonSingleThreaded.cpp

#include <chrono>
#include <iostream>

constexpr auto tenMill = 10000000;

class MySingLeton
{
public:
    static MySingLeton &getInstance()
    {
        static MySingLeton instance;
        volatile int dummy{};
        return instance;
    }
private:
    MySingLeton() = default;
    ~MySingLeton() = default;
    MySingLeton(const MySingLeton &) = delete;
    MySingLeton &operator=(const MySingLeton &) = delete;

};

int main()
{
    constexpr auto fourtyMill = 4 * tenMill;
    const auto begin = std::chrono::system_clock::now();
    for (size_t i = 0; i <= fourtyMill; ++i)
    {
        MySingLeton::getInstance();
    }
    const auto end = std::chrono::system_clock::now() - begin;
    std::cout << std::chrono::duration<double>(end).count() << std::endl;

}

在这里插入图片描述

使用volatile声明变量dummy

当我用最高级别的优化选项来编译程序时，编译器删除了第30行中的MySingleton::getInstance()，因为调用不调用都没有效果，我得到了非常快的执行，但结果错误的性能数字。通过使用volatile声明变量dummy(第12行)，明确告诉编译器不允许优化第30行中的MySingleton::getInstance()调用。

C++11中，Meyers单例已经线程安全了。

线程安全的Meyers单例

C++11标准中，保证以线程安全的方式初始化具有作用域的静态变量。Meyers单例使用就是有作用域的静态变量，这样就成了！剩下要做的工作，就是为多线程用例重写Meyers单例。

多线程中的Meyers单例

// singletonMeyers.cpp

#include <chrono>
#include <iostream>
#include <future>

constexpr auto tenMill = 10000000;

class MySingLeton
{
public:
    static MySingLeton &getInstance()
    {
        static MySingLeton instance;
        volatile int dummy{};
        return instance;
    }
private:
    MySingLeton() = default;
    ~MySingLeton() = default;
    MySingLeton(const MySingLeton &) = delete;
    MySingLeton &operator=(const MySingLeton &) = delete;

};

std::chrono::duration<double> getTime()
{

    auto begin = std::chrono::system_clock::now();
    for (size_t i = 0; i <= tenMill; ++i)
    {
        MySingLeton::getInstance();
    }
    return std::chrono::system_clock::now() - begin;
}

int main()
{
    auto fut1 = std::async(std::launch::async, getTime);
    auto fut2 = std::async(std::launch::async, getTime);
    auto fut3 = std::async(std::launch::async, getTime);
    auto fut4 = std::async(std::launch::async, getTime);
    const auto total = fut1.get() + fut2.get() + fut3.get() + fut4.get();
    std::cout << total.count() << std::endl;
}

在这里插入图片描述

函数getTime中使用单例对象(第24 - 32行)，函数由第36 - 39行中的四个promise来执行，相关future的结果汇总在第41行。

我们来看看最直观的方式——锁。

std::lock_guard

std::lock_guard中的互斥量，保证了能以线程安全的方式初始化单例对象。

// singletonLock.cpp

#include <chrono>
#include <iostream>
#include <future>
#include <mutex>

constexpr auto tenMill = 10000000;

std::mutex myMutex;

class MySingleton
{
public:
    static MySingleton &getInstance()
    {
        std::lock_guard<std::mutex> myLock(myMutex);
        if (!instance)
        {
            instance = new MySingleton();
        }
        volatile int dummy{};
        return *instance;
    }
private:
    MySingleton() = default;
    ~MySingleton() = default;
    MySingleton(const MySingleton &) = delete;
    MySingleton &operator=(const MySingleton &) = delete;

    static MySingleton *instance;
};

MySingleton *MySingleton::instance = nullptr;

std::chrono::duration<double> getTime()
{

    auto begin = std::chrono::system_clock::now();
    for (size_t i = 0; i <= tenMill; ++i)
    {
        MySingleton::getInstance();
    }
    return std::chrono::system_clock::now() - begin;

}

int main()
{

    auto fut1 = std::async(std::launch::async, getTime);
    auto fut2 = std::async(std::launch::async, getTime);
    auto fut3 = std::async(std::launch::async, getTime);
    auto fut4 = std::async(std::launch::async, getTime);

    const auto total = fut1.get() + fut2.get() + fut3.get() + fut4.get();

    std::cout << total.count() << std::endl;

}

这种方式非常的慢。

在这里插入图片描述

线程安全单例模式的下一个场景，基于多线程库，并结合std::call_once和std::once_flag。

使用std::once_flag的std::call_once

std::call_once和std::once_flag可以一起使用，以线程安全的方式执行可调用对象。

// singletonCallOnce.cpp

#include <chrono>
#include <iostream>
#include <future>
#include <mutex>
#include <thread>

constexpr auto tenMill = 10000000;

class MySingleton
{
public:
    static MySingleton &getInstance()
    {
        std::call_once(initInstanceFlag, &MySingleton::initSingleton);
        volatile int dummy{};
        return *instance;
    }
private:
    MySingleton() = default;
    ~MySingleton() = default;
    MySingleton(const MySingleton &) = delete;
    MySingleton &operator=(const MySingleton &) = delete;

    static MySingleton *instance;
    static std::once_flag initInstanceFlag;

    static void initSingleton()
    {
        instance = new MySingleton;
    }
};

MySingleton *MySingleton::instance = nullptr;
std::once_flag MySingleton::initInstanceFlag;

std::chrono::duration<double> getTime()
{

    auto begin = std::chrono::system_clock::now();
    for (size_t i = 0; i <= tenMill; ++i)
    {
        MySingleton::getInstance();
    }
    return std::chrono::system_clock::now() - begin;

}

int main()
{

    auto fut1 = std::async(std::launch::async, getTime);
    auto fut2 = std::async(std::launch::async, getTime);
    auto fut3 = std::async(std::launch::async, getTime);
    auto fut4 = std::async(std::launch::async, getTime);

    const auto total = fut1.get() + fut2.get() + fut3.get() + fut4.get();

    std::cout << total.count() << std::endl;

}

在这里插入图片描述

继续使用原子变量来实现线程安全的单例。

原子变量

使用原子变量，让实现变得更具有挑战性，我甚至可以为原子操作指定内存序。基于前面提到的双重检查锁定模式，实现了以下两个线程安全的单例。

顺序一致语义

第一个实现中，使用了原子操作，但没有显式地指定内存序，所以默认是顺序一致的。

// singletonSequentialConsistency.cpp

#include <chrono>
#include <iostream>
#include <future>
#include <mutex>
#include <thread>

constexpr auto tenMill = 10000000;

class MySingleton
{
public:
    static MySingleton &getInstance()
    {
        MySingleton *sin = instance.load();
        if (!sin)
        {
            std::lock_guard<std::mutex>myLock(myMutex);
            sin = instance.load(std::memory_order_relaxed);
            if (!sin)
            {
                sin = new MySingleton();
                instance.store(sin);
            }
        }
        volatile int dummy{};
        return *instance;
    }
private:
    MySingleton() = default;
    ~MySingleton() = default;
    MySingleton(const MySingleton &) = delete;
    MySingleton &operator=(const MySingleton &) = delete;

    static std::atomic<MySingleton *> instance;
    static std::mutex myMutex;
};


std::atomic<MySingleton *> MySingleton::instance;
std::mutex MySingleton::myMutex;

std::chrono::duration<double> getTime()
{

    auto begin = std::chrono::system_clock::now();
    for (size_t i = 0; i <= tenMill; ++i)
    {
        MySingleton::getInstance();
    }
    return std::chrono::system_clock::now() - begin;

}

int main()
{

    auto fut1 = std::async(std::launch::async, getTime);
    auto fut2 = std::async(std::launch::async, getTime);
    auto fut3 = std::async(std::launch::async, getTime);
    auto fut4 = std::async(std::launch::async, getTime);

    const auto total = fut1.get() + fut2.get() + fut3.get() + fut4.get();

    std::cout << total.count() << std::endl;

}

在这里插入图片描述

与双重检查锁定模式不同，由于原子操作的默认是顺序一致的，现在可以保证第19行中的sin = new MySingleton()出现在第20行instance.store(sin)之前。看一下第17行：sin = instance.load(std::memory_order_relax)，因为另一个线程可能会在第14行第一个load和第16行锁的使用之间，介入并更改instance的值，所以这里的load是必要的。

我们进一步的对程序进行优化。

获取-释放语义

仔细看看之前使用原子实现单例模式的线程安全实现。第14行中单例的加载(或读取)是一个获取操作，第20行中存储(或写入)是一个释放操作。这两种操作都发生在同一个原子上，所以不需要顺序一致。C++11标准保证释放与获取操作在同一原子上同步，并建立顺序约束。也就是，释放操作之后，不能移动之前的所有读和写操作，并且在获取操作之前不能移动之后的所有读和写操作。

这些都是实现线程安全单例的最低保证。

// singletonAcquireRelease.cpp

#include <chrono>
#include <iostream>
#include <future>
#include <mutex>
#include <thread>

constexpr auto tenMill = 10000000;

class MySingleton
{
public:
    static MySingleton &getInstance()
    {
        MySingleton *sin = instance.load(std::memory_order_acquire);
        if (!sin)
        {
            std::lock_guard<std::mutex>myLock(myMutex);
            sin = instance.load(std::memory_order_release);
            if (!sin)
            {
                sin = new MySingleton();
                instance.store(sin);
            }
        }
        volatile int dummy{};
        return *instance;
    }
private:
    MySingleton() = default;
    ~MySingleton() = default;
    MySingleton(const MySingleton &) = delete;
    MySingleton &operator=(const MySingleton &) = delete;

    static std::atomic<MySingleton *> instance;
    static std::mutex myMutex;
};


std::atomic<MySingleton *> MySingleton::instance;
std::mutex MySingleton::myMutex;

std::chrono::duration<double> getTime()
{

    auto begin = std::chrono::system_clock::now();
    for (size_t i = 0; i <= tenMill; ++i)
    {
        MySingleton::getInstance();
    }
    return std::chrono::system_clock::now() - begin;

}

int main()
{

    auto fut1 = std::async(std::launch::async, getTime);
    auto fut2 = std::async(std::launch::async, getTime);
    auto fut3 = std::async(std::launch::async, getTime);
    auto fut4 = std::async(std::launch::async, getTime);

    const auto total = fut1.get() + fut2.get() + fut3.get() + fut4.get();

    std::cout << total.count() << std::endl;

}

获取-释放语义与顺序一致内存序有相似的性能。

在这里插入图片描述

各种线程安全单例实现的性能表现总结

​ 数字很明确，Meyers 单例模式是最快的。它不仅是最快的，也是最容易实现的。如预期的那样，Meyers单例模式比原子模式快两倍。锁的量级最重，所以最慢。std::call_once在Windows上比在Linux上慢得多。

操作系统(编译器)单线程Meyers单例std::lock_guardstd::call_once顺序一致获取-释放语义
Linux(GCC)0.1500.29536.971.611.711.72
cpp单例模式的实现
ptgood的博客
08-17 1730
单例模式的意义 保证全局只会创建一个对象,比如 日志模块全局只有一个,windows的任务管理器等,这样可以避免频繁的创建销毁对象,还可以避免对共享资源的多重占用,具体例子和好处坏处看参考资料[9],不赘述 几种考虑 几个要考虑的问题:懒加载;;线程安全生存周期的考虑;;反序列化;;反射单例;;克隆单例 首先是一个唯一性,保证全部成员只能访问到一个共同的对象 为了防止对象被创建多次,要把构造函数设为private,以防止被他人调用重复建立,而自己单独实现一个接口用来获取实例(可以把构造函数当作这个
Mastering-Concurrency-in-Python:Packt发行的《掌握Python中的并发性》
05-27
Python是目前最流行的编程语言之一，它具有众多促进高性能计算的库和框架。 尽管Python中的并发和并行行为与其他编程语言不同，但是仍然可以以各种方式实现同​​时运行或并行运行的Python程序，并大大缩短了执行...
单例模式CPP
m0_60007338的博客
10-13 728
单例模式CPP
【C++】单例模式的解析与应用
最新发布
richard_yuu的博客
08-19 1073
单例模式是面向对象编程中一种重要的设计模式，它通过确保一个类只有一个实例来简化资源管理和访问。在C++中，实现单例模式需要考虑线程安全、延迟加载等因素，并选择合适的实现方式。通过合理使用单例模式，我们可以提高代码的复用性和可维护性，同时降低资源消耗。然而，也需要注意避免滥用单例模式，以免导致代码结构混乱和难以维护。
cpp的单例模式。
逐梦如风-毕康
11-15 1574
cpp的单例模式。禁止在外部使用，构造器，拷贝构造器，赋值重载在一些场合是很有用。// // main.cpp // singleData // // Created by bikang on 16/11/15. // Copyright (c) 2016年 bikang. All rights reserved. //#include <iostream>class SignalClass
使用cpp 写一个单例
weixin_35756892的博客
01-03 156
确保单例模式的 C++ 实现可以被多线程安全地使用，可以使用如下代码: #include <mutex> class Singleton { public: static Singleton&amp; GetInstance() { static Singleton instance; return instance; } private: ...
cpp单例的设计模式
小宇的博客
08-18 1140
定义：确保一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。 类型：创建类模式 类图：
Node.js-concurrency-loggerHTTP日志中间件
08-09
至于文件`PabloSichert-concurrency-logger-59c2d94`，这看起来是`concurrency-logger`项目的一个特定版本或分支。通常，这样的文件名表示它是从Git仓库中克隆下来的，其中`PabloSichert`可能是作者或维护者的用户名...
Hands-On-Concurrency-with-Rust:Packt发行的Rust的动手并发
05-28
本书将教您如何在现代机器上管理程序性能以及如何在Rust中构建快速，内存安全的并发软件。 它从Rust的基础开始，并讨论了机器体系结构的概念。 我们将带您逐步系统地测量和改进Rust代码的性能，以及如何自信地编写...
CPP-Concurrency-In-Action-2ed-2019-master.zip
12-31
9. **并发策略与设计模式**：介绍各种并发编程的设计模式，如生产者-消费者模型、读写锁等。 10. **性能优化与调试**：提供性能分析和并发代码调试的技巧，帮助开发者优化并发程序。 通过学习这本书，读者不仅可以...
ember-concurrency-retryable:一个Ember插件，添加重试策略和一个任务修饰符，用于自动重试ember-concurrency任务
04-28
ember install ember-concurrency-retryable 文献资料 贡献/报告问题 有关详细信息，请参见指南。 执照 该项目是根据。 谢谢 用于 ，此附加方法基于此。 Devin Weaver在我的原始余烬并发RFC中为可重试任务提供了很...
Cpp真经7---单例模式
weixin_43604927的博客
01-23 469
/ SingleTon 1 default constructor and copy constructro must be private 2 make a instance pointor and set it private 3 provide a getInstance Method to be external so that user can get the sole instance / #include <iostream> using namespace std; /*****
单例模式学习cpp
m0_61862494的博客
07-23 445
现在我们要求定义一个表示总统的类型。presented可以从该类型继承出French present和American present的等类型。这些派生类型都只能产生一个实例为了设计一个表示总统的类型，并从该类型派生出只能产生一个实例的具体总统（如法国总统和美国总统），我们可以利用单例模式和继承来实现。President。
实践1-设计模式-可以扩展的cpp多线程单例模式
搜索引擎预备工程师
01-13 209
可以扩展的多线程单例模式 单例模式真可谓非常出名了, 但是一般大家的探究仅仅止步于如何从多线程安全的角度来实现它. 我今天在网友的智慧的基础上往前再走一步, 提出可以支持扩展的单例模式. 在这篇文章中, 你将了解到4中单例模式, 它们层层递进. 它们分别是 (1) 隐藏构造函数的基本单例模式 (2) 支持多线程的单例模式 (3) 使用模板支持扩展的借助 static 成员属性的单例模式 (4) 使用模板支持扩展的借助 static 局部变量的单例模式 最后两个方法是我本人想了三个小时摸索出来的, 我还没有看
Cpp利用单例模式实现“动态”创建对象
m0_70349506的博客
10-09 89
2、创建一个类（本身有一个newClass的静态函数）如果哪里有错误的话请指出。
C++设计模式---单例模式
精致的灰的博客
09-16 1455
单例模式
单例模式(C++)
zxf347085420的博客
03-14 3417
单例模式
cppunit与单例模式
凡星闪点
03-07 370
cppunit用到单例模式的地方只有一处，那就是在TestFactoryRegistry.cpp文件的TestFactoryRegistryList类中，它提供一个静态类函数如下：   static TestFactoryRegistryList *getInstance()   {     static TestFactoryRegistryList list;     return &
[C/C++] -- 单例模式
Afison的博客
05-07 848
单例模式是一种创建型设计模式，它确保类只有一个实例，并提供全局访问点以访问该实例。
Key-Value数据库的MVCC无锁事务设计与OracleCoherence应用
MVCC (Multi-Version Concurrency Control) 是一种在分布式系统中实现并发控制的有效方式，特别适合于Key-Value数据库。MVCC的核心理念是在多个事务同时访问数据时，每个事务看到的是数据的一个版本，而非实时更新，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值