Concurrency-with-Modern-Cpp学习笔记 - 性能比较

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

求向量元素的加和

向std::vector中添加元素最快的方法是哪种？为了得到答案，我准备向std::vector中填充了一亿个数值，这些数在1~10之间均匀分布 。我们的任务是用各种方法计算这些数字的和，并添加执行时间作为性能指标。本节将讨论原子、锁、线程本地数据和任务。

单线程方式

最直接的方式是使用for循环进行数字的添加。

for循环

下面的代码中，第27行进行加和计算。

// calculateWithLoop.cpp

#include <chrono>
#include <iostream>
#include <random>
#include <vector>

constexpr long long size = 100000000;

int main()
{

    std::cout << std::endl;

    std::vector<int>randValues;
    randValues.reserve(size);

    // random values
    std::random_device seed;
    std::mt19937 engine(seed());
    std::uniform_int_distribution<> uniformDIst(1, 10);
    for (long long i = 0; i < size; ++i)
        randValues.push_back(uniformDIst(engine));

    const auto sta = std::chrono::steady_clock::now();

    unsigned long long sum = {};
    for (auto n : randValues)sum += n;

    const std::chrono::duration<double> dur =
        std::chrono::steady_clock::now() - sta;

    std::cout << "Time for mySumition " << dur.count()
              << "seconds" << std::endl;
    std::cout << "Result: " << sum << std::endl;
    std::cout << std::endl;
}

在这里插入图片描述

显式地使用循环没什么技术含量。大多数情况下，可以使用标准模板库中的算法。

使用std::accumulate进行加和计算

std::accumulate是计算向量和的正确选择，下面代码展示了std::accumulate的使用方法。完整的源文件可以在本书的参考资料中找到。

// calculateWithStd.cpp
...
const unsigned long long sum = std::accumulate(randValues.begin(),
              randValues.end(), 0);
...

Linux上，std::accumulate的性能与for循环的性能大致相同

在这里插入图片描述

现在有了基线参考时间，就可以继续剩余的两个单线程场景了：使用锁和原子操作。为什么是这两个场景？我们需要有性能数字佐证，在没有竞争的情况下，锁和原子操作对数据进行保护，需要付出多大的性能代价。

使用锁进行保护

如果使用锁保护对求和变量的访问，需要回答两个问题。

  1. 无争抢的同步锁，需要多大的代价?
  2. 最优的情况下，锁能有多快？

这里使用std::lock_guard的方式

    unsigned long long sum;
    std::mutex myMutex;
    for (auto i: randValues){
      std::lock_guard<std::mutex> myLockGuard(myMutex);
      sum += i;
    }

在这里插入图片描述

执行时间与预期的一样：对变量sum进行保护后，程序变得很慢。

std::lock_guard的方式大约比std::accumulate慢50-150倍。接下来，让我们来看看原子操作的表现。

使用原子操作进行保护

对于原子操作的问题与锁一样：

  1. 原子同步的代价有多大?
  2. 如果没有竞争，原子操作能有多快?

还有一个问题：原子操作和锁的性能有多大差异?

在这里插入图片描述

单线程场景总结

  1. 原子操作在Linux和Windows上的速度比std::accumulate要慢12 - 50倍。
  2. 在Linux和Windows上，原子操作的速度比锁快2 - 3倍。
  3. std::accumulate似乎在Windows上有更好的优化。

进行多线程场景测试之前，用表总结了单线程执行的结果，时间单位是秒。

操作系统(编译器)for循环std::accumulate锁原子操作
Linux(GCC)1.401.254.712.98/2.88

多线程：使用共享变量进行求和

使用四个线程并用共享变量进行求和，并不是最优的最优的方式，因为同步开销超过了性能收益。

还是那两个问题：

  1. 使用锁和原子的求和方式，在性能上有什么不同?
  2. std::accumulate的单线程执行和多线程执行的性能表现有什么不同?

使用std::lock_guard

实现线程安全的求和，最简单方法是使用std::lock_guard。

// synchronisationWithLock.cpp

#include<chrono>
#include <iostream>
#include <mutex>
#include <random>
#include <thread>
#include <utility>
#include <vector>

constexpr long long size = 100000000;

constexpr long long fir = 25000000;
constexpr long long sec = 50000000;
constexpr long long thi = 75000000;
constexpr long long fou = 100000000;

std::mutex myMutex;

