Cpp Concurrency In Action（读书笔记4）——C++内存模型和原子类型操作

最新推荐文章于 2024-04-10 15:59:12 发布

阳安子

最新推荐文章于 2024-04-10 15:59:12 发布

阅读量1k

点赞数

分类专栏： C/C++ 并发编程读书笔记

本文链接：https://blog.csdn.net/BestZem/article/details/53066217

版权

C/C++ 同时被 3 个专栏收录

19 篇文章 0 订阅

订阅专栏

读书笔记

10 篇文章 0 订阅

订阅专栏

并发编程

9 篇文章 0 订阅

订阅专栏

内存模型基础

基本结构，这个结构奠定了与内存相关的基础
并发

对象和内存位置

每一个变量都是一个对象，包括作为其成员变量的对象。
每个对象至少占有一个内存位置。
基本类型都有确定的内存位置(无论类型大小如何，即使他们是相邻的，或是数组的一部分)。
相邻位域是相同内存中的一部分。

对象、内存位置和并发

所有东西都在内存中。为了避免条件竞争，两个线程就需要一定的执行顺序。第一种方式，使用互斥量来确定访问的顺序；当同一互斥量在两个线程同时访问前被锁住，那么在同一时间内就只有一个线程能够访问到对应的内存位置，所以后一个访问必须在前一个访问之后。另一种方式是使用原子操作(atmic operations)同步机制，决定两个线程的访问顺序。当多于两个线程访问同一个内存地址时，对每个访问这都需要定义一个顺序。

当程序中的对同一内存地址中的数据访问存在竞争，你可以使用原子操作来避免未定义行为。当然，这不会影响竞争的产生——原子操作并没有指定访问顺序——但原子操作把程序拉回了定义行为的区域内。

修改顺序

每一个在C++程序中的对象，都有(由程序中的所有线程对象)确定好的修改顺序(modification order)，在初始化开始阶段确定。在大多数情况下，这个顺序不同于执行中的顺序，但是在给定的执行程序中，所有线程都需要遵守这顺序。如果对象不是一个原子类型，你必要确保有足够的同步操作，来确定每个线程都遵守了变量的修改顺序。当不同线程在不同序列中访问同一个值时，你可能就会遇到数据竞争或未定义行为。如果你使用原子操作，编译器就有责任去替你做必要的同步。

这一要求意味着：投机执行是不允许的，因为当线程按修改顺序访问一个特殊的输入，之后的读操作，必须由线程返回较新的值，并且之后的写操作必须发生在修改顺序之后。同样的，在同一线程上允许读取对象的操作，要不返回一个已写入的值，要不在对象的修改顺序后(也就是在读取后)再写入另一个值。虽然，所有线程都需要遵守程序中每个独立对象的修改顺序，但它们没有必要遵守在独立对象上的相对操作顺序。

C++中的原子操作和原子类型

原子操作是一类不可分割的操作，当这样操作在任意线程中进行一半的时候，你是不能查看的；它的状态要不就是完成，要不就是未完成。如果从对象中读取一个值的操作是原子的，并且对对象的所有修改也都是原子的话，那么加载操作要不就会检索对象初始化的值，要不就将值存在某一次修改中。另一方面，非原子操作可能会被视为由一个线程完成一半的操作。如果这种是一个存储操作，那么其他线程看到的，可能既不是存储前的值，也可能不是已存储的值。如果非原子操作是一个加载操作，那么它可能会去检索对象的部分成员，或是在另一个线程修改了对象的值后，对对象进行检索；所以，检索出来的值可能既不是第一个值，也不是第二个值，可能是某种两者结合的值。这就是一个简单的条件竞争(如第3章所描述)，但是这种级别的竞争会构成数据竞争，且会伴有有未定义行为。

标准原子类型

在C++中(大多数情况下)你需要一个原子类型去执行一个原子操作。

标准原子类型(atomic types)：所有在这种类型上的操作都是原子的，虽然可以使用互斥量去达到原子操作的效果，但只有在这些类型上的操作是原子的（语言明确定义）。实际上，标准原子类型都很相似：它们大多数都有一个is_lock_free()成员函数，这个函数允许用户决定是否直接对一个给定类型使用原子指令(x.is_lock_free()返回true)，或对编译器和运行库使用内部锁x.is_lock_free()返回false)。

