C++多线程中的数据共享与同步机制详解-优快云博客

本文链接：https://blog.youkuaiyun.com/gjg244/article/details/129030859

当创建多个线程时

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__李白_的博客-优快云博客_recursive_mutex

recursive_mutex的使用方法：

https://www.cnblogs.com/bclshuai/p/16846095.html

C++ async_力战者的博客-优快云博客_c++ async