当一个线程不断从内存中查询变量而另一个线程对其进行更新时，是否存在竞争条件？

如何解决当一个线程不断从内存中查询变量而另一个线程对其进行更新时，是否存在竞争条件？

我有以下代码

#include <stdio.h>
#include <thread>
#include <mutex>


class A
{
    public:
        A(int n) : num_workers(n) {
            counter_lock = new std::mutex();
            threads = new std::thread[num_workers];
            for (int i = 0; i < num_workers; i++) {
                threads[i] = std::thread(&A::run,this);
            }
        }

        ~A() {
            delete counter_lock;
        }

        void start() {
            go = true;
            counter = 0;
            total = 1000000;

            while (counter < total) {};

            for (int i = 0; i < num_workers; i++) {
                threads[i].join();
            }
        }

        void run() {
            printf("Spinning\n");
            while(1) {
                if (go) {
                    int i;
                    counter_lock->lock();
                    i = counter++;
                    counter_lock->unlock();
                    if (i >= total) break;
                }
            }
            printf("Done\n");
        }
    private:
        std::mutex* counter_lock;
        std::thread* threads;
        int num_workers;
        int counter;
        int total;
        bool active;
        bool go;
};

int main() {
    A a = A(10);
    a.start();
}

在A的构造函数中，我创建一个num_workers的线程池。他们都在执行一个函数A::run，该函数只是等待直到收到go的信号，然后开始递增counter。函数start旨在与调用它的任何人同步，因此在这种情况下，它应与main同步。因此，在向所有工作线程发出counter信号之后，它只是闲置直到total到达go。

该代码按预期工作。 counter最终以10000010结尾，这是有道理的，因为每个10线程在退出前已经对counter进行了一次递增。

我是否没有注意到比赛条件？我在counter循环中读取while(counter < total) {}时没有锁定，这是否会导致任何问题呢？

谢谢您的建议。

编辑：我用以下（也许是线程安全的）实现替换了while (counter < total) {}循环。但是，由于counter的值尚未更新，它仍然永远循环永远。

while (1) {
    int c;
    counter_lock->lock();
    c = counter;
    counter_lock->unlock();
    if (c >= total) break;
};