std::mutex:: try_lock

뮤텍스를 잠그려고 시도합니다. 즉시 반환됩니다. 잠금 획득에 성공하면 true 를 반환하고, 그렇지 않으면 false 를 반환합니다.

이 함수는 허위로 실패할 수 있으며, 다른 스레드가 현재 뮤텍스를 잠그지 않은 경우에도 false 를 반환할 수 있습니다.

만약 try_lock 이 이미 mutex 를 소유하고 있는 스레드에 의해 호출되면, 그 동작은 정의되지 않습니다.

동일한 뮤텍스에 대한 이전 unlock() 연산은 이 연산이 true 를 반환할 경우 synchronizes-with (이 관계는 std::memory_order 에 정의된 대로) 합니다. 이전 lock() 연산은 이 연산이 false 를 반환할 경우 이 연산과 synchronize하지 않습니다.

매개변수

(없음)

반환값

true 락이 성공적으로 획득된 경우, 그렇지 않으면 false .

예외

아무것도 던지지 않습니다.

예제

#include <chrono>
#include <iostream> // std::cout
#include <mutex>
#include <thread>
std::chrono::milliseconds interval(100);
std::mutex mutex;
int job_shared = 0; // 두 스레드 모두 'job_shared'를 수정할 수 있음,
                    // mutex가 이 변수를 보호함
int job_exclusive = 0; // 오직 하나의 스레드만 'job_exclusive'를 수정할 수 있음
                       // 보호가 필요 없음
// 이 스레드는 'job_shared'와 'job_exclusive' 모두를 수정할 수 있음
void job_1() 
{
    std::this_thread::sleep_for(interval); // 'job_2'가 lock을 취하도록 함
    while (true)
    {
        // 'job_shared'를 수정하기 위해 mutex lock 시도
        if (mutex.try_lock())
        {
            std::cout << "job shared (" << job_shared << ")\n";
            mutex.unlock();
            return;
        }
        else
        {
            // 'job_shared'를 수정할 lock을 얻을 수 없음
            // 하지만 수행할 다른 작업이 있음
            ++job_exclusive;
            std::cout << "job exclusive (" << job_exclusive << ")\n";
            std::this_thread::sleep_for(interval);
        }
    }
}
// 이 스레드는 오직 'job_shared'만 수정할 수 있음
void job_2() 
{
    mutex.lock();
    std::this_thread::sleep_for(5 * interval);
    ++job_shared;
    mutex.unlock();
}
int main() 
{
    std::thread thread_1(job_1);
    std::thread thread_2(job_2);
    thread_1.join();
    thread_2.join();
}

job exclusive (1)
job exclusive (2)
job exclusive (3)
job exclusive (4)
job shared (1)

참고 항목