Существует ли эквивалент С++ 11 для boost::shared_mutex. Или другое решение для обработки ситуации с несколькими читателями/одиночными писателями в С++ 11?
С++ 11 эквивалентно увеличению shared_mutex
Ответ 1
Я попытался, но не смог получить shared_mutex в С++ 11. Он был предложен для будущего стандарта. Предложение здесь.
Изменить: для С++ 14 была принята пересмотренная версия (N3659) .
Вот реализация:
Ответ 2
Простой... Нет никого. Стандартной реализации С++ чтения-записи не существует.
Но у вас есть несколько вариантов.
- Вы оставлены на своих собственных устройствах, чтобы создать свой собственный механизм чтения-записи.
- Используйте платформенную реализацию, такую как Win32, POSIX или Boost, как вы упоминаете.
- Не используйте его вообще - используйте mutex, который уже существует в С++ 11.
Переход С# 1 и реализация вашего собственного - это страшное начинание, и вы можете заколлировать свой код с условиями гонки, если вы не понимаете это правильно. Существует эталонная реализация, которая может облегчить задачу.
Если вам нужен независимый от платформы код или вы не хотите включать какие-либо дополнительные библиотеки в свой код для чего-то такого же простого, как блокиратор для чтения-записи, вы можете выбросить # 2 из окна.
И в # 3 есть пара предостережений, которые большинство людей не понимает: использование блокировки чтения-записи часто менее результативно и имеет более сложный для понимания код, чем эквивалентная реализация с использованием простого мьютекса. Это связано с дополнительным ведением бухгалтерского учета, которое должно выполняться за кулисами реализации блокировки чтения-записи.
Я могу только представить вам ваши варианты, действительно, вам стоит взвесить затраты и преимущества каждого и выбрать, который лучше всего работает.
Edit:
С++ 17 теперь имеет тип shared_mutex для ситуаций, когда преимущества наличия нескольких параллельных считывателей перевешивают стоимость производительности shared_mutex сам по себе.
Ответ 3
Нет, для С++ 11 нет эквивалента для boost::shared_mutex.
Блокировки чтения/записи поддерживаются в С++ 14 или новее:
- С++ 14 добавлено
std::shared_timed_mutex - С++ 17 добавлено
std::shared_mutex
Разница в том, что std::shared_timed_mutex добавляет дополнительные операции синхронизации. Он реализует концепцию SharedTimedMutex, которая является расширением более простого TimedMutex концепция, реализованная std::shared_mutex.
Имейте в виду, что приобретение блокировки для мьютекса чтения/записи является более дорогостоящим, чем приобретение обычного std::mutex. Как следствие, мьютекс чтения/записи не улучшит производительность, если у вас есть частые, но короткие операции чтения. Он лучше подходит для сценариев, поскольку операции чтения являются частыми и дорогими. Чтобы процитировать сообщение сообщение Энтони Уильямса:
Стоимость блокировки shared_mutex выше, чем стоимость блокировки plain std:: mutex, даже для потоков читателей. Это необходимая часть функциональности --- есть более возможные состояния shared_mutex, чем мьютекс, и код должен обрабатывать их правильно. Эта стоимость входит как в размер объекта (который реализация и моя реализация POSIX включает как простой мьютекс и переменная условия), а также при выполнении блокировки и разблокировки операции.
Кроме того, shared_mutex является точкой раздора, и, следовательно, масштабируемый. Блокировка shared_mutex обязательно изменяет состояние мьютекс, даже для блокировки чтения. Следовательно, линия кэша, содержащая Состояние shared_mutex должно передаваться в зависимости от того, какой процессор выполнение операции блокировки или разблокировки.
Если у вас много потоков, выполняющих частые операции короткого чтения, то в многопроцессорной системе это может привести к большому количеству кеша пинг-понга, что значительно повлияет на производительность система. В этом случае вы можете также принять более простой дизайн просто используя простой мьютекс, так как читатели по существу сериализуются в любом случае.
Если чтение не является частым, тогда нет никаких утверждений, поэтому вы не нужно беспокоиться о совместимых читателях, и достаточно простого мьютекса для этого сценария в любом случае.
Если операции чтения занимают много времени, то следствие этого утверждение менее заметно, поскольку оно затмевается временем, проведенным в то время как удерживая блокировку чтения. Однако выполнение трудоемких операций в то время как фиксация представляет собой запах дизайна.
В подавляющем большинстве случаев я думаю, что есть лучшие альтернативы shared_mutex. Это может быть простой мьютекс, атомный поддержка shared_ptr, использование тщательно сконструированного параллельного контейнер или что-то еще, в зависимости от контекста.