[DEV] add v1.76.0

This commit is contained in:
2021-10-05 21:37:46 +02:00
parent a97e9ae7d4
commit d0115b733d
45133 changed files with 4744437 additions and 1026325 deletions

View File

@@ -0,0 +1,793 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Scoped Threads</title>
<link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
<link rel="up" href="../thread.html" title="Chapter 40. Thread 4.8.0">
<link rel="prev" href="thread_management.html" title="Thread Management">
<link rel="next" href="synchronization.html" title="Synchronization">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
<td align="center"><a href="../../../index.html">Home</a></td>
<td align="center"><a href="../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="thread_management.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../thread.html"><img src="../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="synchronization.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="thread.ScopedThreads"></a><a class="link" href="ScopedThreads.html" title="Scoped Threads">Scoped Threads</a>
</h2></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="ScopedThreads.html#thread.ScopedThreads.motivation">Motivation</a></span></dt>
<dt><span class="section"><a href="ScopedThreads.html#thread.ScopedThreads.tutorial">Tutorial</a></span></dt>
<dt><span class="section"><a href="ScopedThreads.html#thread.ScopedThreads.thread_functors">Free Thread Functors</a></span></dt>
<dt><span class="section"><a href="ScopedThreads.html#thread.ScopedThreads.strict_scoped_thread">Class <code class="computeroutput"><span class="identifier">strict_scoped_thread</span></code></a></span></dt>
<dt><span class="section"><a href="ScopedThreads.html#thread.ScopedThreads.scoped_thread">Class <code class="computeroutput"><span class="identifier">scoped_thread</span></code></a></span></dt>
<dt><span class="section"><a href="ScopedThreads.html#thread.ScopedThreads.non_member_swap">Non-member function
<code class="computeroutput"><span class="identifier">swap</span><span class="special">(</span><span class="identifier">scoped_thread</span><span class="special">&amp;,</span><span class="identifier">scoped_thread</span><span class="special">&amp;)</span></code></a></span></dt>
</dl></div>
<h4>
<a name="thread.ScopedThreads.h0"></a>
<span class="phrase"><a name="thread.ScopedThreads.synopsis"></a></span><a class="link" href="ScopedThreads.html#thread.ScopedThreads.synopsis">Synopsis</a>
</h4>
<pre class="programlisting"><span class="comment">//#include &lt;boost/thread/scoped_thread.hpp&gt;</span>
<span class="keyword">struct</span> <span class="identifier">detach</span><span class="special">;</span>
<span class="keyword">struct</span> <span class="identifier">join_if_joinable</span><span class="special">;</span>
<span class="keyword">struct</span> <span class="identifier">interrupt_and_join_if_joinable</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CallableThread</span> <span class="special">=</span> <span class="identifier">join_if_joinable</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Thread</span> <span class="special">=</span> <span class="identifier">thread</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">strict_scoped_thread</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CallableThread</span> <span class="special">=</span> <span class="identifier">join_if_joinable</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Thread</span> <span class="special">=</span> <span class="identifier">thread</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">scoped_thread</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CallableThread</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Thread</span> <span class="special">=</span> <span class="identifier">thread</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">scoped_thread</span><span class="special">&lt;</span><span class="identifier">Callable</span><span class="special">,</span> <span class="identifier">Thread</span><span class="special">&gt;&amp;</span> <span class="identifier">lhs</span><span class="special">,</span> <span class="identifier">scoped_threadCallable</span><span class="special">,</span> <span class="identifier">Thread</span><span class="special">&gt;&amp;</span> <span class="identifier">rhs</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="thread.ScopedThreads.motivation"></a><a class="link" href="ScopedThreads.html#thread.ScopedThreads.motivation" title="Motivation">Motivation</a>
</h3></div></div></div>
<p>
Based on the scoped_thread class defined in C++ Concurrency in Action Boost.Thread
defines a thread wrapper class that instead of calling terminate if the thread
is joinable on destruction, call a specific action given as template parameter.
</p>
<p>
While the scoped_thread class defined in C++ Concurrency in Action is closer
to strict_scoped_thread class that doesn't allows any change in the wrapped
thread, Boost.Thread provides a class scoped_thread that provides the same
non-deprecated interface as <a class="link" href="thread_management.html#thread.thread_management.thread" title="Class thread"><code class="computeroutput"><span class="identifier">thread</span></code></a>.
</p>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="thread.ScopedThreads.tutorial"></a><a class="link" href="ScopedThreads.html#thread.ScopedThreads.tutorial" title="Tutorial">Tutorial</a>
</h3></div></div></div>
<p>
Scoped Threads are wrappers around a thread that allows the user to state
what to do at destruction time. One of the common uses is to join the thread
at destruction time so this is the default behavior. This is the single difference
respect to a thread. While thread call std::terminate() on the destructor
if the thread is joinable, strict_scoped_thread&lt;&gt; or scoped_thread&lt;&gt;
join the thread if joinable.
</p>
<p>
The difference between strict_scoped_thread and scoped_thread is that the
strict_scoped_thread hides completely the owned thread and so the user can
do nothing with the owned thread other than the specific action given as
parameter, while scoped_thread provide the same interface as <a class="link" href="thread_management.html#thread.thread_management.thread" title="Class thread"><code class="computeroutput"><span class="identifier">thread</span></code></a> and forwards all the operations.
</p>
<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">strict_scoped_thread</span><span class="special">&lt;&gt;</span> <span class="identifier">t1</span><span class="special">((</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">thread</span><span class="special">(</span><span class="identifier">f</span><span class="special">)));</span>
<span class="comment">//t1.detach(); // compile fails</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">scoped_thread</span><span class="special">&lt;&gt;</span> <span class="identifier">t2</span><span class="special">((</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">thread</span><span class="special">(</span><span class="identifier">f</span><span class="special">)));</span>
<span class="identifier">t2</span><span class="special">.</span><span class="identifier">detach</span><span class="special">();</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="thread.ScopedThreads.thread_functors"></a><a class="link" href="ScopedThreads.html#thread.ScopedThreads.thread_functors" title="Free Thread Functors">Free Thread Functors</a>
</h3></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="ScopedThreads.html#thread.ScopedThreads.thread_functors.detach">Functor
<code class="computeroutput"><span class="identifier">detach</span></code></a></span></dt>
<dt><span class="section"><a href="ScopedThreads.html#thread.ScopedThreads.thread_functors.join_if_joinable">Functor
<code class="computeroutput"><span class="identifier">join_if_joinable</span></code></a></span></dt>
<dt><span class="section"><a href="ScopedThreads.html#thread.ScopedThreads.thread_functors.interrupt_and_join_if_joinable">Functor
<code class="computeroutput"><span class="identifier">interrupt_and_join_if_joinable</span></code></a></span></dt>
</dl></div>
<pre class="programlisting"><span class="comment">//#include &lt;boost/thread/scoped_thread.hpp&gt;</span>
<span class="keyword">struct</span> <span class="identifier">detach</span><span class="special">;</span>
<span class="keyword">struct</span> <span class="identifier">join_if_joinable</span><span class="special">;</span>
<span class="keyword">struct</span> <span class="identifier">interrupt_and_join_if_joinable</span><span class="special">;</span>
</pre>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.ScopedThreads.thread_functors.detach"></a><a class="link" href="ScopedThreads.html#thread.ScopedThreads.thread_functors.detach" title="Functor detach">Functor
<code class="computeroutput"><span class="identifier">detach</span></code></a>
</h4></div></div></div>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">detach</span>
<span class="special">{</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Thread</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span><span class="identifier">Thread</span><span class="special">&amp;</span> <span class="identifier">t</span><span class="special">)</span>
<span class="special">{</span>
<span class="identifier">t</span><span class="special">.</span><span class="identifier">detach</span><span class="special">();</span>
<span class="special">}</span>
<span class="special">};</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.ScopedThreads.thread_functors.join_if_joinable"></a><a class="link" href="ScopedThreads.html#thread.ScopedThreads.thread_functors.join_if_joinable" title="Functor join_if_joinable">Functor
<code class="computeroutput"><span class="identifier">join_if_joinable</span></code></a>
</h4></div></div></div>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">join_if_joinable</span>
<span class="special">{</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Thread</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span><span class="identifier">Thread</span><span class="special">&amp;</span> <span class="identifier">t</span><span class="special">)</span>
<span class="special">{</span>
<span class="keyword">if</span> <span class="special">(</span><span class="identifier">t</span><span class="special">.</span><span class="identifier">joinable</span><span class="special">())</span>
<span class="special">{</span>
<span class="identifier">t</span><span class="special">.</span><span class="identifier">join</span><span class="special">();</span>
<span class="special">}</span>
<span class="special">}</span>
<span class="special">};</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.ScopedThreads.thread_functors.interrupt_and_join_if_joinable"></a><a class="link" href="ScopedThreads.html#thread.ScopedThreads.thread_functors.interrupt_and_join_if_joinable" title="Functor interrupt_and_join_if_joinable">Functor
<code class="computeroutput"><span class="identifier">interrupt_and_join_if_joinable</span></code></a>
</h4></div></div></div>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">interrupt_and_join_if_joinable</span>
<span class="special">{</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Thread</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span><span class="identifier">Thread</span><span class="special">&amp;</span> <span class="identifier">t</span><span class="special">)</span>
<span class="special">{</span>
<span class="identifier">t</span><span class="special">.</span><span class="identifier">interrupt</span><span class="special">();</span>
<span class="keyword">if</span> <span class="special">(</span><span class="identifier">t</span><span class="special">.</span><span class="identifier">joinable</span><span class="special">())</span>
<span class="special">{</span>
<span class="identifier">t</span><span class="special">.</span><span class="identifier">join</span><span class="special">();</span>
<span class="special">}</span>
<span class="special">}</span>
<span class="special">};</span>
</pre>
</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="thread.ScopedThreads.strict_scoped_thread"></a><a class="link" href="ScopedThreads.html#thread.ScopedThreads.strict_scoped_thread" title="Class strict_scoped_thread">Class <code class="computeroutput"><span class="identifier">strict_scoped_thread</span></code></a>
</h3></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="ScopedThreads.html#thread.ScopedThreads.strict_scoped_thread.default_constructor">Constructor from a <code class="computeroutput"><span class="identifier">thread</span></code></a></span></dt>
<dt><span class="section"><a href="ScopedThreads.html#thread.ScopedThreads.strict_scoped_thread.call_constructor">Move
Constructor from a Callable</a></span></dt>
<dt><span class="section"><a href="ScopedThreads.html#thread.ScopedThreads.strict_scoped_thread.destructor">Destructor</a></span></dt>
</dl></div>
<pre class="programlisting"><span class="comment">// #include &lt;boost/thread/scoped_thread.hpp&gt;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CallableThread</span> <span class="special">=</span> <span class="identifier">join_if_joinable</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Thread</span> <span class="special">=</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">thread</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">strict_scoped_thread</span>
<span class="special">{</span>
<span class="identifier">thread</span> <span class="identifier">t_</span><span class="special">;</span> <span class="comment">// for exposition purposes only</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="identifier">strict_scoped_thread</span><span class="special">(</span><span class="identifier">strict_scoped_thread</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="special">=</span> <span class="keyword">delete</span><span class="special">;</span>
<span class="identifier">strict_scoped_thread</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">strict_scoped_thread</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="special">=</span> <span class="keyword">delete</span><span class="special">;</span>
<span class="keyword">explicit</span> <span class="identifier">strict_scoped_thread</span><span class="special">(</span><span class="identifier">Thread</span><span class="special">&amp;&amp;</span> <span class="identifier">t</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">F</span><span class="special">&amp;&amp;,</span> <span class="keyword">typename</span> <span class="special">...</span><span class="identifier">Args</span><span class="special">&gt;</span>
<span class="keyword">explicit</span> <span class="identifier">strict_scoped_thread</span><span class="special">(</span><span class="identifier">F</span><span class="special">&amp;&amp;,</span> <span class="identifier">Args</span><span class="special">&amp;&amp;...);</span>
<span class="special">~</span><span class="identifier">strict_scoped_thread</span><span class="special">();</span>
<span class="special">};</span>
</pre>
<p>
RAII <a class="link" href="thread_management.html#thread.thread_management.thread" title="Class thread"><code class="computeroutput"><span class="identifier">thread</span></code></a>
wrapper adding a specific destroyer allowing to master what can be done at
destruction time.
</p>
<p>
CallableThread: A callable <code class="computeroutput"><span class="keyword">void</span><span class="special">(</span><span class="identifier">thread</span><span class="special">&amp;)</span></code>.
</p>
<p>
The default is a <code class="computeroutput"><span class="identifier">join_if_joinable</span></code>.
</p>
<p>
Thread destructor terminates the program if the <a class="link" href="thread_management.html#thread.thread_management.thread" title="Class thread"><code class="computeroutput"><span class="identifier">thread</span></code></a> is joinable. This wrapper
can be used to join the thread before destroying it.
</p>
<h5>
<a name="thread.ScopedThreads.strict_scoped_thread.h0"></a>
<span class="phrase"><a name="thread.ScopedThreads.strict_scoped_thread.example"></a></span><a class="link" href="ScopedThreads.html#thread.ScopedThreads.strict_scoped_thread.example">Example</a>
</h5>
<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">strict_scoped_thread</span><span class="special">&lt;&gt;</span> <span class="identifier">t</span><span class="special">((</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">thread</span><span class="special">(</span><span class="identifier">F</span><span class="special">)));</span>
</pre>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.ScopedThreads.strict_scoped_thread.default_constructor"></a>Constructor from a <a class="link" href="thread_management.html#thread.thread_management.thread" title="Class thread"><code class="computeroutput"><span class="identifier">thread</span></code></a>
</h4></div></div></div>
<pre class="programlisting"><span class="keyword">explicit</span> <span class="identifier">strict_scoped_thread</span><span class="special">(</span><span class="identifier">Thread</span><span class="special">&amp;&amp;</span> <span class="identifier">t</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Effects:</span></dt>
<dd><p>
move the thread to own <code class="computeroutput"><span class="identifier">t_</span></code>
</p></dd>
<dt><span class="term">Throws:</span></dt>
<dd><p>
Nothing
</p></dd>
</dl>
</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.ScopedThreads.strict_scoped_thread.call_constructor"></a><a class="link" href="ScopedThreads.html#thread.ScopedThreads.strict_scoped_thread.call_constructor" title="Move Constructor from a Callable">Move
Constructor from a Callable</a>
</h4></div></div></div>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">F</span><span class="special">&amp;&amp;,</span> <span class="keyword">typename</span> <span class="special">...</span><span class="identifier">Args</span><span class="special">&gt;</span>
<span class="keyword">explicit</span> <span class="identifier">strict_scoped_thread</span><span class="special">(</span><span class="identifier">F</span><span class="special">&amp;&amp;,</span> <span class="identifier">Args</span><span class="special">&amp;&amp;...);</span>
</pre>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Effects:</span></dt>
<dd><p>
Construct an internal thread in place.
</p></dd>
<dt><span class="term">Postconditions:</span></dt>
<dd><p>
<code class="computeroutput"><span class="special">*</span><span class="keyword">this</span><span class="special">.</span><span class="identifier">t_</span></code>
refers to the newly created thread of execution and <code class="computeroutput"><span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">get_id</span><span class="special">()!=</span><span class="identifier">thread</span><span class="special">::</span><span class="identifier">id</span><span class="special">()</span></code>.
</p></dd>
<dt><span class="term">Throws:</span></dt>
<dd><p>
Any exception the thread construction can throw.
</p></dd>
</dl>
</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.ScopedThreads.strict_scoped_thread.destructor"></a><a class="link" href="ScopedThreads.html#thread.ScopedThreads.strict_scoped_thread.destructor" title="Destructor">Destructor</a>
</h4></div></div></div>
<pre class="programlisting"><span class="special">~</span><span class="identifier">strict_scoped_thread</span><span class="special">();</span>
</pre>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Effects:</span></dt>
<dd><p>
Equivalent to <code class="computeroutput"><span class="identifier">CallableThread</span><span class="special">()(</span><span class="identifier">t_</span><span class="special">)</span></code>.
</p></dd>
<dt><span class="term">Throws:</span></dt>
<dd><p>
Nothing: The <code class="computeroutput"><span class="identifier">CallableThread</span><span class="special">()(</span><span class="identifier">t_</span><span class="special">)</span></code> should not throw when joining the
thread as the scoped variable is on a scope outside the thread function.
</p></dd>
</dl>
</div>
</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="thread.ScopedThreads.scoped_thread"></a><a class="link" href="ScopedThreads.html#thread.ScopedThreads.scoped_thread" title="Class scoped_thread">Class <code class="computeroutput"><span class="identifier">scoped_thread</span></code></a>
</h3></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.default_constructor">Default
Constructor</a></span></dt>
<dt><span class="section"><a href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.move_constructor">Move
Constructor</a></span></dt>
<dt><span class="section"><a href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.move_assignment">Move
assignment operator</a></span></dt>
<dt><span class="section"><a href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.thread_constructor">Move Constructor from a <code class="computeroutput"><span class="identifier">thread</span></code></a></span></dt>
<dt><span class="section"><a href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.call_constructor">Move
Constructor from a Callable</a></span></dt>
<dt><span class="section"><a href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.destructor">Destructor</a></span></dt>
<dt><span class="section"><a href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.joinable">Member
function <code class="computeroutput"><span class="identifier">joinable</span><span class="special">()</span></code></a></span></dt>
<dt><span class="section"><a href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.join">Member function
<code class="computeroutput"><span class="identifier">join</span><span class="special">()</span></code></a></span></dt>
<dt><span class="section"><a href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.try_join_for">Member
function <code class="computeroutput"><span class="identifier">try_join_for</span><span class="special">()</span></code></a></span></dt>
<dt><span class="section"><a href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.try_join_until">Member
function <code class="computeroutput"><span class="identifier">try_join_until</span><span class="special">()</span></code></a></span></dt>
<dt><span class="section"><a href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.detach">Member function
<code class="computeroutput"><span class="identifier">detach</span><span class="special">()</span></code></a></span></dt>
<dt><span class="section"><a href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.get_id">Member function
<code class="computeroutput"><span class="identifier">get_id</span><span class="special">()</span></code></a></span></dt>
<dt><span class="section"><a href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.interrupt">Member
function <code class="computeroutput"><span class="identifier">interrupt</span><span class="special">()</span></code></a></span></dt>
<dt><span class="section"><a href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.hardware_concurrency">Static
member function <code class="computeroutput"><span class="identifier">hardware_concurrency</span><span class="special">()</span></code></a></span></dt>
<dt><span class="section"><a href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.physical_concurrency">Static
member function <code class="computeroutput"><span class="identifier">physical_concurrency</span><span class="special">()</span></code></a></span></dt>
<dt><span class="section"><a href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.nativehandle">Member
function <code class="computeroutput"><span class="identifier">native_handle</span><span class="special">()</span></code></a></span></dt>
<dt><span class="section"><a href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.swap">Member function
<code class="computeroutput"><span class="identifier">swap</span><span class="special">()</span></code></a></span></dt>
</dl></div>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">thread</span><span class="special">/</span><span class="identifier">scoped_thread</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CallableThread</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Thread</span> <span class="special">=</span> <span class="identifier">thread</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">scoped_thread</span>
<span class="special">{</span>
<span class="identifier">thread</span> <span class="identifier">t_</span><span class="special">;</span> <span class="comment">// for exposition purposes only</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="identifier">scoped_thread</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="identifier">scoped_thread</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">scoped_thread</span><span class="special">&amp;)</span> <span class="special">=</span> <span class="keyword">delete</span><span class="special">;</span>
<span class="identifier">scoped_thread</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">scoped_thread</span><span class="special">&amp;)</span> <span class="special">=</span> <span class="keyword">delete</span><span class="special">;</span>
<span class="keyword">explicit</span> <span class="identifier">scoped_thread</span><span class="special">(</span><span class="identifier">thread</span><span class="special">&amp;&amp;</span> <span class="identifier">th</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">F</span><span class="special">&amp;&amp;,</span> <span class="keyword">typename</span> <span class="special">...</span><span class="identifier">Args</span><span class="special">&gt;</span>
<span class="keyword">explicit</span> <span class="identifier">scoped_thread</span><span class="special">(</span><span class="identifier">F</span><span class="special">&amp;&amp;,</span> <span class="identifier">Args</span><span class="special">&amp;&amp;...);</span>
<span class="special">~</span><span class="identifier">scoped_thread</span><span class="special">();</span>
<span class="comment">// move support</span>
<span class="identifier">scoped_thread</span><span class="special">(</span><span class="identifier">scoped_thread</span> <span class="special">&amp;&amp;</span> <span class="identifier">x</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="identifier">scoped_thread</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">scoped_thread</span> <span class="special">&amp;&amp;</span> <span class="identifier">x</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">scoped_thread</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">thread</span><span class="special">::</span><span class="identifier">id</span> <span class="identifier">id</span><span class="special">;</span>
<span class="identifier">id</span> <span class="identifier">get_id</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="keyword">bool</span> <span class="identifier">joinable</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="keyword">void</span> <span class="identifier">join</span><span class="special">();</span>
<span class="preprocessor">#ifdef</span> <span class="identifier">BOOST_THREAD_USES_CHRONO</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Rep</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Period</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">try_join_for</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">duration</span><span class="special">&lt;</span><span class="identifier">Rep</span><span class="special">,</span> <span class="identifier">Period</span><span class="special">&gt;&amp;</span> <span class="identifier">rel_time</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Duration</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">try_join_until</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span><span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span><span class="special">&gt;&amp;</span> <span class="identifier">t</span><span class="special">);</span>
<span class="preprocessor">#endif</span>
<span class="keyword">void</span> <span class="identifier">detach</span><span class="special">();</span>
<span class="keyword">static</span> <span class="keyword">unsigned</span> <span class="identifier">hardware_concurrency</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="keyword">static</span> <span class="keyword">unsigned</span> <span class="identifier">physical_concurrency</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">thread</span><span class="special">::</span><span class="identifier">native_handle_type</span> <span class="identifier">native_handle_type</span><span class="special">;</span>
<span class="identifier">native_handle_type</span> <span class="identifier">native_handle</span><span class="special">();</span>
<span class="preprocessor">#if</span> <span class="identifier">defined</span> <span class="identifier">BOOST_THREAD_PROVIDES_INTERRUPTIONS</span>
<span class="keyword">void</span> <span class="identifier">interrupt</span><span class="special">();</span>
<span class="keyword">bool</span> <span class="identifier">interruption_requested</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="preprocessor">#endif</span>
<span class="special">};</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CallableThread</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Thread</span> <span class="special">=</span> <span class="identifier">thread</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">scoped_thread</span><span class="special">&lt;</span><span class="identifier">CallableThread</span><span class="special">,</span><span class="identifier">Thread</span><span class="special">&gt;&amp;</span> <span class="identifier">lhs</span><span class="special">,</span><span class="identifier">scoped_thread</span><span class="special">&lt;</span><span class="identifier">CallableThread</span><span class="special">,</span><span class="identifier">Thread</span><span class="special">&gt;&amp;</span> <span class="identifier">rhs</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre>
<p>
RAII <a class="link" href="thread_management.html#thread.thread_management.thread" title="Class thread"><code class="computeroutput"><span class="identifier">thread</span></code></a>
wrapper adding a specific destroyer allowing to master what can be done at
destruction time.
</p>
<p>
CallableThread: A callable void(thread&amp;). The default is join_if_joinable.
</p>
<p>
Thread destructor terminates the program if the thread is joinable. This
wrapper can be used to join the thread before destroying it.
</p>
<p>
Remark: <code class="computeroutput"><span class="identifier">scoped_thread</span></code> is
not a <a class="link" href="thread_management.html#thread.thread_management.thread" title="Class thread"><code class="computeroutput"><span class="identifier">thread</span></code></a>
as <a class="link" href="thread_management.html#thread.thread_management.thread" title="Class thread"><code class="computeroutput"><span class="identifier">thread</span></code></a>
is not designed to be derived from as a polymorphic type.
</p>
<p>
Anyway <code class="computeroutput"><span class="identifier">scoped_thread</span></code> can
be used in most of the contexts a <a class="link" href="thread_management.html#thread.thread_management.thread" title="Class thread"><code class="computeroutput"><span class="identifier">thread</span></code></a> could be used as it has the
same non-deprecated interface with the exception of the construction.
</p>
<h5>
<a name="thread.ScopedThreads.scoped_thread.h0"></a>
<span class="phrase"><a name="thread.ScopedThreads.scoped_thread.example"></a></span><a class="link" href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.example">Example</a>
</h5>
<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">scoped_thread</span><span class="special">&lt;&gt;</span> <span class="identifier">t</span><span class="special">((</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">thread</span><span class="special">(</span><span class="identifier">F</span><span class="special">)));</span>
<span class="identifier">t</span><span class="special">.</span><span class="identifier">interrupt</span><span class="special">();</span>
</pre>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.ScopedThreads.scoped_thread.default_constructor"></a><a class="link" href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.default_constructor" title="Default Constructor">Default
Constructor</a>
</h4></div></div></div>
<pre class="programlisting"><span class="identifier">scoped_thread</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Effects:</span></dt>
<dd><p>
Constructs a scoped_thread instance that wraps to <span class="emphasis"><em>Not-a-Thread</em></span>.
</p></dd>
<dt><span class="term">Postconditions:</span></dt>
<dd><p>
<code class="computeroutput"><span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">get_id</span><span class="special">()==</span><span class="identifier">thread</span><span class="special">::</span><span class="identifier">id</span><span class="special">()</span></code>
</p></dd>
<dt><span class="term">Throws:</span></dt>
<dd><p>
Nothing
</p></dd>
</dl>
</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.ScopedThreads.scoped_thread.move_constructor"></a><a class="link" href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.move_constructor" title="Move Constructor">Move
Constructor</a>
</h4></div></div></div>
<pre class="programlisting"><span class="identifier">scoped_thread</span><span class="special">(</span><span class="identifier">scoped_thread</span><span class="special">&amp;&amp;</span> <span class="identifier">other</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Effects:</span></dt>
<dd><p>
Transfers ownership of the scoped_thread managed by <code class="computeroutput"><span class="identifier">other</span></code> (if any) to the newly constructed
scoped_thread instance.
</p></dd>
<dt><span class="term">Postconditions:</span></dt>
<dd><p>
<code class="computeroutput"><span class="identifier">other</span><span class="special">.</span><span class="identifier">get_id</span><span class="special">()==</span><span class="identifier">thread</span><span class="special">::</span><span class="identifier">id</span><span class="special">()</span></code>
and <code class="computeroutput"><span class="identifier">get_id</span><span class="special">()</span></code>
returns the value of <code class="computeroutput"><span class="identifier">other</span><span class="special">.</span><span class="identifier">get_id</span><span class="special">()</span></code> prior to the construction
</p></dd>
<dt><span class="term">Throws:</span></dt>
<dd><p>
Nothing
</p></dd>
</dl>
</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.ScopedThreads.scoped_thread.move_assignment"></a><a class="link" href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.move_assignment" title="Move assignment operator">Move
assignment operator</a>
</h4></div></div></div>
<pre class="programlisting"><span class="identifier">scoped_thread</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">scoped_thread</span><span class="special">&amp;&amp;</span> <span class="identifier">other</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Effects:</span></dt>
<dd><p>
Transfers ownership of the scoped_thread managed by <code class="computeroutput"><span class="identifier">other</span></code> (if any) to <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>
after having called to <code class="computeroutput"><span class="identifier">CallableThread</span><span class="special">()(</span><span class="identifier">t_</span><span class="special">)</span></code>.
</p></dd>
<dt><span class="term">Postconditions:</span></dt>
<dd><p>
<code class="computeroutput"><span class="identifier">other</span><span class="special">-&gt;</span><span class="identifier">get_id</span><span class="special">()==</span><span class="identifier">thread</span><span class="special">::</span><span class="identifier">id</span><span class="special">()</span></code>
and <code class="computeroutput"><span class="identifier">get_id</span><span class="special">()</span></code>
returns the value of <code class="computeroutput"><span class="identifier">other</span><span class="special">.</span><span class="identifier">get_id</span><span class="special">()</span></code> prior to the assignment.
</p></dd>
<dt><span class="term">Throws:</span></dt>
<dd><p>
Nothing: The <code class="computeroutput"><span class="identifier">CallableThread</span><span class="special">()(</span><span class="identifier">t_</span><span class="special">)</span></code> should not throw when joining the
thread as the scoped variable is on a scope outside the thread function.
</p></dd>
</dl>
</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.ScopedThreads.scoped_thread.thread_constructor"></a>Move Constructor from a <a class="link" href="thread_management.html#thread.thread_management.thread" title="Class thread"><code class="computeroutput"><span class="identifier">thread</span></code></a>
</h4></div></div></div>
<pre class="programlisting"><span class="identifier">scoped_thread</span><span class="special">(</span><span class="identifier">thread</span><span class="special">&amp;&amp;</span> <span class="identifier">t</span><span class="special">);</span>
</pre>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Effects:</span></dt>
<dd><p>
Transfers ownership of the thread managed by <code class="computeroutput"><span class="identifier">other</span></code>
(if any) to the newly constructed scoped_thread instance.
</p></dd>
<dt><span class="term">Postconditions:</span></dt>
<dd><p>
other.get_id()==thread::id() and get_id() returns the value of other.get_id()
prior to the construction.
</p></dd>
<dt><span class="term">Throws:</span></dt>
<dd><p>
Nothing
</p></dd>
</dl>
</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.ScopedThreads.scoped_thread.call_constructor"></a><a class="link" href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.call_constructor" title="Move Constructor from a Callable">Move
Constructor from a Callable</a>
</h4></div></div></div>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">F</span><span class="special">&amp;&amp;,</span> <span class="keyword">typename</span> <span class="special">...</span><span class="identifier">Args</span><span class="special">&gt;</span>
<span class="keyword">explicit</span> <span class="identifier">scoped_thread</span><span class="special">(</span><span class="identifier">F</span><span class="special">&amp;&amp;,</span> <span class="identifier">Args</span><span class="special">&amp;&amp;...);</span>
</pre>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Effects:</span></dt>
<dd><p>
Construct an internal thread in place.
</p></dd>
<dt><span class="term">Postconditions:</span></dt>
<dd><p>
<code class="computeroutput"><span class="special">*</span><span class="keyword">this</span><span class="special">.</span><span class="identifier">t_</span></code>
refers to the newly created thread of execution and <code class="computeroutput"><span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">get_id</span><span class="special">()!=</span><span class="identifier">thread</span><span class="special">::</span><span class="identifier">id</span><span class="special">()</span></code>.
</p></dd>
<dt><span class="term">Throws:</span></dt>
<dd><p>
Any exception the thread construction can throw.
</p></dd>
</dl>
</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.ScopedThreads.scoped_thread.destructor"></a><a class="link" href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.destructor" title="Destructor">Destructor</a>
</h4></div></div></div>
<pre class="programlisting"><span class="special">~</span><span class="identifier">scoped_thread</span><span class="special">();</span>
</pre>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Effects:</span></dt>
<dd><p>
Equivalent to <code class="computeroutput"><span class="identifier">CallableThread</span><span class="special">()(</span><span class="identifier">t_</span><span class="special">)</span></code>.
</p></dd>
<dt><span class="term">Throws:</span></dt>
<dd><p>
Nothing: The <code class="computeroutput"><span class="identifier">CallableThread</span><span class="special">()(</span><span class="identifier">t_</span><span class="special">)</span></code> should not throw when joining the
thread as the scoped variable is on a scope outside the thread function.
</p></dd>
</dl>
</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.ScopedThreads.scoped_thread.joinable"></a><a class="link" href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.joinable" title="Member function joinable()">Member
function <code class="computeroutput"><span class="identifier">joinable</span><span class="special">()</span></code></a>
</h4></div></div></div>
<pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">joinable</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Returns:</span></dt>
<dd><p>
Equivalent to return t_.joinable().
</p></dd>
<dt><span class="term">Throws:</span></dt>
<dd><p>
Nothing
</p></dd>
</dl>
</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.ScopedThreads.scoped_thread.join"></a><a class="link" href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.join" title="Member function join()">Member function
<code class="computeroutput"><span class="identifier">join</span><span class="special">()</span></code></a>
</h4></div></div></div>
<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">join</span><span class="special">();</span>
</pre>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Effects:</span></dt>
<dd><p>
Equivalent to t_.join().
</p></dd>
</dl>
</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.ScopedThreads.scoped_thread.try_join_for"></a><a class="link" href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.try_join_for" title="Member function try_join_for()">Member
function <code class="computeroutput"><span class="identifier">try_join_for</span><span class="special">()</span></code></a>
</h4></div></div></div>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Rep</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Period</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">try_join_for</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">duration</span><span class="special">&lt;</span><span class="identifier">Rep</span><span class="special">,</span> <span class="identifier">Period</span><span class="special">&gt;&amp;</span> <span class="identifier">rel_time</span><span class="special">);</span>
</pre>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Effects:</span></dt>
<dd><p>
Equivalent to return <code class="computeroutput"><span class="identifier">t_</span><span class="special">.</span><span class="identifier">try_join_for</span><span class="special">(</span><span class="identifier">rel_time</span><span class="special">)</span></code>.
</p></dd>
</dl>
</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.ScopedThreads.scoped_thread.try_join_until"></a><a class="link" href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.try_join_until" title="Member function try_join_until()">Member
function <code class="computeroutput"><span class="identifier">try_join_until</span><span class="special">()</span></code></a>
</h4></div></div></div>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Duration</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">try_join_until</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span><span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span><span class="special">&gt;&amp;</span> <span class="identifier">abs_time</span><span class="special">);</span>
</pre>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Effects:</span></dt>
<dd><p>
Equivalent to return <code class="computeroutput"><span class="identifier">t_</span><span class="special">.</span><span class="identifier">try_join_until</span><span class="special">(</span><span class="identifier">abs_time</span><span class="special">)</span></code>.
</p></dd>
</dl>
</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.ScopedThreads.scoped_thread.detach"></a><a class="link" href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.detach" title="Member function detach()">Member function
<code class="computeroutput"><span class="identifier">detach</span><span class="special">()</span></code></a>
</h4></div></div></div>
<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">detach</span><span class="special">();</span>
</pre>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Effects:</span></dt>
<dd><p>
Equivalent to <code class="computeroutput"><span class="identifier">t_</span><span class="special">.</span><span class="identifier">detach</span><span class="special">()</span></code>.
</p></dd>
</dl>
</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.ScopedThreads.scoped_thread.get_id"></a><a class="link" href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.get_id" title="Member function get_id()">Member function
<code class="computeroutput"><span class="identifier">get_id</span><span class="special">()</span></code></a>
</h4></div></div></div>
<pre class="programlisting"><span class="identifier">thread</span><span class="special">::</span><span class="identifier">id</span> <span class="identifier">get_id</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Effects:</span></dt>
<dd><p>
Equivalent to return <code class="computeroutput"><span class="identifier">t_</span><span class="special">.</span><span class="identifier">get_id</span><span class="special">()</span></code>.
</p></dd>
</dl>
</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.ScopedThreads.scoped_thread.interrupt"></a><a class="link" href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.interrupt" title="Member function interrupt()">Member
function <code class="computeroutput"><span class="identifier">interrupt</span><span class="special">()</span></code></a>
</h4></div></div></div>
<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">interrupt</span><span class="special">();</span>
</pre>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Effects:</span></dt>
<dd><p>
Equivalent to <code class="computeroutput"><span class="identifier">t_</span><span class="special">.</span><span class="identifier">interrupt</span><span class="special">()</span></code>.
</p></dd>
</dl>
</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.ScopedThreads.scoped_thread.hardware_concurrency"></a><a class="link" href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.hardware_concurrency" title="Static member function hardware_concurrency()">Static
member function <code class="computeroutput"><span class="identifier">hardware_concurrency</span><span class="special">()</span></code></a>
</h4></div></div></div>
<pre class="programlisting"><span class="keyword">unsigned</span> <span class="identifier">hardware_concurrency</span><span class="special">()</span> <span class="identifier">noexecpt</span><span class="special">;</span>
</pre>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Effects:</span></dt>
<dd><p>
Equivalent to return <code class="computeroutput"><span class="identifier">thread</span><span class="special">::</span><span class="identifier">hardware_concurrency</span><span class="special">()</span></code>.
</p></dd>
</dl>
</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.ScopedThreads.scoped_thread.physical_concurrency"></a><a class="link" href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.physical_concurrency" title="Static member function physical_concurrency()">Static
member function <code class="computeroutput"><span class="identifier">physical_concurrency</span><span class="special">()</span></code></a>
</h4></div></div></div>
<pre class="programlisting"><span class="keyword">unsigned</span> <span class="identifier">physical_concurrency</span><span class="special">()</span> <span class="identifier">noexecpt</span><span class="special">;</span>
</pre>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Effects:</span></dt>
<dd><p>
Equivalent to return <code class="computeroutput"><span class="identifier">thread</span><span class="special">::</span><span class="identifier">physical_concurrency</span><span class="special">()</span></code>.
</p></dd>
</dl>
</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.ScopedThreads.scoped_thread.nativehandle"></a><a class="link" href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.nativehandle" title="Member function native_handle()">Member
function <code class="computeroutput"><span class="identifier">native_handle</span><span class="special">()</span></code></a>
</h4></div></div></div>
<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">thread</span><span class="special">::</span><span class="identifier">native_handle_type</span> <span class="identifier">native_handle_type</span><span class="special">;</span>
<span class="identifier">native_handle_type</span> <span class="identifier">native_handle</span><span class="special">();</span>
</pre>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Effects:</span></dt>
<dd><p>
Equivalent to return <code class="computeroutput"><span class="identifier">t_</span><span class="special">.</span><span class="identifier">native_handle</span><span class="special">()</span></code>.
</p></dd>
</dl>
</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.ScopedThreads.scoped_thread.swap"></a><a class="link" href="ScopedThreads.html#thread.ScopedThreads.scoped_thread.swap" title="Member function swap()">Member function
<code class="computeroutput"><span class="identifier">swap</span><span class="special">()</span></code></a>
</h4></div></div></div>
<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">scoped_thread</span><span class="special">&amp;</span> <span class="identifier">other</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Effects:</span></dt>
<dd><p>
Equivalent <code class="computeroutput"><span class="identifier">t_</span><span class="special">.</span><span class="identifier">swap</span><span class="special">(</span><span class="identifier">other</span><span class="special">.</span><span class="identifier">t_</span><span class="special">)</span></code>.
</p></dd>
</dl>
</div>
</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="thread.ScopedThreads.non_member_swap"></a><a class="link" href="ScopedThreads.html#thread.ScopedThreads.non_member_swap" title="Non-member function swap(scoped_thread&amp;,scoped_thread&amp;)">Non-member function
<code class="computeroutput"><span class="identifier">swap</span><span class="special">(</span><span class="identifier">scoped_thread</span><span class="special">&amp;,</span><span class="identifier">scoped_thread</span><span class="special">&amp;)</span></code></a>
</h3></div></div></div>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">thread</span><span class="special">/</span><span class="identifier">scoped_thread</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CallableThread</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Thread</span> <span class="special">=</span> <span class="identifier">thread</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">scoped_thread</span><span class="special">&lt;</span><span class="identifier">Callable</span><span class="special">,</span> <span class="identifier">Thread</span><span class="special">&gt;&amp;</span> <span class="identifier">lhs</span><span class="special">,</span> <span class="identifier">scoped_threadCallable</span><span class="special">,</span> <span class="identifier">Thread</span><span class="special">&gt;&amp;</span> <span class="identifier">rhs</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Effects:</span></dt>
<dd><p>
<code class="computeroutput"><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">swap</span><span class="special">(</span><span class="identifier">rhs</span><span class="special">)</span></code>.
</p></dd>
</dl>
</div>
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2007 -11 Anthony Williams<br>Copyright © 2011 -17 Vicente J. Botet Escriba<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="thread_management.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../thread.html"><img src="../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="synchronization.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,67 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Acknowledgments</title>
<link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
<link rel="up" href="../thread.html" title="Chapter 40. Thread 4.8.0">
<link rel="prev" href="emulations.html" title="Emulations">
<link rel="next" href="compliance.html" title="Conformance and Extension">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
<td align="center"><a href="../../../index.html">Home</a></td>
<td align="center"><a href="../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="emulations.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../thread.html"><img src="../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="compliance.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="thread.acknowledgements"></a><a class="link" href="acknowledgements.html" title="Acknowledgments">Acknowledgments</a>
</h2></div></div></div>
<p>
The original implementation of <span class="bold"><strong>Boost.Thread</strong></span>
was written by William Kempf, with contributions from numerous others. This
new version initially grew out of an attempt to rewrite <span class="bold"><strong>Boost.Thread</strong></span>
to William Kempf's design with fresh code that could be released under the
Boost Software License. However, as the C++ Standards committee have been actively
discussing standardizing a thread library for C++, this library has evolved
to reflect the proposals, whilst retaining as much backwards-compatibility
as possible.
</p>
<p>
Particular thanks must be given to Roland Schwarz, who contributed a lot of
time and code to the original <span class="bold"><strong>Boost.Thread</strong></span>
library, and who has been actively involved with the rewrite. The scheme for
dividing the platform-specific implementations into separate directories was
devised by Roland, and his input has contributed greatly to improving the quality
of the current implementation.
</p>
<p>
Thanks also must go to Peter Dimov, Howard Hinnant, Alexander Terekhov, Chris
Thomasson and others for their comments on the implementation details of the
code.
</p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2007 -11 Anthony Williams<br>Copyright © 2011 -17 Vicente J. Botet Escriba<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="emulations.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../thread.html"><img src="../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="compliance.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

1620
doc/html/thread/build.html Normal file

File diff suppressed because it is too large Load Diff

2523
doc/html/thread/changes.html Normal file

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@@ -0,0 +1,612 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Emulations</title>
<link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
<link rel="up" href="../thread.html" title="Chapter 40. Thread 4.8.0">
<link rel="prev" href="time.html" title="Time Requirements">
<link rel="next" href="acknowledgements.html" title="Acknowledgments">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
<td align="center"><a href="../../../index.html">Home</a></td>
<td align="center"><a href="../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="time.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../thread.html"><img src="../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="acknowledgements.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="thread.emulations"></a><a class="link" href="emulations.html" title="Emulations">Emulations</a>
</h2></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="emulations.html#thread.emulations.delete"><code class="computeroutput"><span class="special">=</span><span class="keyword">delete</span></code> emulation</a></span></dt>
<dt><span class="section"><a href="emulations.html#thread.emulations.move">Move semantics</a></span></dt>
<dt><span class="section"><a href="emulations.html#thread.emulations.bool_explicit_conversion">Bool explicit
conversion</a></span></dt>
<dt><span class="section"><a href="emulations.html#thread.emulations.scoped_enums">Scoped Enums</a></span></dt>
</dl></div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="thread.emulations.delete"></a><a class="link" href="emulations.html#thread.emulations.delete" title="=delete emulation"><code class="computeroutput"><span class="special">=</span><span class="keyword">delete</span></code> emulation</a>
</h3></div></div></div>
<p>
C++11 allows to delete some implicitly generated functions as constructors
and assignment using '= delete' as in
</p>
<pre class="programlisting"><span class="keyword">public</span><span class="special">:</span>
<span class="identifier">thread</span><span class="special">(</span><span class="identifier">thread</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="special">=</span> <span class="keyword">delete</span><span class="special">;</span>
</pre>
<p>
On compilers not supporting this feature, Boost.Thread relays on a partial
simulation, it declares the function as private without definition.
</p>
<pre class="programlisting"><span class="keyword">private</span><span class="special">:</span>
<span class="identifier">thread</span><span class="special">(</span><span class="identifier">thread</span> <span class="special">&amp;);</span>
</pre>
<p>
The emulation is partial as the private function can be used for overload
resolution for some compilers and prefer it to other overloads that need
a conversion. See below the consequences on the move semantic emulation.
</p>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="thread.emulations.move"></a><a class="link" href="emulations.html#thread.emulations.move" title="Move semantics">Move semantics</a>
</h3></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="emulations.html#thread.emulations.move.deprecated">Deprecated Version
2 interface</a></span></dt>
<dt><span class="section"><a href="emulations.html#thread.emulations.move.portable">Portable interface</a></span></dt>
</dl></div>
<p>
In order to implement Movable classes, move parameters and return types Boost.Thread
uses the rvalue reference when the compiler support it. On compilers not
supporting it Boost.Thread uses either the emulation provided by Boost.Move
or the emulation provided by the previous versions of Boost.Thread depending
whether <code class="computeroutput"><span class="identifier">BOOST_THREAD_USES_MOVE</span></code>
is defined or not. This macros is unset by default when <code class="computeroutput"><span class="identifier">BOOST_THREAD_VERSION</span></code>
is 2. Since <code class="computeroutput"><span class="identifier">BOOST_THREAD_VERSION</span></code>
3, <code class="computeroutput"><span class="identifier">BOOST_THREAD_USES_MOVE</span></code>
is defined.
</p>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.emulations.move.deprecated"></a><a class="link" href="emulations.html#thread.emulations.move.deprecated" title="Deprecated Version 2 interface">Deprecated Version
2 interface</a>
</h4></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="emulations.html#thread.emulations.move.deprecated.Helper">Helpers
class and function</a></span></dt>
<dt><span class="section"><a href="emulations.html#thread.emulations.move.deprecated.movable">Movable
emulation</a></span></dt>
</dl></div>
<p>
Previous to version 1.50, Boost.Thread make use of its own move semantic
emulation which had more limitations than the provided by Boost.Move. In
addition, it is of interest of the whole Boost community that Boost.Thread
uses Boost.Move so that boost::thread can be stored on Movable aware containers.
</p>
<p>
To preserve backward compatibility at least during some releases, Boost.Thread
allows the user to use the deprecated move semantic emulation defining
BOOST_THREAD_DONT_USE_MOVE.
</p>
<p>
Many aspects of move semantics can be emulated for compilers not supporting
rvalue references and Boost.Thread legacy offers tools for that purpose.
</p>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="thread.emulations.move.deprecated.Helper"></a><a class="link" href="emulations.html#thread.emulations.move.deprecated.Helper" title="Helpers class and function">Helpers
class and function</a>
</h5></div></div></div>
<p>
Next follows the interface of the legacy move semantic helper class and
function.
</p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>
<span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">detail</span>
<span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">thread_move_t</span>
<span class="special">{</span>
<span class="keyword">explicit</span> <span class="identifier">thread_move_t</span><span class="special">(</span><span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">t_</span><span class="special">);</span>
<span class="identifier">T</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">*()</span> <span class="keyword">const</span><span class="special">;</span>
<span class="identifier">T</span><span class="special">*</span> <span class="keyword">operator</span><span class="special">-&gt;()</span> <span class="keyword">const</span><span class="special">;</span>
<span class="keyword">private</span><span class="special">:</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">thread_move_t</span><span class="special">&amp;);</span>
<span class="special">};</span>
<span class="special">}</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">thread_move_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">move</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">thread_move_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">t</span><span class="special">);</span>
<span class="special">}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="thread.emulations.move.deprecated.movable"></a><a class="link" href="emulations.html#thread.emulations.move.deprecated.movable" title="Movable emulation">Movable
emulation</a>
</h5></div></div></div>
<p>
We can write a MovableOny class as follows. You just need to follow these
simple steps:
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
Add a conversion to the <code class="computeroutput"><span class="identifier">detail</span><span class="special">::</span><span class="identifier">thread_move_t</span><span class="special">&lt;</span><span class="identifier">classname</span><span class="special">&gt;</span></code>
</li>
<li class="listitem">
Make the copy constructor private.
</li>
<li class="listitem">
Write a constructor taking the parameter as <code class="computeroutput"><span class="identifier">detail</span><span class="special">::</span><span class="identifier">thread_move_t</span><span class="special">&lt;</span><span class="identifier">classname</span><span class="special">&gt;</span></code>
</li>
<li class="listitem">
Write an assignment taking the parameter as <code class="computeroutput"><span class="identifier">detail</span><span class="special">::</span><span class="identifier">thread_move_t</span><span class="special">&lt;</span><span class="identifier">classname</span><span class="special">&gt;</span></code>
</li>
</ul></div>
<p>
For example the thread class defines the following:
</p>
<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">thread</span>
<span class="special">{</span>
<span class="comment">// ...</span>
<span class="keyword">private</span><span class="special">:</span>
<span class="identifier">thread</span><span class="special">(</span><span class="identifier">thread</span><span class="special">&amp;);</span>
<span class="identifier">thread</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">thread</span><span class="special">&amp;);</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="identifier">detail</span><span class="special">::</span><span class="identifier">thread_move_t</span><span class="special">&lt;</span><span class="identifier">thread</span><span class="special">&gt;</span> <span class="identifier">move</span><span class="special">()</span>
<span class="special">{</span>
<span class="identifier">detail</span><span class="special">::</span><span class="identifier">thread_move_t</span><span class="special">&lt;</span><span class="identifier">thread</span><span class="special">&gt;</span> <span class="identifier">x</span><span class="special">(*</span><span class="keyword">this</span><span class="special">);</span>
<span class="keyword">return</span> <span class="identifier">x</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">operator</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">thread_move_t</span><span class="special">&lt;</span><span class="identifier">thread</span><span class="special">&gt;()</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">move</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">thread</span><span class="special">(</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">thread_move_t</span><span class="special">&lt;</span><span class="identifier">thread</span><span class="special">&gt;</span> <span class="identifier">x</span><span class="special">)</span>
<span class="special">{</span>
<span class="identifier">thread_info</span><span class="special">=</span><span class="identifier">x</span><span class="special">-&gt;</span><span class="identifier">thread_info</span><span class="special">;</span>
<span class="identifier">x</span><span class="special">-&gt;</span><span class="identifier">thread_info</span><span class="special">.</span><span class="identifier">reset</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">thread</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">thread_move_t</span><span class="special">&lt;</span><span class="identifier">thread</span><span class="special">&gt;</span> <span class="identifier">x</span><span class="special">)</span>
<span class="special">{</span>
<span class="identifier">thread</span> <span class="identifier">new_thread</span><span class="special">(</span><span class="identifier">x</span><span class="special">);</span>
<span class="identifier">swap</span><span class="special">(</span><span class="identifier">new_thread</span><span class="special">);</span>
<span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span>
<span class="special">}</span>
<span class="comment">// ...</span>
<span class="special">};</span>
</pre>
</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.emulations.move.portable"></a><a class="link" href="emulations.html#thread.emulations.move.portable" title="Portable interface">Portable interface</a>
</h4></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="emulations.html#thread.emulations.move.portable.NO_COPYABLE"><code class="computeroutput"><span class="identifier">BOOST_THREAD_NO_COPYABLE</span><span class="special">(</span><span class="identifier">CLASS</span><span class="special">)</span></code></a></span></dt>
<dt><span class="section"><a href="emulations.html#thread.emulations.move.portable.MOVABLE"><code class="computeroutput"><span class="identifier">BOOST_THREAD_MOVABLE</span><span class="special">(</span><span class="identifier">CLASS</span><span class="special">)</span></code></a></span></dt>
<dt><span class="section"><a href="emulations.html#thread.emulations.move.portable.MOVABLE_ONLY"><code class="computeroutput"><span class="identifier">BOOST_THREAD_MOVABLE_ONLY</span><span class="special">(</span><span class="identifier">CLASS</span><span class="special">)</span></code></a></span></dt>
<dt><span class="section"><a href="emulations.html#thread.emulations.move.portable.COPYABLE_AND_MOVABLE"><code class="computeroutput"><span class="identifier">BOOST_THREAD_COPYABLE_AND_MOVABLE</span><span class="special">(</span><span class="identifier">CLASS</span><span class="special">)</span></code></a></span></dt>
<dt><span class="section"><a href="emulations.html#thread.emulations.move.portable.RV_REF"><code class="computeroutput"><span class="identifier">BOOST_THREAD_RV_REF</span><span class="special">(</span><span class="identifier">TYPE</span><span class="special">)</span></code>,
<code class="computeroutput"><span class="identifier">BOOST_THREAD_RV_REF_BEG</span></code>
and <code class="computeroutput"><span class="identifier">BOOST_THREAD_RV_REF_END</span></code></a></span></dt>
<dt><span class="section"><a href="emulations.html#thread.emulations.move.portable.RV"><code class="computeroutput"><span class="identifier">BOOST_THREAD_RV</span><span class="special">(</span><span class="identifier">V</span><span class="special">)</span></code></a></span></dt>
<dt><span class="section"><a href="emulations.html#thread.emulations.move.portable.MAKE_RV_REF"><code class="computeroutput"><span class="identifier">BOOST_THREAD_MAKE_RV_REF</span><span class="special">(</span><span class="identifier">RVALUE</span><span class="special">)</span></code></a></span></dt>
<dt><span class="section"><a href="emulations.html#thread.emulations.move.portable.DCL_MOVABLE"><code class="computeroutput"><span class="identifier">BOOST_THREAD_DCL_MOVABLE</span></code>, <code class="computeroutput"><span class="identifier">BOOST_THREAD_DCL_MOVABLE_BEG</span><span class="special">(</span><span class="identifier">T1</span><span class="special">)</span></code> and
<code class="computeroutput"><span class="identifier">BOOST_THREAD_DCL_MOVABLE_END</span></code></a></span></dt>
</dl></div>
<p>
In order to make the library code portable Boost.Thread uses some macros
that will use either the ones provided by Boost.Move or the deprecated
move semantics provided by previous versions of Boost.Thread.
</p>
<p>
See the Boost.Move documentation for a complete description on how to declare
new Movable classes and its limitations.
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
<code class="computeroutput"><span class="identifier">BOOST_THREAD_RV_REF</span><span class="special">(</span><span class="identifier">TYPE</span><span class="special">)</span></code> is the equivalent of <code class="computeroutput"><span class="identifier">BOOST_RV_REF</span><span class="special">(</span><span class="identifier">TYPE</span><span class="special">)</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">BOOST_THREAD_RV_REF_BEG</span></code>
is the equivalent of <code class="computeroutput"><span class="identifier">BOOST_RV_REF_BEG</span><span class="special">(</span><span class="identifier">TYPE</span><span class="special">)</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">BOOST_THREAD_RV_REF_END</span></code>
is the equivalent of <code class="computeroutput"><span class="identifier">BOOST_RV_REF_END</span><span class="special">(</span><span class="identifier">TYPE</span><span class="special">)</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">BOOST_THREAD_FWD_REF</span><span class="special">(</span><span class="identifier">TYPE</span><span class="special">)</span></code> is the equivalent of `BOOST_FWD_REF(TYPE)
</li>
</ul></div>
<p>
In addition the following macros are needed to make the code portable:
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
<code class="computeroutput"><span class="identifier">BOOST_THREAD_RV</span><span class="special">(</span><span class="identifier">V</span><span class="special">)</span></code>
macro to access the rvalue from a BOOST_THREAD_RV_REF(TYPE),
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">BOOST_THREAD_MAKE_RV_REF</span><span class="special">(</span><span class="identifier">RVALUE</span><span class="special">)</span></code> makes a rvalue.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">BOOST_THREAD_DCL_MOVABLE</span><span class="special">(</span><span class="identifier">CLASS</span><span class="special">)</span></code> to avoid conflicts with Boost.Move
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">BOOST_THREAD_DCL_MOVABLE_BEG</span><span class="special">(</span><span class="identifier">T1</span><span class="special">)</span></code> and <code class="computeroutput"><span class="identifier">BOOST_THREAD_DCL_MOVABLE_END</span></code>
are variant of <code class="computeroutput"><span class="identifier">BOOST_THREAD_DCL_MOVABLE</span></code>
when the parameter is a template instantiation.
</li>
</ul></div>
<p>
Other macros are provided and must be included on the public section:
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
<code class="computeroutput"><span class="identifier">BOOST_THREAD_NO_COPYABLE</span></code>
declares a class no-copyable either deleting the copy constructors
and copy assignment or moving them to the private section.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">BOOST_THREAD_MOVABLE</span><span class="special">(</span><span class="identifier">CLASS</span><span class="special">)</span></code> declares all the implicit conversions
to an rvalue-reference.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">BOOST_THREAD_MOVABLE_ONLY</span><span class="special">(</span><span class="identifier">CLASS</span><span class="special">)</span></code> is the equivalent of <code class="computeroutput"><span class="identifier">BOOST_MOVABLE_BUT_NOT_COPYABLE</span><span class="special">(</span><span class="identifier">CLASS</span><span class="special">)</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">BOOST_THREAD_COPYABLE_AND_MOVABLE</span><span class="special">(</span><span class="identifier">CLASS</span><span class="special">)</span></code> is the equivalent of <code class="computeroutput"><span class="identifier">BOOST_COPYABLE_AND_MOVABLE</span><span class="special">(</span><span class="identifier">CLASS</span><span class="special">)</span></code>
</li>
</ul></div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="thread.emulations.move.portable.NO_COPYABLE"></a><a class="link" href="emulations.html#thread.emulations.move.portable.NO_COPYABLE" title="BOOST_THREAD_NO_COPYABLE(CLASS)"><code class="computeroutput"><span class="identifier">BOOST_THREAD_NO_COPYABLE</span><span class="special">(</span><span class="identifier">CLASS</span><span class="special">)</span></code></a>
</h5></div></div></div>
<p>
This macro marks a class as no copyable, disabling copy construction
and assignment.
</p>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="thread.emulations.move.portable.MOVABLE"></a><a class="link" href="emulations.html#thread.emulations.move.portable.MOVABLE" title="BOOST_THREAD_MOVABLE(CLASS)"><code class="computeroutput"><span class="identifier">BOOST_THREAD_MOVABLE</span><span class="special">(</span><span class="identifier">CLASS</span><span class="special">)</span></code></a>
</h5></div></div></div>
<p>
This macro marks a class as movable, declaring all the implicit conversions
to an rvalue-reference.
</p>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="thread.emulations.move.portable.MOVABLE_ONLY"></a><a class="link" href="emulations.html#thread.emulations.move.portable.MOVABLE_ONLY" title="BOOST_THREAD_MOVABLE_ONLY(CLASS)"><code class="computeroutput"><span class="identifier">BOOST_THREAD_MOVABLE_ONLY</span><span class="special">(</span><span class="identifier">CLASS</span><span class="special">)</span></code></a>
</h5></div></div></div>
<p>
This macro marks a type as movable but not copyable, disabling copy construction
and assignment. The user will need to write a move constructor/assignment
to fully write a movable but not copyable class.
</p>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="thread.emulations.move.portable.COPYABLE_AND_MOVABLE"></a><a class="link" href="emulations.html#thread.emulations.move.portable.COPYABLE_AND_MOVABLE" title="BOOST_THREAD_COPYABLE_AND_MOVABLE(CLASS)"><code class="computeroutput"><span class="identifier">BOOST_THREAD_COPYABLE_AND_MOVABLE</span><span class="special">(</span><span class="identifier">CLASS</span><span class="special">)</span></code></a>
</h5></div></div></div>
<p>
This macro marks a type as copyable and movable. The user will need to
write a move constructor/assignment and a copy assignment to fully write
a copyable and movable class.
</p>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="thread.emulations.move.portable.RV_REF"></a><a class="link" href="emulations.html#thread.emulations.move.portable.RV_REF" title="BOOST_THREAD_RV_REF(TYPE), BOOST_THREAD_RV_REF_BEG and BOOST_THREAD_RV_REF_END"><code class="computeroutput"><span class="identifier">BOOST_THREAD_RV_REF</span><span class="special">(</span><span class="identifier">TYPE</span><span class="special">)</span></code>,
<code class="computeroutput"><span class="identifier">BOOST_THREAD_RV_REF_BEG</span></code>
and <code class="computeroutput"><span class="identifier">BOOST_THREAD_RV_REF_END</span></code></a>
</h5></div></div></div>
<p>
This macro is used to achieve portable syntax in move constructors and
assignments for classes marked as <code class="computeroutput"><span class="identifier">BOOST_THREAD_COPYABLE_AND_MOVABLE</span></code>
or <code class="computeroutput"><span class="identifier">BOOST_THREAD_MOVABLE_ONLY</span></code>.
</p>
<p>
<code class="computeroutput"><span class="identifier">BOOST_THREAD_RV_REF_BEG</span></code>
and <code class="computeroutput"><span class="identifier">BOOST_THREAD_RV_REF_END</span></code>
are used when the parameter end with a <code class="computeroutput"><span class="special">&gt;</span></code>
to avoid the compiler error.
</p>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="thread.emulations.move.portable.RV"></a><a class="link" href="emulations.html#thread.emulations.move.portable.RV" title="BOOST_THREAD_RV(V)"><code class="computeroutput"><span class="identifier">BOOST_THREAD_RV</span><span class="special">(</span><span class="identifier">V</span><span class="special">)</span></code></a>
</h5></div></div></div>
<p>
While Boost.Move emulation allows to access an rvalue reference <code class="computeroutput"><span class="identifier">BOOST_THREAD_RV_REF</span><span class="special">(</span><span class="identifier">TYPE</span><span class="special">)</span></code>
using the dot operator, the legacy defines the <code class="computeroutput"><span class="keyword">operator</span><span class="special">-&gt;</span></code>. We need then a macro <code class="computeroutput"><span class="identifier">BOOST_THREAD_RV</span></code> that mask this difference.
E.g.
</p>
<pre class="programlisting"><span class="identifier">thread</span><span class="special">(</span><span class="identifier">BOOST_THREAD_RV_REF</span><span class="special">(</span><span class="identifier">thread</span><span class="special">)</span> <span class="identifier">x</span><span class="special">)</span>
<span class="special">{</span>
<span class="identifier">thread_info</span><span class="special">=</span><span class="identifier">BOOST_THREAD_RV</span><span class="special">(</span><span class="identifier">x</span><span class="special">).</span><span class="identifier">thread_info</span><span class="special">;</span>
<span class="identifier">BOOST_THREAD_RV</span><span class="special">(</span><span class="identifier">x</span><span class="special">).</span><span class="identifier">thread_info</span><span class="special">.</span><span class="identifier">reset</span><span class="special">();</span>
<span class="special">}</span>
</pre>
<p>
The use of this macros has reduced considerably the size of the Boost.Thread
move related code.
</p>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="thread.emulations.move.portable.MAKE_RV_REF"></a><a class="link" href="emulations.html#thread.emulations.move.portable.MAKE_RV_REF" title="BOOST_THREAD_MAKE_RV_REF(RVALUE)"><code class="computeroutput"><span class="identifier">BOOST_THREAD_MAKE_RV_REF</span><span class="special">(</span><span class="identifier">RVALUE</span><span class="special">)</span></code></a>
</h5></div></div></div>
<p>
While Boost.Move is the best C++03 move emulation there are some limitations
that impact the way the library can be used. For example, with the following
declarations
</p>
<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">thread</span> <span class="special">{</span>
<span class="comment">// ...</span>
<span class="keyword">private</span><span class="special">:</span>
<span class="identifier">thread</span><span class="special">(</span><span class="identifier">thread</span> <span class="special">&amp;);</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="identifier">thread</span><span class="special">(</span><span class="identifier">rv</span><span class="special">&lt;</span><span class="identifier">thread</span><span class="special">&gt;&amp;);</span>
<span class="comment">// ...</span>
<span class="special">};</span>
</pre>
<p>
This could not work on some compilers even if thread is convertible to
<code class="computeroutput"><span class="identifier">rv</span><span class="special">&lt;</span><span class="identifier">thread</span><span class="special">&gt;</span></code>
because the compiler prefers the private copy constructor.
</p>
<pre class="programlisting"><span class="identifier">thread</span> <span class="identifier">mkth</span><span class="special">()</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">thread</span><span class="special">(</span><span class="identifier">f</span><span class="special">);</span>
<span class="special">}</span>
</pre>
<p>
On these compilers we need to use instead an explicit conversion. The
library provides a move member function that allows to workaround the
issue.
</p>
<pre class="programlisting"><span class="identifier">thread</span> <span class="identifier">mkth</span><span class="special">()</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">thread</span><span class="special">(</span><span class="identifier">f</span><span class="special">).</span><span class="identifier">move</span><span class="special">();</span>
<span class="special">}</span>
</pre>
<p>
Note that <code class="computeroutput"><span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">move</span></code>
can not be used in this case as thread is not implicitly convertible
to <code class="computeroutput"><span class="identifier">thread</span><span class="special">&amp;</span></code>.
</p>
<pre class="programlisting"><span class="identifier">thread</span> <span class="identifier">mkth</span><span class="special">()</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">thread</span><span class="special">(</span><span class="identifier">f</span><span class="special">));</span>
<span class="special">}</span>
</pre>
<p>
To make the code portable Boost.Thread the user needs to use a macro
<code class="computeroutput"><span class="identifier">BOOST_THREAD_MAKE_RV_REF</span></code>
that can be used as in
</p>
<pre class="programlisting"><span class="identifier">thread</span> <span class="identifier">mkth</span><span class="special">()</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">BOOST_THREAD_MAKE_RV_REF</span><span class="special">(</span><span class="identifier">thread</span><span class="special">(</span><span class="identifier">f</span><span class="special">));</span>
<span class="special">}</span>
</pre>
<p>
Note that this limitation is shared also by the legacy Boost.Thread move
emulation.
</p>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="thread.emulations.move.portable.DCL_MOVABLE"></a><a class="link" href="emulations.html#thread.emulations.move.portable.DCL_MOVABLE" title="BOOST_THREAD_DCL_MOVABLE, BOOST_THREAD_DCL_MOVABLE_BEG(T1) and BOOST_THREAD_DCL_MOVABLE_END"><code class="computeroutput"><span class="identifier">BOOST_THREAD_DCL_MOVABLE</span></code>, <code class="computeroutput"><span class="identifier">BOOST_THREAD_DCL_MOVABLE_BEG</span><span class="special">(</span><span class="identifier">T1</span><span class="special">)</span></code> and
<code class="computeroutput"><span class="identifier">BOOST_THREAD_DCL_MOVABLE_END</span></code></a>
</h5></div></div></div>
<p>
As Boost.Move defines also the <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">move</span></code>
function we need to specialize the <code class="computeroutput"><span class="identifier">has_move_emulation_enabled_aux</span></code>
metafunction.
</p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;&gt;</span>
<span class="keyword">struct</span> <span class="identifier">has_move_emulation_enabled_aux</span><span class="special">&lt;</span><span class="identifier">thread</span><span class="special">&gt;</span>
<span class="special">:</span> <span class="identifier">BOOST_MOVE_BOOST_NS</span><span class="special">::</span><span class="identifier">integral_constant</span><span class="special">&lt;</span><span class="keyword">bool</span><span class="special">,</span> <span class="keyword">true</span><span class="special">&gt;</span>
<span class="special">{};</span>
</pre>
<p>
so that the following Boost.Move overload is disabled
</p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">inline</span> <span class="keyword">typename</span> <span class="identifier">BOOST_MOVE_BOOST_NS</span><span class="special">::</span><span class="identifier">disable_if</span><span class="special">&lt;</span><span class="identifier">has_move_emulation_enabled_aux</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="identifier">T</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span> <span class="identifier">move</span><span class="special">(</span><span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
</pre>
<p>
The macros <code class="computeroutput"><span class="identifier">BOOST_THREAD_DCL_MOVABLE</span><span class="special">(</span><span class="identifier">CLASS</span><span class="special">)</span></code>, <code class="computeroutput"><span class="identifier">BOOST_THREAD_DCL_MOVABLE_BEG</span><span class="special">(</span><span class="identifier">T1</span><span class="special">)</span></code> and <code class="computeroutput"><span class="identifier">BOOST_THREAD_DCL_MOVABLE_END</span></code>
are used for this purpose. E.g.
</p>
<pre class="programlisting"><span class="identifier">BOOST_THREAD_DCL_MOVABLE</span><span class="special">(</span><span class="identifier">thread</span><span class="special">)</span>
</pre>
<p>
and
</p>
<pre class="programlisting"><span class="identifier">BOOST_THREAD_DCL_MOVABLE_BEG</span><span class="special">(</span><span class="identifier">T</span><span class="special">)</span> <span class="identifier">promise</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">BOOST_THREAD_DCL_MOVABLE_END</span>
</pre>
</div>
</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="thread.emulations.bool_explicit_conversion"></a><a class="link" href="emulations.html#thread.emulations.bool_explicit_conversion" title="Bool explicit conversion">Bool explicit
conversion</a>
</h3></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="emulations.html#thread.emulations.bool_explicit_conversion.bool_conversion"><code class="computeroutput"><span class="keyword">operator</span> </code><span class="emphasis"><em>unspecified-bool-type</em></span><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span></code></a></span></dt>
<dt><span class="section"><a href="emulations.html#thread.emulations.bool_explicit_conversion.operator_not"><code class="computeroutput"><span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!()</span> <span class="keyword">const</span></code></a></span></dt>
</dl></div>
<p>
Locks provide an explicit bool conversion operator when the compiler provides
them.
</p>
<pre class="programlisting"><span class="keyword">explicit</span> <span class="keyword">operator</span> <span class="keyword">bool</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre>
<p>
The library provides un implicit conversion to an undefined type that can
be used as a conditional expression.
</p>
<pre class="programlisting"><span class="preprocessor">#if</span> <span class="identifier">defined</span><span class="special">(</span><span class="identifier">BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS</span><span class="special">)</span>
<span class="keyword">operator</span> <span class="emphasis"><em>unspecified-bool-type</em></span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!()</span> <span class="keyword">const</span><span class="special">;</span>
<span class="preprocessor">#else</span>
<span class="keyword">explicit</span> <span class="keyword">operator</span> <span class="keyword">bool</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
<span class="preprocessor">#endif</span>
</pre>
<p>
The user should use the lock.owns_lock() when an explicit conversion is required.
</p>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.emulations.bool_explicit_conversion.bool_conversion"></a><a class="link" href="emulations.html#thread.emulations.bool_explicit_conversion.bool_conversion" title="operator unspecified-bool-type() const"><code class="computeroutput"><span class="keyword">operator</span> </code><span class="emphasis"><em>unspecified-bool-type</em></span><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span></code></a>
</h4></div></div></div>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Returns:</span></dt>
<dd><p>
If <a class="link" href="synchronization.html#thread.synchronization.locks.unique_lock.owns_lock" title="bool owns_lock() const"><code class="computeroutput"><span class="identifier">owns_lock</span><span class="special">()</span></code></a>
would return <code class="computeroutput"><span class="keyword">true</span></code>, a
value that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>
in boolean contexts, otherwise a value that evaluates to <code class="computeroutput"><span class="keyword">false</span></code> in boolean contexts.
</p></dd>
<dt><span class="term">Throws:</span></dt>
<dd><p>
Nothing.
</p></dd>
</dl>
</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.emulations.bool_explicit_conversion.operator_not"></a><a class="link" href="emulations.html#thread.emulations.bool_explicit_conversion.operator_not" title="bool operator!() const"><code class="computeroutput"><span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!()</span> <span class="keyword">const</span></code></a>
</h4></div></div></div>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Returns:</span></dt>
<dd><p>
<code class="computeroutput"><span class="special">!</span></code> <a class="link" href="synchronization.html#thread.synchronization.locks.unique_lock.owns_lock" title="bool owns_lock() const"><code class="computeroutput"><span class="identifier">owns_lock</span><span class="special">()</span></code></a>.
</p></dd>
<dt><span class="term">Throws:</span></dt>
<dd><p>
Nothing.
</p></dd>
</dl>
</div>
</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="thread.emulations.scoped_enums"></a><a class="link" href="emulations.html#thread.emulations.scoped_enums" title="Scoped Enums">Scoped Enums</a>
</h3></div></div></div>
<p>
Some of the enumerations defined in the standard library are scoped enums.
</p>
<p>
On compilers that don't support them, the library uses a class to wrap the
underlying type. Instead of
</p>
<pre class="programlisting"><span class="keyword">enum</span> <span class="keyword">class</span> <span class="identifier">future_errc</span>
<span class="special">{</span>
<span class="identifier">broken_promise</span><span class="special">,</span>
<span class="identifier">future_already_retrieved</span><span class="special">,</span>
<span class="identifier">promise_already_satisfied</span><span class="special">,</span>
<span class="identifier">no_state</span>
<span class="special">};</span>
</pre>
<p>
the library declare these types as
</p>
<pre class="programlisting"><span class="identifier">BOOST_SCOPED_ENUM_DECLARE_BEGIN</span><span class="special">(</span><span class="identifier">future_errc</span><span class="special">)</span>
<span class="special">{</span>
<span class="identifier">broken_promise</span><span class="special">,</span>
<span class="identifier">future_already_retrieved</span><span class="special">,</span>
<span class="identifier">promise_already_satisfied</span><span class="special">,</span>
<span class="identifier">no_state</span>
<span class="special">}</span>
<span class="identifier">BOOST_SCOPED_ENUM_DECLARE_END</span><span class="special">(</span><span class="identifier">future_errc</span><span class="special">)</span>
</pre>
<p>
These macros allows to use 'future_errc' in almost all the cases as a scoped
enum.
</p>
<p>
There are however some limitations:
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
The type is not a C++ enum, so 'is_enum&lt;future_errc&gt;' will be false_type.
</li>
<li class="listitem">
The emulated scoped enum can not be used in switch nor in template arguments.
For these cases the user needs to use some macros.
</li>
</ul></div>
<p>
Instead of
</p>
<pre class="programlisting"> <span class="keyword">switch</span> <span class="special">(</span><span class="identifier">ev</span><span class="special">)</span>
<span class="special">{</span>
<span class="keyword">case</span> <span class="identifier">future_errc</span><span class="special">::</span><span class="identifier">broken_promise</span><span class="special">:</span>
<span class="comment">// ...</span>
</pre>
<p>
use
</p>
<pre class="programlisting"><span class="keyword">switch</span> <span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">native_value</span><span class="special">(</span><span class="identifier">ev</span><span class="special">))</span>
<span class="special">{</span>
<span class="keyword">case</span> <span class="identifier">future_errc</span><span class="special">::</span><span class="identifier">broken_promise</span><span class="special">:</span>
</pre>
<p>
And instead of
</p>
<pre class="programlisting"><span class="preprocessor">#ifdef</span> <span class="identifier">BOOST_NO_CXX11_SCOPED_ENUMS</span>
<span class="keyword">template</span> <span class="special">&lt;&gt;</span>
<span class="keyword">struct</span> <span class="identifier">BOOST_SYMBOL_VISIBLE</span> <span class="identifier">is_error_code_enum</span><span class="special">&lt;</span><span class="identifier">future_errc</span><span class="special">&gt;</span> <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">true_type</span> <span class="special">{</span> <span class="special">};</span>
<span class="preprocessor">#endif</span>
</pre>
<p>
use
</p>
<pre class="programlisting"><span class="preprocessor">#ifdef</span> <span class="identifier">BOOST_NO_CXX11_SCOPED_ENUMS</span>
<span class="keyword">template</span> <span class="special">&lt;&gt;</span>
<span class="keyword">struct</span> <span class="identifier">BOOST_SYMBOL_VISIBLE</span> <span class="identifier">is_error_code_enum</span><span class="special">&lt;</span><span class="identifier">future_errc</span><span class="special">::</span><span class="identifier">enum_type</span><span class="special">&gt;</span> <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">true_type</span> <span class="special">{</span> <span class="special">};</span>
<span class="preprocessor">#endif</span>
</pre>
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2007 -11 Anthony Williams<br>Copyright © 2011 -17 Vicente J. Botet Escriba<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="time.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../thread.html"><img src="../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="acknowledgements.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,76 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Future</title>
<link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
<link rel="up" href="../thread.html" title="Chapter 40. Thread 4.8.0">
<link rel="prev" href="changes.html" title="History">
<link rel="next" href="thread_management.html" title="Thread Management">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
<td align="center"><a href="../../../index.html">Home</a></td>
<td align="center"><a href="../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="changes.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../thread.html"><img src="../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="thread_management.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="thread.future"></a><a class="link" href="future.html" title="Future">Future</a>
</h2></div></div></div>
<p>
The following features will be included in next releases.
</p>
<div class="orderedlist"><ol class="orderedlist" type="1">
<li class="listitem">
Add some minor features, in particular
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
<a href="http://svn.boost.org/trac/boost/ticket/7589" target="_top">#7589</a>
Synchro: Add polymorphic lockables.
</li></ul></div>
</li>
<li class="listitem">
Add some features based on C++ proposals, in particular
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
<a href="http://svn.boost.org/trac/boost/ticket/8273" target="_top">#8273</a>
Synchro: Add externally locked streams.
</li>
<li class="listitem">
<a href="http://svn.boost.org/trac/boost/ticket/8514" target="_top">#8514</a>
Async: Add a thread_pool executor with work stealing.
</li>
</ul></div>
</li>
<li class="listitem">
And some additional extensions related to futures as:
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
<a href="http://svn.boost.org/trac/boost/ticket/8517" target="_top">#8517</a>
Async: Add a variadic shared_future::then.
</li></ul></div>
</li>
</ol></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2007 -11 Anthony Williams<br>Copyright © 2011 -17 Vicente J. Botet Escriba<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="changes.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../thread.html"><img src="../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="thread_management.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,618 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Parallel - Fork-Join -- EXPERIMENTAL</title>
<link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
<link rel="up" href="../thread.html" title="Chapter 40. Thread 4.8.0">
<link rel="prev" href="sds.html" title="Synchronized Data Structures">
<link rel="next" href="time.html" title="Time Requirements">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
<td align="center"><a href="../../../index.html">Home</a></td>
<td align="center"><a href="../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="sds.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../thread.html"><img src="../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="time.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="thread.parallel"></a><a class="link" href="parallel.html" title="Parallel - Fork-Join -- EXPERIMENTAL">Parallel - Fork-Join -- EXPERIMENTAL</a>
</h2></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="parallel.html#thread.parallel.fork_join">Fork-Join</a></span></dt>
<dt><span class="section"><a href="parallel.html#thread.parallel.ref">Reference -- EXPERIMENTAL</a></span></dt>
</dl></div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="thread.parallel.fork_join"></a><a class="link" href="parallel.html#thread.parallel.fork_join" title="Fork-Join">Fork-Join</a>
</h3></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="parallel.html#thread.parallel.fork_join.introduction">Introduction</a></span></dt>
<dt><span class="section"><a href="parallel.html#thread.parallel.fork_join.tutorial">Tutorial</a></span></dt>
<dt><span class="section"><a href="parallel.html#thread.parallel.fork_join.examples">Examples</a></span></dt>
<dt><span class="section"><a href="parallel.html#thread.parallel.fork_join.rationale">Design Rationale</a></span></dt>
</dl></div>
<div class="warning"><table border="0" summary="Warning">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Warning]" src="../../../doc/src/images/warning.png"></td>
<th align="left">Warning</th>
</tr>
<tr><td align="left" valign="top"><p>
These features are experimental and subject to change in future versions.
There are not too much tests yet, so it is possible that you can find out
some trivial bugs :(
</p></td></tr>
</table></div>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
These features are based on the <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4088.pdf" target="_top"><span class="bold"><strong>n4088 - Task Region R3</strong></span></a> C++1y proposal from
P. Halpern, A. Robison, A. Laksberg, H. Sutter, et al. The text that follows
has been adapted from this paper to show the differences.
</p></td></tr>
</table></div>
<p>
The major difference respect to the standard proposal is that we are able
to use a common executor for several task regions.
</p>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
Up to now, Boost.Thread doesn't implement the parallel algorithms as defined
in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4105.pdf" target="_top"><span class="bold"><strong>n4105 - Information technology Programming languages, their
environments and system software interfaces Technical Specification
for C++ Extensions for Parallelism</strong></span></a>.
</p></td></tr>
</table></div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.parallel.fork_join.introduction"></a><a class="link" href="parallel.html#thread.parallel.fork_join.introduction" title="Introduction">Introduction</a>
</h4></div></div></div>
<p>
This module introduces a C++11/c++14 library function template <code class="computeroutput"><span class="identifier">task_region</span></code> and a library class <code class="computeroutput"><span class="identifier">task_region_handle</span></code> with member functions
<code class="computeroutput"><span class="identifier">run</span></code> and <code class="computeroutput"><span class="identifier">wait</span></code>
that together enable developers to write expressive and portable fork-join
parallel code.
</p>
<p>
The working draft for the Parallelism TS <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4105.pdf" target="_top"><span class="bold"><strong>N4105</strong></span></a> augments the STL algorithms with the
inclusion of parallel execution policies. Programmers use these as a basis
to write additional high-level algorithms that can be implemented in terms
of the provided parallel algorithms. However, the scope of n4105 does not
include lower-level mechanisms to express arbitrary fork-join parallelism
</p>
<p>
The <code class="computeroutput"><span class="identifier">task_region</span></code>, <code class="computeroutput"><span class="identifier">run</span></code> and the <code class="computeroutput"><span class="identifier">wait</span></code>
functions provided by this library are based on the <code class="computeroutput"><span class="identifier">task_group</span></code>
concept that is a part of the common subset of the PPL and the TBB libraries.
</p>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.parallel.fork_join.tutorial"></a><a class="link" href="parallel.html#thread.parallel.fork_join.tutorial" title="Tutorial">Tutorial</a>
</h4></div></div></div>
<p>
Consider an example of a parallel traversal of a tree, where a user-provided
function compute is applied to each node of the tree, returning the sum
of the results:
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Func</span><span class="special">&gt;</span>
<span class="keyword">int</span> <span class="identifier">traverse</span><span class="special">(</span><span class="identifier">node</span> <span class="special">*</span><span class="identifier">n</span><span class="special">,</span> <span class="identifier">Func</span><span class="special">&amp;&amp;</span> <span class="identifier">compute</span><span class="special">)</span>
<span class="special">{</span>
<span class="keyword">int</span> <span class="identifier">left</span> <span class="special">=</span> <span class="number">0</span><span class="special">,</span> <span class="identifier">right</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
<span class="identifier">task_region</span><span class="special">([&amp;](</span><span class="identifier">task_region_handle</span><span class="special">&amp;</span> <span class="identifier">tr</span><span class="special">)</span> <span class="special">{</span>
<span class="keyword">if</span> <span class="special">(</span><span class="identifier">n</span><span class="special">-&gt;</span><span class="identifier">left</span><span class="special">)</span>
<span class="identifier">tr</span><span class="special">.</span><span class="identifier">run</span><span class="special">([&amp;]</span> <span class="special">{</span> <span class="identifier">left</span> <span class="special">=</span> <span class="identifier">traverse</span><span class="special">(</span><span class="identifier">n</span><span class="special">-&gt;</span><span class="identifier">left</span><span class="special">,</span> <span class="identifier">compute</span><span class="special">);</span> <span class="special">});</span>
<span class="keyword">if</span> <span class="special">(</span><span class="identifier">n</span><span class="special">-&gt;</span><span class="identifier">right</span><span class="special">)</span>
<span class="identifier">tr</span><span class="special">.</span><span class="identifier">run</span><span class="special">([&amp;]</span> <span class="special">{</span> <span class="identifier">right</span> <span class="special">=</span> <span class="identifier">traverse</span><span class="special">(</span><span class="identifier">n</span><span class="special">-&gt;</span><span class="identifier">right</span><span class="special">,</span> <span class="identifier">compute</span><span class="special">);</span> <span class="special">});</span>
<span class="special">});</span>
<span class="keyword">return</span> <span class="identifier">compute</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span> <span class="special">+</span> <span class="identifier">left</span> <span class="special">+</span> <span class="identifier">right</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
The example above demonstrates the use of two of the functions proposed
in this paper, <code class="computeroutput"><span class="identifier">task_region</span></code>
and <code class="computeroutput"><span class="identifier">task_region_handle</span><span class="special">::</span><span class="identifier">run</span></code>.
The <code class="computeroutput"><span class="identifier">task_region</span></code> function
delineates a region in a program code potentially containing invocations
of tasks spawned by the <code class="computeroutput"><span class="identifier">run</span></code>
member function of the <code class="computeroutput"><span class="identifier">task_region_handle</span></code>
class.
</p>
<p>
The run function spawns a task, a unit of work that is allowed to execute
in parallel with respect to the caller. Any parallel tasks spawned by
<code class="computeroutput"><span class="identifier">run</span></code> within the <code class="computeroutput"><span class="identifier">task_region</span></code> are joined back to a single
thread of execution at the end of the <code class="computeroutput"><span class="identifier">task_region</span></code>.
</p>
<p>
<code class="computeroutput"><span class="identifier">run</span></code> takes a user-provided
function object <code class="computeroutput"><span class="identifier">f</span></code> and starts
it asynchronously - i.e. it may return before the execution of <code class="computeroutput"><span class="identifier">f</span></code> completes. The implementation's scheduler
may choose to run <code class="computeroutput"><span class="identifier">f</span></code> immediately
or delay running <code class="computeroutput"><span class="identifier">f</span></code> until
compute resources become available.
</p>
<p>
A <code class="computeroutput"><span class="identifier">task_region_handle</span></code> can
be constructed only by <code class="computeroutput"><span class="identifier">task_region</span></code>
because it has no public constructors. Thus, <code class="computeroutput"><span class="identifier">run</span></code>
can be invoked (directly or indirectly) only from a user-provided function
passed to <code class="computeroutput"><span class="identifier">task_region</span></code>:
</p>
<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">g</span><span class="special">();</span>
<span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">task_region_handle</span><span class="special">&amp;</span> <span class="identifier">tr</span><span class="special">)</span>
<span class="special">{</span>
<span class="identifier">tr</span><span class="special">.</span><span class="identifier">run</span><span class="special">(</span><span class="identifier">g</span><span class="special">);</span> <span class="comment">// OK, invoked from within task_region in h</span>
<span class="special">}</span>
<span class="keyword">void</span> <span class="identifier">h</span><span class="special">()</span>
<span class="special">{</span>
<span class="identifier">task_region</span><span class="special">(</span><span class="identifier">f</span><span class="special">);</span>
<span class="special">}</span>
<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
<span class="identifier">task_region_handle</span> <span class="identifier">tr</span><span class="special">;</span> <span class="comment">// Error: no public constructor</span>
<span class="identifier">tr</span><span class="special">.</span><span class="identifier">run</span><span class="special">(</span><span class="identifier">g</span><span class="special">);</span> <span class="comment">// No way to call run outside of a task_region</span>
<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.parallel.fork_join.examples"></a><a class="link" href="parallel.html#thread.parallel.fork_join.examples" title="Examples">Examples</a>
</h4></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="parallel.html#thread.parallel.fork_join.examples.fib">Parallel
Fibonacci</a></span></dt>
<dt><span class="section"><a href="parallel.html#thread.parallel.fork_join.examples.fibex">Parallel
Fibonacci - Specific executor</a></span></dt>
<dt><span class="section"><a href="parallel.html#thread.parallel.fork_join.examples.quick_sort">Parallel
Accumulate</a></span></dt>
<dt><span class="section"><a href="parallel.html#thread.parallel.fork_join.examples.quick_sort0">Parallel
Quick Sort</a></span></dt>
</dl></div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="thread.parallel.fork_join.examples.fib"></a><a class="link" href="parallel.html#thread.parallel.fork_join.examples.fib" title="Parallel Fibonacci">Parallel
Fibonacci</a>
</h5></div></div></div>
<p>
This is surely the worst implementation of the Fibonacci function. Anyway,
here it is, as it is simple and shows the fork-join structure clearly.
<code class="computeroutput"><span class="identifier">Fibonacci</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span> <span class="special">=</span> <span class="identifier">Fibonacci</span><span class="special">(</span><span class="identifier">n</span><span class="special">-</span><span class="number">1</span><span class="special">)</span>
<span class="special">+</span> <span class="identifier">Fibonacci</span><span class="special">(</span><span class="identifier">n</span><span class="special">-</span><span class="number">2</span><span class="special">)</span></code>,
so the task decomposition is trivial.
</p>
<pre class="programlisting"><span class="keyword">int</span> <span class="identifier">fib_task_region</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">n</span><span class="special">)</span>
<span class="special">{</span>
<span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">experimental</span><span class="special">::</span><span class="identifier">parallel</span><span class="special">::</span><span class="identifier">task_region</span><span class="special">;</span>
<span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">experimental</span><span class="special">::</span><span class="identifier">parallel</span><span class="special">::</span><span class="identifier">task_region_handle</span><span class="special">;</span>
<span class="keyword">if</span> <span class="special">(</span><span class="identifier">n</span> <span class="special">==</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="keyword">if</span> <span class="special">(</span><span class="identifier">n</span> <span class="special">==</span> <span class="number">1</span><span class="special">)</span> <span class="keyword">return</span> <span class="number">1</span><span class="special">;</span>
<span class="keyword">int</span> <span class="identifier">n1</span><span class="special">;</span>
<span class="keyword">int</span> <span class="identifier">n2</span><span class="special">;</span>
<span class="identifier">task_region</span><span class="special">([&amp;](</span><span class="identifier">task_region_handle</span><span class="special">&amp;</span> <span class="identifier">trh</span><span class="special">)</span>
<span class="special">{</span>
<span class="identifier">trh</span><span class="special">.</span><span class="identifier">run</span><span class="special">([&amp;]</span>
<span class="special">{</span>
<span class="identifier">n1</span> <span class="special">=</span> <span class="identifier">fib_task_region</span><span class="special">(</span><span class="identifier">n</span> <span class="special">-</span> <span class="number">1</span><span class="special">);</span>
<span class="special">});</span>
<span class="identifier">n2</span> <span class="special">=</span> <span class="identifier">fib_task_region</span><span class="special">(</span><span class="identifier">n</span> <span class="special">-</span> <span class="number">2</span><span class="special">);</span>
<span class="special">});</span>
<span class="keyword">return</span> <span class="identifier">n1</span> <span class="special">+</span> <span class="identifier">n2</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
<span class="keyword">for</span> <span class="special">(</span><span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span><span class="special">&lt;</span><span class="number">10</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span> <span class="special">{</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">fib_task_region</span><span class="special">(</span><span class="identifier">i</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="string">" "</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="special">}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="thread.parallel.fork_join.examples.fibex"></a><a class="link" href="parallel.html#thread.parallel.fork_join.examples.fibex" title="Parallel Fibonacci - Specific executor">Parallel
Fibonacci - Specific executor</a>
</h5></div></div></div>
<p>
The previous example make use of an implementation defined way to spawn
the tasks. Often the user wants to master how the task must be spawned.
There is an overload of <code class="computeroutput"><span class="identifier">task_region</span></code>
that accept an additional <code class="computeroutput"><span class="identifier">Executor</span></code>
parameter and a function that takes as parameter a <code class="computeroutput"><span class="identifier">task_region_handle_gen</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;</span></code>. <code class="computeroutput"><span class="identifier">task_region_handle_gen</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;</span></code> run uses this executor to spawn the
tasks.
</p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Ex</span><span class="special">&gt;</span>
<span class="keyword">int</span> <span class="identifier">fib_task_region_gen</span><span class="special">(</span> <span class="identifier">Ex</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">n</span><span class="special">)</span>
<span class="special">{</span>
<span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">experimental</span><span class="special">::</span><span class="identifier">parallel</span><span class="special">::</span><span class="identifier">task_region</span><span class="special">;</span>
<span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">experimental</span><span class="special">::</span><span class="identifier">parallel</span><span class="special">::</span><span class="identifier">task_region_handle_gen</span><span class="special">;</span>
<span class="keyword">if</span> <span class="special">(</span><span class="identifier">n</span> <span class="special">==</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="keyword">if</span> <span class="special">(</span><span class="identifier">n</span> <span class="special">==</span> <span class="number">1</span><span class="special">)</span> <span class="keyword">return</span> <span class="number">1</span><span class="special">;</span>
<span class="keyword">int</span> <span class="identifier">n1</span><span class="special">;</span>
<span class="keyword">int</span> <span class="identifier">n2</span><span class="special">;</span>
<span class="identifier">task_region</span><span class="special">(</span><span class="identifier">ex</span><span class="special">,</span> <span class="special">[&amp;](</span><span class="identifier">task_region_handle_gen</span><span class="special">&lt;</span><span class="identifier">Ex</span><span class="special">&gt;&amp;</span> <span class="identifier">trh</span><span class="special">)</span> <span class="comment">// (2)</span>
<span class="special">{</span>
<span class="identifier">trh</span><span class="special">.</span><span class="identifier">run</span><span class="special">([&amp;]</span>
<span class="special">{</span>
<span class="identifier">n1</span> <span class="special">=</span> <span class="identifier">fib_task_region</span><span class="special">(</span><span class="identifier">n</span> <span class="special">-</span> <span class="number">1</span><span class="special">);</span>
<span class="special">});</span>
<span class="identifier">n2</span> <span class="special">=</span> <span class="identifier">fib_task_region</span><span class="special">(</span><span class="identifier">n</span> <span class="special">-</span> <span class="number">2</span><span class="special">);</span>
<span class="special">});</span>
<span class="keyword">return</span> <span class="identifier">n1</span> <span class="special">+</span> <span class="identifier">n2</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">basic_thread_pool</span> <span class="identifier">tp</span><span class="special">;</span> <span class="comment">// (1)</span>
<span class="keyword">for</span> <span class="special">(</span><span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span><span class="special">&lt;</span><span class="number">10</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span> <span class="special">{</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">fib_task_region_gen</span><span class="special">(</span><span class="identifier">tp</span><span class="special">,</span><span class="identifier">i</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="string">" "</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
The specific executor is declared in line (1) and it is used in line
(2).
</p>
</div>
<div class="section"><div class="titlepage"><div><div><h5 class="title">
<a name="thread.parallel.fork_join.examples.quick_sort"></a><a class="link" href="parallel.html#thread.parallel.fork_join.examples.quick_sort" title="Parallel Accumulate">Parallel
Accumulate</a>
</h5></div></div></div></div>
<div class="section"><div class="titlepage"><div><div><h5 class="title">
<a name="thread.parallel.fork_join.examples.quick_sort0"></a><a class="link" href="parallel.html#thread.parallel.fork_join.examples.quick_sort0" title="Parallel Quick Sort">Parallel
Quick Sort</a>
</h5></div></div></div></div>
</div>
<div class="section"><div class="titlepage"><div><div><h4 class="title">
<a name="thread.parallel.fork_join.rationale"></a><a class="link" href="parallel.html#thread.parallel.fork_join.rationale" title="Design Rationale">Design Rationale</a>
</h4></div></div></div></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="thread.parallel.ref"></a><a class="link" href="parallel.html#thread.parallel.ref" title="Reference -- EXPERIMENTAL">Reference -- EXPERIMENTAL</a>
</h3></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="parallel.html#thread.parallel.ref.v1">Parallel V1</a></span></dt>
<dt><span class="section"><a href="parallel.html#thread.parallel.ref.v2">Parallel V2</a></span></dt>
</dl></div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.parallel.ref.v1"></a><a class="link" href="parallel.html#thread.parallel.ref.v1" title="Parallel V1">Parallel V1</a>
</h4></div></div></div>
<div class="toc"><dl class="toc"><dt><span class="section"><a href="parallel.html#thread.parallel.ref.v1.exception_list">Header <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">experimental</span><span class="special">/</span><span class="identifier">exception_list</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code></a></span></dt></dl></div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="thread.parallel.ref.v1.exception_list"></a><a class="link" href="parallel.html#thread.parallel.ref.v1.exception_list" title="Header &lt;experimental/exception_list.hpp&gt;">Header <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">experimental</span><span class="special">/</span><span class="identifier">exception_list</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code></a>
</h5></div></div></div>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>
<span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">experimental</span>
<span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">parallel</span>
<span class="special">{</span>
<span class="keyword">inline</span> <span class="keyword">namespace</span> <span class="identifier">v1</span>
<span class="special">{</span>
<span class="keyword">class</span> <span class="identifier">exception_list</span><span class="special">;</span>
<span class="special">}</span> <span class="comment">// v1</span>
<span class="special">}</span> <span class="comment">// parallel</span>
<span class="special">}</span> <span class="comment">// experimental</span>
<span class="special">}</span> <span class="comment">// boost</span>
</pre>
<div class="section">
<div class="titlepage"><div><div><h6 class="title">
<a name="thread.parallel.ref.v1.exception_list.exception_list"></a><a class="link" href="parallel.html#thread.parallel.ref.v1.exception_list.exception_list" title="Class exception_list">Class
<code class="computeroutput"><span class="identifier">exception_list</span></code></a>
</h6></div></div></div>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>
<span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">experimental</span>
<span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">parallel</span>
<span class="special">{</span>
<span class="keyword">inline</span> <span class="keyword">namespace</span> <span class="identifier">v1</span>
<span class="special">{</span>
<span class="keyword">class</span> <span class="identifier">exception_list</span><span class="special">:</span> <span class="keyword">public</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">exception</span>
<span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="keyword">typedef</span> <span class="char">'implementation defined'</span> <span class="identifier">const_iterator</span><span class="special">;</span>
<span class="special">~</span><span class="identifier">exception_list</span><span class="special">()</span> <span class="keyword">noexcept</span> <span class="special">{}</span>
<span class="keyword">void</span> <span class="identifier">add</span><span class="special">(</span><span class="identifier">exception_ptr</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">);</span>
<span class="identifier">size_t</span> <span class="identifier">size</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="identifier">const_iterator</span> <span class="identifier">begin</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="identifier">const_iterator</span> <span class="identifier">end</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">what</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="special">};</span>
<span class="special">}</span> <span class="comment">// v1</span>
<span class="special">}</span> <span class="comment">// parallel</span>
<span class="special">}</span> <span class="comment">// experimental</span>
<span class="special">}</span> <span class="comment">// boost</span>
</pre>
</div>
</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.parallel.ref.v2"></a><a class="link" href="parallel.html#thread.parallel.ref.v2" title="Parallel V2">Parallel V2</a>
</h4></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="parallel.html#thread.parallel.ref.v2.concepts">Concepts</a></span></dt>
<dt><span class="section"><a href="parallel.html#thread.parallel.ref.v2.task_region">Header <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">experimental</span><span class="special">/</span><span class="identifier">task_region</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code></a></span></dt>
</dl></div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="thread.parallel.ref.v2.concepts"></a><a class="link" href="parallel.html#thread.parallel.ref.v2.concepts" title="Concepts">Concepts</a>
</h5></div></div></div>
<div class="section"><div class="titlepage"><div><div><h6 class="title">
<a name="thread.parallel.ref.v2.concepts.regionCallable"></a><a class="link" href="parallel.html#thread.parallel.ref.v2.concepts.regionCallable" title="Concept Region_Callable">Concept
<code class="computeroutput"><span class="identifier">Region_Callable</span></code></a>
</h6></div></div></div></div>
<div class="section"><div class="titlepage"><div><div><h6 class="title">
<a name="thread.parallel.ref.v2.concepts.taskCallable"></a><a class="link" href="parallel.html#thread.parallel.ref.v2.concepts.taskCallable" title="Concept Task_Callable">Concept
<code class="computeroutput"><span class="identifier">Task_Callable</span></code></a>
</h6></div></div></div></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="thread.parallel.ref.v2.task_region"></a><a class="link" href="parallel.html#thread.parallel.ref.v2.task_region" title="Header &lt;experimental/task_region.hpp&gt;">Header <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">experimental</span><span class="special">/</span><span class="identifier">task_region</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code></a>
</h5></div></div></div>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>
<span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">experimental</span>
<span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">parallel</span>
<span class="special">{</span>
<span class="keyword">inline</span> <span class="keyword">namespace</span> <span class="identifier">v2</span>
<span class="special">{</span>
<span class="keyword">class</span> <span class="identifier">task_canceled_exception</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">task_region_handle_gen</span><span class="special">;</span>
<span class="keyword">using</span> <span class="identifier">default_executor</span> <span class="special">=</span> <span class="char">'implementation defined'</span><span class="special">;</span>
<span class="keyword">class</span> <span class="identifier">task_region_handle</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">F</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">task_region_final</span><span class="special">(</span><span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">,</span> <span class="identifier">F</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">F</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">task_region_final</span><span class="special">(</span><span class="identifier">F</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">F</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">task_region</span><span class="special">(</span><span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">,</span> <span class="identifier">F</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">F</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">task_region</span><span class="special">(</span><span class="identifier">F</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">);</span>
<span class="special">}</span> <span class="comment">// v2</span>
<span class="special">}</span> <span class="comment">// parallel</span>
<span class="special">}</span> <span class="comment">// experimental</span>
<span class="special">}</span> <span class="comment">// boost</span>
</pre>
<div class="section">
<div class="titlepage"><div><div><h6 class="title">
<a name="thread.parallel.ref.v2.task_region.task_canceled_exception"></a><a class="link" href="parallel.html#thread.parallel.ref.v2.task_region.task_canceled_exception" title="Class task_canceled_exception">Class
<code class="computeroutput"><span class="identifier">task_canceled_exception</span> </code></a>
</h6></div></div></div>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>
<span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">experimental</span>
<span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">parallel</span>
<span class="special">{</span>
<span class="keyword">inline</span> <span class="keyword">namespace</span> <span class="identifier">v2</span>
<span class="special">{</span>
<span class="keyword">class</span> <span class="identifier">task_canceled_exception</span><span class="special">:</span> <span class="keyword">public</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">exception</span>
<span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="identifier">task_canceled_exception</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="identifier">task_canceled_exception</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">task_canceled_exception</span><span class="special">&amp;)</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="identifier">task_canceled_exception</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">task_canceled_exception</span><span class="special">&amp;)</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="keyword">virtual</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">what</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="special">};</span>
<span class="special">}</span> <span class="comment">// v2</span>
<span class="special">}</span> <span class="comment">// parallel</span>
<span class="special">}</span> <span class="comment">// experimental</span>
<span class="special">}</span> <span class="comment">// boost</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h6 class="title">
<a name="thread.parallel.ref.v2.task_region.task_region_handle_gen"></a><a class="link" href="parallel.html#thread.parallel.ref.v2.task_region.task_region_handle_gen" title="Template Class task_region_handle_gen&lt;&gt;">Template
Class <code class="computeroutput"><span class="identifier">task_region_handle_gen</span><span class="special">&lt;&gt;</span></code></a>
</h6></div></div></div>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>
<span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">experimental</span>
<span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">parallel</span>
<span class="special">{</span>
<span class="keyword">inline</span> <span class="keyword">namespace</span> <span class="identifier">v2</span>
<span class="special">{</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">task_region_handle_gen</span>
<span class="special">{</span>
<span class="keyword">protected</span><span class="special">:</span>
<span class="identifier">task_region_handle_gen</span><span class="special">(</span><span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">);</span>
<span class="special">~</span><span class="identifier">task_region_handle_gen</span><span class="special">();</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="identifier">task_region_handle_gen</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">task_region_handle_gen</span><span class="special">&amp;)</span> <span class="special">=</span> <span class="keyword">delete</span><span class="special">;</span>
<span class="identifier">task_region_handle_gen</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">task_region_handle_gen</span><span class="special">&amp;)</span> <span class="special">=</span> <span class="keyword">delete</span><span class="special">;</span>
<span class="identifier">task_region_handle_gen</span><span class="special">*</span> <span class="keyword">operator</span><span class="special">&amp;()</span> <span class="keyword">const</span> <span class="special">=</span> <span class="keyword">delete</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">F</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">run</span><span class="special">(</span><span class="identifier">F</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">);</span>
<span class="keyword">void</span> <span class="identifier">wait</span><span class="special">();</span>
<span class="special">};</span>
<span class="special">}</span> <span class="comment">// v2</span>
<span class="special">}</span> <span class="comment">// parallel</span>
<span class="special">}</span> <span class="comment">// experimental</span>
<span class="special">}</span> <span class="comment">// boost</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h6 class="title">
<a name="thread.parallel.ref.v2.task_region.default_executor"></a><a class="link" href="parallel.html#thread.parallel.ref.v2.task_region.default_executor" title="Class default_executor">Class
<code class="computeroutput"><span class="identifier">default_executor</span> </code></a>
</h6></div></div></div>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>
<span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">experimental</span>
<span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">parallel</span>
<span class="special">{</span>
<span class="keyword">inline</span> <span class="keyword">namespace</span> <span class="identifier">v2</span>
<span class="special">{</span>
<span class="keyword">using</span> <span class="identifier">default_executor</span> <span class="special">=</span> <span class="char">'implementation defined'</span><span class="special">;</span>
<span class="special">}</span> <span class="comment">// v2</span>
<span class="special">}</span> <span class="comment">// parallel</span>
<span class="special">}</span> <span class="comment">// experimental</span>
<span class="special">}</span> <span class="comment">// boost</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h6 class="title">
<a name="thread.parallel.ref.v2.task_region.task_region_handle"></a><a class="link" href="parallel.html#thread.parallel.ref.v2.task_region.task_region_handle" title="Class task_region_handle">Class
<code class="computeroutput"><span class="identifier">task_region_handle</span> </code></a>
</h6></div></div></div>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>
<span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">experimental</span>
<span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">parallel</span>
<span class="special">{</span>
<span class="keyword">inline</span> <span class="keyword">namespace</span> <span class="identifier">v2</span>
<span class="special">{</span>
<span class="keyword">class</span> <span class="identifier">task_region_handle</span> <span class="special">:</span>
<span class="keyword">public</span> <span class="identifier">task_region_handle_gen</span><span class="special">&lt;</span><span class="identifier">default_executor</span><span class="special">&gt;</span>
<span class="special">{</span>
<span class="keyword">protected</span><span class="special">:</span>
<span class="identifier">task_region_handle</span><span class="special">();</span>
<span class="identifier">task_region_handle</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">task_region_handle</span><span class="special">&amp;)</span> <span class="special">=</span> <span class="keyword">delete</span><span class="special">;</span>
<span class="identifier">task_region_handle</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">task_region_handle</span><span class="special">&amp;)</span> <span class="special">=</span> <span class="keyword">delete</span><span class="special">;</span>
<span class="identifier">task_region_handle</span><span class="special">*</span> <span class="keyword">operator</span><span class="special">&amp;()</span> <span class="keyword">const</span> <span class="special">=</span> <span class="keyword">delete</span><span class="special">;</span>
<span class="special">};</span>
<span class="special">}</span> <span class="comment">// v2</span>
<span class="special">}</span> <span class="comment">// parallel</span>
<span class="special">}</span> <span class="comment">// experimental</span>
<span class="special">}</span> <span class="comment">// boost</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h6 class="title">
<a name="thread.parallel.ref.v2.task_region.task_region_final"></a><a class="link" href="parallel.html#thread.parallel.ref.v2.task_region.task_region_final" title="Template Function task_region_final">Template
Function <code class="computeroutput"><span class="identifier">task_region_final</span>
</code></a>
</h6></div></div></div>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>
<span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">experimental</span>
<span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">parallel</span>
<span class="special">{</span>
<span class="keyword">inline</span> <span class="keyword">namespace</span> <span class="identifier">v2</span>
<span class="special">{</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">F</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">task_region_final</span><span class="special">(</span><span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">,</span> <span class="identifier">F</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">F</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">task_region_final</span><span class="special">(</span><span class="identifier">F</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">);</span>
<span class="special">}</span> <span class="comment">// v2</span>
<span class="special">}</span> <span class="comment">// parallel</span>
<span class="special">}</span> <span class="comment">// experimental</span>
<span class="special">}</span> <span class="comment">// boost</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h6 class="title">
<a name="thread.parallel.ref.v2.task_region.task_region"></a><a class="link" href="parallel.html#thread.parallel.ref.v2.task_region.task_region" title="Template Function task_region">Template
Function <code class="computeroutput"><span class="identifier">task_region</span> </code></a>
</h6></div></div></div>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>
<span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">experimental</span>
<span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">parallel</span>
<span class="special">{</span>
<span class="keyword">inline</span> <span class="keyword">namespace</span> <span class="identifier">v2</span>
<span class="special">{</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">F</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">task_region</span><span class="special">(</span><span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">,</span> <span class="identifier">F</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">F</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">task_region</span><span class="special">(</span><span class="identifier">F</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">);</span>
<span class="special">}</span> <span class="comment">// v2</span>
<span class="special">}</span> <span class="comment">// parallel</span>
<span class="special">}</span> <span class="comment">// experimental</span>
<span class="special">}</span> <span class="comment">// boost</span>
</pre>
</div>
</div>
</div>
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2007 -11 Anthony Williams<br>Copyright © 2011 -17 Vicente J. Botet Escriba<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="sds.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../thread.html"><img src="../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="time.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

