Device (C++)

Neuro::Device

Defined in header <device/device.h>

<tr class="t-dcl t-since-cxx11">

<td>

class mutex;

</td>

<td class="t-dcl-nopad"> </td> <td> (since C++11) </td> </tr> <tr class="t-dcl-sep"><td></td><td></td><td></td></tr> </tbody></table>

The mutex class is a synchronization primitive that can be used to protect shared data from being simultaneously accessed by multiple threads.

mutex offers exclusive, non-recursive ownership semantics:

• A calling thread owns a mutex from the time that it successfully calls either <a href="/w/cpp/thread/mutex/lock" title="cpp/thread/mutex/lock">lock</a> or <a href="/w/cpp/thread/mutex/try_lock" title="cpp/thread/mutex/try lock">try_lock</a> until it calls <a href="/w/cpp/thread/mutex/unlock" title="cpp/thread/mutex/unlock">unlock</a>.
• When a thread owns a mutex, all other threads will block (for calls to <a href="/w/cpp/thread/mutex/lock" title="cpp/thread/mutex/lock">lock</a>) or receive a false return value (for <a href="/w/cpp/thread/mutex/try_lock" title="cpp/thread/mutex/try lock">try_lock</a>) if they attempt to claim ownership of the mutex.
• A calling thread must not own the mutex prior to calling <a href="/w/cpp/thread/mutex/lock" title="cpp/thread/mutex/lock">lock</a> or <a href="/w/cpp/thread/mutex/try_lock" title="cpp/thread/mutex/try lock">try_lock</a>.

The behavior of a program is undefined if a mutex is destroyed while still owned by any threads, or a thread terminates while owning a mutex. The mutex class satisfies all requirements of <a href="/w/cpp/concept/Mutex" title="cpp/concept/Mutex">Mutex</a> and <a href="/w/cpp/concept/StandardLayoutType" title="cpp/concept/StandardLayoutType">StandardLayoutType</a>.

std::mutex is neither copyable nor movable.

<tbody></tbody>

Member types

<tbody> </tbody>

Member type	Definition
native_handle_type(optional)	implementation-defined

Member functions

<tbody> </tbody>

<a href="/w/cpp/thread/mutex/mutex" title="cpp/thread/mutex/mutex"> (constructor)</a>	constructs the mutex (public member function)
<a href="/w/cpp/thread/mutex/%7Emutex" title="cpp/thread/mutex/~mutex"> (destructor)</a>	destroys the mutex (public member function)
operator= [deleted]	not copy-assignable (public member function)
Locking
<a href="/w/cpp/thread/mutex/lock" title="cpp/thread/mutex/lock"> lock</a>	locks the mutex, blocks if the mutex is not available (public member function)
<a href="/w/cpp/thread/mutex/try_lock" title="cpp/thread/mutex/try lock"> try_lock</a>	tries to lock the mutex, returns if the mutex is not available (public member function)
<a href="/w/cpp/thread/mutex/unlock" title="cpp/thread/mutex/unlock"> unlock</a>	unlocks the mutex (public member function)
Native handle
<a href="/w/cpp/thread/mutex/native_handle" title="cpp/thread/mutex/native handle"> native_handle</a>	returns the underlying implementation-defined native handle object (public member function)

Notes

std::mutex is usually not accessed directly: <a href="/w/cpp/thread/unique_lock" title="cpp/thread/unique lock">std::unique_lock</a>, <a href="/w/cpp/thread/lock_guard" title="cpp/thread/lock guard">std::lock_guard</a>, or std::scoped_lock (since C++17) manage locking in a more exception-safe manner.

Example

This example shows how a mutex can be used to protect a <a href="/w/cpp/container/map" title="cpp/container/map">std::map</a> shared between two threads.

Run this code

<span class="co2">#include <iostream></span>
<span class="co2">#include <map></span>
<span class="co2">#include <string></span>
<span class="co2">#include <chrono></span>
<span class="co2">#include <thread></span>
<span class="co2">#include <mutex></span>
 
