Movatterモバイル変換


[0]ホーム

URL:


cppreference.com
Namespaces
Variants
    Actions

      std::shared_timed_mutex::try_lock_for

      From cppreference.com
      <cpp‎ |thread‎ |shared timed mutex

      [edit template]
       
       
      Concurrency support library
      Threads
      (C++11)
      (C++20)
      this_thread namespace
      (C++11)
      (C++11)
      (C++11)
      Cooperative cancellation
      Mutual exclusion
      Generic lock management
      (C++11)
      (C++11)
      (C++11)
      (C++11)
      Condition variables
      (C++11)
      Semaphores
      Latches and Barriers
      (C++20)
      (C++20)
      Futures
      (C++11)
      (C++11)
      (C++11)
      Safe reclamation
      Hazard pointers
      Atomic types
      (C++11)
      (C++20)
      Initialization of atomic types
      (C++11)(deprecated in C++20)
      (C++11)(deprecated in C++20)
      Memory ordering
      (C++11)(deprecated in C++26)
      Free functions for atomic operations
      Free functions for atomic flags
       
       
      template<class Rep,class Period>
      bool try_lock_for(conststd::chrono::duration<Rep, Period>& timeout_duration);
      (since C++14)

      Tries to lock the mutex. Blocks until the specified durationtimeout_duration has elapsed (timeout) or the lock is acquired (owns the mutex), whichever comes first. On successful lock acquisition returnstrue, otherwise returnsfalse.

      Iftimeout_duration is less or equaltimeout_duration.zero(), the function behaves liketry_lock().

      This function may block for longer thantimeout_duration due to scheduling or resource contention delays.

      The standard recommends that astd::steady_clock is used to measure the duration. If an implementation uses astd::system_clock instead, the wait time may also be sensitive to clock adjustments.

      As withtry_lock(), this function is allowed to fail spuriously and returnfalse even if the mutex was not locked by any other thread at some point duringtimeout_duration.

      Priorunlock() operation on the same mutexsynchronizes-with (as defined instd::memory_order) this operation if it returnstrue.

      Iftry_lock_for is called by a thread that already owns the mutex in any mode (shared or exclusive), the behavior is undefined.

      Contents

      [edit]Parameters

      timeout_duration - minimum duration to block for

      [edit]Return value

      true if the lock was acquired successfully, otherwisefalse.

      [edit]Exceptions

      Any exception thrown bytimeout_duration (durations provided by the standard library never throw).

      [edit]Example

      Run this code
      #include <chrono>#include <iostream>#include <mutex>#include <sstream>#include <thread>#include <vector> usingnamespace std::chrono_literals; std::mutex cout_mutex;// control access to std::coutstd::timed_mutex mutex; void job(int id){std::ostringstream stream; for(int i=0; i<3;++i){if(mutex.try_lock_for(100ms)){            stream<<"success ";std::this_thread::sleep_for(100ms);            mutex.unlock();}else            stream<<"failed "; std::this_thread::sleep_for(100ms);} std::lock_guard<std::mutex> lock{cout_mutex};std::cout<<'['<< id<<"] "<< stream.str()<<'\n';} int main(){std::vector<std::thread> threads;for(int i{0}; i<4;++i)        threads.emplace_back(job, i); for(auto& th: threads)        th.join();}

      Possible output:

      [0] failed failed failed [3] failed failed success [2] failed success failed [1] success failed success

      [edit]See also

      locks the mutex, blocks if the mutex is not available
      (public member function)[edit]
      tries to lock the mutex, returns if the mutex is not available
      (public member function)[edit]
      tries to lock the mutex, returns if the mutex has been
      unavailable until specified time point has been reached
      (public member function)[edit]
      unlocks the mutex
      (public member function)[edit]
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/thread/shared_timed_mutex/try_lock_for&oldid=131033"

      [8]ページ先頭

      ©2009-2025 Movatter.jp