[c++] std::timed_mutex

en.cppreference.com/w/cpp/thread/timed_mutex

std::timed_mutex - cppreference.com

mutex와 비슷하게, timed_mutex는 상호배타적이고, 비재귀적인 소유권을 같습니다. 그런데 timed_mutex는 여기에 추가적으로 timeout 값을 이용하여 소유권을 요청할 수 있습니다 (try_lock_for( ), try_lock_until( )).

 

Member function

1) try_lock_for

// rel_time : relative time
template<class Rep, class Period>
bool try_lock_for(const chrono::duration<Rep, Period>& rel_time); 

• 만약 timed_mutex가 어떠한 스레드에 대해서도 lock되어 있지 않으면 lock을 수행합니다
• 만약 timed_mutex가 특정 스레드에 대해 lock되어 있는 경우, 현재 스레드의 동작은 timed_mutex가 unlock되거나 rel_time시간이 지날 때까지 block됩니다
• 만약 같은 스레드에서 이미 lock된 timed_mutex를 또 lock을 수행하는 경우 deadlock이 발생할 수 있습니다 (예기치못한 동작 수행). 만일 재귀적인 timed_mutex를 이용해야 하는 경우 std::recursive_timed_mutex를 이용할 수 있습니다.

Sample code (try_lock_for)

// timed_mutex::try_lock_for example
#include <iostream>       // std::cout
#include <chrono>         // std::chrono::milliseconds
#include <thread>         // std::thread
#include <mutex>          // std::timed_mutex

std::timed_mutex mtx;

void fireworks () {
  // waiting to get a lock: each thread prints "-" every 200ms:
  while (!mtx.try_lock_for(std::chrono::milliseconds(200))) {
    std::cout << "-";
  }
  // got a lock! - wait for 1s, then this thread prints "*"
  std::this_thread::sleep_for(std::chrono::milliseconds(1000));
  std::cout << "*\n";
  mtx.unlock();
}

int main ()
{
  std::thread threads[10];
  // spawn 10 threads:
  for (int i=0; i<10; ++i)
    threads[i] = std::thread(fireworks);

  for (auto& th : threads) th.join();

  return 0;
}

 

---

2) try_lock_until

// abs_time : absolute time
template <class Clock, class Duration>
  bool try_lock_until (const chrono::time_point<Clock,Duration>& abs_time);

• 만약 timed_mutex가 특정 스레드에 대해 lock되어 있는 경우, 현재 스레드의 동작은 timed_mutex가 unlock되거나 abs_time시간에 도달할 때까지 block됩니다

 

Sample code (try_lock_until)

// timed_mutex::try_lock_until example
#include <iostream>       // std::cout
#include <chrono>         // std::chrono::system_clock
#include <thread>         // std::thread
#include <mutex>          // std::timed_mutex
#include <ctime>          // std::time_t, std::tm, std::localtime, std::mktime

std::timed_mutex cinderella;

// gets time_point for next midnight:
std::chrono::time_point<std::chrono::system_clock> midnight() {
  using std::chrono::system_clock;
  std::time_t tt = system_clock::to_time_t (system_clock::now());
  struct std::tm * ptm = std::localtime(&tt);
  ++ptm->tm_mday; ptm->tm_hour=0; ptm->tm_min=0; ptm->tm_sec=0;
  return system_clock::from_time_t (mktime(ptm));
}

void carriage() {
  if (cinderella.try_lock_until(midnight())) {
    std::cout << "ride back home on carriage\n";
    cinderella.unlock();
  }
  else
    std::cout << "carriage reverts to pumpkin\n";
}

void ball() {
  cinderella.lock();
  std::cout << "at the ball...\n";
  cinderella.unlock();
}

int main ()
{
  std::thread th1 (ball);
  std::thread th2 (carriage);

  th1.join();
  th2.join();

  return 0;
}