void sumUp(unsigned long long &sum, const std::vector<int> &val,
           unsigned long long beg, unsigned long long end)
{
    for (auto it = beg; it < end; ++it)
    {
        std::lock_guard<std::mutex> myLock(myMutex);
        sum += val[it];
    }
}

int main()
{

    std::cout << std::endl;

    std::vector<int> randValues;
    randValues.reserve(size);

    std::mt19937 engine;
    std::uniform_int_distribution<> uniformDist(1, 10);
    for (long long i = 0; i < size; ++i)
        randValues.push_back(uniformDist(engine));

    unsigned long long sum = 0;
    const auto sta = std::chrono::steady_clock::now();

    std::thread t1(sumUp, std::ref(sum), std::ref(randValues), 0, fir);
    std::thread t2(sumUp, std::ref(sum), std::ref(randValues), fir, sec);
    std::thread t3(sumUp, std::ref(sum), std::ref(randValues), sec, thi);
    std::thread t4(sumUp, std::ref(sum), std::ref(randValues), thi, fou);

    t1.join();
    t2.join();
    t3.join();
    t4.join();

    std::chrono::duration<double> dur = std::chrono::steady_clock::now() - sta;
    std::cout << "Time for addition " << dur.count()
              << " seconds" << std::endl;
    std::cout << "Result: " << sum << std::endl;

    std::cout << std::endl;

}

程序很简单，函数sumUp(第20 - 26行)是需要线程完成的工作包。通过引用的方式得到变量sum和std::vector val，beg和end用来限定求和的范围，std::lock_guard(第23行)用于保护共享变量sum。每个线程(第43 - 46行)对四分之一的数据进行加和计算。

下面是我电脑上的性能数据：

在这里插入图片描述

因为std::lock_guard需要对行了同步，所以瓶颈在共享变量sum处。简单直接的解决方案：用轻量级的原子操作来替换重量级的锁。

使用原子变量

求和变量sum是一个原子变量，就不再需要std::lock_guard。以下是修改后的求和函数。

void sumUp(std::atomic<unsigned long long> &sum, const  std::vector<int> &val,
           unsigned long long beg, unsigned long long end)
{
    for (auto it = beg; it < end; ++it)
    {
        sum += val[it];
    }
}

在这里插入图片描述

除了使用+=操作符外，还可以使用fetch_add。

void sumUp(std::atomic<unsigned long long> &sum, const std::vector<int> &val,
           unsigned long long beg, unsigned long long end)
{
    for (auto it = beg; it < end; ++it)
    {
        sum.fetch_add(val[it]);
    }
}

现在的性能与前面的例子相似，操作符+=和fetch_add之间貌似没有什么区别。

在这里插入图片描述

虽然+=操作和fetch_add在性能上没有区别，但是fetch_add有一个优势，可以显式地弱化内存序，并使用自由语义。

使用自由语义的fetch_add

void sumUp(std::atomic<unsigned long long> &sum, const std::vector<int> &val,
           unsigned long long beg, unsigned long long end)
{
    for (auto it = beg; it < end; ++it)
    {
        sum.fetch_add(val[it], std::memory_order_relaxed);
    }
}

在这里插入图片描述

原子变量默认是顺序一致的。对于原子变量的加和和赋值，使用fetch_add是没问题的，也可以进行优化。我将求和表达式中的内存序调整为自由语义：sum.fetch_add (val[it],std::memory_order_relaxed)。自由语义是最弱的内存序，也是我们优化的终点。

这个用例中，自由语义能很好的完成工作，因为fetch_add进行的每个加和都是原子的，并且线程会进行同步。

因为是最弱的内存模型，所以性能最好。

多线程使用共享变量求和总结

性能数值的时间单位是秒。

操作系统(编译器)std::lock_guard原子 +=fetch_addfetch_add (使用自由内存序)
Linux(GCC)28.713.243.203.07

性能数据并不乐观，使用自由语义的共享原子变量，在四个线程的帮助下计算加和，其速度大约比使用std::accumulate算法的单个线程慢100倍。

结合前面的两种加和的策略，接下来会使用四个线程，并尽量减少线程之间的同步。

线程本地的加和

接下来使用局部变量、线程本地数据和任务，可以最小化同步。

使用本地变量

每个线程都使用本地变量求和，所以可以在不同步的情况下完成自己的工作。不过，汇总局部变量的总和时需要进行同步。简单地说：只添加了4个同步，所以从性能的角度来看，使用哪种同步并不重要。我使用std::lock_guard和一个具有顺序一致语义和自由语义的原子变量。

