Standard library header <mutex> - cppreference.com

##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# Standard library header <mutex>

From cppreference.com
< cpp‎ | header

This header is part of the thread support library.

### Classes
mutex (C++11) | provides basic mutual exclusion facility (class) [edit]
timed_mutex (C++11) | provides mutual exclusion facility which implements locking with a timeout (class) [edit]
recursive_mutex (C++11) | provides mutual exclusion facility which can be locked recursively by the same thread (class) [edit]
recursive_timed_mutex (C++11) | provides mutual exclusion facility which can be locked recursively by the same thread and implements locking with a timeout (class) [edit]
lock_guard (C++11) | implements a strictly scope-based mutex ownership wrapper (class template) [edit]
unique_lock (C++11) | implements movable mutex ownership wrapper (class template) [edit]
defer_lock_ttry_to_lock_tadopt_lock_t (C++11)(C++11)(C++11) | tag type used to specify locking strategy (class) [edit]
defer_locktry_to_lockadopt_lock (C++11)(C++11)(C++11) | tag constants used to specify locking strategy (constant) [edit]
once_flag (C++11) | helper object to ensure that `call_once` invokes the function only once (class) [edit]
### Functions
try_lock (C++11) | attempts to obtain ownership of mutexes via repeated calls to `try_lock` (function template) [edit]
lock (C++11) | locks specified mutexes, blocks if any are unavailable (function template) [edit]
call_once (C++11) | invokes a function only once even if called from multiple threads (function template) [edit]
std::swap(std::unique_lock) (C++11) | specialization of std::swap for `unique_lock` (function template) [edit]

### [edit] Synopsis

    namespace std {
        class mutex;
        class recursive_mutex;
        class timed_mutex;
        class recursive_timed_mutex;

        struct defer_lock_t { };
        constexpr defer_lock_t defer_lock { };

        struct try_to_lock_t { };
        constexpr try_to_lock_t try_to_lock { };

        struct adopt_lock_t { };
        constexpr adopt_lock_t adopt_lock { };

        template <class Mutex> class lock_guard;
        template <class Mutex> class unique_lock;

        template <class Mutex>
        void swap(unique_lock<Mutex>& x,
                  unique_lock<Mutex>& y) noexcept;

        template <class L1, class L2, class... L3>
        int try_lock(L1&, L2&, L3&...);

        template <class L1, class L2, class... L3>
        void lock(L1&, L2&, L3&...);

        struct once_flag;

        template<class Callable, class ...Args>
        void call_once(once_flag& flag, Callable func, Args&&... args);
    }

#### [edit] Class std::mutex

    class mutex {
     public:
        constexpr mutex() noexcept;
        ~mutex();
        mutex(const mutex&) = delete;
        mutex& operator=(const mutex&) = delete;

        void lock();
        bool try_lock();
        void unlock();
        typedef /*implementation-defined*/ native_handle_type;
        native_handle_type native_handle();
    };

#### [edit] Class std::recursive_mutex

    class recursive_mutex {
     public:
        recursive_mutex();
        ~recursive_mutex();
        recursive_mutex(const recursive_mutex&) = delete;
        recursive_mutex& operator=(const recursive_mutex&) = delete;

        void lock();
        bool try_lock() noexcept;
        void unlock();
        typedef /*implementation-defined*/ native_handle_type;
        native_handle_type native_handle();
    };

#### [edit] Class std::timed_mutex

    class timed_mutex {
     public:
        timed_mutex();
        ~timed_mutex();
        timed_mutex(const timed_mutex&) = delete;
        timed_mutex& operator=(const timed_mutex&) = delete;

        void lock();
        bool try_lock();
        template <class Rep, class Period>
            bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
        template <class Clock, class Duration>
            bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
        void unlock();
        typedef /*implementation-defined*/ native_handle_type;
        native_handle_type native_handle();
    };

#### [edit] Class std::recursive_timed_mutex

    class recursive_timed_mutex {
     public:
        recursive_timed_mutex();
        ~recursive_timed_mutex();
        recursive_timed_mutex(const recursive_timed_mutex&) = delete;
        recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete;

        void lock();
        bool try_lock() noexcept;
        template <class Rep, class Period>
            bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
        template <class Clock, class Duration>
            bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
        void unlock();
        typedef /*implementation-defined*/ native_handle_type;
        native_handle_type native_handle();
    };

#### [edit] Class std::lock_guard

    template <class Mutex>
    class lock_guard {
     public:
        typedef Mutex mutex_type;
        explicit lock_guard(mutex_type& m);
        lock_guard(mutex_type& m, adopt_lock_t);
        ~lock_guard();
        lock_guard(lock_guard const&) = delete;
        lock_guard& operator=(lock_guard const&) = delete;
     private:
        mutex_type& pm; // exposition only
    };

#### [edit] Class std::unique_lock

    template <class Mutex>
    class unique_lock {
     public:
        typedef Mutex mutex_type;

        // construct/copy/destroy:
        unique_lock() noexcept;
        explicit unique_lock(mutex_type& m);
        unique_lock(mutex_type& m, defer_lock_t) noexcept;
        unique_lock(mutex_type& m, try_to_lock_t);
        unique_lock(mutex_type& m, adopt_lock_t);
        template <class Clock, class Duration>
        unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);
        template <class Rep, class Period>
        unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);
        ~unique_lock();
        unique_lock(unique_lock const&) = delete;
        unique_lock& operator=(unique_lock const&) = delete;
        unique_lock(unique_lock&& u) noexcept;
        unique_lock& operator=(unique_lock&& u) noexcept;

        // locking:
        void lock();
        bool try_lock();
        template <class Rep, class Period>
        bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
        template <class Clock, class Duration>
        bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
        void unlock();

        // modifiers:
        void swap(unique_lock& u) noexcept;
        mutex_type *release() noexcept;

        // observers:
        bool owns_lock() const noexcept;
        explicit operator bool () const noexcept;
        mutex_type* mutex() const noexcept;

     private:
        mutex_type *pm; // exposition only
        bool owns; // exposition only
    };

#### [edit] Class std::once_flag

    struct once_flag {
        constexpr once_flag() noexcept;
        once_flag(const once_flag&) = delete;
        once_flag& operator=(const once_flag&) = delete;
    };

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/header/mutex&oldid=64006"