Object locking for efficient access.

suggest change

Often you want to lock the entire object while you perform multiple operations on it. For example, if you need to examine or modify the object using iterators. Whenever you need to call multiple member functions it is generally more efficient to lock the whole object rather than individual member functions.

For example:

class text_buffer
    // for readability/maintainability
    using mutex_type = std::shared_timed_mutex;
    using reading_lock = std::shared_lock<mutex_type>;
    using updates_lock = std::unique_lock<mutex_type>;

    // This returns a scoped lock that can be shared by multiple
    // readers at the same time while excluding any writers
    reading_lock lock_for_reading() const { return reading_lock(mtx); }

    // This returns a scoped lock that is exclusing to one
    // writer preventing any readers
    updates_lock lock_for_updates() { return updates_lock(mtx); }

    char* data() { return buf; }
    char const* data() const { return buf; }

    char* begin() { return buf; }
    char const* begin() const { return buf; }

    char* end() { return buf + sizeof(buf); }
    char const* end() const { return buf + sizeof(buf); }

    std::size_t size() const { return sizeof(buf); }

    char buf[1024];
    mutable mutex_type mtx; // mutable allows const objects to be locked

When calculating a checksum the object is locked for reading, allowing other threads that want to read from the object at the same time to do so.

std::size_t checksum(text_buffer const& buf)
    std::size_t sum = 0xA44944A4;

    // lock the object for reading
    auto lock = buf.lock_for_reading();

    for(auto c: buf)
        sum = (sum << 8) | (((unsigned char) ((sum & 0xFF000000) >> 24)) ^ c);

    return sum;

Clearing the object updates its internal data so it must be done using an exclusing lock.

void clear(text_buffer& buf)
    auto lock = buf.lock_for_updates(); // exclusive lock
    std::fill(std::begin(buf), std::end(buf), '\0');

When obtaining more than one lock care should be taken to always acquire the locks in the same order for all threads.

void transfer(text_buffer const& input, text_buffer& output)
    auto lock1 = input.lock_for_reading();
    auto lock2 = output.lock_for_updates();

    std::copy(std::begin(input), std::end(input), std::begin(output));

note: This is best done using std::deferred::lock and calling std::lock

Feedback about page:

Optional: your email if you want me to get back to you:

Table Of Contents