std::shared_mutex:: lock_shared

Acquiert la propriété partagée du mutex. Si un autre thread détient le mutex en propriété exclusive, un appel à lock_shared bloquera l'exécution jusqu'à ce que la propriété partagée puisse être acquise.

Si lock_shared est appelé par un thread qui possède déjà le mutex dans n'importe quel mode (exclusif ou partagé), le comportement est indéfini.

Si plus que le nombre maximum défini par l'implémentation de propriétaires partagés ont déjà verrouillé le mutex en mode partagé, lock_shared bloque l'exécution jusqu'à ce que le nombre de propriétaires partagés soit réduit. Le nombre maximum de propriétaires est garanti d'être au moins 10000.

Une opération antérieure de unlock() sur le même mutex synchronise-avec (tel que défini dans std::memory_order ) cette opération.

Paramètres

(aucun)

Valeur de retour

(aucun)

Exceptions

Lance std::system_error en cas d'erreurs, y compris les erreurs du système d'exploitation sous-jacent qui empêcheraient lock de respecter ses spécifications. Le mutex n'est pas verrouillé en cas de levée d'une exception.

Notes

lock_shared() n'est généralement pas appelé directement : std::shared_lock est utilisé pour gérer le verrouillage partagé.

Exemple

#include <chrono>
#include <iostream>
#include <mutex>
#include <shared_mutex>
#include <syncstream>
#include <thread>
#include <vector>
std::mutex stream_mutx;
void print(auto v)
{
    std::unique_lock<std::mutex> lock(stream_mutx);
    std::cout << std::this_thread::get_id() << " a vu : ";
    for (auto e : v)
        std::cout << e << ' ';
    std::cout << '\n';
}
int main()
{
    using namespace std::chrono_literals;
    constexpr int N_READERS = 5;
    constexpr int LAST = -999;
    std::shared_mutex smtx;
    int product = 0;
    auto writer = [&smtx, &product](int start, int end)
    {
        for (int i = start; i < end; ++i)
        {
            auto data = i;            
            {
                std::unique_lock<std::shared_mutex> lock(smtx);
                product = data;
            } 
            std::this_thread::sleep_for(3ms);
        }
        smtx.lock(); // verrouillage manuel
        product = LAST;
        smtx.unlock();
    };
    auto reader = [&smtx, &product]()
    {
        int data = 0;
        std::vector<int> seen;
        do
        {
            {
                smtx.lock_shared(); // mieux d'utiliser : std::shared_lock lock(smtx);
                data = product;
                smtx.unlock_shared();
            }                                   
            seen.push_back(data);
            std::this_thread::sleep_for(2ms);
        }
        while (data != LAST);
        print(seen);
    };
    std::vector<std::thread> threads;
    threads.emplace_back(writer, 1, 13);
    threads.emplace_back(writer, 42, 52);
    for (int i = 0; i < N_READERS; ++i)
        threads.emplace_back(reader);
    for (auto&& t : threads)
        t.join();
}

127755840 saw: 43 3 3 4 46 5 6 7 7 8 9 51 10 11 11 12 -999
144541248 saw: 2 44 3 4 46 5 6 7 7 8 9 51 10 11 11 12 -999
110970432 saw: 42 2 3 45 4 5 47 6 7 8 8 9 10 11 11 12 -999
119363136 saw: 42 2 3 4 46 5 6 7 7 8 9 9 10 11 11 12 12 -999
136148544 saw: 2 44 3 4 46 5 6 48 7 8 9 51 10 11 11 12 12 -999

Voir aussi