基于CAS操作的atomic原子类型

原子操作

C A S (compare And Swap）也叫比较交换，是一种无锁原子算法，映射到操作系统就是一条cmpxchg硬件汇编指令（保证原子性)，其作用是让CPU将内存值更新为新值，但是有个条件，内存值必须与期望值相同，并且C A S操作无需用户态与内核态切换，直接在用户态对内存进行读写操作（意味着不会阻塞/线程上下文切换*)。它包含3个参数C A S (V，E，N)，V表示待更新的内存值，E表示预期值，N表示新值，当V值等于E值时，才会将V值更新成N值，如果V值和E值不等，不做更新，这就是一次C A S的操作

1.原子对象间不能进行拷贝构造
2.原子对象间不能进行赋值

原子操作不单单是一个整型量原子的加一或减一

原子操作底层汇编实现：锁总线

为什么需要进行原子操作

互斥锁是比较重的，互斥锁适用于临界区代码做的事情稍稍复杂，
系统理论:CAS来保证上面++ --操作的原子特性就足够了，无锁操作并不是不加锁，只不过是加锁操作不在软件层面。

CPU和内存通信是需要通过系统总线进行，CAS就是通过像exchange/swap这种指令给系统总线加锁，当一个线程在做CPU和内存之间数据的交换，一个线程如果没有做完事，是不允许其他线程再次去使用系统总线的。

变量属于数据段，一个进程里面的线程是不同，只是栈不同。但是堆和数据段都是共享的，对于共享变量多线程是会缓存的，即就是对于一个共享变量被改变，其他线程是不能立马就看到该变量改变的
因为线程读取的都是自己的缓存。所以就需要加volatile:防止多线程对共享变量进行缓存，保证线程访问的都是原始内存中变量的值

#include<atomic>

volatile atomic_bool isReady = false;
volatile atomic_int Count = 0;

#include<iostream>
#include<thread>
#include<list>
#include<mutex>
#include<queue>//C++STL所有的容器都不是线程安全
#include<condition_variable>
#include<atomic>
using namespace std;
//

//变量属于数据段，一个进程里面的线程是不同，只是栈不同。但是堆和数据段都是共享的，
//对于共享变量多线程是会缓存的，即就是对于一个共享变量被改变，其他线程是不能立马就看到该变量改变的
//因为线程读取的都是自己的缓存。所以就需要加volatile:防止多线程对共享变量进行缓存，
//保证线程访问的都是原始内存中变量的值
volatile atomic_bool isReady = false;
volatile atomic_int Count = 0;

void task()
{
	while (!isReady)
	{
		this_thread::yield();//线程出让当前的cPu时间片，等待下一次调度
	}
	for (int i = 0; i < 100; i++)
	{
		Count++;
	}
}
int main()
{
	list<std::thread>tlist;
	for (int i = 0; i < 10; i++)
	{
		tlist.push_back(thread(task));
	}
	std::this_thread::sleep_for(std::chrono::milliseconds(100));
	isReady = true;
	
	for (thread& t : tlist)
	{
		t.join();
	}
	cout << "Count: " << Count << endl;
	return 0;
}

#if 0
std::mutex mtx;//定义互斥锁，做线程间的互斥操作
std::condition_variable cv; //定义条件变量，做线程间的同步通信操作

//生产者生产一个物品，通知消费者消费一个;消费完了，消费者再通知生产者继续生产物品
class Queue
{
public:
	void put(int val)//生产物品
	{
		//lock_guard<mutex>lock(mtx);
		unique_lock<std::mutex>lck(mtx);
		while (!que.empty())
		{
			//que不空，生产者应该通知消费者消费，消费完了再继续消费
			//生产者进程应该1.进入阻塞状态，2.并且释放mtx,消费者可以获得锁
			
			cv.wait(lck);//通过条件变量wait进入等待状态，一进入等待状态就会把锁释放
		}
		que.push(val);
		cv.notify_all();//通知其它所有的线程，我生产了一个物品，你们赶紧消费吧
		//其它线程得到该通知，就会从等待状态=》阻塞状态=》获取互斥锁才能继续执行

		cout << "生产者 生产：" << val << " 号物品" << endl;
	}
	int get()//消费物品
	{
		//lock_guard<mutex>lock(mtx);
		unique_lock<std::mutex>lck(mtx);
		while (que.empty())
		{
			//que空，消费者应该通知生产者生产
			//进程应该1.进入阻塞状态，2.并且释放mtx
			
			cv.wait(lck);//通过条件变量wait进入等待状态，一进入等待状态就会把锁释放
		}
		int val = que.front();
		que.pop();
		cv.notify_all();//通知其它线程我消费完了，赶紧生产吧

		cout << "消费者 消费：" << val << " 号物品" << endl;
		return val;
	}
private:
	queue<int>que;
};

void producer(Queue* que)
{
	for (int i = 1; i <= 10; i++)
	{
		que->put(i);
		std::this_thread::sleep_for(std::chrono::milliseconds(100));
	}
}
void consumer(Queue* que)
{
	for (int i = 1; i <= 10; i++)
	{
		que->get();
		std::this_thread::sleep_for(std::chrono::milliseconds(100));
	}
}

int main()
{
	Queue que;
	thread t1(producer,&que);
	thread t2(consumer, &que);

	t1.join();
	t2.join();

	return 0;
}
#endif

#if 0
static int ticketcount = 100;
std::mutex mtx;//全局的一把互斥锁

//模拟买票的线程函数
void sellTicket(int index)
{
	//mtx.lock();//此种加锁相当于只有一个窗口在买票
	while (ticketcount >= 1)//锁+双重判断
	{
		//mtx.lock();
		//{
			//lock_guard<mutex>lock(mtx);
			unique_lock<std::mutex>lock(mtx);
			//lock.lock();
			if (ticketcount > 0)
			{
				//临界区代码段-》原子操作=》线程间互斥操作了=》mutex
				cout << "窗口：" << index << "  卖出第：" << ticketcount << " 张票！" << endl;
				ticketcount--;
			}
			lock.unlock();
		//}
		//mtx.unlock();
		std::this_thread::sleep_for(std::chrono::milliseconds(100));
	
	}
	//mtx.unlock();
}
int main()
{
	list<std::thread>tlist;
	for (int i = 1; i <= 3; i++)
	{
		tlist.push_back(std::thread(sellTicket, i));
	}

	for (thread& t : tlist)
	{
		t.join();
	}
	cout << "所有窗口买票结束！" << endl;
	return 0;
}

#endif


#if 0
void threadHandle1()
{
	//让子线程睡眠2秒
	std::this_thread::sleep_for(std::chrono::seconds(2));

	cout << "hello thread1!" << endl;
}

int main()
{
	//创建了一个线程对象，传入一个线程函数，新线程就开始运行了
	thread t1(threadHandle1);
	//主线程等待子线程结束，主线程继续往下运行
	//t1.join();
	t1.detach();

	cout << "main run over!" << endl;
	return 0;
}
#endif