std::notify_all_at_thread_exit

Questa pagina è stata tradotta in modo automatico dalla versione in ineglese della wiki usando Google Translate. La traduzione potrebbe contenere errori e termini strani. Muovi il puntatore sopra al testo per vedere la versione originale. Puoi aiutarci a correggere gli gli errori. Per ulteriori istruzioni clicca qui. Click here for the English version of this page

• La proprietà del lk blocco precedentemente acquisito viene trasferito nella memoria interna.

  Original:

  Ownership of the previously acquired lock lk is transferred to internal storage.

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

• L'ambiente di esecuzione viene modificato in modo tale che quando il thread corrente, dopo i distruttori per tutti gli oggetti con filo durata di archiviazione locale sono chiamati, il cond variabile condizione è notificata come se da:

  Original:

  The execution environment is modified such that when the current thread exits, after the destructors for all objects with filo durata di archiviazione locale are called, the condition variable cond is notified as if by:

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

lk.unlock();
cond.notify_all();

[modifica] Note

[modifica] Parametri

[modifica] Valore di ritorno

[modifica] Esempio

#include <mutex>
#include <thread>
 
std::mutex m;
std::condition_variable cv;
 
bool ready = false;
ComplexType result;  // some arbitrary type
 
void thread_func()
{
    std::unique_lock<std::mutex> lk(m);
    // assign a value to result using thread_local data
    result = function_that_uses_thread_locals();
    ready = true;
    std::notify_all_at_thread_exit(cv, std::move(lk));
} // 1. destroy thread_locals, 2. unlock mutex, 3. notify cv
 
int main()
{
    std::thread t(thread_func);
    t.detach();
 
    // do other work
    // ...
 
    // wait for the detached thread
    std::unique_lock<std::mutex> lk(m);
    while(!ready) {
        cv.wait(lk);
    }
    process(result); // result is ready and thread_local destructors have finished
}

[modifica] Vedi anche