使用原子和互斥 C++ 在 class 内线程化

Question

我编写这个示例程序是为了模仿我在一个更大的程序中尝试做的事情。

我有一些来自用户的数据将被传递到一个线程中进行一些处理。我在数据周围使用互斥锁，当有数据时，标志会发出信号。

使用lambda 表达式，是指向*this 的指针发送到线程吗？我似乎在 cout 语句中得到了我期望的行为。

是否在数据周围正确使用了互斥量？

将原子和互斥锁作为 class 的私有成员是一个好的举措吗？

foo.h

#pragma once
#include <atomic>
#include <thread>
#include <vector>
#include <mutex>

class Foo
{
public:
    Foo();
    ~Foo();

    void StartThread();
    void StopThread();
    void SendData();

private:
    std::atomic<bool> dataFlag;
    std::atomic<bool> runBar;
    void bar();
    std::thread t1;
    std::vector<int> data;
    std::mutex mx;
};

foo.c

#include "FooClass.h"
#include <thread>
#include <string>
#include <iostream>

Foo::Foo()
{
    dataFlag = false;
}

Foo::~Foo()
{
    StopThread();
}

void Foo::StartThread()
{
    runBar = true;
    t1 = std::thread([=] {bar(); });
    return;
}

void Foo::StopThread()
{
    runBar = false;

    if(t1.joinable())
        t1.join();

    return;
}

void Foo::SendData()
{
    mx.lock();
    for (int i = 0; i < 5; ++i) {
        data.push_back(i);
    }
    mx.unlock();
    dataFlag = true;
}

void Foo::bar()
{
    while (runBar)
    {
        if(dataFlag)
        {
            mx.lock();
            for(auto it = data.begin(); it < data.end(); ++it)
            {
                std::cout << *it << '\n';
            }
            mx.unlock();
            dataFlag = false;
        }
    }
}

main.cpp

#include "FooClass.h"
#include <iostream>
#include <string>

int main()
{
    Foo foo1;

    std::cout << "Type anything to end thread" << std::endl;

    foo1.StartThread();
    foo1.SendData();

    // type something to end threads
    char a;
        std::cin >> a;

    foo1.StopThread();

    return 0;
}

Answer 1

您确保使用 RAII 技术连接线程？查看。

所有数据 access/modification 是否通过 atomic 或 mutex 受到保护？查看。

互斥锁定使用std::lock_guard？没有。使用 std::lock_guard 用 RAII 包装你的 lock() 和 unlock() 调用。这确保即使在锁内发生异常，锁也会被释放。

Is putting the atomics and mutexes as a private member of the class a good move?

它既不好也不坏，但在这种情况下，Foo 是 std::thread 的包装器，它可以正常工作并控制同步，这是有道理的。

Using the lambda expression, is a pointer to *this send to the thread?

是的，你也可以t1 = std::thread([this]{bar();});让它更明确。

按照目前的情况，在锁定之后进行 dataFlag 赋值，您可能会遇到问题。如果您调用 SendData 两次，以便 bar 处理第一个，但在设置 dataFlag = false 之前停止，以便第二次调用添加数据，则将标志设置为 true 仅用于让 bar 将其设置回 false。然后，您将拥有 "sent" 但 bar 认为没有任何要处理的数据。

可能还有其他棘手的情况，但这只是一个例子；将它移入锁中可以解决该问题。

例如，您的 SendData 应如下所示：

void Foo::SendData()
{
    std::lock_guard<std::mutex> guard(mx);
    for (int i = 0; i < 5; ++i) {
        data.push_back(i);
    }
    dataFlag = true;
}

使用原子和互斥 C++ 在 class 内线程化

Threading inside class with atomics and mutex c++

c++

multithreading

mutex

class

atomic