当创建多个线程时
vector<thread> mythreads;面对数据共享问题分析
（1）只读的数据-稳定安全
（2）有读有写：2个线程写，8个线程读（崩溃）
最简单的崩溃处理方式：读写同一个容器时，读数据的时候不能写，写数据的时候不能读取。
案例：
（1）共享数据
（2）门票系统
（3）网络游戏服务器：两个自己创建的线程，一个线程收集玩家命令，并将命令写到另一个队列中。另一个线程需要从队列中取出玩家命令，解析，然后执行玩家需要动作。
解决方案：引入C++解决多线程保护共享数据问题的概念(互斥量)。
使用方式：
#include<mutex>
std::mutex my_mutex;
my_mutex.lock();
my_mutex.unlock();使用std::lock_guard类模板可以替换lock()和unlock()
std::lock_guard<std::mutex> sbguard(my_mutex, std::adopt_lock)死锁产生的条件：
- 互斥条件：即进程对所分配到的资源进行排他性使用，即在一段时间内某资源只由一个进程占用，如果此时还有其他进程请求资源，则请求者只能等待，直至占有资源的进程用毕释放。
- 请求和保持条件：指进程已经保持至少一个资源，但又提出了新的资源请求，而该资源已被其他进程占有，此时请求进程阻塞，但又对自己已经获得的其他资源保持不放。
- 不剥夺条件：指进程已获得的资源，在未使用完之前，不能被剥夺，只能在使用完时由自己释放。
- 环路等待条件：指在发生死锁时，必然存在一个进程-资源的环形链。
#include<thread>
#include<mutex>
#include <vector>
#include <iostream>
#include <stdlib.h>
#define RAND_AMX 100
using namespace std;
vector<int> dataQueue;
std::mutex myMutex1;
std::mutex myMutex2;
void writeData(int & data)
{
myMutex1.lock();
cout << " writeData lock1" << std::endl;
myMutex2.lock();
cout << " writeData lock2" << std::endl;
dataQueue.push_back(data);
std::cout << "input data:" << data << std::endl;
myMutex2.unlock();
myMutex1.unlock();
}
void readData()
{
myMutex2.lock();
std::cout << "readData lock1" << endl;
myMutex1.lock();
std::cout << "readData lock2" << endl;
if (!dataQueue.empty())
{
std::cout << "output data:" << dataQueue[dataQueue.size() - 1] << endl;
std::cout << std::endl;
dataQueue.pop_back();
}
else
{
std::cout << "output data is null" << endl;
}
myMutex1.unlock();
myMutex2.unlock();
}
int main()
{
while (true)
{
int i = 1 + (int)(10.0 * rand() / (RAND_MAX + 1.0));
thread th1(writeData, std::ref(i));
thread th2(readData);
th1.join();
th2.join();
}
return 1;
}recursive_mutex:
调用方程在从它成功调用lock或try_lock开始的时期里占有recursive_mutex。
- 在此期间，调用方线程可以多次锁定/解锁互斥元。recursive_mutex可以允许线程递归的去加锁。代码运行未出现任何问题。
- 线程占有recursive_mutex时，若其他所有线程试图要求recursive_mutex的所有权，则它们将阻塞（对于调用lock)或收到false返回值(对于调用try_lock)。
#include <iostream>
#include <thread>
#include <mutex>
class X {
std::recursive_mutex m;
std::string shared;
public:
void fun1()
{
std::lock_guard<std::recursive_mutex> lk(m);
shared = "fun1";
std::cout << "in fun1, shared variable is now " << shared << '\n';
}
void fun2()
{
std::lock_guard<std::recursive_mutex> lk(m);
shared = "fun2";
std::cout << "in fun2, shared variable is now " << shared << '\n';
fun1();
std::cout << "back in fun2, shared variable is " << shared << '\n';
};
};
int main()
{
X x;
std::thread t1(&X::fun1, &x);
std::thread t2(&X::fun2, &x);
t1.join();
t2.join();
}unique_lock的使用方法：
std::unique_lock<std::mutex> sbguard2(std::move(subguard));unique_lock的第二个参数：
std::unique_lock<std::mutex> sub_guard1(my_mutex1, std::try_to_lock);
std::unique_lock<std::mutex> sub_guard1(my_mutex1, std::adopt_lock);
std::unique_lock<std::mutex> sub_guard1(my_mutex1, std::defer_lock);try_to_lock:尝试锁住，如果不成功，程序不会阻塞
adopt_lock:表示互斥量已经被lock，不需要再重复lock。该互斥量必须之前已经被lock，提前加锁，才可以使用该参数，否则会报错。
defer_lock:表示暂时不去lock,之后手动去lock，但是使用之前也不允许去lock。一般用来搭配unique_lock的成员函数去使用。在使用defer_lock参数时，创建了unique_lock的对象就不会自动加锁，需要借助lock这个成员函数来手动加锁，当然也使用unlock来手动解锁。
这个就和mutex的lock和unlock使用方法一样。
condition_variable的使用：
我们可以使用条件变量（condition_variable)实现多个线程间的同步操作；当条件不满足时，相关线程会一直被阻塞，直到某种条件出现，这些线程才会被唤醒。
成员函数
1、notify_one：通知一个等待的线程
2、notify_all:通知所有等待的线程
3、wait:阻塞当前线程，直到条件变量被唤醒
4、wait_for:同wait，到指定时长时限后唤醒
5、wait_until:同wait，到达指定时间点唤醒
condition_variable的使用方法：
#include <thread>
#include <list>
#include <iostream>
#include<mutex>
using std::unique_lock;
using std::list;
std::mutex my_mutex;
std::condition_variable consume,produce;
int cargo = 0;
void consumer()
{
std::unique_lock<std::mutex> lck(my_mutex);
consume.wait(lck, []() {
if (cargo == 0) return false;
else return true;
});
std::cout << "consumer execute" << cargo << std::endl;
cargo = 0;
produce.notify_one();
}
void producer(int id)
{
std::unique_lock<std::mutex> lck(my_mutex);
produce.wait(lck, []() {
if (cargo != 0) return false;
else return true;
});
std::cout << "producer execute" << cargo<< std::endl;
cargo = id;
consume.notify_one();
}
int main()
{
std::thread consumers[10], producers[10];
for (int i = 0; i < 10; i++)
{
consumers[i] = std::thread(consumer);
producers[i] = std::thread(producer, i + 1);
}
for (int i = 0; i < 10; i++)
{
producers[i].join();
consumers[i].join();
}
return 0;
}wait的用法为：
wait（unique_lock<mutex>&lck)
用处：当需要死循环判断某个条件是否成立时(true or false)，我们往往需要开一个线程死循环来判断，这非常消耗cpu。使用条件变量，可以让当前线程wait,释放cpu，如果条件变量改变时，我们再notify退出线程，再次进行判断。
wait（unique_lock<mutex>&lck, Predicate pred)
pred用lambda表达式表示，lambda表达式具体写法为：
[](int x){return x%3 == 0}
具体来说，lambda可访问作用域内的任何动态变量，[z]值访问，[&z]引用访问，[=]按值访问全部变量，[&]引用访问全部变量，[ted,&x]值访问ted变量，引用访问x变量。
async和future、promise
async是一个函数模板，用来启动一个异步任务。相对于thread，std::future是更高级的抽象，异步结果保存在std::future中，使用者不必在乎线程细节的管理。
std::launch::async :在调用async时就开始创建线程
std::launch::deffered:延迟加载方式创建线程。
调用async时不创建线程，直到调用了future的get和wait才创建线程。
默认策略时：std::launch::async|std::launch::deffered
系统会自行决定是异步（创建新线程）还是同步（不创建新线程）运行
#include "iostream"
#include "future"
using namespace std;
int getDataDemo()
{
cout << "数据查询开始" << " threadID:" << this_thread::get_id() << endl;
this_thread::sleep_for(chrono::seconds(5));//模拟耗时
return 100;
}
int main()
{
cout << "执行数据查询" << " threadID:" << this_thread::get_id() << endl;
future<int> m_future = async(getDataDemo);//异步执行
future_status m_status;
do
{
m_status = m_future.wait_for(chrono::seconds(1));
switch (m_status)
{
case std::future_status::ready:
cout << "数据查询完成" << " threadID:" << this_thread::get_id() << endl;
break;
case std::future_status::timeout:
cout << "数据查询中..." << " threadID:" << this_thread::get_id() << endl;
break;
case std::future_status::deferred:
cout << "数据查询延迟" << " threadID:" << this_thread::get_id() << endl;
m_future.wait();
break;
default:
break;
}
} while (m_status != future_status::ready);
int ret = m_future.get();
cout << "数据查询结果:" << ret << " threadID:" << this_thread::get_id() << endl;
system("pause");
return 0;
}std::future是一个模板类，它提供了一种访问异步操作结果的机制。future_status有三种状态
deffered：异步操作未开始
ready：异步操作已经完成
timeout:异步操作超时，主要用于std::future<T>.wait_for()std::promise是c++并发编程中常用的一个类，常配合std::future使用。其作用是在一个线程中保存变量值，可供绑定的std::future对象获取。
#include <iostream>
#include <future>
#include <chrono>
#include <functional>
using T = std::function<int(int)>;
int Test_Func(int iVal)
{
std::cout << "Value is:" << iVal << std::endl;
return iVal;
}
void Thread_Fun1(std::promise<T>& p)
{
std::this_thread::sleep_for(std::chrono::seconds(1));
std::cout << "promise parameter" << std::endl;
p.set_value(std::bind(&Test_Func, std::placeholders::_1));
}
void Thread_Fun2(std::future<T>& f)
{
auto fun = f.get();
int iVal = fun(1);
std::cout << "future Result:" << iVal << std::endl;
}
int main()
{
std::promise<T> pr1;
std::future<T> fu1 = pr1.get_future();
std::thread t1(Thread_Fun1, std::ref(pr1));
std::thread t2(Thread_Fun2, std::ref(fu1));
t1.join();
t2.join();
return 1;
}使用windos.h方法操作共享数据
多个线程操作相同的数据时，比如dateTime,一般是需要按顺序访问，否则会引起数据混乱。为解决这个问题，需要引入互斥变量，让每个线程按顺序访问变量。
EnterCriticalSection(&cs)
//操作dateTime
LeaveCriticalSection(&cs)
#include <Windows.h>
#include <vector>
#include <iostream>
using namespace std;
vector<int> dataSet;
void writeData(int i)
{
EnterCriticalSection;
dataSet.push_back(i);
std::cout << "already write data" << endl;
LeaveCriticalSection;
}
void readData()
{
EnterCriticalSection;
std::cout << "the top data is " << dataSet[dataSet.size() - 1] << endl;
LeaveCriticalSection;
}
int main()
{
for (int i = 0; i < 10; i++)
{
writeData(i);
readData();
}
return 0;
}输出结果
already write data
the top data is 0
already write data
the top data is 1
already write data
the top data is 2
already write data
the top data is 3
already write data
the top data is 4
already write data
the top data is 5
already write data
the top data is 6
already write data
the top data is 7
already write data
the top data is 8
already write data
the top data is 9参考：
c++11 std::recursive_mutex__李白_的博客-CSDN博客_recursive_mutex
recursive_mutex的使用方法：
949
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
