使用 std::mutex 复制类

Question

I have a class with a std::mutex as a member. I am trying to create an array of such class

class C
{
 int x;
 std::mutex m;
};

int main()
{
  C c[10];
  //later trying to create a temp C
  C temp = c[0];
}

Clearly the above is not possible as mutex object is not copyable. The way to solve it is through a copy constructor.

However, I am having problem in creating a copy constructor. I have tried

C (const C &c)
{
   x = c.x;

   //1. m
   //2. m()
   //3. m = c.m
}

I am not sure what is the right syntax out of the 3 choices. Please help.

Answer 1

You shouldn't write any of these lines. Your implementation of copy constructor is equivalent to:

C (const C &c) : x(), m()
{
   x = c.x;
}

So new instance of mutex m is default initialized which means that one of the default constructors will be called. It may be safely used.

However, there are several conserns about this code. Ie if m protects x , you should explicitly lock it before accessing value:

C (const C &c)
{
    std::lock_guard<std::mutex> guard(c.m);
    x = c.x;
}

which would require to declare m as mutable (because c is const reference in copy ctor).

mutable std::mutex m;

In the end, you can see that copying objects with mutexes inside is confusing, and if C is public class, it'll confuse its users, so think twice before implementing copying of it.

Answer 2

Short answer you dont copy the mutex.

Lets start from the basics, mutex is a short name of mutual exclusion ie you want to make sure that, when there are multiple threads you dont want them to change/modify the value in parallel. You want to serialize the access or modification/read so that the value read is valid.

In the above case you are copying a new value to the variable.In this case you need not use a mutex lock as you are creating a new object.

Answer 3

您可以使用shared_ptr<C>的数组，然后您不需要C本身是可复制的......

Answer 4

std::mutex m does not have to be copied. You can use the default constructed mutex.

Answer 5

As stated in other answers, there are only pretty niche situations in which you would want to do this, but in the case that you have some object class that uses a mutex internally, you will want to make copy and move constructors that explicitly declare everything to move and copy except for the mutex. This will result in the mutex (and anything else left out) being default constructed (ie each new or copied object will get its own unique mutex). Make sure that whatever your mutex is used to protect from is not being called while using the copy or move constructors as they do not (can not?) call the mutex to lock.

Here is a full example to help anyone in the future running into this issue:

class Shape
{
public:
    Shape() {} //default constructor
    Shape(double _size) //overloaded constructor
    {
        size = _size;
    }

    Shape(const Shape& obj) //copy constructor (must be explicitly declared if class has non-copyable member)
    {
        //Do not put any non-copyable member variables in here (ie the mutex), as they will be
        //default initialized if left out

        size = obj.size; //any variables you want to retain in the copy
    }
    Shape& operator=(const Shape&& obj) //move constructor (must be explicitly declared if class has non-copyable member)
    {
        //Do not put any non-copyable member variables in here (ie the mutex), as they will be
        //default initialized if left out

        size = obj.size;//any variables you want to retain in the move
        return *this;
    }

    double testMe() { return size; }
private:
    std::mutex dataMutex;
    double size;
};