Есть ли `shared_lock_guard`, а если нет, как бы он выглядел?

Я хотел использовать std::mutex в своем классе и заметил, что он не копируется. Я нахожусь на нижнем уровне моей библиотеки здесь, поэтому кажется, что это ужасная идея иметь такое поведение.Есть ли `shared_lock_guard`, а если нет, как бы он выглядел?

Я использовал std::lock_guard на std::mutex, но, похоже, не существует shared_lock_guard, что было бы предпочтительнее для обеспечения поведения, связанного с блокировкой записи. Это надзор или тривиальное воплощение?

источник

2016-08-27 rubenvb

Возможно, вам это нужно: [std :: shared_lock] (http://en.cppreference.com/w/cpp/thread/shared_lock) – Galik

Это звучит как серьезный недостаток XY-проблемы/дизайна. У меня есть мьютекс на уровне класса, просто оставьте это от копирования. –

«* Я нахожусь на нижнем уровне моей библиотеки здесь, поэтому кажется, что это ужасная идея иметь такое поведение. *« Мьютексы вообще не должны жить «на нижнем уровне» библиотеки. По крайней мере, не так, как вы предлагаете. Это звучит так, будто вы пытаетесь заблокировать доступ через mutex к классу утилиты. Это вообще плохая идея. –

Вы можете использовать std::shared_lock и std::unique_lock для осуществления чтения блокировки/записи:

class lockable 
{ 
public: 
    using mutex_type = std::shared_timed_mutex; 
    using read_lock = std::shared_lock<mutex_type>; 
    using write_lock = std::unique_lock<mutex_type>; 

private: 
    mutable mutex_type mtx; 

    int data = 0; 

public: 

    // returns a scoped lock that allows multiple 
    // readers but excludes writers 
    read_lock lock_for_reading() { return read_lock(mtx); } 

    // returns a scoped lock that allows only 
    // one writer and no one else 
    write_lock lock_for_writing() { return write_lock(mtx); } 

    int read_data() const { return data; } 
    void write_data(int data) { this->data = data; } 
}; 

int main() 
{ 
    lockable obj; 

    { 
     // reading here 
     auto lock = obj.lock_for_reading(); // scoped lock 
     std::cout << obj.read_data() << '\n'; 
    } 

    { 
     // writing here 
     auto lock = obj.lock_for_writing(); // scoped lock 
     obj.write_data(7); 
    } 
}

источник

2016-08-27 20:33:30 Galik

Я не уверен, действительно ли ОП запрашивал блокировку RW. –

@ πάνταῥεῖ Возможно. Но я не могу думать, что еще он подразумевает tbh. – Galik

Похож на твою кишку, где прямо с этим. –

Это не является частью стандарта C++, но вы можете найти пример реализации в импульс.

template<typename SharedMutex> 
class shared_lock_guard 
{ 
private: 
    SharedMutex& m; 

public: 
    typedef SharedMutex mutex_type; 
    explicit shared_lock_guard(SharedMutex& m_): 
     m(m_) 
    { 
     m.lock_shared(); 
    } 
    shared_lock_guard(SharedMutex& m_,adopt_lock_t): 
     m(m_) 
    {} 
    ~shared_lock_guard() 
    { 
     m.unlock_shared(); 
    } 
};

Для этого требуется класс мьютекса, соответствующий концепции SharedMutex; std::shared_mutex является частью предлагаемого стандарта C++ 17 и boost, если бы он был уже в течение некоторого времени: boost::shared_mutex.

источник

2016-08-27 22:21:36 Palec

Есть ли `shared_lock_guard`, а если нет, как бы он выглядел?

ответ

Смежные вопросы