只用 std :: atomic_flag 类型不提供 is_lock_free()成员函数。这种类型上的操作都需要是无锁的 ( lock-free )。在 std :: atomic_flag 对象明确初始化后，做查询和设置 (使用 test_and_set()

成员函数)，或清除(使用clear()成员函数)都很容易。这就是：无赋值，无拷贝，没有测试和清除，没有其他任何操作。

对于 std :: atomic_flag 模板，使用对应的 T类型去特化模板的方式，要好于使用别名的方式。

std::atomic_flag的相关操作

最简单的标准原子类型，它表示了一个布尔标志。这个类型的对象可以在两个状态间切换：设置和清除。它就是那么的简单，只作为一个构建块存在。我从未期待这个类型被使用，除非在十分特别的情况下。

使用 std::atomic_flag实现自旋互斥锁：

    
    #include <atomic>
class spinlock_mutex
{
	std::atomic_flag flag;// = ATOMIC_FLAG_INIT;
public:
	//初始化标志是“清除”，并且互斥量处于解锁状态。
	//std::atomic_flag 类型的对象必须被ATOMIC_FLAG_INIT初始化，总是初始化为清除。
	spinlock_mutex() 
		:flag{ ATOMIC_FLAG_INIT } //此处使用新标准统一的初始化方式，否则就是调用复制构造函数（已删除）
	{}
	void lock()
	{
		while (flag.test_and_set(std::memory_order_acquire));
		//循环运行test_and_set()，直到旧值为false，当前线程设置为true
	}
	void unlock()
	{
		flag.clear(std::memory_order_release);
	}
};

spinlock_mutex使用测试：

    
    #include <atomic>
#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
class spinlock_mutex;//使用上面的定义
struct test {
	spinlock_mutex m;
	int i;
};
void fun(test &t)
{
	std::lock_guard<spinlock_mutex> lk(t.m);
	++t.i;
	std::cout << "thread : fun # " << t.i << std::endl;
}
int main()
{	
	test t;
	std::lock_guard<spinlock_mutex> lk(t.m);
	t.i = 0;
	lk.~lock_guard();
	std::vector<std::thread> vtds;
	for (int i = 0;i < 10;++i)
	{
		vtds.push_back(std::thread{ fun,std::ref(t) });
	}
	for (auto & th : vtds)
	{
		th.join();
	}
	system("pause");
	return 0;
}

由于 std :: atomic_flag 局限性太强，因为它没有非修改查询操作，它甚至不能像普通的布尔标志那样使用。所以，你最好使用 std :: atomic 。

std::atomic的相关操作

std :: atomic ：最基本的原子整型类型就。它有着比 std :: atomic_flag 更加齐全的布尔标志特性。虽然它依旧不能拷贝构造和拷贝赋值，但是你可以使用一个非原子的 bool类型构造它，所以它可以被初始化为 rue或 false，并且你也可以从一个非原子 bool变量赋值给 std :: atomic 的实例。

     
     	std::atomic<bool> f(true);
	f = false;

store()是一个存储操作，而load()是一个加载操作。exchange()是一个“读-改-写”操作：

      
      	std::atomic<bool> b;
	bool x = b.load(std::memory_order_acquire);
	b.store(true);
	x = b.exchange(false, std::memory_order_acq_rel);//x:true;b:false
	/*std::memory_order_acq_rel:Reads as an acquire operation 
	*and writes as a release operation (as described above).
	*/

std :: atomic <bool> 提供的exchange()，不仅仅是一个“读-改-写”的操作；它还介绍了一种新的存储方式：当当前值与预期值一致时，存储新值的操作。

存储一个新值或旧值取决于当前值：

这是一种新型操作，叫做“比较交换”，它的形式表现为compare_exchange_weak()（会发生 “ 伪失败”( spurious failure )）和 compare_exchange_strong() 成员函数。 “比较-交换” 操作是原子类型编程的基石；它比较原子变量的当前值和提供的预期值，当两值相等时，存储预期值。当两值不等，预期值就会被更新为原子变量中的值。 “ 比较交换 ” 函数值是一个 bool 变量，当返回 true 时执行存储操作，当 false则更新期望值。（此处不是很懂）

std :: atomic 和 std :: atomic_flag 的不同之处在于， std :: atomic 不是无锁的；为了保证操作的原子性，其实现中需要一个内置的互斥量。当处于特殊情况时，你可以使用 is_lock_free()成员函数，去检查 std :: atomic 上的操作是否无锁。这是另一个，除了 std :: atomic_flag 之外，所有原子类型都拥有的特征。

