Pourquoi std:: shared ptr:: unique () est-il obsolète?

Quel est le problème technique avec std::shared_ptr::unique() qui est la raison de sa dépréciation en C++17?

Selon cppreference.com, std::shared_ptr::unique() est déprécié en C++17

Cette fonction est obsolète à partir de C++17 Car use_count n'est qu'une approximation dans un environnement multi-thread.

je comprends que cela soit vrai pour use_count() > 1: pendant que je tiens une référence, quelqu'un d'autre pourrait simultanément lâcher la sienne ou créer une nouvelle copie.

Mais si use_count() renvoie 1 (ce qui m'intéresse lors de l'appel de unique()), Il n'y a pas d'autre thread qui pourrait changer cette valeur de manière racée, donc je m'attendrais à ce que cela soit sûr:

if (myPtr && myPtr.unique()) {
    //Modify *myPtr
}

Résultats de ma propre recherche:

J'ai trouvé ce document: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0521r0.html qui propose la dépréciation en réponse à C++17 CD comment CA 14 , mais je n'ai pas pu trouver dit le commentaire lui-même.

Comme alternative, ce document a proposé d'ajouter quelques notes, y compris les suivantes:

Remarque: Lorsque plusieurs threads peuvent affecter la valeur de retour de use_count(), le résultat doit être traité comme approximatif. en particulier, use_count() == 1 n'implique pas que les accès par un shared_ptr précédemment détruits ont en aucun cas terminé. - note de fin

Je comprends que cela pourrait être le cas pour la façon dont use_count() est actuellement spécifié (due à l'absence de synchronisation garantie), mais pourquoi la résolution n'a-t-elle pas seulement pour spécifier une telle synchronisation et donc rendre le modèle ci-dessus sûr? S'il y avait une limitation fondamentale qui ne permettrait pas une telle synchronisation (ou la rendrait prohibitivement coûteuse), alors comment est-il possible d'implémenter correctement le destructeur?

Mise à jour:

J'ai négligé le cas évident présenté par @ alexeykuzmin0 et @rubenvb, car jusqu'à présent je n'ai utilisé que unique() sur les instances de {[10] } qui étaient non accessible aux autres threads eux-mêmes. Il n'y avait donc aucun danger que cette instance particulière soit copiée de manière racée.

Je serais toujours intéressé d'entendre ce qu'était exactement CA 14, car je crois que tous mes cas d'utilisation pour unique() fonctionneraient tant qu'il est garanti de se synchroniser avec tout ce qui arrive à différentes instances shared_ptr sur d'autres threads. Donc, cela me semble toujours être un outil utile, mais je pourrais négliger quelque chose de fondamental ici.

À illustrer ce que j'ai à l'esprit, considérez ce qui suit:

class MemoryCache {
public:
    MemoryCache(size_t size)
        : _cache(size)
    {
        for (auto& ptr : _cache) {
            ptr = std::make_shared<std::array<uint8_t, 256>>();
        }
    }

    // the returned chunk of memory might be passed to a different thread(s),
    // but the function is never accessed from two threads at the same time
    std::shared_ptr<std::array<uint8_t,256>> getChunk()
    {
        auto it = std::find_if(_cache.begin(), _cache.end(), [](auto& ptr) { return ptr.unique(); });
        if (it != _cache.end()) {
            //memory is no longer used by previous user, so it can be given to someone else
            return *it;
        } else {
            return{};
        }
    }
private:
    std::vector<std::shared_ptr<std::array<uint8_t, 256>>> _cache;
};

Y a - t-il quelque chose de mal (Si unique() se synchronisait réellement avec les destructeurs d'autres copies)?