std::lock_guard

使用std::lock_guard进行最小化同步的加和计算。

// localVariable.cpp

#include <mutex>
#include<chrono>
#include <iostream>
#include <random>
#include <thread>
#include <utility>
#include <vector>

constexpr long long size = 100000000;

constexpr long long fir = 25000000;
constexpr long long sec = 50000000;
constexpr long long thi = 75000000;
constexpr long long fou = 100000000;

std::mutex myMutex;

void sumUp(unsigned long long &sum, const std::vector<int> &val,
           unsigned long long beg, unsigned long long end)
{
    unsigned long long tmpSum{};
    for (auto i = beg; i < end; ++i)
    {
        tmpSum += val[i];
    }
    std::lock_guard<std::mutex> lockGuard(myMutex);
    sum += tmpSum;
}

int main()
{

    std::cout << std::endl;

    std::vector<int> randValues;
    randValues.reserve(size);

    std::mt19937 engine;
    std::uniform_int_distribution<> uniformDist(1, 10);
    for (long long i = 0; i < size; ++i)
        randValues.push_back(uniformDist(engine));

    unsigned long long sum{};
    const auto sta = std::chrono::steady_clock::now();

    std::thread t1(sumUp, std::ref(sum), std::ref(randValues), 0, fir);
    std::thread t2(sumUp, std::ref(sum), std::ref(randValues), fir, sec);
    std::thread t3(sumUp, std::ref(sum), std::ref(randValues), sec, thi);
    std::thread t4(sumUp, std::ref(sum), std::ref(randValues), thi, fou);

    t1.join();
    t2.join();
    t3.join();
    t4.join();

    std::chrono::duration<double> dur =
        std::chrono::steady_clock::now() - sta;


    std::cout << "Time for addition " << dur.count()
              << " seconds" << std::endl;
    std::cout << "Result: " << sum << std::endl;

    std::cout << std::endl;

}

第26和27行，将局部求和结果tmpSum添加到全局求和变量sum中。

在这里插入图片描述

接下来使用局部变量的示例中，只有函数求和方式发生了变化，所以只展示这个函数体实现。完整的程序代码，请参考源文件。

使用顺序一致语义的原子变量

让我们用一个原子变量来声明全局求和变量sum。

下面是具体的性能数据：

void sumUp(std::atomic<unsigned long long> &sum, const std::vector<int> &val,
           unsigned long long beg, unsigned long long end)
{
    std::atomic<unsigned long long> tmpSum{};
    for (auto i = beg; i < end; ++i)
    {
        tmpSum += val[i];
    }
    sum += tmpSum;
}

在这里插入图片描述

使用自由语义的原子变量

现在不使用默认的内存序，而使用的是自由语义。只需要保证，所有求和操作是原子的就好。

在这里插入图片描述

使用线程本地数据

线程本地数据属于创建它的线程，其只在需要时被创建，非常适合于本地求和。

// threadLocalSummation.cpp

#include <atomic>
#include<chrono>
#include <iostream>
#include <random>
#include <thread>
#include <utility>
#include <vector>

constexpr long long size = 100000000;

constexpr long long fir = 25000000;
constexpr long long sec = 50000000;
constexpr long long thi = 75000000;
constexpr long long fou = 100000000;

thread_local unsigned long long tmpSum = 0;

void sumUp(std::atomic<unsigned long long> &sum, const std::vector<int> &val,
           unsigned long long beg, unsigned long long end)
{
    for (auto i = beg; i < end; ++i)
    {
        tmpSum += val[i];
    }
    sum.fetch_add(tmpSum, std::memory_order_relaxed);
}

int main()
{

    std::cout << std::endl;

    std::vector<int> randValues;
    randValues.reserve(size);

    std::mt19937 engine;
    std::uniform_int_distribution<> uniformDist(1, 10);
    for (long long i = 0; i < size; ++i)
        randValues.push_back(uniformDist(engine));

    std::atomic<unsigned long long> sum{};
    const auto sta = std::chrono::steady_clock::now();

    std::thread t1(sumUp, std::ref(sum), std::ref(randValues), 0, fir);
    std::thread t2(sumUp, std::ref(sum), std::ref(randValues), fir, sec);
    std::thread t3(sumUp, std::ref(sum), std::ref(randValues), sec, thi);
    std::thread t4(sumUp, std::ref(sum), std::ref(randValues), thi, fou);

    t1.join();
    t2.join();
    t3.join();
    t4.join();

    std::chrono::duration<double> dur =
        std::chrono::steady_clock::now() - sta;

    std::cout << "Time for addition " << dur.count()
              << " seconds" << std::endl;
    std::cout << "Result: " << sum << std::endl;

    std::cout << std::endl;

}