std::atomic指针运算

fetch_add() 和fetch_sub() 的返回值与算数符号运算的返回值略有不同( 如果 x是 std :: atomic < Foo *> 类型的数组的首地址， x.ftech_add(3) 让指向第四个元素，并且函数返回指向第一个元素的地址) 。这种操作也被称为“ 交换-相加” ，并且这是一个原子的“ 读- 改- 写”操作，如同exchange()和compare_exchange_weak()/compare_exchange_strong()一样。正像其他操作那样，返回值是一个普通的 T* 值，而非是std::atomic<Foo*> 对象的引用，所以调用代码可以基于之前的值进行操作：

        
        #include <atomic>
#include <cassert>
class Foo {};
int main()
{	
	Foo some_array[5];
	std::atomic<Foo*> p(some_array);
	Foo* x = p.fetch_add(2); // p加2，并返回原始值
	assert(x == some_array);
	assert(p.load() == &some_array[2]);
	x = (p -= 1); // p减1，并返回p值
	assert(x == &some_array[1]);
	assert(p.load() == &some_array[1]);
	system("pause");
	return 0;
}

两个函数也允许内存顺序语义（ http://www.cplusplus.com/reference/atomic/atomic_flag/test_and_set/）作为给定函数的参数：

        
        p.fetch_add(3,std::memory_order_release);

标准的原子整型的相关操作

