Using boost::mutex::scoped_lock inside const function

Question

This code won't compile:

    class MyClass
    {
        boost::mutex _mutex; 

        void foo() const
        {
          boost::mutex::scoped_lock lock(_mutex);
         //critical section
        }
    }

But defining the function as non const will work fine. Please, can someone explain why? Thanks!

In critical section there there is peek into a data structure. — Sanich, Mar 19 '15 at 14:26
@imreal There may be another non-const function which does modify MyClass. The mutex protects simultaneous reading and writing. — tamas.kenez, Mar 19 '15 at 14:27

JBL · Accepted Answer · 2015-03-19T14:35:54.663

You can't lock a mutex inside a const-member function because this actually modifies the internal state of the mutex (lock is not itself a const function).

If you want to keep the function const, you'll have to declare the mutex as mutable which is a cv-qualifier that allows const functions to modify it, i.e.

//can now be locked (i.e. modified) by a const function
mutable boost::mutex _mutex;

Using mutable relax the const constraints on the member variable which is declared with this qualifier, that's a way to get around constness, so be careful not to abuse this. In this case, it seems reasonable because a mutex is an internal tool of your class, and does not participate in "logical constness" (as opposed to "bitwise constness").

You can declare it as `mutable` – Jose Palma Mar 19 '15 at 14:22 — Jose Palma, Mar 19 '15 at 14:22

score 3 · Answer 2 · answered Mar 19 '15 at 14:23

3

This code should compile

class MyClass
{
    mutable boost::mutex _mutex; 
    void foo() const
    {
       boost::mutex::scoped_lock lock(_mutex);
       //critical section
    }
}

answered Mar 19 '15 at 14:23

Jose Palma

756
6
13

Please can you explain why it didn't work. Is locking the _mutex is 'modifing' it? – Sanich Mar 19 '15 at 14:25
See the @Bas in het Veld comment, he explains the reasons :-). – Jose Palma Mar 19 '15 at 14:26

score 1 · Answer 3 · answered Mar 19 '15 at 14:25

1

Raistmaj is right.

The reason is that a constant method guarantees it does not change its class instance. By declaring the mutex mutable, you make an exception for that variable.

answered Mar 19 '15 at 14:25

Bas in het Veld

1,271
10
17

score 1 · Answer 4 · answered Mar 19 '15 at 14:27

The problem occurs because boost::mutex::lock(), which is called by the constructor of boost::mutex::scoped_lock, is not a const member function. Since the mutex is a member of MyClass, that means that MyClass::_mutex::lock() cannot be called from a non-const member function of MyClass.

The solution is to declare the mutex as a mutable member. This indicates to the compiler that _mutex may be modified, even in a const member function:

class MyClass
{
    mutable boost::mutex _mutex; 

    void foo() const
    {
      boost::mutex::scoped_lock lock(_mutex);
     //critical section
    }
}

score 0 · Answer 5 · answered Mar 19 '15 at 14:58

Please can you explain why it didn't work. Is locking the _mutex is 'modifing' it?

Precisely, the _mutex object will change it's internal state from say "unlocked" to "locked" state. So, you need the mutable keyword fora const-function to preserve logical constness of the function while allowing the mutex to be modifiable.

Using boost::mutex::scoped_lock inside const function

5 Answers5