std::lock - cppreference.com
Espaços nominais
Variantes
    Ações

      std::lock

      De cppreference.com

      <metanoindex/>

       
      C++
       
      Biblioteca de suporte a discussão
      Threads
      Original:
      Threads
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      (C++11)
      this_thread namespace
      Original:
      this_thread namespace
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      (C++11)
      (C++11)
      (C++11)
      (C++11)
      Exclusão mútua
      Original:
      Mutual exclusion
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      (C++11)
      (C++11)
      Gestão de bloqueio genérico
      Original:
      Generic lock management
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      (C++11)
      (C++11)
      (C++11)(C++11)(C++11)
      (C++11)
      (C++11)
      (C++11)(C++11)(C++11)
      Variáveis ​​de condição
      Original:
      Condition variables
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      (C++11)
      (C++11)
      (C++11)
      (C++11)
      Futuros
      Original:
      Futures
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      (C++11)
      (C++11)
      (C++11)
      (C++11)
      (C++11)
      (C++11)
      (C++11)
      (C++11)
      (C++11)
      (C++11)
       
      <tbody> </tbody>
      Definido no cabeçalho <mutex>
      template< class Lockable1, class Lockable2, class LockableN... > void lock( Lockable1& lock1, Lockable2& lock2, LockableN& lockn... );
      		 (desde C++11)
      Bloqueia o dado Lockable objetos lock1, lock2, ..., lockn usando um algoritmo de evitar impasse para evitar bloqueio.
      Original:
      Locks the given Lockable objects lock1, lock2, ..., lockn using a deadlock avoidance algorithm to avoid deadlock.
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      Os objetos estão bloqueadas por uma série não especificada de chamadas para lock, try_lock, unlock. Se uma chamada para lock ou unlock resulta em uma exceção, unlock é chamado por quaisquer objetos bloqueados antes relançando.
      Original:
      The objects are locked by an unspecified series of calls to lock, try_lock, unlock. If a call to lock or unlock results in an exception, unlock is called for any locked objects before rethrowing.
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      Parâmetros

      lock1, lock2, ... , lockn -
      o Lockable objetos para bloquear
      Original:
      the Lockable objects to lock
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      Valor de retorno

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

      Exemplo

      O exemplo a seguir usa std::lock para bloquear pares de semáforos sem impasse .
      Original:
      The following example uses std::lock to lock pairs of mutexes without deadlock.
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      #include <mutex>
#include <thread>
#include <iostream>
#include <vector>
#include <functional>
#include <chrono>

struct Employee {
    Employee(int id) : id(id) {}
    int id;
    std::vector<int> lunch_partners;
    std::mutex m;
};

void send_mail(Employee &e1, Employee &e2)
{
    // simulate a time-consuming messaging operation
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

void assign_lunch_partner(Employee &e1, Employee &e2)
{
    // use std::lock to acquire two locks without worrying about 
    // other calls to assign_lunch_partner deadlocking us
    std::lock(e1.m, e2.m);

    e1.lunch_partners.push_back(e2.id);
    e2.lunch_partners.push_back(e1.id);

    e1.m.unlock();
    e2.m.unlock();

    send_mail(e1, e2);
    send_mail(e2, e1);
}

int main()
{
    Employee alice(0), bob(1), christina(2), dave(3);

    // assign in parallel threads because mailing users about lunch assignments
    // takes a long time
    std::vector<std::thread> threads;
    threads.emplace_back(assign_lunch_partner, std::ref(alice), std::ref(bob));
    threads.emplace_back(assign_lunch_partner, std::ref(christina), std::ref(bob));
    threads.emplace_back(assign_lunch_partner, std::ref(christina), std::ref(alice));
    threads.emplace_back(assign_lunch_partner, std::ref(dave), std::ref(bob));

    for (auto &thread : threads) thread.join();
}


      Veja também