home | help 
std::timed_mutex::lock(3)      C++ Standard Libary     std::timed_mutex::lock(3)

NAME
     std::timed_mutex::lock - std::timed_mutex::lock

Synopsis
	void lock();  (since C++11)

	Locks  the mutex. If another thread has already locked the mutex, a call
     to lock will
	block execution until the lock is acquired.

	If lock is called by a thread that already owns the mutex, the	behavior
     is
	undefined: for example, the program may deadlock. An implementation that
     can detect
	the  invalid usage is encouraged to throw a std::system_error with error
     condition
	resource_deadlock_would_occur instead of deadlocking.

	Prior unlock() operations on the same mutex synchronize-with (as defined
     in
	std::memory_order) this operation.

Parameters
	(none)

Return value
	(none)

Exceptions
	Throws std::system_error when errors occur, including  errors  from  the
     underlying
	operating  system  that  would	prevent lock from meeting its specifica-
     tions. The mutex
	is not locked in the case of any exception being thrown.

Notes
	lock()	 is   usually	 not	called	  directly:    std::unique_lock,
     std::scoped_lock, and
	std::lock_guard are used to manage exclusive locking.

Example
	This  example  shows  how  lock and unlock can be used to protect shared
     data.

     // Run this code

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

      int g_num = 0; // protected by g_num_mutex
      std::mutex g_num_mutex;

      void slow_increment(int id)
      {
	  for (int i = 0; i < 3; ++i)
	  {
	      g_num_mutex.lock();
	      ++g_num;
	      // note, that the mutex also syncronizes the output
	      std::cout << "id: " << id << ", g_num: " << g_num << '\n';
	      g_num_mutex.unlock();

	      std::this_thread::sleep_for(std::chrono::milliseconds(234));
	  }
      }

      int main()
      {
	  std::thread t1{slow_increment, 0};
	  std::thread t2{slow_increment, 1};
	  t1.join();
	  t2.join();
      }

Possible output:
      id: 0, g_num: 1
      id: 1, g_num: 2
      id: 1, g_num: 3
      id: 0, g_num: 4
      id: 0, g_num: 5
      id: 1, g_num: 6

See also
	try_lock       tries to lock the mutex, returns  if  the  mutex  is  not
     available
		       (public member function)
		       tries to lock the mutex, returns if the mutex has been
	try_lock_for   unavailable for the specified timeout duration
		       (public member function)
		       tries to lock the mutex, returns if the mutex has been
	try_lock_until unavailable until specified time point has been reached
		       (public member function)
	unlock	       unlocks the mutex
		       (public member function)
	C documentation for
	mtx_lock

http://cppreference.com 	   2024.06.10	       std::timed_mutex::lock(3)
home | help