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

De cppreference.com

</tbody> <tbody class="t-dcl-rev "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev "> </tbody><tbody>

Definido en el archivo de encabezado `<mutex>`
`constexpr std::defer_lock_t defer_lock {};`		(desde C++11) (hasta C++17)
`inline constexpr std::defer_lock_t defer_lock {};`		(desde C++17)
`constexpr std::try_to_lock_t try_to_lock {};`		(desde C++11) (hasta C++17)
`inline constexpr std::try_to_lock_t try_to_lock {};`		(desde C++17)
`constexpr std::adopt_lock_t adopt_lock {};`		(desde C++11) (hasta C++17)
`inline constexpr std::adopt_lock_t adopt_lock {};`		(desde C++17)

std::defer_lock, std::try_to_lock y std::adopt_lock son instancias de tipos etiqueta struct vacíos std::defer_lock_t, std::try_to_lock_t y std::adopt_lock_t respectivamente.

Se usan para especificar las estrategias de bloqueo para std::lock_guard, std::unique_lock y std::shared_lock.

Tipo	Efecto(s)
`defer_lock_t`	No toman posesión del mutex
`try_to_lock_t`	Tratan de tomar posesión del mutex sin bloquear
`adopt_lock_t`	Supone que el hilo que llama ya tomó posesión del mutex

Ejemplo

#include <mutex>
#include <thread>

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

void transferir(cuenta_de_banco &de, cuenta_de_banco &a, int cantidad)
{
    // bloquear ambos mutexes sin bloqueo mutuo
    std::lock(from.m, to.m);

    // asegurarse que ambos mutexes ya bloqueados se desbloqueen al terminar el ámbito
    std::lock_guard lock1(de.m, std::adopt_lock);
    std::lock_guard lock2(a.m, std::adopt_lock);

// enfoque equivalente:
//    std::unique_lock<std::mutex> lock1(de.m, std::defer_lock);
//    std::unique_lock<std::mutex> lock2(a.m, std::defer_lock);
//    std::lock(lock1, lock2);

    de.balance -= cantidad;
    a.balance += cantidad;
}

int main()
{
    cuenta_de_banco mi_cuenta(100);
    cuenta_de_banco tu_cuenta(50);

    std::thread t1(transferir, mi_cuenta, tu_cuenta, 10);
    std::thread t2(transferir, tu_cuenta, mi_cuenta, 5);

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

Véase también

	Tipo de etiqueta utilizado para especificar la estrategia de bloqueo. (clase) [editar]
	Construye un objeto `lock_guard`, opcionalmente bloquea el mutex dado. (función miembro pública de `std::lock_guard`) [editar]
	Construye un objeto `unique_lock`, y opcionalmente bloquea el mutex suplementado (es decir, toma posesión). (función miembro pública de `std::unique_lock`) [editar]