std :: atomic <int> 和 std :: atomic <unsigned long long > ： fetch_add(), fetch_sub()（返回旧值，非引用）, fetch_and(), fetch_or(), fetch_xor() ，还有复合赋值方式 ((+=, -=（返回新值 ，非引用）, &=, |= 和 ^=) ，以及 ++ 和 --(++x, x++, --x 和 x--) 。只有除法、乘法和移位操作不在其中。因为，整型原子值通常用来作计数器，或者是掩码，所以以上操作的缺失显得不是那么重要；如果需要，额外的操作可以将 compare_exchange_weak() 放入循环中完成。

std::atomic<>主要类的模板

主模板的存在，在除了标准原子类型之外，允许用户使用自定义类型创建一个原子变量。

std :: atomic < UDT > 使用要求 (UDT 是用户定义类型，保证“比较交换”操作能正常的工作 ) ：

必须有拷贝赋值运算符。即不能有任何虚函数或虚基类，以及必须使用编译器创建的拷贝赋值操作。可以使用memcpy()进行拷贝。
必须是“位可比的”(bitwise equality comparable) 。可以使用memcmp()对位进行比较。

编译器可以对 std :: atomic 直接使用原子指令（因此实例化一个特殊无锁结构）。

“ 双字节比较和交换”( double-word-compare-and-swap ， DWCAS ) 指令：如果你的 UDT类型的大小如同 (或小于 )一个 int或 void* 类型时，大多数平台将会对 std :: atomic < UDT > 使用原子指令，有些平台可能会对用户自定义类型 (两倍于int或 void* 的大小)特化的 std :: atomic < > 使用原子指令。

限制：

浮点数的特化，存在相等却表达式不同的情况。
UDT定义了与memcmp()不同的比较操作。
不能使用包含有计数器，标志指针和简单数组的类型，作为特化类型。

原子操作的释放函数

在不同的原子类型中也有等价的非成员函数存在。大多数非成员函数的命名与对应成员函数有关，但是需要 “atomic_”作为前缀（比如， std::atomic_load() ）。这些函数都会被不同的原子类型所重载。 在指定一个内存序列标签时，他们会分成两种：一种没有标签，另一种将“_explicit”作为后 缀，并且需要一个额外的参数，或将内存顺序作为标签，亦或只有标签例如， std::atomic_store(&atomic_var,new_value) 与 std::atomic_store_explicit(&atomic_var,ne w_value,std::memory_order_release )。不过，原子对象被成员函数隐式引用，所有释放函数都持有一个指向原子对象的指针作为第一个参数。

std :: atomic_flag的操作： std :: atomic_flag_test_and_set () 和 std :: atomic_flag_test_and_set_explicit () 。

C++标准库也对在一个原子类型中的 std::shared_ptr<> 智能指针类型提供释放函数。这打破了“ 只有原子类型，才能提供原子操作” 的原则这里 std::shared_ptr<> 肯定不是原子类型。但是，C++标准委员会感觉对此提供额外的函数是很重要的。可使用的原子操作有：load, store, exchange 和compare/exchange ，这些操作重载了标准原子类型的操作，并且获取一个 std::shared_ptr<>* 作为第一个参数：

     
     std::shared_ptr<my_data> p;
void process_global_data()
{
	std::shared_ptr<my_data> local = std::atomic_load(&p);
	process_data(local);
}
void update_global_data()
{
	std::shared_ptr<my_data> local(new my_data);
	std::atomic_store(&p, local);
}

同步操作和强制排序

不同线程对数据的读写：

     
     #include <atomic>
#include <vector>
#include <iostream>
#include <chrono>
#include <thread>
std::vector<int> data;
std::atomic<bool> data_ready(false);
void reader_thread()
{
	while (!data_ready.load()) // 1
	{
		std::this_thread::sleep_for(std::chrono::milliseconds(5));
	}
	std::cout << "The answer=" << data[0] << std::endl; // 2
}
void writer_thread()
{
	data.push_back(42); // 3
	data_ready = true; // 4
}
int main()
{
	std::thread t_reader{ reader_thread }, t_writer{ writer_thread };
	t_reader.detach();
	t_writer.detach();
	system("pause");
	return 0;
}

强制访问顺序是由对 std :: atomic <bool> 类型的data_ready变量进行操作完成的；这些操作通过“ 先行发生 ”( happens-before )和“ 同步发生 ”( synchronizes-with )确定必要的顺序。3先于4，1先于2，读写同步，于是强制顺序：写先于读。

同步发生

“ 同步发生” 关系是指：只能在原子类型之间进行的操作。：在变量 x进行适当标记的原子写操作 W，同步与对进行适当标记的原子读操作，读取的是 W操作写入的内容；或是在 W之后，同一线程上的原子写操作对写入的值；亦或是任意线程对的一系列原子读改 -写操作 (例如， fetch_add()或 compare_exchange_weak())。

先行发生

“ 先行发生” 关系是一个程序中，基本构建块的操作顺序；它指定了某个操作去影响另一个操作。

对于参数中的函数调用顺序是未指定顺序的（结果一般为2，1，与环境相关）：

     
     void foo(int a, int b)
{
	std::cout << a << " , " << b << std::endl;
}
int get_num()
{
	static int i = 0;
	return ++i;
}
int main()
{
	foo(get_num(), get_num()); // 无序调用get_num()
	system("pause");
	return 0;
}

原子操作的内存顺序

三种内存模型（内存序列）： 排序一致序列 ( sequentially consistent )，获取 -释放序列 ( memory_order_consume, memory_order_acquire, memory_order_release 和 memory_order_acq_rel )，和自由序列( memory_order_relaxed )。

排序一致队列：程序中的行为从任意角度去看，序列顺序都保持一致。

全序——序列一致：

       
       #include <atomic>
#include <thread>
#include <cassert>
std::atomic<bool> x, y;
std::atomic<int> z;
void write_x()
{
	x.store(true, std::memory_order_seq_cst); // 1
}
void write_y()
{
	y.store(true, std::memory_order_seq_cst); // 2
}
void read_x_then_y()
{
	while (!x.load(std::memory_order_seq_cst));
	if (y.load(std::memory_order_seq_cst)) // 3
		++z;
}
void read_y_then_x()
{
	while (!y.load(std::memory_order_seq_cst));
	if (x.load(std::memory_order_seq_cst)) // 4
		++z;
}
int main()
{
	x = false;
	y = false;
	z = 0;
	std::thread a(write_x);
	std::thread b(write_y);
	std::thread c(read_x_then_y);
	std::thread d(read_y_then_x);
	a.join();
	b.join();
	c.join();
	d.join();
	assert(z.load() != 0); // 5：可能是1、2，所以永远都不会触发
	system("pause");
	return 0;
}

序列一致是最简单、直观的序列，但是他也是最昂贵的内存序列，因为它需要对所有线程进行全局同步。在一个多处理系统上，这就需要处理期间进行大量并且费时的信息交换。

非排序一致内存模型：线程没必要去保证一致性。在没有明确的顺序限制下，唯一的要求就是，所有线程都要统一对每一个独立变量的修改顺序。对不同变量的操作可以体现在不同线程的不同序列上，提供的值要与任意附加顺序限制保持一致。踏出排序一致世界后，最好的示范就是使用 memory_order_relaxed对所有操作进行约束。

自由序列：在原子类型上的操作以自由序列执行，没有任何同步关系。在同一线程中对于同一变量的操作还是服从先发执行的关系，但是这里不同线程几乎不需要相对的顺序。唯一的要求是，在 访问同一线程中的单个原子变量不能重排序；当一个给定线程已经看到一个原子变量的特定 值，线程随后的读操作就不会去检索变量较早的那个值。当使用 memory_order_relaxed，就不需要任何额外的同步，对于每个变量的修改顺序只是线程间共享的事情。

非限制操作只有非常少的顺序要求（relaxed——任意）：

      
      #include <atomic>
#include <thread>
#include <cassert>
std::atomic<bool> x, y;
std::atomic<int> z;
void write_x_then_y()
{
	x.store(true, std::memory_order_relaxed); // 1
	y.store(true, std::memory_order_relaxed); // 2
}
void read_y_then_x()
{
	while (!y.load(std::memory_order_relaxed)); // 3
	if (x.load(std::memory_order_relaxed)) // 4
		++z;
}
int main()
{
	x = false;
	y = false;
	z = 0;
	std::thread a(write_x_then_y);
	std::thread b(read_y_then_x);
	a.join();
	b.join();
	assert(z.load() != 0); // 5，可能会触发
	system("pause");
	return 0;
}

书上说可能会触发（虽然我循环跑了一次，没有触发，待研究，要与之后的计数员的笔记一块阅读），这里的关键点： x和 y是两个不同的变量，所以这里没有顺序去保证每个操作产生相关值的可见性。

非限制操作 ——多线程版：

       
       #include <thread>
#include <atomic>
#include <iostream>
std::atomic<int> x(0), y(0), z(0); // 1
std::atomic<bool> go(false); // 2
unsigned const loop_count = 10;
struct read_values
{
	int x, y, z;
};
read_values values1[loop_count];
read_values values2[loop_count];
read_values values3[loop_count];
read_values values4[loop_count];
read_values values5[loop_count];
void increment(std::atomic<int>* var_to_inc, read_values* values)
{
	while (!go)
		std::this_thread::yield(); // 3 自旋，等待信号
	for (unsigned i = 0;i<loop_count;++i)
	{
		values[i].x = x.load(std::memory_order_relaxed);
		values[i].y = y.load(std::memory_order_relaxed);
		values[i].z = z.load(std::memory_order_relaxed);
		var_to_inc->store(i + 1, std::memory_order_relaxed); // 4
		std::this_thread::yield();
		/*Provides a hint to the implementation to 
		reschedule the execution of threads,
		allowing other threads to run*/
	}
}
void read_vals(read_values* values)
{
	while (!go)
		std::this_thread::yield(); // 5 自旋，等待信号
	for (unsigned i = 0;i<loop_count;++i)
	{
		values[i].x = x.load(std::memory_order_relaxed);
		values[i].y = y.load(std::memory_order_relaxed);
		values[i].z = z.load(std::memory_order_relaxed);
		std::this_thread::yield();
	}
}
void print(read_values* v)
{
	for (unsigned i = 0;i<loop_count;++i)
	{
		if (i)
			std::cout << ",";
		std::cout << "(" << v[i].x << "," << v[i].y << "," << v[i].z << ")";
	}
	std::cout << std::endl;
}
int main()
{
	std::thread t1(increment, &x, values1);
	std::thread t2(increment, &y, values2);
	std::thread t3(increment, &z, values3);
	std::thread t4(read_vals, values4);
	std::thread t5(read_vals, values5);
	go = true; // 6 开始执行主循环的信号
	t5.join();
	t4.join();
	t3.join();
	t2.join();
	t1.join();
	print(values1); // 7 打印最终结果
	print(values2);
	print(values3);
	print(values4);
	print(values5);
	system("pause");
	return 0;
}

强烈建议避免自由的原子操作，除非它们是硬性要求的，并且在使用它们的时候需要十二分的谨慎。上面程序结果多种。由于给出的不直观的结果，复杂性增强。

获取 - 释放序列： 原子加载就是“获取”(acquire)操作 (memory_order_acquire)，原子存储就是 “释放”操作 (memory_order_release)，原子读- 改 -写操作 (例如 fetch_add()或 exchange())在这里，不是 “获取 ”，就是 “释放 ”，或者两者兼有的操作 (memory_order_acq_rel)。这里，同步在线程释放和获取间，是成对的 (pairwise )。释放操作与获取操作同步，这样就能读取已写入的值。这意味着不同线程看到的序列虽还是不同，但这些序列都是受限的。

获取（acquire——加载）-释放（release——存储）不意味着统一操作顺序：

        
        #include <atomic>
#include <thread>
#include <assert.h>
std::atomic<bool> x, y;
std::atomic<int> z;
void write_x()
{
	x.store(true, std::memory_order_release);
}
void write_y()
{
	y.store(true, std::memory_order_release);
}
void read_x_then_y()
{
	while (!x.load(std::memory_order_acquire));
	if (y.load(std::memory_order_acquire)) // 1
		++z;
}
void read_y_then_x()
{
	while (!y.load(std::memory_order_acquire));
	if (x.load(std::memory_order_acquire))
		++z;
}
int main()
{
	x = false;
	y = false;
	z = 0;
	std::thread a(write_x);
	std::thread b(write_y);
	std::thread c(read_x_then_y);
	std::thread d(read_y_then_x);
	a.join();
	b.join();
	c.join();
	d.join();
	assert(z.load() != 0); // 3，可能触发
}

因为x和y是由不同线程写入，所以序列中的每一次释放到获取都不会影响到其他线程的操作（书中所述：结果类似自由序列）。至于分析，理解能力有限，感觉是一次对应后再次获取就可能不是对应的值了（ https://www.zhihu.com/question/24301047），仍然待研究。

获取-释放操作会影响序列中的释放操作：

        
        #include <atomic>
#include <thread>
#include <assert.h>
std::atomic<bool> x, y;
std::atomic<int> z;
void write_x_then_y()
{
	x.store(true, std::memory_order_relaxed); // 1 
	y.store(true, std::memory_order_release); // 2
}
void read_y_then_x()
{
	while (!y.load(std::memory_order_acquire)); // 3，自旋，等待y被设置为true
	if (x.load(std::memory_order_relaxed)) // 4
		++z;
}
int main()
{
	x = false;
	y = false;
	z = 0;
	std::thread a(write_x_then_y);
	std::thread b(read_y_then_x);
	a.join();
	b.join();
	assert(z.load() != 0); // 5，不会触发
}

读到的y和写入是一样的，因为存储y使用的是 memory_order_release，读取y使用的是 memory_order_acquire，存储就与读取就同步了。1先于2，则1先于3，故1先于4，所以不会触发。

与同步传递相关的获取 - 释放序列：通过获取和释放来控制同步。

使用获取和释放顺序进行同步传递：

       
       #include <atomic>
#include <cassert>
#include <thread>
std::atomic<int> data[5];
std::atomic<bool> sync1(false), sync2(false);
void thread_1()
{
	data[0].store(42, std::memory_order_relaxed);
	data[1].store(97, std::memory_order_relaxed);
	data[2].store(17, std::memory_order_relaxed);
	data[3].store(-141, std::memory_order_relaxed);
	data[4].store(2003, std::memory_order_relaxed);
	sync1.store(true, std::memory_order_release); // 1.设置sync1
}
void thread_2()
{
	while (!sync1.load(std::memory_order_acquire)); // 2.直到sync1设置后，循环结束
	sync2.store(true, std::memory_order_release); // 3.设置sync2
}
void thread_3()
{
	while (!sync2.load(std::memory_order_acquire)); // 4.直到sync1设置后，循环结束
	assert(data[0].load(std::memory_order_relaxed) == 42);
	assert(data[1].load(std::memory_order_relaxed) == 97);
	assert(data[2].load(std::memory_order_relaxed) == 17);
	assert(data[3].load(std::memory_order_relaxed) == -141);
	assert(data[4].load(std::memory_order_relaxed) == 2003);
    //以上实现了同步，不会触发
}
int main()
{
	std::thread t1{thread_1}, t2{thread_2}, t3{thread_3};
	t1.join();
	t2.join();
	t3.join();
	return 0;
}

更改：

        
        #include <atomic>
#include <cassert>
#include <thread>
std::atomic<int> data[5];
std::atomic<int> sync(0);
void thread_1()
{
	data[0].store(42, std::memory_order_relaxed);
	data[1].store(97, std::memory_order_relaxed);
	data[2].store(17, std::memory_order_relaxed);
	data[3].store(-141, std::memory_order_relaxed);
	data[4].store(2003, std::memory_order_relaxed);
	sync.store(1, std::memory_order_release);
}
void thread_2()
{
	int expected = 1;
	while (!sync.compare_exchange_strong(expected, 2,//保证thread_1对变量只进行一次更新
		std::memory_order_acq_rel))//同时进行获取和释放的语义
		expected = 1;
	/*当expected与sync相等时候，sync=2，返回true，结束程序；
	*当expected与sync不等的时候，expected=sync，返回false，
	进入循环，expected=1；
	*/
}
void thread_3()
{
	while (sync.load(std::memory_order_acquire)<2);
	assert(data[0].load(std::memory_order_relaxed) == 42);
	assert(data[1].load(std::memory_order_relaxed) == 97);
	assert(data[2].load(std::memory_order_relaxed) == 17);
	assert(data[3].load(std::memory_order_relaxed) == -141);
	assert(data[4].load(std::memory_order_relaxed) == 2003);
}
int main()
{
	std::thread t1{thread_1}, t2{thread_2}, t3{thread_3};
	t1.join();
	t2.join();
	t3.join();
	return 0;
}

关于 compare_exchange_weak、 compare_exchange_strong： http://en.cppreference.com/w/cpp/atomic/atomic/compare_exchange。

获取 - 释放序列和 memory_order_consume 的数据相关性： memory_order_consume 是“ 获取- 释放” 序列模型的一部分，它完全依赖于数据，并且其展示了与线程间先行关系的不同之处。数据依赖：前序依赖 dependency-ordered-before )和携带依赖 carries-a-dependency-to )。

