std::mutex:: try_lock

Tente de verrouiller le mutex. Retourne immédiatement. En cas de réussite du verrouillage, retourne true , sinon retourne false .

Cette fonction peut échouer sporadiquement et renvoyer false même si le mutex n'est actuellement verrouillé par aucun autre thread.

Si try_lock est appelé par un thread qui possède déjà le mutex , le comportement est indéfini.

L'opération de unlock() antérieure sur le même mutex synchronise-avec (tel que défini dans std::memory_order ) cette opération si elle retourne true . Notez que l'opération de lock() antérieure ne se synchronise pas avec cette opération si elle retourne false .

Paramètres

(aucun)

Valeur de retour

true si le verrou a été acquis avec succès, sinon false .

Exceptions

Ne lance rien.

Exemple

#include <chrono>
#include <iostream> // std::cout
#include <mutex>
#include <thread>
std::chrono::milliseconds interval(100);
std::mutex mutex;
int job_shared = 0; // les deux threads peuvent modifier 'job_shared',
                    // le mutex protégera cette variable
int job_exclusive = 0; // un seul thread peut modifier 'job_exclusive'
                       // aucune protection nécessaire
// ce thread peut modifier 'job_shared' et 'job_exclusive'
void job_1() 
{
    std::this_thread::sleep_for(interval); // laisse 'job_2' prendre un verrou
    while (true)
    {
        // tente de verrouiller le mutex pour modifier 'job_shared'
        if (mutex.try_lock())
        {
            std::cout << "job shared (" << job_shared << ")\n";
            mutex.unlock();
            return;
        }
        else
        {
            // ne peut pas obtenir le verrou pour modifier 'job_shared'
            // mais il y a d'autres tâches à effectuer
            ++job_exclusive;
            std::cout << "job exclusive (" << job_exclusive << ")\n";
            std::this_thread::sleep_for(interval);
        }
    }
}
// ce thread peut modifier uniquement 'job_shared'
void job_2() 
{
    mutex.lock();
    std::this_thread::sleep_for(5 * interval);
    ++job_shared;
    mutex.unlock();
}
int main() 
{
    std::thread thread_1(job_1);
    std::thread thread_2(job_2);
    thread_1.join();
    thread_2.join();
}

job exclusive (1)
job exclusive (2)
job exclusive (3)
job exclusive (4)
job shared (1)

Voir aussi