Вот знакомый подкинул задачку. Интересную. Как подступиться - хз, может среди форумчан кто подскажет 

Есть класс, у него один член X (для определенности - типа int). Есть сеттер setX и геттер getX. Они вызываются из различных потоков, притом геттер вызывается намного чаще сеттера. Вопрос - как наиболее эффективно реализовать класс?

Первое, что приходит на ум - использовать мьютекс, но тогда при его блокировке одним потоком будут простаивать все остальные потоки (а их может быть МНОГО). Так что такой вариант не годится. Нужно то ли как-то закэшировать значение X для того, чтобы его могли использовать геттеры... то ли хз.

Что скажете?

использовать shared_mutex.

Целые числа читаются и пишутся атомарно и мьютекс не нужен. Может X  не int все-таки? Для сложного X  что-то лучше мьютекса придумать думаю будет сложно. Закэшированное значение тоже обновлять придется и не атомарно.

атомарные операции.

Добавлено через 25 секунд

с каких это пор?

в таком случае оно будет иметь ТОЛЬКО значение до того как произошел вызов setX.

или использовать атомарный тип. ибо расходы на много меньше расходов чем при блокировке мьютекса.

для записи/чтения обыкновенного целочисленного типа? а чем atomic_store и atomic_load не угодил?

  

Если int - то он и читаться, и писаться будет одной "атомарной" операцией (одной процессорной командой чтения или записи). Поэтому нах всякие синхронизации - геттер всегда прочитает адекватное значение, а если сеттер вызывается из разных потоков - то сама операционка и отсинхронизирует последовательность изменений значения разнопоточными сеттерами.

Вероятность, что при многоядерном процессоре два или более параллельных потоков будут абсолютно одновременно вызывать сеттеры - принимаем как нулевую. Тем более, что многоядерный проц должен как-то такие коллизии (по одновременной записи данных в кэш) разруливать на аппаратном уровне.

в задаче, целое - как пример. я же подумал несколько дальше.

учитывая, что 

для сложного X уже давно придумали compare-and-swap указателя, правда придется попотеть над очисткой памяти.

Это сообщение отредактировал(а) azesmcar - 6.6.2011, 20:40

ужос, сколько в тему народа повалило  

Добавлено через 52 секунды

траске!  
откуда такая информация?!

с чего это вдруг?  

Компилятор имеел полное право реализовать операцию чтения, как какой-нибудь push, _x_ / pop eax - вот и нет никакой атомарности. Я бы не советовал сильно на это рассчитывать. Но в C++0x есть шаблоны, _гарантирующие_ гатомарность операции. Только вы уверены, что это поможет на двухъядерном процессоре?


Кажется, я где-то видел что-то похожее. Называлось типа RWLock. Интересно, а как оно реализуется?

Потому что в шину помещается. Как я понял, int тут для примера. Так что можно забить на это

Где про это почитать?

Народ любит хитрые задачки