home | help 
std::shared..._mutex::lock(3)  C++ Standard Libary std::shared..._mutex::lock(3)

NAME
     std::shared_timed_mutex::lock - std::shared_timed_mutex::lock

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

	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  in  any  mode
     (shared or
	exclusive), the behavior is undefined.

	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.

	Shared mutexes do not support direct transition from  shared  to  unique
     ownership
	mode: the shared lock has to be relinquished with unlock_shared() before
     exclusive
	ownership  may be obtained with lock(). boost::upgrade_mutex may be used
     for this
	purpose.

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)
	unlock	 unlocks the mutex
		 (public member function)
	C documentation for
	mtx_lock

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