2586
doc/html/thread/sds.html Normal file

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@@ -0,0 +1,382 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Thread Local Storage</title>
<link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
<link rel="up" href="../thread.html" title="Chapter 40. Thread 4.8.0">
<link rel="prev" href="synchronization.html" title="Synchronization">
<link rel="next" href="sds.html" title="Synchronized Data Structures">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
<td align="center"><a href="../../../index.html">Home</a></td>
<td align="center"><a href="../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="synchronization.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../thread.html"><img src="../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="sds.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="thread.thread_local_storage"></a><a class="link" href="thread_local_storage.html" title="Thread Local Storage">Thread Local Storage</a>
</h2></div></div></div>
<div class="toc"><dl class="toc"><dt><span class="section"><a href="thread_local_storage.html#thread.thread_local_storage.thread_specific_ptr">Class
<code class="computeroutput"><span class="identifier">thread_specific_ptr</span></code></a></span></dt></dl></div>
<h4>
<a name="thread.thread_local_storage.h0"></a>
<span class="phrase"><a name="thread.thread_local_storage.synopsis"></a></span><a class="link" href="thread_local_storage.html#thread.thread_local_storage.synopsis">Synopsis</a>
</h4>
<p>
Thread local storage allows multi-threaded applications to have a separate
instance of a given data item for each thread. Where a single-threaded application
would use static or global data, this could lead to contention, deadlock or
data corruption in a multi-threaded application. One example is the C <code class="computeroutput"><span class="identifier">errno</span></code> variable, used for storing the error
code related to functions from the Standard C library. It is common practice
(and required by POSIX) for compilers that support multi-threaded applications
to provide a separate instance of <code class="computeroutput"><span class="identifier">errno</span></code>
for each thread, in order to avoid different threads competing to read or update
the value.
</p>
<p>
Though compilers often provide this facility in the form of extensions to the
declaration syntax (such as <code class="computeroutput"><span class="identifier">__declspec</span><span class="special">(</span><span class="identifier">thread</span><span class="special">)</span></code>
or <code class="computeroutput"><a class="link" href="thread_management.html#thread.thread_management.thread" title="Class thread"><code class="computeroutput"><span class="identifier">thread</span></code></a></code>
annotations on <code class="computeroutput"><span class="keyword">static</span></code> or namespace-scope
variable declarations), such support is non-portable, and is often limited
in some way, such as only supporting POD types.
</p>
<h4>
<a name="thread.thread_local_storage.h1"></a>
<span class="phrase"><a name="thread.thread_local_storage.portable_thread_local_storage_with__code__phrase_role__identifier__boost__phrase__phrase_role__special______phrase__phrase_role__identifier__thread_specific_ptr__phrase___code_"></a></span><a class="link" href="thread_local_storage.html#thread.thread_local_storage.portable_thread_local_storage_with__code__phrase_role__identifier__boost__phrase__phrase_role__special______phrase__phrase_role__identifier__thread_specific_ptr__phrase___code_">Portable
thread-local storage with <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">thread_specific_ptr</span></code></a>
</h4>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">thread_specific_ptr</span></code> provides a portable mechanism
for thread-local storage that works on all compilers supported by <span class="bold"><strong>Boost.Thread</strong></span>. Each instance of <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">thread_specific_ptr</span></code>
represents a pointer to an object (such as <code class="computeroutput"><span class="identifier">errno</span></code>)
where each thread must have a distinct value. The value for the current thread
can be obtained using the <code class="computeroutput"><span class="identifier">get</span><span class="special">()</span></code> member function, or by using the <code class="computeroutput"><span class="special">*</span></code> and <code class="computeroutput"><span class="special">-&gt;</span></code>
pointer deference operators. Initially the pointer has a value of <code class="computeroutput"><span class="identifier">NULL</span></code> in each thread, but the value for the
current thread can be set using the <code class="computeroutput"><span class="identifier">reset</span><span class="special">()</span></code> member function.
</p>
<p>
If the value of the pointer for the current thread is changed using <code class="computeroutput"><span class="identifier">reset</span><span class="special">()</span></code>,
then the previous value is destroyed by calling the cleanup routine. Alternatively,
the stored value can be reset to <code class="computeroutput"><span class="identifier">NULL</span></code>
and the prior value returned by calling the <code class="computeroutput"><span class="identifier">release</span><span class="special">()</span></code> member function, allowing the application
to take back responsibility for destroying the object.
</p>
<h4>
<a name="thread.thread_local_storage.h2"></a>
<span class="phrase"><a name="thread.thread_local_storage.cleanup_at_thread_exit"></a></span><a class="link" href="thread_local_storage.html#thread.thread_local_storage.cleanup_at_thread_exit">Cleanup
at thread exit</a>
</h4>
<p>
When a thread exits, the objects associated with each <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">thread_specific_ptr</span></code>
instance are destroyed. By default, the object pointed to by a pointer <code class="computeroutput"><span class="identifier">p</span></code> is destroyed by invoking <code class="computeroutput"><span class="keyword">delete</span> <span class="identifier">p</span></code>,
but this can be overridden for a specific instance of <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">thread_specific_ptr</span></code>
by providing a cleanup routine to the constructor. In this case, the object
is destroyed by invoking <code class="computeroutput"><span class="identifier">func</span><span class="special">(</span><span class="identifier">p</span><span class="special">)</span></code>
where <code class="computeroutput"><span class="identifier">func</span></code> is the cleanup routine
supplied to the constructor. The cleanup functions are called in an unspecified
order. If a cleanup routine sets the value of associated with an instance of
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">thread_specific_ptr</span></code> that has already been
cleaned up, that value is added to the cleanup list. Cleanup finishes when
there are no outstanding instances of <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">thread_specific_ptr</span></code>
with values.
</p>
<p>
Note: on some platforms, cleanup of thread-specific data is not performed for
threads created with the platform's native API. On those platforms such cleanup
is only done for threads that are started with <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">thread</span></code>
unless <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">on_thread_exit</span><span class="special">()</span></code>
is called manually from that thread.
</p>
<h4>
<a name="thread.thread_local_storage.h3"></a>
<span class="phrase"><a name="thread.thread_local_storage.rationale_about_the_nature_of_the_key"></a></span><a class="link" href="thread_local_storage.html#thread.thread_local_storage.rationale_about_the_nature_of_the_key">Rationale
about the nature of the key</a>
</h4>
<p>
Boost.Thread uses the address of the <code class="computeroutput"><span class="identifier">thread_specific_ptr</span></code>
instance as key of the thread specific pointers. This avoids to create/destroy
a key which will need a lock to protect from race conditions. This has a little
performance liability, as the access must be done using an associative container.
</p>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="thread.thread_local_storage.thread_specific_ptr"></a><a class="link" href="thread_local_storage.html#thread.thread_local_storage.thread_specific_ptr" title="Class thread_specific_ptr">Class
<code class="computeroutput"><span class="identifier">thread_specific_ptr</span></code></a>
</h3></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="thread_local_storage.html#thread.thread_local_storage.thread_specific_ptr.default_constructor"><code class="computeroutput"><span class="identifier">thread_specific_ptr</span><span class="special">();</span></code></a></span></dt>
<dt><span class="section"><a href="thread_local_storage.html#thread.thread_local_storage.thread_specific_ptr.constructor_with_custom_cleanup"><code class="computeroutput"><span class="keyword">explicit</span> <span class="identifier">thread_specific_ptr</span><span class="special">(</span><span class="keyword">void</span> <span class="special">(*</span><span class="identifier">cleanup_function</span><span class="special">)(</span><span class="identifier">T</span><span class="special">*));</span></code></a></span></dt>
<dt><span class="section"><a href="thread_local_storage.html#thread.thread_local_storage.thread_specific_ptr.destructor"><code class="computeroutput"><span class="special">~</span><span class="identifier">thread_specific_ptr</span><span class="special">();</span></code></a></span></dt>
<dt><span class="section"><a href="thread_local_storage.html#thread.thread_local_storage.thread_specific_ptr.get"><code class="computeroutput"><span class="identifier">T</span><span class="special">*</span> <span class="identifier">get</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code></a></span></dt>
<dt><span class="section"><a href="thread_local_storage.html#thread.thread_local_storage.thread_specific_ptr.operator_arrow"><code class="computeroutput"><span class="identifier">T</span><span class="special">*</span> <span class="keyword">operator</span><span class="special">-&gt;()</span> <span class="keyword">const</span><span class="special">;</span></code></a></span></dt>
<dt><span class="section"><a href="thread_local_storage.html#thread.thread_local_storage.thread_specific_ptr.operator_star"><code class="computeroutput"><span class="identifier">T</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">*()</span> <span class="keyword">const</span><span class="special">;</span></code></a></span></dt>
<dt><span class="section"><a href="thread_local_storage.html#thread.thread_local_storage.thread_specific_ptr.reset"><code class="computeroutput"><span class="keyword">void</span> <span class="identifier">reset</span><span class="special">(</span><span class="identifier">T</span><span class="special">*</span>
<span class="identifier">new_value</span><span class="special">=</span><span class="number">0</span><span class="special">);</span></code></a></span></dt>
<dt><span class="section"><a href="thread_local_storage.html#thread.thread_local_storage.thread_specific_ptr.release"><code class="computeroutput"><span class="identifier">T</span><span class="special">*</span> <span class="identifier">release</span><span class="special">();</span></code></a></span></dt>
</dl></div>
<pre class="programlisting"><span class="comment">// #include &lt;boost/thread/tss.hpp&gt;</span>
<span class="keyword">namespace</span> <span class="identifier">boost</span>
<span class="special">{</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">thread_specific_ptr</span>
<span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="identifier">thread_specific_ptr</span><span class="special">();</span>
<span class="keyword">explicit</span> <span class="identifier">thread_specific_ptr</span><span class="special">(</span><span class="keyword">void</span> <span class="special">(*</span><span class="identifier">cleanup_function</span><span class="special">)(</span><span class="identifier">T</span><span class="special">*));</span>
<span class="special">~</span><span class="identifier">thread_specific_ptr</span><span class="special">();</span>
<span class="identifier">T</span><span class="special">*</span> <span class="identifier">get</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
<span class="identifier">T</span><span class="special">*</span> <span class="keyword">operator</span><span class="special">-&gt;()</span> <span class="keyword">const</span><span class="special">;</span>
<span class="identifier">T</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">*()</span> <span class="keyword">const</span><span class="special">;</span>
<span class="identifier">T</span><span class="special">*</span> <span class="identifier">release</span><span class="special">();</span>
<span class="keyword">void</span> <span class="identifier">reset</span><span class="special">(</span><span class="identifier">T</span><span class="special">*</span> <span class="identifier">new_value</span><span class="special">=</span><span class="number">0</span><span class="special">);</span>
<span class="special">};</span>
<span class="special">}</span>
</pre>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.thread_local_storage.thread_specific_ptr.default_constructor"></a><a class="link" href="thread_local_storage.html#thread.thread_local_storage.thread_specific_ptr.default_constructor" title="thread_specific_ptr();"><code class="computeroutput"><span class="identifier">thread_specific_ptr</span><span class="special">();</span></code></a>
</h4></div></div></div>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Requires:</span></dt>
<dd><p>
<code class="computeroutput"><span class="keyword">delete</span> <span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">get</span><span class="special">()</span></code> is well-formed.
</p></dd>
<dt><span class="term">Effects:</span></dt>
<dd><p>
Construct a <code class="computeroutput"><span class="identifier">thread_specific_ptr</span></code>
object for storing a pointer to an object of type <code class="computeroutput"><span class="identifier">T</span></code>
specific to each thread. The default <code class="computeroutput"><span class="keyword">delete</span></code>-based
cleanup function will be used to destroy any thread-local objects
when <code class="computeroutput"><span class="identifier">reset</span><span class="special">()</span></code>
is called, or the thread exits.
</p></dd>
<dt><span class="term">Throws:</span></dt>
<dd><p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">thread_resource_error</span></code> if an error
occurs.
</p></dd>
</dl>
</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.thread_local_storage.thread_specific_ptr.constructor_with_custom_cleanup"></a><a class="link" href="thread_local_storage.html#thread.thread_local_storage.thread_specific_ptr.constructor_with_custom_cleanup" title="explicit thread_specific_ptr(void (*cleanup_function)(T*));"><code class="computeroutput"><span class="keyword">explicit</span> <span class="identifier">thread_specific_ptr</span><span class="special">(</span><span class="keyword">void</span> <span class="special">(*</span><span class="identifier">cleanup_function</span><span class="special">)(</span><span class="identifier">T</span><span class="special">*));</span></code></a>
</h4></div></div></div>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Requires:</span></dt>
<dd><p>
<code class="computeroutput"><span class="identifier">cleanup_function</span><span class="special">(</span><span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">get</span><span class="special">())</span></code> does not throw any exceptions.
</p></dd>
<dt><span class="term">Effects:</span></dt>
<dd><p>
Construct a <code class="computeroutput"><span class="identifier">thread_specific_ptr</span></code>
object for storing a pointer to an object of type <code class="computeroutput"><span class="identifier">T</span></code>
specific to each thread. The supplied <code class="computeroutput"><span class="identifier">cleanup_function</span></code>
will be used to destroy any thread-local objects when <code class="computeroutput"><span class="identifier">reset</span><span class="special">()</span></code>
is called, or the thread exits.
</p></dd>
<dt><span class="term">Throws:</span></dt>
<dd><p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">thread_resource_error</span></code> if an error
occurs.
</p></dd>
</dl>
</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.thread_local_storage.thread_specific_ptr.destructor"></a><a class="link" href="thread_local_storage.html#thread.thread_local_storage.thread_specific_ptr.destructor" title="~thread_specific_ptr();"><code class="computeroutput"><span class="special">~</span><span class="identifier">thread_specific_ptr</span><span class="special">();</span></code></a>
</h4></div></div></div>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Requires:</span></dt>
<dd><p>
All the thread specific instances associated to this thread_specific_ptr
(except maybe the one associated to this thread) must be null.
</p></dd>
<dt><span class="term">Effects:</span></dt>
<dd><p>
Calls <code class="computeroutput"><span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">reset</span><span class="special">()</span></code>
to clean up the associated value for the current thread, and destroys
<code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
</p></dd>
<dt><span class="term">Throws:</span></dt>
<dd><p>
Nothing.
</p></dd>
<dt><span class="term">Remarks:</span></dt>
<dd><p>
The requirement is due to the fact that in order to delete all these
instances, the implementation should be forced to maintain a list
of all the threads having an associated specific ptr, which is against
the goal of thread specific data.
</p></dd>
</dl>
</div>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
Care needs to be taken to ensure that any threads still running after
an instance of <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">thread_specific_ptr</span></code>
has been destroyed do not call any member functions on that instance.
</p></td></tr>
</table></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.thread_local_storage.thread_specific_ptr.get"></a><a class="link" href="thread_local_storage.html#thread.thread_local_storage.thread_specific_ptr.get" title="T* get() const;"><code class="computeroutput"><span class="identifier">T</span><span class="special">*</span> <span class="identifier">get</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code></a>
</h4></div></div></div>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Returns:</span></dt>
<dd><p>
The pointer associated with the current thread.
</p></dd>
<dt><span class="term">Throws:</span></dt>
<dd><p>
Nothing.
</p></dd>
</dl>
</div>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
The initial value associated with an instance of <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">thread_specific_ptr</span></code>
is <code class="computeroutput"><span class="identifier">NULL</span></code> for each thread.
</p></td></tr>
</table></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.thread_local_storage.thread_specific_ptr.operator_arrow"></a><a class="link" href="thread_local_storage.html#thread.thread_local_storage.thread_specific_ptr.operator_arrow" title="T* operator-&gt;() const;"><code class="computeroutput"><span class="identifier">T</span><span class="special">*</span> <span class="keyword">operator</span><span class="special">-&gt;()</span> <span class="keyword">const</span><span class="special">;</span></code></a>
</h4></div></div></div>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Returns:</span></dt>
<dd><p>
<code class="computeroutput"><span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">get</span><span class="special">()</span></code>
</p></dd>
<dt><span class="term">Throws:</span></dt>
<dd><p>
Nothing.
</p></dd>
</dl>
</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.thread_local_storage.thread_specific_ptr.operator_star"></a><a class="link" href="thread_local_storage.html#thread.thread_local_storage.thread_specific_ptr.operator_star" title="T&amp; operator*() const;"><code class="computeroutput"><span class="identifier">T</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">*()</span> <span class="keyword">const</span><span class="special">;</span></code></a>
</h4></div></div></div>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Requires:</span></dt>
<dd><p>
<code class="computeroutput"><span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">get</span></code> is not <code class="computeroutput"><span class="identifier">NULL</span></code>.
</p></dd>
<dt><span class="term">Returns:</span></dt>
<dd><p>
<code class="computeroutput"><span class="special">*(</span><span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">get</span><span class="special">())</span></code>
</p></dd>
<dt><span class="term">Throws:</span></dt>
<dd><p>
Nothing.
</p></dd>
</dl>
</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.thread_local_storage.thread_specific_ptr.reset"></a><a class="link" href="thread_local_storage.html#thread.thread_local_storage.thread_specific_ptr.reset" title="void reset(T* new_value=0);"><code class="computeroutput"><span class="keyword">void</span> <span class="identifier">reset</span><span class="special">(</span><span class="identifier">T</span><span class="special">*</span>
<span class="identifier">new_value</span><span class="special">=</span><span class="number">0</span><span class="special">);</span></code></a>
</h4></div></div></div>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Effects:</span></dt>
<dd><p>
If <code class="computeroutput"><span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">get</span><span class="special">()!=</span><span class="identifier">new_value</span></code> and <code class="computeroutput"><span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">get</span><span class="special">()</span></code> is non-<code class="computeroutput"><span class="identifier">NULL</span></code>,
invoke <code class="computeroutput"><span class="keyword">delete</span> <span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">get</span><span class="special">()</span></code> or <code class="computeroutput"><span class="identifier">cleanup_function</span><span class="special">(</span><span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">get</span><span class="special">())</span></code> as appropriate. Store <code class="computeroutput"><span class="identifier">new_value</span></code> as the pointer associated
with the current thread.
</p></dd>
<dt><span class="term">Postcondition:</span></dt>
<dd><p>
<code class="computeroutput"><span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">get</span><span class="special">()==</span><span class="identifier">new_value</span></code>
</p></dd>
<dt><span class="term">Throws:</span></dt>
<dd><p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">thread_resource_error</span></code> if an error
occurs.
</p></dd>
</dl>
</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.thread_local_storage.thread_specific_ptr.release"></a><a class="link" href="thread_local_storage.html#thread.thread_local_storage.thread_specific_ptr.release" title="T* release();"><code class="computeroutput"><span class="identifier">T</span><span class="special">*</span> <span class="identifier">release</span><span class="special">();</span></code></a>
</h4></div></div></div>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Effects:</span></dt>
<dd><p>
Return <code class="computeroutput"><span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">get</span><span class="special">()</span></code>
and store <code class="computeroutput"><span class="identifier">NULL</span></code> as
the pointer associated with the current thread without invoking the
cleanup function.
</p></dd>
<dt><span class="term">Postcondition:</span></dt>
<dd><p>
<code class="computeroutput"><span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">get</span><span class="special">()==</span><span class="number">0</span></code>
</p></dd>
<dt><span class="term">Throws:</span></dt>
<dd><p>
Nothing.
</p></dd>
</dl>
</div>
</div>
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2007 -11 Anthony Williams<br>Copyright © 2011 -17 Vicente J. Botet Escriba<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="synchronization.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../thread.html"><img src="../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="sds.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