使用 std :: memory_order_consume 同步数据：

        
        #include <string>
#include <atomic>
#include <thread>
#include <cassert>
struct X
{
	int i;
	std::string s;
};
std::atomic<X*> p;
std::atomic<int> a;
void create_x()
{
	X *x = new X;
	x->i = 42;
	x->s = "hello";
	a.store(99, std::memory_order_relaxed); // 1
	p.store(x, std::memory_order_release); // 2
}
void use_x()
{
	X* x;
	while (!(x = p.load(std::memory_order_consume))) // 3
		std::this_thread::sleep_for(std::chrono::microseconds(1));
	assert(x->i == 42); // 4，不会触发
	assert(x->s == "hello"); // 5，不会触发
	assert(a.load(std::memory_order_relaxed) == 99); // 6，可能触发
}
int main()
{
	std::thread t1(create_x);
	std::thread t2(use_x);
	t1.join();
	t2.join();
	return 0;
}

存储p 的操作标记为 emory_order_release，加载p 的操作标记为 emory_order_consume，这就意味着p存储仅先行那些需要加载的操作。对 x变量操作的表达式对加载p 的操作携带有依赖。

显式打破依赖链 ：

       
       int global_data[] = {...};
std::atomic<int> index;
void f()
{
	int i = index.load(std::memory_order_consume);
	do_something_with(global_data[std::kill_dependency(i)]);
	//让编译器知道这里不需要重新读取该数组的内容
}

