date:  2020-05-29 16:51:33 +0800
tags:
  - 编程基础

原始C++标准仅支持单线程编程。新的C++标准(称为C++11或C++0x)于2011年发布。在C++11中，引入了新的线程库。因此运行本文程序需要C++至少符合C++ 11标准。

4 数据共享和资源竞争

在多线程环境中，线程之间的数据共享非常容易。但是，这种易于共享的数据可能会导致应用程序出现问题。这样的问题之一就是资源竞争。

4.1 资源竞争

竞争条件是多线程应用程序中出现的一种错误。当两个或多个线程并行执行一组操作时，它们将访问同一内存位置。同样，其中的一个或多个线程会修改该内存位置中的数据，这有时会导致意外结果。这称为竞争条件。
竞赛条件通常不会每次都出现，因此通常很难找到和复制。仅当两个或多个线程的相对执行顺序导致意外结果时，它们才会发生。让我们通过一个例子来理解。
让我们创建一个Wallet类，它在内部维护money并提供一个服务/功能，即addMoney()。此成员函数按指定的计数递增钱包对象的内部货币。

class Wallet
{
	int mMoney;
public:
	Wallet() :mMoney(0) {}
	int getMoney() {
		return mMoney;
	}
	void addMoney(int money)
	{
		for (int i = 0; i < money; ++i)
		{
			mMoney++;
		}
	}
};

现在，让我们创建5个线程，所有这些线程将共享Wallet类的同一对象，并使用其addMoney()成员函数并行向内部货币添加100000(这个数字要足够大，否则无效果)。因此，如果最初在钱包中的钱为0。那么在完成所有线程的执行后，在Wallet中的钱应该为500000。但是，由于所有线程正在同时修改共享数据，因此在某些情况下，最终钱包中的钱可能少于500000。让我们测试一下：

#include <iostream>
#include <vector>
#include <thread>

class Wallet
{
	int mMoney;
public:
	Wallet() :mMoney(0) {}
	int getMoney() {
		return mMoney;
	}
	void addMoney(int money)
	{
		for (int i = 0; i < money; ++i)
		{
			mMoney++;
		}
	}
};

int testMultithreadedWallet()
{
	Wallet walletObject;
	std::vector<std::thread> threads;
	for (int i = 0; i < 5; ++i)
	{
		threads.push_back(std::thread(&Wallet::addMoney, &walletObject, 100000));
	}
	for (int i = 0; i < threads.size(); i++)
	{
		threads.at(i).join();
	}
	return walletObject.getMoney();
}
int main()
{
	int val = 0;
	for (int k = 0; k < 10; k++)
	{
		if ((val = testMultithreadedWallet()) != 500000)
		{
			std::cout << "Error at count = " << k << " Money in Wallet = " << val << std::endl;
		}
	}
	return 0;
}

输出为：

Error at count = 0 Money in Wallet = 360389
Error at count = 1 Money in Wallet = 420648
Error at count = 2 Money in Wallet = 382707
Error at count = 3 Money in Wallet = 397744
Error at count = 4 Money in Wallet = 280937
Error at count = 5 Money in Wallet = 248475
Error at count = 6 Money in Wallet = 240935
Error at count = 7 Money in Wallet = 320526
Error at count = 8 Money in Wallet = 328090
Error at count = 9 Money in Wallet = 370140

由于同一Wallet类对象的addMoney()成员函数执行了5次，因此其内部货币预计为500000。但是由于addMoney()成员函数并行执行，因此在某些情况下mMoney会比500000小得多。

为什么会这样？
每个线程并行递增相同的“mMoney”成员变量。虽然看起来只有一行，但是这个“mMoney++”实际上被转换成三个机器命令。

1. 将“ mMoney”变量值加载到寄存器中
2. 增量寄存器的值
3. 用寄存器的值更新变量“ mMoney”

现在假设在特殊情况下，上述命令的执行顺序如下：

在这种情况下，一个增量将被忽略，因为不是将“mMoney”变量递增两次，而是不同的寄存器递增，并且“mMoney”变量的值被覆盖。
假设在此方案之前，mMoney为46，如上图所示，它增加了2倍，因此预期结果为48。但是由于上述方案中的资源竞争，mMoney的最终值将仅为47。

4.2 如何解决比赛条件？

为了解决这个问题，我们需要使用Lock机制，即每个线程需要在修改或读取共享数据之前获取一个锁，并且在修改数据之后，每个线程都应该解锁该锁。我们将在下一篇文章中讨论这一点。

4.3 参考

https://thispointer.com/c11-multithreading-part-4-data-sharing-and-race-conditions/