C++ 需要互斥的情况？

有人能帮我举一个例子吗？在这种情况下，缺少互斥“肯定”会导致错误的结果

我需要这个，以便测试我的互斥实现

--

---

Neeraj当需要互斥时，您肯定需要一个互斥（或类似的机制）。

制作一个包含fork（）的程序。然后，让子进程和父进程从同一个文件中读取一个数字，增加该数字，然后将其写回该文件。在每个过程中都要这样做100次。

最典型的例子是夫妻共用的ATM机。一个存款，另一个用不同的线程取款。如果关键部分没有适当地由互斥锁保护，那么它们中的每一个都可能看到不一致的结果

---

如果需要“确定的情况”，让丈夫先存一笔钱，然后再睡上足够的时间，这样妻子就可以取款了。丈夫的结果将覆盖妻子的结果，帐户余额不再是酸性的。

我认为不是，因为从应用程序的角度来看，当前操作系统中实现的调度程序是不确定的。但是，如果启动大量线程并多次测试代码，则冲突的概率应该足够高。

请考虑使用互斥体进行同步的任何正确代码。通过移除锁定，您将向程序引入新的（可能不正确的）行为（执行）。但是，新代码仍将包含所有旧行为，因此始终至少有一次执行会产生正确的结果。因此，您所要求的是不可能的。

以下是我在互斥体实现测试套件中使用的测试类型：

// global:
enum { HUGE_VAL = 50000 }
Mutex mutex;
int variable;

// main thread
mutex.lock();
thread.run();
for(int i = 0; i < HUGE_VAL; ++i)
    ++variable;
assert(variable == HUGE_VAL);
mutex.unlock();
thread.join();
assert(variable == -HUGE_VAL);

// parallel thread
mutex.lock();
variable = -HUGE_VAL;
mutex.unlock();

//全局：
枚举{MAGING_VAL=50000}
互斥互斥；
int变量；
//主线
mutex.lock（）；
thread.run（）；
对于（int i=0；i<0+i）
++可变的；
断言（变量==巨大值）；
mutex.unlock（）；
thread.join（）；
断言（变量==-巨大值）；
//平行线
mutex.lock（）；
变量=-巨大的值；
mutex.unlock（）；

---

当然，可以根据您的感觉调整大的值，因为互斥是用来防止并发访问的。因此，要测试它，您需要创建并发性，并且机器运行得越快，它应该越大……

您只是在测试它是否正确锁定吗？如果是这样，也许是这样的？两条线

#Global Variables
int counter = 1
int factorial = 1


#Critical Section
counter++
Delay for some amount of time
factorial *= counter
#End Critical Section

---

如果互斥锁工作，那么最终结果应该是6。否则将是9编辑或3我认为，

*=

不是原子的，但无论如何不是6。

您可以模拟用于说明数据库事务的著名示例。我们有A和B两个账户，需要从A到B转账200美元

类C++伪代码（未测试）

int accountA=200；
int accountB=0；
无效转账（整笔和从、整笔和到、整笔金额）
{
//互斥数据采集应该在这里
如果（从<金额）{
printf（“错误”）；
//互斥释放应该在这里
返回；
}
from-=金额；
休眠（5000）；//空闲等待5秒
至+=金额；
//互斥释放应该在这里
}
无效显示（常量int和account1、常量int和account2）
{
//互斥数据采集应该在这里
睡眠（3000）；//等待3秒钟
printf（“%d”，account1）；
printf（%d），account2；
//互斥释放应该在这里
}

现在产生两个线程，并在一个线程上执行

transfer（accountA，accountB，200）；

，在另一个线程上执行

display（accountA，accountB）；

，同时开始

---

在一个无负载的系统中，程序将显示货币在转移过程中消失了——在“交易”的中间（在这里没有交易的情况下），帐户被读取，所以没有隔离。“

这是一个非常明确的问题。如果你正确理解我的问题，我不需要“可能性”，我需要一个“确定的情况”，以保证产生错误的结果。这可能会，但不一定会导致同步问题。我认为这仅适用于，如果您不停止某个特定的进程来影响指令的执行顺序，那么如果存在这样一个测试（保证可以发现同步错误）岂不是很好。不幸的是，正如@avakar所说，这是不可能的。删除同步只会扩大可能的行为范围。它不会阻止正确的行为发生。

 int accountA = 200;
 int accountB = 0;

 void transfer( int& from, int& to, int amount )
 {
     //mutex acquisition should be here
     if( from < amount ) {
         printf( "error" );
         // mutex release should be here
         return;
     }
     from -= amount;
     Sleep( 5000 ); //wait idle for 5 seconds
     to += amount;
     // mutex release should be here
 }

 void display( const int& account1, const int& account2 )
 {
     //mutex acquisition should be here
     Sleep( 3000 ); //wait 3 seconds
     printf( "%d", account1 );
     printf( %d", account2 );
     // mutex release should be here
 }