File diff suppressed because it is too large Load Diff

180
doc/html/thread/time.html Normal file
View File

@@ -0,0 +1,180 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Time Requirements</title>
<link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
<link rel="up" href="../thread.html" title="Chapter 40. Thread 4.8.0">
<link rel="prev" href="parallel.html" title="Parallel - Fork-Join -- EXPERIMENTAL">
<link rel="next" href="emulations.html" title="Emulations">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
<td align="center"><a href="../../../index.html">Home</a></td>
<td align="center"><a href="../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="parallel.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../thread.html"><img src="../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="emulations.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="thread.time"></a><a class="link" href="time.html" title="Time Requirements">Time Requirements</a>
</h2></div></div></div>
<div class="toc"><dl class="toc"><dt><span class="section"><a href="time.html#thread.time.deprecated">Deprecated</a></span></dt></dl></div>
<p>
As of Boost 1.50.0, the <span class="bold"><strong>Boost.Thread</strong></span> library
uses Boost.Chrono library for all operations that require a time out as defined
in the standard c++11. These include (but are not limited to):
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">this_thread</span><span class="special">::</span><a class="link" href="thread_management.html#thread.thread_management.this_thread.sleep_for" title="Non-member function sleep_for()"><code class="computeroutput"><span class="identifier">sleep_for</span></code></a></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">this_thread</span><span class="special">::</span><a class="link" href="thread_management.html#thread.thread_management.this_thread.sleep_until" title="Non-member function sleep_until()"><code class="computeroutput"><span class="identifier">sleep_until</span></code></a></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><a class="link" href="thread_management.html#thread.thread_management.thread" title="Class thread"><code class="computeroutput"><span class="identifier">thread</span></code></a><span class="special">::</span><a class="link" href="thread_management.html#thread.thread_management.thread.try_join_for" title="Member function try_join_for() EXTENSION"><code class="computeroutput"><span class="identifier">try_join_for</span></code></a></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><a class="link" href="thread_management.html#thread.thread_management.thread" title="Class thread"><code class="computeroutput"><span class="identifier">thread</span></code></a><span class="special">::</span><a class="link" href="thread_management.html#thread.thread_management.thread.try_join_until" title="Member function try_join_until() EXTENSION"><code class="computeroutput"><span class="identifier">try_join_until</span></code></a></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><a class="link" href="synchronization.html#thread.synchronization.condvar_ref.condition_variable" title="Class condition_variable"><code class="computeroutput"><span class="identifier">condition_variable</span></code></a><span class="special">::</span><a class="link" href="synchronization.html#thread.synchronization.condvar_ref.condition_variable.wait_for" title="template &lt;class Rep, class Period&gt; cv_status wait_for(boost::unique_lock&lt;boost::mutex&gt;&amp; lock, const chrono::duration&lt;Rep, Period&gt;&amp; rel_time)"><code class="computeroutput"><span class="identifier">wait_for</span></code></a></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><a class="link" href="synchronization.html#thread.synchronization.condvar_ref.condition_variable" title="Class condition_variable"><code class="computeroutput"><span class="identifier">condition_variable</span></code></a><span class="special">::</span><a class="link" href="synchronization.html#thread.synchronization.condvar_ref.condition_variable.wait_until" title="template &lt;class Clock, class Duration&gt; cv_status wait_until(boost::unique_lock&lt;boost::mutex&gt;&amp; lock, const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time)"><code class="computeroutput"><span class="identifier">wait_until</span></code></a></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><a class="link" href="synchronization.html#thread.synchronization.condvar_ref.condition_variable_any" title="Class condition_variable_any"><code class="computeroutput"><span class="identifier">condition_variable_any</span></code></a><span class="special">::</span><a class="link" href="synchronization.html#thread.synchronization.condvar_ref.condition_variable_any.wait_for" title="template &lt;class lock_type, class Rep, class Period&gt; cv_status wait_for(lock_type&amp; lock, const chrono::duration&lt;Rep, Period&gt;&amp; rel_time)"><code class="computeroutput"><span class="identifier">wait_for</span></code></a></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><a class="link" href="synchronization.html#thread.synchronization.condvar_ref.condition_variable_any" title="Class condition_variable_any"><code class="computeroutput"><span class="identifier">condition_variable_any</span></code></a><span class="special">::</span><a class="link" href="synchronization.html#thread.synchronization.condvar_ref.condition_variable_any.wait_until" title="template &lt;class lock_type, class Clock, class Duration&gt; cv_status wait_until(lock_type&amp; lock, const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time)"><code class="computeroutput"><span class="identifier">wait_until</span></code></a></code>
</li>
<li class="listitem">
<code class="computeroutput"><a class="link" href="synchronization.html#thread.synchronization.mutex_concepts.timed_lockable" title="TimedLockable Concept"><code class="computeroutput"><span class="identifier">TimedLockable</span></code></a><span class="special">::</span><a class="link" href="synchronization.html#thread.synchronization.mutex_concepts.timed_lockable.try_lock_for" title="m.try_lock_for(rel_time)"><code class="computeroutput"><span class="identifier">try_lock_for</span></code></a></code>
</li>
<li class="listitem">
<code class="computeroutput"><a class="link" href="synchronization.html#thread.synchronization.mutex_concepts.timed_lockable" title="TimedLockable Concept"><code class="computeroutput"><span class="identifier">TimedLockable</span></code></a><span class="special">::</span><a class="link" href="synchronization.html#thread.synchronization.mutex_concepts.timed_lockable.try_lock_until" title="m.try_lock_until(abs_time)"><code class="computeroutput"><span class="identifier">try_lock_until</span></code></a></code>
</li>
</ul></div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="thread.time.deprecated"></a><a class="link" href="time.html#thread.time.deprecated" title="Deprecated">Deprecated</a>
</h3></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="time.html#thread.time.deprecated.system_time">Typedef <code class="computeroutput"><span class="identifier">system_time</span></code></a></span></dt>
<dt><span class="section"><a href="time.html#thread.time.deprecated.get_system_time">Non-member
function <code class="computeroutput"><span class="identifier">get_system_time</span><span class="special">()</span></code></a></span></dt>
</dl></div>
<p>
The time related functions introduced in Boost 1.35.0, using the <a class="link" href="../date_time.html" title="Chapter 13. Boost.Date_Time">Boost.Date_Time</a>
library are deprecated. These include (but are not limited to):
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
<a class="link" href="thread_management.html#thread.thread_management.this_thread.sleep" title="Non-member function sleep() DEPRECATED"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">this_thread</span><span class="special">::</span><span class="identifier">sleep</span><span class="special">()</span></code></a>
</li>
<li class="listitem">
<a class="link" href="thread_management.html#thread.thread_management.thread.timed_join" title="Member function timed_join() DEPRECATED"><code class="computeroutput"><span class="identifier">timed_join</span><span class="special">()</span></code></a>
</li>
<li class="listitem">
<a class="link" href="synchronization.html#thread.synchronization.condvar_ref.condition_variable.timed_wait" title="bool timed_wait(boost::unique_lock&lt;boost::mutex&gt;&amp; lock,boost::system_time const&amp; abs_time)"><code class="computeroutput"><span class="identifier">timed_wait</span><span class="special">()</span></code></a>
</li>
<li class="listitem">
<a class="link" href="synchronization.html#thread.synchronization.mutex_concepts.timed_lockable.timed_lock" title="m.timed_lock(abs_time)"><code class="computeroutput"><span class="identifier">timed_lock</span><span class="special">()</span></code></a>
</li>
</ul></div>
<p>
For the overloads that accept an absolute time parameter, an object of type
<a class="link" href="time.html#thread.time.deprecated.system_time" title="Typedef system_time"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">system_time</span></code></a>
is required. Typically, this will be obtained by adding a duration to the
current time, obtained with a call to <a class="link" href="time.html#thread.time.deprecated.get_system_time" title="Non-member function get_system_time()"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">get_system_time</span><span class="special">()</span></code></a>.
e.g.
</p>
<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">system_time</span> <span class="keyword">const</span> <span class="identifier">timeout</span><span class="special">=</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">get_system_time</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">posix_time</span><span class="special">::</span><span class="identifier">milliseconds</span><span class="special">(</span><span class="number">500</span><span class="special">);</span>
<span class="keyword">extern</span> <span class="keyword">bool</span> <span class="identifier">done</span><span class="special">;</span>
<span class="keyword">extern</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">mutex</span> <span class="identifier">m</span><span class="special">;</span>
<span class="keyword">extern</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">condition_variable</span> <span class="identifier">cond</span><span class="special">;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">unique_lock</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mutex</span><span class="special">&gt;</span> <span class="identifier">lk</span><span class="special">(</span><span class="identifier">m</span><span class="special">);</span>
<span class="keyword">while</span><span class="special">(!</span><span class="identifier">done</span><span class="special">)</span>
<span class="special">{</span>
<span class="keyword">if</span><span class="special">(!</span><span class="identifier">cond</span><span class="special">.</span><span class="identifier">timed_wait</span><span class="special">(</span><span class="identifier">lk</span><span class="special">,</span><span class="identifier">timeout</span><span class="special">))</span>
<span class="special">{</span>
<span class="keyword">throw</span> <span class="string">"timed out"</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">}</span>
</pre>
<p>
For the overloads that accept a <span class="emphasis"><em>TimeDuration</em></span> parameter,
an object of any type that meets the <a class="link" href="../date_time/posix_time.html#date_time.posix_time.time_duration" title="Time Duration">Boost.Date_Time
Time Duration requirements</a> can be used, e.g.
</p>
<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">this_thread</span><span class="special">::</span><span class="identifier">sleep</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">posix_time</span><span class="special">::</span><span class="identifier">milliseconds</span><span class="special">(</span><span class="number">25</span><span class="special">));</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">mutex</span> <span class="identifier">m</span><span class="special">;</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">m</span><span class="special">.</span><span class="identifier">timed_lock</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">posix_time</span><span class="special">::</span><span class="identifier">nanoseconds</span><span class="special">(</span><span class="number">100</span><span class="special">)))</span>
<span class="special">{</span>
<span class="comment">// ...</span>
<span class="special">}</span>
</pre>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.time.deprecated.system_time"></a><a class="link" href="time.html#thread.time.deprecated.system_time" title="Typedef system_time">Typedef <code class="computeroutput"><span class="identifier">system_time</span></code></a>
</h4></div></div></div>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">thread</span><span class="special">/</span><span class="identifier">thread_time</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">posix_time</span><span class="special">::</span><span class="identifier">ptime</span> <span class="identifier">system_time</span><span class="special">;</span>
</pre>
<p>
See the documentation for <a class="link" href="../date_time/posix_time.html#date_time.posix_time.ptime_class" title="Ptime"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">posix_time</span><span class="special">::</span><span class="identifier">ptime</span></code></a> in the Boost.Date_Time library.
</p>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="thread.time.deprecated.get_system_time"></a><a class="link" href="time.html#thread.time.deprecated.get_system_time" title="Non-member function get_system_time()">Non-member
function <code class="computeroutput"><span class="identifier">get_system_time</span><span class="special">()</span></code></a>
</h4></div></div></div>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">thread</span><span class="special">/</span><span class="identifier">thread_time</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="identifier">system_time</span> <span class="identifier">get_system_time</span><span class="special">();</span>
</pre>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Returns:</span></dt>
<dd><p>
The current time.
</p></dd>
<dt><span class="term">Throws:</span></dt>
<dd><p>
Nothing.
</p></dd>
</dl>
</div>
</div>
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2007 -11 Anthony Williams<br>Copyright © 2011 -17 Vicente J. Botet Escriba<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="parallel.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../thread.html"><img src="../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="emulations.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>