~ubuntu-branches/ubuntu/jaunty/asio/jaunty

<h1><a class="anchor" name="tuttimer5">Timer.5 - Synchronising handlers in multithreaded programs</a></h1>This tutorial demonstrates the use of the <a class="elRef" doxygen="asio.doxytags:../reference/" href="../reference/a00126.html#3be3fa00c86ab58ba41aabe8fcbf11be">asio::strand</a> class to synchronise callback handlers in a multithreaded program.<p>

The previous four tutorials avoided the issue of handler synchronisation by calling the <a class="elRef" doxygen="asio.doxytags:../reference/" href="../reference/a00032.html#c84bed0d1dd061bc71010ba1228439da">asio::io_service::run()</a> function from one thread only. As you already know, the asio library provides a guarantee that callback handlers will <b>only</b> be called from threads that are currently calling <a class="elRef" doxygen="asio.doxytags:../reference/" href="../reference/a00032.html#c84bed0d1dd061bc71010ba1228439da">asio::io_service::run()</a>. Consequently, calling <a class="elRef" doxygen="asio.doxytags:../reference/" href="../reference/a00032.html#c84bed0d1dd061bc71010ba1228439da">asio::io_service::run()</a> from only one thread ensures that callback handlers cannot run concurrently.<p>

The single threaded approach is usually the best place to start when developing applications using asio. The downside is the limitations it places on programs, particularly servers, including:<p>

<ul>

<li>

Poor responsiveness when handlers can take a long time to complete. </li>

<li>

An inability to scale on multiprocessor systems. </li>

</ul>

<p>

If you find yourself running into these limitations, an alternative approach is to have a pool of threads calling <a class="elRef" doxygen="asio.doxytags:../reference/" href="../reference/a00032.html#c84bed0d1dd061bc71010ba1228439da">asio::io_service::run()</a>. However, as this allows handlers to execute concurrently, we need a method of synchronisation when handlers might be accessing a shared, thread-unsafe resource.<p>

<div class="fragment"><pre class="fragment"><span class="preprocessor">#include <iostream></span>

<span class="preprocessor">#include <asio.hpp></span>

<span class="preprocessor">#include <boost/bind.hpp></span>

<span class="preprocessor">#include <boost/date_time/posix_time/posix_time.hpp></span>

</pre></div><p>

We start by defining a class called <code>printer</code>, similar to the class in the previous tutorial. This class will extend the previous tutorial by running two timers in parallel.<p>

<span class="keyword">class </span>printer