std :: kill_dependency ( ) 是一个简单的函数模板，其会复制提供的参数给返回值，但是依旧会打破依赖链。你必须记住，这是为了优化，所以这种方式必须谨慎使用，并且需要性能数据证明其存在的意义（待研究）。

释放队列与同步

使用原子操作从队列中读取数据：

        
        #include <atomic>
#include <thread>
#include <vector>
#include <iostream>
std::vector<int> queue_data;
std::atomic<int> count;
void populate_queue()
{
	unsigned const number_of_items = 20;
	queue_data.clear();
	for (unsigned i = 0;i<number_of_items;++i)
	{
		queue_data.push_back(i);
	}
	count.store(number_of_items, std::memory_order_release); // 1 初始化存储
}
void consume_queue_items()
{
	while (true)
	{
		int item_index;
		if ((item_index = count.fetch_sub(1, std::memory_order_acquire)) <= 0) 
			// 2 一个“读-改-写”操作
		{
			wait_for_more_items(); // 3 等待更多元素
			break;
		}
		process(queue_data[item_index - 1]); // 4 安全读取queue_data
	}
}
int main()
{
	std::thread a(populate_queue);
	std::thread b(consume_queue_items);
	std::thread c(consume_queue_items);
	a.join();
	b.join();
	c.join();
	system("pause");
	return 0;
}

