Ver el código de «cpp/thread/mutex»

No tienes permiso para modificar esta página, por el siguiente motivo:

La acción que has solicitado está restringida a los usuarios de uno de estos 2 grupos: Usuarios, Administradores.

Puedes ver y copiar el código fuente de esta página.

{{cpp/title|mutex}}
{{cpp/thread/mutex/navbar}}
{{ddcl | header=mutex | since=c++11 | 1=
class mutex;
}}

La clase {{tt|mutex}} es una primitiva de sincronización que puede usarse para proteger datos compartidos de un acceso simultáneo por varios hilos.

{{tt|mutex}} ofrece una semántica de propiedad exclusiva, no recursiva:

* Un hilo llamante ''posee'' un {{tt|mutex}} a partir del momento en el que llama con éxito a [[cpp/thread/mutex/lock|{{tt|lock}}]] o [[cpp/thread/mutex/try_lock|{{tt|try_lock}}]] hasta que llama a [[cpp/thread/mutex/unlock|{{tt|unlock}}]].
* Cuando un hilo posee un {{tt|mutex}}, los demás hilos se bloquearán (para las llamadas a [[cpp/thread/mutex/lock|{{tt|lock}}]]) o recibirán un valor de retorno {{c|false}} (para [[cpp/thread/mutex/try_lock|{{tt|try_lock}}]]) si intentan reclamar la posesión del {{tt|mutex}}.
* Un hilo llamante no debe poseer el {{tt|mutex}} antes de llamar a [[cpp/thread/mutex/lock|{{tt|lock}}]] o [[cpp/thread/mutex/try_lock|{{tt|try_lock}}]].

El comportamiento de un programa no está definido si un {{tt|mutex}} se destruye si todavía se posee por algún hilo, o un hilo termina mientras posee un {{tt|mutex}}.  La clase {{tt|mutex}} satisface todos los requerimientos de {{named req|Mutex}} y {{named req|StandardLayoutType}}.

{{tt|std::mutex}} no es ni copiable ni movible.

===Tipos miembro===
{{dsc begin}}
{{dsc hitem | Tipo Miembro | Definición}}
{{dsc inc | cpp/thread/dsc native_handle_type | mutex}}
{{dsc end}}

===Funciones miembro===
{{dsc begin}}
{{dsc inc | cpp/thread/mutex/dsc constructor | mutex}}
{{dsc inc | cpp/thread/mutex/dsc destructor | mutex}}
{{dsc inc | cpp/thread/mutex/dsc operator{{=}}}}

{{dsc h2 | Bloqueo}}
{{dsc inc | cpp/thread/mutex/dsc lock | mutex}}
{{dsc inc | cpp/thread/mutex/dsc try_lock | mutex}}
{{dsc inc | cpp/thread/mutex/dsc unlock | mutex}}

{{dsc h2 | Identificador nativo}}
{{dsc inc | cpp/thread/mutex/dsc native_handle | mutex}}
{{dsc end}}

===Notas===
Generalmente no se accede a un {{tt|std::mutex}} directamente: {{lc|std::unique_lock}}, {{lc|std::lock_guard}}, {{rev inl|since=c++17| o [[cpp/thread/scoped_lock|{{lc|std::scoped_lock}}]] }} gestionan el bloqueo de una manera más segura contra excepciones.

===Ejemplo===
{{example
 | Este ejemplo muestra cómo un {{tt|mutex}} puede usarse para proteger un {{lc|std::map}} compartido entre dos hilos.
 | code=
#include <iostream>
#include <map>
#include <string>
#include <chrono>
#include <thread>
#include <mutex>

std::map<std::string, std::string> g_pages;
std::mutex g_pages_mutex;

void save_page(const std::string &url)
{
    // simular la recuperación de una página extensa
    std::this_thread::sleep_for(std::chrono::seconds(2));
    std::string result = "contenido falso";

    std::lock_guard<std::mutex> guard(g_pages_mutex);
    g_pages[url] = result;
}

int main() 
{
    std::thread t1(save_page, "http://foo");
    std::thread t2(save_page, "http://bar");
    t1.join();
    t2.join();

    // ahora es seguro acceder a g_pages sin bloqueo, ya que los hilos están unidos
    for (const auto &pair : g_pages) {
        std::cout << pair.first << " => " << pair.second << '\n';
    }
}
 | output=
http://bar => contenido falso
http://foo => contenido falso
}}

{{langlinks|ar|de|en|fr|it|ja|ko|pt|ru|zh}}

Plantillas usadas en esta página:

Volver a cpp/thread/mutex.

cppreference.com

Buscar

Espacios de nombres

Variantes

Vistas

Acciones

Ver el código de «cpp/thread/mutex»

Navegación

Herramientas