Espaços nominais
Variantes
Acções

std::notify_all_at_thread_exit

Da cppreference.com
< cpp‎ | thread

 
 
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.
thread(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.
get_id(C++11)
yield(C++11)
sleep_for(C++11)
sleep_until(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.
mutex(C++11)
timed_mutex(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.
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)
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.
condition_variable(C++11)
condition_variable_any(C++11)
notify_all_at_thread_exit(C++11)
cv_status(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.
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)
 
Defined in header <condition_variable>
void notify_all_at_thread_exit( std::condition_variable& cond,
                                std::unique_lock<std::mutex> lk );
(a partir do C++ 11)
notify_all_at_thread_exit fornece um mecanismo para notificar outras threads que um determinado segmento completamente acabados, incluindo destruir todos os objetos thread_local. Opera-se como se segue:
Original:
notify_all_at_thread_exit provides a mechanism to notify other threads that a given thread has completely finished, including destroying all thread_local objects. It operates as follows:
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
  • A propriedade do lk bloqueio anteriormente adquirida é transferida para armazenamento interno.
    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.
  • O ambiente de execução é modificado de tal modo que quando o segmento sai correntes, após os destruidores para todos os objectos com rosca duração de armazenamento local são chamados, a cond variável de condição é notificado como se por:
    Original:
    The execution environment is modified such that when the current thread exits, after the destructors for all objects with rosca duração de armazenamento local 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();

Um efeito equivalente pode ser obtida com as facilidades oferecidas por std::promise ou std::packaged_task.
Original:
An equivalent effect may be achieved with the facilities provided by std::promise or std::packaged_task.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Índice

[editar] Notas

Chamar essa função se lock.mutex() não está bloqueada pelo atual segmento é um comportamento indefinido.
Original:
Calling this function if lock.mutex() is not locked by the current thread is undefined behavior.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Chamar essa função se lock.mutex() não é o mesmo mutex como o utilizado por todos os outros segmentos que estão aguardando na variável mesma condição é um comportamento indefinido.
Original:
Calling this function if lock.mutex() is not the same mutex as the one used by all other threads that are currently waiting on the same condition variable is undefined behavior.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
O lk bloqueio fornecido é mantido até a thread. Uma vez que esta função tem sido chamado, não há mais threads podem adquirir o mesmo bloqueio, a fim de esperar em cond. Se algum segmento está aguardando esta variável condição, ele não deve tentar libertar e readquirir o bloqueio quando ele acorda spuriously.
Original:
The supplied lock lk is held until the thread exits. Once this function has been called, no more threads may acquire the same lock in order to wait on cond. If some thread is waiting on this condition variable, it should not attempt to release and reacquire the lock when it wakes up spuriously.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Em casos de uso típicas, esta função é a última coisa chamada por um fio separado.
Original:
In typical use cases, this function is the last thing called by a detached thread.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[editar] Parâmetros

cond -
a variável de condição para notificar a saída de rosca
Original:
the condition variable to notify at thread exit
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
lk -
o bloqueio associado ao cond variável de condição
Original:
the lock associated with the condition variable cond
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[editar] 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.

[editar] Exemplo

Este fragmento de código parcial ilustra como notify_all_at_thread_exit pode ser usado para evitar a aceder a dados que dependem locals de rosca, enquanto os locais de rosca estão em processo de serem destruídos:
Original:
This partial code fragment illustrates how notify_all_at_thread_exit can be used to avoid accessing data that depends on thread locals while those thread locals are in the process of being destructed:
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>
 
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
}


[editar] Veja também

define o resultado ao valor específico ao entregar a notificação apenas com saída de rosca
Original:
sets the result to specific value while delivering the notification only at thread exit
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(of std::promise função pública membro) [edit]
executa a função de garantir que o resultado é preparada uma única vez a thread corrente
Original:
executes the function ensuring that the result is ready only once the current thread exits
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(of std::packaged_task função pública membro) [edit]