std::defer_lock, std::try_to_lock, std::adopt_lock – cppreference.com

Aus cppreference.com


`constexpr std::defer_lock_t defer_lock = std::defer_lock_t();`		(seit C++11)

`constexpr std::try_to_lock_t try_to_lock = std::try_to_lock_t();`		(seit C++11)

`constexpr std::adopt_lock_t adopt_lock = std::adopt_lock_t();`		(seit C++11)

std::defer_lock, std::try_to_lock and std::adopt_lock are instances of empty struct tag types std::defer_lock_t, std::try_to_lock_t and std::adopt_lock_t respectively.

They are used to specify locking strategies for std::lock_guard and std::unique_lock.


Type Original: Type The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.	Effect(s)

`defer_lock_t`	nicht erwerben Besitz des Mutex Original: do not acquire ownership of the mutex The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

`try_to_lock_t`	versuchen Besitz des Mutex ohne Blockierung zu erwerben Original: try to acquire ownership of the mutex without blocking The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

`adopt_lock_t`	nehmen den aufrufenden Thread hat bereits Besitz des Mutex Original: assume the calling thread already has ownership of the mutex The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

Beispiel

[edit]

#include <mutex>
#include <thread>

struct bank_account {
    explicit bank_account(int balance) : balance(balance) {}
    int balance;
    std::mutex m;
};

void transfer(bank_account &from, bank_account &to, int amount)
{
    // attempt to lock both mutexes without deadlock
    std::lock(from.m, to.m);

    // make sure both already-locked mutexes are unlocked when 
    // we're done; if we just used the lock_guard without std::lock
    // and std::adopt_lock, we might deadlock with other calls to transfer
    std::lock_guard lock1(from.m, std::adopt_lock);
    std::lock_guard lock2(to.m, std::adopt_lock);

    from.balance -= amount;
    to.balance += amount;
}

int main()
{
    bank_account my_account(100);
    bank_account your_account(50);

    std::thread t1(transfer, my_account, your_account, 10);
    std::thread t2(transfer, your_account, my_account, 5);

    t1.join();
    t2.join();
}

Siehe auch


defer_lock_t try_to_lock_t adopt_lock_t	Tag-Typ verwendet werden, um Sperrstrategie angeben Original: tag type used to specify locking strategy The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (Klasse) [edit]

(constructor)	konstruiert eine lock_guard, gegebenenfalls Verriegeln des gegebenen Mutex Original: constructs a lock_guard, optionally locking the given mutex The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (öffentliche Elementfunktion of `std::lock_guard`) [edit]

(constructor)	konstruiert eine `unique_lock`, wahlweise Verriegelung der mitgelieferten Mutex Original: constructs a `unique_lock`, optionally locking the supplied mutex The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (öffentliche Elementfunktion of `std::unique_lock`) [edit]