Как доступы `weak_ptr` и `shared_ptr` атомарны

Этот вопрос состоит из двух частей:

Потокобезопасность

Код НЕ ориентирован на многопотоковое исполнение, но это не имеет ничего общего с lock():
существует гонка между int_ptr.reset(); и std::weak_ptr int_ptr_weak = int_ptr;. Потому что один поток модифицирует неатомарную переменную int_ptr, а другой читает ее, что по определению является гонкой данных.

Так что это было бы нормально:

int main() {
    auto int_ptr = std::make_shared<int>(1);
    std::weak_ptr<int> int_ptr_weak = int_ptr;  //create the weak pointer in the original thread
    std::thread th( [&]() {
        auto int_ptr_local = int_ptr_weak.lock();
        if (int_ptr_local) {
            std::cout << "Value in the shared_ptr is " << *int_ptr_local << std::endl;
        }
    });

    int_ptr.reset();
    th.join();
}

Атомная версия примера кода expired() ? shared_ptr<T>() : shared_ptr<T>(*this)

Конечно, весь процесс не может быть атомарным. На самом деле важная часть заключается в том, что счетчик сильных ссылок увеличивается только в том случае, если он уже больше нуля, и что проверка и приращение происходят атомарным образом. Я не знаю, есть ли для этого какие-либо специфичные для системы/архитектуры примитивы, но один из способов реализовать это в С++ 11:

std::shared_ptr<T> lock() {
    if (!isInitialized) {
        return std::shared_ptr<T>();
    }
    std::atomic<int>& strong_ref_cnt = get_strong_ref_cnt_var_from_control_block();
    int old_cnt = strong_ref_cnt.load();
    while (old_cnt && !strong_ref_cnt.compare_exchange_weak(old_cnt, old_cnt + 1)) {
        ;
    }
    if (old_cnt > 0) {
        // create shared_ptr without touching the control block any further
    } else {
        // create empty shared_ptr
    }
}

Является ли приведенный выше код потокобезопасным?

Я думаю, что нет, так как int_ptr.reset(nullptr); соревнуется с std::weak_ptr int_ptr_weak = int_ptr;.

Я не могу понять, как интерфейсы std::weak_ptr и std::shared_ptr делают следующую операцию атомарной expired() ? shared_ptr<T>() : shared_ptr<T>(*this)

Такая операция не является атомарной, поскольку expired() может возвращать значение false, но к тому времени, когда вы воздействуете на это значение, оно уже может быть неточным. С другой стороны, если он возвращает значение true, оно гарантированно останется точным, если с тех пор никто не модифицировал конкретный экземпляр shared_ptr. То есть операции с другими копиями данного shared_ptr не могут привести к истечению срока его действия.

Реализация weak_ptr::lock() не будет использовать expired(). Вероятно, он будет делать что-то вроде атомарного сравнения-обмена, когда дополнительная сильная ссылка добавляется только в том случае, если текущее количество сильных ссылок больше нуля.

Нет, ваш код не является потокобезопасным. Существует гонка данных между операцией int_ptr.reset() в основном потоке (которая является операцией записи) и инициализацией int_weak_ptr из int_ptr в th (которая является операцией чтения).

" как интерфейсы std::weak_ptr и std::shared_ptr делают следующую операцию атомарной expired() ? shared_ptr<T>() : shared_ptr<T>(*this)"

Интерфейсы - нет. Это внутреннее свойство реализации. Как именно это делается, зависит от реализации.