Энтони Уильямс - Параллельное программирование на С++ в действии. Практика разработки многопоточных программ

С другой стороны, compare_exchange_strong()гарантированно возвращает falseтолько в том случае, когда текущее значение не было равно ожидаемому ( expected). Это устраняет необходимость в показанном выше цикле, когда нужно только узнать, удалось ли нам изменить переменную или другой поток добрался до нее раньше.

Если мы хотим изменить переменную, каким бы ни было ее текущее значение (при этом новое значение может зависеть от текущего), то обновление expectedоказывается полезной штукой; на каждой итерации цикла expectedперезагружается, так что если другой поток не модифицирует значение в промежутке, то вызов compare_exchange_weak()или compare_exchange_strong()должен оказаться успешным на следующей итерации. Если новое сохраняемое значение вычисляется просто, то выгоднее использовать compare_exchange_weak(), чтобы избежать двойного цикла на платформах, где compare_exchange_weak() может давать ложный отказ (и, следовательно, compare_exchange_strong()содержит цикл). С другой стороны, если вычисление нового значения занимает длительное время, то имеет смысл использовать compare_exchange_strong(), чтобы не вычислять значение заново, когда expectedне изменилась. Для типа std::atomicэто не столь существенно — в конце концов, есть всего два возможных значения — но для более широких атомарных типов различие может оказаться заметным.

Функции сравнения и обмена необычны еще и тем, что могут принимать два параметра упорядочения доступа к памяти. Это позволяет по-разному задавать семантику упорядочения в случае успеха и отказа; быть может, при успешном вызове требуется семантика memory_order_acq_rel, а при неудачном — memory_order_relaxed. В случае отказа функция сохранить-и-обменять не производит сохранение, поэтому семантика memory_order_releaseили memory_order_acq_relнеприменима. Поэтому задавать эти варианты упорядочения для отказа не разрешается. Кроме того, нельзя задавать для отказа более строгое упорядочение, чем для успеха; если вы требуете семантику memory_order_acquireили memory_order_seq_cstв случае отказа, то должны потребовать такую же и в случае успеха.

Если упорядочение для отказа не задано, то предполагается, что оно такое же, как для успеха, с тем отличием, что часть release заменяется: memory_order_releaseстановится memory_order_relaxed, a memory_order_acq_rel— memory_order_acquire. Если не задано ни одно упорядочение, то как обычно предполагается memory_order_seq_cst, то есть полное последовательное упорядочение доступа как в случае успеха, так и в случае отказа. Следующие два вызова compare_exchange_weak()эквивалентны:

std::atomic b;

bool expected;

b.compare_exchange_weak(expected, true,

memory_order_acq_rel, memory_order_acquire);

b.compare_exchange_weak(expected, true, memory_order_acq_rel);

К чему приводит задание того или иного упорядочения, я расскажу в разделе 5.3.

Еще одно отличие std::atomicот std::atomic_flagзаключается в том, что тип std::atomicне обязательно свободен от блокировок; для обеспечения атомарности реализация библиотеки может захватывать внутренний мьютекс. В тех редких случаях, когда это важно, можно с помощью функции-члена is_lock_free()узнать, являются ли операции над std::atomicсвободными от блокировок. Это еще одна особенность, присущая всем атомарным типам, кроме std::atomic_flag.

Следующими по простоте являются атомарные специализации указателей std::atomic.

Атомарная форма указателя на тип T— std::atomic— выглядит так же, как атомарная форма bool( std::atomic). Интерфейс по существу такой же, только операции применяются к указателям на значения соответствующего типа, а не к значениям типа bool. Как и в случае std::atomic, копирующие конструктор и оператор присваивания не определены, но разрешено конструирование и присваивание на основе подходящих указателей. Помимо обязательной функции is_lock_free(), тип std::atomicрасполагает также функциями load(), store(), exchange(), compare_exchange_weak()и compare_exchange_strong()с такой же семантикой, как std::atomic, но принимаются и возвращаются значения типа T*, а не bool.

Новыми в типе std::atomicявляются арифметические операции над указателями. Базовые операции предоставляются функциями-членами fetch_add()и fetch_sub(), которые прибавляют и вычитают целое число из сохраненного адреса, а также операторы +=, -=, ++и --(последние в обеих формах — пред и пост), представляющие собой удобные обертки вокруг этих функций. Операторы работают так же, как для встроенных типов: если x— указатель std::atomicна первый элемент массива объектов типа Foo, то после выполнения оператора x+=3 xбудет указывать на четвертый элемент и при этом возвращается простой указатель Foo*, который также указывает на четвертый элемент. Функции fetch_add()и fetch_sub()отличаются от операторов тем, что возвращают старое значение (то есть x.fetch_add(3)изменит x, так что оно будет указывать на четвертый элемент, но вернет указатель на первый элемент массива). Эту операцию еще называют обменять-и-прибавить , она относится к категории атомарных операций чтения-модификации-записи, наряду с exchange(), compare_exchange_weak()и compare_exchange_strong(). Как и другие операции такого рода, fetch_add()возвращает простой указатель T*, а не ссылку на объект std::atomic, поэтому вызывающая программа может выполнять действия над прежним значением: