mirror of
https://github.com/boostorg/thread.git
synced 2026-02-03 09:42:16 +00:00
Compare commits
5 Commits
svn-branch
...
boost-1.25
| Author | SHA1 | Date | |
|---|---|---|---|
|
4db2e35a33 | ||
|
ca2cf20cf3 | ||
|
|
b3acba1d2d | ||
|
|
6d2731c463 | ||
|
|
b7f8f8867c |
40
build/Jamfile
Normal file
40
build/Jamfile
Normal file
@@ -0,0 +1,40 @@
|
||||
# (C) Copyright William E. Kempf 2001. Permission to copy, use, modify, sell and
|
||||
# distribute this software is granted provided this copyright notice appears
|
||||
# in all copies. This software is provided "as is" without express or implied
|
||||
# warranty, and with no claim as to its suitability for any purpose.
|
||||
#
|
||||
# Boost.Threads build and test Jamfile
|
||||
#
|
||||
# Declares the following targets:
|
||||
# 1. libboost_thread, a static link library.
|
||||
# 1a. On Win32, a dynamic link library libboost_threadmon,
|
||||
# which must be used in conjunction with libboost_thread.
|
||||
|
||||
# declare the location of this subproject relative to the root
|
||||
subproject libs/thread/build ;
|
||||
|
||||
#######################
|
||||
|
||||
#
|
||||
# Declare the Boost.Threads static link library.
|
||||
#
|
||||
|
||||
# For Win32 we need to build a special DLL, libboost_threadmon, to handle
|
||||
# TSS destruction.
|
||||
if $(NT)
|
||||
{
|
||||
dll libboost_threadmon : ../src/threadmon.cpp
|
||||
# requirements
|
||||
: <threading>multi
|
||||
: debug release ;
|
||||
}
|
||||
|
||||
# Base names of the source files for libboost_thread
|
||||
CPP_SOURCES =
|
||||
condition mutex recursive_mutex semaphore thread tss xtime once ;
|
||||
|
||||
lib libboost_thread : ../src/$(CPP_SOURCES).cpp
|
||||
# requirements
|
||||
: <include>$(BOOST_ROOT)
|
||||
<threading>multi
|
||||
: debug release ;
|
||||
72
doc/acknowledgements.html
Normal file
72
doc/acknowledgements.html
Normal file
@@ -0,0 +1,72 @@
|
||||
<html>
|
||||
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
|
||||
<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
|
||||
<meta name="ProgId" content="FrontPage.Editor.Document">
|
||||
<title>Boost.Threads Acknowledgements</title>
|
||||
</head>
|
||||
|
||||
<body bgcolor="#FFFFFF" text="#000000">
|
||||
|
||||
<table border="0" cellpadding="7" cellspacing="0" width="100%">
|
||||
<tr>
|
||||
<td valign="top" width="300">
|
||||
<h3><img src="../../../c++boost.gif" alt="C++ Boost" width="277" height="86"></h3>
|
||||
</td>
|
||||
<td valign="top">
|
||||
<h1 align="center">Boost.Threads</h1>
|
||||
<h2 align="center">Acknowledgements</h2>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<h2>Acknowledgments</h2>
|
||||
|
||||
<p><a href="../../../people/william_kempf.htm">William E. Kempf</a> was the
|
||||
architect, designer, and implementor of <b>Boost.Threads</b>.</p>
|
||||
|
||||
<p>Important contributions were also made by Jeremy Siek (lots of input on
|
||||
the design and on the implementation), Alexander Terekhov (lots of input on
|
||||
the Win32 implementation, especially in regards to boost::condition, as well
|
||||
as a lot of explanation of POSIX behavior), Greg Colvin (lots of input on the
|
||||
design), and Paul Mclachlan, Thomas Matelich and Iain Hanson (for help in
|
||||
trying to get the build to work on other platforms).</p>
|
||||
|
||||
<p>The documentation was written by William E. Kempf. Beman Dawes provided
|
||||
additional documentation material and editing.</p>
|
||||
|
||||
<p>Discussions on the boost.org mailing list were essential in the development
|
||||
of <b>Boost.Threads</b>. As of August 1, 2001, participants included Alan Griffiths,
|
||||
Albrecht Fritzsche, Aleksey Gurtovoy, Alexander Terekhov, Andrew Green, Andy Sawyer,
|
||||
Asger Alstrup Nielsen, Beman Dawes, Bill Klein, Bill Rutiser, Bill Wade, Branko
|
||||
Èibej, Brent Verner, Craig Henderson, Csaba Szepesvari, Dale Peakall, Damian
|
||||
Dixon, Dan Nuffer, Darryl Green, Daryle Walker, David Abrahams, David Allan
|
||||
Finch, Dejan Jelovic, Dietmar Kuehl, Doug Gregor, Douglas Gregor, Duncan Harris,
|
||||
Ed Brey, Eric Swanson, Eugene Karpachov, Fabrice Truillot, Frank
|
||||
Gerlach, Gary Powell, Gernot Neppert, Geurt Vos, Ghazi Ramadan, Greg Colvin,
|
||||
Gregory Seidman, HYS, Iain Hanson, Ian Bruntlett, J Panzer, Jeff Garland, Jeff
|
||||
Paquette, Jens Maurer, Jeremy Siek, Jesse Jones, Joe Gottman, John (EBo) David,
|
||||
John Bandela, John Maddock, John Max Skaller, John Panzer, Jon Jagger , Karl
|
||||
Nelson, Kevlin Henney, KG Chandrasekhar, Levente Farkas, Lie-Quan Lee, Lois
|
||||
Goldthwaite, Luis Pedro Coelho, Marc Girod, Mark A. Borgerding, Mark Rodgers,
|
||||
Marshall Clow, Matthew Austern, Matthew Hurd, Michael D. Crawford, Michael H.
|
||||
Cox , Mike Haller, Miki Jovanovic, Nathan Myers, Paul Moore, Pavel Cisler, Peter
|
||||
Dimov, Petr Kocmid, Philip Nash, Rainer Deyke, Reid Sweatman, Ross Smith, Scott
|
||||
McCaskill, Shalom Reich , Steve Cleary, Steven Kirk, Thomas Holenstein, Thomas
|
||||
Matelich, Trevor Perrin, Valentin Bonnard, Vesa Karvonen, Wayne Miller, and
|
||||
William Kempf.</p>
|
||||
|
||||
<p>Apologies for anyone inadvertently missed.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->01 October, 2001<!--webbot bot="Timestamp" endspan i-checksum="38291" -->
|
||||
</p>
|
||||
|
||||
<p>©<i> Copyright <a href="mailto:williamkempf@hotmail.com">William E. Kempf</a>
|
||||
2001</i></p>
|
||||
|
||||
</body>
|
||||
|
||||
</html>
|
||||
145
doc/bibliography.html
Normal file
145
doc/bibliography.html
Normal file
@@ -0,0 +1,145 @@
|
||||
<html>
|
||||
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
|
||||
<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
|
||||
<meta name="ProgId" content="FrontPage.Editor.Document">
|
||||
<title>Boost.Threads Bibliography</title>
|
||||
</head>
|
||||
|
||||
<body bgcolor="#FFFFFF" text="#000000">
|
||||
|
||||
<table border="0" cellpadding="7" cellspacing="0" width="100%">
|
||||
<tr>
|
||||
<td valign="top" width="300">
|
||||
<h3><img src="../../../c++boost.gif" alt="C++ Boost" width="277" height="86"></h3>
|
||||
</td>
|
||||
<td valign="top">
|
||||
<h1 align="center">Boost.Threads</h1>
|
||||
<h2 align="center">Bibliography</h2>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
<h2>Bibliography</h2>
|
||||
<table border="0" cellpadding="5" width="777">
|
||||
<tr>
|
||||
<td width="102" valign="top" align="left"><b>[<a name="Andrews-83">Andrews
|
||||
83</a>]</b></td>
|
||||
<td width="645">
|
||||
Gregory R. Andrews, Fred B. Schneider, <cite>Concepts and Notations for Concurrent
|
||||
Programming</cite>, ACM Computing Surveys, Vol. 15, No. 1, March, 1983. <a href="http://www.acm.org/pubs/citations/journals/surveys/1983-15-1/p3-andrews/">http://www.acm.org/pubs/citations/journals/surveys/1983-15-1/p3-andrews/</a>
|
||||
<p>Good general background reading. Includes descriptions of Path
|
||||
Expressions, Message Passing, and Remote Procedure Call in addition to the
|
||||
basics.
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td width="102" valign="top" align="left"><b>[<a name="Boost">Boost</a>]</b></td>
|
||||
<td width="645">
|
||||
The <cite> Boost</cite> world-wide web site. <a href="http://www.boost.org">http://www.boost.org</a>
|
||||
<p>Boost.Threads is one of many Boost libraries. The Boost web site
|
||||
includes a great deal of documentation and general information which applies to
|
||||
all Boost libraries. Current copies of the libraries including documentation and
|
||||
test programs may be downloaded from the web site.
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td width="102" valign="top" align="left"><b>[<a name="Brinch-Hansen-73">Brinch
|
||||
Hansen 73</a>]</b></td>
|
||||
<td width="645">
|
||||
Per Brinch Hansen, <cite>Concurrent Programming Concepts</cite>, ACM Computing
|
||||
Surveys, Vol. 5, No. 4, December, 1973. <a href="http://www.acm.org/pubs/articles/journals/surveys/1973-5-4/p223-hansen/p223-hansen.pdf">http://www.acm.org/pubs/articles/journals/surveys/1973-5-4/p223-hansen/</a>
|
||||
<p>"This paper describes the evolution of language features for
|
||||
multiprogramming from event queues and semaphores to critical regions and
|
||||
monitors." Includes analysis of why <i>events</i> are considered
|
||||
error-prone. Also noteworthy because of an introductory quotation from
|
||||
Christopher Alexander; Brinch Hansen was years ahead of others in recognizing
|
||||
pattern concepts applied to software too.
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td width="102" valign="top" align="left"><b>]<a name="Butenhof-97">Butenhof
|
||||
97</a>]</b></td>
|
||||
<td width="645">
|
||||
<p> David R. Butenhof, <cite>Programming with
|
||||
POSIX Threads</cite>, Addison-Wesley 1997, ISBN 0-201-63392-2 <a href="http://cseng.aw.com/book/0,3828,0201633922,00.html">http://cseng.aw.com/book/0,3828,0201633922,00.html</a></p>
|
||||
<p>This is a very readable explanation of threads and how to use them. Many
|
||||
of the insights given apply to all multi-threaded programming, not just POSIX
|
||||
Threads.</p>
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td width="102" valign="top" align="left"><b>[<a name="Hoare-74">Hoare 74</a>]</b></td>
|
||||
<td width="645">
|
||||
<p>C.A.R Hoare, <cite> Monitors: An Operating System Structuring Concept</cite>,
|
||||
Communications of the ACM, Vol. 17, No. 10. October
|
||||
1974, pp. 549-557 <a href="http://www.acm.org/classics/feb96/">http://www.acm.org/classics/feb96/ </a></p>
|
||||
<p>Hoare and Brinch Hansen's work on Monitors is the basis for reliable
|
||||
multi-threading patterns. This is one of the most often referenced papers in
|
||||
all of computer science, and with good reason.</p>
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td width="102" valign="top" align="left"><b>[<a name="ISO-98">ISO 98</a>]</b></td>
|
||||
<td width="645">
|
||||
<p>ISO/IEC 14882:1998(E) <cite> Programming Language C++</cite> <a href="http://www.ansi.org">http://www.ansi.org</a></p>
|
||||
<p>This is the official C++ Standards
|
||||
document. Available from the ANSI (American
|
||||
National Standards Institute) Electronic Standards Store.</p>
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td width="102" valign="top" align="left"><b>[<a name="McDowell-89">McDowell
|
||||
89</a>]</b></td>
|
||||
<td width="645">
|
||||
Charles E McDowell, David P. Helmbold, <cite>Debugging Concurrent Programs</cite>,
|
||||
ACM Computing Surveys, Vol. 21, No. 2, December, 1989. <a href="http://www.acm.org/pubs/citations/journals/surveys/1989-21-4/p593-mcdowell/">http://www.acm.org/pubs/citations/journals/surveys/1989-21-4/p593-mcdowell/</a>
|
||||
<p>Identifies many of the unique failure modes and debugging difficulties
|
||||
associated with concurrent programs.
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td width="102" valign="top" align="left"> <b>[<a name="Schmidt">Schmidt</a>] </b></td>
|
||||
<td width="645">
|
||||
<p> Douglas C. Schmidt and Irfan Pyarali, <cite>Strategies for
|
||||
Implementing POSIX Condition Variables on Win32</cite>, Department of Computer Science, Washington University, St. Louis, Missouri.
|
||||
<a href="http://www.cs.wustl.edu/~schmidt/win32-cv-1.html">http://www.cs.wustl.edu/~schmidt/win32-cv-1.html</a></p>
|
||||
<p>Rationale for understanding Boost.Threads condition variables. Note that Alexander Terekhov found some bugs in
|
||||
the implementation given in this article, so pthreads-win32 and Boost.Threads
|
||||
are even more complicated yet.</p>
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td width="102" valign="top" align="left"> <b>[<a name="Schmidt-00">Schmidt
|
||||
00</a>] </b></td>
|
||||
<td width="645">
|
||||
<p> Douglas C. Schmidt, Michael Stal, Hans Rohnert and Frank Buschmann, <cite>Pattern-Oriented Software Architecture Volume 2 - Patterns for
|
||||
Concurrent and Networked Objects</cite>, Wiley 2000, ISBN 0-471-60695-2 <a href="http://www.wiley.com/Corporate/Website/Objects/Products/0,9049,104671,00.html">http://www.wiley.com/Corporate/Website/Objects/Products/0,9049,104671,00.html</a></p>
|
||||
<p>This is a very good explanation of how to apply several patterns useful for concurrent programming.
|
||||
Among the patterns documented is the Monitor Pattern mentioned frequently in the <b>Boost.Threads</b>
|
||||
documentation.</p>
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td width="102" valign="top" align="left"> <b>[<a name="Stroustrup-00">Stroustrup
|
||||
00</a>]</b></td>
|
||||
<td width="645">
|
||||
Bjarne Stroustrup, <cite> The C++ Programming Language</cite>, Special Edition, Addison-Wesley
|
||||
2000, ISBN 0-201-70073-5 <a href="http://cseng.aw.com/book/0,3828,0201700735,00.html">http://cseng.aw.com/book/0,3828,0201700735,00.html</a>
|
||||
<p>The first book a C++ programmer should own. Note that the 3rd edition
|
||||
(and subsequent editions like the Special Edition) has been rewritten to cover
|
||||
the ISO standard language and library.
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
<p>Note: The URL's above are provided in plain text form so that they will be visible
|
||||
on printed copies of this document.</p>
|
||||
<hr>
|
||||
<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %b %Y" startspan -->01 Oct 2001<!--webbot bot="Timestamp" endspan i-checksum="14990" -->
|
||||
</p>
|
||||
|
||||
<p>© Copyright Beman Dawes, 2001</p>
|
||||
|
||||
</body>
|
||||
|
||||
</html>
|
||||
128
doc/call_once.html
Normal file
128
doc/call_once.html
Normal file
@@ -0,0 +1,128 @@
|
||||
<html>
|
||||
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
|
||||
<meta name="keywords" content="threads, Boost.Threads, thread library, C++">
|
||||
<link rel="stylesheet" type="text/css" href="styles.css">
|
||||
<title>Boost.Threads, call_once</title>
|
||||
</head>
|
||||
|
||||
<body bgcolor="#FFFFFF" link="#0000FF" vlink="#800080">
|
||||
|
||||
<table border="0" cellpadding="7" cellspacing="0" width="100%">
|
||||
<tr>
|
||||
<td valign="top" width="300">
|
||||
<h3><img src="../../../c++boost.gif" alt="C++ Boost" width="277" height="86"></h3>
|
||||
</td>
|
||||
<td valign="top">
|
||||
<h1 align="center">Boost.Threads</h1>
|
||||
<h2 align="center">call_once</h2>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<hr>
|
||||
|
||||
<p><A href="#Introduction">Introduction</A><br>
|
||||
<A href="#Header">Header</A><br>
|
||||
<A href="#Synopsis">Synopsis</A><br>
|
||||
<A href="#Members">Members</A><br>
|
||||
<A href="#Example">Example</A></p>
|
||||
|
||||
<h2><a name="Introduction">Introduction</a></h2>
|
||||
|
||||
<p>The <code>call_once</code> routine and <code>once_flag</code> type can be used to
|
||||
run a routine exactly once. This can be used to initialize data in a
|
||||
<a href="definitions.html#Thread-safe">thread-safe</a> manner.</p>
|
||||
|
||||
<h2><a name="Header">Header</a></h2>
|
||||
|
||||
<pre>
|
||||
#include <a href="../../../boost/thread/once.hpp"><boost/thread/once.hpp></a>
|
||||
</pre>
|
||||
|
||||
<h2><a name="Synopsis">Synopsis</a></h2>
|
||||
|
||||
<pre>
|
||||
namespace boost {
|
||||
|
||||
typedef <i>[implementation defined]</i> once_flag;
|
||||
const once_flag once_init = <i>[implementation defined]</i>;
|
||||
void call_once(void (*func)(), once_flag& flag);
|
||||
|
||||
} // namespace boost
|
||||
</pre>
|
||||
|
||||
<h2><a name="Reference">Reference</a></h2>
|
||||
|
||||
<hr>
|
||||
<h3>once_flag</h3>
|
||||
|
||||
<p>This implementation defined type is used as a flag to insure a routine is called only once.
|
||||
Instances of this type should be statically initialized to <code>once_init</code>.</p>
|
||||
|
||||
<hr>
|
||||
<h3>once_init</h3>
|
||||
|
||||
<p>This is a constant value used to initialize <code>once_flag</code> instances
|
||||
to indicate that the logically associated routine has not been run yet.</p>
|
||||
|
||||
<hr>
|
||||
<h3>call_once</h3>
|
||||
|
||||
<pre>
|
||||
void call_once(void (*func)(), once_flag& flag);
|
||||
</pre>
|
||||
|
||||
<p><b>Requires:</b> The function <code>func</code> shall not throw exceptions.</p>
|
||||
|
||||
<p><b>Effects:</b> As if (in an atomic fashion)</p>
|
||||
|
||||
<code>
|
||||
if (flag == once_init)<br>
|
||||
func();
|
||||
</code>
|
||||
|
||||
<p><b>Postcondition:</b> <code>flag</code> != <code>once_init</code></p>
|
||||
|
||||
<hr>
|
||||
<h2><a name="Example">Example Usage</a></h2>
|
||||
|
||||
<pre>
|
||||
#include <a href="../../../boost/thread/thread.hpp"><boost/thread/thread.hpp></a>
|
||||
#include <a href="../../../boost/thread/tss.hpp"><boost/thread/once.hpp></a>
|
||||
#include <cassert>
|
||||
|
||||
int value=0;
|
||||
boost::once_flag once = boost::once_init;
|
||||
|
||||
void init()
|
||||
{
|
||||
++value;
|
||||
}
|
||||
|
||||
void thread_proc()
|
||||
{
|
||||
boost::call_once(&init, once);
|
||||
}
|
||||
|
||||
int main(int argc, char* argv[])
|
||||
{
|
||||
boost::thread_group threads;
|
||||
for (int i=0; i<5; ++i)
|
||||
threads.create_thread(&thread_proc);
|
||||
threads.join_all();
|
||||
assert(value == 1);
|
||||
}
|
||||
</pre>
|
||||
|
||||
<hr>
|
||||
|
||||
<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->01 October, 2001<!--webbot bot="Timestamp" endspan i-checksum="38291" -->
|
||||
</p>
|
||||
|
||||
<p><i>© Copyright <a href="mailto:williamkempf@hotmail.com">William E. Kempf</a>
|
||||
2001 all rights reserved.</i></p>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
333
doc/condition.html
Normal file
333
doc/condition.html
Normal file
@@ -0,0 +1,333 @@
|
||||
<html>
|
||||
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
|
||||
<meta name="keywords" content="threads, BTL, thread library, C++">
|
||||
<link rel="stylesheet" type="text/css" href="styles.css">
|
||||
<title>Boost.Threads, condition</title>
|
||||
</head>
|
||||
|
||||
<body bgcolor="#ffffff" link="#0000ff" vlink="#800080" text="#000000">
|
||||
|
||||
<table border="0" cellpadding="7" cellspacing="0" width="100%">
|
||||
<tr>
|
||||
<td valign="top" width="300">
|
||||
<h3><IMG height=86 alt="C++ Boost" src="../../../c++boost.gif" width=277></h3>
|
||||
</td>
|
||||
<td valign="top">
|
||||
<h1 align="center">Boost.Threads</h1>
|
||||
<h2 align="center">condition</h2>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<hr>
|
||||
|
||||
<p><A href="#Introduction">Introduction</a><br>
|
||||
<A href="#Header">Header</a><br>
|
||||
<A href="#Synopsis">Synopsis</a><br>
|
||||
<A href="#Members">Members</a><br>
|
||||
<A href="#Example">Example</a></p>
|
||||
|
||||
<h2><a name="Introduction">Introduction</a></h2>
|
||||
|
||||
<p>An object of class <code>condition</code> is a synchronization primitive used to
|
||||
cause a thread to wait until a particular shared-data condition (or time) is met.
|
||||
A <code>condition</code> object is always used in conjunction with a mutex
|
||||
object modeling a <a href="mutex_concept.html">Mutex Concept</a>. The mutex must be locked prior to waiting on the
|
||||
<code>condition</code>, which is ensured by passing a lock object modeling a <a href="lock_concept.html">Lock
|
||||
Concept</a> to the <code>condition</code> object's <code>wait</code> functions. While the thread is waiting on the <code>condition</code>
|
||||
object,
|
||||
the mutex associated with the lock is unlocked. When the thread returns
|
||||
from a call to one of the <code>condition</code> object's <code>wait</code> functions,
|
||||
the mutex is again locked. The tricky lock/unlock/lock sequence is performed
|
||||
automatically by the <code>condition</code> object's <code>wait</code>
|
||||
functions.</p>
|
||||
|
||||
<p>The <code>condition</code> type is often used to implement the <i>Monitor Object</i>
|
||||
and other important patterns. See <A href="bibliography.html#Schmidt-00">[Schmidt-00]</a>
|
||||
and <A href="bibliography.html#Hoare-74">[Hoare 74]</a>. Monitors are one of the most
|
||||
important patterns for creating reliable multithreaded programs.</p>
|
||||
|
||||
<p>See <A href="definitions.html">Formal Definitions</a> for definitions of thread
|
||||
states <A href="definitions.html#state">blocked</a> and
|
||||
<A href="definitions.html#state">ready</a>. Note that "waiting" is a synonym
|
||||
for blocked.</p>
|
||||
|
||||
<h2><a name="Header">Header</a></h2>
|
||||
|
||||
<pre>
|
||||
#include <A href="../../../boost/thread/condition.hpp"><boost/thread/condition.hpp></a>
|
||||
</pre>
|
||||
|
||||
<h2><a name="Synopsis">Synopsis</a></h2>
|
||||
|
||||
<pre>
|
||||
namespace boost {
|
||||
|
||||
class condition : private <A href="../../utility/utility.htm#Class noncopyable">boost::noncopyable</a> // Exposition only.
|
||||
// Class condition meets the <a href="overview.html#NonCopyable">NonCopyable</a> requirement.
|
||||
{
|
||||
public:
|
||||
condition();
|
||||
~condition();
|
||||
|
||||
void notify_one();
|
||||
void notify_all();
|
||||
template <typename <a href="scoped_lock.html">ScopedLock</a>>
|
||||
void wait(<a href="scoped_lock.html">ScopedLock</a>& lock);
|
||||
template <typename <a href="scoped_lock.html">ScopedLock</a>, typename <A href="http://www.sgi.com/tech/stl/Predicate.html">Predicate</A>>
|
||||
void wait(<a href="scoped_lock.html">ScopedLock</a>& lock, <A href="http://www.sgi.com/tech/stl/Predicate.html">Predicate</A> pred);
|
||||
template <typename <a href="scoped_lock.html">ScopedLock</a>>
|
||||
bool timed_wait(<a href="scoped_lock.html">ScopedLock</a>& lock, const xtime& xt);
|
||||
template <typename <a href="scoped_lock.html">ScopedLock</a>, typename <A href="http://www.sgi.com/tech/stl/Predicate.html">Predicate</A>>
|
||||
bool timed_wait(<a href="scoped_lock.html">ScopedLock</a>& lock, const xtime& xt, <A href="http://www.sgi.com/tech/stl/Predicate.html">Predicate</A> pred);
|
||||
};
|
||||
|
||||
} // namespace boost
|
||||
</pre>
|
||||
|
||||
<h2><a name="Members">Members</a></h2>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>Constructor</h3>
|
||||
|
||||
<pre>
|
||||
condition();
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> Constructs a <code>condition</code>.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>Destructor</h3>
|
||||
|
||||
<pre>
|
||||
~condition();
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> Destroys <code>*this</code>.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>notify_one</h3>
|
||||
|
||||
<pre>
|
||||
void notify_one();
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> If there is a thread waiting on <code>*this</code>, change
|
||||
that thread's state to ready. Otherwise there is no effect.</p>
|
||||
|
||||
<p><b>Notes:</b> If more that one thread is waiting on the condition, it is
|
||||
unspecified which is made ready.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>notify_all</h3>
|
||||
|
||||
<pre>
|
||||
void notify_all();
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> Change the state of all threads waiting on <code>*this</code>
|
||||
to ready. If there are no waiting threads, <code>notify_all()</code> has no effect.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>wait</h3>
|
||||
|
||||
<pre>
|
||||
template <typename ScopedLock>
|
||||
void wait(ScopedLock& lock);
|
||||
</pre>
|
||||
|
||||
<p><b>Requires:</b> ScopedLock meets the
|
||||
<A href="lock_concept.html#ScopedLock">ScopedLock</a> requirements.</p>
|
||||
|
||||
<p><b>Effects:</b> Releases the lock on the <A href="mutex_concept.html">mutex model</a>
|
||||
associated with <code>lock</code>, blocks the current thread of execution until readied
|
||||
by a call to <code>this->notify_one()</code> or <code>this->notify_all()</code>,
|
||||
and then reacquires the lock. All effects occur in an atomic fashion.</p>
|
||||
|
||||
<p><b>Throws:</b> <code><A href="lock_error.html">lock_error</a></code>
|
||||
if <code>!lock.locked()</code></p>
|
||||
|
||||
<p><b>Danger:</b> This version should always be used within a loop checking that the
|
||||
state logically associated with the <code>condition</code> has become true. Without
|
||||
the loop, race conditions can ensue due to possible "spurious wake ups". The second
|
||||
version encapsulates this loop idiom internally and is generally the preferred method.</p>
|
||||
|
||||
<pre>
|
||||
template <typename ScopedLock, typename Pr>
|
||||
void wait(ScopedLock& lock, Pr pred);
|
||||
</pre>
|
||||
|
||||
<p><b>Requires:</b> ScopedLock meets the
|
||||
<A href="lock_concept.html#ScopedLock">ScopedLock</a> requirements, return from
|
||||
<code>pred()</code> convertible to bool.</p>
|
||||
|
||||
<p><b>Effects:</b> As if:</p>
|
||||
|
||||
<code>
|
||||
while (!pred()) wait(lock)
|
||||
</code>
|
||||
|
||||
<p><b>Throws:</b> <code><A href="lock_error.html">lock_error</a></code> if
|
||||
<code>!lock.locked()</code></p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>timed_wait</h3>
|
||||
|
||||
<pre>
|
||||
template <typename ScopedTimedLock>
|
||||
bool timed_wait(ScopedTimedLock& lock, const <a href="xtime.html">xtime</a>& xt);
|
||||
</pre>
|
||||
|
||||
<p><b>Requires:</b> ScopedTimeLock meets the
|
||||
<A href="lock_concept.html#ScopedTimedLock">ScopedTimedLock</a> requirements.</p>
|
||||
|
||||
<p><b>Effects:</b> Releases the lock on the <A href="mutex_concept.html">mutex model</a>
|
||||
associated with the <code>lock</code>, blocks the current thread of execution until
|
||||
readied by a call to <code>this->notify_one()</code> or
|
||||
<code>this->notify_all()</code>, or until <code>xt</code>, and then reacquires the
|
||||
lock. All effects occur in an atomic fashion.</p>
|
||||
|
||||
<p><b>Throws:</b> <code><A href="lock_error.html">lock_error</a></code> if
|
||||
<code>!lock.locked()</code></p>
|
||||
|
||||
<p><b>Danger:</b> This version should always be used within a loop checking that the
|
||||
state logically associated with the <code>condition</code> has become true. Without
|
||||
the loop, race conditions can ensue due to "spurious wake ups". The second version
|
||||
encapsulates this loop idiom internally and is generally the preferred method.</p>
|
||||
|
||||
<p><b>Returns:</b> <code>false</code> if <code>xt</code> is reached, otherwise
|
||||
<code>true</code>.</p>
|
||||
|
||||
<pre>
|
||||
template <typename ScopedTimedLock, typename Pr>
|
||||
bool timed_wait(ScopedTimedLock& lock, const <a href="xtime.html">xtime</a>& xt, Pr pred);
|
||||
</pre>
|
||||
|
||||
<p><b>Requires: </b>ScopedTimeLock meets the
|
||||
<A href="lock_concept.html#ScopedTimedLock">ScopedTimedLock</a> requirements,
|
||||
return from <code>pred()</code> convertible to bool.</p>
|
||||
|
||||
<p><b>Effects: </b>As if:</p>
|
||||
|
||||
<code>
|
||||
while (!pred())<br>
|
||||
{<br>
|
||||
if (!timed_wait(lock, xt))<br>
|
||||
return false;<br>
|
||||
}
|
||||
</code>
|
||||
|
||||
<p><b>Throws:</b> <code><A href="lock_error.html">lock_error</a></code> if
|
||||
<code>!lock.locked()</code></p>
|
||||
|
||||
<p><b>Returns:</b> <code>false</code> if <code>xt</code> is reached, otherwise
|
||||
<code>true</code>.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h2><a name="Example">Example Usage</a></h2>
|
||||
|
||||
<pre>
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
#include <A href="../../../boost/utility.hpp"><boost/utility.hpp></a>
|
||||
#include <A href="../../../boost/thread/condition.hpp"><boost/thread/condition.hpp></a>
|
||||
#include <A href="../../../boost/thread/thread.hpp"><boost/thread/thread.hpp></a>
|
||||
|
||||
class bounded_buffer : private boost::noncopyable
|
||||
{
|
||||
public:
|
||||
typedef boost::mutex::scoped_lock lock;
|
||||
|
||||
bounded_buffer(int n) : begin(0), end(0), buffered(0), circular_buf(n) { }
|
||||
|
||||
void send (int m) {
|
||||
lock lk(monitor);
|
||||
while (buffered == circular_buf.size())
|
||||
buffer_not_full.wait(lk);
|
||||
circular_buf[end] = m;
|
||||
end = (end+1) % circular_buf.size();
|
||||
++buffered;
|
||||
buffer_not_empty.notify_one();
|
||||
}
|
||||
int receive() {
|
||||
lock lk(monitor);
|
||||
while (buffered == 0)
|
||||
buffer_not_empty.wait(lk);
|
||||
int i = circular_buf[begin];
|
||||
begin = (begin+1) % circular_buf.size();
|
||||
--buffered;
|
||||
buffer_not_full.notify_one();
|
||||
return i;
|
||||
}
|
||||
|
||||
private:
|
||||
int begin, end, buffered;
|
||||
std::vector<int> circular_buf;
|
||||
boost::condition buffer_not_full, buffer_not_empty;
|
||||
boost::mutex monitor;
|
||||
};
|
||||
|
||||
bounded_buffer buf(2);
|
||||
|
||||
void sender() {
|
||||
int n = 0;
|
||||
while (n < 100) {
|
||||
buf.send(n);
|
||||
std::cout << "sent: " << n << std::endl;
|
||||
++n;
|
||||
}
|
||||
buf.send(-1);
|
||||
}
|
||||
|
||||
void receiver() {
|
||||
int n;
|
||||
do {
|
||||
n = buf.receive();
|
||||
std::cout << "received: " << n << std::endl;
|
||||
} while (n != -1); // -1 indicates end of buffer
|
||||
}
|
||||
|
||||
int main(int, char*[])
|
||||
{
|
||||
boost::thread thrd1(&sender);
|
||||
boost::thread thrd2(&receiver);
|
||||
thrd1.join();
|
||||
thrd2.join();
|
||||
return 0;
|
||||
}
|
||||
</pre>
|
||||
|
||||
<p>Typical output (dependent on scheduling policies) is:</p>
|
||||
|
||||
<pre>
|
||||
sent: 0
|
||||
sent: 1
|
||||
received: 0
|
||||
received: 1
|
||||
sent: 2
|
||||
sent: 3
|
||||
received: 2
|
||||
received: 3
|
||||
sent: 4
|
||||
received: 4
|
||||
</pre>
|
||||
|
||||
<hr>
|
||||
|
||||
<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->01 October, 2001<!--webbot bot="Timestamp" endspan i-checksum="38291" -->
|
||||
</p>
|
||||
|
||||
<p><i>© Copyright <A href="mailto:williamkempf@hotmail.com">William E. Kempf</a>
|
||||
2001 all rights reserved.</i></p>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
103
doc/config.html
Normal file
103
doc/config.html
Normal file
@@ -0,0 +1,103 @@
|
||||
<html>
|
||||
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
|
||||
<meta name="keywords" content="threads, BTL, thread library, C++">
|
||||
<title>Boost.Threads, Configuration Information</title>
|
||||
</head>
|
||||
|
||||
<body bgcolor="#FFFFFF" link="#0000FF" vlink="#800080">
|
||||
|
||||
<table border="0" cellpadding="7" cellspacing="0" width="100%">
|
||||
<tr>
|
||||
<td valign="top" width="300">
|
||||
<h3><img src="../../../c++boost.gif" alt="C++ Boost" width="277" height="86"></h3>
|
||||
</td>
|
||||
<td valign="top">
|
||||
<h1 align="center">Boost.Threads</h1>
|
||||
<h2 align="center">Configuration Information</h2>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<hr>
|
||||
|
||||
<p><b>Boost.Threads</b> uses several configuration macros in <a href="../../config/config.htm"> <boost/config.hpp></a>.
|
||||
These macros are documented here. Most of the macros are
|
||||
of interest only to developers attempting to provide new implementations of <b>Boost.Threads</b>.
|
||||
The one exception to this is BOOST_HAS_THREADS.</p>
|
||||
|
||||
<table cellspacing="10" width="100%">
|
||||
<tr>
|
||||
<td valign="top">
|
||||
<b>Macro</b>
|
||||
</td>
|
||||
<td valign="top">
|
||||
<b>Meaning</b>
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top">
|
||||
BOOST_HAS_THREADS
|
||||
</td>
|
||||
<td valign="top">
|
||||
Indicates that threading support is available. This means both that there is a
|
||||
platform specific implementation for <b>Boost.Threads</b> and that threading
|
||||
support has been enabled in a platform specific manner. For instance, on the
|
||||
Win32 platform there's an implementation for <b>Boost.Threads</b> but unless
|
||||
the program is compiled against one of the multi-threading runtimes
|
||||
(often determined by the
|
||||
compiler predefining the macro _MT) the
|
||||
BOOST_HAS_THREADS macro remains undefined.
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top">
|
||||
BOOST_HAS_WINTHREADS
|
||||
</td>
|
||||
<td valign="top">
|
||||
Indicates that the platform has the Microsoft Win32 threading libraries,
|
||||
and that they should be used
|
||||
to implement <b>Boost.Threads</b>.
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top">
|
||||
BOOST_HAS_PTHREADS
|
||||
</td>
|
||||
<td valign="top">
|
||||
Indicates that the platform has the POSIX pthreads libraries, and that
|
||||
they should be used
|
||||
to implement <b>Boost.Threads</b>.
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top">
|
||||
BOOST_HAS_FTIME
|
||||
</td>
|
||||
<td valign="top">
|
||||
Indicates that the implementation should use GetSystemTimeAsFileTime() and
|
||||
the FILETIME type to calculate the current time. This is an implementation
|
||||
detail used by boost::detail::getcurtime().
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top">
|
||||
BOOST_HAS_GETTTIMEOFDAY
|
||||
</td>
|
||||
<td valign="top">
|
||||
Indicates that the implementation should use gettimeofday() to calculate the
|
||||
current time. This is an implementation detail used by boost::detail::getcurtime().
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
<hr>
|
||||
|
||||
<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->01 October, 2001<!--webbot bot="Timestamp" endspan i-checksum="38291" -->
|
||||
</p>
|
||||
|
||||
<p><i>© Copyright <a href="mailto:williamkempf@hotmail.com">William E. Kempf</a>
|
||||
2001 all rights reserved.</i></p>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
244
doc/definitions.html
Normal file
244
doc/definitions.html
Normal file
@@ -0,0 +1,244 @@
|
||||
<html>
|
||||
|
||||
<head>
|
||||
<meta http-equiv="Content-Language" content="en-us">
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
|
||||
<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
|
||||
<meta name="ProgId" content="FrontPage.Editor.Document">
|
||||
<title>Boost.Threads Definitions</title>
|
||||
</head>
|
||||
|
||||
<body bgcolor="#FFFFFF">
|
||||
|
||||
<table border="0" cellpadding="7" cellspacing="0" width="100%">
|
||||
<tr>
|
||||
<td valign="top" width="300">
|
||||
<h3><img src="../../../c++boost.gif" alt="C++ Boost" width="277" height="86"></h3>
|
||||
</td>
|
||||
<td valign="top">
|
||||
<h1 align="center">Boost.Threads</h1>
|
||||
<h2 align="center"> Definitions</h2>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
<h2>Introduction</h2>
|
||||
<p>The definitions are given in terms of the <a href="bibliography.html#ISO-98"> C++ Standard</a>. References to the standard
|
||||
are in the form [1.2.3/4], which
|
||||
represents the section number, with the paragraph number following the "/".</p>
|
||||
<p>Because the definitions are written in something akin to
|
||||
"standardese", they can be difficult to understand. The intent
|
||||
isn't to confuse, but rather to clarify the additional requirements
|
||||
Boost.Threads places on a C++ implementation as defined by the C++ Standard.</p>
|
||||
<h2>Definitions</h2>
|
||||
<h3>Thread</h3>
|
||||
<p>Thread is short for "thread of execution". A thread of execution is an execution environment [1.9/7] within the execution environment
|
||||
of a C++ program [1.9]. The main() function [3.6.1] of the program is the
|
||||
initial function of the initial thread. A program in a multi-threading
|
||||
environment always has an initial thread even if the program explicitly creates
|
||||
no additional threads.</p>
|
||||
<p>Unless otherwise specified, each thread shares all aspects of its execution environment with
|
||||
other threads in the program. Shared aspects of the execution environment
|
||||
include, but are not limited to, the following:</p>
|
||||
<ul>
|
||||
<li>Static storage duration (static, extern) objects [3.7.1].</li>
|
||||
</ul>
|
||||
<ul>
|
||||
<li>Dynamic storage duration (heap) objects [3.7.3]. Thus each memory
|
||||
allocation will return a unique addresses, regardless of the thread making
|
||||
the allocation request.</li>
|
||||
</ul>
|
||||
<ul>
|
||||
<li>Automatic storage duration (stack) objects [3.7.2] accessed via pointer or
|
||||
reference from another thread.</li>
|
||||
</ul>
|
||||
<ul>
|
||||
<li>Resources provided by the operating
|
||||
system. For example, files.</li>
|
||||
</ul>
|
||||
<ul>
|
||||
<li>The program itself. In other words, each thread is executing some
|
||||
function of the same program, not a totally different program.</li>
|
||||
</ul>
|
||||
<p>Each thread has its own:</p>
|
||||
<ul>
|
||||
<li>Registers and current execution sequence (program counter) [1.9/5].</li>
|
||||
</ul>
|
||||
<ul>
|
||||
<li>Automatic storage duration (stack) objects [3.7.2].</li>
|
||||
</ul>
|
||||
<h3><a name="Thread-safe">Thread-safe</a></h3>
|
||||
<p>A program is thread-safe if it has no <a href="#Race condition">race
|
||||
conditions</a>, does not <a href="#Deadlock">deadlock</a>, and has no <a href="#Priority failure">priority
|
||||
failures</a>.</p>
|
||||
<p>Note that thread-safety does not necessarily imply efficiency, and than while
|
||||
some thread-safety violations can be determined statically at compile time, many
|
||||
thread-safety errors can only only be detected at runtime.</p>
|
||||
<h3>Thread <a name="State">State</a></h3>
|
||||
<p>During the lifetime of a thread, it shall be in one of the following
|
||||
states:</p>
|
||||
<table border="1" cellpadding="5">
|
||||
<tr>
|
||||
<td><b>State</b></td>
|
||||
<td><b>Description</b></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>Ready</td>
|
||||
<td>Ready to run, but waiting for a processor.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>Running</td>
|
||||
<td>Currently executing on a processor. Zero or more threads may be running
|
||||
at any time, with a maximum equal to the number of processors. </td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>Blocked</td>
|
||||
<td>Waiting for some resource other than a processor which is not currently
|
||||
available, or for the completion of calls to library functions [1.9/6].
|
||||
The term "waiting" is synonymous for "blocked"</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>Terminated</td>
|
||||
<td>Finished execution but not yet detached or joined.</td>
|
||||
</tr>
|
||||
</table>
|
||||
<p>Thread state transitions shall occur only as specified:</p>
|
||||
<table border="1" cellpadding="5">
|
||||
<tr>
|
||||
<td><b>From</b></td>
|
||||
<td><b>To</b></td>
|
||||
<td><b>Cause</b></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>
|
||||
<p align="left">[none]</td>
|
||||
<td>Ready</td>
|
||||
<td>Thread is created by a call to a library function. In the case of
|
||||
the initial thread, creation is implicit and occurs during the startup of
|
||||
the main() function [3.6.1].</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>Ready</td>
|
||||
<td>Running</td>
|
||||
<td>Processor becomes available.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>Running</td>
|
||||
<td>Ready</td>
|
||||
<td>Thread preempted.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>Running</td>
|
||||
<td>Blocked</td>
|
||||
<td>Thread calls a library function which waits for a resource or for the
|
||||
completion of I/O.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>Running</td>
|
||||
<td>Terminated</td>
|
||||
<td>Thread returns from its initial function, calls a thread termination
|
||||
library function, or is cancelled by some other thread calling a thread
|
||||
termination library function.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>Blocked</td>
|
||||
<td>Ready</td>
|
||||
<td>The resource being waited for becomes available, or the blocking library
|
||||
function completes.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>Terminated</td>
|
||||
<td>[none]</td>
|
||||
<td>Thread is detached or joined by some other thread calling the
|
||||
appropriate library function, or by program termination [3.6.3].</td>
|
||||
</tr>
|
||||
</table>
|
||||
<p>[Note: if a suspend() function is added to the threading library, additional
|
||||
transitions to the blocked state will have to be added to the above table.]</p>
|
||||
<h3><a name="Race condition">Race condition</a></h3>
|
||||
<p>A race condition is what occurs when multiple threads read and
|
||||
write to the same memory without proper synchronization, resulting in an
|
||||
incorrect value being read or written. The result of a race condition may
|
||||
be a bit pattern which isn't even a valid value for the data type. A race
|
||||
condition results in undefined behavior [1.3.12].</p>
|
||||
<p>Race conditions can be prevented by serializing memory access
|
||||
using the tools provided by Boost.Threads. </p>
|
||||
<h3><a name="Deadlock">Deadlock</a></h3>
|
||||
<p>Deadlock is an execution state where for some set of threads, each thread in
|
||||
the set is blocked waiting for some action by one of the other threads in the
|
||||
set. Since each is waiting on the others, none will ever become ready again.</p>
|
||||
<h3><a name="Priority failure">Priority failure</a></h3>
|
||||
<p>A priority failure (such as priority inversion or infinite overtaking) occurs
|
||||
when threads executed in such a sequence that required work is not performed in
|
||||
time to be useful.</p>
|
||||
<h2>Memory visibility between threads</h2>
|
||||
<p>An address [1.7] shall always point to the same memory byte, regardless of the
|
||||
thread or processor dereferencing the address.</p>
|
||||
<p>An object [1.8, 1.9] is accessible from multiple threads if it is of
|
||||
static storage duration (static, extern) [3.7.1], or if a pointer or reference to
|
||||
it is explicitly or
|
||||
implicitly dereferenced in multiple threads.</p>
|
||||
<p>For an object accessible from multiple threads, the value of the object
|
||||
accessed from one thread may be indeterminate or different than the value
|
||||
accessed from another thread, except under the conditions specified in the following
|
||||
table. For the same row of the table, the value of an object
|
||||
accessible at the indicated sequence point in thread A will be determinate and the
|
||||
same if accessed at or after the indicated sequence point in thread B, provided
|
||||
the object is not otherwise modified. In the table, the
|
||||
"sequence point at a call" is the sequence point after the evaluation
|
||||
of all function arguments [1.9/17], while the "sequence point after a
|
||||
call" is the sequence point after the copying of the returned
|
||||
value..." [1.9/17].</p>
|
||||
<table border="1" cellpadding="5">
|
||||
<tr>
|
||||
<td align="center"><b>Thread A</b></td>
|
||||
<td align="center"><b>Thread B</b></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>The sequence point at a call to a library thread-creation
|
||||
function. </td>
|
||||
<td>The first sequence point of the initial function in the new thread
|
||||
created by the Thread A call.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>The sequence point at a call to a library function which locks a mutex,
|
||||
directly or by waiting for a condition variable.</td>
|
||||
<td>The sequence point after a call to a library function which unlocks the
|
||||
same mutex.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>The last sequence point before thread termination.</td>
|
||||
<td>The sequence point after a call to a library function which joins the
|
||||
terminated thread.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>The sequence point at a call to a library function which signals or
|
||||
broadcasts a condition variable.</td>
|
||||
<td>The sequence point after the call to the library function which was
|
||||
waiting on that same condition variable or signal.</td>
|
||||
</tr>
|
||||
</table>
|
||||
<p>The architecture of the execution environment and the observable behavior of
|
||||
the abstract machine [1.9] shall be the same on all processors.</p>
|
||||
<p>The latitude granted by the C++ standard for an implementation to alter the
|
||||
definition of observable behavior of the abstract machine to include additional library I/O
|
||||
functions [1.9/6] is extended to include threading library functions.</p>
|
||||
<p>When an exception is thrown and there is no matching exception handler in the
|
||||
same thread, behavior is undefined. The preferred behavior is the same as when there is no matching exception handler
|
||||
in a program [15.3/9]. That is, terminate() is called, and it is implementation defined
|
||||
whether or not the stack is unwound.</p>
|
||||
<h2><a name="Acknowledgements">Acknowledgements</a></h2>
|
||||
<p>This document has been much improved by the incorporation of comments from
|
||||
William Kempf.</p>
|
||||
<p>The visibility rules are based on <a href="bibliography.html#Butenhof-97">[Butenhof
|
||||
97]</a>. </p>
|
||||
<hr>
|
||||
<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %b %Y" startspan -->01 Oct 2001<!--webbot bot="Timestamp" endspan i-checksum="14990" -->
|
||||
</p>
|
||||
<p>© Copyright Beman Dawes, 2001</p>
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
</body>
|
||||
|
||||
</html>
|
||||
174
doc/faq.html
Normal file
174
doc/faq.html
Normal file
@@ -0,0 +1,174 @@
|
||||
<html>
|
||||
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
|
||||
<meta name="keywords" content="threads, BTL, thread library, C++">
|
||||
<link rel="stylesheet" type="text/css" href="styles.css">
|
||||
<title>Boost.Threads, FAQ</title>
|
||||
</head>
|
||||
|
||||
<body bgcolor="#FFFFFF" link="#0000FF" vlink="#800080">
|
||||
|
||||
<table border="0" cellpadding="7" cellspacing="0" width="100%">
|
||||
<tr>
|
||||
<td valign="top" width="300">
|
||||
<h3><img src="../../../c++boost.gif" alt="C++ Boost" width="277" height="86"></h3>
|
||||
</td>
|
||||
<td valign="top">
|
||||
<h1 align="center">Boost.Threads</h1>
|
||||
<h2 align="center">Frequently Asked Questions</h2>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<hr>
|
||||
|
||||
<h2>1. Are lock objects <a href="definitions.html#Thread-safe">thread-safe</a>?</h2>
|
||||
|
||||
<p><b>No!</b> Lock objects are not meant to be shared between threads. They are meant to
|
||||
be short lived objects created on automatic storage within a code block. Any other usage
|
||||
is just likely to lead to errors and won't really be of actual benefit any way. Share
|
||||
<a href="mutex_concept.html">mutexes</a>, not locks. For more information see the
|
||||
<a href="rationale.html#lock_objects">rationale</a> behind the design for lock objects.</p>
|
||||
|
||||
<h2>2a. Why was Boost.Threads modeled after (specific library name)?</h2>
|
||||
|
||||
<p>It wasn't. Boost.Threads was designed from scratch. Extensive design
|
||||
discussions involved numerous people representing a wide range of experience across
|
||||
many platforms. To ensure portability, the initial implements were done in
|
||||
parallel using POSIX Threads and theWin32 threading API. But the Boost.Threads
|
||||
design is very much in the spirit of C++, and thus doesn't model such C based
|
||||
APIs.</p>
|
||||
|
||||
<h2>2b. Why wasn't Boost.Threads modeled after (specific library name)?</h2>
|
||||
|
||||
<p>Existing C++ libraries either seemed dangerous (often failing to take
|
||||
advantage of prior art to reduce errors) or had excessive dependencies on
|
||||
library components unrelated to threading. Existing C libraries couldn't meet
|
||||
our C++ requirements, and were also missing certain features. For
|
||||
instance, POSIX threads doesn't support a maximum value for semaphores.
|
||||
The WIN32 thread API lacks condition variables, even though these are critical
|
||||
for the important Monitor pattern <a href="bibliography.html#Schmidt-00">[Schmidt
|
||||
00]</a>.</p>
|
||||
|
||||
<h2>3. Why do <a href="mutex_concept.html"> Mutexes</a> have noncopyable semantics?</h2>
|
||||
|
||||
<p>To ensure that <a href="definitions.html#Deadlock"> deadlocks</a> don't occur. The only logical form of copy would be to
|
||||
use some sort of shallow copy semantics in which multiple mutex objects could refer
|
||||
to the same mutex state. This means that if ObjA has a mutex object as part of its state
|
||||
and ObjB is copy constructed from it, then when ObjB::foo() locks the mutex it has effectively
|
||||
locked ObjA as well. This behavior can result in deadlock. Other
|
||||
copy semantics result in similar problems (if you think you can prove this to
|
||||
be wrong then supply us with an alternative and we'll reconsider).</p>
|
||||
|
||||
<h2>4. How can you prevent <a href="definitions.html#Deadlock"> deadlock</a> from occurring when a thread must lock multiple
|
||||
mutexes?</h2>
|
||||
|
||||
<p>Always lock them in the same order. One easy way of doing this is to use
|
||||
each mutex's address to determine the order in which they are locked. A future
|
||||
Boost.Threads concept may wrap this pattern up in a reusable class.</p>
|
||||
|
||||
<h2>5. Don't noncopyable <a href="mutex_concept.html"> mutex</a> semantics mean that a
|
||||
class with a mutex member will be noncopyable as well?</h2>
|
||||
|
||||
<p>No, but what it does mean is that the compiler can't generate a copy constructor
|
||||
and assignment operator, so they will have to be coded explicitly. This is a
|
||||
<b>good thing</b>, however, since the compiler generated operations would not
|
||||
be <a href="definitions.html#Thread-safe">thread-safe</a>. The following is a
|
||||
simple example of a class with copyable semantics and internal synchronization through
|
||||
a mutex member.</p>
|
||||
|
||||
<pre>
|
||||
class counter
|
||||
{
|
||||
public:
|
||||
// Doesn't need synchronization since there can be no references to *this
|
||||
// until after it's constructed!
|
||||
explicit counter(int initial_value)
|
||||
: m_value(initial_value)
|
||||
{
|
||||
}
|
||||
|
||||
// We only need to syncronize other for the same reason we don't have to
|
||||
// synchronize on construction!
|
||||
counter(const counter& other)
|
||||
{
|
||||
boost::mutex::scoped_lock scoped_lock(other.m_mutex);
|
||||
m_value = other.m_value;
|
||||
}
|
||||
|
||||
// For assignment we need to synchronize both objects!
|
||||
const counter& operator=(const counter& other)
|
||||
{
|
||||
if (this == &other)
|
||||
return *this;
|
||||
|
||||
boost::mutex::scoped_lock lock1(&m_mutex < &other.m_mutex ? m_mutex : other.m_mutex);
|
||||
boost::mutex::scoped_lock lock2(&m_mutex > &other.m_mutex ? m_mutex : other.m_mutex);
|
||||
m_value = other.m_value;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
int value() const
|
||||
{
|
||||
boost::mutex::scoped_lock scoped_lock(m_mutex);
|
||||
return m_value;
|
||||
}
|
||||
int increment()
|
||||
{
|
||||
boost::mutex::scoped_lock scoped_lock(m_mutex);
|
||||
return ++m_value;
|
||||
}
|
||||
|
||||
private:
|
||||
mutable boost::mutex m_mutex;
|
||||
int m_value;
|
||||
};
|
||||
</pre>
|
||||
|
||||
<h2>6. How can you lock a <a href="mutex_concept.html"> mutex</a> member in a const member function, in order to
|
||||
implement the Monitor Pattern?</h2>
|
||||
|
||||
<p>The Monitor Pattern mutex <a href="bibliography.html#Schmidt-00">[Schmidt
|
||||
00]</a> should simply be declared as mutable. See the example code above. The internal state of mutex
|
||||
types could have been made mutable, with all lock calls made via const
|
||||
functions, but
|
||||
this does a poor job of documenting the actual semantics. Declaring a mutex member
|
||||
as mutable clearly documentations the intended semantics.</p>
|
||||
|
||||
<h2>7. Why supply <a href="condition.html">condition variables</a> rather than <a href="rationale.html#Events">
|
||||
event variables</a>?</h2>
|
||||
|
||||
<p>Condition variables result in user code much less prone to <a href="definitions.html#Race condition">race
|
||||
conditions</a> than event variables. See <a href="rationale.html#Events">Rationale</a>
|
||||
for analysis. Also see <a href="bibliography.html#Hoare-74">[Hoare74]</a>
|
||||
and <a href="bibliography.html#Schmidt-00">[Schmidt
|
||||
00]</a>.</p>
|
||||
|
||||
<h2>8. Why isn't thread cancellation or termination provided?</h2>
|
||||
|
||||
<p>There's a valid need for thread termination, so at some point Boost.Threads
|
||||
probably will include it, but only after we can find a truly safe (and portable)
|
||||
mechanism for this concept.</p>
|
||||
|
||||
<h2>9. Is it safe for threads to share automatic storage duration (stack)
|
||||
objects via pointers or references?</h2>
|
||||
|
||||
<p>Only if you can guarantee that the lifetime of the stack object will not end
|
||||
while other threads might still access the object. Thus the safest practice is
|
||||
to avoid sharing stack objects, particularly in designs where threads are
|
||||
created and destroyed dynamically. Restrict sharing of stack objects to simple
|
||||
designs with very clear and unchanging function and thread lifetimes. (Suggested
|
||||
by Darryl Green).</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->01 October, 2001<!--webbot bot="Timestamp" endspan i-checksum="38291" -->
|
||||
</p>
|
||||
|
||||
<p><i>© Copyright <a href="mailto:williamkempf@hotmail.com">William E. Kempf</a>
|
||||
2001 all rights reserved.</i></p>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
87
doc/index.html
Normal file
87
doc/index.html
Normal file
@@ -0,0 +1,87 @@
|
||||
<html>
|
||||
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
|
||||
<meta name="keywords" content="threads, BTL, thread library, C++">
|
||||
<title>Boost.Threads, Index</title>
|
||||
</head>
|
||||
|
||||
<body bgcolor="#FFFFFF" link="#0000FF" vlink="#800080">
|
||||
|
||||
<table border="0" cellpadding="7" cellspacing="0" width="100%">
|
||||
<tr>
|
||||
<td valign="top" width="300">
|
||||
<h3><img src="../../../c++boost.gif" alt="C++ Boost" width="277" height="86"></h3>
|
||||
</td>
|
||||
<td valign="top">
|
||||
<h1 align="center">Boost.Threads</h1>
|
||||
<h2 align="center">Documentation Map</h2>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<hr>
|
||||
|
||||
<h2>Contents</h2>
|
||||
|
||||
<ul>
|
||||
<li><a href="overview.html">Overview</a></li>
|
||||
<li>Class <a href="semaphore.html">semaphore</a></li>
|
||||
<li><a href="mutex_concept.html">Mutex Concepts</a></li>
|
||||
<ul>
|
||||
<li><a href="mutex_concept.html#Mutex">Mutex</a></li>
|
||||
<li><a href="mutex_concept.html#TryMutex">TryMutex</a></li>
|
||||
<li><a href="mutex_concept.html#TimedMutex">TimedMutex</a></li>
|
||||
</ul>
|
||||
<li>Mutex Classes</li>
|
||||
<ul>
|
||||
<li><a href="mutex.html">mutex / try_mutex / timed_mutex</a></li>
|
||||
<li><a href="recursive_mutex.html">recursive_mutex / recursive_try_mutex / recursive_timed_mutex</a></li>
|
||||
</ul>
|
||||
<li><a href="lock_concept.html">Lock Concepts</a></li>
|
||||
<ul>
|
||||
<li><a href="lock_concept.html#Lock">Lock</a></li>
|
||||
<li><a href="lock_concept.html#ScopedLock">ScopedLock</a></li>
|
||||
<li><a href="lock_concept.html#ScopedTryLock">ScopedTryLock</a></li>
|
||||
<li><a href="lock_concept.html#ScopedTimedLock">ScopedTimedLock</a></li>
|
||||
</ul>
|
||||
<li>Lock Classes</li>
|
||||
<ul>
|
||||
<li><a href="scoped_lock.html">scoped_lock</a></li>
|
||||
<li><a href="scoped_try_lock.html">scoped_try_lock</a></li>
|
||||
<li><a href="scoped_timed_lock.html">scoped_timed_lock</a></li>
|
||||
</ul>
|
||||
<li>Class <a href="condition.html">condition</a></li>
|
||||
<li>Class <a href="thread_specific_ptr.html">thread_specific_ptr</a></li>
|
||||
<li>Class <a href="thread.html">thread</a></li>
|
||||
<li>Class <a href="thread_group.html">thread_group</a></li>
|
||||
<li>Class <a href="xtime.html">xtime</a></li>
|
||||
<li>Class <a href="lock_error.html">lock_error</a></li>
|
||||
<li>Class <a href="thread_resource_error.html">thread_resource_error</a></li>
|
||||
<li>Routine <a href="call_once.html">call_once</a></li>
|
||||
<li><a href="config.html">Configuration Information</a></li>
|
||||
<li><a href="introduction.html">Introduction to design</a></li>
|
||||
<li><a href="rationale.html">Rationale for design decisions</a></li>
|
||||
<li><a href="definitions.html">Definitions</a></li>
|
||||
<li><a href="faq.html">Frequently Asked Questions</a></li>
|
||||
<li><a href="bibliography.html">Bibliography</a></li>
|
||||
<li><a href="acknowledgements.html">Acknowledgements</a></li>
|
||||
</ul>
|
||||
|
||||
<hr>
|
||||
|
||||
<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->01 October, 2001<!--webbot bot="Timestamp" endspan i-checksum="38291" -->
|
||||
</p>
|
||||
|
||||
<p>©<i> Copyright <a href="mailto:williamkempf@hotmail.com">William E. Kempf</a>
|
||||
2001</i></p>
|
||||
<p>Permission to use, copy, modify, distribute and sell this software
|
||||
and its documentation for any purpose is hereby granted without fee,
|
||||
provided that the above copyright notice appear in all copies and
|
||||
that both that copyright notice and this permission notice appear
|
||||
in supporting documentation. William E. Kempf makes no representations
|
||||
about the suitability of this software for any purpose.
|
||||
It is provided "as is" without express or implied warranty.</p>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
151
doc/introduction.html
Normal file
151
doc/introduction.html
Normal file
@@ -0,0 +1,151 @@
|
||||
<html>
|
||||
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
|
||||
<meta name="keywords" content="threads, BTL, thread library, C++">
|
||||
<title>Boost.Threads, Introduction</title>
|
||||
</head>
|
||||
|
||||
<body bgcolor="#ffffff" link="#0000ff" vlink="#800080">
|
||||
|
||||
<table border="0" cellpadding="7" cellspacing="0" width="100%">
|
||||
<tr>
|
||||
<td valign="top" width="300">
|
||||
<h3><IMG height=86 alt="C++ Boost" src="../../../c++boost.gif" width=277></h3>
|
||||
</td>
|
||||
<td valign="top">
|
||||
<h1 align="center">Boost.Threads</h1>
|
||||
<h2 align="center">Introduction</h2>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>Motivation</h3>
|
||||
|
||||
<p>With client/server and three-tier architectures becoming common place in today's
|
||||
world, it's becoming increasingly important for programs to be able to handle parallel
|
||||
processing. Modern day operating systems usually provide some support for this
|
||||
through native thread APIs. Unfortunately, writing portable code that makes use
|
||||
of parallel processing in C++ is made very difficult by a lack of a standard interface
|
||||
for these native APIs. Further, these APIs are almost universally C APIs and fail to
|
||||
take advantage of C++'s strengths, or to address C++'s issues.</p>
|
||||
|
||||
<p>The <b>Boost.Threads</b> library is an attempt to define a portable interface for writing
|
||||
parallel processes in C++.</p>
|
||||
|
||||
<h3>Goals</h3>
|
||||
|
||||
<p>The <b>Boost.Threads</b> library has several goals that should help to set it apart from
|
||||
other solutions. These goals are listed in order of precedence with full descriptions
|
||||
below.<p>
|
||||
|
||||
<ul>
|
||||
<li><b>Portability</b>
|
||||
<p><b>Boost.Threads</b> was designed to be highly portable. The goal is for the
|
||||
interface to be easily implemented on any platform that supports threads,
|
||||
and possibly even on platforms without native thread support.</p>
|
||||
<li><b>Safety</b>
|
||||
<p><b>Boost.Threads</b> was designed to be as safe as possible. Writing
|
||||
<a href="definitions.html#Thread-safe">thread-safe</a>
|
||||
code is very difficult and successful libraries must strive to insulate
|
||||
the programmer from dangerous constructs as much as possible. This is accomplished
|
||||
in several ways:</p>
|
||||
<ul>
|
||||
<li><p align="left">C++ language features are used make correct usage easy (if possible,
|
||||
the default) and error-prone impossible or at least more difficult.
|
||||
For example, see the <a href="mutex_concept.html">Mutex</a> and <a href="lock_concept.html">Lock</a>
|
||||
designs, and how note how they interact.</p></li>
|
||||
<li>
|
||||
<p align="left">Certain traditional concurrent programming features
|
||||
are considered so error-prone that they are not provided at all. For
|
||||
example, see the <a href="rationale.html#Events">Events Not Provided</a>
|
||||
rationale.</p>
|
||||
</li>
|
||||
<li>
|
||||
<p align="left">Dangerous features, or features which may be misused,
|
||||
are identified as such in the documentation to make users aware of
|
||||
potential pitfalls. For example, see <a href="semaphore.html#Danger">Semaphore</a>.</p>
|
||||
</li>
|
||||
</ul>
|
||||
<li><b>Flexibility</b>
|
||||
<p><b>Boost.Threads</b> was designed to be flexible. This goal is often at odds
|
||||
with <i>safety</i>. When functionality might be compromised by the desire
|
||||
to keep the interface safe, <b>Boost.Threads</b> has been designed to provide
|
||||
the functionality, but to make it's use prohibitive for general use.</p>
|
||||
<li><b>Efficiency</b>
|
||||
<p><b>Boost.Threads</b> was designed to be as efficient as possible. When building
|
||||
a library on top of another library there is always a danger that the result
|
||||
will be so much slower than the "native" API that programmers are inclined
|
||||
to ignore the higher level API. <b>Boost.Threads</b> was designed to minimize the
|
||||
chances of this occurring. The interfaces have been crafted to allow an
|
||||
implementation the greatest chance of being as efficient as possible. This
|
||||
goal is often at odds with the goal for <i>safety</i>. Every effort was made to
|
||||
ensure efficient implementations, but when in conflict <i>safety</i> has always taken
|
||||
precedence.</p>
|
||||
</li>
|
||||
</ul>
|
||||
|
||||
<h3>Iterative Phases</h3>
|
||||
|
||||
<p>Another goal of <b>Boost.Threads</b> was to take a dynamic, iterative
|
||||
approach in its development. The computing industry is still exploring the concepts of parallel programming.
|
||||
Most thread libraries supply only simple primitive concepts for thread synchronization.
|
||||
These concepts are very simple, but they are very difficult to use safely or to provide
|
||||
formal proofs for constructs built on top of them. Until recently, these primitives
|
||||
were "state of the art" and the only concepts available to programmers. Recently
|
||||
there has been a lot of research in other concepts, such as in "Communicating Sequential
|
||||
Processes." <b>Boost.Threads</b> was designed in iterative steps, providing the building
|
||||
blocks necessary for the next step, and giving the researcher the tools necessary to
|
||||
explore new concepts in a portable manner.</p>
|
||||
|
||||
<p>Given the goal of following a dynamic, iterative approach <b>Boost.Threads</b> shall go through
|
||||
several growth cycles. Each phase in its development shall be roughly documented here.</p>
|
||||
|
||||
<h4>Phase 1, Synchronization Primitives</h4>
|
||||
|
||||
<p>Boost is all about providing high quality libraries with implementations for many platforms.
|
||||
Unfortunately, there's a big problem faced by developers wishing to supply such high quality
|
||||
libraries, namely thread-safety. The C++ standard doesn't address threads at all, but real
|
||||
world programs often make use of native threading support. A portable library that doesn't
|
||||
address the issue of thread-safety is there for not much help to a programmer who wants to
|
||||
use the library in his multi-threaded application. So there's a very great need for portable
|
||||
primitives that will allow the library developer to create <a href="definitions.html#Thread-safe">thread-safe</a>
|
||||
implementations. This
|
||||
need far out weighs the need for portable methods to create and manage threads.</p>
|
||||
|
||||
<p>Because of this need, the first phase of <b>Boost.Threads</b> focuses solely on providing
|
||||
portable primitive concepts for thread synchronization. Types provided in this phase include
|
||||
the <A href="semaphore.html">semaphore</a>, <A href="mutex.html">mutex/try_mutex/timed_mutex</a>,
|
||||
<A href="recursive_mutex.html">recursive_mutex/recursive_try_mutex/recursive_timed_mutex</a>,
|
||||
<A href="scoped_lock.html">scoped_lock</a>, <A href="scoped_try_lock.html">scoped_try_lock</a>,
|
||||
<A href="scoped_timed_lock.html">scoped_timed_lock</a> and <A href="lock_error.html">lock_error</a>.
|
||||
These are considered the "core" synchronization primitives, though there are others that will
|
||||
be added in later phases.</p>
|
||||
|
||||
<h4>Phase 2, Thread Management and Thread Specific Storage</h4>
|
||||
|
||||
<p>This phase addresses the creation and management of threads and provides a mechanism for
|
||||
thread specific storage (data associated with a thread instance). Thread management is a tricky
|
||||
issue in C++, so this phase addresses only the basic needs of multi-threaded program. Later
|
||||
phases are likely to add additional functionality in this area. This phase of <b>Boost.Threads</b>
|
||||
adds the <A href="thread.html">thread</a> and
|
||||
<A href="thread_specific_ptr.html">thread_specific_ptr</a> types. With these additions
|
||||
the <b>Boost.Threads</b> library can be considered minimal but complete.</p>
|
||||
|
||||
<h4>The Next Phase</h4>
|
||||
|
||||
<p>The next phase will address more advanced synchronization concepts, such as read/write mutexes
|
||||
and barriers.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->01 October, 2001<!--webbot bot="Timestamp" endspan i-checksum="38291" -->
|
||||
</p>
|
||||
|
||||
<p><i>© Copyright <A href="mailto:williamkempf@hotmail.com">William E. Kempf</a>
|
||||
2001 all rights reserved.</i></p>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
242
doc/lock_concept.html
Normal file
242
doc/lock_concept.html
Normal file
@@ -0,0 +1,242 @@
|
||||
<html>
|
||||
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
|
||||
<meta name="keywords" content="threads, BTL, thread library, C++">
|
||||
<title>Boost.Threads, Lock Concept</title>
|
||||
</head>
|
||||
|
||||
<body bgcolor="#FFFFFF" link="#0000FF" vlink="#800080">
|
||||
|
||||
<table border="0" cellpadding="7" cellspacing="0" width="100%">
|
||||
<tr>
|
||||
<td valign="top" width="300">
|
||||
<h3><img src="../../../c++boost.gif" alt="C++ Boost" width="277" height="86"></h3>
|
||||
</td>
|
||||
<td valign="top">
|
||||
<h1 align="center">Boost.Threads</h1>
|
||||
<h2 align="center">Lock Concepts</h2>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<hr>
|
||||
|
||||
<p><a href="#Introduction">Introduction</a><br>
|
||||
<a href="#Requirements">Concept Requirements</a><br>
|
||||
<a href="#Lock">Lock Concept</a><br>
|
||||
<a href="#ScopedLock">ScopedLock Concept</a><br>
|
||||
<a href="#ScopedTryLock">ScopedTryLock Concept</a><br>
|
||||
<a href="#ScopedTimedLock">ScopedTimedLock Concept</a><br>
|
||||
<a href="#Models">Models</a></p>
|
||||
|
||||
<h2><a name="Introduction">Introduction</a></h2>
|
||||
|
||||
<p>The lock concepts provide exception safe means for locking and unlocking a
|
||||
<a href="mutex_concept.html">mutex model</a>. In other words they are an
|
||||
implementation of the <i>Scoped Locking</i>
|
||||
<a href="bibliography.html#Schmidt 00">[Schmidt 00]</a> pattern. The
|
||||
<a href="#ScopedLock">ScopedLock</a> concept, with
|
||||
<a href="#ScopedTryLock">ScopedTryLock</a> and
|
||||
<a href="#ScopedTimedLock">ScopedTimedLock</a> refinements, formalize the
|
||||
requirements.</p>
|
||||
|
||||
<p>Lock models are constructed with a reference to a
|
||||
<a href="mutex_concept.html">mutex model</a> and typically acquire ownership of the
|
||||
<a href="mutex_concept.html">mutex model</a> by setting its state to locked. They also
|
||||
ensure ownership is relinquished in the destructor. Lock models also expose functions
|
||||
to query the lock status and to manually lock and unlock the
|
||||
<a href="mutex_concept.html">mutex model</a>.</p>
|
||||
|
||||
<p>Instances of lock models are meant to be short lived, expected to be used at block
|
||||
scope only. The lock models are not
|
||||
<a href="definitions.html#Thread-safe">thread-safe</a>. Lock models must maintain state
|
||||
to indicate whether or not they've been locked and this state is not protected by any
|
||||
synchronization concepts. For this reason an instance of a lock model should never be
|
||||
shared between multiple threads.</p>
|
||||
|
||||
<h2>Concept <a name="Requirements">Requirements</a></h2>
|
||||
|
||||
<p>[For documentation purposes, portions of the concept requirements are
|
||||
repeated in the documentation for specific lock classes. Those copies need
|
||||
to be kept in sync with the requirements here.]</p>
|
||||
|
||||
<h3><a name="Lock">Lock</a> Concept</h3>
|
||||
|
||||
<p>For a <a href="#ScopedLock"> ScopedLock</a>,
|
||||
<a href="#ScopedTryLock">ScopedTryLock</a>, or
|
||||
<a href="#ScopedTimedLock">ScopedTimedLock</a> type <code>L</code> and an object
|
||||
<code>lk</code> and const object <code>clk</code> of that type, the following expressions
|
||||
must be well-formed and have the indicated effects.</p>
|
||||
|
||||
<p>The Lock concept is used as a base for the <a href="#ScopedLock">ScopedLock</a>,
|
||||
<a href="#ScopedTryLock">ScopedTryLock</a>, and
|
||||
<a href="#ScopedTimedLock">ScopedTimedLock</a> refinements. The associated mutex type
|
||||
is as specified for each of those refinements respectively.</p>
|
||||
|
||||
<table border="1" cellpadding="5">
|
||||
<tr>
|
||||
<td><b>Expression</b></td>
|
||||
<td><b>Effects</b></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top"><code>(&lk)->~L();</code></td>
|
||||
<td><code>if (locked()) unlock();</code></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top"><code>(&clk)->operator const void*()</code></td>
|
||||
<td>Returns type void*, non-zero if if the associated mutex has been locked
|
||||
by <code>clk</code>, otherwise 0.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top"><code>clk.locked()</code></td>
|
||||
<td>Returns a <code>bool</code>, <code>(&clk)->operator const void*() != 0</code></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top"><code>lk.lock()</code></td>
|
||||
<td>Throws lock_error if locked(). If the associated mutex is already locked by some other
|
||||
thread, places the current thread in the
|
||||
<a href="definitions.html#State">Blocked</a> state until the associated mutex is
|
||||
unlocked, after which the current thread is placed in the
|
||||
<a href="definitions.html#State">Ready</a> state, eventually to be returned to the
|
||||
<a href="definitions.html#State">Running</a> state.<br>
|
||||
Postcondition: locked()</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top"><code>lk.unlock()</code></td>
|
||||
<td>If !locked(), throws lock_error, otherwise unlocks the associated mutex.<br>
|
||||
Postcondition: !locked()</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<h3><a name="ScopedLock">ScopedLock</a> Concept</h3>
|
||||
|
||||
<p>A ScopedLock must meet the <a href="#Lock">Lock</a> requirements. For a ScopedLock
|
||||
type <code>L</code> and an object <code>lk</code> of that type,
|
||||
and an object <code>m</code> of a type meeting the
|
||||
<a href="mutex_concept.html#Mutex">Mutex</a> requirements, and an object <code>b</code>
|
||||
of type <code>bool</code>, the following expressions must be well-formed and have the
|
||||
indicated effects.</p>
|
||||
|
||||
<table border="1" cellpadding="5">
|
||||
<tr>
|
||||
<td><b>Expression</b></td>
|
||||
<td><b>Effects</b></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top"><code>L lk(m);</code></td>
|
||||
<td>Constructs an object <code>lk</code>, and associates mutex <code>m</code> with
|
||||
it, then calls <code>lock()</code></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top"><code>L lk(m,b);</code></td>
|
||||
<td>Constructs an object <code>lk</code>, and associates mutex <code>m</code> with
|
||||
it, then if <code>b</code>, calls <code>lock()</code></td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<h3><a name="ScopedTryLock">ScopedTryLock</a> Concept</h3>
|
||||
|
||||
<p>A ScopedTryLock must meet the <a href="#Lock">Lock</a> requirements. For a
|
||||
ScopedTryLock type <code>L</code> and an object <code>lk</code> of that type,
|
||||
and an object <code>m</code> of a type meeting the
|
||||
<a href="mutex_concept.html#TryMutex">TryMutex</a> requirements, and an object
|
||||
<code>b</code> of type <code>bool</code>, the following expressions must be well-formed
|
||||
and have the indicated effects.</p>
|
||||
|
||||
<table border="1" cellpadding="5">
|
||||
<tr>
|
||||
<td><b>Expression</b></td>
|
||||
<td><b>Effects</b></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top"><code>L lk(m);</code></td>
|
||||
<td>Constructs an object <code>lk</code>, and associates mutex <code>m</code> with
|
||||
it, then calls <code>try_lock()</code></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top"><code>L lk(m,b);</code></td>
|
||||
<td>Constructs an object <code>lk</code>, and associates mutex <code>m</code> with
|
||||
it, then if <code>b</code>, calls <code>lock()</code></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top"><code>lk.try_lock()</code></td>
|
||||
<td>If locked(), throws <code>lock_error</code>. Makes a non-blocking attempt to
|
||||
lock the associated mutex, returning <code>true</code> if the lock attempt is
|
||||
successful, otherwise <code>false</code>.</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<h3><a name="ScopedTimedLock">ScopedTimedLock</a> Concept</h3>
|
||||
|
||||
<p>A ScopedTimedLock must meet the <a href="#Lock">Lock</a> requirements. For a
|
||||
ScopedTimedLock type <code>L</code> and an object <code>lk</code> of that type,
|
||||
and an object <code>m</code> of a type meeting the
|
||||
<a href="mutex_concept.html#TimedMutex">TimedMutex</a> requirements, and an object
|
||||
<code>b</code> of type <code>bool</code>, and an object <code>t</code> of type
|
||||
<code><a href="xtime.html">xtime</a></code>, the following expressions must be well-formed and have the indicated
|
||||
effects.</p>
|
||||
|
||||
<table border="1" cellpadding="5">
|
||||
<tr>
|
||||
<td><b>Expression</b></td>
|
||||
<td><b>Effects</b></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top"><code>L lk(m,t);</code></td>
|
||||
<td>Constructs an object <code>lk</code>, and associates mutex <code>m</code> with
|
||||
it, then calls <code>timed_lock(t)</code></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top"><code>L lk(m,b);</code></td>
|
||||
<td>Constructs an object <code>lk</code>, and associates mutex <code>m</code> with
|
||||
it, then if <code>b</code>, calls <code>lock()</code></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top"><code>lk.timed_lock(t)</code></td>
|
||||
<td>If locked(), throws lock_error. Makes a blocking attempt to lock the
|
||||
associated mutex, and returns <code>true</code> if successful within the specified
|
||||
time <code>t</code>, otherwise <code>false</code>.</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<h2><a name="Models">Models</a></h2>
|
||||
|
||||
<p><b>Boost.Threads</b> currently supplies three classes which model lock concepts.</p>
|
||||
|
||||
<p>These classes are normally accessed via typedefs of the same name supplied by
|
||||
a <a href="mutex_concept.html">mutex model</a>.</p>
|
||||
|
||||
<table border="1" cellpadding="5">
|
||||
<tr>
|
||||
<td><b>Concept</b></td>
|
||||
<td><b>Refines</b></td>
|
||||
<td><b>Classes Modeling the Concept</b></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><a href="#ScopedLock">ScopedLock</a></td>
|
||||
<td> </td>
|
||||
<td><a href="scoped_lock.html">scoped_lock</a></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><a href="#ScopedTryLock">ScopedTryLock</a></td>
|
||||
<td><a href="#ScopedLock">ScopedLock</a></td>
|
||||
<td><a href="scoped_try_lock.html">scoped_try_lock</a> </td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><a href="#ScopedTimedLock">ScopedTimedLock</a></td>
|
||||
<td><a href="#ScopedLock">ScopedLock</a></td>
|
||||
<td><a href="scoped_timed_lock.html">scoped_timed_lock</a></td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<hr>
|
||||
|
||||
<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->01 October, 2001<!--webbot bot="Timestamp" endspan i-checksum="38291" -->
|
||||
</p>
|
||||
|
||||
<p><i>© Copyright <a href="mailto:williamkempf@hotmail.com">William E. Kempf</a>
|
||||
2001 all rights reserved.</i></p>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
111
doc/lock_error.html
Normal file
111
doc/lock_error.html
Normal file
@@ -0,0 +1,111 @@
|
||||
<html>
|
||||
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
|
||||
<meta name="keywords" content="threads, BTL, thread library, C++">
|
||||
<link rel="stylesheet" type="text/css" href="styles.css">
|
||||
<title>Boost.Threads, lock_error</title>
|
||||
</head>
|
||||
|
||||
<body bgcolor="#FFFFFF" link="#0000FF" vlink="#800080">
|
||||
|
||||
<table border="0" cellpadding="7" cellspacing="0" width="100%">
|
||||
<tr>
|
||||
<td valign="top" width="300">
|
||||
<h3><img src="../../../c++boost.gif" alt="C++ Boost" width="277" height="86"></h3>
|
||||
</td>
|
||||
<td valign="top">
|
||||
<h1 align="center">Boost.Threads</h1>
|
||||
<h2 align="center">lock_error</h2>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<hr>
|
||||
|
||||
<p><a href="#Introduction">Introduction</a><br>
|
||||
<a href="#Header">Header</a><br>
|
||||
<a href="#Synopsis">Synopsis</a><br>
|
||||
<a href="#Members">Members</a><br>
|
||||
<a href="#Example">Example</a></p>
|
||||
|
||||
<h2><a name="Introduction">Introduction</a></h2>
|
||||
|
||||
<p>The <tt>lock_error</tt> class defines an exception type thrown to indicate a
|
||||
locking related error has been detected. Examples of such errors include a lock
|
||||
operation which can be determined to result in a deadlock, or unlock operations
|
||||
attempted by a thread that does not own the lock.</p>
|
||||
|
||||
<h2><a name="Header">Header</a></h2>
|
||||
|
||||
<pre>
|
||||
#include <a href="../../../boost/thread/thread.hpp"><boost/thread/thread.hpp></a>
|
||||
</pre>
|
||||
|
||||
<h2><a name="Synopsis">Synopsis</a></h2>
|
||||
|
||||
<pre>
|
||||
namespace boost
|
||||
|
||||
class lock_error : public std::runtime_error
|
||||
{
|
||||
public:
|
||||
lock_error();
|
||||
};
|
||||
}
|
||||
</pre>
|
||||
|
||||
<h2><a name="Members">Members</a></h2>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>Constructor</h3>
|
||||
|
||||
<pre>
|
||||
lock_error();
|
||||
</pre>
|
||||
|
||||
<p>Constructs a <tt>lock_error</tt> object.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h2><a name="Example">Example</a> Usage</h2>
|
||||
|
||||
<pre>
|
||||
#include <a href="../../../boost/thread/mutex.hpp"><boost/thread/mutex.hpp></a>
|
||||
#include <a href="../../../boost/thread/thread.hpp"><boost/thread/thread.hpp></a>
|
||||
#include <iostream>
|
||||
|
||||
int main(int, char*[])
|
||||
{
|
||||
boost::mutex mutex;
|
||||
boost::mutex::scoped_lock scoped_lock(mutex);
|
||||
try
|
||||
{
|
||||
boost::mutex::scoped_lock deadlock(mutex);
|
||||
std::cout << "lock succeeded" << std::endl;
|
||||
}
|
||||
catch (boost::lock_error& err)
|
||||
{
|
||||
std::cout << err.what() << " - deadlock occurred." << std::endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
</pre>
|
||||
|
||||
<p>The output is:</p>
|
||||
|
||||
<pre>
|
||||
thread lock error - deadlock occurred.
|
||||
</pre>
|
||||
|
||||
<hr>
|
||||
|
||||
<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->01 October, 2001<!--webbot bot="Timestamp" endspan i-checksum="38291" -->
|
||||
</p>
|
||||
|
||||
<p><i>© Copyright <a href="mailto:williamkempf@hotmail.com">William E. Kempf</a>
|
||||
2001 all rights reserved.</i></p>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
319
doc/mutex.html
Normal file
319
doc/mutex.html
Normal file
@@ -0,0 +1,319 @@
|
||||
<html>
|
||||
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
|
||||
<meta name="keywords" content="threads, BTL, thread library, C++">
|
||||
<link rel="stylesheet" type="text/css" href="styles.css">
|
||||
<title>Boost.Threads, mutex</title>
|
||||
</head>
|
||||
|
||||
<body bgcolor="#ffffff" link="#0000ff" vlink="#800080">
|
||||
|
||||
<table border="0" cellpadding="7" cellspacing="0" width="100%">
|
||||
<tr>
|
||||
<td valign="top" width="300">
|
||||
<h3><IMG alt="C++ Boost" src="../../../c++boost.gif" width="277" height="86"></h3>
|
||||
</td>
|
||||
<td valign="top">
|
||||
<h1 align="center">Boost.Threads</h1>
|
||||
<h2 align="center">mutex<br>
|
||||
try_mutex<br>
|
||||
timed_mutex</h2>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<hr>
|
||||
|
||||
<p><a href="#Introduction">Introduction</a><br>
|
||||
<a href="#Header">Header</a><br>
|
||||
<a href="#mutex Synopsis">Class mutex Synopsis</a><br>
|
||||
<a href="#mutex Members">Class mutex Members</a><br>
|
||||
<a href="#try_mutex Synopsis">Class try_mutex Synopsis</a><br>
|
||||
<a href="#try_mutex Members">Class try_mutex Members</a><br>
|
||||
<a href="#timed_mutex Synopsis">Class timed_mutex Synopsis</a><br>
|
||||
<a href="#timed_mutex Members">Class timed_mutex Members</a><br>
|
||||
<a href="#Example">Example</a></p>
|
||||
|
||||
<h2><a name="Introduction">Introduction</a></h2>
|
||||
|
||||
<p>The <tt><a href="#mutex Synopsis">mutex</a></tt>, <tt><a href="#try_mutex Synopsis">try_mutex</a></tt> and <tt><a href="#timed_mutex Synopsis">timed_mutex</a></tt> classes define full featured
|
||||
models of the <a href="mutex_concept.html#Mutex">Mutex</a>, <a href="mutex_concept.html#TryMutex">TryMutex</a>,
|
||||
and <a href="mutex_concept.html#TimedMutex">TimedMutex</a> concepts. These types should be used to
|
||||
non-recursively synchronize access to
|
||||
shared resources. For recursive locking mechanics, see <a href="recursive_mutex.html">recursive
|
||||
mutexes</a>.</p>
|
||||
|
||||
<p>Each class supplies one or more typedefs for lock types which model matching
|
||||
lock concepts. For the best possible performance you should use the mutex class that supports
|
||||
the minimum set of lock
|
||||
types that you need.</p>
|
||||
|
||||
<table border="1" cellpadding="5">
|
||||
<tr>
|
||||
<td><b>Mutex Class</b></td>
|
||||
<td><b>Lock name</b></td>
|
||||
<td><b>Implementation defined Lock Type</b></td>
|
||||
<td><b> Lock Concept</b></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top"><a href="#mutex Synopsis"><code>mutex</code></a></td>
|
||||
<td valign="middle"><code>scoped_lock</code></td>
|
||||
<td valign="middle"><code><a href="scoped_lock.html">boost::</a></code><a href="scoped_lock.html"><code>detail::thread::scoped_lock<mutex></code></a></td>
|
||||
<td valign="middle"><a href="lock_concept.html#ScopedLock">ScopedLock</a></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top"><tt><a href="#try_mutex Synopsis">try_mutex</a></tt> </td>
|
||||
<td valign="middle"><code>scoped_lock<br>
|
||||
scoped_try_lock</code></td>
|
||||
<td valign="middle"><code><a href="scoped_lock.html">boost::</a></code><a href="scoped_lock.html"><code>detail::thread::scoped_lock<try_mutex><br>
|
||||
</code></a><code><a href="scoped_try_lock.html">boost::detail::thread::scoped_try_lock<try_mutex></a></code></td>
|
||||
<td valign="middle"><a href="lock_concept.html#ScopedLock">ScopedLock</a><br>
|
||||
<a href="lock_concept.html#ScopedTryLock">ScopedTryLock</a></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top"><code><a href="#timed_mutex Synopsis">timed_mutex</a></code> </td>
|
||||
<td valign="middle"><code>scoped_lock<br>
|
||||
scoped_try_lock<br>
|
||||
scoped_timed_lock</code></td>
|
||||
<td valign="middle"><code><a href="scoped_lock.html">boost::</a></code><a href="scoped_lock.html"><code>detail::thread::scoped_lock<timed_mutex></code></a><br>
|
||||
<code><a href="scoped_try_lock.html">boost::</a></code><a href="scoped_try_lock.html"><code>detail::thread::scoped_try_lock<timed_mutex></code></a><br>
|
||||
<code><a href="scoped_timed_lock.html">boost::</a></code><a href="scoped_timed_lock.html"><code>detail::thread::scoped_timed_lock<timed_mutex></code></a></td>
|
||||
<td valign="middle"><a href="lock_concept.html#ScopedLock">ScopedLock</a><br>
|
||||
<a href="lock_concept.html#ScopedTryLock">ScopedTryLock</a><br>
|
||||
<a href="lock_concept.html#ScopedTimedLock">ScopedTimedLock</a></td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<p>The <tt>mutex</tt>, <tt>try_mutex</tt> and <tt>timed_mutex</tt> classes use an <tt>Unspecified</tt>
|
||||
<A href="mutex_concept.html#LockingStrategies">locking strategy</a>, so attempts to recursively lock
|
||||
them or attempts to unlock them by threads that don't own a lock on them result in <b>undefined behavior</b>.
|
||||
This strategy allows implementations to be as efficient as possible on any given platform. It is, however,
|
||||
recommended that implementations include debugging support to detect misuse when <tt>NDEBUG</tt> is
|
||||
not defined.</p>
|
||||
|
||||
<p>Like all the <b>Boost.Threads</b> <A href="mutex_concept.html">mutex models</a>, the <tt>mutex</tt>,
|
||||
<tt>try_mutex</tt> and <tt>timed_mutex</tt> leave the
|
||||
<A href="mutex_concept.html#SchedulingPolicies">scheduling policy</a> as <tt>Unspecified</tt>.
|
||||
Programmers should assume that threads waiting for a lock on objects of these types
|
||||
acquire
|
||||
the lock in a random order, even though the specific behavior for a given platform may be different.</p>
|
||||
|
||||
<h2><a name="Header">Header</a></h2>
|
||||
|
||||
<pre>
|
||||
#include <a href="../../../boost/thread/mutex.hpp"><boost/thread/mutex.hpp></a>
|
||||
</pre>
|
||||
|
||||
<h2>Class <a name="mutex Synopsis"> mutex Synopsis</a></h2>
|
||||
|
||||
<pre>
|
||||
namespace boost
|
||||
{
|
||||
class mutex : private <a href="../../utility/utility.htm">boost::noncopyable</a> // Exposition only.
|
||||
// Class mutex meets the <a href="overview.html#NonCopyable">NonCopyable</a> requirement.
|
||||
{
|
||||
public:
|
||||
typedef <i>[implementation defined; see <a href="#Introduction">Introduction</a>]</i> scoped_lock;
|
||||
|
||||
mutex();
|
||||
~mutex();
|
||||
};
|
||||
}
|
||||
</pre>
|
||||
|
||||
<h2>
|
||||
Class <a name="mutex Members">mutex Members</a>
|
||||
</h2>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>Constructor</h3>
|
||||
|
||||
<pre>
|
||||
mutex();
|
||||
</pre>
|
||||
|
||||
<p><b>Postconditions: </b><code>*this</code> is in the unlocked state.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>Destructor</h3>
|
||||
|
||||
<pre>
|
||||
~mutex();
|
||||
</pre>
|
||||
|
||||
<p><b>Requires:</b> <code>*this</code> is in the unlocked state.</p>
|
||||
|
||||
<p><b>Effects:</b> Destroys <code>*this</code>.</p>
|
||||
|
||||
<p><b>Dangers:</b> Destruction of a locked mutex is a serious programming error
|
||||
resulting in undefined behavior such as a program crash.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h2>
|
||||
Class <a name="try_mutex Synopsis">try_mutex Synopsis</a>
|
||||
</h2>
|
||||
|
||||
<pre>
|
||||
namespace boost
|
||||
{
|
||||
class try_mutex : private boost::noncopyable // Exposition only.
|
||||
// Class try_mutex meets the <a href="overview.html#NonCopyable">NonCopyable</a> requirement.
|
||||
{
|
||||
public:
|
||||
typedef <i>[implementation defined; see <a href="#Introduction">Introduction</a>]</i> scoped_lock;
|
||||
typedef <i>[implementation defined; see <a href="#Introduction">Introduction</a>]</i> scoped_try_lock;
|
||||
|
||||
try_mutex();
|
||||
~try_mutex();
|
||||
};
|
||||
}
|
||||
</pre>
|
||||
|
||||
<h2>Class <a name="try_mutex Members">try_mutex Members</a></h2>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>Constructor</h3>
|
||||
|
||||
<pre>
|
||||
try_mutex();
|
||||
</pre>
|
||||
|
||||
<p><b>Postconditions: </b><code>*this</code> is in the unlocked state.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>Destructor</h3>
|
||||
|
||||
<pre>
|
||||
~try_mutex();
|
||||
</pre>
|
||||
|
||||
<p><b>Requires:</b> <code>*this</code> is in the unlocked state.</p>
|
||||
|
||||
<p><b>Effects:</b> Destroys <code>*this</code>.</p>
|
||||
|
||||
<p><b>Dangers:</b> Destruction of a locked mutex is a serious programming error
|
||||
resulting in undefined behavior such as a program crash.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h2>
|
||||
Class <a name="timed_mutex Synopsis">timed_mutex Synopsis</a>
|
||||
</h2>
|
||||
|
||||
<pre>
|
||||
namespace boost
|
||||
{
|
||||
class timed_mutex : private boost::noncopyable // Exposition only.
|
||||
// Class timed_mutex meets the <a href="overview.html#NonCopyable">NonCopyable</a> requirement.
|
||||
{
|
||||
public:
|
||||
typedef <i>[implementation defined; see <a href="#Introduction">Introduction</a>]</i> scoped_lock;
|
||||
typedef <i>[implementation defined; see <a href="#Introduction">Introduction</a>]</i> scoped_try_lock;
|
||||
typedef <i>[implementation defined; see <a href="#Introduction">Introduction</a>]</i> scoped_timed_lock;
|
||||
|
||||
timed_mutex();
|
||||
~timed_mutex();
|
||||
};
|
||||
}
|
||||
</pre>
|
||||
|
||||
<h2>Class <a name="timed_mutex Members">timed_mutex Members</a></h2>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>Constructor</h3>
|
||||
|
||||
<pre>
|
||||
timed_mutex();
|
||||
</pre>
|
||||
|
||||
<p><b>Postconditions: </b><code>*this</code> is in the unlocked state.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>Destructor</h3>
|
||||
|
||||
<pre>
|
||||
~timed_mutex();
|
||||
</pre>
|
||||
|
||||
<p><b>Requires:</b> <code>*this</code> is in the unlocked state.</p>
|
||||
|
||||
<p><b>Effects:</b> Destroys <code>*this</code>.</p>
|
||||
|
||||
<p><b>Dangers:</b> Destruction of a locked mutex is a serious programming error
|
||||
resulting in undefined behavior such as a program crash.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h2><a name="Example">Example</a> Usage</h2>
|
||||
|
||||
<pre>
|
||||
#include <a href="../../../boost/thread/mutex.hpp"><boost/thread/mutex.hpp></a>
|
||||
#include <a href="../../../boost/thread/thread.hpp"><boost/thread/thread.hpp></a>
|
||||
#include <iostream>
|
||||
|
||||
boost::mutex io_mutex; // The iostreams are not guaranteed to be <a href="definitions.html#Thread-safe">thread-safe</a>!
|
||||
|
||||
class counter
|
||||
{
|
||||
public:
|
||||
counter() : count(0) { }
|
||||
|
||||
int increment() {
|
||||
boost::mutex::scoped_lock scoped_lock(mutex);
|
||||
return ++count;
|
||||
}
|
||||
|
||||
private:
|
||||
boost::mutex mutex;
|
||||
int count;
|
||||
};
|
||||
|
||||
counter c;
|
||||
|
||||
void change_count(void*)
|
||||
{
|
||||
int i = c.increment();
|
||||
boost::mutex::scoped_lock scoped_lock(io_mutex);
|
||||
std::cout << "count == " << i << std::endl;
|
||||
}
|
||||
|
||||
int main(int, char*[])
|
||||
{
|
||||
const int num_threads = 4;
|
||||
boost::thread_group thrds;
|
||||
for (int i=0; i < num_threads; ++i)
|
||||
thrds.create_thread(&change_count, 0);
|
||||
|
||||
thrds.join_all();
|
||||
|
||||
return 0;
|
||||
}
|
||||
</pre>
|
||||
|
||||
<p>The output is:</p>
|
||||
|
||||
<pre>
|
||||
count == 1
|
||||
count == 2
|
||||
count == 3
|
||||
count == 4
|
||||
</pre>
|
||||
|
||||
<hr>
|
||||
|
||||
<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->01 October, 2001<!--webbot bot="Timestamp" endspan i-checksum="38291" -->
|
||||
</p>
|
||||
|
||||
<p><i>© Copyright <A href="mailto:williamkempf@hotmail.com">William E. Kempf</a>
|
||||
2001 all rights reserved.</i></p>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
275
doc/mutex_concept.html
Normal file
275
doc/mutex_concept.html
Normal file
@@ -0,0 +1,275 @@
|
||||
<html>
|
||||
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
|
||||
<meta name="keywords" content="threads, BTL, thread library, C++">
|
||||
<title>Boost.Threads, Mutex Concept</title>
|
||||
</head>
|
||||
|
||||
<body bgcolor="#ffffff" link="#0000ff" vlink="#800080">
|
||||
|
||||
<table border="0" cellpadding="7" cellspacing="0" width="100%">
|
||||
<tr>
|
||||
<td valign="top" width="300">
|
||||
<h3><IMG height=86 alt="C++ Boost" src="../../../c++boost.gif" width=277></h3>
|
||||
</td>
|
||||
<td valign="top">
|
||||
<h1 align="center">Boost.Threads</h1>
|
||||
<h2 align="center">Mutex Concepts</h2>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<hr>
|
||||
|
||||
<p><a href="#Introduction">Introduction</a><br>
|
||||
<a href="#LockingStrategies">Locking Strategies</a><br>
|
||||
<a href="#Recursive">Recursive</a><br>
|
||||
<a href="#CheckedStrategy">Checked</a><br>
|
||||
<a href="#UncheckedStrategy">Unchecked</a><br>
|
||||
<a href="#UnspecifiedStrategy">Unspecified</a><br>
|
||||
<a href="#SchedulingPolicies">Scheduling Policies</a><br>
|
||||
<a href="#FIFO">FIFO</a><br>
|
||||
<a href="#Priority Driven">Priority Driven</a><br>
|
||||
<a href="#UndefinedScheduling">Undefined</a><br>
|
||||
<a href="#UnspecifiedScheduling">Unspecified</a><br>
|
||||
<a href="#Requirements">Concept Requirements</a><br>
|
||||
<a href="#Mutex">Mutex Concept</a><br>
|
||||
<a href="#TryMutex">TryMutex Concept</a><br>
|
||||
<a href="#TimedMutex">TimedMutex Concept</a><br>
|
||||
<a href="#Models">Models</a></p>
|
||||
|
||||
<h2><a name="Introduction">Introduction</a></h2>
|
||||
|
||||
<p>A mutex (short for mutual-exclusion) concept serializes access to
|
||||
a resource shared between multiple threads. The <a href="#Mutex">Mutex</a>
|
||||
concept, with <a href="#TryMutex">TryMutex</a> and <a href="#TimedMutex">TimedMutex</a>
|
||||
refinements, formalize the requirements. A model that implements Mutex and its
|
||||
refinements has two states: <b> locked</b> and <b>unlocked</b>. Before using a
|
||||
shared resource, a thread locks a Boost.Threads mutex model object,
|
||||
insuring <a href="definitions.html#Thread-safe">thread-safe</a> access to the shared
|
||||
resource. When use of the shared resource is complete, the thread unlocks the mutex
|
||||
model object, allowing another thread to acquire the lock and use the shared resource.</p>
|
||||
|
||||
<p>Traditional C thread APIs, like Pthreads or the Windows thread APIs, expose
|
||||
functions to lock and unlock a mutex model. This is dangerous since it's easy to forget
|
||||
to unlock a locked mutex. When the flow of control is complex, with multiple return
|
||||
points, the likelihood of forgetting to unlock a mutex model would become even greater.
|
||||
When exceptions are thrown, it becomes nearly impossible to ensure that the mutex is
|
||||
unlocked properly when using these traditional API's. The result is
|
||||
<a href="definitions.html#Deadlock">deadlock</a>.</p>
|
||||
|
||||
<p>Many C++ threading libraries use a pattern known as <i>Scoped Locking</i>
|
||||
<a href="bibliography.html#Schmidt 00">[Schmidt 00]</a> to free the programmer from the
|
||||
need to explicitly lock and unlock mutexes. With this pattern, a
|
||||
<A href="lock_concept.html">lock concept</A> is employed where the lock model's
|
||||
constructor locks the associated mutex model and the destructor automatically does the
|
||||
unlocking. The <b>Boost.Threads</b> library takes this pattern to the extreme in that
|
||||
lock concepts are the only way to lock and unlock a mutex model: lock and unlock
|
||||
functions are not exposed by any <b>Boost.Threads </b>mutex models. This helps to
|
||||
ensure safe usage patterns, especially when code throws exceptions.</p>
|
||||
|
||||
<h2><a name="LockingStrategies">Locking Strategies</a></h2>
|
||||
|
||||
<p>Every mutex model follows one of several locking strategies. These strategies
|
||||
define the semantics for the locking operation when the calling thread already
|
||||
owns a lock on the mutex model.</p>
|
||||
|
||||
<h3><a name="Recursive">Recursive</a></h3>
|
||||
|
||||
<p>With a recursive locking strategy when a thread attempts to acquire a lock on
|
||||
the mutex model for which it already owns a lock, the operation is successful.
|
||||
Note the distinction between a thread, which may have multiple locks outstanding
|
||||
on a recursive mutex, and a lock object, which even for a recursive mutex cannot
|
||||
have its lock() function called multiple times without first calling unlock().</p>
|
||||
|
||||
<p>Internally a lock count is maintained and the owning thread must unlock the
|
||||
mutex model the same number of times that it's locked it before the mutex model's
|
||||
state returns to unlocked. Since mutex models in <b>Boost.Threads</b> expose
|
||||
locking functionality only through lock concepts, a thread will always unlock a mutex
|
||||
model the same number of times that it locked it. This helps to eliminate a whole set
|
||||
of errors typically found in traditional C style thread APIs.</p>
|
||||
|
||||
<p>Classes <A href="recursive_mutex.html">recursive_mutex</A>,
|
||||
<A href="recursive_mutex.html">recursive_try_mutex</A> and
|
||||
<A href="recursive_mutex.html">recursive_timed_mutex</A> use this locking strategy.</p>
|
||||
|
||||
<h3><a name="CheckedStrategy">Checked</a></h3>
|
||||
|
||||
<p>With a checked locking strategy when a thread attempts to acquire a lock on
|
||||
the mutex model for which the thread already owns a lock, the operation will fail with
|
||||
some sort of error indication. Further, attempts by a thread to unlock a mutex
|
||||
that was not locked by the thread will also return some sort of error indication.
|
||||
In <b>Boost.Threads</b>, an exception of type <A href="lock_error.html">lock_error</A>
|
||||
would be thrown in these cases.</p>
|
||||
|
||||
<p><b>Boost.Threads</b> does not currently provide any mutex models that use this
|
||||
strategy.</p>
|
||||
|
||||
<h3><a name="UncheckedStrategy">Unchecked</a></h3>
|
||||
|
||||
<p>With an unchecked locking strategy when a thread attempts to acquire a lock
|
||||
on the mutex model for which the thread already owns a lock the operation will
|
||||
<a href="definitions.html#Deadlock">deadlock</a>. In general this locking strategy is
|
||||
less safe than a checked or recursive strategy, but it's also a faster strategy and so
|
||||
is employed by many libraries.</p>
|
||||
|
||||
<p><b>Boost.Threads</b> does not currently provide any mutex models that use this
|
||||
strategy.</p>
|
||||
|
||||
<h3><a name="UnspecifiedStrategy">Unspecified</a></h3>
|
||||
|
||||
<p>With an unspecified locking strategy, when a thread attempts to acquire a lock
|
||||
on a mutex model for which the thread already owns a lock the operation results in
|
||||
<b>undefined behavior</b>. When a mutex model has an unspecified locking strategy the
|
||||
programmer must assume that the mutex model instead uses an unchecked strategy.</p>
|
||||
|
||||
<p>In general a mutex model with an unspecified locking strategy is unsafe, and it
|
||||
requires programmer discipline to use the mutex model properly. However, this strategy
|
||||
allows an implementation to be as fast as possible with no restrictions on its
|
||||
implementation. This is especially true for portable implementations that wrap the
|
||||
native threading support of a platform. For this reason, the classes
|
||||
<A href="mutex.html">mutex</A>, <A href="mutex.html">try_mutex</A> and
|
||||
<A href="mutex.html">timed_mutex</A> use this locking strategy despite the lack of
|
||||
safety.</p>
|
||||
|
||||
<h2><a name="SchedulingPolicies">Scheduling Policies</a></h2>
|
||||
|
||||
<p>Every mutex model follows one of several scheduling policies. These policies
|
||||
define the semantics when the mutex model is unlocked and there is more than one
|
||||
thread waiting to acquire a lock. In other words, the policy defines which waiting
|
||||
thread shall acquire the lock.</p>
|
||||
|
||||
<h3><a name="FIFO">FIFO</a></h3>
|
||||
|
||||
<p>With a FIFO scheduling policy, threads waiting for the lock will acquire it in
|
||||
a first come first serve order (or First In First Out). This can help prevent a
|
||||
high priority thread from starving lower priority threads that are also waiting
|
||||
on the mutex lock.</p>
|
||||
|
||||
<h3><a name="Priority Driven">Priority Driven</a></h3>
|
||||
|
||||
<p>With a Priority Driven scheduling policy, the thread with the highest priority
|
||||
acquires the lock. Note that this means that low-priority threads may never acquire
|
||||
the lock if the mutex model has high contention and there is always at least one
|
||||
high-priority thread waiting. This is known as thread starvation. When multiple threads
|
||||
of the same priority are waiting on the mutex lock one of the other scheduling
|
||||
priorities will determine which thread shall acquire the lock.</p>
|
||||
|
||||
<h3><a name="UndefinedScheduling">Undefined</a></h3>
|
||||
|
||||
<p>Threads acquire the lock in no particular order. Users should assume that
|
||||
low-priority threads may wait indefinitely, and that threads of the same
|
||||
priority acquire the lock in essentially random order.</p>
|
||||
|
||||
<h3><a name="UnspecifiedScheduling">Unspecified</a></h3>
|
||||
|
||||
<p>The mutex model does not specify which scheduling policy is used. The programmer
|
||||
must assume that an undefined scheduling policy is used. In order to ensure portability,
|
||||
all <b>Boost.Threads</b> mutex models use an unspecified scheduling policy.</p>
|
||||
|
||||
<h2>Concept <a name="Requirements">Requirements</a></h2>
|
||||
|
||||
<h3><a name="Mutex">Mutex</a> Concept</h3>
|
||||
|
||||
<p>A Mutex object has two states: locked and unlocked. Mutex object state can only be
|
||||
determined by an object meeting the <a href="lock_concept.html#ScopedLock">ScopedLock</a>
|
||||
requirements and constructed for the Mutex object.</p>
|
||||
|
||||
<p>A Mutex is <a href="../../utility/utility.htm#Class noncopyable">noncopyable</a>.</p>
|
||||
|
||||
<p>For a Mutex type M and an object m of that type, the following expressions must be
|
||||
well-formed and have the indicated effects.</p>
|
||||
|
||||
<table border="1" cellpadding="5">
|
||||
<tr>
|
||||
<td><b>Expression</b></td>
|
||||
<td><b>Effects</b></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>M m;</code></td>
|
||||
<td>Constructs a mutex object m. Post-condition: m is unlocked.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>(&m)->~M();</code></td>
|
||||
<td>Precondition: m is unlocked. Destroys a mutex object m.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>M::scoped_lock</code></td>
|
||||
<td>A type meeting the <a href="lock_concept.html#ScopedLock">ScopedLock</a>
|
||||
requirements.</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<h3><a name="TryMutex">TryMutex</a> Concept</h3>
|
||||
<p>A TryMutex must meet the <a href="#Mutex"> Mutex</a> requirements. In addition, for a
|
||||
TryMutex type M and an object m of that type, the following expressions must be
|
||||
well-formed and have the indicated effects.</p>
|
||||
<table border="1" cellpadding="5">
|
||||
<tr>
|
||||
<td><b>Expression</b></td>
|
||||
<td><b>Effects</b></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>M::scoped_try_lock</code></td>
|
||||
<td>A type meeting the <a href="lock_concept.html#ScopedTryLock">ScopedTryLock</a>
|
||||
requirements.</td>
|
||||
</tr>
|
||||
</table>
|
||||
<h3><a name="TimedMutex">TimedMutex</a> Concept</h3>
|
||||
<p>A TimedMutex must meet the <a href="#TryMutex"> TryMutex</a> requirements. In addition, for a
|
||||
TimedMutex type M and an object m of that type, the following
|
||||
expressions must be well-formed and have the indicated effects.</p>
|
||||
<table border="1" cellpadding="5">
|
||||
<tr>
|
||||
<td><b>Expression</b></td>
|
||||
<td><b>Effects</b></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>M::scoped_timed_lock</code></td>
|
||||
<td>A type meeting the <a href="lock_concept.html#ScopedTimedLock">ScopedTimedLock</a>
|
||||
requirements.</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<h2><a name="Models">Models</a></h2>
|
||||
|
||||
<p> <b>Boost.Threads</b> currently supplies six classes which model mutex
|
||||
concepts.</p>
|
||||
|
||||
<table border="1" cellpadding="5">
|
||||
<tr>
|
||||
<td><b>Concept</b></td>
|
||||
<td><b>Refines</b></td>
|
||||
<td><b>Classes Modeling the Concept</b></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top"><a href="#Mutex">Mutex</a></td>
|
||||
<td valign="top"> </td>
|
||||
<td><A href="mutex.html">mutex</A><br>
|
||||
<A href="recursive_mutex.html">recursive_mutex</A></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top"><a href="#TryMutex">TryMutex</a></td>
|
||||
<td valign="top"><a href="#Mutex">Mutex</a></td>
|
||||
<td><A href="mutex.html">try_mutex<br>
|
||||
</A><A href="recursive_mutex.html">recursive_try_mutex</A> </td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top"><a href="#TimedMutex">TimedMutex</a></td>
|
||||
<td valign="top"><a href="#TryMutex">TryMutex</a></td>
|
||||
<td><A href="mutex.html">timed_mutex<br>
|
||||
</A><A href="recursive_mutex.html">recursive_timed_mutex</A></td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<hr>
|
||||
|
||||
<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->01 October, 2001<!--webbot bot="Timestamp" endspan i-checksum="38291" -->
|
||||
</p>
|
||||
|
||||
<p><i>© Copyright <A href="mailto:williamkempf@hotmail.com">William E. Kempf</A>
|
||||
2001 all rights reserved.</i></p>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
156
doc/overview.html
Normal file
156
doc/overview.html
Normal file
@@ -0,0 +1,156 @@
|
||||
<html>
|
||||
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
|
||||
<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
|
||||
<meta name="ProgId" content="FrontPage.Editor.Document">
|
||||
<title>Boost.Threads Overview</title>
|
||||
</head>
|
||||
|
||||
<body>
|
||||
|
||||
<table border="0" cellpadding="7" cellspacing="0" width="100%">
|
||||
<tr>
|
||||
<td valign="top" width="300">
|
||||
<h3><IMG height=86 alt="C++ Boost" src="../../../c++boost.gif" width=277></h3>
|
||||
</td>
|
||||
<td valign="top">
|
||||
<h1 align="center">Boost.Threads</h1>
|
||||
<h2 align="center">Overview</h2>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<p><a href="#Introduction">Introduction</a><br>
|
||||
<a href="#Dangers">Dangers</a><br>
|
||||
<a href="#Library">C++ Standard Library usage</a><br>
|
||||
<a href="#Common">Common requirements</a></p>
|
||||
|
||||
<h2><a name="Introduction">Introduction</a></h2>
|
||||
<p>Boost.Threads allows C++ programs to execute as multiple, asynchronous,
|
||||
independent, threads-of-execution. Each thread has its own machine state
|
||||
including program instruction counter and registers. Programs which execute as
|
||||
multiple threads are call multi-threaded programs to distinguish them from
|
||||
traditional single-threaded programs. <a href="definitions.html">Definitions</a>
|
||||
gives a more complete description of the multi-threading execution environment.</p>
|
||||
<p>Multi-threading provides several advantages:</p>
|
||||
<ul>
|
||||
<li>Programs which would otherwise block waiting for some external event can
|
||||
continue to respond if the blocking operation is placed in a separate
|
||||
thread. Multi-threading is usually an absolute requirement for these
|
||||
programs.</li>
|
||||
</ul>
|
||||
<ul>
|
||||
<li>Well-designed multi-threaded programs may execute faster than single-threaded
|
||||
programs, particularly on multi-processor hardware.
|
||||
Note, however, that poorly-designed multi-threaded programs are often slower
|
||||
that single-threaded programs.</li>
|
||||
</ul>
|
||||
<ul>
|
||||
<li>Some program designs may be easier to formulate using a multi-threaded
|
||||
approach.
|
||||
After all, the real world is asynchronous! </li>
|
||||
</ul>
|
||||
<h2><a name="Dangers">Dangers</a></h2>
|
||||
<p>Beyond the errors which can occur in single-threaded programs, multi-threaded
|
||||
programs are subject to additional errors:</p>
|
||||
<ul>
|
||||
<li><a href="definitions.html#Race condition">Race conditions</a>.
|
||||
<li><a href="definitions.html#Deadlock">Deadlock</a> (sometimes called
|
||||
"deadly embrace")
|
||||
<li><a href="definitions.html#Priority failure">Priority failures</a>
|
||||
(priority inversion, infinite overtaking, starvation, etc.)</li>
|
||||
</ul>
|
||||
<p>Every multi-threaded program must be designed carefully to avoid race
|
||||
conditions and deadlock. These aren't rare or exotic failures - they are
|
||||
virtually guaranteed to occur unless multi-threaded code is designed to avoid
|
||||
them. Priority failures are somewhat less common, but are none-the-less
|
||||
serious.</p>
|
||||
<p>The <a href="introduction.html">Boost.Threads design</a> attempts to minimize
|
||||
these errors, but they will still occur unless the programmer proactively
|
||||
designs to avoid them.</p>
|
||||
<h3>Testing and debugging considerations</h3>
|
||||
<p>Multi-threaded programs are non-deterministic. In other words, the same
|
||||
program with the same input data may follow different execution paths each time
|
||||
it is invoked. That can make testing and debugging a nightmare:</p>
|
||||
<ul>
|
||||
<li>Failures are often not repeatable.
|
||||
<li>Probe effect causes debuggers to produce very different results from
|
||||
non-debug uses.
|
||||
<li>Debuggers require special support to show thread state.
|
||||
<li>Tests on a single processor system may give no indication of serious
|
||||
errors which would appear on multiprocessor systems, and visa versa. Thus test
|
||||
cases should include a varying number of processors. </li>
|
||||
<li>For programs which create a varying number of threads according to
|
||||
workload, tests which don't span the full range of possibilities may miss
|
||||
serious errors.</li>
|
||||
</ul>
|
||||
<h3>Getting a head start</h3>
|
||||
<p>Although it might appear that multi-threaded programs are inherently
|
||||
unreliable, many reliable multi-threaded programs do exist. Multi-threading
|
||||
techniques are known which lead to reliable programs.</p>
|
||||
<p>Design patterns for reliable multi-threaded programs, including the important
|
||||
<i>monitor</i> pattern, are presented in <cite>Pattern-Oriented Software Architecture Volume 2 - Patterns for
|
||||
Concurrent and Networked Objects</cite> [<a href="bibliography.html#Schmidt-00">Schmidt
|
||||
00</a>]. Many important multi-threading programming considerations
|
||||
(independent of threading library) are discussed in <cite>Programming with
|
||||
POSIX Threads</cite> [<a href="bibliography.html#Butenhof-97">Butenhof 97</a>].</p>
|
||||
<p>Reading and study first yields a head start toward designing reliable
|
||||
multi-threaded programs.</p>
|
||||
|
||||
<h2><a name="Library">C++ Standard Library usage in multi-threaded programs</a></h2>
|
||||
<h3>Runtime libraries</h3>
|
||||
<p><b>Warning:</b> Multi-threaded programs such as those using <b>Boost.Threads</b> must link to
|
||||
<a href="definitions.html#Thread-safe">thread-safe</a> versions of all runtime
|
||||
libraries used by the program, including the runtime library for the C++
|
||||
Standard Library. Otherwise <a href="definitions.html#Race condition">race
|
||||
conditions</a> will occur when multiple threads simultaneously execute runtime
|
||||
library functions for <i>new</i>, <i>delete</i>, or other language features
|
||||
which imply shared state. </p>
|
||||
<h3>Potentially non-thread-safe functions</h3>
|
||||
<p>Certain C++ Standard Library functions inherited from C are particular
|
||||
problems because they hold internal state between calls:</p>
|
||||
<ul>
|
||||
<li>rand</li>
|
||||
<li>strtok</li>
|
||||
<li>asctime</li>
|
||||
<li>ctime </li>
|
||||
<li>gmtime</li>
|
||||
<li>localtime</li>
|
||||
</ul>
|
||||
<p>It is possible to write thread-safe implementations of these by using <a href="thread_specific_ptr.html">thread-specific
|
||||
storage</a>, and several C++ compiler vendors do just that. The technique
|
||||
is well-know and is explained in [<a href="bibliography.html#Butenhof-97">Buttenhof-97</a>].</p>
|
||||
<p>But at least one vendor (HP-UX) does not provide thread-safe implementations
|
||||
of the above functions in their otherwise thread-safe runtime library.
|
||||
Instead they provide replacement functions with different names and arguments.</p>
|
||||
<p><b>Recommendation:</b> For the most portable, yet thread-safe code, use Boost
|
||||
replacements for the problem functions. See the <a href="../../random/index.html">Boost
|
||||
Random Number Library</a> and <a href="../../tokenizer/index.htm">Boost
|
||||
Tokenizer Library</a>.</p>
|
||||
<h2><a name="Common">Common</a> requirements for all Boost.Threads components</h2>
|
||||
<h3>Exceptions</h3>
|
||||
<p> <b>Boost.Threads</b> destructors never throw exceptions. Unless otherwise
|
||||
specified, other <b>Boost.Threads</b>
|
||||
functions that do not have an exception-specification may throw implementation-defined exceptions.</p>
|
||||
<p>In particular, <b>Boost.Threads</b> reports failure to allocate storage by throwing an exception of type
|
||||
std::bad_alloc, or a class derived from std::bad_alloc, failure to obtain
|
||||
thread resources other than memory by throwing an exception of type <a href="thread_resource_error.html">boost::thread_resource_error</a>,
|
||||
and certain lock related failures by throwing an exception of type <a href="lock_error.html">boost::lock_error</a></p>
|
||||
<p><b>Rationale: </b>Follows the C++ Standard Library practice of allowing all
|
||||
functions except destructors or other specified functions to throw exceptions on
|
||||
errors.</p>
|
||||
<h3><a name="NonCopyable">NonCopyable</a> requirement</h3>
|
||||
<p><b>Boost.Threads</b> classes documented as meeting the NonCopyable requirement disallow copy
|
||||
construction and copy assignment. For the sake of exposition, the synopsis of
|
||||
such classes show private derivation from <a href="../../utility/utility.htm">boost::noncopyable</a>.
|
||||
Users should not depend on this derivation, however, as implementations are free
|
||||
to meet the NonCopyable requirement in other ways.</p>
|
||||
|
||||
<hr>
|
||||
<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->01 October, 2001<!--webbot bot="Timestamp" endspan i-checksum="38291" -->
|
||||
</p>
|
||||
<p>© Copyright 2001 Beman Dawes</p>
|
||||
</body>
|
||||
|
||||
</html>
|
||||
431
doc/rationale.html
Normal file
431
doc/rationale.html
Normal file
@@ -0,0 +1,431 @@
|
||||
<html>
|
||||
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
|
||||
<meta name="keywords" content="threads, BTL, thread library, C++">
|
||||
<title>Boost.Threads, rationale</title>
|
||||
</head>
|
||||
|
||||
<body bgcolor="#ffffff" link="#0000ff" vlink="#800080">
|
||||
|
||||
<table border="0" cellpadding="7" cellspacing="0" width="100%">
|
||||
<tr>
|
||||
<td valign="top" width="300">
|
||||
<h3><IMG height=86 alt="C++ Boost" src="../../../c++boost.gif" width=277></h3>
|
||||
</td>
|
||||
<td valign="top">
|
||||
<h1 align="center">Boost.Threads</h1>
|
||||
<h2 align="center">Rationale</h2>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<hr>
|
||||
|
||||
<p>This page explains the rationale behind various design decisions in the <b> Boost.Threads</b>
|
||||
library. Having the rationale documented here should explain how we arrived at the current
|
||||
design as well as prevent future rehashing of discussions and thought processes that have
|
||||
already occurred. It can also give users a lot of insight into the design process required
|
||||
for this library.</p>
|
||||
|
||||
<h2><a name="library">Rationale for the Creation of Boost.Threads</a></h2>
|
||||
|
||||
<p>Processes often have a degree of "potential parallelism" and it can often be more intuitive
|
||||
to design systems with this in mind. Further, these parallel processes can result in more responsive
|
||||
programs. The benefits for multi-threaded programming are quite well known to most modern programmers,
|
||||
yet the C++ language doesn't directly support this concept.</p>
|
||||
|
||||
<p>Many platforms support multi-threaded programming despite the fact that the language doesn't support
|
||||
it. They do this through external libraries, which are, unfortunately, platform specific. POSIX has
|
||||
tried to address this problem through the standardization of a "pthread" library. However, this
|
||||
is a standard only on POSIX platforms, so its portability is limited.</p>
|
||||
|
||||
<p>Another problem with POSIX and other platform specific thread libraries is that they are
|
||||
almost universally C based libraries. This leaves several C++ specific issues unresolved, such
|
||||
as what happens when an exception is thrown in a thread. Further, there are some C++ concepts,
|
||||
such as destructors, that can make usage much easier than what's available in a C library.</p>
|
||||
|
||||
<p>What's truly needed is C++ language support for threads. However, the C++ standards committee needs
|
||||
existing practice or a good proposal as a starting point for adding this to the standard.</p>
|
||||
|
||||
<p>The Boost.Threads library was developed to provide a C++ developer with a portable interface
|
||||
for writing multi-threaded programs on numerous platforms. There's a hope that the library can
|
||||
be the basis for a more detailed proposal for the C++ standards committee to consider for inclusion
|
||||
in the next C++ standard.</p>
|
||||
|
||||
<h2><a name="primitives">Rationale for the Low Level Primitives Supported in Boost.Threads</a></h2>
|
||||
|
||||
<p>The Boost.Threads library supplies a set of low level primitives for writing multi-threaded
|
||||
programs, such as semaphores, mutexes and condition variables. In fact, the first release of
|
||||
Boost.Threads supports only these low level primitives. However, computer
|
||||
science research has shown
|
||||
that use of these primitives is difficult since there's no way to mathematically prove that a
|
||||
usage pattern is correct, meaning it doesn't result in race conditions or deadlocks. There
|
||||
are several algebras (such as CSP, CCS and Join calculus) that have been developed to help write
|
||||
provably correct parallel processes. In order to prove the correctness these processes must
|
||||
be coded using higher level abstractions. So why does Boost.Threads support the lower level
|
||||
concepts?</p>
|
||||
|
||||
<p>The reason is simple: the higher level concepts need to be implemented using at least some
|
||||
of the lower level concepts. So having portable lower level concepts makes it easier to develop
|
||||
the higher level concepts and will allow researchers to experiment with various techniques.</p>
|
||||
|
||||
<p>Beyond this theoretical application of higher level concepts, however, the fact remains that
|
||||
many multi-threaded programs are written using only the lower level concepts, so they are
|
||||
useful in and of themselves, even if it's hard to prove that their usage is correct. Since
|
||||
many users will be familiar with these lower level concepts but be unfamiliar with any of the
|
||||
higher level concepts there's also an argument for accessibility.</p>
|
||||
|
||||
<h2><a name="lock_objects">Rationale for the Lock Design</a></h2>
|
||||
|
||||
<p>Programmers who are used to multi-threaded programming issues will quickly note that the
|
||||
Boost.Thread's design for mutex lock concepts is not <a href="definitions.html#Thread-safe">thread-safe</a>
|
||||
(this is clearly documented
|
||||
as well). At first this may seem like a serious design flaw. Why have a multi-threading primitive
|
||||
that's not thread-safe itself?</p>
|
||||
|
||||
<p>A lock object is not a synchronization primitive. A lock object's sole responsibility is
|
||||
to ensure that a mutex is both locked and unlocked in a manner that won't result in the common
|
||||
error of locking a mutex and then forgetting to unlock it. This means that instances of a
|
||||
lock object are only going to be created, at least in theory, within block scope and won't
|
||||
be shared between threads. Only the mutex objects will be created outside of block scope and/or
|
||||
shared between threads. Though it's possible to create a lock object outside of block scope and
|
||||
to share it between threads to do so would not be a typical usage. Nor are there any cases when
|
||||
such usage would be required.</p>
|
||||
|
||||
<p>Lock objects must maintain some state information. In order to allow a program to determine
|
||||
if a try_lock or timed_lock was successful the lock object must retain state indicating
|
||||
the success or failure of the call made in its constructor. If a lock object were to have
|
||||
such state and remain thread-safe it would need to synchronize access to the state information
|
||||
which would result in roughly doubling the time of most operations. Worse, since checking
|
||||
the state can occur only by a call after construction we'd have a race condition if the lock
|
||||
object were shared between threads.</p>
|
||||
|
||||
<p>So, to avoid the overhead of synchronizing access to the state information and to avoid
|
||||
the race condition the Boost.Threads library simply does nothing to make lock objects thread-safe. Instead, sharing a lock object between threads results in undefined behavior. Since the
|
||||
only proper usage of lock objects is within block scope this isn't a problem, and so long
|
||||
as the lock object is properly used there's no danger of any multi-threading issues.</p>
|
||||
|
||||
<h2><a name="thread">Rationale for Non-copyable Thread Type</a></h2>
|
||||
|
||||
<p>Programmers who are used to C libraries for multi-threaded programming are likely to
|
||||
wonder why Boost.Threads uses a non-copyable design for <a href="thread.html">boost::thread</a>. After all, the C
|
||||
thread types are copyable, and you often have a need for copying them within user code.
|
||||
However, careful comparison of C designs to C++ designs shows a flaw in this logic.</p>
|
||||
|
||||
<p>All C types are copyable. It is, in fact, not possible to make a non-copyable type in
|
||||
C. For this reason types that represent system resources in C are often designed to behave
|
||||
very similarly to a pointer to dynamic memory. There's an API for acquiring the resource
|
||||
and an API for releasing the resources. For memory we have pointers as the type and
|
||||
alloc/free for the acquisition and release APIs. For files we have FILE* as the type
|
||||
and fopen/fclose for the acquisition and release APIs. You can freely copy instances of the
|
||||
types but must manually manage the lifetime of the actual resource through the acquisition
|
||||
and release APIs.</p>
|
||||
|
||||
<p>C++ designs recognize that the acquisition and release APIs are error prone and try
|
||||
to eliminate possible errors by acquiring the resource in the constructor and releasing it
|
||||
in the destructor. The best example of such a design is the std::iostream set of classes
|
||||
which can represent the same resource as the FILE* type in C. A file is opened in the
|
||||
std::fstream's constructor and closed in its destructor. However, if an iostream were
|
||||
copyable it could lead to a file being closed twice, an obvious error, so the std::iostream
|
||||
types are noncopyable by design. This is the same design used by boost::thread, which
|
||||
is a simple and easy to understand design that's consistent with other C++ standard types.</p>
|
||||
|
||||
<p>During the design of boost::thread it was pointed out that it would be possible to allow
|
||||
it to be a copyable type if some form of "reference management" were used, such as ref-counting
|
||||
or ref-lists, and many argued for a boost::thread_ref design instead. The reasoning was
|
||||
that copying "thread" objects was a typical need in the C libraries, and so presumably would
|
||||
be in the C++ libraries as well. It was also thought that implementations could provide
|
||||
more efficient reference management then wrappers (such as boost::shared_ptr) around a noncopyable
|
||||
thread concept. Analysis of whether or not these arguments would hold true don't appear to
|
||||
bear them out. To illustrate the analysis we'll first provide pseudo-code illustrating the six
|
||||
typical usage patterns of a thread object.</p>
|
||||
|
||||
<h3>1. Simple creation of a thread.</h3>
|
||||
|
||||
<pre>
|
||||
void foo()
|
||||
{
|
||||
create_thread(&bar);
|
||||
}
|
||||
</pre>
|
||||
|
||||
<h3>2. Creation of a thread that's later joined.</h3>
|
||||
|
||||
<pre>
|
||||
void foo()
|
||||
{
|
||||
thread = create_thread(&bar);
|
||||
join(thread);
|
||||
}
|
||||
</pre>
|
||||
|
||||
<h3>3. Simple creation of several threads in a loop.</h3>
|
||||
|
||||
<pre>
|
||||
void foo()
|
||||
{
|
||||
for (int i=0; i<NUM_THREADS; ++i)
|
||||
create_thread(&bar);
|
||||
}
|
||||
</pre>
|
||||
|
||||
<h3>4. Creation of several threads in a loop which are later joined.</h3>
|
||||
|
||||
<pre>
|
||||
void foo()
|
||||
{
|
||||
for (int i=0; i<NUM_THREADS; ++i)
|
||||
threads[i] = create_thread(&bar);
|
||||
for (int i=0; i<NUM_THREADS; ++i)
|
||||
threads[i].join();
|
||||
}
|
||||
</pre>
|
||||
|
||||
<h3>5. Creation of a thread whose ownership is passed to another object/method.</h3>
|
||||
|
||||
<pre>
|
||||
void foo()
|
||||
{
|
||||
thread = create_thread(&bar);
|
||||
manager.owns(thread);
|
||||
}
|
||||
</pre>
|
||||
|
||||
<h3>6. Creation of a thread whose ownership is shared between multiple objects.</h3>
|
||||
|
||||
<pre>
|
||||
void foo()
|
||||
{
|
||||
thread = create_thread(&bar);
|
||||
manager1.add(thread);
|
||||
manager2.add(thread);
|
||||
}
|
||||
</pre>
|
||||
|
||||
<p>Of these usage patterns there's only one that requires reference management (number 6).
|
||||
Hopefully it's fairly obvious that this usage pattern simply won't occur as often as the
|
||||
other usage patterns. So there really isn't a "typical need" for a thread concept, though
|
||||
there is some need.</p>
|
||||
|
||||
<p>Since the need isn't typical we must use different criteria for deciding on either a
|
||||
thread_ref or thread design. Possible criteria include ease of use and performance. So let's
|
||||
analyze both of these carefully.</p>
|
||||
|
||||
<p>With ease of use we can look at existing experience. The standard C++ objects that
|
||||
represent a system resource, such as std::iostream, are noncopyable, so we know that C++
|
||||
programmers must at least be experienced with this design. Most C++ developers are also
|
||||
used to smart pointers such as boost::shared_ptr, so we know they can at least adapt to
|
||||
a thread_ref concept with little effort. So existing experience isn't going to lead us
|
||||
to a choice.</p>
|
||||
|
||||
<p>The other thing we can look at is how difficult it is to use both types for the six usage
|
||||
patterns above. If we find it overly difficult to use a concept for any of the usage patterns
|
||||
there would be a good argument for choosing the other design. So we'll code all six usage
|
||||
patterns using both designs.</p>
|
||||
|
||||
<h3>1.</h3>
|
||||
|
||||
<pre>
|
||||
void foo()
|
||||
{
|
||||
thread thrd(&bar);
|
||||
}
|
||||
|
||||
void foo()
|
||||
{
|
||||
thread_ref thrd = create_thread(&bar);
|
||||
}
|
||||
</pre>
|
||||
|
||||
<h3>2.</h3>
|
||||
|
||||
<pre>
|
||||
void foo()
|
||||
{
|
||||
thread thrd(&bar);
|
||||
thrd.join();
|
||||
}
|
||||
|
||||
void foo()
|
||||
{
|
||||
thread_ref thrd =
|
||||
create_thread(&bar);thrd->join();
|
||||
}
|
||||
</pre>
|
||||
|
||||
<h3>3.</h3>
|
||||
|
||||
<pre>
|
||||
void foo()
|
||||
{
|
||||
for (int i=0; i<NUM_THREADS; ++i)
|
||||
thread thrd(&bar);
|
||||
}
|
||||
|
||||
void foo()
|
||||
{
|
||||
for (int i=0; i<NUM_THREADS; ++i)
|
||||
thread_ref thrd = create_thread(&bar);
|
||||
}
|
||||
</pre>
|
||||
|
||||
<h3>4.</h3>
|
||||
|
||||
<pre>
|
||||
void foo()
|
||||
{
|
||||
std::auto_ptr<thread> threads[NUM_THREADS];
|
||||
for (int i=0; i<NUM_THREADS; ++i)
|
||||
threads[i] = std::auto_ptr<thread>(new thread(&bar));
|
||||
for (int i= 0; i<NUM_THREADS;
|
||||
++i)threads[i]->join();
|
||||
}
|
||||
|
||||
void foo()
|
||||
{
|
||||
thread_ref threads[NUM_THREADS];
|
||||
for (int i=0; i<NUM_THREADS; ++i)
|
||||
threads[i] = create_thread(&bar);
|
||||
for (int i= 0; i<NUM_THREADS;
|
||||
++i)threads[i]->join();
|
||||
}
|
||||
</pre>
|
||||
|
||||
<h3>5.</h3>
|
||||
|
||||
<pre>
|
||||
void foo()
|
||||
{
|
||||
thread thrd* = new thread(&bar);
|
||||
manager.owns(thread);
|
||||
}
|
||||
|
||||
void foo()
|
||||
{
|
||||
thread_ref thrd = create_thread(&bar);
|
||||
manager.owns(thrd);
|
||||
}
|
||||
</pre>
|
||||
|
||||
<h3>6.</h3>
|
||||
|
||||
<pre>
|
||||
void foo()
|
||||
{
|
||||
boost::shared_ptr<thread> thrd(new thread(&bar));
|
||||
manager1.add(thrd);
|
||||
manager2.add(thrd);
|
||||
}
|
||||
|
||||
void foo()
|
||||
{
|
||||
thread_ref thrd = create_thread(&bar);
|
||||
manager1.add(thrd);
|
||||
manager2.add(thrd);
|
||||
}
|
||||
</pre>
|
||||
|
||||
<p>This shows the usage patterns being nearly identical in complexity for both designs.
|
||||
The only actual added complexity occurs because of the use of operator new in (4), (5)
|
||||
and (6) and the use of std::auto_ptr and boost::shared_ptr in (4) and (6) respectively.
|
||||
However, that's not really much added complexity, and C++ programmers are used to using
|
||||
these idioms any way. Some may dislike the presence of operator new in user code,
|
||||
but this can be eliminated by proper design of higher level concepts, such as the
|
||||
boost::thread_group class that simplifies example (4) down to:</p>
|
||||
|
||||
<pre>
|
||||
void foo()
|
||||
{
|
||||
thread_group threads;
|
||||
for (int i=0; i<NUM_THREADS; ++i)
|
||||
threads.create_thread(&bar);
|
||||
threads.join_all();
|
||||
}
|
||||
</pre>
|
||||
|
||||
<p>So ease of use is really a wash and not much help in picking a design.</p>
|
||||
|
||||
<p>So what about performance? If you look at the above code examples we can analyze
|
||||
the theoretical impact to performance that both designs have. For (1) we can see that
|
||||
platforms that don't have a ref-counted native thread type (POSIX, for instance) will
|
||||
be impacted by a thread_ref design. Even if the native thread type is ref-counted there
|
||||
may be an impact if more state information has to be maintained for concepts foreign
|
||||
to the native API, such as clean up stacks for Win32 implementations. For (2) the
|
||||
performance impact will be identical to (1). The same for (3). For (4) things get a
|
||||
little more interesting and we find that theoretically at least the thread_ref may
|
||||
perform faster since the thread design requires dynamic memory allocation/deallocation.
|
||||
However, in practice there may be dynamic allocation for the thread_ref design as well,
|
||||
it will just be hidden from the user. As long as the implementation has to do dynamic
|
||||
allocations the thread_ref loses again because of the reference management. For (5)
|
||||
we see the same impact as we do for (4). For (6) we still have a possible impact
|
||||
to the thread design because of dynamic allocation but thread_ref no longer suffers
|
||||
because of it's reference management, and in fact, theoretically at least, the thread_ref
|
||||
may do a better job of managing the references. All of this indicates that thread wins
|
||||
for (1), (2) and (3), with (4) and (5) the winner depends on the implementation and the platform
|
||||
but the thread design probably has a better chance, and with (6) it will again
|
||||
depend on the implementation and platform but this time we favor thread_ref slightly.
|
||||
Given all of this it's a narrow margin, but the thread design prevails.</p>
|
||||
|
||||
<p>Given this analysis, and the fact that noncopyable objects for system resources are
|
||||
the normal designs that C++ programmers are used to dealing with, the Boost.Threads
|
||||
library has gone with a noncopyable design.</p>
|
||||
|
||||
<h2>Rationale for not providing <i><a name="Events">Event</a> Variables</i></h2>
|
||||
|
||||
<p><i>Event variables </i>are simply far too error-prone. <a href="condition.html">Condition
|
||||
variables</a> are a much safer alternative.</p>
|
||||
|
||||
<p>[Note that Graphical User Interface <i>events</i> are a different concept,
|
||||
and are not what is being discussed here.]</p>
|
||||
|
||||
<p>Event variables were one of the first synchronization primitives. They are
|
||||
still used today, for example, in the native Windows multithreading API.</p>
|
||||
|
||||
<p>Yet both respected computer science researchers and experienced
|
||||
multithreading practitioners believe event variables are so inherently
|
||||
error-prone that they should never be used, and thus should not be part of a
|
||||
multithreading library.</p>
|
||||
|
||||
<p>Per Brinch Hansen <a href="bibliography.html#Brinch-Hansen-73">[Brinch Hansen
|
||||
73]</a> analyzed event variables in some detail, pointing out [emphasis his]
|
||||
that "<i>event operations force the programmer to be aware of the relative
|
||||
speeds of the sending and receiving processes</i>". His summary:</p>
|
||||
|
||||
<blockquote>
|
||||
<p>We must therefore conclude that event variables of the previous type are
|
||||
impractical for system design. <i>The effect of an interaction between two
|
||||
processes must be independent of the speed at which it is carried out.</i></p>
|
||||
|
||||
</blockquote>
|
||||
<p>Experienced programmers using the Windows platform today
|
||||
report that event variables are a continuing source of errors, even after previous
|
||||
bad experiences caused them to be very careful in their use of event
|
||||
variables. Overt problems can be avoided, for example, by teaming the
|
||||
event variable with a mutex, but that may just convert a <a href="definitions.html#Race condition">race
|
||||
condition</a> into another problem, such as excessive resource use. One of the most
|
||||
distressing aspects of the experience reports is the claim that many defects are
|
||||
latent. That is, the programs appear to work correctly, but contain
|
||||
hidden timing dependencies which will cause them to fail when environmental
|
||||
factors or usage patterns change, altering relative thread timings.</p>
|
||||
|
||||
<p>The decision to exclude event variables from Boost.Threads has been
|
||||
surprising to some Windows programmers. They have written programs which
|
||||
work using event variables, and wonder what the problem is. It seems
|
||||
similar to the "goto considered harmful" controversy of 30 years ago.
|
||||
It isn't that events, like gotos, can't be made to work, but rather that
|
||||
virtually all programs using alternatives will be easier to write, debug,
|
||||
read, maintain, and be less likely to contain latent defects.</p>
|
||||
|
||||
<p>[Rationale provided by Beman Dawes]</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->01 October, 2001<!--webbot bot="Timestamp" endspan i-checksum="38291" -->
|
||||
</p>
|
||||
|
||||
<p><i>© Copyright <A href="mailto:williamkempf@hotmail.com">William E. Kempf</A>
|
||||
2001 all rights reserved.</i></p>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
327
doc/recursive_mutex.html
Normal file
327
doc/recursive_mutex.html
Normal file
@@ -0,0 +1,327 @@
|
||||
<html>
|
||||
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
|
||||
<meta name="keywords" content="threads, BTL, thread library, C++">
|
||||
<link rel="stylesheet" type="text/css" href="styles.css">
|
||||
<title>Boost.Threads, recursive_mutex</title>
|
||||
</head>
|
||||
|
||||
<body bgcolor="#FFFFFF" link="#0000FF" vlink="#800080">
|
||||
|
||||
<table border="0" cellpadding="7" cellspacing="0" width="100%">
|
||||
<tr>
|
||||
<td valign="top" width="300">
|
||||
<h3><img src="../../../c++boost.gif" alt="C++ Boost" width="277" height="86"></h3>
|
||||
</td>
|
||||
<td valign="top">
|
||||
<h1 align="center">Boost.Threads</h1>
|
||||
<h2 align="center">recursive_mutex<br>
|
||||
recursive_try_mutex<br>
|
||||
recursive_timed_mutex</h2>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<hr>
|
||||
|
||||
<p><a href="#Introduction">Introduction</a><br>
|
||||
<a href="#Header">Header</a><br>
|
||||
<a href="#recursive_mutex Synopsis">Class recursive_mutex Synopsis</a><br>
|
||||
<a href="#recursive_mutex Members">Class recursive_mutex Members</a><br>
|
||||
<a href="#recursive_try_mutex Synopsis">Class recursive_try_mutex Synopsis</a><br>
|
||||
<a href="#recursive_try_mutex Members">Class recursive_try_mutex Members</a><br>
|
||||
<a href="#recursive_timed_mutex Synopsis">Class recursive_timed_mutex Synopsis</a><br>
|
||||
<a href="#recursive_timed_mutex Members">Class recursive_timed_mutex Members</a><br>
|
||||
<a href="#Example">Example</a></p>
|
||||
|
||||
<h2><a name="Introduction">Introduction</a></h2>
|
||||
|
||||
<p>The <code>recursive_mutex</code>, <code>recursive_try_mutex</code> and
|
||||
<code>recursive_timed_mutex</code> classes define full featured models of the
|
||||
<a href="mutex_concept.html#Mutex">Mutex</a>,
|
||||
<a href="mutex_concept.html#TryMutex">TryMutex</a> and
|
||||
<a href="mutex_concept.html#TimedMutex">TimedMutex</a> concepts with recursive locking
|
||||
semantics. These types should be used to synchronize access to shared resources
|
||||
when recursive locking by a single thread is likely to occur. A good example for this
|
||||
is when a class supplies "internal synchronization" to ensure
|
||||
<a href="definitions.html#Thread-safe">thread-safety</a> and a function of the class
|
||||
may have to call other functions of the class which also attempt to lock the mutex.
|
||||
For recursive locking mechanics, see <a href="mutex.html">mutexes</a>.
|
||||
|
||||
<p>Each class supplies one or more typedefs for lock types which model matching
|
||||
lock concepts. For the best possible performance you should use the mutex class that
|
||||
supports the minimum set of lock types that you need.</p>
|
||||
|
||||
<table border="1" cellpadding="5">
|
||||
<tr>
|
||||
<td><b>Mutex Class</b></td>
|
||||
<td><b>Lock name</b></td>
|
||||
<td><b>Implementation defined Lock Type</b></td>
|
||||
<td><b>Lock Concept</b></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top"><a href="#recursive_mutex Synopsis"><code>recursive_mutex</code></a></td>
|
||||
<td valign="middle"><code>scoped_lock</code></td>
|
||||
<td valign="middle"><a href="scoped_lock.html"><code>detail::thread::scoped_lock<recursive_mutex></code></a></td>
|
||||
<td valign="middle"><a href="lock_concept.html#ScopedLock">ScopedLock</a></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top"><code><a href="#recursive_try_mutex Synopsis">recursive_try_mutex</a></code></td>
|
||||
<td valign="middle"><code>scoped_lock<br>
|
||||
scoped_try_lock</code></td>
|
||||
<td valign="middle"><a href="scoped_lock.html"><code>detail::thread::scoped_lock<recursive_try_mutex><br>
|
||||
</code></a><code><a href="scoped_try_lock.html">detail::thread::scoped_try_lock<recursive_try_mutex></a></code></td>
|
||||
<td valign="middle"><a href="lock_concept.html#ScopedLock">ScopedLock</a><br>
|
||||
<a href="lock_concept.html#ScopedTryLock">ScopedTryLock</a></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top"><code><a href="#recursive_timed_mutex Synopsis">recursive_timed_mutex</a></code> </td>
|
||||
<td valign="middle"><code>scoped_lock<br>
|
||||
scoped_try_lock<br>
|
||||
scoped_timed_lock</code></td>
|
||||
<td valign="middle"><a href="scoped_lock.html"><code>detail::thread::scoped_lock<recursive_timed_mutex></code></a><br>
|
||||
<a href="scoped_try_lock.html"><code>detail::thread::scoped_try_lock<recursive_timed_mutex></code></a><br>
|
||||
<a href="scoped_timed_lock.html"><code>detail::thread::scoped_timed_lock<recursive_timed_mutex></code></a></td>
|
||||
<td valign="middle"><a href="lock_concept.html#ScopedLock">ScopedLock</a><br>
|
||||
<a href="lock_concept.html#ScopedTryLock">ScopedTryLock</a><br>
|
||||
<a href="lock_concept.html#ScopedTimedLock">ScopedTimedLock</a></td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<p>The <code>recursive_mutex</code>, <code>recursive_try_mutex</code> and
|
||||
<code>recursive_timed_mutex</code> employ a <code>Recursive</code>
|
||||
<a href="mutex_concept.html#LockingStrategies">locking strategy</a>, so attempts to
|
||||
recursively lock them succeed and an internal "lock count" is maintained. Attempts
|
||||
to unlock them by a thread that does not own a lock on them will result in a
|
||||
<a href="lock_error.html">lock_error</a> exception being thrown.</p>
|
||||
|
||||
<p>The <code>recursive_mutex</code>, <code>recursive_try_mutex</code> and
|
||||
<code>recursive_timed_mutex</code> leave the
|
||||
<a href="mutex_concept.html#SchedulingPolicies">scheduling policy</a> as
|
||||
<code>Unspecified</code>. Programmers should assume that threads waiting for a lock on
|
||||
objects of these types acquire the lock in a random order, even though the specific
|
||||
behavior for a given platform may be different.</p>
|
||||
|
||||
<h2><a name="Header">Header</a></h2>
|
||||
|
||||
<pre>
|
||||
#include <a href="../../../boost/thread/recursive_mutex.hpp"><boost/thread/recursive_mutex.hpp></a>
|
||||
</pre>
|
||||
|
||||
<h2>Class <a name="recursive_mutex Synopsis"> recursive_mutex Synopsis</a></h2>
|
||||
|
||||
<hr>
|
||||
|
||||
<pre>
|
||||
namespace boost
|
||||
{
|
||||
class recursive_mutex : private <a href="../../utility/utility.htm">boost::noncopyable</a> // Exposition only.
|
||||
// Class recursive_mutex meets the <a href="overview.html#NonCopyable">NonCopyable</a> requirement.
|
||||
{
|
||||
public:
|
||||
typedef <i>[implementation defined; see <a href="#Introduction">Introduction</a>]</i> scoped_lock;
|
||||
|
||||
recursive_mutex();
|
||||
~recursive_mutex();
|
||||
};
|
||||
}
|
||||
</pre>
|
||||
|
||||
<h2>Class <a name="recursive_mutex Members">recursive_mutex Members</a></h2>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>Constructor</h3>
|
||||
|
||||
<pre>
|
||||
recursive_mutex();
|
||||
</pre>
|
||||
|
||||
<p><b>Postconditions: </b><code>*this</code> is in the unlocked state.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>Destructor</h3>
|
||||
|
||||
<pre>
|
||||
~recursive_mutex();
|
||||
</pre>
|
||||
|
||||
<p><b>Requires:</b> <code>*this</code> is in the unlocked state.</p>
|
||||
|
||||
<p><b>Effects:</b> Destroys <code>*this</code>.</p>
|
||||
|
||||
<p><b>Dangers:</b> Destruction of a locked mutex is a serious programming error
|
||||
resulting in undefined behavior such as a program crash..</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h2>
|
||||
Class <a name="recursive_try_mutex Synopsis">recursive_try_mutex Synopsis</a>
|
||||
</h2>
|
||||
|
||||
<pre>
|
||||
namespace boost
|
||||
{
|
||||
class recursive_try_mutex : private boost::noncopyable // Exposition only.
|
||||
// Class recursive_try_mutex meets the <a href="overview.html#NonCopyable">NonCopyable</a> requirement.
|
||||
{
|
||||
public:
|
||||
typedef <i>[implementation defined; see <a href="#Introduction">Introduction</a>]</i> scoped_lock;
|
||||
typedef <i>[implementation defined; see <a href="#Introduction">Introduction</a>]</i> scoped_try_lock;
|
||||
|
||||
recursive_try_mutex();
|
||||
~recursive_try_mutex();
|
||||
};
|
||||
}
|
||||
</pre>
|
||||
|
||||
<h2>Class <a name="recursive_try_mutex Members">recursive_try_mutex Members</a></h2>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>Constructor</h3>
|
||||
|
||||
<pre>
|
||||
recursive_try_mutex();
|
||||
</pre>
|
||||
|
||||
<p><b>Postconditions: </b><code>*this</code> is in the unlocked state.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>Destructor</h3>
|
||||
|
||||
<pre>
|
||||
~recursive_try_mutex();
|
||||
</pre>
|
||||
|
||||
<p><b>Requires:</b> <code>*this</code> is in the unlocked state.</p>
|
||||
|
||||
<p><b>Effects:</b> Destroys <code>*this</code>.</p>
|
||||
|
||||
<p><b>Dangers:</b> Destruction of a locked mutex is a serious programming error
|
||||
resulting in undefined behavior such as a program crash..</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h2>
|
||||
Class <a name="recursive_timed_mutex Synopsis">recursive_timed_mutex Synopsis</a>
|
||||
</h2>
|
||||
|
||||
<pre>
|
||||
namespace boost
|
||||
{
|
||||
class recursive_timed_mutex : private boost::noncopyable // Exposition only.
|
||||
// Class recursive_timed_mutex meets the <a href="overview.html#NonCopyable">NonCopyable</a> requirement.
|
||||
{
|
||||
public:
|
||||
typedef <i>[implementation defined; see <a href="#Introduction">Introduction</a>]</i> scoped_lock;
|
||||
typedef <i>[implementation defined; see <a href="#Introduction">Introduction</a>]</i> scoped_try_lock;
|
||||
typedef <i>[implementation defined; see <a href="#Introduction">Introduction</a>]</i> scoped_timed_lock;
|
||||
|
||||
recursive_timed_mutex();
|
||||
~recursive_timed_mutex();
|
||||
};
|
||||
}
|
||||
</pre>
|
||||
|
||||
<h2>
|
||||
Class <a name="recursive_timed_mutex Members">recursive_timed_mutex Members</a>
|
||||
</h2>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>Constructor</h3>
|
||||
|
||||
<pre>
|
||||
recursive_timed_mutex();
|
||||
</pre>
|
||||
|
||||
<p><b>Postconditions: </b><code>*this</code> is in the unlocked state.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>Destructor</h3>
|
||||
|
||||
<pre>
|
||||
~recursive_timed_mutex();
|
||||
</pre>
|
||||
|
||||
<p><b>Requires:</b> <code>*this</code> is in the unlocked state.</p>
|
||||
|
||||
<p><b>Effects:</b> Destroys <code>*this</code>.</p>
|
||||
|
||||
<p><b>Dangers:</b> Destruction of a locked mutex is a serious programming error
|
||||
resulting in undefined behavior such as a program crash..</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h2><a name="Example">Example</a> Usage</h2>
|
||||
|
||||
<pre>
|
||||
#include <a href="../../../boost/thread/recursive_mutex.hpp"><boost/thread/recursive_mutex.hpp></a>
|
||||
#include <a href="../../../boost/thread/thread.hpp"><boost/thread/thread.hpp></a>
|
||||
#include <iostream>
|
||||
|
||||
class counter
|
||||
{
|
||||
public:
|
||||
counter() : count(0) { }
|
||||
|
||||
int add(int val) {
|
||||
boost::recursive_mutex::scoped_lock scoped_lock(mutex);
|
||||
count += val;
|
||||
return count;
|
||||
}
|
||||
int increment() {
|
||||
boost::recursive_mutex::scoped_lock scoped_lock(mutex);
|
||||
return add(1);
|
||||
}
|
||||
|
||||
private:
|
||||
boost::recursive_mutex mutex;
|
||||
int count;
|
||||
};
|
||||
|
||||
counter c;
|
||||
|
||||
void change_count(void*)
|
||||
{
|
||||
std::cout << "count == " << c.increment() << std::endl;
|
||||
}
|
||||
|
||||
int main(int, char*[])
|
||||
{
|
||||
const int num_threads=4;
|
||||
|
||||
boost::thread_group threads;
|
||||
for (int i=0; i < num_threads; ++i)
|
||||
threads.create_thread(&change_count, 0);
|
||||
|
||||
threads.join_all();
|
||||
|
||||
return 0;
|
||||
}
|
||||
</pre>
|
||||
|
||||
<p>The output is:</p>
|
||||
|
||||
<pre>
|
||||
count == 1
|
||||
count == 2
|
||||
count == 3
|
||||
count == 4
|
||||
</pre>
|
||||
|
||||
<hr>
|
||||
|
||||
<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->01 October, 2001<!--webbot bot="Timestamp" endspan i-checksum="38291" -->
|
||||
</p>
|
||||
|
||||
<p><i>© Copyright <a href="mailto:williamkempf@hotmail.com">William E. Kempf</a>
|
||||
2001 all rights reserved.</i></p>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
134
doc/removed_atomic_t.html
Normal file
134
doc/removed_atomic_t.html
Normal file
@@ -0,0 +1,134 @@
|
||||
<html>
|
||||
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
|
||||
<meta name="keywords" content="threads, BTL, thread library, C++">
|
||||
<title>Boost.Threads, atomic_t</title>
|
||||
</head>
|
||||
|
||||
<body bgcolor="#FFFFFF" link="#0000FF" vlink="#800080">
|
||||
|
||||
<table border="0" cellpadding="7" cellspacing="0" width="100%">
|
||||
<tr>
|
||||
<td valign="top" width="300">
|
||||
<h3><img src="../../../c++boost.gif" alt="C++ Boost" width="277" height="86"></h3>
|
||||
</td>
|
||||
<td valign="top">
|
||||
<h1 align="center">Boost.Threads</h1>
|
||||
<h2 align="center">atomic_t</h2>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<hr>
|
||||
|
||||
<h2>Header</h2>
|
||||
|
||||
<p>The <tt>atomic_t</tt> class defines an "atomic integer" type. This class should be used
|
||||
to perform thread safe operations on an integral type with out the overhead of locks. Only
|
||||
a limited set of integer operations are available with an <tt>atomic_t</tt> instance.</p>
|
||||
|
||||
<pre>
|
||||
#include <boost/thread/atomic.hpp>
|
||||
</pre>
|
||||
|
||||
<h2>Public Interface</h2>
|
||||
|
||||
<pre>
|
||||
class atomic_t
|
||||
{
|
||||
public:
|
||||
typedef <b>implementation defined</b> value_type;
|
||||
|
||||
explicit atomic_t(value_type val=0);
|
||||
};
|
||||
|
||||
atomic_t::value_type read(const atomic_t& x);
|
||||
atomic_t::value_type increment(atomic_t& x);
|
||||
atomic_t::value_type decrement(atomic_t& x);
|
||||
atomic_t::value_type swap(atomic_t& x, atomic_t::value_type y);
|
||||
atomic_t::value_type compare_swap(atomic_t& x, atomic_t::value_type y, atomic_t::value_type z);
|
||||
</pre>
|
||||
|
||||
<h3>Constructor</h3>
|
||||
|
||||
<pre>
|
||||
atomic_t(atomic_t::value_type val=0);
|
||||
</pre>
|
||||
|
||||
<p>Constructs an <tt>atomic_t</tt> and sets its value to <tt>val</tt>.</p>
|
||||
|
||||
<h3>read</h3>
|
||||
|
||||
<pre>
|
||||
atomic_t::value_type read(const atomic_t& x);
|
||||
</pre>
|
||||
|
||||
<p>Gets the current value of <tt>x</tt>.</p>
|
||||
|
||||
<h3>increment</h3>
|
||||
|
||||
<pre>
|
||||
atomic_t::value_type increment(atomic_t& x);
|
||||
</pre>
|
||||
|
||||
<p>Increments <tt>x</tt> and returns a value <tt>< 0</tt> if the result is less than 0,
|
||||
<tt>> 0</tt> if the result is greater than 0 and <tt>== 0</tt> if the result is equal to
|
||||
0.</p>
|
||||
|
||||
<h3>decrement</h3>
|
||||
|
||||
<pre>
|
||||
atomic_t::value_type decrement(atomic_t& x);
|
||||
</pre>
|
||||
|
||||
<p>Decrements <tt>x</tt> and returns a value <tt>< 0</tt> if the result is less than 0,
|
||||
<tt>> 0</tt> if the result is greater than 0 and <tt>== 0</tt> if the result is equal to
|
||||
0.</p>
|
||||
|
||||
<h3>swap</h3>
|
||||
|
||||
<pre>
|
||||
atomic_t::value_type swap(atomic_t& x, atomic_t::value_type y);
|
||||
</pre>
|
||||
|
||||
<p>Assigns the value of <tt>y</tt> to <tt>x</tt> and returns the value of <tt>x</tt> prior
|
||||
to the swap.</p>
|
||||
|
||||
<h3>compare_swap</h3>
|
||||
|
||||
<pre>
|
||||
atomic_t::value_type compare_swap(atomic_t& x, atomic_t::value_type y, atomic_t::value_type z);
|
||||
</pre>
|
||||
|
||||
<p>Compares the value of <tt>z</tt> to the value of <tt>x</tt> and if equal sets the value of
|
||||
<tt>x</tt> to the value of <tt>y</tt> and returns the value of <tt>x</tt> prior to the swap.</p>
|
||||
|
||||
<h2>Example Usage</h2>
|
||||
|
||||
<pre>
|
||||
#include <boost/thread/atomic.hpp>
|
||||
#include <boost/test/test_tools.hpp>
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
boost::atomic_t a;
|
||||
BOOST_TEST_VERIFY(boost::read(a) == 0);
|
||||
BOOST_TEST_VERIFY(boost::increment(a) > 0);
|
||||
BOOST_TEST_VERIFY(boost::decrement(a) == 0);
|
||||
BOOST_TEST_VERIFY(boost::swap(a, 1) == 0);
|
||||
BOOST_TEST_VERIFY(boost::swap(a, 2, 0) == 1);
|
||||
BOOST_TEST_VERIFY(boost::read(a) == 1);
|
||||
}
|
||||
</pre>
|
||||
|
||||
<hr>
|
||||
|
||||
<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->01 October, 2001<!--webbot bot="Timestamp" endspan i-checksum="38291" -->
|
||||
</p>
|
||||
|
||||
<p><i>© Copyright <a href="mailto:williamkempf@hotmail.com">William E. Kempf</a>
|
||||
2001 all rights reserved.</i></p>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
213
doc/scoped_lock.html
Normal file
213
doc/scoped_lock.html
Normal file
@@ -0,0 +1,213 @@
|
||||
<html>
|
||||
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
|
||||
<meta name="keywords" content="threads, BTL, thread library, C++">
|
||||
<link rel="stylesheet" type="text/css" href="styles.css">
|
||||
<title>Boost.Threads, scoped_lock</title>
|
||||
</head>
|
||||
|
||||
<body bgcolor="#FFFFFF" link="#0000FF" vlink="#800080">
|
||||
|
||||
<table border="0" cellpadding="7" cellspacing="0" width="100%">
|
||||
<tr>
|
||||
<td valign="top" width="300">
|
||||
<h3><img src="../../../c++boost.gif" alt="C++ Boost" width="277" height="86"></h3>
|
||||
</td>
|
||||
<td valign="top">
|
||||
<h1 align="center">Boost.Threads</h1>
|
||||
<h2 align="center">scoped_lock</h2>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<hr>
|
||||
|
||||
<p><a href="#Introduction">Introduction</a><br>
|
||||
<a href="#Header">Header</a><br>
|
||||
<a href="#Synopsis">Synopsis</a><br>
|
||||
<a href="#Members">Members</a><br>
|
||||
<a href="#Example">Example</a></p>
|
||||
|
||||
<h2><a name="Introduction">Introduction</a></h2>
|
||||
|
||||
<p>This class template defines a generic lock type which meets the
|
||||
<a href="lock_concept.html#ScopedLock">ScopedLock</a> requirements. The
|
||||
<a href="mutex.html">mutex</a>, <a href="mutex.html">try_mutex</a>,
|
||||
<a href="mutex.html">timed_mutex</a>, <a href="recursive_mutex.html">recursive_mutex</a>,
|
||||
<a href="recursive_mutex.html">recursive_try_mutex</a> and
|
||||
<a href="recursive_mutex.html">recursive_timed_mutex</a> classes all use this template
|
||||
to define their <code>scoped_lock</code> types.</p>
|
||||
|
||||
<p>Like all the <b>Boost.Threads</b> <a href="lock_concept.html">lock models</a>,
|
||||
<code>scoped_lock</code> objects are meant to be short-lived. Objects of the class
|
||||
are not <a href="definitions.html#thread-safe">thread-safe</a>, and so should not be
|
||||
shared between threads.</p>
|
||||
|
||||
<p>Class <code> scoped_lock</code> follows the "resource acquisition is
|
||||
initialization" idiom <a href="bibliography.html#Stroustrup-00">[Stroustrup
|
||||
00 14.4.1]</a> and is a realization of the "Scoped Locking Pattern"
|
||||
<a href="bibliography.html#Schmidt-00">[Schmidt-00]</a>. Thus the usage is to let the
|
||||
constructor do the locking, and then let the destructor do the unlocking automatically at
|
||||
the end of the enclosing scope. The lock() and unlock() members are usually not
|
||||
explicitly called, but are provided to allow for complex overlapping locks of multiple
|
||||
mutexes.</p>
|
||||
|
||||
<p>The type used to instantiate the class must meet the
|
||||
<a href="mutex_concept.html#Mutex">Mutex</a> requirements.</p>
|
||||
|
||||
<p>Although this class is an implementation detail, it is publicly documented here because
|
||||
of its importance.</p>
|
||||
|
||||
<h2><a name="Header">Header</a></h2>
|
||||
|
||||
<pre>
|
||||
#include <a href="../../../boost/thread/detail/lock.hpp"><boost/thread/detail/lock.hpp></a>
|
||||
<i>This header is usually not included directly by programmers
|
||||
because it is supplied by <a href="../../../boost/thread/mutex.hpp"><boost/thread/mutex.hpp></a> or
|
||||
<a href="../../../boost/thread/recursive_mutex.hpp"><boost/thread/recursive_mutex.hpp></a></i>
|
||||
</pre>
|
||||
|
||||
<h2><a name="Synopsis">Synopsis</a></h2>
|
||||
|
||||
<pre>
|
||||
namespace boost { namespace detail { namespace thread {
|
||||
template <typename Mutex>
|
||||
class scoped_lock : private <a href="../../utility/utility.htm#Class noncopyable">boost::noncopyable</a> // Exposition only.
|
||||
// Class scoped_lock meets the <a href="overview.html#NonCopyable">NonCopyable</a> requirement.
|
||||
{
|
||||
public:
|
||||
typedef Mutex mutex_type;
|
||||
|
||||
explicit scoped_lock(Mutex& mx, bool initially_locked=true);
|
||||
~scoped_lock();
|
||||
|
||||
void lock();
|
||||
void unlock();
|
||||
|
||||
operator const void*() const;
|
||||
bool locked() const;
|
||||
};
|
||||
} // namespace thread
|
||||
} // namespace detail
|
||||
} // namespace boost
|
||||
</pre>
|
||||
|
||||
<h2><a name="Members">Members</a></h2>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>Constructor</h3>
|
||||
|
||||
<pre>
|
||||
explicit scoped_lock(Mutex& mx, bool initially_locked=true);
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> Associates mutex <code>mx</code> with <code>*this</code>.
|
||||
If <code>initially_locked</code> is <code>true,</code> calls <code>lock()</code>.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>Destructor</h3>
|
||||
|
||||
<pre>
|
||||
~scoped_lock();
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> If <code> locked()</code>, calls <code>unlock()</code>. Destroys
|
||||
<code>*this</code>.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>lock</h3>
|
||||
|
||||
<pre>
|
||||
void lock();
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> If the associated mutex is already locked by another lock in the
|
||||
current thread, the effects depend on the locking strategy of the associated mutex, as
|
||||
shown in the following table:</p>
|
||||
|
||||
<table border="1" cellpadding="5">
|
||||
<tr>
|
||||
<td><i><a href="mutex_concept.html#LockingStrategies">Locking Strategy</a><br>
|
||||
of associated mutex</i></td>
|
||||
<td><i>Effect if associated mutex is already locked by the current thread</i></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>Recursive</td>
|
||||
<td>As if an additional lock were added to the mutex.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>Checked</td>
|
||||
<td>Throws <a href="lock_error.html">lock_error</a>.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>Unchecked</td>
|
||||
<td>Undefined behavior [<a href="bibliography.html#ISO">ISO</a> 1.3.12] (but
|
||||
typically, <a href="definitions.html#Deadlock">deadlock</a>.)</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<p>If the associated mutex is already locked by some other thread, places the
|
||||
current thread in the <a href="definitions.html#State">Blocked</a> state until
|
||||
the associated mutex is unlocked, after which the current thread is placed in
|
||||
the <a href="definitions.html#State">Ready</a> state, eventually to be returned
|
||||
to the <a href="definitions.html#State">Running</a> state.
|
||||
|
||||
<p><b>Postcondition:</b> locked()
|
||||
|
||||
<p><b>Throws:</b> <a href="lock_error.html">lock_error</a> if <code>locked()</code> or
|
||||
as indicated in <b>Effects</b>.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>unlock</h3>
|
||||
|
||||
<pre>
|
||||
void unlock();
|
||||
</pre>
|
||||
|
||||
<p><b>Effects: </b>Unlocks the associated mutex.</p>
|
||||
|
||||
<p><b>Throws:</b> <a href="lock_error.html">lock_error</a> if <code>!locked()</code>.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>const void* Conversion</h3>
|
||||
|
||||
<pre>
|
||||
operator const void*() const;
|
||||
</pre>
|
||||
|
||||
<p><b>Returns:</b> If the associated mutex is currently locked, a value convertible to
|
||||
<code>true</code>, else a value convertible to <code>false</code>.</p>
|
||||
|
||||
<p><b>Rationale:</b> A <code>const void*</code> conversion is considered safer than a
|
||||
conversion to <code>bool</code>.</p>
|
||||
|
||||
<hr>
|
||||
<h3>locked</h3>
|
||||
<pre>
|
||||
bool locked() const;
|
||||
</pre>
|
||||
<p><b>Returns:</b> <code>this->operator const void*() != 0</code>.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h2><a name="Example">Example</a> Usage</h2>
|
||||
|
||||
<p>See the example given in the documentation for the <a href="mutex.html">mutex</a>
|
||||
class.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->01 October, 2001<!--webbot bot="Timestamp" endspan i-checksum="38291" -->
|
||||
</p>
|
||||
|
||||
<p><i>© Copyright <a href="mailto:williamkempf@hotmail.com">William E. Kempf</a>
|
||||
2001 all rights reserved.</i></p>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
261
doc/scoped_timed_lock.html
Normal file
261
doc/scoped_timed_lock.html
Normal file
@@ -0,0 +1,261 @@
|
||||
<html>
|
||||
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
|
||||
<meta name="keywords" content="threads, BTL, thread library, C++">
|
||||
<link rel="stylesheet" type="text/css" href="styles.css">
|
||||
<title>Boost.Threads, scoped_timed_lock</title>
|
||||
</head>
|
||||
|
||||
<body bgcolor="#FFFFFF" link="#0000FF" vlink="#800080">
|
||||
|
||||
<table border="0" cellpadding="7" cellspacing="0" width="100%">
|
||||
<tr>
|
||||
<td valign="top" width="300">
|
||||
<h3><img src="../../../c++boost.gif" alt="C++ Boost" width="277" height="86"></h3>
|
||||
</td>
|
||||
<td valign="top">
|
||||
<h1 align="center">Boost.Threads</h1>
|
||||
<h2 align="center">scoped_timed_lock</h2>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<hr>
|
||||
|
||||
<p><a href="#Introduction">Introduction</a><br>
|
||||
<a href="#Header">Header</a><br>
|
||||
<a href="#Synopsis">Synopsis</a><br>
|
||||
<a href="#Members">Members</a><br>
|
||||
<a href="#Example">Example</a></p>
|
||||
|
||||
<h2><a name="Introduction">Introduction</a></h2>
|
||||
|
||||
<p>This class template defines a generic lock type which meets the
|
||||
<a href="lock_concept.html#ScopedTimedLock">ScopedTimedLock</a> requirements. The
|
||||
<a href="mutex.html">timed_mutex</a> and
|
||||
<a href="recursive_mutex.html">recursive_timed_mutex</a> classes use this template to
|
||||
define their <code>scoped_timed_lock</code> types.</p>
|
||||
|
||||
<p>Like all the <b>Boost.Threads</b> <a href="lock_concept.html">lock models</a>,
|
||||
<code>scoped_timed_lock</code> objects are meant to be short-lived. Objects of the
|
||||
class are not <a href="definitions.html#thread-safe">thread-safe</a>, and so should
|
||||
not be shared between threads.</p>
|
||||
|
||||
<p>Class <code>scoped_timed_lock</code> follows the "resource acquisition is
|
||||
initialization" idiom <a href="bibliography.html#Stroustrup-00">[Stroustrup
|
||||
00 14.4.1]</a> and is a realization of the "Scoped Locking Pattern"
|
||||
<a href="bibliography.html#Schmidt-00">[Schmidt-00]</a>. Thus the usage is to let the
|
||||
constructor do the locking, and then let the destructor do the unlocking automatically
|
||||
at the end of the enclosing scope. The lock() and unlock() members are usually not
|
||||
explicitly called, but are provided to allow for complex overlapping locks of multiple
|
||||
mutexes.</p>
|
||||
|
||||
<p>The type used to instantiate the class must meet the
|
||||
<a href="mutex_concept.html#TimedMutex">TimedMutex</a> requirements.</p>
|
||||
|
||||
<p>Although this class is an implementation detail, it is publicly documented here because
|
||||
of its importance.</p>
|
||||
|
||||
<h2><a name="Header">Header</a></h2>
|
||||
|
||||
<pre>
|
||||
#include <a href="../../../boost/thread/detail/lock.hpp"><boost/thread/detail/lock.hpp></a>
|
||||
<i>This header is usually not included directly by programmers
|
||||
because it is supplied by <a href="../../../boost/thread/mutex.hpp"><boost/thread/mutex.hpp></a> or
|
||||
<a href="../../../boost/thread/recursive_mutex.hpp"><boost/thread/recursive_mutex.hpp></a></i>
|
||||
</pre>
|
||||
|
||||
<h2><a name="Synopsis">Synopsis</a></h2>
|
||||
|
||||
<pre>
|
||||
namespace boost { namespace detail { namespace thread {
|
||||
template <typename TimedMutex>
|
||||
class scoped_timed_lock : private <a href="../../utility/utility.htm#Class noncopyable">boost::noncopyable</a> // Exposition only.
|
||||
// Class scoped_timed_lock meets the <a href="overview.html#NonCopyable">NonCopyable</a> requirement.
|
||||
{
|
||||
public:
|
||||
typedef TimedMutex mutex_type;
|
||||
|
||||
scoped_timed_lock(TimedMutex& mx, const boost::xtime& xt);
|
||||
scoped_timed_lock(TimedMutex& mx, bool initially_locked);
|
||||
~scoped_timed_lock();
|
||||
|
||||
void lock();
|
||||
bool timed_lock(const xtime& xt);
|
||||
void unlock();
|
||||
|
||||
operator const void*() const;
|
||||
};
|
||||
} // namespace thread
|
||||
} // namesapce detail
|
||||
} // namespace boost
|
||||
</pre>
|
||||
|
||||
<h2><a name="Members">Members</a></h2>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>Constructor</h3>
|
||||
|
||||
<pre>
|
||||
scoped_timed_lock(TimedMutex& mx, const <a href="xtime.html">xtime</a>& xt);
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> Associates mutex <code>mx</code> with <code>*this</code>.
|
||||
Calls <code>timed_lock</code>( <code>xt</code>)</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<pre>
|
||||
scoped_timed_lock(TimedMutex& mx, bool initially_locked);
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> Associates mutex <code>mx</code> with <code>*this</code>.
|
||||
If <code>initially_locked</code> is <code>true</code>, calls <code>lock()</code>.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>Destructor</h3>
|
||||
|
||||
<pre>
|
||||
~scoped_timed_lock();
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> If <code> locked()</code>, calls <code>unlock()</code>. Destroys
|
||||
<code>*this</code>.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>lock</h3>
|
||||
|
||||
<pre>
|
||||
void lock();
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> If the associated mutex is already locked by another lock in the
|
||||
current thread, the effects depend on the locking strategy of the associated mutex, as
|
||||
shown in the following table:</p>
|
||||
|
||||
<table border="1" cellpadding="5">
|
||||
<tr>
|
||||
<td><i><a href="mutex_concept.html#LockingStrategies">Locking Strategy</a><br>
|
||||
of associated mutex</i></td>
|
||||
<td><i>Effect if associated mutex is already locked by the current thread</i></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>Recursive</td>
|
||||
<td>As if an additional lock were added to the mutex.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>Checked</td>
|
||||
<td>Throws <a href="lock_error.html">lock_error</a>.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>Unchecked</td>
|
||||
<td>Undefined behavior [<a href="bibliography.html#ISO">ISO</a> 1.3.12] (but
|
||||
typically, <a href="definitions.html#Deadlock">deadlock</a>.)</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<p>If the associated mutex is already locked by some other thread, places the
|
||||
current thread in the <a href="definitions.html#State">Blocked</a> state until
|
||||
the associated mutex is unlocked, after which the current thread is placed in
|
||||
the <a href="definitions.html#State">Ready</a> state, eventually to be returned
|
||||
to the <a href="definitions.html#State">Running</a> state. Places the associated
|
||||
mutex in the locked state.
|
||||
|
||||
<p><b>Throws:</b> <a href="lock_error.html">lock_error</a> if <code>locked()</code> or
|
||||
as indicated in <b>Effects</b>.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>timed_lock</h3>
|
||||
|
||||
<pre>
|
||||
bool timed_lock(const <a href="xtime.html">xtime</a>& xt);
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> Same as <code>lock()</code>, except that if xt is reached,
|
||||
places the current thread in the <a href="definitions.html#State">Ready</a>
|
||||
state without further ado.</p>
|
||||
|
||||
<p><b>Returns:</b> <code>locked()</code>.</p>
|
||||
|
||||
<p><b>Throws:</b> <a href="lock_error.html">lock_error</a> if <code>locked()</code> or
|
||||
as indicated in <b>Effects</b>.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>unlock</h3>
|
||||
|
||||
<pre>
|
||||
void unlock();
|
||||
</pre>
|
||||
|
||||
<p><b>Effects: </b>Unlocks the associated mutex.</p>
|
||||
|
||||
<p><b>Throws:</b> <a href="lock_error.html">lock_error</a> if <code>!locked()</code>.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>const void* Conversion</h3>
|
||||
|
||||
<pre>
|
||||
operator const void*() const;
|
||||
</pre>
|
||||
|
||||
<p><b>Returns:</b> If the associated mutex is currently locked, a value convertible to
|
||||
<code>true</code>, else a value convertible to <code>false</code>.</p>
|
||||
|
||||
<p><b>Rationale:</b> A <code>const void*</code> conversion is considered safer than a
|
||||
conversion to <code>bool</code>.</p>
|
||||
|
||||
<hr>
|
||||
<h3>locked</h3>
|
||||
|
||||
<pre>
|
||||
bool locked() const;
|
||||
</pre>
|
||||
|
||||
<p><b>Returns:</b> <code>this->operator const void*() != 0</code>.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h2><a name="Example">Example</a> Usage</h2>
|
||||
|
||||
<pre>
|
||||
#include <boost/thread/mutex.hpp>
|
||||
#include <iostream>
|
||||
|
||||
int main(int, char*[])
|
||||
{
|
||||
boost::timed_mutex mutex;
|
||||
boost::xtime xt;
|
||||
boost::get_xtime(&xt, boost::TIME_UTC);
|
||||
xt.sec += 1;
|
||||
boost::mutex::scoped_timed_lock scope_timed_lock(mutex, xt);
|
||||
if (scope_timed_lock.locked())
|
||||
std::cout << "locked" << std::endl;
|
||||
else
|
||||
std::cout << "unlocked" << std::endl;
|
||||
return 0;
|
||||
}
|
||||
</pre>
|
||||
|
||||
<p>The output is:</p>
|
||||
|
||||
<pre>
|
||||
locked
|
||||
</pre>
|
||||
|
||||
<hr>
|
||||
|
||||
<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%B %d, %Y" startspan -->October 01, 2001<!--webbot bot="Timestamp" endspan i-checksum="30079" -->
|
||||
</p>
|
||||
|
||||
<p><i>© Copyright <a href="mailto:williamkempf@hotmail.com">William E. Kempf</a>
|
||||
2001 all rights reserved.</i></p>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
282
doc/scoped_try_lock.html
Normal file
282
doc/scoped_try_lock.html
Normal file
@@ -0,0 +1,282 @@
|
||||
<html>
|
||||
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
|
||||
<meta name="keywords" content="threads, BTL, thread library, C++">
|
||||
<link rel="stylesheet" type="text/css" href="styles.css">
|
||||
<title>Boost.Threads, scoped_try_lock</title>
|
||||
</head>
|
||||
|
||||
<body bgcolor="#FFFFFF" link="#0000FF" vlink="#800080">
|
||||
|
||||
<table border="0" cellpadding="7" cellspacing="0" width="100%">
|
||||
<tr>
|
||||
<td valign="top" width="300">
|
||||
<h3><img src="../../../c++boost.gif" alt="C++ Boost" width="277" height="86"></h3>
|
||||
</td>
|
||||
<td valign="top">
|
||||
<h1 align="center">Boost.Threads</h1>
|
||||
<h2 align="center">scoped_try_lock</h2>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<hr>
|
||||
|
||||
<p><a href="#Introduction">Introduction</a><br>
|
||||
<a href="#Header">Header</a><br>
|
||||
<a href="#Synopsis">Synopsis</a><br>
|
||||
<a href="#Members">Members</a><br>
|
||||
<a href="#Example">Example</a></p>
|
||||
|
||||
<h2><a name="Introduction">Introduction</a></h2>
|
||||
|
||||
<p>This class template defines a generic lock type which meets the
|
||||
<a href="lock_concept.html#ScopedTryLock">ScopedTryLock</a> requirements. The
|
||||
<a href="mutex.html">try_mutex</a>, <a href="mutex.html">timed_mutex</a>,
|
||||
<a href="recursive_mutex.html">recursive_try_mutex</a> and
|
||||
<a href="recursive_mutex.html">recursive_timed_mutex</a> classes use this template
|
||||
to define their <code>scoped_try_lock</code> types.</p>
|
||||
|
||||
<p>Like all the <b>Boost.Threads</b> <a href="lock_concept.html">lock models</a>,
|
||||
<code>scoped_try_lock</code> objects are meant to be short-lived. Objects of the
|
||||
class are not <a href="definitions.html#thread-safe">thread-safe</a>, and
|
||||
so should not be shared between threads.</p>
|
||||
|
||||
<p>Class <code> scoped_try_lock</code> follows the "resource acquisition is
|
||||
initialization" idiom <a href="bibliography.html#Stroustrup-00">[Stroustrup
|
||||
00 14.4.1]</a> and is a realization of the "Scoped Locking Pattern"
|
||||
<a href="bibliography.html#Schmidt-00">[Schmidt-00]</a>. Thus the usage is to let the
|
||||
constructor do the locking, and then let the destructor do the unlocking automatically at
|
||||
the end of the enclosing scope. The lock() and unlock() members are usually not
|
||||
explicitly called, but are provided to allow for complex overlapping locks of multiple
|
||||
mutexes.</p>
|
||||
|
||||
<p>Although this class is an implementation detail, it is publicly documented here because
|
||||
of its importance.</p>
|
||||
|
||||
<p>The type used to instantiate the class must meet the <a href="mutex_concept.html#TryMutex">TryMutex</a> requirements.</p>
|
||||
|
||||
<h2><a name="Header">Header</a></h2>
|
||||
|
||||
<pre>
|
||||
#include <a href="../../../boost/thread/detail/lock.hpp"><boost/thread/detail/lock.hpp></a>
|
||||
<i>This header is usually not included directly by programmers
|
||||
because it is supplied by <a href="../../../boost/thread/mutex.hpp"><boost/thread/mutex.hpp></a> or
|
||||
<a href="../../../boost/thread/recursive_mutex.hpp"><boost/thread/recursive_mutex.hpp></a></i>
|
||||
</pre>
|
||||
|
||||
<h2><a name="Synopsis">Synopsis</a></h2>
|
||||
|
||||
<pre>
|
||||
namespace boost { namespace detail { namespace thread {
|
||||
template <typename TryMutex>
|
||||
class scoped_try_lock : private <a href="../../utility/utility.htm#Class noncopyable">boost::noncopyable</a> // Exposition only.
|
||||
// Class scoped_try_lock meets the <a href="overview.html#NonCopyable">NonCopyable</a> requirement.
|
||||
{
|
||||
public:
|
||||
typedef TryMutex mutex_type;
|
||||
|
||||
explicit scoped_try_lock(TryMutex& mx);
|
||||
scoped_try_lock(TryMutex& mx, bool initially_locked);
|
||||
~scoped_try_lock();
|
||||
|
||||
void lock();
|
||||
bool try_lock();
|
||||
void unlock();
|
||||
|
||||
operator const void*() const;
|
||||
};
|
||||
} // namespace thread
|
||||
} // namespace detail
|
||||
} // namespace boost
|
||||
</pre>
|
||||
|
||||
<h2><a name="Members">Members</a></h2>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>Constructors</h3>
|
||||
|
||||
<pre>
|
||||
explicit scoped_try_lock(TryMutex& mx);
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> Associates mutex <code>mx</code> with <code>*this</code>.
|
||||
Calls <code>try_lock()</code>.</p>
|
||||
|
||||
<hr>
|
||||
<pre>
|
||||
scoped_try_lock(TryMutex& mx, bool initially_locked);
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> Associates mutex <code>mx</code> with <code>*this</code>.
|
||||
If <code>initially_locked</code> is <code>true,</code> calls <code>lock()</code>.</p>
|
||||
<hr>
|
||||
|
||||
<h3>Destructor</h3>
|
||||
|
||||
<pre>
|
||||
~scoped_try_lock();
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> If <code>locked()</code>, calls <code>unlock()</code>. Destroys
|
||||
<code>*this</code>.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>lock</h3>
|
||||
|
||||
<pre>
|
||||
void lock();
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> If the associated mutex is already locked by another lock in the
|
||||
current thread, the effects depend on the locking strategy of the associated mutex, as
|
||||
shown in the following table:</p>
|
||||
|
||||
<table border="1" cellpadding="5" height="147">
|
||||
<tr>
|
||||
<td height="34"><i><a href="mutex_concept.html#LockingStrategies">Locking Strategy</a><br>
|
||||
of associated mutex</i></td>
|
||||
<td height="34"><i>Effect if associated mutex is already locked by the
|
||||
current thread</i></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td height="19">Recursive</td>
|
||||
<td height="19">As if an additional lock were added to the mutex.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td height="19">Checked</td>
|
||||
<td height="19">Throws <a href="lock_error.html">lock_error</a>.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td height="19">Unchecked</td>
|
||||
<td height="19">Undefined behavior [<a href="bibliography.html#ISO">ISO</a> 1.3.12] (but
|
||||
typically, <a href="definitions.html#Deadlock">deadlock</a>.)</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<p>If the associated mutex is already locked by some other thread, places the
|
||||
current thread in the <a href="definitions.html#State">Blocked</a> state until
|
||||
the associated mutex is unlocked, after which the current thread is placed in
|
||||
the <a href="definitions.html#State">Ready</a> state, eventually to be returned
|
||||
to the <a href="definitions.html#State">Running</a> state. Places the associated
|
||||
mutex in the locked state.</p>
|
||||
|
||||
<p><b>Throws:</b> <a href="lock_error.html">lock_error</a> if <code>locked()</code> or
|
||||
as indicated in <b>Effects</b>.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>try_lock</h3>
|
||||
|
||||
<pre>
|
||||
bool try_lock();
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> If the associated mutex is already locked by another lock in the
|
||||
current thread, the effects depend on the locking strategy of the associated mutex, as
|
||||
shown in the following table:</p>
|
||||
|
||||
<table border="1" cellpadding="5" height="147">
|
||||
<tr>
|
||||
<td height="34"><i><a href="mutex_concept.html#LockingStrategies">Locking Strategy</a><br>
|
||||
of associated mutex</i></td>
|
||||
<td height="34"><i>Effect if associated mutex is already locked by the
|
||||
current thread</i></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td height="19">Recursive</td>
|
||||
<td height="19">As if an additional lock were added to the mutex.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td height="19">Checked</td>
|
||||
<td height="19">Throws <a href="lock_error.html">lock_error</a>.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td height="19">Unspecified</td>
|
||||
<td height="19">Undefined behavior [<a href="bibliography.html#ISO">ISO</a> 1.3.12] (but
|
||||
typically, <a href="definitions.html#Deadlock">deadlock</a>.)</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<p>If the associated mutex is not already locked by some other thread, locks the
|
||||
associated mutex and returns true, else returns false.</p>
|
||||
|
||||
<p><b>Returns:</b> See effects.</p>
|
||||
|
||||
<p><b>Throws:</b> <a href="lock_error.html">lock_error</a> if <code>locked()</code> or
|
||||
as indicated in <b>Effects</b>.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>unlock</h3>
|
||||
|
||||
<pre>
|
||||
void unlock();
|
||||
</pre>
|
||||
|
||||
<p><b>Effects: </b>Unlocks the associated mutex.</p>
|
||||
|
||||
<p><b>Throws:</b> <a href="lock_error.html">lock_error</a> if <code>!locked()</code>.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>const void* Conversion</h3>
|
||||
|
||||
<pre>
|
||||
operator const void*() const;
|
||||
</pre>
|
||||
|
||||
<p><b>Returns:</b> If the associated mutex is currently locked, a value convertible to
|
||||
<code>true</code>, else a value convertible to <code>false</code>.</p>
|
||||
|
||||
<p><b>Rationale:</b> A <code>const void*</code> conversion is considered safer
|
||||
than a conversion to <code>bool</code>.</p>
|
||||
|
||||
<hr>
|
||||
<h3>locked</h3>
|
||||
|
||||
<pre>
|
||||
bool locked() const;
|
||||
</pre>
|
||||
|
||||
<p><b>Returns:</b> <code>this->operator const void*() != 0</code>.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h2><a name="Example">Example</a> Usage</h2>
|
||||
|
||||
<pre>
|
||||
#include <a href="../../../boost/thread/mutex.hpp"><boost/thread/mutex.hpp></a>
|
||||
#include <iostream>
|
||||
|
||||
int main(int, char*[])
|
||||
{
|
||||
boost::mutex mutex;
|
||||
boost::mutex::try_lock lock(mutex);
|
||||
if (lock)
|
||||
std::cout << "locked" << std::endl;
|
||||
else
|
||||
std::cout << "unlocked" << std::endl;
|
||||
return 0;
|
||||
}
|
||||
</pre>
|
||||
|
||||
<p>The output is:</p>
|
||||
|
||||
<pre>
|
||||
locked
|
||||
</pre>
|
||||
|
||||
<hr>
|
||||
|
||||
<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->01 October, 2001<!--webbot bot="Timestamp" endspan i-checksum="38291" -->
|
||||
</p>
|
||||
|
||||
<p><i>© Copyright <a href="mailto:williamkempf@hotmail.com">William E. Kempf</a>
|
||||
2001 all rights reserved.</i></p>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
226
doc/semaphore.html
Normal file
226
doc/semaphore.html
Normal file
@@ -0,0 +1,226 @@
|
||||
<html>
|
||||
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
|
||||
<meta name="keywords" content="threads, BTL, thread library, C++">
|
||||
<link rel="stylesheet" type="text/css" href="styles.css">
|
||||
<title>Boost.Threads, semaphore</title>
|
||||
</head>
|
||||
|
||||
<body bgcolor="#ffffff" link="#0000ff" vlink="#800080">
|
||||
|
||||
<table border="0" cellpadding="7" cellspacing="0" width="100%">
|
||||
<tr>
|
||||
<td valign="top" width="300">
|
||||
<h3><IMG height=86 alt="C++ Boost" src="../../../c++boost.gif" width=277></h3>
|
||||
</td>
|
||||
<td valign="top">
|
||||
<h1 align="center">Boost.Threads</h1>
|
||||
<h2 align="center">semaphore</h2>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<hr>
|
||||
|
||||
<p><a href="#Introduction">Introduction</a><br>
|
||||
<a href="#Header">Header</a><br>
|
||||
<a href="#Synopsis">Synopsis</a><br>
|
||||
<a href="#Members">Members</a><br>
|
||||
<a href="#Example">Example</a></p>
|
||||
|
||||
<h2><a name="Introduction">Introduction</a></h2>
|
||||
|
||||
<p>The <tt>semaphore</tt> class defines a classic synchronization primitive invented by the
|
||||
Dutch computer scientist Edsger W. Dijkstra. A semaphore manages an internal counter. This
|
||||
counter never goes below zero, or above a specified maximum value. When calling
|
||||
<tt>semaphore::down</tt> the calling thread will block until the value is non-zero and then
|
||||
decrement the value in a single atomic operation. When calling <tt>semaphore::up</tt> the
|
||||
calling thread will increment the value in a single atomic operation, failing if the value has
|
||||
already reached the specified maximum.</p>
|
||||
|
||||
<p><b>Rationale:</b> The semaphore is the simplest synchronization primitive available and is generally the
|
||||
primitive used to build other synchronization concepts at some level of implementation. For this
|
||||
reason <b>Boost.Threads</b> defines the <tt>semaphore</tt> type in the classic form. This simplifies
|
||||
usage and implementation, but it means that the interface is not as safe as other <b>Boost.Threads</b>
|
||||
interfaces.</p>
|
||||
|
||||
<p><b><a name="Danger">Danger</a>:</b> Unlike the <A href="mutex_concept.html">mutex models</a> supplied by <b>Boost.Threads,</b>
|
||||
there is no <A href="lock_concept.html">lock_concept</a> for the semaphore to help ensure proper
|
||||
usage. Great care must be taken when using a <tt>semaphore</tt> object to ensure
|
||||
<a href="definitions.html#Deadlock"> deadlock</a> or <a href="definitions.html#Race condition">race conditions</a> do not occur. </p>
|
||||
|
||||
<p>The dangers are spelled out by <a href="bibliography.html#Andrews-83">[Andrews-83]</a>
|
||||
(function names updated, see historical note below): </p>
|
||||
|
||||
<blockquote>
|
||||
|
||||
<p>Although semaphores can be used to program almost any kind of synchronization,
|
||||
<b>down()</b> and <b>up()</b> are rather unstructured primitives, and so it is easy to err when using them. Execution of each critical section must begin with a
|
||||
<b>down()</b> and end with a <b>up()</b> (on the same semaphore). Omitting a <b>down()</b>
|
||||
or <b>up()</b>, or accidentally coding a <b>down()</b> on one semaphore and a <b>up()</b>
|
||||
on another can have disastrous effects, since mutually exclusive execution would no longer be ensured. Also, when using semaphores, a programmer can forget to include in critical sections all statements that reference shared objects. This, too, could destroy the mutual exclusion required within critical sections. A second difficulty with using semaphores is that both condition synchronization and mutual exclusion are programmed using the same pair of primitives. This makes it difficult to identify the purpose of a given
|
||||
<b>down()</b> or <b>up()</b> operation without looking at the other operations on the corresponding semaphore. Since mutual exclusion and condition synchronization are distinct concepts, they should have distinct notations.</p>
|
||||
|
||||
</blockquote>
|
||||
|
||||
<p><b>Historical note: </b>Dijkstra's original name for <b>down()</b> was <b>P</b>
|
||||
(short for the Dutch "passeren", "to pass"), and for <b>up()</b>
|
||||
was <b>V</b> (short for the Dutch "vrygeven", "to release").</p>
|
||||
|
||||
<h2><a name="Header">Header</a></h2>
|
||||
|
||||
<pre>
|
||||
#include <a href="../../../boost/thread/semaphore.hpp"><boost/thread/semaphore.hpp></a>
|
||||
</pre>
|
||||
|
||||
<h2><a name="Synopsis">Synopsis</a></h2>
|
||||
|
||||
<pre>
|
||||
namespace boost
|
||||
{
|
||||
class semaphore : private <a href="../../utility/utility.htm#Class noncopyable">boost::noncopyable</a> // Exposition only.
|
||||
// Class semaphore meets the <a href="overview.html#NonCopyable">NonCopyable</a> requirement.
|
||||
{
|
||||
public:
|
||||
explicit semaphore(unsigned count=0, unsigned max=0);
|
||||
~semaphore();
|
||||
|
||||
bool up(unsigned count=1, unsigned* prev=0);
|
||||
void down();
|
||||
bool down(const xtime& xt);
|
||||
private:
|
||||
unsigned m_count; <i>exposition only [ISO 17.3.2.3/2]
|
||||
</i> unsigned m_max; <i>exposition only [ISO 17.3.2.3/2]</i>
|
||||
};
|
||||
}
|
||||
</pre>
|
||||
|
||||
<h2><a name="Members">Members</a></h2>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>Constructor</h3>
|
||||
|
||||
<pre>
|
||||
explicit semaphore(unsigned count=0, unsigned max=0);
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> As if:</p>
|
||||
|
||||
<p><code> m_count = count;<br>
|
||||
m_max = (max == 0 ? std::numeric_limits<unsigned>::max()
|
||||
? max );</code></p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>Destructor</h3>
|
||||
|
||||
<pre>
|
||||
~semaphore();
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> Destroys <code>*this</code>.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>up</h3>
|
||||
|
||||
<pre>
|
||||
bool up(unsigned count=1, unsigned* prev=0);
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> As if:</p>
|
||||
|
||||
<p><code> unsigned ct;<br>
|
||||
bool ret;<br>
|
||||
{ // as a single atomic operation:<br>
|
||||
ct = m_count;<br>
|
||||
if (m_count == m_max) ret =
|
||||
false;<br>
|
||||
else<br>
|
||||
{<br>
|
||||
ret =
|
||||
true;<br>
|
||||
++m_count;<br>
|
||||
}<br>
|
||||
}<br>
|
||||
if (prev) *prev = m_count;<br>
|
||||
return ret;</code></p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>down</h3>
|
||||
|
||||
<pre>
|
||||
void down();
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> If <code>m_count == 0</code>, places the current thread in
|
||||
the <a href="definitions.html#State">blocked</a> state until <code>m_count != 0</code>.
|
||||
Finally, <code>--m_count</code>.<code> </code></p>
|
||||
|
||||
<hr>
|
||||
|
||||
<pre>
|
||||
bool down(const <a href="xtime.html">xtime</a>& xt);
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> If <code>m_count == 0</code>, places the current thread in
|
||||
the <a href="definitions.html#State">blocked</a> state until <code>m_count != 0</code>
|
||||
or <code>xt</code> is reached. Finally, <code>--m_count</code>.<code> </code></p>
|
||||
|
||||
<p><b>Returns:</b> If xt was reached, true, else false.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h2><a name="Example">Example</a> Usage</h2>
|
||||
|
||||
<pre>
|
||||
#include <a href="../../../boost/thread/semaphore.hpp"><boost/thread/semaphore.hpp></a>
|
||||
#include <a href="../../../boost/thread/thread.hpp"><boost/thread/thread.hpp></a>
|
||||
#include <iostream>
|
||||
|
||||
int global_data = 0;
|
||||
boost::semaphore global_semaphore(1);
|
||||
|
||||
void change_global_data(void*)
|
||||
{
|
||||
global_semaphore.down();
|
||||
++global_data;
|
||||
std::cout << "global_data == " << global_data << std::endl;
|
||||
global_semaphore.up();
|
||||
}
|
||||
|
||||
int main(int, char*[])
|
||||
{
|
||||
const int num_threads = 4;
|
||||
boost::thread_group thrds;
|
||||
for (int i=0; i < num_threads; ++i)
|
||||
thrds.create_thread(&change_global_data, 0);
|
||||
|
||||
thrds.join_all();
|
||||
|
||||
return 0;
|
||||
}
|
||||
</pre>
|
||||
|
||||
<p>The output is:</p>
|
||||
|
||||
<pre>
|
||||
global_data == 1
|
||||
global_data == 2
|
||||
global_data == 3
|
||||
global_data == 4
|
||||
</pre>
|
||||
|
||||
<hr>
|
||||
|
||||
<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->01 October, 2001<!--webbot bot="Timestamp" endspan i-checksum="38291" -->
|
||||
</p>
|
||||
|
||||
<p><i>© Copyright <A href="mailto:williamkempf@hotmail.com">William E. Kempf</a>
|
||||
2001 all rights reserved.</i></p>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
4
doc/styles.css
Normal file
4
doc/styles.css
Normal file
@@ -0,0 +1,4 @@
|
||||
PRE
|
||||
{
|
||||
BACKGROUND-COLOR: lightcyan
|
||||
}
|
||||
254
doc/thread.html
Normal file
254
doc/thread.html
Normal file
@@ -0,0 +1,254 @@
|
||||
<html>
|
||||
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
|
||||
<meta name="keywords" content="threads, Boost.Threads, thread library, C++">
|
||||
<link rel="stylesheet" type="text/css" href="styles.css">
|
||||
<title>Boost.Threads, thread</title>
|
||||
</head>
|
||||
|
||||
<body bgcolor="#ffffff" link="#0000ff" vlink="#800080">
|
||||
|
||||
<table border="0" cellpadding="7" cellspacing="0" width="100%">
|
||||
<tr>
|
||||
<td valign="top" width="300">
|
||||
<h3><IMG height=86 alt="C++ Boost" src="../../../c++boost.gif" width=277></h3>
|
||||
</td>
|
||||
<td valign="top">
|
||||
<h1 align="center">Boost.Threads</h1>
|
||||
<h2 align="center">Class thread</h2>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<hr>
|
||||
|
||||
<p><A href="#Introduction">Introduction</A><br>
|
||||
<A href="#Header">Header</A><br>
|
||||
<A href="#Synopsis">Synopsis</A><br>
|
||||
<A href="#Members">Members</A><br>
|
||||
<A href="#Example">Example</A></p>
|
||||
|
||||
<h2><a name="Introduction">Introduction</a></h2>
|
||||
|
||||
<p>The <code>thread</code> class represents threads of execution, and provides
|
||||
the functionality to create and manage threads within the <b>Boost.Threads</b>
|
||||
library. See <A href="definitions.html">Definitions</A> for a precise description of
|
||||
"thread of execution", and for definitions of threading related terms and of thread
|
||||
states such as "blocked".</p>
|
||||
|
||||
<p>A thread of execution has an initial function. For the program's
|
||||
initial thread, the initial function is <code>main()</code>. For other
|
||||
threads, the initial function is <code>operator()</code> of the function object
|
||||
passed to the class <code>thread</code> constructor.</p>
|
||||
|
||||
<p>A thread of execution is said to be "finished" or "finished execution" when its
|
||||
initial function returns or is terminated. This includes completion of all thread
|
||||
cleanup handlers, and completion of the normal C++ function return behaviors, such
|
||||
as destruction of automatic storage (stack) objects and releasing any associated
|
||||
implementation resources.</p>
|
||||
|
||||
<p>A thread object has an associated state which is either "joinable" or
|
||||
"non-joinable".</p>
|
||||
|
||||
<p>Except as described below, the policy used by an implementation of
|
||||
<b>Boost.Threads</b> to schedule transitions between thread states is unspecified.</p>
|
||||
|
||||
<p><b>Note: </b>Just as the lifetime of a file may be different from the
|
||||
lifetime of an iostream object which represents the file, the lifetime of a
|
||||
thread of execution may be different from the <code>thread</code> object which
|
||||
represents the thread of execution. In particular, after a call to <code>join()</code>,
|
||||
the thread of execution will no longer exist even though the <code>thread</code>
|
||||
object continues to exist until the end of its normal lifetime. The
|
||||
converse is also possible; if a <code>thread</code> object is destroyed without
|
||||
<code>join()</code> having first been called, the thread of execution continues until
|
||||
its initial function completes.</p>
|
||||
|
||||
<h2><a name="Header">Header</a></h2>
|
||||
|
||||
<pre>
|
||||
#include <A href="../../../boost/thread/thread.hpp"><boost/thread/thread.hpp></A>
|
||||
</pre>
|
||||
|
||||
<h2><a name="Synopsis">Synopsis</a></h2>
|
||||
|
||||
<pre>
|
||||
namespace boost {
|
||||
|
||||
class thread : <a href="../../utility/utility.htm#noncopyable">boost::noncopyable</a> // Exposition only.
|
||||
// Class thread meets the <a href="overview.html#NonCopyable">NonCopyable</a> requirement.
|
||||
{
|
||||
public:
|
||||
thread();
|
||||
explicit thread(const boost::function0<void>& threadfunc);
|
||||
~thread();
|
||||
|
||||
bool operator==(const thread& rhs) const;
|
||||
bool operator!=(const thread& rhs) const;
|
||||
|
||||
void join();
|
||||
|
||||
static void sleep(const xtime& xt);
|
||||
static void yield();
|
||||
};
|
||||
|
||||
} // namespace boost
|
||||
</pre>
|
||||
|
||||
<h2><a name="Members">Members</a></h2>
|
||||
|
||||
<hr>
|
||||
<h3>Constructors</h3>
|
||||
|
||||
<pre>
|
||||
thread();
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> Constructs a <code>thread</code> object representing the current thread
|
||||
of execution.</p>
|
||||
|
||||
<p><b>Postcondition:</b> <code>*this</code> is non-joinable.</p>
|
||||
|
||||
<p><b>Danger:</b> <code>*this</code> is valid only within the current thread.</p>
|
||||
|
||||
<pre>
|
||||
thread(const <A href="../../function/index.html">boost::function0</A><void>& threadfunc);
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> Starts a new thread of execution and constructs a <code>thread</code> object
|
||||
representing it. Copies <code>threadfunc</code>
|
||||
(which in turn copies the function object wrapped by <code>threadfunc</code>) to an
|
||||
internal location which persists for the lifetime of the new thread of execution. Calls
|
||||
<code>operator()</code> on the copy of the <code>threadfunc</code> function object in
|
||||
the new thread of execution.</p>
|
||||
|
||||
<p><b>Postcondition:</b> <code>*this</code> is joinable.</p>
|
||||
|
||||
<p><b>Throws:</b> <code>boost::thread_resource_error</code> if a new thread of execution
|
||||
cannot be started.</p>
|
||||
|
||||
<hr>
|
||||
<h3>Destructor</h3>
|
||||
|
||||
<pre>
|
||||
~thread();
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> Destroys <code>*this</code>. The actual thread of execution may
|
||||
continue to execute after the <code>thread</code> object has been destroyed.</p>
|
||||
|
||||
<p><b>Notes:</b> If <code>*this</code> is joinable the actual thread of execution
|
||||
becomes "detached". Any resources used by the thread will be reclaimed when the
|
||||
thread of execution completes. To ensure such a thread of execution runs to completion
|
||||
before the <code>thread</code> object is destroyed, call <code>join()</code>.</p>
|
||||
|
||||
<hr>
|
||||
<h3>Comparison Operators</h3>
|
||||
|
||||
<pre>
|
||||
bool operator==(const thread& rhs);
|
||||
</pre>
|
||||
|
||||
<p><b>Requires:</b> The thread is non-terminated or <code>*this</code> is joinable.</p>
|
||||
|
||||
<p><b>Returns:</b> <code>true</code> if <code>*this</code> and <code>rhs</code>
|
||||
represent the same thread of execution.</p>
|
||||
|
||||
<pre>
|
||||
bool operator!=(const thread& rhs);
|
||||
</pre>
|
||||
|
||||
<p><b>Returns:</b> <code>!(*this==rhs)</code>.</p>
|
||||
|
||||
<hr>
|
||||
<h3>join</h3>
|
||||
|
||||
<pre>
|
||||
void join();
|
||||
</pre>
|
||||
|
||||
<p><b>Requires:</b> <code>*this</code> is joinable.</p>
|
||||
|
||||
<p><b>Effects:</b> The current thread of execution blocks until the initial function of
|
||||
the thread of execution represented by <code>*this</code> finishes and all resources
|
||||
are reclaimed.</p>
|
||||
|
||||
<p><b>Postcondition:</b> <code>*this</code> is non-joinable.</p>
|
||||
|
||||
<p><b>Note:</b></p> If <code>*this == thread()</code> the result is implementation defined.
|
||||
If the implementation doesn't detect this the result will be
|
||||
<a href="definitions.html#Deadlock">deadlock</a>.</p>
|
||||
|
||||
<hr>
|
||||
<h3>sleep</h3>
|
||||
|
||||
<pre>
|
||||
static void sleep(const <a href="xtime.html">xtime</a>& xt);
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> The current thread of execution blocks until <code>xt</code> is
|
||||
reached.</p>
|
||||
|
||||
<hr>
|
||||
<h3>yield</h3>
|
||||
|
||||
<pre>
|
||||
static void yield();
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> The current thread of execution is placed in the "ready" state.</p>
|
||||
|
||||
<p><b>Notes:</b> Allow the current thread to give up the rest of its time slice
|
||||
(or other scheduling quota) to another thread. Particularly useful in non-preemptive
|
||||
implementations.</p>
|
||||
|
||||
<hr>
|
||||
<h2><a name="Example">Example Usage</a></h2>
|
||||
|
||||
<pre>
|
||||
#include <boost/thread/thread.hpp>
|
||||
#include <iostream>
|
||||
|
||||
struct thread_alarm
|
||||
{
|
||||
thread_alarm(int secs) : m_secs(secs) { }
|
||||
void operator()()
|
||||
{
|
||||
boost::xtime xt;
|
||||
boost::xtime_get(&xt, boost::TIME_UTC);
|
||||
xt.sec += m_secs;
|
||||
|
||||
boost::thread::sleep(xt);
|
||||
|
||||
std::cout << "alarm sounded..." << std::endl;
|
||||
}
|
||||
|
||||
int m_secs;
|
||||
};
|
||||
|
||||
int main(int argc, char* argv[])
|
||||
{
|
||||
int secs = 5;
|
||||
std::cout << "setting alarm for 5 seconds..." << std::endl;
|
||||
boost::thread thrd(thread_alarm(secs));
|
||||
thrd.join();
|
||||
}
|
||||
</pre>
|
||||
|
||||
<p>The output is:</p>
|
||||
|
||||
<pre>
|
||||
setting alarm for 5 seconds...
|
||||
alarm sounded...
|
||||
</pre>
|
||||
|
||||
<hr>
|
||||
|
||||
<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->01 October, 2001<!--webbot bot="Timestamp" endspan i-checksum="38291" -->
|
||||
</p>
|
||||
|
||||
<p><i>© Copyright <A href="mailto:williamkempf@hotmail.com">William E. Kempf</A>
|
||||
2001 all rights reserved.</i></p>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
187
doc/thread_group.html
Normal file
187
doc/thread_group.html
Normal file
@@ -0,0 +1,187 @@
|
||||
<html>
|
||||
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
|
||||
<meta name="keywords" content="threads, BTL, thread library, C++">
|
||||
<link rel="stylesheet" type="text/css" href="styles.css">
|
||||
<title>Boost.Threads, thread_group</title>
|
||||
</head>
|
||||
|
||||
<body bgcolor="#FFFFFF" link="#0000FF" vlink="#800080">
|
||||
|
||||
<table border="0" cellpadding="7" cellspacing="0" width="100%">
|
||||
<tr>
|
||||
<td valign="top" width="300">
|
||||
<h3><img src="../../../c++boost.gif" alt="C++ Boost" width="277" height="86"></h3>
|
||||
</td>
|
||||
<td valign="top">
|
||||
<h1 align="center">Boost.Threads</h1>
|
||||
<h2 align="center">thread_group</h2>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<hr>
|
||||
|
||||
<p><a href="#Introduction">Introduction</a><br>
|
||||
<a href="#Header">Header</a><br>
|
||||
<a href="#Synopsis">Synopsis</a><br>
|
||||
<a href="#Members">Members</a><br>
|
||||
<a href="#Example">Example</a></p>
|
||||
|
||||
<h2><a name="Introduction">Introduction</a></h2>
|
||||
|
||||
<p>The <tt>thread_group</tt> class provides a container for easy grouping of threads to simplify several
|
||||
common thread creation and management idioms.</p>
|
||||
|
||||
<p>All <tt>thread_group</tt> member functions are <a href="definitions.html#thread-safe">thread-safe</a>,
|
||||
except destruction.</p>
|
||||
|
||||
<h2><a name="Header">Header</a></h2>
|
||||
|
||||
<pre>
|
||||
#include <a href="../../../boost/thread/thread.hpp"><boost/thread/thread.hpp></a>
|
||||
</pre>
|
||||
|
||||
<h2><a name="Synopsis">Synopsis</a></h2>
|
||||
|
||||
<pre>
|
||||
namespace boost
|
||||
{
|
||||
class thread_group : <a href="../../utility/utility.htm#noncopyable">boost::noncopyable</a>
|
||||
{
|
||||
public:
|
||||
thread_group();
|
||||
~thread_group();
|
||||
|
||||
thread* create_thread(const boost::function0<void>& threadfunc);
|
||||
void add_thread(thread* thrd);
|
||||
void remove_thread(thread* thrd);
|
||||
void join_all();
|
||||
};
|
||||
}
|
||||
</pre>
|
||||
|
||||
<h2><a name="Members">Members</a></h2>
|
||||
<hr>
|
||||
|
||||
<h3>Constructor</h3>
|
||||
|
||||
<pre>
|
||||
thread_group();
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> Constructs an empty <tt>thread_group</tt> container.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>Destructor</h3>
|
||||
|
||||
<pre>
|
||||
~thread_group();
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> Destroys each contained thread object. Destroys <code>*this</code>.</p>
|
||||
|
||||
<p><b>Notes:</b> Behavior is undefined if another thread references *this during
|
||||
the execution of the destructor.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>create_thread</h3>
|
||||
|
||||
<pre>
|
||||
thread* create_thread(const boost::function0<void>& threadfunc);
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> Creates a new <tt>thread</tt> object that executes <tt>threadfunc</tt> and adds it to the
|
||||
<tt>thread_group</tt> container object's list of managed <tt>thread</tt> objects.</p>
|
||||
|
||||
<p><b>Returns:</b> Pointer to the newly created thread.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>add_thread</h3>
|
||||
|
||||
<pre>
|
||||
void add_thread(thread* thrd);
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> Adds <tt>thrd</tt> to the <tt>thread_group</tt> object's list of managed <tt>thread</tt>
|
||||
objects. The <tt>thrd</tt> object must have been allocated via operator new and will
|
||||
be deleted when the group is destroyed.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>remove_thread</h3>
|
||||
|
||||
<pre>
|
||||
void remove_thread(thread* thrd);
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> Removes <code>*this</code>'s list of managed <tt>thread</tt>
|
||||
objects.</p>
|
||||
|
||||
<p><b>Throws: </b>? if <tt>thrd</tt> is not it <code>*this</code>'s list of managed <tt>thread</tt>
|
||||
objects.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>join_all</h3>
|
||||
|
||||
<pre>
|
||||
void join_all();
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> Calls <code> join()</code> on each of the managed <tt>thread</tt> objects.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<h2><a name="Example">Example</a> Usage</h2>
|
||||
|
||||
<pre>
|
||||
#include <boost/thread/thread.hpp>
|
||||
#include <iostream>
|
||||
|
||||
int count = 0;
|
||||
boost::mutex mutex;
|
||||
|
||||
void increment_count()
|
||||
{
|
||||
boost::mutex::lock lock(mutex);
|
||||
std::cout << "count = " << ++count << std::endl;
|
||||
}
|
||||
|
||||
int main(int argc, char* argv[])
|
||||
{
|
||||
boost::thread_group threads;
|
||||
for (int i = 0; i < 10; ++i)
|
||||
threads.create_thread(&increment_count);
|
||||
threads.join_all();
|
||||
}
|
||||
</pre>
|
||||
|
||||
<p>The output is:</p>
|
||||
|
||||
<pre>
|
||||
count = 1
|
||||
count = 2
|
||||
count = 3
|
||||
count = 4
|
||||
count = 5
|
||||
count = 6
|
||||
count = 7
|
||||
count = 8
|
||||
count = 9
|
||||
count = 10
|
||||
</pre>
|
||||
<hr>
|
||||
|
||||
<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->01 October, 2001<!--webbot bot="Timestamp" endspan i-checksum="38291" -->
|
||||
</p>
|
||||
|
||||
<p><i>© Copyright <a href="mailto:williamkempf@hotmail.com">William E. Kempf</a>
|
||||
2001 all rights reserved.</i></p>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
80
doc/thread_resource_error.html
Normal file
80
doc/thread_resource_error.html
Normal file
@@ -0,0 +1,80 @@
|
||||
<html>
|
||||
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
|
||||
<meta name="keywords" content="threads, BTL, thread library, C++">
|
||||
<link rel="stylesheet" type="text/css" href="styles.css">
|
||||
<title>Boost.Threads, thread_resource_error</title>
|
||||
</head>
|
||||
|
||||
<body bgcolor="#FFFFFF" link="#0000FF" vlink="#800080">
|
||||
|
||||
<table border="0" cellpadding="7" cellspacing="0" width="100%">
|
||||
<tr>
|
||||
<td valign="top" width="300">
|
||||
<h3><img src="../../../c++boost.gif" alt="C++ Boost" width="277" height="86"></h3>
|
||||
</td>
|
||||
<td valign="top">
|
||||
<h1 align="center">Boost.Threads</h1>
|
||||
<h2 align="center">thread_resource_error</h2>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<hr>
|
||||
|
||||
<p><a href="#Introduction">Introduction</a><br>
|
||||
<a href="#Header">Header</a><br>
|
||||
<a href="#Synopsis">Synopsis</a><br>
|
||||
<a href="#Members">Members</a><br>
|
||||
<a href="#Example">Example</a></p>
|
||||
|
||||
<h2><a name="Introduction">Introduction</a></h2>
|
||||
|
||||
<p>The <code>thread_resource_error</code> class defines an exception type that is thrown
|
||||
by constructors in the <b>Boost.Threads</b> library when thread related resources
|
||||
can not be
|
||||
acquired. This does not include memory allocation failures which instead throw
|
||||
std::bad_alloc.</p>
|
||||
|
||||
<h2><a name="Header">Header</a></h2>
|
||||
|
||||
<pre>
|
||||
#include <a href="../../../boost/thread/thread.hpp"><boost/thread/exceptions.hpp></a>
|
||||
</pre>
|
||||
|
||||
<h2><a name="Synopsis">Synopsis</a></h2>
|
||||
|
||||
<pre>
|
||||
namespace boost
|
||||
{
|
||||
class thread_resource_error : public std::runtime_error
|
||||
{
|
||||
public:
|
||||
thread_resource_error();
|
||||
};
|
||||
}
|
||||
</pre>
|
||||
|
||||
<h2><a name="Members">Members</a></h2>
|
||||
|
||||
<hr>
|
||||
|
||||
<h3>Constructor</h3>
|
||||
|
||||
<pre>
|
||||
thread_resource_error();
|
||||
</pre>
|
||||
|
||||
<p>Constructs a <code>thread_resource_error</code> object.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->01 October, 2001<!--webbot bot="Timestamp" endspan i-checksum="38291" -->
|
||||
</p>
|
||||
|
||||
<p><i>© Copyright <a href="mailto:williamkempf@hotmail.com">William E. Kempf</a>
|
||||
2001 all rights reserved.</i></p>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
214
doc/thread_specific_ptr.html
Normal file
214
doc/thread_specific_ptr.html
Normal file
@@ -0,0 +1,214 @@
|
||||
<html>
|
||||
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
|
||||
<meta name="keywords" content="threads, Boost.Threads, thread library, C++">
|
||||
<link rel="stylesheet" type="text/css" href="styles.css">
|
||||
<title>Boost.Threads, thread_specific_ptr</title>
|
||||
</head>
|
||||
|
||||
<body bgcolor="#FFFFFF" link="#0000FF" vlink="#800080">
|
||||
|
||||
<table border="0" cellpadding="7" cellspacing="0" width="100%">
|
||||
<tr>
|
||||
<td valign="top" width="300">
|
||||
<h3><img src="../../../c++boost.gif" alt="C++ Boost" width="277" height="86"></h3>
|
||||
</td>
|
||||
<td valign="top">
|
||||
<h1 align="center">Boost.Threads</h1>
|
||||
<h2 align="center">thread_specific_ptr</h2>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<hr>
|
||||
|
||||
<p><A href="#Introduction">Introduction</A><br>
|
||||
<A href="#Header">Header</A><br>
|
||||
<A href="#Synopsis">Synopsis</A><br>
|
||||
<A href="#Members">Members</A><br>
|
||||
<A href="#Example">Example</A></p>
|
||||
|
||||
<h2><a name="Introduction">Introduction</a></h2>
|
||||
|
||||
<p>The <code>thread_specific_ptr</code> class defines an interface for using thread
|
||||
specific storage. Thread specific storage is data associated with individual threads
|
||||
and is often used to make operations
|
||||
<a href="definitions.html#Thread-safe">thread-safe</a> that rely on global data.</p>
|
||||
|
||||
<p>Template <code>thread_specific_ptr</code> stores a pointer to an object obtained via
|
||||
<code>new</code> on a thread-by-thread basis and calls delete on the contained pointer
|
||||
when the thread terminates. Each thread initially stores the null pointer in each
|
||||
<code>thread_specific_ptr</code> instance.</p>
|
||||
|
||||
<p>The template <code>thread_specific_ptr</code> is useful in the following cases:</p>
|
||||
|
||||
<ul>
|
||||
<li>An interface was original written assuming a single thread of control and is
|
||||
being ported to a multi-threaded environment.</li>
|
||||
<li>Each thread of control invokes sequences of methods that share data that must be
|
||||
logically accessed through a globally visible access point, but are physically
|
||||
unique for each thread, instead of being explicitly passed.</li>
|
||||
</ul>
|
||||
|
||||
<h2><a name="Header">Header</a></h2>
|
||||
|
||||
<pre>
|
||||
#include <a href="../../../boost/thread/tss.hpp"><boost/thread/tss.hpp></a>
|
||||
</pre>
|
||||
|
||||
<h2><a name="Synopsis">Synopsis</a></h2>
|
||||
|
||||
<pre>
|
||||
namespace boost {
|
||||
|
||||
template <typename T>
|
||||
class thread_specific_ptr : private boost::noncopyable // Exposition only.
|
||||
// Class thread_specific_ptr meets the <a href="overview.html#NonCopyable">NonCopyable</a> requirement.
|
||||
{
|
||||
public:
|
||||
thread_specific_ptr();
|
||||
~thread_specific_ptr();
|
||||
|
||||
T* get() const;
|
||||
T* operator->() const;
|
||||
T& operator*() const;
|
||||
T* release();
|
||||
void reset(T* p=0);
|
||||
};
|
||||
|
||||
} // namespace boost
|
||||
</pre>
|
||||
|
||||
<h2><a name="Members">Members</a></h2>
|
||||
|
||||
<hr>
|
||||
<h3>Constructor</h3>
|
||||
|
||||
<pre>
|
||||
thread_specific_ptr();
|
||||
</pre>
|
||||
|
||||
<p><b>Postconditions:</b> A thread specific storage has been reserved for use by *this
|
||||
in all threads, with each thread initially storing a null pointer.</p>
|
||||
|
||||
<p><b>Requires:</b> The expression <code>delete get()</code> is well formed.</p>
|
||||
|
||||
<p><b>Throws:</b> <code>boost::thread_resource_error</code> if the necessary resources
|
||||
can not be obtained.</p>
|
||||
|
||||
<p><b>Notes:</b> There is an implementation specific limit to the number of thread
|
||||
specific storage objects that can be created, and this limit may be small.</p>
|
||||
|
||||
<hr>
|
||||
<h3>Destructor</h3>
|
||||
|
||||
<pre>
|
||||
~thread_specific_ptr();
|
||||
</pre>
|
||||
|
||||
<p><b>Notes:</b> Does not destroy any data that may be stored in any thread's thread
|
||||
specific storage. For this reason you should not destroy a
|
||||
<code>thread_specific_ptr</code> object until you are certain there are no threads
|
||||
running that have made use of its thread specific storage.</p>
|
||||
|
||||
<hr>
|
||||
<h3>get</h3>
|
||||
|
||||
<pre>
|
||||
T* get() const;
|
||||
</pre>
|
||||
|
||||
<p><b>Returns:</b> The object stored in thread specific storage for the current thread
|
||||
for *this.</p>
|
||||
|
||||
<p><b>Notes:</b> Each thread initially returns 0.</p>
|
||||
|
||||
<hr>
|
||||
<h3>Smart Pointer Operations</h3>
|
||||
|
||||
<pre>
|
||||
T* operator->() const;
|
||||
</pre>
|
||||
|
||||
<p><b>Returns:</b> <code>get()</code></p>
|
||||
|
||||
<pre>
|
||||
T& operator*() const;
|
||||
</pre>
|
||||
|
||||
<p><b>Returns:</b> <code>get()</code></p>
|
||||
|
||||
<p><b>Requires:</b> <code>get() != 0</code></p>
|
||||
|
||||
<hr>
|
||||
<h3>Release</h3>
|
||||
|
||||
<pre>
|
||||
T* release();
|
||||
</pre>
|
||||
|
||||
<p><b>Returns:</b> <code>get()</code></p>
|
||||
|
||||
<p><b>Postcondition:</b> *this holds the null pointer for the current thread.</p>
|
||||
|
||||
<hr>
|
||||
<h3>Reset</h3>
|
||||
|
||||
<pre>
|
||||
void reset(T* p=0);
|
||||
</pre>
|
||||
|
||||
<p><b>Effects:</b> If <code>get()!= p</code> then <code>delete get()</code>.</p>
|
||||
|
||||
<p><b>Postconditions:</b> <code>*this</code> holds the pointer <code>p</code> for
|
||||
the current thread.</p>
|
||||
|
||||
<p><b>Notes:</b> The pointer will be deleted when the thread terminates.</p>
|
||||
|
||||
<hr>
|
||||
<h2><a name="Example">Example Usage</a></h2>
|
||||
|
||||
<pre>
|
||||
#include <a href="../../../boost/thread/thread.hpp"><boost/thread/thread.hpp></a>
|
||||
#include <a href="../../../boost/thread/tss.hpp"><boost/thread/tss.hpp></a>
|
||||
#include <cassert>
|
||||
|
||||
boost::thread_specific_ptr<int> value;
|
||||
|
||||
void increment()
|
||||
{
|
||||
int* p = value.get();
|
||||
++*p;
|
||||
}
|
||||
|
||||
void thread_proc()
|
||||
{
|
||||
value.reset(new int(0)); // initialize the thread's storage
|
||||
for (int i=0; i<10; ++i)
|
||||
{
|
||||
increment();
|
||||
int* p = value.get();
|
||||
assert(*p == i+1);
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char* argv[])
|
||||
{
|
||||
boost::thread_group threads;
|
||||
for (int i=0; i<5; ++i)
|
||||
threads.create_thread(&thread_proc);
|
||||
threads.join_all();
|
||||
}
|
||||
</pre>
|
||||
|
||||
<hr>
|
||||
|
||||
<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->01 October, 2001<!--webbot bot="Timestamp" endspan i-checksum="38291" -->
|
||||
</p>
|
||||
|
||||
<p><i>© Copyright <a href="mailto:williamkempf@hotmail.com">William E. Kempf</a>
|
||||
2001 all rights reserved.</i></p>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
141
doc/xtime.html
Normal file
141
doc/xtime.html
Normal file
@@ -0,0 +1,141 @@
|
||||
<html>
|
||||
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
|
||||
<meta name="keywords" content="threads, Boost.Threads, thread library, C++">
|
||||
<link rel="stylesheet" type="text/css" href="styles.css">
|
||||
<title>Boost.Threads, xtime</title>
|
||||
</head>
|
||||
|
||||
<body bgcolor="#FFFFFF" link="#0000FF" vlink="#800080">
|
||||
|
||||
<table border="0" cellpadding="7" cellspacing="0" width="100%">
|
||||
<tr>
|
||||
<td valign="top" width="300">
|
||||
<h3><img src="../../../c++boost.gif" alt="C++ Boost" width="277" height="86"></h3>
|
||||
</td>
|
||||
<td valign="top">
|
||||
<h1 align="center">Boost.Threads</h1>
|
||||
<h2 align="center">xtime</h2>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<hr>
|
||||
|
||||
<p><A href="#Introduction">Introduction</A><br>
|
||||
<A href="#Header">Header</A><br>
|
||||
<A href="#Synopsis">Synopsis</A><br>
|
||||
<A href="#Reference">Reference</A><br>
|
||||
<A href="#Example">Example</A></p>
|
||||
|
||||
<h2><a name="Introduction">Introduction</a></h2>
|
||||
|
||||
<p>The <code>xtime</code> type is used to represent a point on some time scale or
|
||||
a duration in time. This type may be proposed for the C standard by Markus Kuhn.
|
||||
<b>Boost.Threads</b> provides only a very minimal implementation of this proposal
|
||||
and it's expected that a full implementation will be provided in Boost as a separate
|
||||
library, at which time <b>Boost.Threads</b> will deprecate its implementation.</p>
|
||||
|
||||
<h2><a name="Header">Header</a></h2>
|
||||
|
||||
<pre>
|
||||
#include <a href="../../../boost/thread/xtime.hpp"><boost/thread/xtime.hpp></a>
|
||||
</pre>
|
||||
|
||||
<h2><a name="Synopsis">Synopsis</a></h2>
|
||||
|
||||
<pre>
|
||||
namespace boost {
|
||||
|
||||
enum
|
||||
{
|
||||
TIME_UTC=1,
|
||||
};
|
||||
|
||||
struct xtime
|
||||
{
|
||||
#if defined(BOOST_NO_INT64_T)
|
||||
int_fast32_t sec;
|
||||
#else
|
||||
int_fast64_t sec;
|
||||
#endif
|
||||
int_fast32_t nsec;
|
||||
};
|
||||
|
||||
int xtime_get(struct xtime* xtp, int clock_type);
|
||||
|
||||
} // namespace boost
|
||||
</pre>
|
||||
|
||||
<h2><a name="Reference">Reference</a></h2>
|
||||
|
||||
<hr>
|
||||
<h3>TIME_UTC</h3>
|
||||
|
||||
<p>The clock type for Coordinated Universal Time (UTC). The epoch for this clock type
|
||||
is 1970-01-01 00:00:00. This is the only clock type supported by <b>Boost.Threads</b>.</p>
|
||||
|
||||
<hr>
|
||||
<h3>xtime</h3>
|
||||
|
||||
<pre>
|
||||
struct xtime
|
||||
{
|
||||
#if defined(BOOST_NO_INT64_T)
|
||||
int_fast32_t sec;
|
||||
#else
|
||||
int_fast64_t sec;
|
||||
#endif
|
||||
int_fast32_t nsec;
|
||||
};
|
||||
</pre>
|
||||
|
||||
<p><b>sec</b> represents the whole seconds that have passed since the epoch.</p>
|
||||
|
||||
<p><b>nsec</b> represents the nanoseconds since <code>sec.</code>
|
||||
|
||||
<hr>
|
||||
<h3>xtime_get</h3>
|
||||
|
||||
<pre>
|
||||
int xtime_get(struct xtime* xtp, int clock_type);
|
||||
</pre>
|
||||
|
||||
<p><b>Postcondition:</b> <code>xtp</code> represents the current point in time
|
||||
as a duration since the epoch specified by the <code>clock_type</code>.</p>
|
||||
|
||||
<p><b>Returns:</b> <code>clock_type</code> if successful, otherwise 0.
|
||||
|
||||
<p><b>Notes:</b> The resolution is implementation specific. For many
|
||||
implementations the best resolution of time is far more than one nanosecond, and
|
||||
even when the resolution is reasonably good, the latency of a call to <code>xtime_get()</code>
|
||||
may be significant. For maximum portability, avoid durations of less than
|
||||
one second.</p>
|
||||
|
||||
<hr>
|
||||
<h2><a name="Example">Example Usage</a></h2>
|
||||
|
||||
<pre>
|
||||
#include <a href="../../../boost/thread/thread.hpp"><boost/thread/thread.hpp></a>
|
||||
#include <a href="../../../boost/thread/tss.hpp"><boost/thread/xtime.hpp></a>
|
||||
|
||||
int main(int argc, char* argv[])
|
||||
{
|
||||
boost::xtime xt;
|
||||
boost::xtime_get(&xt, boost::TIME_UTC);
|
||||
xt.sec += 1;
|
||||
boost::thread::sleep(xt); // Sleep for 1 second
|
||||
}
|
||||
</pre>
|
||||
|
||||
<hr>
|
||||
|
||||
<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->01 October, 2001<!--webbot bot="Timestamp" endspan i-checksum="38291" -->
|
||||
</p>
|
||||
|
||||
<p><i>© Copyright <a href="mailto:williamkempf@hotmail.com">William E. Kempf</a>
|
||||
2001 all rights reserved.</i></p>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
105
example/monitor/monitor.cpp
Normal file
105
example/monitor/monitor.cpp
Normal file
@@ -0,0 +1,105 @@
|
||||
#include <vector>
|
||||
#include <iostream>
|
||||
#include <boost/thread/condition.hpp>
|
||||
#include <boost/thread/mutex.hpp>
|
||||
#include <boost/thread/recursive_mutex.hpp>
|
||||
#include <boost/thread/thread.hpp>
|
||||
|
||||
namespace {
|
||||
const int ITERS = 100;
|
||||
boost::mutex io_mutex;
|
||||
};
|
||||
|
||||
template <typename M>
|
||||
class buffer_t
|
||||
{
|
||||
public:
|
||||
typedef typename M::scoped_lock scoped_lock;
|
||||
|
||||
buffer_t(int n)
|
||||
: p(0), c(0), full(0), buf(n)
|
||||
{
|
||||
}
|
||||
|
||||
void send(int m)
|
||||
{
|
||||
scoped_lock lk(mutex);
|
||||
while (full == buf.size())
|
||||
cond.wait(lk);
|
||||
buf[p] = m;
|
||||
p = (p+1) % buf.size();
|
||||
++full;
|
||||
cond.notify_all();
|
||||
}
|
||||
int receive()
|
||||
{
|
||||
scoped_lock lk(mutex);
|
||||
while (full == 0)
|
||||
cond.wait(lk);
|
||||
int i = buf[c];
|
||||
c = (c+1) % buf.size();
|
||||
--full;
|
||||
cond.notify_all();
|
||||
return i;
|
||||
}
|
||||
|
||||
static buffer_t& get_buffer()
|
||||
{
|
||||
static buffer_t buf(2);
|
||||
return buf;
|
||||
}
|
||||
|
||||
static void do_sender_thread()
|
||||
{
|
||||
for (int n = 0; n < ITERS; ++n)
|
||||
{
|
||||
get_buffer().send(n);
|
||||
{
|
||||
boost::mutex::scoped_lock lock(io_mutex);
|
||||
std::cout << "sent: " << n << std::endl;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void do_receiver_thread()
|
||||
{
|
||||
int n;
|
||||
do
|
||||
{
|
||||
n = get_buffer().receive();
|
||||
{
|
||||
boost::mutex::scoped_lock lock(io_mutex);
|
||||
std::cout << "received: " << n << std::endl;
|
||||
}
|
||||
} while (n < ITERS - 1);
|
||||
}
|
||||
|
||||
private:
|
||||
M mutex;
|
||||
boost::condition cond;
|
||||
unsigned int p, c, full;
|
||||
std::vector<int> buf;
|
||||
};
|
||||
|
||||
template <typename M>
|
||||
void do_test(M* dummy=0)
|
||||
{
|
||||
typedef buffer_t<M> buffer_type;
|
||||
buffer_type::get_buffer();
|
||||
boost::thread thrd1(&buffer_type::do_sender_thread);
|
||||
boost::thread thrd2(&buffer_type::do_receiver_thread);
|
||||
thrd1.join();
|
||||
thrd2.join();
|
||||
}
|
||||
|
||||
void test_buffer()
|
||||
{
|
||||
do_test<boost::mutex>();
|
||||
do_test<boost::recursive_mutex>();
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_buffer();
|
||||
return 0;
|
||||
}
|
||||
171
example/starvephil/starvephil.cpp
Normal file
171
example/starvephil/starvephil.cpp
Normal file
@@ -0,0 +1,171 @@
|
||||
#include <boost/thread/mutex.hpp>
|
||||
#include <boost/thread/condition.hpp>
|
||||
#include <boost/thread/thread.hpp>
|
||||
#include <boost/thread/xtime.hpp>
|
||||
#include <iostream>
|
||||
#include <time.h>
|
||||
|
||||
namespace
|
||||
{
|
||||
boost::mutex iomx;
|
||||
};
|
||||
|
||||
class canteen
|
||||
{
|
||||
public:
|
||||
canteen() : m_chickens(0) { }
|
||||
|
||||
void get(int id)
|
||||
{
|
||||
boost::mutex::scoped_lock lock(m_mutex);
|
||||
while (m_chickens == 0)
|
||||
{
|
||||
{
|
||||
boost::mutex::scoped_lock lock(iomx);
|
||||
std::cout << "(" << clock() << ") Phil" << id <<
|
||||
": wot, no chickens? I'll WAIT ..." << std::endl;
|
||||
}
|
||||
m_condition.wait(lock);
|
||||
}
|
||||
{
|
||||
boost::mutex::scoped_lock lock(iomx);
|
||||
std::cout << "(" << clock() << ") Phil" << id <<
|
||||
": those chickens look good ... one please ..." << std::endl;
|
||||
}
|
||||
m_chickens--;
|
||||
}
|
||||
void put(int value)
|
||||
{
|
||||
boost::mutex::scoped_lock lock(m_mutex);
|
||||
{
|
||||
boost::mutex::scoped_lock lock(iomx);
|
||||
std::cout << "(" << clock() <<
|
||||
") Chef: ouch ... make room ... this dish is very hot ..." << std::endl;
|
||||
}
|
||||
boost::xtime xt;
|
||||
boost::xtime_get(&xt, boost::TIME_UTC);
|
||||
xt.sec += 3;
|
||||
boost::thread::sleep(xt);
|
||||
m_chickens += value;
|
||||
{
|
||||
boost::mutex::scoped_lock lock(iomx);
|
||||
std::cout << "(" << clock() <<
|
||||
") Chef: more chickens ... " << m_chickens <<
|
||||
" now available ... NOTIFYING ..." << std::endl;
|
||||
}
|
||||
m_condition.notify_all();
|
||||
}
|
||||
|
||||
private:
|
||||
boost::mutex m_mutex;
|
||||
boost::condition m_condition;
|
||||
int m_chickens;
|
||||
};
|
||||
|
||||
canteen g_canteen;
|
||||
|
||||
void chef()
|
||||
{
|
||||
const int chickens = 4;
|
||||
{
|
||||
boost::mutex::scoped_lock lock(iomx);
|
||||
std::cout << "(" << clock() << ") Chef: starting ..." << std::endl;
|
||||
}
|
||||
for (;;)
|
||||
{
|
||||
{
|
||||
boost::mutex::scoped_lock lock(iomx);
|
||||
std::cout << "(" << clock() << ") Chef: cooking ..." << std::endl;
|
||||
}
|
||||
boost::xtime xt;
|
||||
boost::xtime_get(&xt, boost::TIME_UTC);
|
||||
xt.sec += 2;
|
||||
boost::thread::sleep(xt);
|
||||
{
|
||||
boost::mutex::scoped_lock lock(iomx);
|
||||
std::cout << "(" << clock() << ") Chef: " << chickens
|
||||
<< " chickens, ready-to-go ..." << std::endl;
|
||||
}
|
||||
g_canteen.put(chickens);
|
||||
}
|
||||
}
|
||||
|
||||
struct phil
|
||||
{
|
||||
phil(int id) : m_id(id) { }
|
||||
void run() {
|
||||
{
|
||||
boost::mutex::scoped_lock lock(iomx);
|
||||
std::cout << "(" << clock() << ") Phil" << m_id << ": starting ..." << std::endl;
|
||||
}
|
||||
for (;;)
|
||||
{
|
||||
if (m_id > 0)
|
||||
{
|
||||
boost::xtime xt;
|
||||
boost::xtime_get(&xt, boost::TIME_UTC);
|
||||
xt.sec += 3;
|
||||
boost::thread::sleep(xt);
|
||||
}
|
||||
{
|
||||
boost::mutex::scoped_lock lock(iomx);
|
||||
std::cout << "(" << clock() << ") Phil" << m_id
|
||||
<< ": gotta eat ..." << std::endl;
|
||||
}
|
||||
g_canteen.get(m_id);
|
||||
{
|
||||
boost::mutex::scoped_lock lock(iomx);
|
||||
std::cout << "(" << clock() << ") Phil" << m_id
|
||||
<< ": mmm ... that's good ..." << std::endl;
|
||||
}
|
||||
}
|
||||
}
|
||||
static void do_thread(void* param) {
|
||||
static_cast<phil*>(param)->run();
|
||||
}
|
||||
|
||||
int m_id;
|
||||
};
|
||||
|
||||
struct thread_adapt
|
||||
{
|
||||
thread_adapt(void (*func)(void*), void* param) : _func(func), _param(param) { }
|
||||
int operator()() const
|
||||
{
|
||||
_func(_param);
|
||||
return 0;
|
||||
}
|
||||
|
||||
void (*_func)(void*);
|
||||
void* _param;
|
||||
};
|
||||
|
||||
class thread_adapter
|
||||
{
|
||||
public:
|
||||
thread_adapter(void (*func)(void*), void* param) : _func(func), _param(param) { }
|
||||
void operator()() const { _func(_param); }
|
||||
private:
|
||||
void (*_func)(void*);
|
||||
void* _param;
|
||||
};
|
||||
|
||||
int main(int argc, char* argv[])
|
||||
{
|
||||
boost::thread thrd_chef(&chef);
|
||||
phil p[] = { phil(0), phil(1), phil(2), phil(3), phil(4) };
|
||||
boost::thread thrd_phil0(thread_adapter(&phil::do_thread, &p[0]));
|
||||
boost::thread thrd_phil1(thread_adapter(&phil::do_thread, &p[1]));
|
||||
boost::thread thrd_phil2(thread_adapter(&phil::do_thread, &p[2]));
|
||||
boost::thread thrd_phil3(thread_adapter(&phil::do_thread, &p[3]));
|
||||
boost::thread thrd_phil4(thread_adapter(&phil::do_thread, &p[4]));
|
||||
|
||||
thrd_chef.join();
|
||||
thrd_phil0.join();
|
||||
thrd_phil1.join();
|
||||
thrd_phil2.join();
|
||||
thrd_phil3.join();
|
||||
thrd_phil4.join();
|
||||
|
||||
return 0;
|
||||
}
|
||||
121
example/tennis/tennis.cpp
Normal file
121
example/tennis/tennis.cpp
Normal file
@@ -0,0 +1,121 @@
|
||||
#include <boost/thread/mutex.hpp>
|
||||
#include <boost/thread/condition.hpp>
|
||||
#include <boost/thread/semaphore.hpp>
|
||||
#include <boost/thread/thread.hpp>
|
||||
#include <boost/thread/xtime.hpp>
|
||||
#include <iostream>
|
||||
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
# include <windows.h>
|
||||
# include <process.h>
|
||||
#endif
|
||||
|
||||
enum game_state
|
||||
{
|
||||
START,
|
||||
PLAYER_A,
|
||||
PLAYER_B,
|
||||
GAME_OVER,
|
||||
ONE_PLAYER_GONE,
|
||||
BOTH_PLAYERS_GONE
|
||||
};
|
||||
|
||||
int state;
|
||||
boost::mutex mutex;
|
||||
boost::condition cond;
|
||||
|
||||
char* player_name(int state)
|
||||
{
|
||||
if (state == PLAYER_A)
|
||||
return "PLAYER-A";
|
||||
if (state == PLAYER_B)
|
||||
return "PLAYER-B";
|
||||
throw "bad player";
|
||||
return 0;
|
||||
}
|
||||
|
||||
void player(void* param)
|
||||
{
|
||||
boost::mutex::scoped_lock lock(mutex);
|
||||
|
||||
int active = (int)param;
|
||||
int other = active == PLAYER_A ? PLAYER_B : PLAYER_A;
|
||||
|
||||
while (state < GAME_OVER)
|
||||
{
|
||||
std::cout << player_name(active) << ": Play." << std::endl;
|
||||
state = other;
|
||||
cond.notify_all();
|
||||
do
|
||||
{
|
||||
cond.wait(lock);
|
||||
if (state == other)
|
||||
std::cout << "---" << player_name(active) << ": Spurious wakeup!" << std::endl;
|
||||
} while (state == other);
|
||||
}
|
||||
|
||||
++state;
|
||||
std::cout << player_name(active) << ": Gone." << std::endl;
|
||||
cond.notify_all();
|
||||
}
|
||||
|
||||
struct thread_adapt
|
||||
{
|
||||
thread_adapt(void (*func)(void*), void* param) : _func(func), _param(param) { }
|
||||
int operator()() const
|
||||
{
|
||||
_func(_param);
|
||||
return 0;
|
||||
}
|
||||
|
||||
void (*_func)(void*);
|
||||
void* _param;
|
||||
};
|
||||
|
||||
class thread_adapter
|
||||
{
|
||||
public:
|
||||
thread_adapter(void (*func)(void*), void* param) : _func(func), _param(param) { }
|
||||
void operator()() const { _func(_param); }
|
||||
private:
|
||||
void (*_func)(void*);
|
||||
void* _param;
|
||||
};
|
||||
|
||||
int main(int argc, char* argv[])
|
||||
{
|
||||
state = START;
|
||||
|
||||
boost::thread thrda(thread_adapter(&player, (void*)PLAYER_A));
|
||||
boost::thread thrdb(thread_adapter(&player, (void*)PLAYER_B));
|
||||
|
||||
boost::xtime xt;
|
||||
boost::xtime_get(&xt, boost::TIME_UTC);
|
||||
xt.sec += 1;
|
||||
boost::thread::sleep(xt);
|
||||
{
|
||||
boost::mutex::scoped_lock lock(mutex);
|
||||
std::cout << "---Noise ON..." << std::endl;
|
||||
}
|
||||
|
||||
for (int i = 0; i < 1000000; ++i)
|
||||
cond.notify_all();
|
||||
|
||||
{
|
||||
boost::mutex::scoped_lock lock(mutex);
|
||||
std::cout << "---Noise OFF..." << std::endl;
|
||||
state = GAME_OVER;
|
||||
cond.notify_all();
|
||||
do
|
||||
{
|
||||
cond.wait(lock);
|
||||
} while (state != BOTH_PLAYERS_GONE);
|
||||
}
|
||||
|
||||
std::cout << "GAME OVER" << std::endl;
|
||||
|
||||
thrda.join();
|
||||
thrdb.join();
|
||||
|
||||
return 0;
|
||||
}
|
||||
156
include/boost/thread/condition.hpp
Normal file
156
include/boost/thread/condition.hpp
Normal file
@@ -0,0 +1,156 @@
|
||||
// Copyright (C) 2001
|
||||
// William E. Kempf
|
||||
//
|
||||
// Permission to use, copy, modify, distribute and sell this software
|
||||
// and its documentation for any purpose is hereby granted without fee,
|
||||
// provided that the above copyright notice appear in all copies and
|
||||
// that both that copyright notice and this permission notice appear
|
||||
// in supporting documentation. William E. Kempf makes no representations
|
||||
// about the suitability of this software for any purpose.
|
||||
// It is provided "as is" without express or implied warranty.
|
||||
|
||||
#ifndef BOOST_CONDITION_WEK070601_HPP
|
||||
#define BOOST_CONDITION_WEK070601_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#ifndef BOOST_HAS_THREADS
|
||||
# error Thread support is unavailable!
|
||||
#endif
|
||||
|
||||
#include <boost/thread/exceptions.hpp>
|
||||
#include <boost/utility.hpp>
|
||||
|
||||
#if defined(BOOST_HAS_PTHREADS)
|
||||
# include <pthread.h>
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
|
||||
struct xtime;
|
||||
|
||||
class condition : private noncopyable
|
||||
{
|
||||
public:
|
||||
condition();
|
||||
~condition();
|
||||
|
||||
void notify_one();
|
||||
void notify_all();
|
||||
|
||||
template <typename L>
|
||||
void wait(L& lock)
|
||||
{
|
||||
if (!lock)
|
||||
throw lock_error();
|
||||
|
||||
do_wait(lock.m_mutex);
|
||||
}
|
||||
|
||||
template <typename L, typename Pr>
|
||||
void wait(L& lock, Pr pred)
|
||||
{
|
||||
if (!lock)
|
||||
throw lock_error();
|
||||
|
||||
while (!pred())
|
||||
do_wait(lock.m_mutex);
|
||||
}
|
||||
|
||||
template <typename L>
|
||||
bool timed_wait(L& lock, const xtime& xt)
|
||||
{
|
||||
if (!lock)
|
||||
throw lock_error();
|
||||
|
||||
return do_timed_wait(lock.m_mutex, xt);
|
||||
}
|
||||
|
||||
template <typename L, typename Pr>
|
||||
bool timed_wait(L& lock, const xtime& xt, Pr pred)
|
||||
{
|
||||
if (!lock)
|
||||
throw lock_error();
|
||||
|
||||
while (!pred())
|
||||
{
|
||||
if (!do_timed_wait(lock.m_mutex, xt))
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
private:
|
||||
template <typename M>
|
||||
void do_wait(M& mutex)
|
||||
{
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
enter_wait();
|
||||
#endif
|
||||
|
||||
typename M::cv_state state;
|
||||
mutex.do_unlock(state);
|
||||
|
||||
#if defined(BOOST_HAS_PTHREADS)
|
||||
do_wait(state.pmutex);
|
||||
#elif defined(BOOST_HAS_WINTHREADS)
|
||||
do_wait();
|
||||
#endif
|
||||
|
||||
mutex.do_lock(state);
|
||||
}
|
||||
|
||||
template <typename M>
|
||||
bool do_timed_wait(M& mutex, const xtime& xt)
|
||||
{
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
enter_wait();
|
||||
#endif
|
||||
|
||||
typename M::cv_state state;
|
||||
mutex.do_unlock(state);
|
||||
|
||||
bool ret = false;
|
||||
|
||||
#if defined(BOOST_HAS_PTHREADS)
|
||||
ret = do_timed_wait(xt, state.pmutex);
|
||||
#elif defined(BOOST_HAS_WINTHREADS)
|
||||
ret = do_timed_wait(xt);
|
||||
#endif
|
||||
|
||||
mutex.do_lock(state);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
void enter_wait();
|
||||
void do_wait();
|
||||
bool do_timed_wait(const xtime& xt);
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
void do_wait(pthread_mutex_t* pmutex);
|
||||
bool do_timed_wait(const xtime& xt, pthread_mutex_t* pmutex);
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
unsigned long m_gate;
|
||||
unsigned long m_queue;
|
||||
unsigned long m_mutex;
|
||||
unsigned m_gone; // # threads that timed out and never made it to the m_queue
|
||||
unsigned long m_blocked; // # threads m_blocked m_waiting for the condition
|
||||
unsigned m_waiting; // # threads m_waiting no longer m_waiting for the condition but still
|
||||
// m_waiting to be removed from the m_queue
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
pthread_cond_t m_condition;
|
||||
#endif
|
||||
};
|
||||
|
||||
} // namespace boost
|
||||
|
||||
// Change Log:
|
||||
// 8 Feb 01 WEKEMPF Initial version.
|
||||
// 22 May 01 WEKEMPF Modified to use xtime for time outs.
|
||||
// 23 May 01 WEKEMPF Removed "duration" timed_waits, as they are too difficult
|
||||
// to use with spurious wakeups.
|
||||
|
||||
#endif // BOOST_CONDITION_WEK070601_HPP
|
||||
100
include/boost/thread/config.hpp
Normal file
100
include/boost/thread/config.hpp
Normal file
@@ -0,0 +1,100 @@
|
||||
// Copyright (C) 2001
|
||||
// William E. Kempf
|
||||
//
|
||||
// Permission to use, copy, modify, distribute and sell this software
|
||||
// and its documentation for any purpose is hereby granted without fee,
|
||||
// provided that the above copyright notice appear in all copies and
|
||||
// that both that copyright notice and this permission notice appear
|
||||
// in supporting documentation. William E. Kempf makes no representations
|
||||
// about the suitability of this software for any purpose.
|
||||
// It is provided "as is" without express or implied warranty.
|
||||
|
||||
// This file is used to configure Boost.Threads during development
|
||||
// in order to decouple dependency on any Boost release. Once
|
||||
// accepted into Boost these contents will be moved to <boost/config>
|
||||
// or some other appropriate build configuration and all
|
||||
// #include <boost/thread/config.hpp> statements will be changed
|
||||
// accordingly.
|
||||
|
||||
#ifndef BOOST_THREAD_CONFIG_WEK070601_HPP
|
||||
#define BOOST_THREAD_CONFIG_WEK070601_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#error "Included <boost/thread/config.hpp>"
|
||||
|
||||
/*// Define if threading support is enabled for the toolset.
|
||||
#undef BOOST_HAS_THREADS
|
||||
|
||||
// Define if threading should be implemented in terms of Win32 threads.
|
||||
#undef BOOST_HAS_WINTHREADS
|
||||
|
||||
// Define if threading should be implemented in terms of POSIX threads.
|
||||
#undef BOOST_HAS_PTHREADS
|
||||
|
||||
// Define if BOOST_HAS_PTHREADS and pthread_delay_np() exists.
|
||||
#undef BOOST_HAS_PTHREAD_DELAY_NP
|
||||
|
||||
// Define if BOOST_HAS_PTHREADS and not BOOST_HAS_PTHREAD_DELAY_NP
|
||||
// but nanosleep can be used instead.
|
||||
#undef BOOST_HAS_NANOSLEEP
|
||||
|
||||
// Define if BOOST_HAS_PTHREADS and pthread_yield() exists.
|
||||
#undef BOOST_HAS_PTHREAD_YIELD
|
||||
|
||||
// Define if BOOST_HAS_PTHREADS and not BOOST_HAS_PTHREAD_YIELD and
|
||||
// sched_yield() exists.
|
||||
#undef BOOST_HAS_SCHED_YIELD
|
||||
|
||||
// Define if gettimeofday() exists.
|
||||
#undef BOOST_HAS_GETTIMEOFDAY
|
||||
|
||||
// Define if not BOOST_HAS_GETTIMEOFDAY and clock_gettime() exists.
|
||||
#undef BOOST_HAS_CLOCK_GETTIME
|
||||
|
||||
// Define if not BOOST_HAS_GETTIMEOFDAY and not BOOST_HAS_CLOCK_GETTIME and
|
||||
// GetSystemTimeAsFileTime() can be called with an FTIME structure.
|
||||
#undef BOOST_HAS_FTIME
|
||||
|
||||
// Define if pthread_mutexattr_settype and pthread_mutexattr_gettype exist.
|
||||
#undef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
|
||||
|
||||
// Here we'll set up known compiler options.
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
# if defined(_MT)
|
||||
# define BOOST_HAS_THREADS
|
||||
# endif
|
||||
# define BOOST_HAS_WINTHREADS // comment out this to test pthreads-win32.
|
||||
# if !defined(BOOST_HAS_WINTHREADS)
|
||||
# define BOOST_HAS_PTHREADS
|
||||
# define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
|
||||
# define PtW32NoCatchWarn
|
||||
# pragma comment(lib, "pthreadVCE.lib")
|
||||
# endif
|
||||
# define BOOST_HAS_FTIME
|
||||
// pdm: this is for linux - is there a better #define to #if on?
|
||||
// wek: not sure how else to do this, but GNU CC on Win32 should probably
|
||||
// use BOOST_HAS_WINTHREADS, and I expect there will be other
|
||||
// platform specific variations for this compiler toolset. Need
|
||||
// to decide how to handle this.
|
||||
#elif defined( __GNUC__ )
|
||||
# define BOOST_HAS_THREADS
|
||||
# define BOOST_HAS_PTHREADS
|
||||
# define BOOST_HAS_NANOSLEEP
|
||||
# define BOOST_HAS_GETTIMEOFDAY
|
||||
// pdm: From the pthread.h header, one of these macros
|
||||
// must be defined for this stuff to exist.
|
||||
// wek: This seems like a harmless enough method to determine these
|
||||
// switches, but one should note that some implementations may not
|
||||
// use these. Notably, pthreads-win32 doesn't define either
|
||||
// __USE_UNIX98 or __USE_GNU.
|
||||
# if defined( __USE_UNIX98 )
|
||||
# define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
|
||||
# elif defined( __USE_GNU )
|
||||
# define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
|
||||
# define BOOST_HAS_PTHREAD_YIELD
|
||||
# endif
|
||||
#endif*/
|
||||
|
||||
#endif // BOOST_THREAD_CONFIG_WEK070601_HPP
|
||||
172
include/boost/thread/detail/lock.hpp
Normal file
172
include/boost/thread/detail/lock.hpp
Normal file
@@ -0,0 +1,172 @@
|
||||
// Copyright (C) 2001
|
||||
// William E. Kempf
|
||||
//
|
||||
// Permission to use, copy, modify, distribute and sell this software
|
||||
// and its documentation for any purpose is hereby granted without fee,
|
||||
// provided that the above copyright notice appear in all copies and
|
||||
// that both that copyright notice and this permission notice appear
|
||||
// in supporting documentation. William E. Kempf makes no representations
|
||||
// about the suitability of this software for any purpose.
|
||||
// It is provided "as is" without express or implied warranty.
|
||||
|
||||
#ifndef BOOST_XLOCK_WEK070601_HPP
|
||||
#define BOOST_XLOCK_WEK070601_HPP
|
||||
|
||||
#include <boost/utility.hpp>
|
||||
#include <boost/thread/exceptions.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
class condition;
|
||||
struct xtime;
|
||||
|
||||
namespace detail { namespace thread {
|
||||
|
||||
template <typename Mutex>
|
||||
class scoped_lock : private noncopyable
|
||||
{
|
||||
public:
|
||||
typedef Mutex mutex_type;
|
||||
|
||||
explicit scoped_lock(Mutex& mx, bool initially_locked=true)
|
||||
: m_mutex(mx), m_locked(false)
|
||||
{
|
||||
if (initially_locked) lock();
|
||||
}
|
||||
~scoped_lock()
|
||||
{
|
||||
if (m_locked) unlock();
|
||||
}
|
||||
|
||||
void lock()
|
||||
{
|
||||
if (m_locked) throw lock_error();
|
||||
m_mutex.do_lock();
|
||||
m_locked = true;
|
||||
}
|
||||
void unlock()
|
||||
{
|
||||
if (!m_locked) throw lock_error();
|
||||
m_mutex.do_unlock();
|
||||
m_locked = false;
|
||||
}
|
||||
|
||||
bool locked() const { return m_locked; }
|
||||
operator const void*() const { return m_locked ? this : 0; }
|
||||
|
||||
private:
|
||||
friend class boost::condition;
|
||||
|
||||
Mutex& m_mutex;
|
||||
bool m_locked;
|
||||
};
|
||||
|
||||
template <typename TryMutex>
|
||||
class scoped_try_lock : private noncopyable
|
||||
{
|
||||
public:
|
||||
typedef TryMutex mutex_type;
|
||||
|
||||
explicit scoped_try_lock(TryMutex& mx)
|
||||
: m_mutex(mx), m_locked(false)
|
||||
{
|
||||
try_lock();
|
||||
}
|
||||
scoped_try_lock(TryMutex& mx, bool initially_locked)
|
||||
: m_mutex(mx), m_locked(false)
|
||||
{
|
||||
if (initially_locked) lock();
|
||||
}
|
||||
~scoped_try_lock()
|
||||
{
|
||||
if (m_locked) unlock();
|
||||
}
|
||||
|
||||
void lock()
|
||||
{
|
||||
if (m_locked) throw lock_error();
|
||||
m_mutex.do_lock();
|
||||
m_locked = true;
|
||||
}
|
||||
bool try_lock()
|
||||
{
|
||||
if (m_locked) throw lock_error();
|
||||
return (m_locked = m_mutex.do_trylock());
|
||||
}
|
||||
void unlock()
|
||||
{
|
||||
if (!m_locked) throw lock_error();
|
||||
m_mutex.do_unlock();
|
||||
m_locked = false;
|
||||
}
|
||||
|
||||
bool locked() const { return m_locked; }
|
||||
operator const void*() const { return m_locked ? this : 0; }
|
||||
|
||||
private:
|
||||
friend class boost::condition;
|
||||
|
||||
TryMutex& m_mutex;
|
||||
bool m_locked;
|
||||
};
|
||||
|
||||
template <typename TimedMutex>
|
||||
class scoped_timed_lock : private noncopyable
|
||||
{
|
||||
public:
|
||||
typedef TimedMutex mutex_type;
|
||||
|
||||
scoped_timed_lock(TimedMutex& mx, const xtime& xt)
|
||||
: m_mutex(mx), m_locked(false)
|
||||
{
|
||||
timed_lock(xt);
|
||||
}
|
||||
scoped_timed_lock(TimedMutex& mx, bool initially_locked)
|
||||
: m_mutex(mx), m_locked(false)
|
||||
{
|
||||
if (initially_locked) lock();
|
||||
}
|
||||
~scoped_timed_lock()
|
||||
{
|
||||
if (m_locked) unlock();
|
||||
}
|
||||
|
||||
void lock()
|
||||
{
|
||||
if (m_locked) throw lock_error();
|
||||
m_mutex.do_lock();
|
||||
m_locked = true;
|
||||
}
|
||||
bool timed_lock(const xtime& xt)
|
||||
{
|
||||
if (m_locked) throw lock_error();
|
||||
return (m_locked = m_mutex.do_timedlock(xt));
|
||||
}
|
||||
void unlock()
|
||||
{
|
||||
if (!m_locked) throw lock_error();
|
||||
m_mutex.do_unlock();
|
||||
m_locked = false;
|
||||
}
|
||||
|
||||
bool locked() const { return m_locked; }
|
||||
operator const void*() const { return m_locked ? this : 0; }
|
||||
|
||||
private:
|
||||
friend class boost::condition;
|
||||
|
||||
TimedMutex& m_mutex;
|
||||
bool m_locked;
|
||||
};
|
||||
|
||||
} // namespace thread
|
||||
} // namespace detail
|
||||
} // namespace boost
|
||||
|
||||
// Change Log:
|
||||
// 8 Feb 01 WEKEMPF Initial version.
|
||||
// 22 May 01 WEKEMPF Modified to use xtime for time outs.
|
||||
// 30 Jul 01 WEKEMPF Moved lock types into boost::detail::thread. Renamed some types.
|
||||
// Added locked() methods.
|
||||
|
||||
#endif // BOOST_XLOCK_WEK070601_HPP
|
||||
46
include/boost/thread/exceptions.hpp
Normal file
46
include/boost/thread/exceptions.hpp
Normal file
@@ -0,0 +1,46 @@
|
||||
// Copyright (C) 2001
|
||||
// William E. Kempf
|
||||
//
|
||||
// Permission to use, copy, modify, distribute and sell this software
|
||||
// and its documentation for any purpose is hereby granted without fee,
|
||||
// provided that the above copyright notice appear in all copies and
|
||||
// that both that copyright notice and this permission notice appear
|
||||
// in supporting documentation. William E. Kempf makes no representations
|
||||
// about the suitability of this software for any purpose.
|
||||
// It is provided "as is" without express or implied warranty.
|
||||
|
||||
// This file is used to configure Boost.Threads during development
|
||||
// in order to decouple dependency on any Boost release. Once
|
||||
// accepted into Boost these contents will be moved to <boost/config>
|
||||
// or some other appropriate build configuration and all
|
||||
// #include <boost/thread/config.hpp> statements will be changed
|
||||
// accordingly.
|
||||
|
||||
#ifndef BOOST_THREAD_EXCEPTIONS_PDM070801_H
|
||||
#define BOOST_THREAD_EXCEPTIONS_PDM070801_H
|
||||
|
||||
// pdm: Sorry, but this class is used all over the place & I end up
|
||||
// with recursive headers if I don't separate it
|
||||
// wek: Not sure why recursive headers would cause compilation problems
|
||||
// given the include guards, but regardless it makes sense to
|
||||
// seperate this out any way.
|
||||
|
||||
#include <stdexcept>
|
||||
|
||||
namespace boost {
|
||||
|
||||
class lock_error : public std::runtime_error
|
||||
{
|
||||
public:
|
||||
lock_error() : std::runtime_error("thread lock error") { }
|
||||
};
|
||||
|
||||
class thread_resource_error : public std::runtime_error
|
||||
{
|
||||
public:
|
||||
thread_resource_error() : std::runtime_error("thread resource error") { }
|
||||
};
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_THREAD_CONFIG_PDM070801_H
|
||||
146
include/boost/thread/mutex.hpp
Normal file
146
include/boost/thread/mutex.hpp
Normal file
@@ -0,0 +1,146 @@
|
||||
// Copyright (C) 2001
|
||||
// William E. Kempf
|
||||
//
|
||||
// Permission to use, copy, modify, distribute and sell this software
|
||||
// and its documentation for any purpose is hereby granted without fee,
|
||||
// provided that the above copyright notice appear in all copies and
|
||||
// that both that copyright notice and this permission notice appear
|
||||
// in supporting documentation. William E. Kempf makes no representations
|
||||
// about the suitability of this software for any purpose.
|
||||
// It is provided "as is" without express or implied warranty.
|
||||
|
||||
#ifndef BOOST_MUTEX_WEK070601_HPP
|
||||
#define BOOST_MUTEX_WEK070601_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#ifndef BOOST_HAS_THREADS
|
||||
# error Thread support is unavailable!
|
||||
#endif
|
||||
|
||||
#include <boost/utility.hpp>
|
||||
#include <boost/thread/detail/lock.hpp>
|
||||
|
||||
#if defined(BOOST_HAS_PTHREADS)
|
||||
# include <pthread.h>
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
|
||||
class condition;
|
||||
struct xtime;
|
||||
|
||||
class mutex : private noncopyable
|
||||
{
|
||||
public:
|
||||
friend class detail::thread::scoped_lock<mutex>;
|
||||
friend class condition;
|
||||
|
||||
typedef detail::thread::scoped_lock<mutex> scoped_lock;
|
||||
|
||||
mutex();
|
||||
~mutex();
|
||||
|
||||
private:
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
typedef void* cv_state;
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
struct cv_state
|
||||
{
|
||||
pthread_mutex_t* pmutex;
|
||||
};
|
||||
#endif
|
||||
void do_lock();
|
||||
void do_unlock();
|
||||
void do_lock(cv_state& state);
|
||||
void do_unlock(cv_state& state);
|
||||
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
unsigned long m_mutex;
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
pthread_mutex_t m_mutex;
|
||||
#endif
|
||||
};
|
||||
|
||||
class try_mutex : private noncopyable
|
||||
{
|
||||
public:
|
||||
friend class detail::thread::scoped_lock<try_mutex>;
|
||||
friend class detail::thread::scoped_try_lock<try_mutex>;
|
||||
friend class condition;
|
||||
|
||||
typedef detail::thread::scoped_lock<try_mutex> scoped_lock;
|
||||
typedef detail::thread::scoped_try_lock<try_mutex> scoped_try_lock;
|
||||
|
||||
try_mutex();
|
||||
~try_mutex();
|
||||
|
||||
private:
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
typedef void* cv_state;
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
struct cv_state
|
||||
{
|
||||
pthread_mutex_t* pmutex;
|
||||
};
|
||||
#endif
|
||||
void do_lock();
|
||||
bool do_trylock();
|
||||
void do_unlock();
|
||||
void do_lock(cv_state& state);
|
||||
void do_unlock(cv_state& state);
|
||||
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
unsigned long m_mutex;
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
pthread_mutex_t m_mutex;
|
||||
#endif
|
||||
};
|
||||
|
||||
class timed_mutex : private noncopyable
|
||||
{
|
||||
public:
|
||||
friend class detail::thread::scoped_lock<timed_mutex>;
|
||||
friend class detail::thread::scoped_try_lock<timed_mutex>;
|
||||
friend class detail::thread::scoped_timed_lock<timed_mutex>;
|
||||
friend class condition;
|
||||
|
||||
typedef detail::thread::scoped_lock<timed_mutex> scoped_lock;
|
||||
typedef detail::thread::scoped_try_lock<timed_mutex> scoped_try_lock;
|
||||
typedef detail::thread::scoped_timed_lock<timed_mutex> scoped_timed_lock;
|
||||
|
||||
timed_mutex();
|
||||
~timed_mutex();
|
||||
|
||||
private:
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
typedef void* cv_state;
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
struct cv_state
|
||||
{
|
||||
pthread_mutex_t* pmutex;
|
||||
};
|
||||
#endif
|
||||
void do_lock();
|
||||
bool do_trylock();
|
||||
bool do_timedlock(const xtime& xt);
|
||||
void do_unlock();
|
||||
void do_lock(cv_state& state);
|
||||
void do_unlock(cv_state& state);
|
||||
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
unsigned long m_mutex;
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
pthread_mutex_t m_mutex;
|
||||
pthread_cond_t m_condition;
|
||||
bool m_locked;
|
||||
#endif
|
||||
};
|
||||
|
||||
} // namespace boost
|
||||
|
||||
// Change Log:
|
||||
// 8 Feb 01 WEKEMPF Initial version.
|
||||
// 22 May 01 WEKEMPF Modified to use xtime for time outs. Factored out
|
||||
// to three classes, mutex, try_mutex and timed_mutex.
|
||||
|
||||
#endif // BOOST_MUTEX_WEK070601_HPP
|
||||
45
include/boost/thread/once.hpp
Normal file
45
include/boost/thread/once.hpp
Normal file
@@ -0,0 +1,45 @@
|
||||
// Copyright (C) 2001
|
||||
// William E. Kempf
|
||||
//
|
||||
// Permission to use, copy, modify, distribute and sell this software
|
||||
// and its documentation for any purpose is hereby granted without fee,
|
||||
// provided that the above copyright notice appear in all copies and
|
||||
// that both that copyright notice and this permission notice appear
|
||||
// in supporting documentation. William E. Kempf makes no representations
|
||||
// about the suitability of this software for any purpose.
|
||||
// It is provided "as is" without express or implied warranty.
|
||||
|
||||
#ifndef BOOST_ONCE_WEK080101_HPP
|
||||
#define BOOST_ONCE_WEK080101_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#ifndef BOOST_HAS_THREADS
|
||||
# error Thread support is unavailable!
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_HAS_PTHREADS)
|
||||
# include <pthread.h>
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
|
||||
#if defined(BOOST_HAS_PTHREADS)
|
||||
|
||||
typedef pthread_once_t once_flag;
|
||||
const once_flag once_init = PTHREAD_ONCE_INIT;
|
||||
|
||||
#elif defined(BOOST_HAS_WINTHREADS)
|
||||
|
||||
typedef bool once_flag;
|
||||
const once_flag once_init = false;
|
||||
|
||||
#endif
|
||||
|
||||
void call_once(void (*func)(), once_flag& flag);
|
||||
|
||||
} // namespace boost
|
||||
|
||||
// Change Log:
|
||||
// 1 Aug 01 WEKEMPF Initial version.
|
||||
|
||||
#endif // BOOST_ONCE_WEK080101_HPP
|
||||
167
include/boost/thread/recursive_mutex.hpp
Normal file
167
include/boost/thread/recursive_mutex.hpp
Normal file
@@ -0,0 +1,167 @@
|
||||
// Copyright (C) 2001
|
||||
// William E. Kempf
|
||||
//
|
||||
// Permission to use, copy, modify, distribute and sell this software
|
||||
// and its documentation for any purpose is hereby granted without fee,
|
||||
// provided that the above copyright notice appear in all copies and
|
||||
// that both that copyright notice and this permission notice appear
|
||||
// in supporting documentation. William E. Kempf makes no representations
|
||||
// about the suitability of this software for any purpose.
|
||||
// It is provided "as is" without express or implied warranty.
|
||||
|
||||
#ifndef BOOST_RECURSIVE_MUTEX_WEK070601_HPP
|
||||
#define BOOST_RECURSIVE_MUTEX_WEK070601_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#ifndef BOOST_HAS_THREADS
|
||||
# error Thread support is unavailable!
|
||||
#endif
|
||||
|
||||
#include <boost/utility.hpp>
|
||||
#include <boost/thread/detail/lock.hpp>
|
||||
|
||||
#if defined(BOOST_HAS_PTHREADS)
|
||||
# include <pthread.h>
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
|
||||
class condition;
|
||||
struct xtime;
|
||||
|
||||
class recursive_mutex : private noncopyable
|
||||
{
|
||||
public:
|
||||
friend class detail::thread::scoped_lock<recursive_mutex>;
|
||||
friend class condition;
|
||||
|
||||
typedef detail::thread::scoped_lock<recursive_mutex> scoped_lock;
|
||||
|
||||
recursive_mutex();
|
||||
~recursive_mutex();
|
||||
|
||||
private:
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
typedef std::size_t cv_state;
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
struct cv_state
|
||||
{
|
||||
long count;
|
||||
pthread_mutex_t* pmutex;
|
||||
};
|
||||
#endif
|
||||
void do_lock();
|
||||
void do_unlock();
|
||||
void do_lock(cv_state& state);
|
||||
void do_unlock(cv_state& state);
|
||||
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
unsigned long m_mutex;
|
||||
unsigned long m_count;
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
pthread_mutex_t m_mutex;
|
||||
unsigned m_count;
|
||||
# if !defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
|
||||
pthread_cond_t m_unlocked;
|
||||
pthread_t m_thread_id;
|
||||
bool m_valid_id;
|
||||
# endif
|
||||
#endif
|
||||
};
|
||||
|
||||
class recursive_try_mutex : private noncopyable
|
||||
{
|
||||
public:
|
||||
friend class detail::thread::scoped_lock<recursive_try_mutex>;
|
||||
friend class detail::thread::scoped_try_lock<recursive_try_mutex>;
|
||||
friend class condition;
|
||||
|
||||
typedef detail::thread::scoped_lock<recursive_try_mutex> scoped_lock;
|
||||
typedef detail::thread::scoped_try_lock<recursive_try_mutex> scoped_try_lock;
|
||||
|
||||
recursive_try_mutex();
|
||||
~recursive_try_mutex();
|
||||
|
||||
private:
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
typedef std::size_t cv_state;
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
struct cv_state
|
||||
{
|
||||
long count;
|
||||
pthread_mutex_t* pmutex;
|
||||
};
|
||||
#endif
|
||||
void do_lock();
|
||||
bool do_trylock();
|
||||
void do_unlock();
|
||||
void do_lock(cv_state& state);
|
||||
void do_unlock(cv_state& state);
|
||||
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
unsigned long m_mutex;
|
||||
unsigned long m_count;
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
pthread_mutex_t m_mutex;
|
||||
unsigned m_count;
|
||||
# if !defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
|
||||
pthread_cond_t m_unlocked;
|
||||
pthread_t m_thread_id;
|
||||
bool m_valid_id;
|
||||
# endif
|
||||
#endif
|
||||
};
|
||||
|
||||
class recursive_timed_mutex : private noncopyable
|
||||
{
|
||||
public:
|
||||
friend class detail::thread::scoped_lock<recursive_timed_mutex>;
|
||||
friend class detail::thread::scoped_try_lock<recursive_timed_mutex>;
|
||||
friend class detail::thread::scoped_timed_lock<recursive_timed_mutex>;
|
||||
friend class condition;
|
||||
|
||||
typedef detail::thread::scoped_lock<recursive_timed_mutex> scoped_lock;
|
||||
typedef detail::thread::scoped_try_lock<recursive_timed_mutex> scoped_try_lock;
|
||||
typedef detail::thread::scoped_timed_lock<recursive_timed_mutex> scoped_timed_lock;
|
||||
|
||||
recursive_timed_mutex();
|
||||
~recursive_timed_mutex();
|
||||
|
||||
private:
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
typedef std::size_t cv_state;
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
struct cv_state
|
||||
{
|
||||
long count;
|
||||
pthread_mutex_t* pmutex;
|
||||
};
|
||||
#endif
|
||||
void do_lock();
|
||||
bool do_trylock();
|
||||
bool do_timedlock(const xtime& xt);
|
||||
void do_unlock();
|
||||
void do_lock(cv_state& state);
|
||||
void do_unlock(cv_state& state);
|
||||
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
unsigned long m_mutex;
|
||||
unsigned long m_count;
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
pthread_mutex_t m_mutex;
|
||||
pthread_cond_t m_unlocked;
|
||||
pthread_t m_thread_id;
|
||||
bool m_valid_id;
|
||||
unsigned m_count;
|
||||
#endif
|
||||
};
|
||||
|
||||
} // namespace boost
|
||||
|
||||
// Change Log:
|
||||
// 8 Feb 01 WEKEMPF Initial version.
|
||||
// 1 Jun 01 WEKEMPF Modified to use xtime for time outs. Factored out
|
||||
// to three classes, mutex, try_mutex and timed_mutex.
|
||||
// 11 Jun 01 WEKEMPF Modified to use PTHREAD_MUTEX_RECURSIVE if available.
|
||||
|
||||
#endif // BOOST_RECURSIVE_MUTEX_WEK070601_HPP
|
||||
57
include/boost/thread/semaphore.hpp
Normal file
57
include/boost/thread/semaphore.hpp
Normal file
@@ -0,0 +1,57 @@
|
||||
// Copyright (C) 2001
|
||||
// William E. Kempf
|
||||
//
|
||||
// Permission to use, copy, modify, distribute and sell this software
|
||||
// and its documentation for any purpose is hereby granted without fee,
|
||||
// provided that the above copyright notice appear in all copies and
|
||||
// that both that copyright notice and this permission notice appear
|
||||
// in supporting documentation. William E. Kempf makes no representations
|
||||
// about the suitability of this software for any purpose.
|
||||
// It is provided "as is" without express or implied warranty.
|
||||
|
||||
#ifndef BOOST_SEMAPHORE_WEK070601_HPP
|
||||
#define BOOST_SEMAPHORE_WEK070601_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#ifndef BOOST_HAS_THREADS
|
||||
# error Thread support is unavailable!
|
||||
#endif
|
||||
|
||||
#include <boost/utility.hpp>
|
||||
|
||||
#if defined(BOOST_HAS_PTHREADS)
|
||||
# include <pthread.h>
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
|
||||
struct xtime;
|
||||
|
||||
class semaphore : private noncopyable
|
||||
{
|
||||
public:
|
||||
explicit semaphore(unsigned count=0, unsigned max=0);
|
||||
~semaphore();
|
||||
|
||||
bool up(unsigned count=1, unsigned* prev=0);
|
||||
void down();
|
||||
bool down(const xtime& xt);
|
||||
|
||||
private:
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
unsigned long m_sema;
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
pthread_mutex_t m_mutex;
|
||||
pthread_cond_t m_condition;
|
||||
unsigned m_available;
|
||||
unsigned m_max;
|
||||
#endif
|
||||
};
|
||||
|
||||
} // namespace boost
|
||||
|
||||
// Change Log:
|
||||
// 8 Feb 01 WEKEMPF Initial version.
|
||||
// 22 May 01 WEKEMPF Modified to use xtime for time outs.
|
||||
|
||||
#endif // BOOST_SEMAPHORE_WEK070601_HPP
|
||||
84
include/boost/thread/thread.hpp
Normal file
84
include/boost/thread/thread.hpp
Normal file
@@ -0,0 +1,84 @@
|
||||
// Copyright (C) 2001
|
||||
// William E. Kempf
|
||||
//
|
||||
// Permission to use, copy, modify, distribute and sell this software
|
||||
// and its documentation for any purpose is hereby granted without fee,
|
||||
// provided that the above copyright notice appear in all copies and
|
||||
// that both that copyright notice and this permission notice appear
|
||||
// in supporting documentation. William E. Kempf makes no representations
|
||||
// about the suitability of this software for any purpose.
|
||||
// It is provided "as is" without express or implied warranty.
|
||||
|
||||
#ifndef BOOST_THREAD_WEK070601_HPP
|
||||
#define BOOST_THREAD_WEK070601_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#ifndef BOOST_HAS_THREADS
|
||||
# error Thread support is unavailable!
|
||||
#endif
|
||||
|
||||
#include <boost/utility.hpp>
|
||||
#include <boost/function.hpp>
|
||||
#include <boost/thread/mutex.hpp>
|
||||
#include <list>
|
||||
#include <memory>
|
||||
|
||||
#if defined(BOOST_HAS_PTHREADS)
|
||||
# include <pthread.h>
|
||||
# include <boost/thread/condition.hpp>
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
|
||||
struct xtime;
|
||||
|
||||
class thread : private noncopyable
|
||||
{
|
||||
public:
|
||||
thread();
|
||||
explicit thread(const function0<void>& threadfunc);
|
||||
~thread();
|
||||
|
||||
bool operator==(const thread& other) const;
|
||||
bool operator!=(const thread& other) const;
|
||||
|
||||
void join();
|
||||
|
||||
static void sleep(const xtime& xt);
|
||||
static void yield();
|
||||
|
||||
private:
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
unsigned long m_thread;
|
||||
unsigned int m_id;
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
private:
|
||||
pthread_t m_thread;
|
||||
#endif
|
||||
bool m_joinable;
|
||||
};
|
||||
|
||||
class thread_group : private noncopyable
|
||||
{
|
||||
public:
|
||||
thread_group();
|
||||
~thread_group();
|
||||
|
||||
thread* create_thread(const function0<void>& threadfunc);
|
||||
void add_thread(thread* thrd);
|
||||
void remove_thread(thread* thrd);
|
||||
void join_all();
|
||||
|
||||
private:
|
||||
std::list<thread*> m_threads;
|
||||
mutex m_mutex;
|
||||
};
|
||||
|
||||
} // namespace boost
|
||||
|
||||
// Change Log:
|
||||
// 8 Feb 01 WEKEMPF Initial version.
|
||||
// 1 Jun 01 WEKEMPF Added boost::thread initial implementation.
|
||||
// 3 Jul 01 WEKEMPF Redesigned boost::thread to be noncopyable.
|
||||
|
||||
#endif // BOOST_THREAD_WEK070601_HPP
|
||||
72
include/boost/thread/tss.hpp
Normal file
72
include/boost/thread/tss.hpp
Normal file
@@ -0,0 +1,72 @@
|
||||
// Copyright (C) 2001
|
||||
// William E. Kempf
|
||||
//
|
||||
// Permission to use, copy, modify, distribute and sell this software
|
||||
// and its documentation for any purpose is hereby granted without fee,
|
||||
// provided that the above copyright notice appear in all copies and
|
||||
// that both that copyright notice and this permission notice appear
|
||||
// in supporting documentation. William E. Kempf makes no representations
|
||||
// about the suitability of this software for any purpose.
|
||||
// It is provided "as is" without express or implied warranty.
|
||||
|
||||
#ifndef BOOST_TSS_WEK070601_HPP
|
||||
#define BOOST_TSS_WEK070601_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#ifndef BOOST_HAS_THREADS
|
||||
# error Thread support is unavailable!
|
||||
#endif
|
||||
|
||||
#include <boost/utility.hpp>
|
||||
|
||||
#if defined(BOOST_HAS_PTHREADS)
|
||||
# include <pthread.h>
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
|
||||
namespace detail {
|
||||
class tss : private noncopyable
|
||||
{
|
||||
public:
|
||||
tss(void (*cleanup)(void*)=0);
|
||||
~tss();
|
||||
|
||||
void* get() const;
|
||||
bool set(void* value);
|
||||
|
||||
private:
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
unsigned long m_key;
|
||||
void (*m_cleanup)(void*);
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
pthread_key_t m_key;
|
||||
#endif
|
||||
};
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
class thread_specific_ptr : private noncopyable
|
||||
{
|
||||
public:
|
||||
thread_specific_ptr() : m_tss(&thread_specific_ptr<T>::cleanup) { }
|
||||
|
||||
T* get() const { return static_cast<T*>(m_tss.get()); }
|
||||
T* operator->() const { return get(); }
|
||||
T& operator*() const { return *get(); }
|
||||
T* release() { T* temp = get(); m_tss.set(0); return temp; }
|
||||
void reset(T* p=0) { T* cur = get(); if (cur == p) return; delete cur; m_tss.set(p); }
|
||||
|
||||
private:
|
||||
static void cleanup(void* p) { delete static_cast<T*>(p); }
|
||||
|
||||
mutable detail::tss m_tss;
|
||||
};
|
||||
|
||||
} // namespace boost
|
||||
|
||||
// Change Log:
|
||||
// 6 Jun 01 WEKEMPF Initial version.
|
||||
|
||||
#endif // BOOST_TSS_WEK070601_HPP
|
||||
|
||||
50
include/boost/thread/xtime.hpp
Normal file
50
include/boost/thread/xtime.hpp
Normal file
@@ -0,0 +1,50 @@
|
||||
// Copyright (C) 2001
|
||||
// William E. Kempf
|
||||
//
|
||||
// Permission to use, copy, modify, distribute and sell this software
|
||||
// and its documentation for any purpose is hereby granted without fee,
|
||||
// provided that the above copyright notice appear in all copies and
|
||||
// that both that copyright notice and this permission notice appear
|
||||
// in supporting documentation. William E. Kempf makes no representations
|
||||
// about the suitability of this software for any purpose.
|
||||
// It is provided "as is" without express or implied warranty.
|
||||
|
||||
#ifndef BOOST_XTIME_WEK070601_HPP
|
||||
#define BOOST_XTIME_WEK070601_HPP
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/config.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
enum
|
||||
{
|
||||
TIME_UTC=1,
|
||||
TIME_TAI,
|
||||
TIME_MONOTONIC,
|
||||
TIME_PROCESS,
|
||||
TIME_THREAD,
|
||||
TIME_LOCAL,
|
||||
TIME_SYNC,
|
||||
TIME_RESOLUTION
|
||||
};
|
||||
|
||||
struct xtime
|
||||
{
|
||||
#if defined(BOOST_NO_INT64_T)
|
||||
int_fast32_t sec;
|
||||
#else
|
||||
int_fast64_t sec;
|
||||
#endif
|
||||
int_fast32_t nsec;
|
||||
};
|
||||
|
||||
int xtime_get(struct xtime* xtp, int clock_type);
|
||||
|
||||
} // namespace boost
|
||||
|
||||
// Change Log:
|
||||
// 8 Feb 01 WEKEMPF Initial version.
|
||||
|
||||
#endif // BOOST_XTIME_WEK070601_HPP
|
||||
|
||||
80
src/_atomic.cpp
Normal file
80
src/_atomic.cpp
Normal file
@@ -0,0 +1,80 @@
|
||||
/*
|
||||
*
|
||||
* Copyright (C) 2001
|
||||
* William E. Kempf
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. William E. Kempf makes no representations
|
||||
* about the suitability of this software for any purpose.
|
||||
* It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
* Revision History (excluding minor changes for specific compilers)
|
||||
* 8 Feb 01 Initial version.
|
||||
*/
|
||||
|
||||
#include <boost/thread/atomic.hpp>
|
||||
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
# include <windows.h>
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
atomic_t::value_type read(const atomic_t& x)
|
||||
{
|
||||
return x._value;
|
||||
}
|
||||
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
atomic_t::value_type increment(atomic_t& x)
|
||||
{
|
||||
return InterlockedIncrement(const_cast<long*>(&x._value));
|
||||
}
|
||||
|
||||
atomic_t::value_type decrement(atomic_t& x)
|
||||
{
|
||||
return InterlockedDecrement(const_cast<long*>(&x._value));
|
||||
}
|
||||
|
||||
atomic_t::value_type swap(atomic_t& x, atomic_t::value_type y)
|
||||
{
|
||||
return InterlockedExchange(const_cast<long*>(&x._value), y);
|
||||
}
|
||||
|
||||
atomic_t::value_type compare_swap(atomic_t& x, atomic_t::value_type y, atomic_t::value_type z)
|
||||
{
|
||||
return InterlockedCompareExchange(const_cast<long*>(&x._value), y, z);
|
||||
}
|
||||
#else
|
||||
atomic_t::value_type increment(atomic_t& x)
|
||||
{
|
||||
mutex::lock lock(x._mutex);
|
||||
return ++x._value;
|
||||
}
|
||||
|
||||
atomic_t::value_type decrement(atomic_t& x)
|
||||
{
|
||||
mutex::lock lock(x._mutex);
|
||||
return --x._value;
|
||||
}
|
||||
|
||||
atomic_t::value_type swap(atomic_t& x, atomic_t::value_type y)
|
||||
{
|
||||
mutex::lock lock(x._mutex);
|
||||
atomic_t::value_type temp = x._value;
|
||||
x._value = y;
|
||||
return temp;
|
||||
}
|
||||
|
||||
atomic_t::value_type compare_swap(atomic_t& x, atomic_t::value_type y, atomic_t::value_type z)
|
||||
{
|
||||
mutex::lock lock(x._mutex);
|
||||
atomic_t::value_type temp = x._value;
|
||||
if (temp == z)
|
||||
x._value = y;
|
||||
return temp;
|
||||
}
|
||||
#endif
|
||||
} // namespace boost
|
||||
360
src/condition.cpp
Normal file
360
src/condition.cpp
Normal file
@@ -0,0 +1,360 @@
|
||||
// Copyright (C) 2001
|
||||
// William E. Kempf
|
||||
//
|
||||
// Permission to use, copy, modify, distribute and sell this software
|
||||
// and its documentation for any purpose is hereby granted without fee,
|
||||
// provided that the above copyright notice appear in all copies and
|
||||
// that both that copyright notice and this permission notice appear
|
||||
// in supporting documentation. William E. Kempf makes no representations
|
||||
// about the suitability of this software for any purpose.
|
||||
// It is provided "as is" without express or implied warranty.
|
||||
|
||||
#include <boost/thread/condition.hpp>
|
||||
#include <boost/thread/xtime.hpp>
|
||||
#include <boost/thread/thread.hpp>
|
||||
#include <boost/thread/exceptions.hpp>
|
||||
#include <boost/limits.hpp>
|
||||
#include <cassert>
|
||||
#include "timeconv.inl"
|
||||
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
# define NOMINMAX
|
||||
# include <windows.h>
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
# include <errno.h>
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
condition::condition()
|
||||
: m_gone(0), m_blocked(0), m_waiting(0)
|
||||
{
|
||||
m_gate = reinterpret_cast<unsigned long>(CreateSemaphore(0, 1, 1, 0));
|
||||
m_queue = reinterpret_cast<unsigned long>(CreateSemaphore(0, 0, std::numeric_limits<long>::max(), 0));
|
||||
m_mutex = reinterpret_cast<unsigned long>(CreateMutex(0, 0, 0));
|
||||
|
||||
if (!m_gate || !m_queue || !m_mutex)
|
||||
{
|
||||
int res = 0;
|
||||
if (m_gate)
|
||||
{
|
||||
res = CloseHandle(reinterpret_cast<HANDLE>(m_gate));
|
||||
assert(res);
|
||||
}
|
||||
if (m_queue)
|
||||
{
|
||||
res = CloseHandle(reinterpret_cast<HANDLE>(m_queue));
|
||||
assert(res);
|
||||
}
|
||||
if (m_mutex)
|
||||
{
|
||||
res = CloseHandle(reinterpret_cast<HANDLE>(m_mutex));
|
||||
assert(res);
|
||||
}
|
||||
|
||||
throw thread_resource_error();
|
||||
}
|
||||
}
|
||||
|
||||
condition::~condition()
|
||||
{
|
||||
int res = 0;
|
||||
res = CloseHandle(reinterpret_cast<HANDLE>(m_gate));
|
||||
assert(res);
|
||||
res = CloseHandle(reinterpret_cast<HANDLE>(m_queue));
|
||||
assert(res);
|
||||
res = CloseHandle(reinterpret_cast<HANDLE>(m_mutex));
|
||||
assert(res);
|
||||
}
|
||||
|
||||
void condition::notify_one()
|
||||
{
|
||||
unsigned signals = 0;
|
||||
|
||||
int res = 0;
|
||||
res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), INFINITE);
|
||||
assert(res == WAIT_OBJECT_0);
|
||||
|
||||
if (m_waiting != 0) // the m_gate is already closed
|
||||
{
|
||||
if (m_blocked == 0)
|
||||
{
|
||||
res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
|
||||
assert(res);
|
||||
return;
|
||||
}
|
||||
|
||||
++m_waiting;
|
||||
--m_blocked;
|
||||
}
|
||||
else
|
||||
{
|
||||
res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_gate), INFINITE);
|
||||
assert(res == WAIT_OBJECT_0);
|
||||
if (m_blocked > m_gone)
|
||||
{
|
||||
if (m_gone != 0)
|
||||
{
|
||||
m_blocked -= m_gone;
|
||||
m_gone = 0;
|
||||
}
|
||||
signals = m_waiting = 1;
|
||||
--m_blocked;
|
||||
}
|
||||
else
|
||||
{
|
||||
res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0);
|
||||
assert(res);
|
||||
}
|
||||
|
||||
res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
|
||||
assert(res);
|
||||
|
||||
if (signals)
|
||||
{
|
||||
res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_queue), signals, 0);
|
||||
assert(res);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void condition::notify_all()
|
||||
{
|
||||
unsigned signals = 0;
|
||||
|
||||
int res = 0;
|
||||
res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), INFINITE);
|
||||
assert(res == WAIT_OBJECT_0);
|
||||
|
||||
if (m_waiting != 0) // the m_gate is already closed
|
||||
{
|
||||
if (m_blocked == 0)
|
||||
{
|
||||
res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
|
||||
assert(res);
|
||||
return;
|
||||
}
|
||||
|
||||
m_waiting += (signals = m_blocked);
|
||||
m_blocked = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_gate), INFINITE);
|
||||
assert(res == WAIT_OBJECT_0);
|
||||
if (m_blocked > m_gone)
|
||||
{
|
||||
if (m_gone != 0)
|
||||
{
|
||||
m_blocked -= m_gone;
|
||||
m_gone = 0;
|
||||
}
|
||||
signals = m_waiting = m_blocked;
|
||||
m_blocked = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0);
|
||||
assert(res);
|
||||
}
|
||||
|
||||
res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
|
||||
assert(res);
|
||||
|
||||
if (signals)
|
||||
{
|
||||
res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_queue), signals, 0);
|
||||
assert(res);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void condition::enter_wait()
|
||||
{
|
||||
int res = 0;
|
||||
res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_gate), INFINITE);
|
||||
assert(res == WAIT_OBJECT_0);
|
||||
++m_blocked;
|
||||
res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0);
|
||||
assert(res);
|
||||
}
|
||||
|
||||
void condition::do_wait()
|
||||
{
|
||||
int res = 0;
|
||||
res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_queue), INFINITE);
|
||||
assert(res == WAIT_OBJECT_0);
|
||||
|
||||
unsigned was_waiting=0;
|
||||
unsigned was_gone=0;
|
||||
|
||||
res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), INFINITE);
|
||||
assert(res == WAIT_OBJECT_0);
|
||||
was_waiting = m_waiting;
|
||||
was_gone = m_gone;
|
||||
if (was_waiting != 0)
|
||||
{
|
||||
if (--m_waiting == 0)
|
||||
{
|
||||
if (m_blocked != 0)
|
||||
{
|
||||
res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0); // open m_gate
|
||||
assert(res);
|
||||
was_waiting = 0;
|
||||
}
|
||||
else if (m_gone != 0)
|
||||
m_gone = 0;
|
||||
}
|
||||
}
|
||||
else if (++m_gone == (std::numeric_limits<unsigned>::max() / 2))
|
||||
{
|
||||
// timeout occured, normalize the m_gone count
|
||||
// this may occur if many calls to wait with a timeout are made and
|
||||
// no call to notify_* is made
|
||||
res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_gate), INFINITE);
|
||||
assert(res == WAIT_OBJECT_0);
|
||||
m_blocked -= m_gone;
|
||||
res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0);
|
||||
assert(res);
|
||||
m_gone = 0;
|
||||
}
|
||||
res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
|
||||
assert(res);
|
||||
|
||||
if (was_waiting == 1)
|
||||
{
|
||||
for (/**/ ; was_gone; --was_gone)
|
||||
{
|
||||
// better now than spurious later
|
||||
res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_queue), INFINITE);
|
||||
assert(res == WAIT_OBJECT_0);
|
||||
}
|
||||
res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0);
|
||||
assert(res);
|
||||
}
|
||||
}
|
||||
|
||||
bool condition::do_timed_wait(const xtime& xt)
|
||||
{
|
||||
unsigned milliseconds;
|
||||
to_duration(xt, milliseconds);
|
||||
|
||||
int res = 0;
|
||||
res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_queue), milliseconds);
|
||||
assert(res != WAIT_FAILED && res != WAIT_ABANDONED);
|
||||
|
||||
bool ret = (res == WAIT_OBJECT_0);
|
||||
|
||||
unsigned was_waiting=0;
|
||||
unsigned was_gone=0;
|
||||
|
||||
res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), INFINITE);
|
||||
assert(res == WAIT_OBJECT_0);
|
||||
was_waiting = m_waiting;
|
||||
was_gone = m_gone;
|
||||
if (was_waiting != 0)
|
||||
{
|
||||
if (!ret) // timeout
|
||||
{
|
||||
if (m_blocked != 0)
|
||||
--m_blocked;
|
||||
else
|
||||
++m_gone; // count spurious wakeups
|
||||
}
|
||||
if (--m_waiting == 0)
|
||||
{
|
||||
if (m_blocked != 0)
|
||||
{
|
||||
res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0); // open m_gate
|
||||
assert(res);
|
||||
was_waiting = 0;
|
||||
}
|
||||
else if (m_gone != 0)
|
||||
m_gone = 0;
|
||||
}
|
||||
}
|
||||
else if (++m_gone == (std::numeric_limits<unsigned>::max() / 2))
|
||||
{
|
||||
// timeout occured, normalize the m_gone count
|
||||
// this may occur if many calls to wait with a timeout are made and
|
||||
// no call to notify_* is made
|
||||
res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_gate), INFINITE);
|
||||
assert(res == WAIT_OBJECT_0);
|
||||
m_blocked -= m_gone;
|
||||
res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0);
|
||||
assert(res);
|
||||
m_gone = 0;
|
||||
}
|
||||
res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
|
||||
assert(res);
|
||||
|
||||
if (was_waiting == 1)
|
||||
{
|
||||
for (/**/ ; was_gone; --was_gone)
|
||||
{
|
||||
// better now than spurious later
|
||||
res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_queue), INFINITE);
|
||||
assert(res == WAIT_OBJECT_0);
|
||||
}
|
||||
res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0);
|
||||
assert(res);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
condition::condition()
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_cond_init(&m_condition, 0);
|
||||
if (res != 0)
|
||||
throw thread_resource_error();
|
||||
}
|
||||
|
||||
condition::~condition()
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_cond_destroy(&m_condition);
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
void condition::notify_one()
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_cond_signal(&m_condition);
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
void condition::notify_all()
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_cond_broadcast(&m_condition);
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
void condition::do_wait(pthread_mutex_t* pmutex)
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_cond_wait(&m_condition, pmutex);
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
bool condition::do_timed_wait(const xtime& xt, pthread_mutex_t* pmutex)
|
||||
{
|
||||
timespec ts;
|
||||
to_timespec(xt, ts);
|
||||
|
||||
int res = 0;
|
||||
res = pthread_cond_timedwait(&m_condition, pmutex, &ts);
|
||||
assert(res == 0 || res == ETIMEDOUT);
|
||||
|
||||
return res != ETIMEDOUT;
|
||||
}
|
||||
#endif
|
||||
|
||||
} // namespace boost
|
||||
|
||||
// Change Log:
|
||||
// 8 Feb 01 WEKEMPF Initial version.
|
||||
// 22 May 01 WEKEMPF Modified to use xtime for time outs.
|
||||
405
src/mutex.cpp
Normal file
405
src/mutex.cpp
Normal file
@@ -0,0 +1,405 @@
|
||||
// Copyright (C) 2001
|
||||
// William E. Kempf
|
||||
//
|
||||
// Permission to use, copy, modify, distribute and sell this software
|
||||
// and its documentation for any purpose is hereby granted without fee,
|
||||
// provided that the above copyright notice appear in all copies and
|
||||
// that both that copyright notice and this permission notice appear
|
||||
// in supporting documentation. William E. Kempf makes no representations
|
||||
// about the suitability of this software for any purpose.
|
||||
// It is provided "as is" without express or implied warranty.
|
||||
|
||||
#include <boost/thread/mutex.hpp>
|
||||
#include <boost/thread/xtime.hpp>
|
||||
#include <boost/thread/thread.hpp>
|
||||
#include <boost/thread/exceptions.hpp>
|
||||
#include <boost/limits.hpp>
|
||||
#include <stdexcept>
|
||||
#include <cassert>
|
||||
#include "timeconv.inl"
|
||||
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
# include <windows.h>
|
||||
# include <time.h>
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
# include <errno.h>
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
mutex::mutex()
|
||||
{
|
||||
m_mutex = reinterpret_cast<unsigned long>(CreateMutex(0, 0, 0));
|
||||
if (!m_mutex)
|
||||
throw thread_resource_error();
|
||||
}
|
||||
|
||||
mutex::~mutex()
|
||||
{
|
||||
int res = 0;
|
||||
res = CloseHandle(reinterpret_cast<HANDLE>(m_mutex));
|
||||
assert(res);
|
||||
}
|
||||
|
||||
void mutex::do_lock()
|
||||
{
|
||||
int res = 0;
|
||||
res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), INFINITE);
|
||||
assert(res == WAIT_OBJECT_0);
|
||||
}
|
||||
|
||||
void mutex::do_unlock()
|
||||
{
|
||||
int res = 0;
|
||||
res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
|
||||
assert(res);
|
||||
}
|
||||
|
||||
void mutex::do_lock(cv_state&)
|
||||
{
|
||||
do_lock();
|
||||
}
|
||||
|
||||
void mutex::do_unlock(cv_state&)
|
||||
{
|
||||
do_unlock();
|
||||
}
|
||||
|
||||
try_mutex::try_mutex()
|
||||
{
|
||||
m_mutex = reinterpret_cast<unsigned long>(CreateMutex(0, 0, 0));
|
||||
if (!m_mutex)
|
||||
throw thread_resource_error();
|
||||
}
|
||||
|
||||
try_mutex::~try_mutex()
|
||||
{
|
||||
int res = 0;
|
||||
res = CloseHandle(reinterpret_cast<HANDLE>(m_mutex));
|
||||
assert(res);
|
||||
}
|
||||
|
||||
void try_mutex::do_lock()
|
||||
{
|
||||
int res = 0;
|
||||
res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), INFINITE);
|
||||
assert(res == WAIT_OBJECT_0);
|
||||
}
|
||||
|
||||
bool try_mutex::do_trylock()
|
||||
{
|
||||
int res = 0;
|
||||
res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), 0);
|
||||
assert(res != WAIT_FAILED && res != WAIT_ABANDONED);
|
||||
return res == WAIT_OBJECT_0;
|
||||
}
|
||||
|
||||
void try_mutex::do_unlock()
|
||||
{
|
||||
int res = 0;
|
||||
res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
|
||||
assert(res);
|
||||
}
|
||||
|
||||
void try_mutex::do_lock(cv_state&)
|
||||
{
|
||||
do_lock();
|
||||
}
|
||||
|
||||
void try_mutex::do_unlock(cv_state&)
|
||||
{
|
||||
do_unlock();
|
||||
}
|
||||
|
||||
timed_mutex::timed_mutex()
|
||||
{
|
||||
m_mutex = reinterpret_cast<unsigned long>(CreateMutex(0, 0, 0));
|
||||
if (!m_mutex)
|
||||
throw thread_resource_error();
|
||||
}
|
||||
|
||||
timed_mutex::~timed_mutex()
|
||||
{
|
||||
int res = 0;
|
||||
res = CloseHandle(reinterpret_cast<HANDLE>(m_mutex));
|
||||
assert(res);
|
||||
}
|
||||
|
||||
void timed_mutex::do_lock()
|
||||
{
|
||||
int res = 0;
|
||||
res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), INFINITE);
|
||||
assert(res == WAIT_OBJECT_0);
|
||||
}
|
||||
|
||||
bool timed_mutex::do_trylock()
|
||||
{
|
||||
int res = 0;
|
||||
res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), 0);
|
||||
assert(res != WAIT_FAILED && res != WAIT_ABANDONED);
|
||||
return res == WAIT_OBJECT_0;
|
||||
}
|
||||
|
||||
bool timed_mutex::do_timedlock(const xtime& xt)
|
||||
{
|
||||
unsigned milliseconds;
|
||||
to_duration(xt, milliseconds);
|
||||
|
||||
int res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), milliseconds);
|
||||
assert(res != WAIT_FAILED && res != WAIT_ABANDONED);
|
||||
return res == WAIT_OBJECT_0;
|
||||
}
|
||||
|
||||
void timed_mutex::do_unlock()
|
||||
{
|
||||
int res = 0;
|
||||
res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
|
||||
assert(res);
|
||||
}
|
||||
|
||||
void timed_mutex::do_lock(cv_state&)
|
||||
{
|
||||
do_lock();
|
||||
}
|
||||
|
||||
void timed_mutex::do_unlock(cv_state&)
|
||||
{
|
||||
do_unlock();
|
||||
}
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
mutex::mutex()
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_mutex_init(&m_mutex, 0);
|
||||
if (res != 0)
|
||||
throw thread_resource_error();
|
||||
}
|
||||
|
||||
mutex::~mutex()
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_mutex_destroy(&m_mutex);
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
void mutex::do_lock()
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_mutex_lock(&m_mutex);
|
||||
if (res == EDEADLK) throw lock_error();
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
void mutex::do_unlock()
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_mutex_unlock(&m_mutex);
|
||||
if (res == EPERM) throw lock_error();
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
void mutex::do_lock(cv_state& state)
|
||||
{
|
||||
}
|
||||
|
||||
void mutex::do_unlock(cv_state& state)
|
||||
{
|
||||
state.pmutex = &m_mutex;
|
||||
}
|
||||
|
||||
try_mutex::try_mutex()
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_mutex_init(&m_mutex, 0);
|
||||
if (res != 0)
|
||||
throw thread_resource_error();
|
||||
}
|
||||
|
||||
try_mutex::~try_mutex()
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_mutex_destroy(&m_mutex);
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
void try_mutex::do_lock()
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_mutex_lock(&m_mutex);
|
||||
if (res == EDEADLK) throw lock_error();
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
bool try_mutex::do_trylock()
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_mutex_trylock(&m_mutex);
|
||||
if (res == EDEADLK) throw lock_error();
|
||||
assert(res == 0 || res == EBUSY);
|
||||
return res == 0;
|
||||
}
|
||||
|
||||
void try_mutex::do_unlock()
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_mutex_unlock(&m_mutex);
|
||||
if (res == EPERM) throw lock_error();
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
void try_mutex::do_lock(cv_state& state)
|
||||
{
|
||||
}
|
||||
|
||||
void try_mutex::do_unlock(cv_state& state)
|
||||
{
|
||||
state.pmutex = &m_mutex;
|
||||
}
|
||||
|
||||
timed_mutex::timed_mutex()
|
||||
: m_locked(false)
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_mutex_init(&m_mutex, 0);
|
||||
if (res != 0)
|
||||
throw thread_resource_error();
|
||||
|
||||
res = pthread_cond_init(&m_condition, 0);
|
||||
if (res != 0)
|
||||
{
|
||||
pthread_mutex_destroy(&m_mutex);
|
||||
throw thread_resource_error();
|
||||
}
|
||||
}
|
||||
|
||||
timed_mutex::~timed_mutex()
|
||||
{
|
||||
assert(!m_locked);
|
||||
int res = 0;
|
||||
res = pthread_mutex_destroy(&m_mutex);
|
||||
assert(res == 0);
|
||||
|
||||
res = pthread_cond_destroy(&m_condition);
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
void timed_mutex::do_lock()
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_mutex_lock(&m_mutex);
|
||||
assert(res == 0);
|
||||
|
||||
while (m_locked)
|
||||
{
|
||||
res = pthread_cond_wait(&m_condition, &m_mutex);
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
assert(!m_locked);
|
||||
m_locked = true;
|
||||
|
||||
res = pthread_mutex_unlock(&m_mutex);
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
bool timed_mutex::do_trylock()
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_mutex_lock(&m_mutex);
|
||||
assert(res == 0);
|
||||
|
||||
bool ret = false;
|
||||
if (!m_locked)
|
||||
{
|
||||
m_locked = true;
|
||||
ret = true;
|
||||
}
|
||||
|
||||
res = pthread_mutex_unlock(&m_mutex);
|
||||
assert(res == 0);
|
||||
return ret;
|
||||
}
|
||||
|
||||
bool timed_mutex::do_timedlock(const xtime& xt)
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_mutex_lock(&m_mutex);
|
||||
assert(res == 0);
|
||||
|
||||
timespec ts;
|
||||
to_timespec(xt, ts);
|
||||
|
||||
while (m_locked)
|
||||
{
|
||||
res = pthread_cond_timedwait(&m_condition, &m_mutex, &ts);
|
||||
assert(res == 0 || res == ETIMEDOUT);
|
||||
|
||||
if (res == ETIMEDOUT)
|
||||
break;
|
||||
}
|
||||
|
||||
bool ret = false;
|
||||
if (!m_locked)
|
||||
{
|
||||
m_locked = true;
|
||||
ret = true;
|
||||
}
|
||||
|
||||
res = pthread_mutex_unlock(&m_mutex);
|
||||
assert(res == 0);
|
||||
return ret;
|
||||
}
|
||||
|
||||
void timed_mutex::do_unlock()
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_mutex_lock(&m_mutex);
|
||||
assert(res == 0);
|
||||
|
||||
assert(m_locked);
|
||||
m_locked = false;
|
||||
|
||||
res = pthread_cond_signal(&m_condition);
|
||||
assert(res == 0);
|
||||
|
||||
res = pthread_mutex_unlock(&m_mutex);
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
void timed_mutex::do_lock(cv_state& state)
|
||||
{
|
||||
int res = 0;
|
||||
while (m_locked)
|
||||
{
|
||||
res = pthread_cond_wait(&m_condition, &m_mutex);
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
assert(!m_locked);
|
||||
m_locked = true;
|
||||
|
||||
res = pthread_mutex_unlock(&m_mutex);
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
void timed_mutex::do_unlock(cv_state& state)
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_mutex_lock(&m_mutex);
|
||||
assert(res == 0);
|
||||
|
||||
assert(m_locked);
|
||||
m_locked = false;
|
||||
|
||||
res = pthread_cond_signal(&m_condition);
|
||||
assert(res == 0);
|
||||
|
||||
state.pmutex = &m_mutex;
|
||||
}
|
||||
#endif
|
||||
|
||||
} // namespace boost
|
||||
|
||||
// Change Log:
|
||||
// 8 Feb 01 WEKEMPF Initial version.
|
||||
96
src/once.cpp
Normal file
96
src/once.cpp
Normal file
@@ -0,0 +1,96 @@
|
||||
// Copyright (C) 2001
|
||||
// William E. Kempf
|
||||
//
|
||||
// Permission to use, copy, modify, distribute and sell this software
|
||||
// and its documentation for any purpose is hereby granted without fee,
|
||||
// provided that the above copyright notice appear in all copies and
|
||||
// that both that copyright notice and this permission notice appear
|
||||
// in supporting documentation. William E. Kempf makes no representations
|
||||
// about the suitability of this software for any purpose.
|
||||
// It is provided "as is" without express or implied warranty.
|
||||
|
||||
#include <boost/thread/once.hpp>
|
||||
#include <cstdio>
|
||||
#include <cassert>
|
||||
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
# include <windows.h>
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_NO_STDC_NAMESPACE
|
||||
namespace std { using ::sprintf; }
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_HAS_PTHREADS)
|
||||
namespace {
|
||||
pthread_key_t key;
|
||||
pthread_once_t once = PTHREAD_ONCE_INIT;
|
||||
|
||||
typedef void (*once_callback)();
|
||||
}
|
||||
|
||||
extern "C" {
|
||||
|
||||
static void key_init()
|
||||
{
|
||||
pthread_key_create(&key, 0);
|
||||
}
|
||||
|
||||
static void do_once()
|
||||
{
|
||||
once_callback cb = reinterpret_cast<once_callback>(pthread_getspecific(key));
|
||||
(*cb)();
|
||||
}
|
||||
|
||||
}
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
|
||||
void call_once(void (*func)(), once_flag& flag)
|
||||
{
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
once_flag tmp = flag;
|
||||
|
||||
// Memory barrier would be needed here to prevent race conditions on some platforms with
|
||||
// partial ordering.
|
||||
|
||||
if (!tmp)
|
||||
{
|
||||
char name[41];
|
||||
std::sprintf(name, "2AC1A572DB6944B0A65C38C4140AF2F4%X%X", GetCurrentProcessId(), &flag);
|
||||
HANDLE mutex = CreateMutex(NULL, FALSE, name);
|
||||
assert(mutex != NULL);
|
||||
|
||||
int res = 0;
|
||||
res = WaitForSingleObject(mutex, INFINITE);
|
||||
assert(res == WAIT_OBJECT_0);
|
||||
|
||||
tmp = flag;
|
||||
if (!tmp)
|
||||
{
|
||||
func();
|
||||
tmp = true;
|
||||
|
||||
// Memory barrier would be needed here to prevent race conditions on some platforms
|
||||
// with partial ordering.
|
||||
|
||||
flag = tmp;
|
||||
}
|
||||
|
||||
res = ReleaseMutex(mutex);
|
||||
assert(res);
|
||||
res = CloseHandle(mutex);
|
||||
assert(res);
|
||||
}
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
pthread_once(&once, &key_init);
|
||||
pthread_setspecific(key, func);
|
||||
pthread_once(&flag, do_once);
|
||||
#endif
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Change Log:
|
||||
// 1 Aug 01 WEKEMPF Initial version.
|
||||
789
src/recursive_mutex.cpp
Normal file
789
src/recursive_mutex.cpp
Normal file
@@ -0,0 +1,789 @@
|
||||
// Copyright (C) 2001
|
||||
// William E. Kempf
|
||||
//
|
||||
// Permission to use, copy, modify, distribute and sell this software
|
||||
// and its documentation for any purpose is hereby granted without fee,
|
||||
// provided that the above copyright notice appear in all copies and
|
||||
// that both that copyright notice and this permission notice appear
|
||||
// in supporting documentation. William E. Kempf makes no representations
|
||||
// about the suitability of this software for any purpose.
|
||||
// It is provided "as is" without express or implied warranty.
|
||||
|
||||
#include <boost/thread/recursive_mutex.hpp>
|
||||
#include <boost/thread/xtime.hpp>
|
||||
#include <boost/thread/thread.hpp>
|
||||
#include <boost/limits.hpp>
|
||||
#include <stdexcept>
|
||||
#include <cassert>
|
||||
#include "timeconv.inl"
|
||||
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
# include <windows.h>
|
||||
# include <time.h>
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
# include <errno.h>
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
recursive_mutex::recursive_mutex()
|
||||
: m_count(0)
|
||||
{
|
||||
m_mutex = reinterpret_cast<unsigned long>(CreateMutex(0, 0, 0));
|
||||
if (!m_mutex)
|
||||
throw thread_resource_error();
|
||||
}
|
||||
|
||||
recursive_mutex::~recursive_mutex()
|
||||
{
|
||||
int res = 0;
|
||||
res = CloseHandle(reinterpret_cast<HANDLE>(m_mutex));
|
||||
assert(res);
|
||||
}
|
||||
|
||||
void recursive_mutex::do_lock()
|
||||
{
|
||||
int res = 0;
|
||||
res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), INFINITE);
|
||||
assert(res == WAIT_OBJECT_0);
|
||||
|
||||
if (++m_count > 1)
|
||||
{
|
||||
res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
|
||||
assert(res);
|
||||
}
|
||||
}
|
||||
|
||||
void recursive_mutex::do_unlock()
|
||||
{
|
||||
if (--m_count == 0)
|
||||
{
|
||||
int res = 0;
|
||||
res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
|
||||
assert(res);
|
||||
}
|
||||
}
|
||||
|
||||
void recursive_mutex::do_lock(cv_state& state)
|
||||
{
|
||||
int res = 0;
|
||||
res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), INFINITE);
|
||||
assert(res == WAIT_OBJECT_0);
|
||||
|
||||
m_count = state;
|
||||
}
|
||||
|
||||
void recursive_mutex::do_unlock(cv_state& state)
|
||||
{
|
||||
state = m_count;
|
||||
m_count = 0;
|
||||
|
||||
int res = 0;
|
||||
res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
|
||||
assert(res);
|
||||
}
|
||||
|
||||
recursive_try_mutex::recursive_try_mutex()
|
||||
: m_count(0)
|
||||
{
|
||||
m_mutex = reinterpret_cast<unsigned long>(CreateMutex(0, 0, 0));
|
||||
if (!m_mutex)
|
||||
throw thread_resource_error();
|
||||
}
|
||||
|
||||
recursive_try_mutex::~recursive_try_mutex()
|
||||
{
|
||||
int res = 0;
|
||||
res = CloseHandle(reinterpret_cast<HANDLE>(m_mutex));
|
||||
assert(res);
|
||||
}
|
||||
|
||||
void recursive_try_mutex::do_lock()
|
||||
{
|
||||
int res = 0;
|
||||
res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), INFINITE);
|
||||
assert(res == WAIT_OBJECT_0);
|
||||
|
||||
if (++m_count > 1)
|
||||
{
|
||||
res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
|
||||
assert(res);
|
||||
}
|
||||
}
|
||||
|
||||
bool recursive_try_mutex::do_trylock()
|
||||
{
|
||||
int res = 0;
|
||||
res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), 0);
|
||||
assert(res != WAIT_FAILED && res != WAIT_ABANDONED);
|
||||
|
||||
if (res == WAIT_OBJECT_0)
|
||||
{
|
||||
if (++m_count > 1)
|
||||
{
|
||||
res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
|
||||
assert(res);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void recursive_try_mutex::do_unlock()
|
||||
{
|
||||
if (--m_count == 0)
|
||||
{
|
||||
int res = 0;
|
||||
res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
|
||||
assert(res);
|
||||
}
|
||||
}
|
||||
|
||||
void recursive_try_mutex::do_lock(cv_state& state)
|
||||
{
|
||||
int res = 0;
|
||||
res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), INFINITE);
|
||||
assert(res == WAIT_OBJECT_0);
|
||||
|
||||
m_count = state;
|
||||
}
|
||||
|
||||
void recursive_try_mutex::do_unlock(cv_state& state)
|
||||
{
|
||||
state = m_count;
|
||||
m_count = 0;
|
||||
|
||||
int res = 0;
|
||||
res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
|
||||
assert(res);
|
||||
}
|
||||
|
||||
recursive_timed_mutex::recursive_timed_mutex()
|
||||
: m_count(0)
|
||||
{
|
||||
m_mutex = reinterpret_cast<unsigned long>(CreateMutex(0, 0, 0));
|
||||
if (!m_mutex)
|
||||
throw thread_resource_error();
|
||||
}
|
||||
|
||||
recursive_timed_mutex::~recursive_timed_mutex()
|
||||
{
|
||||
int res = 0;
|
||||
res = CloseHandle(reinterpret_cast<HANDLE>(m_mutex));
|
||||
assert(res);
|
||||
}
|
||||
|
||||
void recursive_timed_mutex::do_lock()
|
||||
{
|
||||
int res = 0;
|
||||
res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), INFINITE);
|
||||
assert(res == WAIT_OBJECT_0);
|
||||
|
||||
if (++m_count > 1)
|
||||
{
|
||||
res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
|
||||
assert(res);
|
||||
}
|
||||
}
|
||||
|
||||
bool recursive_timed_mutex::do_trylock()
|
||||
{
|
||||
int res = 0;
|
||||
res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), 0);
|
||||
assert(res != WAIT_FAILED && res != WAIT_ABANDONED);
|
||||
|
||||
if (res == WAIT_OBJECT_0)
|
||||
{
|
||||
if (++m_count > 1)
|
||||
{
|
||||
res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
|
||||
assert(res);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool recursive_timed_mutex::do_timedlock(const xtime& xt)
|
||||
{
|
||||
unsigned milliseconds;
|
||||
to_duration(xt, milliseconds);
|
||||
|
||||
int res = 0;
|
||||
res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), milliseconds);
|
||||
assert(res != WAIT_FAILED && res != WAIT_ABANDONED);
|
||||
|
||||
if (res == WAIT_OBJECT_0)
|
||||
{
|
||||
if (++m_count > 1)
|
||||
{
|
||||
res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
|
||||
assert(res);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void recursive_timed_mutex::do_unlock()
|
||||
{
|
||||
if (--m_count == 0)
|
||||
{
|
||||
int res = 0;
|
||||
res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
|
||||
assert(res);
|
||||
}
|
||||
}
|
||||
|
||||
void recursive_timed_mutex::do_lock(cv_state& state)
|
||||
{
|
||||
int res = 0;
|
||||
res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), INFINITE);
|
||||
assert(res == WAIT_OBJECT_0);
|
||||
|
||||
m_count = state;
|
||||
}
|
||||
|
||||
void recursive_timed_mutex::do_unlock(cv_state& state)
|
||||
{
|
||||
state = m_count;
|
||||
m_count = 0;
|
||||
|
||||
int res = 0;
|
||||
res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
|
||||
assert(res);
|
||||
}
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
recursive_mutex::recursive_mutex()
|
||||
: m_count(0)
|
||||
# if !defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
|
||||
, m_valid_id(false)
|
||||
# endif
|
||||
{
|
||||
pthread_mutexattr_t attr;
|
||||
int res = 0;
|
||||
res = pthread_mutexattr_init(&attr);
|
||||
assert(res == 0);
|
||||
|
||||
# if defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
|
||||
res = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
|
||||
assert(res == 0);
|
||||
# endif
|
||||
|
||||
res = pthread_mutex_init(&m_mutex, &attr);
|
||||
if (res != 0)
|
||||
throw thread_resource_error();
|
||||
|
||||
# if !defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
|
||||
res = pthread_cond_init(&m_unlocked, 0);
|
||||
if (res != 0)
|
||||
{
|
||||
pthread_mutex_destroy(&m_mutex);
|
||||
throw thread_resource_error();
|
||||
}
|
||||
# endif
|
||||
}
|
||||
|
||||
recursive_mutex::~recursive_mutex()
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_mutex_destroy(&m_mutex);
|
||||
assert(res == 0);
|
||||
|
||||
# if !defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
|
||||
res = pthread_cond_destroy(&m_unlocked);
|
||||
assert(res == 0);
|
||||
# endif
|
||||
}
|
||||
|
||||
void recursive_mutex::do_lock()
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_mutex_lock(&m_mutex);
|
||||
assert(res == 0);
|
||||
|
||||
# if defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
|
||||
if (++m_count > 1)
|
||||
{
|
||||
res = pthread_mutex_unlock(&m_mutex);
|
||||
assert(res == 0);
|
||||
}
|
||||
# else
|
||||
pthread_t tid = pthread_self();
|
||||
if (m_valid_id && pthread_equal(m_thread_id, tid))
|
||||
++m_count;
|
||||
else
|
||||
{
|
||||
while (m_valid_id)
|
||||
{
|
||||
res = pthread_cond_wait(&m_unlocked, &m_mutex);
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
m_thread_id = tid;
|
||||
m_valid_id = true;
|
||||
m_count = 1;
|
||||
}
|
||||
|
||||
res = pthread_mutex_unlock(&m_mutex);
|
||||
assert(res == 0);
|
||||
# endif
|
||||
}
|
||||
|
||||
void recursive_mutex::do_unlock()
|
||||
{
|
||||
# if defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
|
||||
if (--m_count == 0)
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_mutex_unlock(&m_mutex);
|
||||
assert(res == 0);
|
||||
}
|
||||
# else
|
||||
int res = 0;
|
||||
res = pthread_mutex_lock(&m_mutex);
|
||||
assert(res == 0);
|
||||
|
||||
pthread_t tid = pthread_self();
|
||||
if (m_valid_id && !pthread_equal(m_thread_id, tid))
|
||||
{
|
||||
res = pthread_mutex_unlock(&m_mutex);
|
||||
assert(res == 0);
|
||||
throw lock_error();
|
||||
}
|
||||
|
||||
if (--m_count == 0)
|
||||
{
|
||||
assert(m_valid_id);
|
||||
m_valid_id = false;
|
||||
|
||||
res = pthread_cond_signal(&m_unlocked);
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
res = pthread_mutex_unlock(&m_mutex);
|
||||
assert(res == 0);
|
||||
# endif
|
||||
}
|
||||
|
||||
void recursive_mutex::do_lock(cv_state& state)
|
||||
{
|
||||
# if defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
|
||||
m_count = state.count;
|
||||
# else
|
||||
int res = 0;
|
||||
|
||||
while (m_valid_id)
|
||||
{
|
||||
res = pthread_cond_wait(&m_unlocked, &m_mutex);
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
m_thread_id = pthread_self();
|
||||
m_valid_id = true;
|
||||
m_count = state.count;
|
||||
|
||||
res = pthread_mutex_unlock(&m_mutex);
|
||||
assert(res == 0);
|
||||
# endif
|
||||
}
|
||||
|
||||
void recursive_mutex::do_unlock(cv_state& state)
|
||||
{
|
||||
# if !defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
|
||||
int res = 0;
|
||||
res = pthread_mutex_lock(&m_mutex);
|
||||
assert(res == 0);
|
||||
|
||||
assert(m_valid_id);
|
||||
m_valid_id = false;
|
||||
|
||||
res = pthread_cond_signal(&m_unlocked);
|
||||
assert(res == 0);
|
||||
# endif
|
||||
|
||||
state.pmutex = &m_mutex;
|
||||
state.count = m_count;
|
||||
}
|
||||
|
||||
recursive_try_mutex::recursive_try_mutex()
|
||||
: m_count(0)
|
||||
# if !defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
|
||||
, m_valid_id(false)
|
||||
# endif
|
||||
{
|
||||
pthread_mutexattr_t attr;
|
||||
int res = 0;
|
||||
res = pthread_mutexattr_init(&attr);
|
||||
assert(res == 0);
|
||||
|
||||
# if defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
|
||||
res = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
|
||||
assert(res == 0);
|
||||
# endif
|
||||
|
||||
res = pthread_mutex_init(&m_mutex, &attr);
|
||||
if (res != 0)
|
||||
throw thread_resource_error();
|
||||
|
||||
# if !defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
|
||||
res = pthread_cond_init(&m_unlocked, 0);
|
||||
if (res != 0)
|
||||
{
|
||||
pthread_mutex_destroy(&m_mutex);
|
||||
throw thread_resource_error();
|
||||
}
|
||||
# endif
|
||||
}
|
||||
|
||||
recursive_try_mutex::~recursive_try_mutex()
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_mutex_destroy(&m_mutex);
|
||||
assert(res == 0);
|
||||
|
||||
# if !defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
|
||||
res = pthread_cond_destroy(&m_unlocked);
|
||||
assert(res == 0);
|
||||
# endif
|
||||
}
|
||||
|
||||
void recursive_try_mutex::do_lock()
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_mutex_lock(&m_mutex);
|
||||
assert(res == 0);
|
||||
|
||||
# if defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
|
||||
if (++m_count > 1)
|
||||
{
|
||||
res = pthread_mutex_unlock(&m_mutex);
|
||||
assert(res == 0);
|
||||
}
|
||||
# else
|
||||
pthread_t tid = pthread_self();
|
||||
if (m_valid_id && pthread_equal(m_thread_id, tid))
|
||||
++m_count;
|
||||
else
|
||||
{
|
||||
while (m_valid_id)
|
||||
{
|
||||
res = pthread_cond_wait(&m_unlocked, &m_mutex);
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
m_thread_id = tid;
|
||||
m_valid_id = true;
|
||||
m_count = 1;
|
||||
}
|
||||
|
||||
res = pthread_mutex_unlock(&m_mutex);
|
||||
assert(res == 0);
|
||||
# endif
|
||||
}
|
||||
|
||||
bool recursive_try_mutex::do_trylock()
|
||||
{
|
||||
# if defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
|
||||
int res = 0;
|
||||
res = pthread_mutex_trylock(&m_mutex);
|
||||
assert(res == 0);
|
||||
|
||||
if (res == 0)
|
||||
{
|
||||
if (++m_count > 1)
|
||||
{
|
||||
res = pthread_mutex_unlock(&m_mutex);
|
||||
assert(res == 0);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
# else
|
||||
int res = 0;
|
||||
res = pthread_mutex_lock(&m_mutex);
|
||||
assert(res == 0);
|
||||
|
||||
bool ret = false;
|
||||
pthread_t tid = pthread_self();
|
||||
if (m_valid_id && pthread_equal(m_thread_id, tid))
|
||||
{
|
||||
++m_count;
|
||||
ret = true;
|
||||
}
|
||||
else if (!m_valid_id)
|
||||
{
|
||||
m_thread_id = tid;
|
||||
m_valid_id = true;
|
||||
m_count = 1;
|
||||
ret = true;
|
||||
}
|
||||
|
||||
res = pthread_mutex_unlock(&m_mutex);
|
||||
assert(res == 0);
|
||||
return ret;
|
||||
# endif
|
||||
}
|
||||
|
||||
void recursive_try_mutex::do_unlock()
|
||||
{
|
||||
# if defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
|
||||
if (--m_count == 0)
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_mutex_unlock(&m_mutex);
|
||||
assert(res == 0);
|
||||
}
|
||||
# else
|
||||
int res = 0;
|
||||
res = pthread_mutex_lock(&m_mutex);
|
||||
assert(res == 0);
|
||||
|
||||
pthread_t tid = pthread_self();
|
||||
if (m_valid_id && !pthread_equal(m_thread_id, tid))
|
||||
{
|
||||
res = pthread_mutex_unlock(&m_mutex);
|
||||
assert(res == 0);
|
||||
throw lock_error();
|
||||
}
|
||||
|
||||
if (--m_count == 0)
|
||||
{
|
||||
assert(m_valid_id);
|
||||
m_valid_id = false;
|
||||
|
||||
res = pthread_cond_signal(&m_unlocked);
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
res = pthread_mutex_unlock(&m_mutex);
|
||||
assert(res == 0);
|
||||
# endif
|
||||
}
|
||||
|
||||
void recursive_try_mutex::do_lock(cv_state& state)
|
||||
{
|
||||
# if defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
|
||||
m_count = state.count;
|
||||
# else
|
||||
int res = 0;
|
||||
|
||||
while (m_valid_id)
|
||||
{
|
||||
res = pthread_cond_wait(&m_unlocked, &m_mutex);
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
m_thread_id = pthread_self();
|
||||
m_valid_id = true;
|
||||
m_count = state.count;
|
||||
|
||||
res = pthread_mutex_unlock(&m_mutex);
|
||||
assert(res == 0);
|
||||
# endif
|
||||
}
|
||||
|
||||
void recursive_try_mutex::do_unlock(cv_state& state)
|
||||
{
|
||||
# if !defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
|
||||
int res = 0;
|
||||
res = pthread_mutex_lock(&m_mutex);
|
||||
assert(res == 0);
|
||||
|
||||
assert(m_valid_id);
|
||||
m_valid_id = false;
|
||||
|
||||
res = pthread_cond_signal(&m_unlocked);
|
||||
assert(res == 0);
|
||||
# endif
|
||||
|
||||
state.pmutex = &m_mutex;
|
||||
state.count = m_count;
|
||||
}
|
||||
|
||||
recursive_timed_mutex::recursive_timed_mutex()
|
||||
: m_valid_id(false), m_count(0)
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_mutex_init(&m_mutex, 0);
|
||||
if (res != 0)
|
||||
throw thread_resource_error();
|
||||
|
||||
res = pthread_cond_init(&m_unlocked, 0);
|
||||
if (res != 0)
|
||||
{
|
||||
pthread_mutex_destroy(&m_mutex);
|
||||
throw thread_resource_error();
|
||||
}
|
||||
}
|
||||
|
||||
recursive_timed_mutex::~recursive_timed_mutex()
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_mutex_destroy(&m_mutex);
|
||||
assert(res == 0);
|
||||
|
||||
res = pthread_cond_destroy(&m_unlocked);
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
void recursive_timed_mutex::do_lock()
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_mutex_lock(&m_mutex);
|
||||
assert(res == 0);
|
||||
|
||||
pthread_t tid = pthread_self();
|
||||
if (m_valid_id && pthread_equal(m_thread_id, tid))
|
||||
++m_count;
|
||||
else
|
||||
{
|
||||
while (m_valid_id)
|
||||
{
|
||||
res = pthread_cond_wait(&m_unlocked, &m_mutex);
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
m_thread_id = tid;
|
||||
m_valid_id = true;
|
||||
m_count = 1;
|
||||
}
|
||||
|
||||
res = pthread_mutex_unlock(&m_mutex);
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
bool recursive_timed_mutex::do_trylock()
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_mutex_lock(&m_mutex);
|
||||
assert(res == 0);
|
||||
|
||||
bool ret = false;
|
||||
pthread_t tid = pthread_self();
|
||||
if (m_valid_id && pthread_equal(m_thread_id, tid))
|
||||
{
|
||||
++m_count;
|
||||
ret = true;
|
||||
}
|
||||
else if (!m_valid_id)
|
||||
{
|
||||
m_thread_id = tid;
|
||||
m_valid_id = true;
|
||||
m_count = 1;
|
||||
ret = true;
|
||||
}
|
||||
|
||||
res = pthread_mutex_unlock(&m_mutex);
|
||||
assert(res == 0);
|
||||
return ret;
|
||||
}
|
||||
|
||||
bool recursive_timed_mutex::do_timedlock(const xtime& xt)
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_mutex_lock(&m_mutex);
|
||||
assert(res == 0);
|
||||
|
||||
bool ret = false;
|
||||
pthread_t tid = pthread_self();
|
||||
if (m_valid_id && pthread_equal(m_thread_id, tid))
|
||||
{
|
||||
++m_count;
|
||||
ret = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
timespec ts;
|
||||
to_timespec(xt, ts);
|
||||
|
||||
while (m_valid_id)
|
||||
{
|
||||
res = pthread_cond_timedwait(&m_unlocked, &m_mutex, &ts);
|
||||
if (res == ETIMEDOUT)
|
||||
break;
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
if (!m_valid_id)
|
||||
{
|
||||
m_thread_id = tid;
|
||||
m_valid_id = true;
|
||||
m_count = 1;
|
||||
ret = true;
|
||||
}
|
||||
}
|
||||
|
||||
res = pthread_mutex_unlock(&m_mutex);
|
||||
assert(res == 0);
|
||||
return ret;
|
||||
}
|
||||
|
||||
void recursive_timed_mutex::do_unlock()
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_mutex_lock(&m_mutex);
|
||||
assert(res == 0);
|
||||
|
||||
pthread_t tid = pthread_self();
|
||||
if (m_valid_id && !pthread_equal(m_thread_id, tid))
|
||||
{
|
||||
res = pthread_mutex_unlock(&m_mutex);
|
||||
assert(res == 0);
|
||||
throw lock_error();
|
||||
}
|
||||
|
||||
if (--m_count == 0)
|
||||
{
|
||||
assert(m_valid_id);
|
||||
m_valid_id = false;
|
||||
|
||||
res = pthread_cond_signal(&m_unlocked);
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
res = pthread_mutex_unlock(&m_mutex);
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
void recursive_timed_mutex::do_lock(cv_state& state)
|
||||
{
|
||||
int res = 0;
|
||||
|
||||
while (m_valid_id)
|
||||
{
|
||||
res = pthread_cond_wait(&m_unlocked, &m_mutex);
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
m_thread_id = pthread_self();
|
||||
m_valid_id = true;
|
||||
m_count = state.count;
|
||||
|
||||
res = pthread_mutex_unlock(&m_mutex);
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
void recursive_timed_mutex::do_unlock(cv_state& state)
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_mutex_lock(&m_mutex);
|
||||
assert(res == 0);
|
||||
|
||||
assert(m_valid_id);
|
||||
m_valid_id = false;
|
||||
|
||||
res = pthread_cond_signal(&m_unlocked);
|
||||
assert(res == 0);
|
||||
|
||||
state.pmutex = &m_mutex;
|
||||
state.count = m_count;
|
||||
}
|
||||
#endif
|
||||
|
||||
} // namespace boost
|
||||
|
||||
// Change Log:
|
||||
// 8 Feb 01 WEKEMPF Initial version.
|
||||
179
src/semaphore.cpp
Normal file
179
src/semaphore.cpp
Normal file
@@ -0,0 +1,179 @@
|
||||
// Copyright (C) 2001
|
||||
// William E. Kempf
|
||||
//
|
||||
// Permission to use, copy, modify, distribute and sell this software
|
||||
// and its documentation for any purpose is hereby granted without fee,
|
||||
// provided that the above copyright notice appear in all copies and
|
||||
// that both that copyright notice and this permission notice appear
|
||||
// in supporting documentation. William E. Kempf makes no representations
|
||||
// about the suitability of this software for any purpose.
|
||||
// It is provided "as is" without express or implied warranty.
|
||||
|
||||
#include <boost/thread/semaphore.hpp>
|
||||
#include <boost/thread/xtime.hpp>
|
||||
#include <boost/limits.hpp>
|
||||
#include <boost/thread/exceptions.hpp>
|
||||
#include <stdexcept>
|
||||
#include <cassert>
|
||||
#include "timeconv.inl"
|
||||
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
# include <windows.h>
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
# include <pthread.h>
|
||||
# include <errno.h>
|
||||
# include <boost/thread/mutex.hpp>
|
||||
# include <boost/thread/condition.hpp>
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
semaphore::semaphore(unsigned count, unsigned max)
|
||||
{
|
||||
if (static_cast<long>(max) <= 0)
|
||||
max = std::numeric_limits<long>::max();
|
||||
|
||||
m_sema = reinterpret_cast<unsigned long>(CreateSemaphore(0, count, max, 0));
|
||||
if (!m_sema)
|
||||
throw thread_resource_error();
|
||||
}
|
||||
|
||||
semaphore::~semaphore()
|
||||
{
|
||||
int res = 0;
|
||||
res = CloseHandle(reinterpret_cast<HANDLE>(m_sema));
|
||||
assert(res);
|
||||
}
|
||||
|
||||
bool semaphore::up(unsigned count, unsigned* prev)
|
||||
{
|
||||
long p;
|
||||
bool ret = !!ReleaseSemaphore(reinterpret_cast<HANDLE>(m_sema), count, &p);
|
||||
|
||||
if (prev)
|
||||
*prev = p;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
void semaphore::down()
|
||||
{
|
||||
int res = 0;
|
||||
res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_sema), INFINITE);
|
||||
assert(res == WAIT_OBJECT_0);
|
||||
}
|
||||
|
||||
bool semaphore::down(const xtime& xt)
|
||||
{
|
||||
unsigned milliseconds;
|
||||
to_duration(xt, milliseconds);
|
||||
int res = 0;
|
||||
res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_sema), milliseconds);
|
||||
assert(res != WAIT_FAILED && res != WAIT_ABANDONED);
|
||||
return res == WAIT_OBJECT_0;
|
||||
}
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
semaphore::semaphore(unsigned count, unsigned max)
|
||||
: m_available(count), m_max(max ? max : std::numeric_limits<unsigned>::max())
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_mutex_init(&m_mutex, 0);
|
||||
if (res != 0)
|
||||
throw thread_resource_error();
|
||||
|
||||
res = pthread_cond_init(&m_condition, 0);
|
||||
if (res != 0)
|
||||
{
|
||||
pthread_mutex_destroy(&m_mutex);
|
||||
throw thread_resource_error();
|
||||
}
|
||||
}
|
||||
|
||||
semaphore::~semaphore()
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_mutex_destroy(&m_mutex);
|
||||
assert(res == 0);
|
||||
|
||||
res = pthread_cond_destroy(&m_condition);
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
bool semaphore::up(unsigned count, unsigned* prev)
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_mutex_lock(&m_mutex);
|
||||
assert(res == 0);
|
||||
|
||||
if (prev)
|
||||
*prev = m_available;
|
||||
|
||||
if (m_available + count > m_max)
|
||||
{
|
||||
res = pthread_mutex_unlock(&m_mutex);
|
||||
assert(res == 0);
|
||||
return false;
|
||||
}
|
||||
|
||||
m_available += count;
|
||||
|
||||
res = pthread_cond_broadcast(&m_condition);
|
||||
assert(res == 0);
|
||||
|
||||
res = pthread_mutex_unlock(&m_mutex);
|
||||
assert(res == 0);
|
||||
return true;
|
||||
}
|
||||
|
||||
void semaphore::down()
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_mutex_lock(&m_mutex);
|
||||
assert(res == 0);
|
||||
|
||||
while (m_available == 0)
|
||||
{
|
||||
res = pthread_cond_wait(&m_condition, &m_mutex);
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
m_available--;
|
||||
res = pthread_mutex_unlock(&m_mutex);
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
bool semaphore::down(const xtime& xt)
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_mutex_lock(&m_mutex);
|
||||
assert(res == 0);
|
||||
|
||||
timespec ts;
|
||||
to_timespec(xt, ts);
|
||||
|
||||
while (m_available == 0)
|
||||
{
|
||||
res = pthread_cond_timedwait(&m_condition, &m_mutex, &ts);
|
||||
assert(res == 0 || res == ETIMEDOUT);
|
||||
|
||||
if (res == ETIMEDOUT)
|
||||
{
|
||||
res = pthread_mutex_unlock(&m_mutex);
|
||||
assert(res == 0);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
m_available--;
|
||||
res = pthread_mutex_unlock(&m_mutex);
|
||||
assert(res == 0);
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
|
||||
} // namespace boost
|
||||
|
||||
// Change Log:
|
||||
// 8 Feb 01 WEKEMPF Initial version.
|
||||
// 22 May 01 WEKEMPF Modified to use xtime for time outs.
|
||||
255
src/thread.cpp
Normal file
255
src/thread.cpp
Normal file
@@ -0,0 +1,255 @@
|
||||
// Copyright (C) 2001
|
||||
// William E. Kempf
|
||||
//
|
||||
// Permission to use, copy, modify, distribute and sell this software
|
||||
// and its documentation for any purpose is hereby granted without fee,
|
||||
// provided that the above copyright notice appear in all copies and
|
||||
// that both that copyright notice and this permission notice appear
|
||||
// in supporting documentation. William E. Kempf makes no representations
|
||||
// about the suitability of this software for any purpose.
|
||||
// It is provided "as is" without express or implied warranty.
|
||||
|
||||
#include <boost/thread/thread.hpp>
|
||||
#include <boost/thread/semaphore.hpp>
|
||||
#include <boost/thread/xtime.hpp>
|
||||
#include <boost/thread/condition.hpp>
|
||||
#include <cassert>
|
||||
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
# include <windows.h>
|
||||
# include <process.h>
|
||||
#endif
|
||||
|
||||
#include "timeconv.inl"
|
||||
|
||||
namespace {
|
||||
|
||||
class thread_param
|
||||
{
|
||||
public:
|
||||
thread_param(const boost::function0<void>& threadfunc) : m_threadfunc(threadfunc), m_started(false) { }
|
||||
void wait()
|
||||
{
|
||||
boost::mutex::scoped_lock scoped_lock(m_mutex);
|
||||
while (!m_started)
|
||||
m_condition.wait(scoped_lock);
|
||||
}
|
||||
void started()
|
||||
{
|
||||
boost::mutex::scoped_lock scoped_lock(m_mutex);
|
||||
m_started = true;
|
||||
m_condition.notify_one();
|
||||
}
|
||||
|
||||
boost::mutex m_mutex;
|
||||
boost::condition m_condition;
|
||||
const boost::function0<void>& m_threadfunc;
|
||||
bool m_started;
|
||||
};
|
||||
|
||||
} // unnamed namespace
|
||||
|
||||
extern "C" {
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
unsigned __stdcall thread_proxy(void* param)
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
static void* thread_proxy(void* param)
|
||||
#endif
|
||||
{
|
||||
try
|
||||
{
|
||||
thread_param* p = static_cast<thread_param*>(param);
|
||||
boost::function0<void> threadfunc = p->m_threadfunc;
|
||||
p->started();
|
||||
threadfunc();
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
namespace boost {
|
||||
|
||||
thread::thread()
|
||||
: m_joinable(false)
|
||||
{
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
m_thread = reinterpret_cast<unsigned long>(GetCurrentThread());
|
||||
m_id = GetCurrentThreadId();
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
m_thread = pthread_self();
|
||||
#endif
|
||||
}
|
||||
|
||||
thread::thread(const function0<void>& threadfunc)
|
||||
: m_joinable(true)
|
||||
{
|
||||
thread_param param(threadfunc);
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
m_thread = _beginthreadex(0, 0, &thread_proxy, ¶m, 0, &m_id);
|
||||
if (!m_thread)
|
||||
throw thread_resource_error();
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
int res = 0;
|
||||
res = pthread_create(&m_thread, 0, &thread_proxy, ¶m);
|
||||
if (res != 0)
|
||||
throw thread_resource_error();
|
||||
#endif
|
||||
param.wait();
|
||||
}
|
||||
|
||||
thread::~thread()
|
||||
{
|
||||
if (m_joinable)
|
||||
{
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
int res = 0;
|
||||
res = CloseHandle(reinterpret_cast<HANDLE>(m_thread));
|
||||
assert(res);
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
pthread_detach(m_thread);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
bool thread::operator==(const thread& other) const
|
||||
{
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
return other.m_id == m_id;
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
return pthread_equal(m_thread, other.m_thread) != 0;
|
||||
#endif
|
||||
}
|
||||
|
||||
bool thread::operator!=(const thread& other) const
|
||||
{
|
||||
return !operator==(other);
|
||||
}
|
||||
|
||||
void thread::join()
|
||||
{
|
||||
int res = 0;
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_thread), INFINITE);
|
||||
assert(res == WAIT_OBJECT_0);
|
||||
res = CloseHandle(reinterpret_cast<HANDLE>(m_thread));
|
||||
assert(res);
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
res = pthread_join(m_thread, 0);
|
||||
assert(res == 0);
|
||||
#endif
|
||||
// This isn't a race condition since any race that could occur would
|
||||
// have us in undefined behavior territory any way.
|
||||
m_joinable = false;
|
||||
}
|
||||
|
||||
void thread::sleep(const xtime& xt)
|
||||
{
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
unsigned milliseconds;
|
||||
to_duration(xt, milliseconds);
|
||||
Sleep(milliseconds);
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
# if defined(BOOST_HAS_PTHREAD_DELAY_NP)
|
||||
timespec ts;
|
||||
to_timespec(xt, ts);
|
||||
int res = 0;
|
||||
res = pthread_delay_np(&ts);
|
||||
assert(res == 0);
|
||||
# elif defined(BOOST_HAS_NANOSLEEP)
|
||||
timespec ts;
|
||||
to_timespec_duration(xt, ts);
|
||||
|
||||
// nanosleep takes a timespec that is an offset, not
|
||||
// an absolute time.
|
||||
nanosleep(&ts, 0);
|
||||
# else
|
||||
semaphore sema;
|
||||
sema.down(xt);
|
||||
# endif
|
||||
#endif
|
||||
}
|
||||
|
||||
void thread::yield()
|
||||
{
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
Sleep(0);
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
# if defined(BOOST_HAS_SCHED_YIELD)
|
||||
int res = 0;
|
||||
res = sched_yield();
|
||||
assert(res == 0);
|
||||
# elif defined(BOOST_HAS_PTHREAD_YIELD)
|
||||
int res = 0;
|
||||
res = pthread_yield();
|
||||
assert(res == 0);
|
||||
# else
|
||||
xtime xt;
|
||||
xtime_get(&xt, TIME_UTC);
|
||||
sleep(xt);
|
||||
# endif
|
||||
#endif
|
||||
}
|
||||
|
||||
thread_group::thread_group()
|
||||
{
|
||||
}
|
||||
|
||||
thread_group::~thread_group()
|
||||
{
|
||||
// We shouldn't have to scoped_lock here, since referencing this object from another thread
|
||||
// while we're deleting it in the current thread is going to lead to undefined behavior
|
||||
// any way.
|
||||
for (std::list<thread*>::iterator it = m_threads.begin(); it != m_threads.end(); ++it)
|
||||
delete (*it);
|
||||
}
|
||||
|
||||
thread* thread_group::create_thread(const function0<void>& threadfunc)
|
||||
{
|
||||
// No scoped_lock required here since the only "shared data" that's modified here occurs
|
||||
// inside add_thread which does scoped_lock.
|
||||
std::auto_ptr<thread> thrd(new thread(threadfunc));
|
||||
add_thread(thrd.get());
|
||||
return thrd.release();
|
||||
}
|
||||
|
||||
void thread_group::add_thread(thread* thrd)
|
||||
{
|
||||
mutex::scoped_lock scoped_lock(m_mutex);
|
||||
|
||||
// For now we'll simply ignore requests to add a thread object multiple times.
|
||||
// Should we consider this an error and either throw or return an error value?
|
||||
std::list<thread*>::iterator it = std::find(m_threads.begin(), m_threads.end(), thrd);
|
||||
assert(it == m_threads.end());
|
||||
if (it == m_threads.end())
|
||||
m_threads.push_back(thrd);
|
||||
}
|
||||
|
||||
void thread_group::remove_thread(thread* thrd)
|
||||
{
|
||||
mutex::scoped_lock scoped_lock(m_mutex);
|
||||
|
||||
// For now we'll simply ignore requests to remove a thread object that's not in the group.
|
||||
// Should we consider this an error and either throw or return an error value?
|
||||
std::list<thread*>::iterator it = std::find(m_threads.begin(), m_threads.end(), thrd);
|
||||
assert(it != m_threads.end());
|
||||
if (it != m_threads.end())
|
||||
m_threads.erase(it);
|
||||
}
|
||||
|
||||
void thread_group::join_all()
|
||||
{
|
||||
mutex::scoped_lock scoped_lock(m_mutex);
|
||||
for (std::list<thread*>::iterator it = m_threads.begin(); it != m_threads.end(); ++it)
|
||||
(*it)->join();
|
||||
}
|
||||
|
||||
} // namespace boost
|
||||
|
||||
// Change Log:
|
||||
// 8 Feb 01 WEKEMPF Initial version.
|
||||
// 1 Jun 01 WEKEMPF Added boost::thread initial implementation.
|
||||
// 3 Jul 01 WEKEMPF Redesigned boost::thread to be noncopyable.
|
||||
138
src/threadmon.cpp
Normal file
138
src/threadmon.cpp
Normal file
@@ -0,0 +1,138 @@
|
||||
// threadmon.cpp : Defines the entry point for the DLL application.
|
||||
//
|
||||
|
||||
#define BOOST_THREADMON_EXPORTS
|
||||
#include "threadmon.hpp"
|
||||
|
||||
#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
|
||||
#include <windows.h>
|
||||
|
||||
#pragma warning(disable : 4786)
|
||||
#include <list>
|
||||
#include <set>
|
||||
#include <algorithm>
|
||||
|
||||
typedef void (__cdecl * handler)(void);
|
||||
typedef std::list<handler> exit_handlers;
|
||||
typedef std::set<exit_handlers*> registered_handlers;
|
||||
|
||||
namespace
|
||||
{
|
||||
CRITICAL_SECTION cs;
|
||||
DWORD key;
|
||||
registered_handlers registry;
|
||||
}
|
||||
|
||||
#if defined(__BORLANDC__)
|
||||
#define DllMain DllEntryPoint
|
||||
#endif
|
||||
|
||||
BOOL APIENTRY DllMain(HANDLE module, DWORD reason, LPVOID)
|
||||
{
|
||||
switch (reason)
|
||||
{
|
||||
case DLL_PROCESS_ATTACH:
|
||||
InitializeCriticalSection(&cs);
|
||||
key = TlsAlloc();
|
||||
break;
|
||||
case DLL_THREAD_ATTACH:
|
||||
break;
|
||||
case DLL_THREAD_DETACH:
|
||||
{
|
||||
// Call the thread's exit handlers.
|
||||
exit_handlers* handlers = static_cast<exit_handlers*>(TlsGetValue(key));
|
||||
if (handlers)
|
||||
{
|
||||
for (exit_handlers::iterator it = handlers->begin(); it != handlers->end(); ++it)
|
||||
(*it)();
|
||||
|
||||
// Remove the exit handler list from the registered lists and then destroy it.
|
||||
EnterCriticalSection(&cs);
|
||||
registry.erase(handlers);
|
||||
LeaveCriticalSection(&cs);
|
||||
delete handlers;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case DLL_PROCESS_DETACH:
|
||||
{
|
||||
// Assume the main thread is ending (call its handlers) and all other threads
|
||||
// have already ended. If this DLL is loaded and unloaded dynamically at run time
|
||||
// this is a bad assumption, but this is the best we can do.
|
||||
exit_handlers* handlers = static_cast<exit_handlers*>(TlsGetValue(key));
|
||||
if (handlers)
|
||||
{
|
||||
for (exit_handlers::iterator it = handlers->begin(); it != handlers->end(); ++it)
|
||||
(*it)();
|
||||
}
|
||||
|
||||
// Destroy any remaining exit handlers. Above we assumed there'd only be the main
|
||||
// thread left, but to insure we don't get memory leaks we won't make that assumption
|
||||
// here.
|
||||
EnterCriticalSection(&cs);
|
||||
for (registered_handlers::iterator it = registry.begin(); it != registry.end(); ++it)
|
||||
delete (*it);
|
||||
LeaveCriticalSection(&cs);
|
||||
DeleteCriticalSection(&cs);
|
||||
TlsFree(key);
|
||||
}
|
||||
break;
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
int on_thread_exit(void (__cdecl * func)(void))
|
||||
{
|
||||
// Get the exit handlers for the current thread, creating and registering
|
||||
// one if it doesn't exist.
|
||||
exit_handlers* handlers = static_cast<exit_handlers*>(TlsGetValue(key));
|
||||
if (!handlers)
|
||||
{
|
||||
try
|
||||
{
|
||||
handlers = new exit_handlers;
|
||||
// Handle "broken" implementations of operator new that don't throw.
|
||||
if (!handlers)
|
||||
return -1;
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Attempt to set a TLS value for the new handlers.
|
||||
if (!TlsSetValue(key, handlers))
|
||||
{
|
||||
delete handlers;
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Attempt to register this new handler so that memory can be properly
|
||||
// cleaned up.
|
||||
try
|
||||
{
|
||||
EnterCriticalSection(&cs);
|
||||
registry.insert(handlers);
|
||||
LeaveCriticalSection(&cs);
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
LeaveCriticalSection(&cs);
|
||||
delete handlers;
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
// Attempt to add the handler to the list of exit handlers. If it's been previously
|
||||
// added just report success and exit.
|
||||
try
|
||||
{
|
||||
handlers->push_front(func);
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
14
src/threadmon.hpp
Normal file
14
src/threadmon.hpp
Normal file
@@ -0,0 +1,14 @@
|
||||
|
||||
// The following ifdef block is the standard way of creating macros which make exporting
|
||||
// from a DLL simpler. All files within this DLL are compiled with the BOOST_THREADMON_EXPORTS
|
||||
// symbol defined on the command line. this symbol should not be defined on any project
|
||||
// that uses this DLL. This way any other project whose source files include this file see
|
||||
// BOOST_THREADMON_API functions as being imported from a DLL, wheras this DLL sees symbols
|
||||
// defined with this macro as being exported.
|
||||
#ifdef BOOST_THREADMON_EXPORTS
|
||||
#define BOOST_THREADMON_API __declspec(dllexport)
|
||||
#else
|
||||
#define BOOST_THREADMON_API __declspec(dllimport)
|
||||
#endif
|
||||
|
||||
extern "C" BOOST_THREADMON_API int on_thread_exit(void (__cdecl * func)(void));
|
||||
92
src/timeconv.inl
Normal file
92
src/timeconv.inl
Normal file
@@ -0,0 +1,92 @@
|
||||
// Copyright (C) 2001
|
||||
// William E. Kempf
|
||||
//
|
||||
// Permission to use, copy, modify, distribute and sell this software
|
||||
// and its documentation for any purpose is hereby granted without fee,
|
||||
// provided that the above copyright notice appear in all copies and
|
||||
// that both that copyright notice and this permission notice appear
|
||||
// in supporting documentation. William E. Kempf makes no representations
|
||||
// about the suitability of this software for any purpose.
|
||||
// It is provided "as is" without express or implied warranty.
|
||||
|
||||
namespace {
|
||||
const unsigned MILLISECONDS_PER_SECOND = 1000;
|
||||
const unsigned NANOSECONDS_PER_SECOND = 1000000000;
|
||||
const unsigned NANOSECONDS_PER_MILLISECOND = 1000000;
|
||||
|
||||
inline void to_time(unsigned milliseconds, boost::xtime& xt)
|
||||
{
|
||||
int res = 0;
|
||||
res = boost::xtime_get(&xt, boost::TIME_UTC);
|
||||
assert(res == boost::TIME_UTC);
|
||||
|
||||
xt.sec += (milliseconds / MILLISECONDS_PER_SECOND);
|
||||
xt.nsec += ((milliseconds % MILLISECONDS_PER_SECOND) * NANOSECONDS_PER_MILLISECOND);
|
||||
|
||||
if (xt.nsec > NANOSECONDS_PER_SECOND)
|
||||
{
|
||||
++xt.sec;
|
||||
xt.nsec -= NANOSECONDS_PER_SECOND;
|
||||
}
|
||||
}
|
||||
|
||||
#if defined(BOOST_HAS_PTHREADS)
|
||||
inline void to_timespec(const boost::xtime& xt, timespec& ts)
|
||||
{
|
||||
ts.tv_sec = static_cast<int>(xt.sec);
|
||||
ts.tv_nsec = static_cast<int>(xt.nsec);
|
||||
}
|
||||
|
||||
inline void to_time(unsigned milliseconds, timespec& ts)
|
||||
{
|
||||
boost::xtime xt;
|
||||
to_time(milliseconds, xt);
|
||||
to_timespec(xt, ts);
|
||||
}
|
||||
|
||||
inline void to_timespec_duration(const boost::xtime& xt, timespec& ts)
|
||||
{
|
||||
boost::xtime cur;
|
||||
int res = 0;
|
||||
res = boost::xtime_get(&cur, boost::TIME_UTC);
|
||||
assert(res == boost::TIME_UTC);
|
||||
|
||||
if (xt.sec < cur.sec || (xt.sec == cur.sec && xt.nsec < cur.nsec))
|
||||
{
|
||||
ts.tv_sec = 0;
|
||||
ts.tv_nsec = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
ts.tv_sec = xt.sec - cur.sec;
|
||||
ts.tv_nsec = xt.nsec - cur.nsec;
|
||||
|
||||
if( ts.tv_nsec < 0 )
|
||||
{
|
||||
ts.tv_sec -= 1;
|
||||
ts.tv_nsec += NANOSECONDS_PER_SECOND;
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
inline void to_duration(const boost::xtime& xt, unsigned& milliseconds)
|
||||
{
|
||||
boost::xtime cur;
|
||||
int res = 0;
|
||||
res = boost::xtime_get(&cur, boost::TIME_UTC);
|
||||
assert(res == boost::TIME_UTC);
|
||||
|
||||
if (xt.sec < cur.sec || (xt.sec == cur.sec && xt.nsec < cur.nsec))
|
||||
milliseconds = 0;
|
||||
else
|
||||
{
|
||||
milliseconds = static_cast<unsigned>(((xt.sec - cur.sec) * MILLISECONDS_PER_SECOND) +
|
||||
(((xt.nsec - cur.nsec) + (NANOSECONDS_PER_MILLISECOND/2)) /
|
||||
NANOSECONDS_PER_MILLISECOND));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Change Log:
|
||||
// 1 Jun 01 Initial creation.
|
||||
145
src/tss.cpp
Normal file
145
src/tss.cpp
Normal file
@@ -0,0 +1,145 @@
|
||||
// Copyright (C) 2001
|
||||
// William E. Kempf
|
||||
//
|
||||
// Permission to use, copy, modify, distribute and sell this software
|
||||
// and its documentation for any purpose is hereby granted without fee,
|
||||
// provided that the above copyright notice appear in all copies and
|
||||
// that both that copyright notice and this permission notice appear
|
||||
// in supporting documentation. William E. Kempf makes no representations
|
||||
// about the suitability of this software for any purpose.
|
||||
// It is provided "as is" without express or implied warranty.
|
||||
|
||||
#include <boost/thread/tss.hpp>
|
||||
#include <boost/thread/once.hpp>
|
||||
#include <boost/thread/exceptions.hpp>
|
||||
#include <stdexcept>
|
||||
#include <cassert>
|
||||
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
# include <windows.h>
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
#include "threadmon.hpp"
|
||||
#include <map>
|
||||
namespace {
|
||||
typedef std::pair<void(*)(void*), void*> cleanup_info;
|
||||
typedef std::map<int, cleanup_info> cleanup_handlers;
|
||||
|
||||
DWORD key;
|
||||
boost::once_flag once = boost::once_init;
|
||||
|
||||
void init_cleanup_key()
|
||||
{
|
||||
key = TlsAlloc();
|
||||
assert(key != 0xFFFFFFFF);
|
||||
}
|
||||
|
||||
void __cdecl cleanup()
|
||||
{
|
||||
cleanup_handlers* handlers = static_cast<cleanup_handlers*>(TlsGetValue(key));
|
||||
for (cleanup_handlers::iterator it = handlers->begin(); it != handlers->end(); ++it)
|
||||
{
|
||||
cleanup_info info = it->second;
|
||||
if (info.second)
|
||||
info.first(info.second);
|
||||
}
|
||||
delete handlers;
|
||||
}
|
||||
|
||||
cleanup_handlers* get_handlers()
|
||||
{
|
||||
boost::call_once(&init_cleanup_key, once);
|
||||
|
||||
cleanup_handlers* handlers = static_cast<cleanup_handlers*>(TlsGetValue(key));
|
||||
if (!handlers)
|
||||
{
|
||||
try
|
||||
{
|
||||
handlers = new cleanup_handlers;
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
int res = 0;
|
||||
res = TlsSetValue(key, handlers);
|
||||
assert(res);
|
||||
res = on_thread_exit(&cleanup);
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
return handlers;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
namespace boost { namespace detail {
|
||||
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
tss::tss(void (*cleanup)(void*))
|
||||
{
|
||||
m_key = TlsAlloc();
|
||||
if (m_key == 0xFFFFFFFF)
|
||||
throw thread_resource_error();
|
||||
|
||||
m_cleanup = cleanup;
|
||||
}
|
||||
|
||||
tss::~tss()
|
||||
{
|
||||
int res = 0;
|
||||
res = TlsFree(m_key);
|
||||
assert(res);
|
||||
}
|
||||
|
||||
void* tss::get() const
|
||||
{
|
||||
return TlsGetValue(m_key);
|
||||
}
|
||||
|
||||
bool tss::set(void* value)
|
||||
{
|
||||
if (value && m_cleanup)
|
||||
{
|
||||
cleanup_handlers* handlers = get_handlers();
|
||||
assert(handlers);
|
||||
if (!handlers)
|
||||
return false;
|
||||
cleanup_info info(m_cleanup, value);
|
||||
(*handlers)[m_key] = info;
|
||||
}
|
||||
return !!TlsSetValue(m_key, value);
|
||||
}
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
tss::tss(void (*cleanup)(void*))
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_key_create(&m_key, cleanup);
|
||||
if (res != 0)
|
||||
throw thread_resource_error();
|
||||
}
|
||||
|
||||
tss::~tss()
|
||||
{
|
||||
int res = 0;
|
||||
res = pthread_key_delete(m_key);
|
||||
assert(res == 0);
|
||||
}
|
||||
|
||||
void* tss::get() const
|
||||
{
|
||||
return pthread_getspecific(m_key);
|
||||
}
|
||||
|
||||
bool tss::set(void* value)
|
||||
{
|
||||
return pthread_setspecific(m_key, value) == 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
} // namespace detail
|
||||
} // namespace boost
|
||||
|
||||
// Change Log:
|
||||
// 6 Jun 01 WEKEMPF Initial version.
|
||||
56
src/xtime.cpp
Normal file
56
src/xtime.cpp
Normal file
@@ -0,0 +1,56 @@
|
||||
// Copyright (C) 2001
|
||||
// William E. Kempf
|
||||
//
|
||||
// Permission to use, copy, modify, distribute and sell this software
|
||||
// and its documentation for any purpose is hereby granted without fee,
|
||||
// provided that the above copyright notice appear in all copies and
|
||||
// that both that copyright notice and this permission notice appear
|
||||
// in supporting documentation. William E. Kempf makes no representations
|
||||
// about the suitability of this software for any purpose.
|
||||
// It is provided "as is" without express or implied warranty.
|
||||
|
||||
#include <boost/thread/xtime.hpp>
|
||||
|
||||
#if defined(BOOST_HAS_FTIME)
|
||||
# include <windows.h>
|
||||
#elif defined(BOOST_HAS_GETTIMEOFDAY)
|
||||
# include <sys/time.h>
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
|
||||
int xtime_get(struct xtime* xtp, int clock_type)
|
||||
{
|
||||
if (clock_type == TIME_UTC)
|
||||
{
|
||||
#if defined(BOOST_HAS_FTIME)
|
||||
FILETIME ft;
|
||||
GetSystemTimeAsFileTime(&ft);
|
||||
const __int64 TIMESPEC_TO_FILETIME_OFFSET = ((__int64)27111902 << 32) + (__int64)3577643008;
|
||||
xtp->sec = (int)((*(__int64*)&ft - TIMESPEC_TO_FILETIME_OFFSET) / 10000000);
|
||||
xtp->nsec = (int)((*(__int64*)&ft - TIMESPEC_TO_FILETIME_OFFSET -
|
||||
((__int64)xtp->sec * (__int64)10000000)) * 100);
|
||||
return clock_type;
|
||||
#elif defined(BOOST_HAS_GETTIMEOFDAY)
|
||||
struct timeval tv;
|
||||
gettimeofday(&tv, 0);
|
||||
xtp->sec = tv.tv_sec;
|
||||
xtp->nsec = tv.tv_usec * 1000;
|
||||
return clock_type;
|
||||
#elif defined(BOOST_HAS_CLOCK_GETTIME)
|
||||
timespec ts;
|
||||
clock_gettime(CLOCK_REALTIME, &ts);
|
||||
xtp->sec = ts.tv_sec;
|
||||
xtp->nsec = ts.tv_nsec;
|
||||
return clock_type;
|
||||
#else
|
||||
# error "xtime_get implementation undefined"
|
||||
#endif
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
} // namespace boost
|
||||
|
||||
// Change Log:
|
||||
// 8 Feb 01 WEKEMPF Initial version.
|
||||
487
test/test_thread.cpp
Normal file
487
test/test_thread.cpp
Normal file
@@ -0,0 +1,487 @@
|
||||
#include <list>
|
||||
#include <boost/thread/mutex.hpp>
|
||||
#include <boost/thread/recursive_mutex.hpp>
|
||||
#include <boost/thread/condition.hpp>
|
||||
#include <boost/thread/semaphore.hpp>
|
||||
//#include <boost/thread/atomic.hpp>
|
||||
#include <boost/thread/tss.hpp>
|
||||
#include <boost/thread/once.hpp>
|
||||
#include <boost/thread/thread.hpp>
|
||||
#include <boost/thread/xtime.hpp>
|
||||
|
||||
#define BOOST_INCLUDE_MAIN
|
||||
#include <boost/test/test_tools.hpp>
|
||||
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
# include <windows.h>
|
||||
#endif
|
||||
|
||||
template <typename M>
|
||||
void test_lock(M* dummy=0)
|
||||
{
|
||||
typedef M mutex_type;
|
||||
typedef typename M::scoped_lock lock_type;
|
||||
|
||||
mutex_type mutex;
|
||||
boost::condition condition;
|
||||
|
||||
// Test the lock's constructors.
|
||||
{
|
||||
lock_type lock(mutex, false);
|
||||
BOOST_TEST(!lock);
|
||||
}
|
||||
lock_type lock(mutex);
|
||||
BOOST_TEST(lock);
|
||||
|
||||
// Construct and initialize an xtime for a fast time out.
|
||||
boost::xtime xt;
|
||||
BOOST_TEST(boost::xtime_get(&xt, boost::TIME_UTC) == boost::TIME_UTC);
|
||||
xt.nsec += 100000000;
|
||||
|
||||
// Test the lock and the mutex with condition variables.
|
||||
// No one is going to notify this condition variable. We expect to
|
||||
// time out.
|
||||
BOOST_TEST(condition.timed_wait(lock, xt) == false);
|
||||
BOOST_TEST(lock);
|
||||
|
||||
// Test the lock and unlock methods.
|
||||
lock.unlock();
|
||||
BOOST_TEST(!lock);
|
||||
lock.lock();
|
||||
BOOST_TEST(lock);
|
||||
}
|
||||
|
||||
template <typename M>
|
||||
void test_trylock(M* dummy=0)
|
||||
{
|
||||
typedef M mutex_type;
|
||||
typedef typename M::scoped_try_lock try_lock_type;
|
||||
|
||||
mutex_type mutex;
|
||||
boost::condition condition;
|
||||
|
||||
// Test the lock's constructors.
|
||||
{
|
||||
try_lock_type lock(mutex);
|
||||
BOOST_TEST(lock);
|
||||
}
|
||||
{
|
||||
try_lock_type lock(mutex, false);
|
||||
BOOST_TEST(!lock);
|
||||
}
|
||||
try_lock_type lock(mutex, true);
|
||||
BOOST_TEST(lock);
|
||||
|
||||
// Construct and initialize an xtime for a fast time out.
|
||||
boost::xtime xt;
|
||||
BOOST_TEST(boost::xtime_get(&xt, boost::TIME_UTC) == boost::TIME_UTC);
|
||||
xt.nsec += 100000000;
|
||||
|
||||
// Test the lock and the mutex with condition variables.
|
||||
// No one is going to notify this condition variable. We expect to
|
||||
// time out.
|
||||
BOOST_TEST(condition.timed_wait(lock, xt) == false);
|
||||
BOOST_TEST(lock);
|
||||
|
||||
// Test the lock, unlock and trylock methods.
|
||||
lock.unlock();
|
||||
BOOST_TEST(!lock);
|
||||
lock.lock();
|
||||
BOOST_TEST(lock);
|
||||
lock.unlock();
|
||||
BOOST_TEST(!lock);
|
||||
BOOST_TEST(lock.try_lock());
|
||||
BOOST_TEST(lock);
|
||||
}
|
||||
|
||||
template <typename M>
|
||||
void test_timedlock(M* dummy=0)
|
||||
{
|
||||
typedef M mutex_type;
|
||||
typedef typename M::scoped_timed_lock timed_lock_type;
|
||||
|
||||
mutex_type mutex;
|
||||
boost::condition condition;
|
||||
|
||||
// Test the lock's constructors.
|
||||
{
|
||||
// Construct and initialize an xtime for a fast time out.
|
||||
boost::xtime xt;
|
||||
BOOST_TEST(boost::xtime_get(&xt, boost::TIME_UTC) == boost::TIME_UTC);
|
||||
xt.nsec += 100000000;
|
||||
|
||||
timed_lock_type lock(mutex, xt);
|
||||
BOOST_TEST(lock);
|
||||
}
|
||||
{
|
||||
timed_lock_type lock(mutex, false);
|
||||
BOOST_TEST(!lock);
|
||||
}
|
||||
timed_lock_type lock(mutex, true);
|
||||
BOOST_TEST(lock);
|
||||
|
||||
// Construct and initialize an xtime for a fast time out.
|
||||
boost::xtime xt;
|
||||
BOOST_TEST(boost::xtime_get(&xt, boost::TIME_UTC) == boost::TIME_UTC);
|
||||
xt.nsec += 100000000;
|
||||
|
||||
// Test the lock and the mutex with condition variables.
|
||||
// No one is going to notify this condition variable. We expect to
|
||||
// time out.
|
||||
BOOST_TEST(condition.timed_wait(lock, xt) == false);
|
||||
BOOST_TEST(lock);
|
||||
|
||||
// Test the lock, unlock and timedlock methods.
|
||||
lock.unlock();
|
||||
BOOST_TEST(!lock);
|
||||
lock.lock();
|
||||
BOOST_TEST(lock);
|
||||
lock.unlock();
|
||||
BOOST_TEST(!lock);
|
||||
BOOST_TEST(boost::xtime_get(&xt, boost::TIME_UTC) == boost::TIME_UTC);
|
||||
xt.nsec += 100000000;
|
||||
BOOST_TEST(lock.timed_lock(xt));
|
||||
}
|
||||
|
||||
void test_mutex()
|
||||
{
|
||||
typedef boost::mutex mutex;
|
||||
test_lock<mutex>();
|
||||
}
|
||||
|
||||
void test_try_mutex()
|
||||
{
|
||||
typedef boost::try_mutex mutex;
|
||||
test_lock<mutex>();
|
||||
test_trylock<mutex>();
|
||||
}
|
||||
|
||||
void test_timed_mutex()
|
||||
{
|
||||
typedef boost::timed_mutex mutex;
|
||||
test_lock<mutex>();
|
||||
test_trylock<mutex>();
|
||||
test_timedlock<mutex>();
|
||||
}
|
||||
|
||||
void test_recursive_mutex()
|
||||
{
|
||||
typedef boost::recursive_mutex mutex;
|
||||
test_lock<mutex>();
|
||||
mutex mx;
|
||||
mutex::scoped_lock lock1(mx);
|
||||
mutex::scoped_lock lock2(mx);
|
||||
}
|
||||
|
||||
void test_recursive_try_mutex()
|
||||
{
|
||||
typedef boost::recursive_try_mutex mutex;
|
||||
test_lock<mutex>();
|
||||
test_trylock<mutex>();
|
||||
mutex mx;
|
||||
mutex::scoped_lock lock1(mx);
|
||||
mutex::scoped_lock lock2(mx);
|
||||
}
|
||||
|
||||
void test_recursive_timed_mutex()
|
||||
{
|
||||
typedef boost::recursive_timed_mutex mutex;
|
||||
test_lock<mutex>();
|
||||
test_trylock<mutex>();
|
||||
test_timedlock<mutex>();
|
||||
mutex mx;
|
||||
mutex::scoped_lock lock1(mx);
|
||||
mutex::scoped_lock lock2(mx);
|
||||
}
|
||||
|
||||
struct condition_test_data
|
||||
{
|
||||
condition_test_data() : notified(0), awoken(0) { }
|
||||
|
||||
boost::mutex mutex;
|
||||
boost::condition condition;
|
||||
int notified;
|
||||
int awoken;
|
||||
};
|
||||
|
||||
void condition_test_thread(void* param)
|
||||
{
|
||||
condition_test_data* data = static_cast<condition_test_data*>(param);
|
||||
boost::mutex::scoped_lock lock(data->mutex);
|
||||
BOOST_TEST(lock);
|
||||
while (!(data->notified > 0))
|
||||
data->condition.wait(lock);
|
||||
BOOST_TEST(lock);
|
||||
data->awoken++;
|
||||
}
|
||||
|
||||
class thread_adapter
|
||||
{
|
||||
public:
|
||||
thread_adapter(void (*func)(void*), void* param) : _func(func), _param(param) { }
|
||||
void operator()() const { _func(_param); }
|
||||
private:
|
||||
void (*_func)(void*);
|
||||
void* _param;
|
||||
};
|
||||
|
||||
void test_condition_notify_one()
|
||||
{
|
||||
condition_test_data data;
|
||||
|
||||
boost::thread thread(thread_adapter(&condition_test_thread, &data));
|
||||
|
||||
{
|
||||
boost::mutex::scoped_lock lock(data.mutex);
|
||||
BOOST_TEST(lock);
|
||||
data.notified++;
|
||||
data.condition.notify_one();
|
||||
}
|
||||
|
||||
thread.join();
|
||||
BOOST_TEST(data.awoken == 1);
|
||||
}
|
||||
|
||||
void test_condition_notify_all()
|
||||
{
|
||||
const int NUMTHREADS = 5;
|
||||
boost::thread_group threads;
|
||||
condition_test_data data;
|
||||
|
||||
for (int i = 0; i < NUMTHREADS; ++i)
|
||||
threads.create_thread(thread_adapter(&condition_test_thread, &data));
|
||||
|
||||
{
|
||||
boost::mutex::scoped_lock lock(data.mutex);
|
||||
BOOST_TEST(lock);
|
||||
data.notified++;
|
||||
data.condition.notify_all();
|
||||
}
|
||||
|
||||
threads.join_all();
|
||||
BOOST_TEST(data.awoken == NUMTHREADS);
|
||||
}
|
||||
|
||||
struct cond_predicate
|
||||
{
|
||||
cond_predicate(int& var, int val) : _var(var), _val(val) { }
|
||||
|
||||
bool operator()() { return _var == _val; }
|
||||
|
||||
int& _var;
|
||||
int _val;
|
||||
};
|
||||
|
||||
void condition_test_waits(void* param)
|
||||
{
|
||||
condition_test_data* data = static_cast<condition_test_data*>(param);
|
||||
|
||||
boost::mutex::scoped_lock lock(data->mutex);
|
||||
BOOST_TEST(lock);
|
||||
|
||||
// Test wait.
|
||||
while (data->notified != 1)
|
||||
data->condition.wait(lock);
|
||||
BOOST_TEST(lock);
|
||||
BOOST_TEST(data->notified == 1);
|
||||
data->awoken++;
|
||||
data->condition.notify_one();
|
||||
|
||||
// Test predicate wait.
|
||||
data->condition.wait(lock, cond_predicate(data->notified, 2));
|
||||
BOOST_TEST(lock);
|
||||
BOOST_TEST(data->notified == 2);
|
||||
data->awoken++;
|
||||
data->condition.notify_one();
|
||||
|
||||
// Test timed_wait.
|
||||
boost::xtime xt;
|
||||
BOOST_TEST(boost::xtime_get(&xt, boost::TIME_UTC) == boost::TIME_UTC);
|
||||
xt.nsec += 100000000;
|
||||
while (data->notified != 3)
|
||||
data->condition.timed_wait(lock, xt);
|
||||
BOOST_TEST(lock);
|
||||
BOOST_TEST(data->notified == 3);
|
||||
data->awoken++;
|
||||
data->condition.notify_one();
|
||||
|
||||
// Test predicate timed_wait.
|
||||
BOOST_TEST(boost::xtime_get(&xt, boost::TIME_UTC) == boost::TIME_UTC);
|
||||
xt.sec += 2;
|
||||
BOOST_TEST(data->condition.timed_wait(lock, xt, cond_predicate(data->notified, 4)));
|
||||
BOOST_TEST(lock);
|
||||
BOOST_TEST(data->notified == 4);
|
||||
data->awoken++;
|
||||
}
|
||||
|
||||
void test_condition_waits()
|
||||
{
|
||||
condition_test_data data;
|
||||
|
||||
boost::thread thread(thread_adapter(&condition_test_waits, &data));
|
||||
|
||||
boost::xtime xt;
|
||||
|
||||
{
|
||||
boost::mutex::scoped_lock lock(data.mutex);
|
||||
BOOST_TEST(lock);
|
||||
|
||||
BOOST_TEST(boost::xtime_get(&xt, boost::TIME_UTC) == boost::TIME_UTC);
|
||||
xt.sec += 1;
|
||||
boost::thread::sleep(xt);
|
||||
data.notified++;
|
||||
data.condition.notify_one();
|
||||
while (data.awoken != 1)
|
||||
data.condition.wait(lock);
|
||||
BOOST_TEST(data.awoken == 1);
|
||||
|
||||
BOOST_TEST(boost::xtime_get(&xt, boost::TIME_UTC) == boost::TIME_UTC);
|
||||
xt.sec += 1;
|
||||
boost::thread::sleep(xt);
|
||||
data.notified++;
|
||||
data.condition.notify_one();
|
||||
while (data.awoken != 2)
|
||||
data.condition.wait(lock);
|
||||
BOOST_TEST(data.awoken == 2);
|
||||
|
||||
BOOST_TEST(boost::xtime_get(&xt, boost::TIME_UTC) == boost::TIME_UTC);
|
||||
xt.sec += 1;
|
||||
boost::thread::sleep(xt);
|
||||
data.notified++;
|
||||
data.condition.notify_one();
|
||||
while (data.awoken != 3)
|
||||
data.condition.wait(lock);
|
||||
BOOST_TEST(data.awoken == 3);
|
||||
}
|
||||
|
||||
BOOST_TEST(boost::xtime_get(&xt, boost::TIME_UTC) == boost::TIME_UTC);
|
||||
xt.sec += 1;
|
||||
boost::thread::sleep(xt);
|
||||
data.notified++;
|
||||
data.condition.notify_one();
|
||||
BOOST_TEST(boost::xtime_get(&xt, boost::TIME_UTC) == boost::TIME_UTC);
|
||||
xt.sec += 1;
|
||||
boost::thread::sleep(xt);
|
||||
thread.join();
|
||||
BOOST_TEST(data.awoken == 4);
|
||||
}
|
||||
|
||||
void test_condition()
|
||||
{
|
||||
test_condition_notify_one();
|
||||
test_condition_notify_all();
|
||||
test_condition_waits();
|
||||
}
|
||||
|
||||
void test_semaphore()
|
||||
{
|
||||
boost::xtime xt;
|
||||
unsigned val;
|
||||
boost::semaphore sema(0, 1);
|
||||
|
||||
BOOST_TEST(sema.up(1, &val));
|
||||
BOOST_TEST(val == 0);
|
||||
BOOST_TEST(!sema.up());
|
||||
|
||||
sema.down();
|
||||
BOOST_TEST(sema.up());
|
||||
|
||||
BOOST_TEST(boost::xtime_get(&xt, boost::TIME_UTC) == boost::TIME_UTC);
|
||||
xt.nsec += 100000000;
|
||||
BOOST_TEST(sema.down(xt));
|
||||
BOOST_TEST(boost::xtime_get(&xt, boost::TIME_UTC) == boost::TIME_UTC);
|
||||
xt.nsec += 100000000;
|
||||
BOOST_TEST(!sema.down(xt));
|
||||
}
|
||||
|
||||
/*void test_atomic_t()
|
||||
{
|
||||
boost::atomic_t atomic;
|
||||
BOOST_TEST(boost::increment(atomic) > 0);
|
||||
BOOST_TEST(boost::decrement(atomic) == 0);
|
||||
BOOST_TEST(boost::swap(atomic, 10) == 0);
|
||||
BOOST_TEST(boost::swap(atomic, 0) == 10);
|
||||
BOOST_TEST(boost::compare_swap(atomic, 20, 10) == 0);
|
||||
BOOST_TEST(boost::compare_swap(atomic, 20, 0) == 0);
|
||||
BOOST_TEST(boost::read(atomic) == 20);
|
||||
}*/
|
||||
|
||||
boost::mutex tss_mutex;
|
||||
int tss_instances = 0;
|
||||
|
||||
struct tss_value_t
|
||||
{
|
||||
tss_value_t()
|
||||
{
|
||||
boost::mutex::scoped_lock lock(tss_mutex);
|
||||
++tss_instances;
|
||||
value = 0;
|
||||
}
|
||||
~tss_value_t()
|
||||
{
|
||||
boost::mutex::scoped_lock lock(tss_mutex);
|
||||
--tss_instances;
|
||||
}
|
||||
int value;
|
||||
};
|
||||
|
||||
boost::thread_specific_ptr<tss_value_t> tss_value;
|
||||
|
||||
void test_tss_thread()
|
||||
{
|
||||
tss_value.reset(new tss_value_t());
|
||||
for (int i=0; i<1000; ++i)
|
||||
{
|
||||
int& n = tss_value->value;
|
||||
BOOST_TEST(n == i);
|
||||
++n;
|
||||
}
|
||||
}
|
||||
|
||||
void test_tss()
|
||||
{
|
||||
const int NUMTHREADS=5;
|
||||
boost::thread_group threads;
|
||||
for (int i=0; i<NUMTHREADS; ++i)
|
||||
threads.create_thread(&test_tss_thread);
|
||||
threads.join_all();
|
||||
BOOST_TEST(tss_instances == 0);
|
||||
}
|
||||
|
||||
int once_value = 0;
|
||||
boost::once_flag once = boost::once_init;
|
||||
|
||||
void init_once_value()
|
||||
{
|
||||
once_value++;
|
||||
}
|
||||
|
||||
void test_once_thread()
|
||||
{
|
||||
boost::call_once(&init_once_value, once);
|
||||
}
|
||||
|
||||
void test_once()
|
||||
{
|
||||
const int NUMTHREADS=5;
|
||||
boost::thread_group threads;
|
||||
for (int i=0; i<NUMTHREADS; ++i)
|
||||
threads.create_thread(&test_once_thread);
|
||||
threads.join_all();
|
||||
BOOST_TEST(once_value == 1);
|
||||
}
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
test_mutex();
|
||||
test_try_mutex();
|
||||
test_timed_mutex();
|
||||
test_recursive_mutex();
|
||||
test_recursive_try_mutex();
|
||||
test_recursive_timed_mutex();
|
||||
test_condition();
|
||||
test_semaphore();
|
||||
test_tss();
|
||||
test_once();
|
||||
return 0;
|
||||
}
|
||||
Reference in New Issue
Block a user