哪种类型的 memory_order 应该用于 atomic_flag 的非阻塞行为？

Question

我不想让我的线程等待，什么也不做，让其他线程完成使用数据，同时做一些其他事情（比如检查输入，或者重新渲染前一帧队列，然后返回检查另一个线程是否完成了它的任务）。

我认为我编写的这段代码可以做到这一点，而且它“似乎”在我执行的测试中有效，但我真的不明白 std::memory_order_acquire 和 std::memory_order_clear 工作正常，所以我想要一些专家建议，看看我是否正确地使用它们来实现我想要的行为。

另外，我以前从未见过多线程是这样实现的，这让我有点担心。有充分的理由不让线程执行其他任务而不是等待吗？

/*test program
intended to test if atomic flags can be used to perform other tasks while shared
data is in use, instead of blocking

each thread enters the flag protected part of the loop 20 times before quitting
if the flag indicates that the if block is already in use, the thread is intended to
execute the code in the else block (only up to 5 times to avoid cluttering the output)

debug note: this doesn't work with std::cout because all the threads are using it at once
and it's not thread safe so it all gets garbled.  at least it didn't crash

real world usage
one thread renders and draws to the screen, while the other checks for input and
provides frameData for the renderer to use.  neither thread should ever block*/

#include <fstream>
#include <atomic>
#include <thread>
#include <string>

struct ThreadData {
    int numTimesToWriteToDebugIfBlockFile;
    int numTimesToWriteToDebugElseBlockFile;
};

class SharedData {
public:
    SharedData() {
        threadData = new ThreadData[10];
        for (int a = 0; a < 10; ++a) {
            threadData[a] = { 20, 5 };
        }
        flag.clear();
    }

    ~SharedData() {
        delete[] threadData;
    }

    void runThread(int threadID) {
        while (this->threadData[threadID].numTimesToWriteToDebugIfBlockFile > 0) {
            if (this->flag.test_and_set(std::memory_order_acquire)) {
                std::string fileName = "debugIfBlockOutputThread#";
                fileName += std::to_string(threadID);
                fileName += ".txt";
                std::ofstream writeFile(fileName.c_str(), std::ios::app);
                writeFile << threadID << ", running, output #" << this->threadData[threadID].numTimesToWriteToDebugIfBlockFile << std::endl;
                writeFile.close();
                writeFile.clear();
                this->threadData[threadID].numTimesToWriteToDebugIfBlockFile -= 1;
                this->flag.clear(std::memory_order_release);
            }
            else {
                if (this->threadData[threadID].numTimesToWriteToDebugElseBlockFile > 0) {
                    std::string fileName = "debugElseBlockOutputThread#";
                    fileName += std::to_string(threadID);
                    fileName += ".txt";
                    std::ofstream writeFile(fileName.c_str(), std::ios::app);
                    writeFile << threadID << ", standing by, output #" << this->threadData[threadID].numTimesToWriteToDebugElseBlockFile << std::endl;
                    writeFile.close();
                    writeFile.clear();
                    this->threadData[threadID].numTimesToWriteToDebugElseBlockFile -= 1;
                }
            }
        }
    }
private:
    ThreadData* threadData;
    std::atomic_flag flag;
};

void runThread(int threadID, SharedData* sharedData) {
    sharedData->runThread(threadID);
}

int main() {
    SharedData sharedData;
    std::thread thread[10];
    for (int a = 0; a < 10; ++a) {
        thread[a] = std::thread(runThread, a, &sharedData);
    }
    thread[0].join();
    thread[1].join();
    thread[2].join();
    thread[3].join();
    thread[4].join();
    thread[5].join();
    thread[6].join();
    thread[7].join();
    thread[8].join();
    thread[9].join();
    return 0;
}```

Answer 1

您在此处使用的内存顺序是正确的。

当你测试和设置你的标志（获取你的手写锁）时的acquire内存顺序具有非正式的效果，即防止以下代码的任何内存访问在标志被测试。这就是您想要的，因为您希望确保在已设置标志的情况下不会有效地完成这些访问。同样，末尾 clear 上的 release 命令可防止前面的任何访问在清除后变得可见，这也是您需要的，以便它们仅在持有锁时发生。

不过，使用 std::mutex 可能更简单。如果你不想等待拿锁，而是在你做不到的情况下做其他事情，那就是 try_lock 的目的。

class SharedData {
    // ...
private:
    std::mutex my_lock;
}
// ...
if (my_lock.try_lock()) {
    // lock was taken, proceed with critical section
    my_lock.unlock();
} else {
    // lock not taken, do non-critical work
}

这可能会有更多的开销，但避免了考虑原子性和内存排序的需要。如果稍后有用，它还为您提供了轻松进行阻塞等待的选项。如果你围绕 atomic_flag 设计你的程序，后来发现必须等待获取锁的情况，你可能会发现自己在不断重试锁的同时陷入旋转（这浪费了 CPU 周期），或类似 std::this_thread::yield()，在锁定可用后等待的时间可能比必要的时间更长。

的确，这种模式有点不寻常。如果总是有不需要锁的非关键工作要做，通常你会设计你的程序有一个单独的线程，它只连续地做非关键工作，然后“关键”线程可以在等待锁定时阻塞。

哪种类型的 memory_order 应该用于 atomic_flag 的非阻塞行为？

Which types of memory_order should be used for non-blocking behaviour with an atomic_flag?

c++

multithreading

nonblocking

memory-barriers

stdatomic