第18行中声明了线程本地变量tmpSum，并在第23和25行中使用它进行加和。

下面是使用本地变量加和的性能数据：

在这里插入图片描述

最后，来看下如何使用任务(task)完成这项工作。

使用任务

使用任务，我们可以使用隐式同步完成整个工作。每个部分求和在单独的线程中执行，最后在主线程中进行求和。

代码如下：

// tasksSummation.cpp

#include<chrono>
#include <future>
#include <iostream>
#include <random>
#include <thread>
#include <utility>
#include <vector>

constexpr long long size = 100000000;

constexpr long long fir = 25000000;
constexpr long long sec = 50000000;
constexpr long long thi = 75000000;
constexpr long long fou = 100000000;

void sumUp(std::promise<unsigned long long> &&prom, const std::vector<int> &val,
           unsigned long long beg, unsigned long long end)
{
    unsigned long long sum = {};
    for (auto i = beg; i < end; ++i)
    {
        sum += val[i];
    }
    prom.set_value(sum);
}

int main()
{

    std::cout << std::endl;

    std::vector<int> randValues;
    randValues.reserve(size);

    std::mt19937 engine;
    std::uniform_int_distribution<> uniformDist(1, 10);
    for (long long i = 0; i < size; ++i)
        randValues.push_back(uniformDist(engine));

    std::promise<unsigned long long> prom1;
    std::promise<unsigned long long> prom2;
    std::promise<unsigned long long> prom3;
    std::promise<unsigned long long> prom4;

    auto fut1 = prom1.get_future();
    auto fut2 = prom2.get_future();
    auto fut3 = prom3.get_future();
    auto fut4 = prom4.get_future();

    const auto sta = std::chrono::steady_clock::now();

    std::thread t1(sumUp, std::move(prom1), std::ref(randValues), 0, fir);
    std::thread t2(sumUp, std::move(prom2), std::ref(randValues), fir, sec);
    std::thread t3(sumUp, std::move(prom3), std::ref(randValues), sec, thi);
    std::thread t4(sumUp, std::move(prom4), std::ref(randValues), thi, fou);

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

    std::chrono::duration<double> dur = std::chrono::steady_clock::now() - sta;
    std::cout << "Time for addition " << dur.count()
              << " seconds" << std::endl;
    std::cout << "Result: " << sum << std::endl;

    t1.join();
    t2.join();
    t3.join();
    t4.join();

    std::cout << std::endl;

}

在这里插入图片描述

第39 - 47行定义了四个promise和future。第51 - 54行中，每个promise都被移动到线程中。promise只能移动，不能复制。sumUp的第一个参数使用右值引用的promise。future在第56行使用阻塞的get获取求和结果。

所有线程本地求和场景的总结

无论是使用局部变量，任务来部分求和，还是各种同步原语(如原子)，性能上好像没有太大的区别，只有线程本地数据似乎让程序变慢了一些。这个观察结果适用于Linux和Windows，不要对Linux相对于Windows的更高性能感到惊讶。别忘了，Linux的电脑上有4个核

操作系统(编译器)std::lock_guard使用顺序一致语义的原子变量使用自由语义的原子变量线程本地数据任务
Linux(GCC)0.2740.2690.2650.2450.269

多线程的本地求和的速度，大约是单线程求和的两倍。因为线程之间几乎不需要同步，所以在最优的情况下，我认为性能会提高四倍。背后的根本原因是什么？

总结：求向量元素的加和

单线程

基于for循环和STL算法std::accumulate的性能差不多。优化版本中，编译器会使用向量化的SIMD指令(SSE或AVX)用于求和。因此，循环计数器增加了4(SSE)或8(AVX)。

使用共享变量多线程求和

使用共享变量作为求和变量，可以说明了一点：同步操作是代价是非常昂贵的，应该尽可能避免。虽然我使用了原子变量，甚至打破了顺序一致性，但这四个线程比一个线程还要慢100倍。从性能角度考虑，要尽可能减少同步。

线程本地求和

线程本地求和仅比单线程for循环或std::accumulate快两倍，即使四个线程都可以独立工作，这种情况仍然存在。这也让我很惊讶，因为我原以为会有四倍的性能提升。更让我惊讶的是，电脑的四个核心并没有充分利用。

