移动构造函数对于具有 std::thread 和 std::mutex 作为其字段的 class 是否有意义？

Question

假设我有一个 class:

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;
    }
}

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

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);

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

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

我是不是做错了什么，copying/moving 线程和互斥锁是一个糟糕的设计，我应该重新考虑程序的架构？

编辑：

class 的实际用途存在疑问。它实际上是一个 TCP/IP 客户端（表示为 class）持有：

服务器最新数据（几张数据表，类似std::vector）。
包含管理线程（更新状态、send/receive 消息）的方法。

一次可以建立多个连接，因此在代码中的某处有一个 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>> 并修改了初始化代码以创建指针对象而不是直接创建对象并解决了我的问题，但问题仍然存在所以我决定在这里 post 它。

Answer 1

WonnaBeMovedClass 是一个持有线程和互斥量的句柄，因此为它们提供移动语义（但不是复制）并不是一个糟糕的设计。

第二个解决方案看起来不错，但不要忘记为您的互斥体（构造和析构）进行适当的资源管理。我不太了解 class 的实际用途，因此根据整个解决方案的设计，使用 shared_ptr 而不是 unique_ptr 可能更好（以防多个 WonnaBeMovedClass可以共享相同的互斥体）。

std::thread 本身就是系统线程的句柄，所以它不必包裹在指针中，资源管理（即 OS 线程句柄）由标准库本身管理.

注意 mutex 实际上是内核对象（通常实现为不透明指针，例如在 Windows API)，因此 不应被用户代码以任何方式修改或更改 。

Answer 2

It makes more sense now... Or not?

不是真的。

如果一个 std::mutex 被移动，其他线程将不会知道该互斥锁的内存地址的修改！这会丢弃线程安全性。

但是，std::unique_ptr 的解决方案存在于

最后但并非最不重要的一点是，C++14 似乎可以发挥作用。在

中阅读更多内容

Answer 3

让我们把问题一分为二。

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

总而言之，

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);
}

移动构造函数对于具有 std::thread 和 std::mutex 作为其字段的 class 是否有意义？

Does move constructor makes any sense for a class that has std::thread's and std::mutex's as its fields?

c++

multithreading

pointers

move

c++11

编辑：