<a href="http://en.cppreference.com/w/cpp/container/map"><span class="kw1281">std::<span class="me2">map</span></span></a><span class="sy1"><</span><a href="http://en.cppreference.com/w/cpp/string/basic_string"><span class="kw1230">std::<span class="me2">string</span></span></a>, <a href="http://en.cppreference.com/w/cpp/string/basic_string"><span class="kw1230">std::<span class="me2">string</span></span></a><span class="sy1">></span> g_pages<span class="sy4">;</span>
std<span class="sy4">::</span><span class="me2">mutex</span> g_pages_mutex<span class="sy4">;</span>
 
<span class="kw4">void</span> save_page<span class="br0">(</span><span class="kw4">const</span> <a href="http://en.cppreference.com/w/cpp/string/basic_string"><span class="kw1230">std::<span class="me2">string</span></span></a> <span class="sy3">&</span>url<span class="br0">)</span>
<span class="br0">{</span>
    <span class="co1">// simulate a long page fetch</span>
    <a href="http://en.cppreference.com/w/cpp/thread/sleep_for"><span class="kw2149">std::<span class="me2">this_thread</span><span class="sy4">::</span><span class="me2">sleep_for</span></span></a><span class="br0">(</span><a href="http://en.cppreference.com/w/cpp/chrono/duration"><span class="kw997">std::<span class="me2">chrono</span><span class="sy4">::</span><span class="me2">seconds</span></span></a><span class="br0">(</span><span class="nu0">2</span><span class="br0">)</span><span class="br0">)</span><span class="sy4">;</span>
    <a href="http://en.cppreference.com/w/cpp/string/basic_string"><span class="kw1230">std::<span class="me2">string</span></span></a> result <span class="sy1">=</span> <span class="st0">"fake content"</span><span class="sy4">;</span>
 
    <a href="http://en.cppreference.com/w/cpp/thread/lock_guard"><span class="kw2165">std::<span class="me2">lock_guard</span></span></a><span class="sy1"><</span>std<span class="sy4">::</span><span class="me2">mutex</span><span class="sy1">></span> guard<span class="br0">(</span>g_pages_mutex<span class="br0">)</span><span class="sy4">;</span>
    g_pages<span class="br0">[</span>url<span class="br0">]</span> <span class="sy1">=</span> result<span class="sy4">;</span>
<span class="br0">}</span>
 
<span class="kw4">int</span> main<span class="br0">(</span><span class="br0">)</span> 
<span class="br0">{</span>
    <a href="http://en.cppreference.com/w/cpp/thread/thread"><span class="kw2146">std::<span class="me2">thread</span></span></a> t1<span class="br0">(</span>save_page, <span class="st0">"http://foo"</span><span class="br0">)</span><span class="sy4">;</span>
    <a href="http://en.cppreference.com/w/cpp/thread/thread"><span class="kw2146">std::<span class="me2">thread</span></span></a> t2<span class="br0">(</span>save_page, <span class="st0">"http://bar"</span><span class="br0">)</span><span class="sy4">;</span>
    t1.<span class="me1">join</span><span class="br0">(</span><span class="br0">)</span><span class="sy4">;</span>
    t2.<span class="me1">join</span><span class="br0">(</span><span class="br0">)</span><span class="sy4">;</span>
 
    <span class="co1">// safe to access g_pages without lock now, as the threads are joined</span>
    <span class="kw1">for</span> <span class="br0">(</span><span class="kw4">const</span> <span class="kw4">auto</span> <span class="sy3">&</span>pair <span class="sy4">:</span> g_pages<span class="br0">)</span> <span class="br0">{</span>
        <a href="http://en.cppreference.com/w/cpp/io/cout"><span class="kw1758">std::<span class="me2">cout</span></span></a> <span class="sy1"><<</span> pair.<span class="me1">first</span> <span class="sy1"><<</span> <span class="st0">" => "</span> <span class="sy1"><<</span> pair.<span class="me1">second</span> <span class="sy1"><<</span> <span class="st0">'<span class="es1">\n</span>'</span><span class="sy4">;</span>
    <span class="br0">}</span>
<span class="br0">}</span>

Output:

http://bar => fake content
http://foo => fake content

</div>

               </div>