std::mutex

 

C++

Linguaggio

Concetti

Libreria di Utilità

Stringhe

Contenitori

Algoritmi

Iteratori

Libreria matematca

Input/output

Localizzazione

Espressioni regolari (C++11)

Operazioni atomicche (C++11)

Multithreading (C++11)

 

Discussione libreria di supporto

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.
thread (C++11)
this_thread spazio dei nomi 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.
get_id (C++11) yield (C++11)	sleep_for (C++11) sleep_until (C++11)
Mutua esclusione 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.
mutex (C++11) timed_mutex (C++11)	recursive_mutex (C++11) recursive_timed_mutex (C++11)
Blocco di gestione generico 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.
lock_guard (C++11) unique_lock (C++11) defer_lock_t try_to_lock_t adopt_lock_t (C++11) (C++11) (C++11)	lock (C++11) try_lock (C++11) defer_lock try_to_lock adopt_lock (C++11) (C++11) (C++11)
Condizioni variabili 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.
condition_variable (C++11)
condition_variable_any (C++11)
notify_all_at_thread_exit (C++11)
cv_status (C++11)
Futures Original: Futures The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
promise (C++11) future (C++11) shared_future (C++11) packaged_task (C++11) async (C++11)	launch (C++11) future_status (C++11) future_error (C++11) future_category (C++11) future_errc (C++11)

 

std::mutex

Membri funzioni Original: Member functions The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

mutex::mutex

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

mutex::lock

mutex::try_lock

mutex::unlock

Maniglia nativo Original: Native handle The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

mutex::native_handle

 

Defined in header <mutex>
class mutex;		(dal C++11)

La classe mutex è una primitiva di sincronizzazione che può essere utilizzato per proteggere i dati condivisi vengano accedere contemporaneamente più thread.

Original:

The mutex class is a synchronization primitive that can be used to protect shared data from being simultaneously accessed by multiple threads.

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

mutex offre esclusivi, non ricorsivi semantica di proprietà:

Original:

mutex offers exclusive, non-recursive ownership semantics:

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

• Un thread chiamante' possiede un mutex dal momento in cui lo chiama con successo sia lock o try_lock fino a quando non chiama unlock.

  Original:

  A calling thread owns a mutex from the time that it successfully calls either lock or try_lock until it calls unlock.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.
• Quando un thread possiede un mutex, tutti gli altri thread si blocca (per le chiamate verso lock) o ricevere un valore restituito false (per try_lock) se tentano di rivendicare la proprietà del mutex.

  Original:

  When a thread owns a mutex, all other threads will block (for calls to lock) or receive a false return value (for try_lock) if they attempt to claim 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.
• Un thread chiamante non deve possedere un mutex prima di chiamare lock o try_lock.

  Original:

  A calling thread must not own a mutex prior to calling lock or try_lock.

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

Il comportamento di un programma non è definito se un mutex viene distrutto mentre ancora di proprietà di un po 'di filo. La classe mutex non è copiabile.

Original:

The behavior of a program is undefined if a mutex is destroyed while still owned by some thread. The mutex class is non-copyable.

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

Membri tipi

Membro tipo Original: Member type The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.	Definition
native_handle_type	Implementazione definita Original: implementation-defined The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

Membri funzioni

(constructor)	costruisce il mutex Original: constructs the mutex The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (metodo pubblico)
Bloccaggio Original: Locking The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
lock	blocca i blocchi mutex, se il mutex non è disponibile Original: locks the mutex, blocks if the mutex is not available The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (metodo pubblico)
try_lock	prova a bloccare il mutex, restituisce se il mutex non è disponibile Original: tries to lock the mutex, returns if the mutex is not available The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (metodo pubblico)
unlock	sblocca il mutex Original: unlocks the mutex The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (metodo pubblico)
Maniglia nativo Original: Native handle The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
native_handle	restituisce l'implementazione sottostante definito handle di thread Original: returns the underlying implementation-defined thread handle The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (metodo pubblico)

Esempio

Questo esempio mostra come un mutex può essere utilizzata per proteggere un std::map condiviso tra due thread .

Original:

This example shows how a mutex can be used to protect a std::map shared between two threads.

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

#include <iostream>
#include <chrono>
#include <thread>
#include <mutex>
#include <map>
#include <string>
 
std::map<std::string, std::string> g_pages;
std::mutex g_pages_mutex;
 
void save_page(const std::string &url)
{
    // simulate a long page fetch
    std::this_thread::sleep_for(std::chrono::seconds(2));
    std::string result = "fake content";
 
    g_pages_mutex.lock();
    g_pages[url] = result;
    g_pages_mutex.unlock();
}
 
int main() 
{
    std::thread t1(save_page, "http://foo");
    std::thread t2(save_page, "http://bar");
    t1.join();
    t2.join();
 
    g_pages_mutex.lock();
    for (const auto &pair : g_pages) {
        std::cout << pair.first << " => " << pair.second << '\n';
    }
    g_pages_mutex.unlock();
}

Output:

http://bar => fake content
http://foo => fake content