栅栏

栅栏操作会对内存序列进行约束，使其无法对任何数据进行修改，典型的做法是与使用 memory_order_relaxed约束序的原子操作一起使用。栅栏属于全局操作，执行栅栏操作可以影响到在线程中的其他原子操作。因为 这类操作就像画了一条任何代码都无法跨越的线一样，所以栅栏操作通常也被称为“内存栅栏”(memory barriers)。

栅栏可以让自由操作变的有序：

       
       #include <atomic>
#include <thread>
#include <cassert>
std::atomic<bool> x, y;
std::atomic<int> z;
void write_x_then_y()
{
	x.store(true, std::memory_order_relaxed); // 1
	std::atomic_thread_fence(std::memory_order_release); // 2，释放栅栏
	y.store(true, std::memory_order_relaxed); // 3
}
void read_y_then_x()
{
	while (!y.load(std::memory_order_relaxed)); // 4
	std::atomic_thread_fence(std::memory_order_acquire); // 5，获取栅栏
	if (x.load(std::memory_order_relaxed)) // 6
		++z;
}
int main()
{
	x = false;
	y = false;
	z = 0;
	std::thread a(write_x_then_y);
	std::thread b(read_y_then_x);
	a.join();
	b.join();
	assert(z.load() != 0); // 7，不会触发
}

