std::try_lock

来自cppreference.com

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

 
C++
 
线程的支持库
主题
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命名空间
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）
相互排斥
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）
通用锁管理
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）
条件变量
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）
期货
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 <mutex>
template< class Lockable1, class Lockable2, class LockableN... >
int try_lock( Lockable1& lock1, Lockable2& lock2, LockableN& lockn... );
 （C++11 起）
试图锁定每一个给定的Lockable对象lock1，lock2，...，lockn开始依次调用try_lock的第一.
Original:
Tries to lock each of the given Lockable objects lock1, lock2, ..., lockn by calling try_lock in order beginning with the first.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
如果调用try_lock失败，unlock任何被锁定的对象被称为返回一个0的索引，无法锁定的对象.....
Original:
If a call to try_lock fails, unlock is called for any locked objects and a 0-based index of the object that failed to lock is returned.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
如果try_lock结果调用的异常，unlock要求任何被锁定的对象，然后重新抛出.
Original:
If a call to try_lock results in an exception, unlock is called for any locked objects before rethrowing.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

目录

[编辑] 参数

lock1, lock2, ... , lockn -
Lockable对象锁定
Original:
the Lockable objects to lock
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[编辑] 返回值

-1成功，或0无法锁定的对象的索引值.
Original:
-1 on success, or 0-based index value of the object that failed to lock.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[编辑] 为例

下面的示例使用std::try_lock定期理货和重置计数器在单独的线程中运行.
Original:
The following example uses std::try_lock to periodically tally and reset counters running in separate threads.
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 <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';
}

Possible output: 

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

[编辑] 另请参阅

（C++11）
指定的锁互斥体，块，如果有任何无法使用
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.

（函数模板） [edit]
来自“http://zh.cppreference.com/mwiki/index.php?title=cpp/thread/try_lock&oldid=27878”