{

<span class="keyword">public</span>:

</pre></div><p>

In addition to initialising a pair of <a class="elRef" doxygen="asio.doxytags:../reference/" href="../reference/a00126.html#9c1e57628983c6b9c45e9204228109b7">asio::deadline_timer</a> members, the constructor initialises the <code>strand_</code> member, an object of type <a class="elRef" doxygen="asio.doxytags:../reference/" href="../reference/a00126.html#3be3fa00c86ab58ba41aabe8fcbf11be">asio::strand</a>.<p>

An <a class="elRef" doxygen="asio.doxytags:../reference/" href="../reference/a00126.html#3be3fa00c86ab58ba41aabe8fcbf11be">asio::strand</a> guarantees that, for those handlers that are dispatched through it, an executing handler will be allowed to complete before the next one is started. This is guaranteed irrespective of the number of threads that are calling <a class="elRef" doxygen="asio.doxytags:../reference/" href="../reference/a00032.html#c84bed0d1dd061bc71010ba1228439da">asio::io_service::run()</a>. Of course, the handlers may still execute concurrently with other handlers that were <b>not</b> dispatched through an <a class="elRef" doxygen="asio.doxytags:../reference/" href="../reference/a00126.html#3be3fa00c86ab58ba41aabe8fcbf11be">asio::strand</a>, or were dispatched through a different <a class="elRef" doxygen="asio.doxytags:../reference/" href="../reference/a00126.html#3be3fa00c86ab58ba41aabe8fcbf11be">asio::strand</a> object.<p>

<div class="fragment"><pre class="fragment"> printer(<a class="codeRef" doxygen="asio.doxytags:../reference/" href="../reference/a00032.html">asio::io_service</a>& io)

: strand_(io),

timer1_(io, boost::posix_time::seconds(1)),

timer2_(io, boost::posix_time::seconds(1)),

count_(0)

{

</pre></div><p>

When initiating the asynchronous operations, each callback handler is "wrapped" using the <a class="elRef" doxygen="asio.doxytags:../reference/" href="../reference/a00126.html#3be3fa00c86ab58ba41aabe8fcbf11be">asio::strand</a> object. The <a class="elRef" doxygen="asio.doxytags:../reference/" href="../reference/a00035.html#ebaeb20a72830b4c6f4552fb30bff742">asio::strand::wrap()</a> function returns a new handler that automatically dispatches its contained handler through the <a class="elRef" doxygen="asio.doxytags:../reference/" href="../reference/a00126.html#3be3fa00c86ab58ba41aabe8fcbf11be">asio::strand</a> object. By wrapping the handlers using the same <a class="elRef" doxygen="asio.doxytags:../reference/" href="../reference/a00126.html#3be3fa00c86ab58ba41aabe8fcbf11be">asio::strand</a>, we are ensuring that they cannot execute concurrently.<p>

<div class="fragment"><pre class="fragment"> timer1_.async_wait(strand_.wrap(boost::bind(&printer::print1, <span class="keyword">this</span>)));

timer2_.async_wait(strand_.wrap(boost::bind(&printer::print2, <span class="keyword">this</span>)));

}

~printer()

{

std::cout << <span class="stringliteral">"Final count is "</span> << count_ << <span class="stringliteral">"\n"</span>;

}

</pre></div><p>

In a multithreaded program, the handlers for asynchronous operations should be synchronised if they access shared resources. In this tutorial, the shared resources used by the handlers (<code>print1</code> and <code>print2</code>) are <code>std::cout</code> and the <code>count_</code> data member.<p>

<span class="keywordtype">void</span> print1()

{

<span class="keywordflow">if</span> (count_ < 10)

{

std::cout << <span class="stringliteral">"Timer 1: "</span> << count_ << <span class="stringliteral">"\n"</span>;

++count_;

timer1_.expires_at(timer1_.expires_at() + boost::posix_time::seconds(1));

timer1_.async_wait(strand_.wrap(boost::bind(&printer::print1, <span class="keyword">this</span>)));

}

<span class="keywordtype">void</span> print2()

{

<span class="keywordflow">if</span> (count_ < 10)

{

std::cout << <span class="stringliteral">"Timer 2: "</span> << count_ << <span class="stringliteral">"\n"</span>;

++count_;

timer2_.expires_at(timer2_.expires_at() + boost::posix_time::seconds(1));

timer2_.async_wait(strand_.wrap(boost::bind(&printer::print2, <span class="keyword">this</span>)));

}

100

}

101

102

<span class="keyword">private</span>:

103

<a class="codeRef" doxygen="asio.doxytags:../reference/" href="../reference/a00035.html">asio::strand</a> strand_;

104

<a class="codeRef" doxygen="asio.doxytags:../reference/" href="../reference/a00006.html">asio::deadline_timer</a> timer1_;

105

<a class="codeRef" doxygen="asio.doxytags:../reference/" href="../reference/a00006.html">asio::deadline_timer</a> timer2_;

106

<span class="keywordtype">int</span> count_;

107

};

108

</pre></div><p>

109

The <code>main</code> function now causes <a class="elRef" doxygen="asio.doxytags:../reference/" href="../reference/a00032.html#c84bed0d1dd061bc71010ba1228439da">asio::io_service::run()</a> to be called from two threads: the main thread and one additional thread. This is accomplished using an <a class="elRef" doxygen="asio.doxytags:../reference/" href="../reference/a00052.html">asio::thread</a> object.<p>

110

Just as it would with a call from a single thread, concurrent calls to <a class="elRef" doxygen="asio.doxytags:../reference/" href="../reference/a00032.html#c84bed0d1dd061bc71010ba1228439da">asio::io_service::run()</a> will continue to execute while there is "work" left to do. The background thread will not exit until all asynchronous operations have completed.<p>

111

112

<span class="keywordtype">int</span> main()

113

{

114

<a class="codeRef" doxygen="asio.doxytags:../reference/" href="../reference/a00032.html">asio::io_service</a> io;

115

printer p(io);

116

<a class="codeRef" doxygen="asio.doxytags:../reference/" href="../reference/a00052.html">asio::thread</a> t(boost::bind(&<a class="codeRef" doxygen="asio.doxytags:../reference/" href="../reference/a00032.html#c84bed0d1dd061bc71010ba1228439da">asio::io_service::run</a>, &io));

117

io.<a class="codeRef" doxygen="asio.doxytags:../reference/" href="../reference/a00032.html#c84bed0d1dd061bc71010ba1228439da">run</a>();

118

t.join();

119

120

<span class="keywordflow">return</span> 0;

121

}

122

</pre></div><p>

123

See the <a class="el" href="tuttimer5src.html">full source listing</a> <br>

124

Return to the <a class="el" href="index.html#index">tutorial index</a> <br>

125

Previous: <a class="el" href="tuttimer4.html">Timer.4 - Using a member function as a handler</a> <br>

126

127

128

<TR>

129

130

131

</TD>

132

133

<A CLASS="qindex" HREF="../index.html">Home</A> |

134

<A CLASS="qindex" HREF="../reference/index.html">Reference</A> |

135

<A CLASS="qindex" HREF="../tutorial/index.html">Tutorial</A> |

136

<A CLASS="qindex" HREF="../examples/index.html">Examples</A> |

137

<A CLASS="qindex" HREF="../design/index.html">Design</A>

138

</TD>

139

</TR>

140

</TABLE>

141

</DIV>

142

</BODY>

143

</HTML>

Older »