这两个栅栏都是必要的：你需要在一个线程中进行释放，然后在另一个线程中进行获取，这样才能构建出同步关系。栅栏同步依赖于读取 /写入的操作发生于栅栏之前 /后，但是这里有一点很重要：同步 点，就是栅栏本身。

如果采用如下方式，则也许会触发，失去了栅栏将两个释放操作隔开。

        
        void write_x_then_y()
{
	std::atomic_thread_fence(std::memory_order_release);
	x.store(true, std::memory_order_relaxed);
	y.store(true, std::memory_order_relaxed);
}

原子操作对非原子的操作排序

使用非原子操作执行序列：

     
     #include <atomic>
#include <thread>
#include <assert.h>
bool x = false; // x现在是一个非原子变量
std::atomic<bool> y;
std::atomic<int> z;
void write_x_then_y()
{
	x = true; // 1 在栅栏前存储x
	std::atomic_thread_fence(std::memory_order_release);
	y.store(true, std::memory_order_relaxed); // 2 在栅栏后存储y
}
void read_y_then_x()
{
	while (!y.load(std::memory_order_relaxed)); // 3 在#2写入前，持续等待
	std::atomic_thread_fence(std::memory_order_acquire);
	if (x) // 4 这里读取到的值，是#1中写入
		++z;
}
int main()
{
	x = false;
	y = false;
	z = 0;
	std::thread a(write_x_then_y);
	std::thread b(read_y_then_x);
	a.join();
	b.join();
	assert(z.load() != 0); // 5 断言将不会触发
}

其中y必须是原子操作，否则会数据竞争，而对x不用（栅栏作用）。

不仅是栅栏可对非原子操作排序。你在上面看到 memory_order_release/memory_order_consume对，也可以用来排序非原子访问，为的是可以动态分配对象，并且本章中的许多例子都可以使用普通的非原子操作，去替代标记为m emory_order_relaxed的操作。

后记

在本章的学习中，可以说是举步维艰，我觉得要先看《深度探索C++对象模型》等书，对内存模型有一个初步的认识，看来还要努力学习。同时，书中部分代码没有完全明白，今后需要重温。文中文字部分摘抄至原翻译作品以及自己的部分感想总结。

阳安子

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Cpp Concurrency In Action（读书笔记4）——C++内存模型和原子类型操作

内存模型基础基本结构，这个结构奠定了与内存相关的基础并发对象和内存位置每一个变量都是一个对象，包括作为其成员变量的对象。每个对象至少占有一个内存位置。基本类型都有确定的内存位置(无论类型大小如何，即使他们是相邻的，或是数组的一部分)。相邻位域是相同内存中的一部分。对象、内存位置和并发所有东西都在内存中。为了避免条件竞争，两个线程就需要一
复制链接

扫一扫

专栏目录