Movatterモバイル変換


[0]ホーム

URL:


cppreference.com
Namespaces
Variants
    Actions

      std::mutex::lock

      From cppreference.com
      <cpp‎ |thread‎ |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
       
       
      void lock();
      (since C++11)

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

      Iflock is called by a thread that already owns themutex, the behavior is undefined: for example, the programmay deadlock. An implementation that can detect the invalid usage is encouraged to throw astd::system_error with error conditionresource_deadlock_would_occur instead of deadlocking.

      Priorunlock() operations on the same mutexsynchronize-with (as defined instd::memory_order) this operation.

      Contents

      [edit]Exceptions

      Throwsstd::system_error when errors occur, including errors from the underlying operating system that would preventlock from meeting its specifications. The mutex is not locked in the case of any exception being thrown.

      [edit]Notes

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

      [edit]Example

      This example shows howlock andunlock 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_mutexstd::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 outputstd::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: 1id: 1, g_num: 2id: 1, g_num: 3id: 0, g_num: 4id: 0, g_num: 5id: 1, g_num: 6

      [edit]See also

      tries to lock the mutex, returns if the mutex is not available
      (public member function)[edit]
      unlocks the mutex
      (public member function)[edit]
      C documentation formtx_lock
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/thread/mutex/lock&oldid=161189"

      [8]ページ先頭

      ©2009-2025 Movatter.jp