lock_guard和unique_lock

1.lock_guard和unique_lock
2.condition_variable wait和notify_all方法

std::mutex mtx;
std::condition_variable cv;
int main()
{
	//锁+双重判断
	void sellTicket(int index)
	{
	while (ticketCount > 0) //ticketCount = 1 锁+双重判断
	{
	//当ticketCount为1时，其他线程这时可能指定到这里，但是当该线程执行完后，票变为了0，其他线程获取锁，对0减一，是错误的，所以要加双重判断。
		mtx.lock();
		if (ticketCount > 0)
		{
			tickedCount--;
		}
		mtx.unlock();
		std::this_thread::sleep_for(std::chrono::milliseconds(100));
	}
	}
	

	/*
	通知在cv上等待的线程，条件成立了，起来干活了
	其他在cv上等待的线程，收到通知，从等待状态->阻塞状态->获取互斥锁->继续往下
	*/
	cv.notify_all();

	//它不仅可以使用在简单的临界区代码段的互斥操作中，还能用在函数调用过程中
	unique_lock<std::mutex> lck(mtx);
	cv.wait(lck); //1.使线程进入等待状态 2.lck.unlock可以把mtx给释放掉

	//不可能用在函数参数传递或者返回过程中
	//只能用在简单的临界区代码段的互斥操作中
	lock_guard<std::mutex> guard(mtx);

	//mtx.lock();
	//...
	//mtx.unlock();
	return 0;
}
//lock_guard不能手动释放(unlock)

CAS

volatile std::atomic_bool isReady = false;
volatile std::atomic_int mycount = 0;//volatile防止多线程对共享变量进行缓存，访问的都是原始变量的值

void task()
{
	while (!isReady)
	{
		std::this_thread::yield();//线程出让当前的CPU时间片，等待下一次调度
	}
	
	for (int i = 0; i < 100; i++)
	{
		mycount++;
	}
}

int main()
{
	list<std::thread> tlist;
	for (int i = 0; i < 10; i++) 
	{
		tlist.push_back(std::thread(task));
	}
	
	std::this_thread::sleep_for(std::chrono::seconds(3));
	isReady = true;
	
	for (std::thread &t : tlist)
	{
		t.join():
	}
	
	cout << "mycount: " << mycount << endl;
	
	return 0;
}