mutex互斥锁

以下模拟三个窗口卖100张票程序,存在竞态条件，每次结果随着cpu对线程的不同调用顺序，可能不同

int cnt = 100;void sell(int i)
{while (cnt > 0){cout << "窗口:" << i << "卖出第:" << cnt << "张票" << endl;cnt--;this_thread::sleep_for(chrono::milliseconds(100));}
}
int main()
{listthreads;for (int i = 1; i <= 3; ++i){threads.push_back(thread(sell,i));}for (thread& t : threads){t.join();}cout << "所有窗口结束售卖" << endl;
}
//没有对临界资源互斥访问

void sell(int i)
{   while (cnt > 0){//仍然有问题，cnt==1时，多个线程可能在一段时间内都会进入while循环，mtx.lock();cout << "窗口:" << i << "卖出第:" << cnt << "张票" << endl;cnt--;mtx.unlock();this_thread::sleep_for(chrono::milliseconds(100));}
}
//改进：
while (cnt > 0){mtx.lock();if (cnt > 0){cout << "窗口:" << i << "卖出第:" << cnt << "张票" << endl;cnt--;}mtx.unlock();this_thread::sleep_for(chrono::milliseconds(100));}

lock_guard，unique_lock

如果在mtx.unlock前，异常，导致锁没有被释放：
使用lock_guard,封装互斥锁，且使用时加{}作用域，出作用域则自动进行析构，释放锁，类似scoped_ptr,不允许拷贝构造和赋值

void sell(int i)
{   while (cnt > 0){{   //加作用域lock_guardlock(mtx);if (cnt > 0){cout << "窗口:" << i << "卖出第:" << cnt << "张票" << endl;cnt--;}}this_thread::sleep_for(chrono::milliseconds(100));}
}

unique_lock类似unique_ptr，允许右值引用的拷贝构造和赋值

unique_locklock(mtx);if (cnt > 0){cout << "窗口:" << i << "卖出第:" << cnt << "张票" << endl;cnt--;}lock.unlock();

保证所有线程都能释放锁，防止死锁发生

lock_guard不可能用于函数参数传递或返回过程中，因为lock_guard不能拷贝构造和赋值，只能用于临界区代码段的简单互斥操作中

unique_lock可以用于函数调用过程中(右值引用)

atomic 原子类型

基于CAS(exchange，swap)操作(无锁操作)

对于类似全局变量的++，--操作，互斥锁较为繁琐

atomic_bool isReady = false;
atomic_int cnt = 0;void task()
{while (!isReady){this_thread::yield();}for (int i = 0; i < 100; ++i){cnt++;}
}
int main()
{listthreads;for (int i = 1; i <= 10; ++i){threads.push_back(thread(task));}this_thread::sleep_for(chrono::seconds(3));isReady = true;for (thread& t : threads){t.join();}cout << "count:" << cnt << endl;
}

多线程会对共享变量缓存，所以主线程改变isReady后，子线程不一定能立刻看到改后的值

所以要防止缓存：访问原始内存中的值

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

线程间的同步通信

生产者消费者模型

共享一个队列

C++ STL中的所有容器都不是线程安全的

#include 
#include
#include
#include
#include
#include
#include
using namespace std;mutex mtx;
condition_variable cv;//不为空则消费，为空则通知生产，为满则通知消费
//生产者生产一个，通知消费者消费一个，消费完，通知生产者生产
class Queue
{
public:void put(int val)   //生产{//生产者消费者同步unique_locklck(mtx);    //对临界区互斥while (!que.empty()){//que不为空，通知消费，生产者线程进入等待状态，且要释放互斥锁(使用条件变量)  cv.wait(lck);//进入等待状态则会将锁释放}que.push(val);cv.notify_all();//通知其他所有线程，消费,其他线程得到通知时，从等待->阻塞->获取到互斥锁才能继续执行cout << "生产者生产：" << val << endl;}int get()   //消费{unique_locklck(mtx);while (que.empty()){cv.wait(lck);//进入等待状态则会将锁释放}int val = que.front();que.pop();cv.notify_all();//通知生产者生产cout << "消费者消费：" << val << endl;return val;}private:queueque;
};void producer(Queue* que)
{for (int i = 0; i < 10; i++){que->put(i);this_thread::sleep_for(chrono::microseconds(100));}
}
void consumer(Queue* que)
{for (int i = 0; i < 10; i++){que->get();this_thread::sleep_for(chrono::microseconds(100));}
}
int main()
{Queue que;thread t1(producer,&que);thread t2(consumer,&que);t1.join();t2.join();}

条件变量wait使线程进入等待状态，且可以把持有的互斥锁先释放掉

notify_all()通知在条件变量上等待的线程，条件成立，解除等待

其他在条件变量上等待的线程，从等待->阻塞->获取到互斥锁才能继续执行