#include <iostream>
#include<atomic>
#include<thread>
//std::atomic<bool>是一个比 std::atomic_flag 更具功能的布尔标志。
// 尽管仍然不能进行拷贝构造或拷贝赋值，但可以从一个非原子的 bool 类型构造它，或进行赋值

//与 std::atomic_flag 使用功能有限的 clear() 函数不同，写入操作（true 、false）是通过调用 store() 来完成的。
// 同样，test_and_set() 被更通用的 exchange() 成员函数取代，它允许用选择的新值替换存储的值，并原子地检索原始值
void do_something(std::atomic<bool>&lock) {
	while (lock.load(std::memory_order_acquire)) { //加载操作，返回当前的值
		std::cout << "等待其他线程完成，当前锁的状态为：" << (lock.load() ? "已上锁" : "未上锁")<< "\n"; 
		std::this_thread::sleep_for(std::chrono::milliseconds(250));
	}
	//exchange读修改操作
	bool status = lock.exchange(true, std::memory_order_acq_rel); //上锁，并返回之前的状态
	std::cout << "线程" << std::this_thread::get_id() << "准备就绪！当前锁的状态为：" << (status? "已上锁" : "未上锁") << "\n";

	std::cout << "线程" << std::this_thread::get_id() << "运行中！当前锁的状态为："<<(lock.load()?"已上锁" :"未上锁")<<"\n";
	std::this_thread::sleep_for(std::chrono::milliseconds(300));
	
	//存储操作，把锁存储为false，表示未占用
	lock.store(false,std::memory_order_release); //释放锁，恢复为未占用的状态

}
void Test1() {
	std::atomic<bool>lock(false); //初始化
	std::thread threads[10];
	for (int i = 0; i < 10; ++i) {
		threads[i] = std::thread(do_something,std::ref(lock));
	}
	for (int i = 0; i < 10; ++i) {
		threads[i].join();
	}
}
//compare_exchange_weak和compare_exchange_strong成员函数
//于 compare_exchange_weak()，即使原始值等于期望值，存储操作也可能不成功
//这种情况最有可能发生在缺乏单一比较和交换指令的机器上，可能是因为执行操作的线程在必要的指令序列中间被切换出去，
// 而操作系统在其位置安排了另一个线程

void Test2() {
	std::atomic_bool atomic_lock(false); //atomic_bool和atomic<bool>一样
	bool expected_status = true; //期望的bool状态
	bool desired_status = false; //比较后修改的状态

	//当前状态的期望状态不一样，返回false，并且不会改变当前的状态，但会修改expected_status的状态为当前原子的状态
	bool compare_status = atomic_lock.compare_exchange_weak(expected_status, desired_status);
	std::cout << "比较后得到的状态是" << (compare_status ? "true" : "false") << "\n";
	std::cout << "atomic_bool的状态是" << (atomic_lock.load(std::memory_order_acquire) ? "true" : "false") << "\n";
	std::cout<<"expected_statu的状态是"<< (expected_status ? "true" : "false") << "\n";
	std::cout << "desired_statu的状态是" << (desired_status ? "true" : "false") << "\n";

	//当前状态的期望状态一样，返回true，并且改变当前的状态为desire_status，不会修改expected_status的状态
	atomic_lock.store(true, std::memory_order_release); // 改变当前状态为true
	expected_status = true; // 更新期望的状态为true
	compare_status = atomic_lock.compare_exchange_weak(expected_status, desired_status);

	std::cout << "比较后得到的状态是" << (compare_status ? "true" : "false") << "\n";
	std::cout << "atomic_bool的状态是" << (atomic_lock.load(std::memory_order_acquire) ? "true" : "false") << "\n";
	std::cout << "expected_statu的状态是" << (expected_status ? "true" : "false") << "\n";
	std::cout << "desired_statu的状态是" << (desired_status ? "true" : "false") << "\n";

	//但compare_exchange_weak一次比较可能会发生“伪失败”，需要使用一个循环
	bool expected = false;
	std::atomic<bool> b(false); 
	//多次比较
	while (!b.compare_exchange_weak(expected, true)&&!expected) { //通常情况这两个条件不会同时满足，除非发生错误
		expected = false; //比较失败需要重置，多次比较
		std::cout << "修改失败！\n";
	}
	std::cout << "修改成功！\n";

	//ompare_exchange_strong() 保证只有在值不相等的情况下才返回 false。这可以消除像上面展示的循环的需要
	atomic_lock.store(true,std::memory_order_release); // 改变当前状态为true
	expected_status = true; // 更新期望的状态为true
	compare_status = atomic_lock.compare_exchange_strong(expected_status, desired_status);

	std::cout << "比较后得到的状态是" << (compare_status ? "true" : "false") << "\n";
	std::cout << "atomic_bool的状态是" << (atomic_lock.load(std::memory_order_acquire) ? "true" : "false") << "\n";
	std::cout << "expected_statu的状态是" << (expected_status ? "true" : "false") << "\n";
	std::cout << "desired_statu的状态是" << (desired_status ? "true" : "false") << "\n";

	//可以为比较成功和失败指定相应的排序
	//成功：可能希望具有 memory_order_acq_rel 语义
	//失败：则具有 memory_order_relaxed 语义
	//失败的比较交换不会执行存储操作，因此它不能具有 memory_order_release 或 memory_order_acq_rel 语义
	//也不能为失败提供比成功更严格的内存排序
	//如果没有为失败指定排序，它被假设与成功时相同，只是释放部分被剥离：
	//memory_order_release 变为 memory_order_relaxed，memory_order_acq_rel 变为 memory_order_acquire。
	//如果两者都没有指定，默认为 memory_order_seq_cst

	atomic_lock.store(false, std::memory_order_release); // 改变当前状态为true
	expected_status = true; // 更新期望的状态为true
	//比较成功调用的排序为memory_order_acq_rel，失败后调用的是memory_order_relaxed
	compare_status = atomic_lock.compare_exchange_strong(
		expected_status, desired_status,std::memory_order_acq_rel,std::memory_order_relaxed);
	

	std::cout << "比较后得到的状态是" << (compare_status ? "true" : "false") << "\n";
	std::cout << "atomic_bool的状态是" << (atomic_lock.load(std::memory_order_acquire) ? "true" : "false") << "\n";
	std::cout << "expected_statu的状态是" << (expected_status ? "true" : "false") << "\n";
	std::cout << "desired_statu的状态是" << (desired_status ? "true" : "false") << "\n";

}
int main(){
	//Test1();
	Test2();

	return 0;
}