原子操作
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
