C ++ memory_order_acquire / вопросы выпуска

Последовательная согласованность обеспечивает единый общий порядок всех последовательно согласованных операций. Итак, если у вас есть последовательно согласованное хранилище в потоке A и последовательно согласованная загрузка в потоке B, а хранилище упорядочено до загрузки (в указанном едином общем порядке), тогда B наблюдает значение, сохраненное в A. Таким образом, в основном последовательная согласованность гарантирует, что хранилище будет немедленно видно другим потокам. Магазин релизов не предоставляет эту гарантию.

Как правильно указал Питер Кордес, термин «сразу видимый» довольно неточен. Видимость проистекает из того факта, что все операции seq-cst полностью упорядочены, и все потоки соблюдают этот порядок. Поскольку магазин и загрузка полностью упорядочены, значение магазина становится видимым до того, как будет выполнена последующая загрузка (в едином общем порядке).

Не существует такого полного порядка между операциями получения / выпуска в разных потоках, поэтому нет гарантии видимости. Операции упорядочиваются только тогда, когда операция получения наблюдает значение из операции получения, но нет никакой гарантии, когда значение операции выпуска становится видимым для потока, выполняющего операцию получения.

Давайте посмотрим, что произошло бы, если бы мы использовали в этом примере получение / выпуск:

void write_x() { x.store(true, std::memory_order_release); }
void write_y() { y.store(true, std::memory_order_release); }
 
void read_x_then_y() {
     while (!x.load(std::memory_order_acquire));

     if (y.load(std::memory_order_acquire)) 
         ++z;
}
 
void read_y_then_x() {
     while (!y.load(std::memory_order_acquire));

     if (x.load(std::memory_order_acquire))
        ++z;
}
 
int main() {
    std::thread a(write_x);
    std::thread b(write_y);
    std::thread c(read_x_then_y);
    std::thread d(read_y_then_x);

    a.join(); b.join(); c.join(); d.join();

    assert(z.load() != 0);  // can actually happen!!
}

Поскольку у нас нет гарантии видимости, может случиться так, что поток c наблюдает x == true и y == false, в то время как поток d может наблюдать y == true и x == false. Таким образом, ни один поток не будет увеличивать z, и утверждение сработает.

Для получения дополнительных сведений о модели памяти C ++ я могу порекомендовать эту статью, в которой я являюсь соавтором: Модели памяти для C / C ++ Программисты

Вы можете использовать aquire / release при передаче информации из одного потока в другой - это наиболее распространенная ситуация. Нет необходимости в последовательных требованиях к этому.

В этом примере есть несколько потоков. Два потока выполняют операцию записи, а третий грубо проверяет, был ли x готов до y, а четвертый проверяет, был ли y готов до x. Теоретически один поток может наблюдать, что x был изменен до y, а другой видит, что y был изменен до x. Не совсем уверен, насколько это вероятно. Это необычный вариант использования.

Изменить: вы можете визуализировать пример: предположим, что каждый поток выполняется на другом ПК, и они обмениваются данными через сеть. У каждой пары компьютеров разный пинг. Здесь легко привести пример, в котором неясно, какое событие произошло первым x или y, поскольку каждый компьютер будет видеть события, происходящие в разном порядке.

Я не уверен, на каких архитектурах может возникать этот эффект, но есть сложные, где соединены два разных процессора. Конечно, связь между процессорами медленнее, чем между ядрами каждого процессора.