std::try_lock

This page has been machine-translated from the English version of the wiki using Google Translate.

The translation may contain errors and awkward wording. Hover over text to see the original version. You can help to fix errors and improve the translation. For instructions click here.

Click here for the English version of this page

Biblioteca de suporte a discussão

Threads

thread

(C++11)

this_thread namespace

get_id (C++11)
yield (C++11)

sleep_for (C++11)
sleep_until (C++11)

Exclusão mútua

mutex (C++11)
timed_mutex (C++11)

recursive_mutex (C++11)
recursive_timed_mutex (C++11)

Gestão de bloqueio genérico

lock_guard (C++11)
unique_lock (C++11)
defer_lock_ttry_to_lock_tadopt_lock_t (C++11)(C++11)(C++11)

lock (C++11)
try_lock (C++11)
defer_locktry_to_lockadopt_lock (C++11)(C++11)(C++11)

Variáveis de condição

condition_variable

(C++11)

condition_variable_any

(C++11)

notify_all_at_thread_exit

(C++11)

cv_status

(C++11)

Futuros

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)

[edit]

Definido no cabeçalho `<mutex>`

`template< class Lockable1, class Lockable2, class LockableN... > int try_lock( Lockable1& lock1, Lockable2& lock2, LockableN& lockn... );`		(desde C++11)

Tenta bloquear cada um dos objetos dado Lockable lock1, lock2, ..., lockn chamando try_lock no início ordem com o primeiro.

Se uma chamada para try_lock falhar, unlock é chamado por quaisquer objetos bloqueados e um índice baseado 0 do objeto que não conseguiu travar é devolvido.

Se uma chamada para resultados try_lock em uma exceção, unlock é chamado por quaisquer objetos bloqueados antes relançando.

Parâmetros

lock1, lock2, ... , lockn

-

o Lockable objetos para bloquear

Valor de retorno

-1 em sucesso, ou valor de índice 0 baseado do objeto que não conseguiu travar.

Exemplo

O exemplo a seguir usa std::try_lock periodicamente registro e contadores reiniciadas em execução em segmentos separados .

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

int main()
{
    int foo_count = 0;
    std::mutex foo_count_mutex;
    int bar_count = 0;
    std::mutex bar_count_mutex;
    int overall_count = 0;
    bool done = false;
    std::mutex done_mutex;

    auto increment = [](int &counter, std::mutex &m,  const char *desc) {
        for (int i = 0; i < 10; ++i) {
            std::unique_lock<std::mutex> lock(m);
            ++counter;
            std::cout << desc << ": " << counter << '\n';
            lock.unlock();
            std::this_thread::sleep_for(std::chrono::seconds(1));
        }
    };

    std::thread increment_foo(increment, std::ref(foo_count), 
        std::ref(foo_count_mutex), "foo");
    std::thread increment_bar(increment, std::ref(bar_count), 
        std::ref(bar_count_mutex), "bar");

    std::thread update_overall([&]() {
        done_mutex.lock();
        while (!done) {
            done_mutex.unlock();
            int result = std::try_lock(foo_count_mutex, bar_count_mutex);
            if (result == -1) {
                overall_count += foo_count + bar_count;
                foo_count = 0;
                bar_count = 0;
                std::cout << "overall: " << overall_count << '\n';
                foo_count_mutex.unlock();
                bar_count_mutex.unlock();
            }
            std::this_thread::sleep_for(std::chrono::seconds(2));
            done_mutex.lock();
        }
        done_mutex.unlock();
    });

    increment_foo.join();
    increment_bar.join();
    done_mutex.lock();
    done = true;
    done_mutex.unlock();
    update_overall.join();

    std::cout << "Done processing\n"
              << "foo: " << foo_count << '\n'
              << "bar: " << bar_count << '\n'
              << "overall: " << overall_count << '\n';
}

Potencial saída:

bar: 1
foo: 1
foo: 2
bar: 2
foo: 3
overall: 5
bar: 1
foo: 1
bar: 2
foo: 2
bar: 3
overall: 10
bar: 1
foo: 1
bar: 2
foo: 2
overall: 14
bar: 1
foo: 1
bar: 2
overall: 17
foo: 1
bar: 1
foo: 2
overall: 20
Done processing
foo: 0
bar: 0
overall: 20

Veja também


lock (C++11)	bloqueia especificados semáforos, blocos se algum não estão disponíveis Original: locks specified mutexes, blocks if any are unavailable The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (modelo de função) [edit]

Suporte ao Compilador
Freestanding and hosted
Linguagem
Headers da Biblioteca Standard
Requerimentos nomeados
Feature test macros (C++20)
Biblioteca de suporte de língua
Biblioteca de conceitos (C++20)
Biblioteca de diagnósticos
Biblioteca de utilitários em geral
Biblioteca de strings
Biblioteca de containers
Ranges library (C++20)
Biblioteca de iteradores
Biblioteca de algorítmos
Biblioteca numérica
Biblioteca de localizações
Biblioteca de input/output
Biblioteca de sistema de arquivo (C++17)
Biblioteca de expressões regulares (C++11)
Biblioteca de operações atômicas (C++11)
Biblioteca de suporte de thread (C++11)
Especificações Técnicas
Índice de symbolos
Bibliotecas externas

cppreference.com

Procurar

Espaços nominais

Variantes

Visualizações

Ações

std::try_lock

Índice

Parâmetros

Valor de retorno

Exemplo

Veja também

Navegação

Ferramentas