C++ 互斥量不起作用 - 同步失败

Question

我想应用尽可能简单的互斥锁。

#include <iostream>
#include <thread>
#include <vector>
#include <functional>
#include <algorithm>
#include <mutex>
using namespace std;

int sum;
static mutex m;

void addValue(int value)
{
    m.lock();
    sum += value;
    m.unlock();
}

int main()
{

    int counter1 = 0;
    int counter2 = 0;
    for (int i = 0; i < 100; i++)
    {
        thread t1(addValue, 100);
        thread t2(addValue, 200);

        if (sum == 300)
        {
            counter1++;
        }
        else
        {
            counter2++;
        }
        sum = 0;
        t1.join();
        t2.join();
    }
    cout << counter1 << endl;
    cout << counter2 << endl;
}

不幸的是，上面提到的代码没有按预期工作。我预计：

a) 总和总是等于 300
b) counter1 总是 100
c) counter2 总是 0

怎么了？

编辑：

当我在 else 条件下调试 sum 变量时，我看到如下值： 200、400、100，甚至 0（我假设加法甚至没有发生）。

Answer 1

C++ mutex doesn't work - synchronization fails

为什么每个第一次学习这些东西的人都认为适用于其他人的久经考验的同步原语被打破了，而不是他们的假设？

互斥量没问题。你的心智模型被打破了。这应该是您的起始假设。

I expect that:

sum is always equal to 300

如果您在检查值之前join编辑了两个线程，就会出现这种情况。但是您还没有这样做，所以您正在对 sum 进行完全不同步的读取，而其他两个线程可能正在改变它。这是一场数据竞赛。除非您总是在访问数据时使用互斥体，否则互斥体不会保护您的数据。

假设我们进行了最小的更改，因此 sum 始终受到保护：

thread t1(addValue, 100); // a thread t2(addValue, 200); // b m.lock(); if (sum == 300) // c { counter1++; } else { counter2++; } sum = 0; m.unlock();

现在一些可用的顺序是：

abc - 您所期望的（以及如果您在阅读 sum 之前加入两个线程将会保证什么）

acb - 您在第 c 行读取 100，增加 counter2，第二个线程将 sum 增加到 300 在你读完之后（但你永远不会看到这个）

cab - 在两个线程甚至被安排到运行
之前，您立即阅读 0
bca - 您阅读 200，在您检查
后它会增加到 300
等等

每个排列都是允许的，除非你努力明确地对它们进行排序

Answer 2

它按预期工作，问题是您没有预料到所有 3 个线程的“时间”都不相同，并且您驳斥了一个线程先于另一个线程启动这一明显的事情，这显然增加了一个优势，甚至更多，如果它只需要做的是循环 100 次增量。

#include <iostream>
#include <thread>
#include <mutex>

bool keep_alive;

void add_value_mutex(std::mutex * mx, int * trg, int value) {
    while (keep_alive){
        mx->lock();
        (*trg) += value;
        mx->unlock();
    }
}

int main(){

    std::thread thread_1;
    std::thread thread_2;

    int count_targ = 2000;
    int * counter_1 = new int(0);
    int * counter_2 = new int(0);

    /* --- */

    std::mutex mx_1;
    std::mutex mx_2;

    keep_alive = true;
    thread_1 = std::thread(add_value_mutex, &mx_1, counter_1, 1);
    thread_2 = std::thread(add_value_mutex, &mx_2, counter_2, 1);

    while(1){

        if (mx_1.try_lock()){
            if (count_targ <= * counter_1){
                mx_1.unlock();
                break;
            }
            mx_1.unlock();
        }

        if (mx_2.try_lock()){
            if (count_targ <= * counter_2){
                mx_2.unlock();
                break;
            }
            mx_2.unlock();
        }

    }
    
    keep_alive = false;
    thread_1.join();
    thread_2.join();
        
    std::cout << "Thread 1 (independent mutex) -> " << * counter_1 << std::endl;
    std::cout << "Thread 2 (independent mutex) -> " << * counter_2 << std::endl;

    /* --- */

    keep_alive = true;
    (*counter_1) = 0;
    (*counter_2) = 0;

    std::mutex mx_s;
    thread_1 = std::thread(add_value_mutex, &mx_s, counter_1, 1);
    thread_2 = std::thread(add_value_mutex, &mx_s, counter_2, 1);

    while(1){

        if (mx_s.try_lock()){
            if (count_targ <= * counter_1 || count_targ <= * counter_2){
                mx_s.unlock();
                break;
            }
            mx_s.unlock();
        }
    }

    std::cout << "Thread 1 (shared mutex) -> " << * counter_1 << std::endl;
    std::cout << "Thread 2 (shared mutex) -> " << * counter_2 << std::endl;

    keep_alive = false;
    thread_1.join();
    thread_2.join();


    delete counter_1;
    delete counter_2;

    return 0;
}

如果你想要我的另一个例子来测量线程等待的时间check this one

C++ 互斥量不起作用 - 同步失败

C++ mutex doesn't work - synchronization fails

c++

thread-safety

mutex

race-condition

data-race