c++ - move 构造函数对于具有 std::threads 和 std::mutex 作为其字段的类是否有意义？

Question

假设我有一个类:

class WonnaBeMovedClass
{
public:

    WonnaBeMovedClass(WonnaBeMovedClass&& other);

    void start();

private:

    void updateSharedData();

    std::vector<int> _sharedData;
    std::thread _threadUpdate;
    std::mutex _mutexShaderData;

    //other stuff
};

WonnaBeMovedClass::WonnaBeMovedClass(WonnaBeMovedClass&& other)
{
    _sharedData = std::move(other._sharedData);
    _threadUpdate = std::move(other._threadUpdate);
    _mutexShaderData = std::move(other._mutexShaderData); //won't compile.
}

void WonnaBeMovedClass::start()
{
    _threadUpdate = std::thread(&updateSharedData, this);
}

void WonnaBeMovedClass::updateSharedData()
{
    std::lock_guard<std::mutex> lockSharedData(_mutexShaderData);

    for (auto& value : _sharedData)
    {
        ++value;
    }
}

它不会编译，因为无法 move 互斥量。这没有意义。 然后我认为可以通过使用指针而不是实际变量来解决这个问题，并提出以下建议:

class WonnaBeMovedClass
{
public:

    WonnaBeMovedClass(WonnaBeMovedClass&& other);

    void start();

private:

    void updateSharedData();

    std::vector<int> _sharedData;
    std::unique_ptr<std::thread> _threadUpdate //pointer;
    std::unique_ptr<std::mutex> _mutexShaderData //pointer;

    //other stuff
};

WonnaBeMovedClass::WonnaBeMovedClass(WonnaBeMovedClass&& other)
{
    _sharedData = std::move(other._sharedData);
    _threadUpdate = std::move(other._threadUpdate);
    _mutexShaderData = std::move(other._mutexShaderData); //won't compile.
}

void WonnaBeMovedClass::start()
{
    _threadUpdate = std::make_unique<std::thread>(&updateSharedData, this);
}

void WonnaBeMovedClass::updateSharedData()
{
    std::lock_guard<std::mutex> lockSharedData(*_mutexShaderData);

    for (auto& value : _sharedData)
    {
        ++value;
    }
}

所以现在当我:

WonnaBeMovedClass object1;
WonnaBeMovedClass object2;

//do stuff

object1 = std::move(object2);

我实际上 move 了互斥量和线程的地址。 现在更有意义了……还是不是？

该线程仍在处理object1 的数据，而不是object2，所以它仍然没有任何意义。 我可能 move 了互斥量，但线程不知道 object2。或者是吗？ 我无法找到答案，所以我向您寻求帮助。

我是不是做错了什么，复制/move 线程和互斥量只是一个糟糕的设计，我应该重新考虑程序的架构吗？

编辑:

有一个关于类(class)实际目的的问题。它实际上是一个 TCP/IP 客户端(表示为一个类)，它包含:

• 来自服务器的最新数据(几个数据表，类似于std::vector)。
• 包含管理线程(更新状态、发送/接收消息)的方法。

一次可以建立多个连接，因此在代码中的某处有一个 std::vector<Client>表示所有事件连接的字段。 连接由配置文件决定。

//read configurations

...

//init clients
for (auto& configuration : _configurations)
{
    Client client(configuration);
    _activeClients.push_back(client); // this is where compiler reminded me that I am unable to move my object (aka WonnaBeMovedClass object).
}}

我已经改变了_activeClients来自 std::vector<Client>至 std::vector<std::unique_ptr<Client>>并修改了初始化代码以创建指针对象而不是直接创建对象并解决了我的问题，但问题仍然存在，所以我决定将其发布在这里。

Answer 1

让我们把问题一分为二。

1. move 互斥体。这是不可能做到的，因为互斥锁通常是根据必须具有固定地址的操作系统对象来实现的。换句话说，操作系统(或运行时库，对于我们的目的而言与操作系统相同)保留互斥体的地址。这可以通过在代码中存储指向互斥体的(智能)指针并 move 它们来解决。互斥量本身不会 move 。线程对象可以 move ，所以没有问题。
2. move 您自己的数据，而一些事件代码(线程或正在运行的函数或 std::function 存储在某处或其他任何地方)具有您的数据地址并可以访问它。这实际上与之前的情况非常相似，只是保存数据的是您自己的代码而不是操作系统。和以前一样，解决方案是不 move 您的数据。而是将(智能)指针存储并 move 到数据。

总结一下，

class WonnaBeMovedClass
{
public:
    WonnaBeMovedClass
        (WonnaBeMovedClass&& other);
    void start();
private:
    struct tdata {
        std::vector<int> _sharedData;
        std::thread _threadUpdate;
        std::mutex _mutexShaderData;
     };
     std::shared_ptr<tdata> data;
     static void updateSharedData(std::shared_ptr<tdata>);
};

void WonnaBeMovedClass::start()
{
    _threadUpdate = std::thread(&updateSharedData, data);
}