虾球xz
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Concurrency-with-Modern-Cpp学习笔记 内存模型的基础知识
虾球
08-15 253
c++ 学习笔记 内存模型的基础知识 引用cppreference.com中对内存位置的定义： 标量对象(算术类型、指针类型、枚举类型或std::nullptr_t)， 或非零长度的连续序列。 下面是内存位置的例子: struct S { char a; // memory location #1 int b : 5; // memory location #2 int c : 11, // memory location #2 (continued)
Concurrency-with-Modern-Cpp学习笔记 - 并发架构
虾球
08-24 246
并发架构 活动对象的设计模式将执行与调用进行解耦，每个对象会留在自己的控制线程中，其目标是通过使用异步方法和调度器来引入并发。维基百科：Active object 监控对象的设计模式，会同步并发方法的执行，以确保对象每次只运行一个成员函数。并且，还允许对象的成员函数协同调度序列的执行。 半同步/半异步体系结构模式，在并发系统中对异步和同步服务处理进行解耦，从而在不降低太多性能的情况下简化编程。该模式引入了两个通信层，一个用于异步，另一个用于同步。 活动对象 ​ 活动对象模式将执行与对象的成员
Concurrency-with-Modern-Cpp学习笔记 - C++的六种内存序
虾球
08-15 1005
C++的六种内存序 原子操作默认的内存序是std::memory_order_seq_cst，这表示顺序一致。也可以显式地指定其他五个中的一个 enum memory_order { memory_order_relaxed, memory_order_consume, memory_order_acquire, memory_order_release, memory_order_acq_rel, memory_order_seq_cst } 原子操作的种类 这里有三种不同类型的
[modern c++] 细粒度锁的concurrency数据结构
ykun089的博客
03-31 342
前言 https://blog.csdn.net/ykun089/article/details/115349993中描述的是 serilization 模式的数据结构，其锁的粒度很大，虽然说是多线程安全的，但是无法进行并发（concurrency）访问，从而导致同一时刻只能有一个线程在操作数据结构。 如果想实现并发访问，一种是使用低粒度锁的数据结构，另一种就是无锁的数据结构设计。其实低粒度锁属于 “伪并发”，它在是否能真正设计成并发需要视应用场景而定。 虽然都有锁，粗粒度锁就是串行化访问，低粒度锁.
Node.js-concurrency-loggerHTTP日志中间件
08-09
至于文件`PabloSichert-concurrency-logger-59c2d94`，这看起来是`concurrency-logger`项目的一个特定版本或分支。通常，这样的文件名表示它是从Git仓库中克隆下来的，其中`PabloSichert`可能是作者或维护者的用户名...
Mastering-Concurrency-in-Python:Packt发行的《掌握Python中的并发性》
05-27
Python是目前最流行的编程语言之一，它具有众多促进高性能计算的库和框架。 尽管Python中的并发和并行行为与其他编程语言不同，但是仍然可以以各种方式实现同​​时运行或并行运行的Python程序，并大大缩短了执行...
Cpp-Concurrency-in-Action-2ed::books: C++ Concurrency in Action 2ed 笔记：C++111417 多线程技术
05-02
本书适合 C++ 多线程初学者，此为个人笔记，仅供参考，更详细内容见。相关链接GitHub Pages：GitBook 在线阅读：本书大多未详细解释的基础知识可参考：、、、、死锁C++11线程库API线程管理（Managing thread）线程间...
java-concurrency编程内部分享.zip_java-concurrency
最新发布
09-21
这份“java-concurrency编程内部分享”压缩包包含了关于Java并发编程的一份PPT，它可能涵盖了以下几个关键知识点： 1. **线程与进程**：首先，会讲解线程和进程的基本概念，它们的区别和联系。在Java中，线程是执行...
ember-poller：基于ember-concurrency的轮询服务
02-04
您可以使用ember-concurrency任务启动轮询程序。 import { reject } from 'rsvp' ; import { task } from 'ember-concurrency' ; poller: service ( ) , // Somewhere on the code call track method of the pol
modern-cpp-tutorial-en-us.pdf
03-30
C++ user group is a fairly large. From the advent of C++98 to the official finalization of C++11, it has accumulated over a decade. C++14/17 is an important complement and optimization for C++11, and C++20 brings this language to the door of modernization. The extended features of all these new standards are given to the C++ language. Infused with new vitality. C++ programmers, who are still using traditional C++ (this book refers to C++98 and its previous C++ standards as traditional C++), may even amzed by the fact that they are not using the same language while reading modern C++ code.
Java-Concurrency-Progamming-Tutorial:BAT华为大厂一线工程师四年磨一剑精心编排 Java 高并发编程案例代码 & 教程 & 面试题集锦。详细文档讲解请阅读本人的知识库仓：https
05-13
线程安全与程序性能的取舍之道 ... 3 环境参数 Maven 3.6+ JDK 8+ Tomcat 8.5+ MySQL 8.0.16+ Redis 6.0+ Intellij IDEA 2019.3 4 方案概要 线程安全性 线程安全性，主要从原子性、可见性、有序性三个方面 原子性...
concurrency-limits
04-28
概述Java库，该库实现并集成了从TCP拥塞控制到自动检测服务并发限制的概念，以实现具有最佳延迟的最佳吞吐量。背景传统上，在考虑服务可用性时，运营商会考虑RPS（每秒请求数）。 通常执行压力测试以确定RPS，然后...
CPP-Concurrency-In-Action-2ed-2019-master.zip
12-31
10. **性能优化与调试**：提供性能分析和并发代码调试的技巧，帮助开发者优化并发程序。 通过学习这本书，读者不仅可以掌握C++的并发编程基础，还能了解到高级的并发编程技术，提升在实际项目中编写高效、稳定并发...
Hands-On-Concurrency-with-Rust:Packt发行的Rust的动手并发
05-28
本书将教您如何在现代机器上管理程序性能以及如何在Rust中构建快速，内存安全的并发软件。 它从Rust的基础开始，并讨论了机器体系结构的概念。 我们将带您逐步系统地测量和改进Rust代码的性能，以及如何自信地编写...
[modern c++] 无锁的concurrency数据结构
ykun089的博客
04-01 146
前言： 前面讨论了使用 “全局加锁serilization数据结构”和 “局部加锁的concurrency数据结构”，这二者都离不开锁的控制，只要有锁就会有时间损耗，最主要的是会引入锁的副作用，比如 死锁、活锁 以及 优先级翻转，那么无锁的 concurrency 数据结构就显得 既高效又安全。 ...
C++并发编程实战 (1) Concurrency in C++
weixin_47658743的博客
09-11 339
Concurrency in C++并发方式多进程并发多线程并发设计思路存在的问题 并发方式 目前来看并发方式有两种，多进程并发和多线程并发。 多进程并发 这种方法可以被用在基于网络的多机器协同计算上，但是数据交互需要时间。 多线程并发 两个thread在同一个process里。Threads are much like lightweight processes. 多线程之间共享了一个内存空间，全局变量仍然是全局的，指针可以用来进行线程间交互。这种方法对数据保护就差很多。 在不同的进程中，同一个位置的数据
Concurrency-with-Modern-Cpp学习笔记 - 栅栏
虾球
08-16 696
栅栏 C++支持的栅栏类型：std::atomic_thread_fence和std::atomic_signal_fence。 std::atomic_thread_fence : 同步线程间的内存访问。 std::atomic_signal_fence : 线程内信号之间的同步。 std::atomic_thread_fence可以防止特定的操作翻过栅栏。不需要原子变量，通常称为栅栏或内存屏障。 栅栏当做内存屏障 特定的操作不能翻过内存屏障。现在有两种操作：读写操作或加载/存储操作。 if(resu
Concurrency-with-Modern-Cpp学习笔记 - 同步策略
虾球
08-24 245
处理共享 如果使用不共享数据，就没有竞争。不共享意味着线程只处理本地变量，可以通过值复制、特定的线程存储，也可以通过受保护的数据通道将结果传输到future来实现。本节中的模式非常直观，我会给出一些简单的解释。 值复制 线程通过值复制，而不是引用来获取参数时，就不需要对任何数据的访问进行同步，也就没有数据竞争的条件和数据生命周期的问题。 使用引用的数据竞争 下面的程序启动三个线程：一个线程通过复制获取参数，另一个线程通过引用获取参数，最后一个线程通过常量引用获取参数。 // copiedValueDataR
Objective-C教程：Mac与iOS应用开发第二版指南
"《学习Objective-C：Mac OS X与iOS编程第2版》是一本专为想要深入理解和掌握Objective-C语言，特别是针对Mac OS X和iOS平台开发者编写的英文技术书籍。本书详细地介绍了Objective-C的核心概念和技术，包括从基础...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值