C++并行并发

5.内存顺序
1）宽松模型
在此模型下，单个线程内的原子操作都是顺序执行的，不允许指令重排，但不同线程间原子操作的顺序是任意的。类型通过 std::memory_order_relaxed 指定。

#include 
#include 
#include 
#include 



int main() 
{
	//宽松模型
	std::cout << "宽松模型" << std::endl;
	std::atomic counter = { 0 };
	std::vector vt;
	for (int i = 0; i < 100; ++i)
	{
		vt.emplace_back([&]() {
			counter.fetch_add(1, std::memory_order_relaxed);
			});
	}

	for (auto& t : vt)
	{
		t.join();
	}
	std::cout << "finnal counter:" << counter << std::endl;
	return 0;
}

2）释放/消费模型：在此模型中，我们开始限制进程间的操作顺序，如果某个线程需要修改某个值，但另一个线程会对该值的某次操作产生依赖，即后者依赖前者。具体而言，线程 A 完成了三次对 x 的写操作，线程 B 仅依赖其中第三次 x 的写操作，与 x 的前两次写行为无关，则当 A 主动 x.release() 时候（即使用 std::memory_order_release），选项 std::memory_order_consume 能够确保 B 在调用 x.load() 时候观察到 A 中第三次对 x 的写操作。

#include 
#include 
#include 
#include 



int main() 
{
	std::atomic ptr(nullptr);
	int v;
	std::thread producer([&]() {
		int *p = new int(42);
		v = 1024;
		ptr.store(p, std::memory_order_release);
		});

	std::thread consumer([&]() {
		int *p;
		while (!(p = ptr.load(std::memory_order_consume)));

		std::cout << "p:" << *p << std::endl;
		std::cout << "v:" << v << std::endl;
		});

	producer.join();
	consumer.join();
	return 0;
}

3）释放/获取模型：在此模型下，我们可以进一步加紧对不同线程间原子操作的顺序的限制，在释放 std::memory_order_release 和获取 std::memory_order_acquire 之间规定时序，即发生在释放（release）操作之前的所有写操作，对其他线程的任何获取（acquire）操作都是可见的，亦即发生顺序（happens-before）。

可以看到，std::memory_order_release 确保了它之前的写操作不会发生在释放操作之后，是一个向后的屏障（backward），而 std::memory_order_acquire 确保了它之前的写行为不会发生在该获取操作之后，是一个向前的屏障（forward）。对于选项 std::memory_order_acq_rel 而言，则结合了这两者的特点，唯一确定了一个内存屏障，使得当前线程对内存的读写不会被重排并越过此操作的前后

#include 
#include 
#include 
#include 



int main() 
{
	std::vector v;
	std::atomic flag = { 0 };
	std::thread release([&]() {
		v.push_back(42);
		flag.store(1, std::memory_order_release);
		});

	std::thread acqrel([&]() {
			int expected = 1;
			while (!flag.compare_exchange_strong(expected, 2, std::memory_order_acq_rel)) {
				expected = 1;
			}
		});
	std::thread acquire([&]() {
			while (flag.load(std::memory_order_acquire) < 2);
			std::cout << v.at(0) << std::endl;
		});

	release.join();
	acqrel.join();
	acquire.join();
	return 0;
}

4）顺序一致模型：在此模型下，原子操作满足顺序一致性，进而可能对性能产生损耗。可显式的通过 std::memory_order_seq_cst 进行指定。

#include 
#include 
#include 
#include 



int main() 
{
	std::atomic counter = { 0 };
	std::vector vt;
	for (int i = 0; i < 100; ++i) {
		vt.emplace_back([&]() {
			std::cout << "current counter:" << counter << std::endl;
			counter.fetch_add(1, std::memory_order_seq_cst);
			
			});
	}
	for (auto & t : vt)
	{
		t.join();
	} 
	std::cout << "final counter:" << counter << std::endl;
	return 0;
}