c++ - 创建一个线程安全的原子计数器

Question

我在我的一个项目中有一个特定的要求，即保持对某些操作的“计数”并最终定期(例如 24 小时)“读取”+“重置”这些计数器。

操作将是:

• 工作线程 -> 递增计数器(随机)
• 计时器线程(例如 24 小时)-> 读取计数 -> 做某事 -> 重置计数器

我比较感兴趣的平台是Windows，如果这个能跨平台就更好了。我使用的是 Visual Studio，目标 Windows 体系结构仅限 x64。

我不确定结果是否“正常”以及我的实现是否正确。坦率地说，我从未使用过太多标准包装器，而且我的 C++ 知识非常有限。

结果是:

12272 Current: 2
12272 After: 0
12272 Current: 18
12272 After: 0
12272 Current: 20
12272 After: 0
12272 Current: 20
12272 After: 0
12272 Current: 20
12272 After: 0

下面是一个完全复制/粘贴的可重现示例:

#include <iostream>
#include <chrono>
#include <thread>
#include <Windows.h>

class ThreadSafeCounter final 
{
private:
    std::atomic_uint m_Counter1;
    std::atomic_uint m_Counter2;
    std::atomic_uint m_Counter3;
public:
    ThreadSafeCounter(const ThreadSafeCounter&) = delete;
    ThreadSafeCounter(ThreadSafeCounter&&) = delete;
    ThreadSafeCounter& operator = (const ThreadSafeCounter&) = delete;
    ThreadSafeCounter& operator = (ThreadSafeCounter&&) = delete;

    ThreadSafeCounter() : m_Counter1(0), m_Counter2(0), m_Counter3(0) {}
    ~ThreadSafeCounter() = default;

    std::uint32_t IncCounter1() noexcept 
    {
        m_Counter1.fetch_add(1, std::memory_order_relaxed) + 1;
        return m_Counter1;
    }

    std::uint32_t DecCounter1() noexcept
    {
        m_Counter1.fetch_sub(1, std::memory_order_relaxed) - 1;
        return m_Counter1;
    }

    VOID ClearCounter1() noexcept
    {
        m_Counter1.exchange(0);
    }
};

int main()
{
    static ThreadSafeCounter Threads;

    auto Thread1 = []() {
        while (true)
        {
            auto test = Threads.IncCounter1();
            std::cout << std::this_thread::get_id() << " Threads.IncCounter1() -> " << test << std::endl;

            std::this_thread::sleep_for(std::chrono::seconds(2));
        }
    };

    auto Thread2 = []() {
        while (true)
        {
            auto test = Threads.DecCounter1();
            std::cout << std::this_thread::get_id() << " Threads.DecCounter1() -> " << test << std::endl;

            std::this_thread::sleep_for(std::chrono::seconds(2));
        }
    };

    auto Thread3 = []() {
        while (true)
        {
            Threads.ClearCounter1();
            std::cout << std::this_thread::get_id() << " Threads.ClearCounter1()" << std::endl;

            std::this_thread::sleep_for(std::chrono::seconds(2));
        }
    };

    std::thread th1(Thread1);
    std::thread th2(Thread2);
    std::thread th3(Thread3);

    th1.join();
    th2.join();
    th3.join();
}

我应该提一下，在我的现实生活项目中没有使用 std::thread 包装器，线程是使用 CreateThread 等 WinApi 函数创建的。以上只是为了模拟/测试代码。

请指出上述代码有什么问题、可以改进的地方以及我的方向是否正确。

谢谢!

Answer 1

你为什么要写 ThreadSafeCounter上课吗？

std::atomic<size_t> 是一个ThreadSafeCounter。这就是 std::atomic 的全部意义所在。所以你应该改用它。无需再上课。大多数原子都有 operator++/operator-- 特化，所以你的主循环可以很容易地重写如下:

    static std::atomic_int ThreadCounter1(0);

    auto Thread1 = []() {
        while (true)
        {
            auto test = ++ThreadCounter1;  // or ThreadCounter1++, whatever you need
            std::cout << std::this_thread::get_id() << " Threads.IncCounter1() -> " << test << std::endl;

            std::this_thread::sleep_for(std::chrono::seconds(2));
        }
    };

    auto Thread2 = []() {
        while (true)
        {
            auto test = --ThreadCounter1;
            std::cout << std::this_thread::get_id() << " Threads.DecCounter1() -> " << test << std::endl;

            std::this_thread::sleep_for(std::chrono::seconds(2));
        }
    };

    auto Thread3 = []() {
        while (true)
        {
/* Note: You could simply "ThreadCounter1 = 0" assign it here.
But exchange not only assigns a new value, it returns the previous value.
*/
            auto ValueAtReset=ThreadCounter1.exchange(0);
            std::cout << std::this_thread::get_id() << " Threads.ClearCounter1() called at value" << ValueAtReset << std::endl;

            std::this_thread::sleep_for(std::chrono::seconds(2));
        }
    };

我忘了提及您的 DecCounter 操作的问题。您正在使用 atomic_uint，它不能处理负数。但是不能保证您的 Thread2 不会在 Thread1 之前运行(也就是递减计数器)。这意味着您的计数器将换行。

所以你可以/应该使用 std::atomic<int>反而。这将为您提供正确数量的 (calls_Thread1 - calls_Thread2)。如果 Thead2 比 Thread1 更频繁地递减该值，则该数字将变为负数。