Блокировки чтения / записи в C++

Более новые версии boost::thread имеют блокировки чтения 9X_multi-threaded / записи (1.35.0 и более поздние версии, очевидно, предыдущие 9X_thread версии работали некорректно).

У них есть 9X_multi-threaded имена shared_lock, unique_lock и upgrade_lock, и они работают с shared_mutex.

Использование стандартных предварительно 9X_cross-threading протестированных, предварительно созданных 9X_lock вещей всегда хорошо (например, Boost в качестве 9X_lock другого варианта ответа), но это не так 9X_locking уж сложно создать самостоятельно. Вот небольшая 9X_cross-threading глупая реализация, извлеченная из моего 9X_thread проекта:

#include 

struct rwlock {
    pthread_mutex_t lock;
    pthread_cond_t read, write;
    unsigned readers, writers, read_waiters, write_waiters;
};

void reader_lock(struct rwlock *self) {
    pthread_mutex_lock(&self->lock);
    if (self->writers || self->write_waiters) {
        self->read_waiters++;
        do pthread_cond_wait(&self->read, &self->lock);
        while (self->writers || self->write_waiters);
        self->read_waiters--;
    }
    self->readers++;
    pthread_mutex_unlock(&self->lock);
}

void reader_unlock(struct rwlock *self) {
    pthread_mutex_lock(&self->lock);
    self->readers--;
    if (self->write_waiters)
        pthread_cond_signal(&self->write);
    pthread_mutex_unlock(&self->lock);
}

void writer_lock(struct rwlock *self) {
    pthread_mutex_lock(&self->lock);
    if (self->readers || self->writers) {
        self->write_waiters++;
        do pthread_cond_wait(&self->write, &self->lock);
        while (self->readers || self->writers);
        self->write_waiters--;
    }
    self->writers = 1;
    pthread_mutex_unlock(&self->lock);
}

void writer_unlock(struct rwlock *self) {
    pthread_mutex_lock(&self->lock);
    self->writers = 0;
    if (self->write_waiters)
        pthread_cond_signal(&self->write);
    else if (self->read_waiters)
        pthread_cond_broadcast(&self->read);
    pthread_mutex_unlock(&self->lock);
}

void rwlock_init(struct rwlock *self) {
    self->readers = self->writers = self->read_waiters = self->write_waiters = 0;
    pthread_mutex_init(&self->lock, NULL);
    pthread_cond_init(&self->read, NULL);
    pthread_cond_init(&self->write, NULL);
}

pthreads на самом деле не является Windows-родным, но 9X_lock общая идея здесь. Эта реализация немного 9X_threads смещена в сторону писателей (толпа писателей 9X_thread может бесконечно морить читателей голодом); просто 9X_cross-threading измените writer_unlock, если хотите, чтобы баланс был 9X_cross-threading наоборот.

Да, это C, а не C++. Перевод - это 9X_threads упражнение, оставленное читателю.

Изменить

Грег Роджерс 9X_multithread указал, что стандарт POSIX действительно 9X_threads определяет pthread_rwlock_*. Это не поможет, если у вас 9X_threading нет pthreads, но заставило меня вспомнить: Pthreads-w32 должен 9X_cxx работать! Вместо того, чтобы переносить 9X_thread этот код на не pthreads для собственного использования, просто 9X_cxx используйте Pthreads-w32 в Windows и нативный 9X_c++ pthreads везде.

Что бы вы ни решили использовать, сравните 9X_cxx свою рабочую нагрузку с простыми блокировками, поскольку 9X_threading блокировки чтения / записи обычно в 3-40 9X_multi-threaded раз медленнее, чем простой мьютекс, когда 9X_c++ нет конфликта.

Вот some reference

Изменить: ссылка на журнал MSDN больше не 9X_cross-threading доступна. Статья CodeProject теперь доступна 9X_threading на https://www.codeproject.com/Articles/32685/Testing-reader-writer-locks и довольно хорошо подводит итог. Также 9X_c++ я нашел новую ссылку MSDN о Compound Synchronisation Objects.

В MSDN есть 9X_multithreading article о блокировках чтения и записи, в котором 9X_thread представлены некоторые их реализации. Он 9X_cpp также вводит Slim reader / writer lock, примитив 9X_multithread синхронизации ядра, представленный в Vista. Также 9X_threading есть CodeProject article о сравнении различных реализаций (включая 9X_thread те, которые описаны в статье MSDN).

C++ 17 поддерживает std::shared_mutex. Он поддерживается 9X_threading в MSVC++ 2015 и 2017.

Строительные блоки Intel Thread также предоставляют 9X_thread несколько вариантов rw_lock:

http://www.threadingbuildingblocks.org/

У них есть spin_rw_mutex 9X_lock для очень коротких периодов конкуренции 9X_multithreading и queueing_rw_mutex для более длительных 9X_thread периодов конкуренции. Первый может использоваться 9X_locking в коде, особенно чувствительном к производительности. Последний 9X_threads более сопоставим по производительности с 9X_cpp Boost.Thread или прямым использованием pthreads. Но 9X_cpp профилируйте, чтобы убедиться, какой из 9X_multithread них лучше всего подходит для ваших шаблонов 9X_locking доступа.

Я могу порекомендовать ACE library, который предоставляет 9X_lock множество механизмов блокировки и портирован 9X_threads на различные платформы.

В зависимости от 9X_cxx граничных условий вашей проблемы вам могут 9X_multi-threaded быть полезны следующие классы:

• ACE_RW_Process_Mutex
• ACE_Write_Guard и ACE_Read_Guard
• ACE_Condition

Boost.Thread начиная с версии 1.35.0 уже поддерживает 9X_c++ блокировки чтения и записи. Хорошая вещь 9X_lock в этом заключается в том, что реализация 9X_c++ является кроссплатформенной, проходит экспертную 9X_multi-threaded оценку и на самом деле является a reference implementation for the upcoming C++0x standard.

http://www.codeproject.com/KB/threads/ReaderWriterLock.aspx

Вот хорошая и легкая реализация, подходящая 9X_lock для большинства задач.

Класс блокировки синхронизации с несколькими 9X_threads устройствами чтения и одной записью для 9X_cross-threading Win32, автор - Гленн Слейд

http://www.glennslayden.com/code/win32/reader-writer-lock