mirror of
https://github.com/boostorg/thread.git
synced 2026-02-03 09:42:16 +00:00
Compare commits
1 Commits
boost-1.44
...
boost-1.25
| Author | SHA1 | Date | |
|---|---|---|---|
|
ec824ccf29 |
49
build/Jamfile
Normal file
49
build/Jamfile
Normal file
@@ -0,0 +1,49 @@
|
||||
# (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)
|
||||
{
|
||||
if $(PTW32)
|
||||
{
|
||||
PTW32_REQUIREMENTS = <define>BOOST_HAS_PTHREADS <define>PtW32NoCatchWarn ;
|
||||
}
|
||||
else
|
||||
{
|
||||
dll libboost_threadmon : ../src/threadmon.cpp
|
||||
# requirements
|
||||
: <include>$(BOOST_ROOT)
|
||||
<threading>multi
|
||||
: debug release ;
|
||||
}
|
||||
}
|
||||
|
||||
# Base names of the source files for libboost_thread
|
||||
CPP_SOURCES =
|
||||
condition mutex recursive_mutex thread tss xtime once exceptions ;
|
||||
|
||||
lib libboost_thread : ../src/$(CPP_SOURCES).cpp
|
||||
# requirements
|
||||
: <include>$(BOOST_ROOT)
|
||||
$(PTW32_REQUIREMENTS)
|
||||
<threading>multi
|
||||
: debug release ;
|
||||
207
build/Jamfile.v2
207
build/Jamfile.v2
@@ -1,207 +0,0 @@
|
||||
# $Id$
|
||||
# Copyright 2006-2007 Roland Schwarz.
|
||||
# Copyright 2007 Anthony Williams
|
||||
# Distributed under the Boost Software License, Version 1.0. (See
|
||||
# accompanying file LICENSE_1_0.txt or copy at
|
||||
# http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#########################################################################
|
||||
# The boost threading library can be built on top of different API's
|
||||
# Currently this is the win32 API and the pthreads API.
|
||||
# Pthread is native on unix variants.
|
||||
# To get pthread on windows you need the pthread win32 library
|
||||
# http://sourceware.org/pthreads-win32 which is available under LGPL.
|
||||
#
|
||||
# You need to provide the include path and lib path in the variables
|
||||
# PTW32_INCLUDE and PTW32_LIB respectively. You can specify these
|
||||
# paths in site-config.jam, user-config.jam or in the environment.
|
||||
# A new feature is provided to request a specific API:
|
||||
# <threadapi>win32 and <threadapi)pthread.
|
||||
#
|
||||
# The naming of the resulting libraries is mostly the same for the
|
||||
# variant native to the build platform, i.e.
|
||||
# boost_thread and the boost specific tagging.
|
||||
# For the library variant that is not native on the build platform
|
||||
# an additional tag is applied:
|
||||
# boost_thread_pthread for the pthread variant on windows, and
|
||||
# boost_thread_win32 for the win32 variant (likely when built on cygwin).
|
||||
#
|
||||
# To request the pthread variant on windows, from boost root you would
|
||||
# say e.g:
|
||||
# bjam msvc-8.0 --with-thread install threadapi=pthread
|
||||
#########################################################################
|
||||
|
||||
import os ;
|
||||
import feature ;
|
||||
import indirect ;
|
||||
import path ;
|
||||
|
||||
project boost/thread
|
||||
: source-location ../src
|
||||
: requirements <threading>multi
|
||||
<link>static:<define>BOOST_THREAD_BUILD_LIB=1
|
||||
<link>shared:<define>BOOST_THREAD_BUILD_DLL=1
|
||||
-<tag>@$(BOOST_JAMROOT_MODULE)%$(BOOST_JAMROOT_MODULE).tag
|
||||
<tag>@$(__name__).tag
|
||||
<toolset>gcc:<cxxflags>-Wno-long-long
|
||||
: default-build <threading>multi
|
||||
;
|
||||
|
||||
local rule default_threadapi ( )
|
||||
{
|
||||
local api = pthread ;
|
||||
if [ os.name ] = "NT" { api = win32 ; }
|
||||
return $(api) ;
|
||||
}
|
||||
|
||||
feature.feature threadapi : pthread win32 : propagated ;
|
||||
feature.set-default threadapi : [ default_threadapi ] ;
|
||||
|
||||
rule tag ( name : type ? : property-set )
|
||||
{
|
||||
local result = $(name) ;
|
||||
|
||||
if $(type) in STATIC_LIB SHARED_LIB IMPORT_LIB
|
||||
{
|
||||
local api = [ $(property-set).get <threadapi> ] ;
|
||||
|
||||
# non native api gets additional tag
|
||||
if $(api) != [ default_threadapi ] {
|
||||
result = $(result)_$(api) ;
|
||||
}
|
||||
}
|
||||
|
||||
# forward to the boost tagging rule
|
||||
return [ indirect.call $(BOOST_JAMROOT_MODULE)%$(BOOST_JAMROOT_MODULE).tag
|
||||
$(result) : $(type) : $(property-set) ] ;
|
||||
}
|
||||
|
||||
rule win32_pthread_paths ( properties * )
|
||||
{
|
||||
local result ;
|
||||
local PTW32_INCLUDE ;
|
||||
local PTW32_LIB ;
|
||||
PTW32_INCLUDE = [ modules.peek : PTW32_INCLUDE ] ;
|
||||
PTW32_LIB = [ modules.peek : PTW32_LIB ] ;
|
||||
PTW32_INCLUDE ?= [ modules.peek user-config : PTW32_INCLUDE ] ;
|
||||
PTW32_LIB ?= [ modules.peek user-config : PTW32_LIB ] ;
|
||||
PTW32_INCLUDE ?= [ modules.peek site-config : PTW32_INCLUDE ] ;
|
||||
PTW32_LIB ?= [ modules.peek site-config : PTW32_LIB ] ;
|
||||
|
||||
if ! ( $(PTW32_INCLUDE) && $(PTW32_LIB) )
|
||||
{
|
||||
if ! $(.notified)
|
||||
{
|
||||
echo "************************************************************" ;
|
||||
echo "Trying to build Boost.Thread with pthread support." ;
|
||||
echo "If you need pthread you should specify the paths." ;
|
||||
echo "You can specify them in site-config.jam, user-config.jam" ;
|
||||
echo "or in the environment." ;
|
||||
echo "For example:" ;
|
||||
echo "PTW32_INCLUDE=C:\\Program Files\\ptw32\\Pre-built2\\include" ;
|
||||
echo "PTW32_LIB=C:\\Program Files\\ptw32\\Pre-built2\\lib" ;
|
||||
echo "************************************************************" ;
|
||||
.notified = true ;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
local include_path = [ path.make $(PTW32_INCLUDE) ] ;
|
||||
local lib_path = [ path.make $(PTW32_LIB) ] ;
|
||||
local libname = pthread ;
|
||||
if <toolset>msvc in $(properties)
|
||||
{
|
||||
libname = $(libname)VC2.lib ;
|
||||
}
|
||||
if <toolset>gcc in $(properties)
|
||||
{
|
||||
libname = lib$(libname)GC2.a ;
|
||||
}
|
||||
lib_path = [ path.glob $(lib_path) : $(libname) ] ;
|
||||
if ! $(lib_path)
|
||||
{
|
||||
if ! $(.notified)
|
||||
{
|
||||
echo "************************************************************" ;
|
||||
echo "Trying to build Boost.Thread with pthread support." ;
|
||||
echo "But the library" $(libname) "could not be found in path" ;
|
||||
echo $(PTW32_LIB) ;
|
||||
echo "************************************************************" ;
|
||||
.notified = true ;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
result += <include>$(include_path) ;
|
||||
result += <library>$(lib_path) ;
|
||||
}
|
||||
}
|
||||
return $(result) ;
|
||||
}
|
||||
|
||||
rule usage-requirements ( properties * )
|
||||
{
|
||||
local result ;
|
||||
if <threadapi>pthread in $(properties)
|
||||
{
|
||||
result += <define>BOOST_THREAD_POSIX ;
|
||||
if <target-os>windows in $(properties)
|
||||
{
|
||||
result += [ win32_pthread_paths $(properties) ] ;
|
||||
# TODO: What is for static linking? Is the <library> also needed
|
||||
# in that case?
|
||||
}
|
||||
}
|
||||
return $(result) ;
|
||||
}
|
||||
|
||||
rule requirements ( properties * )
|
||||
{
|
||||
local result ;
|
||||
|
||||
if <threadapi>pthread in $(properties)
|
||||
{
|
||||
result += <define>BOOST_THREAD_POSIX ;
|
||||
if <target-os>windows in $(properties)
|
||||
{
|
||||
local paths = [ win32_pthread_paths $(properties) ] ;
|
||||
if $(paths)
|
||||
{
|
||||
result += $(paths) ;
|
||||
}
|
||||
else
|
||||
{
|
||||
result = <build>no ;
|
||||
}
|
||||
}
|
||||
}
|
||||
return $(result) ;
|
||||
}
|
||||
|
||||
alias thread_sources
|
||||
: ## win32 sources ##
|
||||
win32/thread.cpp
|
||||
win32/tss_dll.cpp
|
||||
win32/tss_pe.cpp
|
||||
: ## requirements ##
|
||||
<threadapi>win32
|
||||
;
|
||||
|
||||
alias thread_sources
|
||||
: ## pthread sources ##
|
||||
pthread/thread.cpp
|
||||
pthread/once.cpp
|
||||
: ## requirements ##
|
||||
<threadapi>pthread
|
||||
;
|
||||
|
||||
explicit thread_sources ;
|
||||
|
||||
lib boost_thread
|
||||
: thread_sources
|
||||
: <conditional>@requirements
|
||||
:
|
||||
: <link>shared:<define>BOOST_THREAD_USE_DLL=1
|
||||
<link>static:<define>BOOST_THREAD_USE_LIB=1
|
||||
<conditional>@usage-requirements
|
||||
;
|
||||
@@ -1,31 +0,0 @@
|
||||
# (C) Copyright 2008 Anthony Williams
|
||||
#
|
||||
# Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
path-constant boost-images : ../../../doc/src/images ;
|
||||
|
||||
xml thread : thread.qbk ;
|
||||
|
||||
boostbook standalone
|
||||
:
|
||||
thread
|
||||
:
|
||||
# HTML options first:
|
||||
# Use graphics not text for navigation:
|
||||
<xsl:param>navig.graphics=1
|
||||
# How far down we chunk nested sections, basically all of them:
|
||||
<xsl:param>chunk.section.depth=3
|
||||
# Don't put the first section on the same page as the TOC:
|
||||
<xsl:param>chunk.first.sections=1
|
||||
# How far down sections get TOC's
|
||||
<xsl:param>toc.section.depth=10
|
||||
# Max depth in each TOC:
|
||||
<xsl:param>toc.max.depth=3
|
||||
# How far down we go with TOC's
|
||||
<xsl:param>generate.section.toc.level=10
|
||||
# Path for links to Boost:
|
||||
<xsl:param>boost.root=../../../..
|
||||
;
|
||||
|
||||
|
||||
77
doc/acknowledgements.html
Normal file
77
doc/acknowledgements.html
Normal file
@@ -0,0 +1,77 @@
|
||||
<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 summary="header" 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 -->05 November, 2001<!--webbot bot="Timestamp" endspan i-checksum="39359" --></p>
|
||||
|
||||
<p>© <i>Copyright <a href="mailto:williamkempf@hotmail.com">
|
||||
William E. Kempf</a> 2001</i></p>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
@@ -1,23 +0,0 @@
|
||||
[/
|
||||
(C) Copyright 2007-8 Anthony Williams.
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt).
|
||||
]
|
||||
|
||||
[section:acknowledgements Acknowledgments]
|
||||
|
||||
The original implementation of __boost_thread__ was written by William Kempf, with contributions from numerous others. This new
|
||||
version initially grew out of an attempt to rewrite __boost_thread__ to William Kempf's design with fresh code that could be
|
||||
released under the Boost Software License. However, as the C++ Standards committee have been actively discussing standardizing a
|
||||
thread library for C++, this library has evolved to reflect the proposals, whilst retaining as much backwards-compatibility as
|
||||
possible.
|
||||
|
||||
Particular thanks must be given to Roland Schwarz, who contributed a lot of time and code to the original __boost_thread__ library,
|
||||
and who has been actively involved with the rewrite. The scheme for dividing the platform-specific implementations into separate
|
||||
directories was devised by Roland, and his input has contributed greatly to improving the quality of the current implementation.
|
||||
|
||||
Thanks also must go to Peter Dimov, Howard Hinnant, Alexander Terekhov, Chris Thomasson and others for their comments on the
|
||||
implementation details of the code.
|
||||
|
||||
[endsect]
|
||||
@@ -1,72 +0,0 @@
|
||||
[/
|
||||
(C) Copyright 2007-8 Anthony Williams.
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt).
|
||||
]
|
||||
|
||||
[section:barriers Barriers]
|
||||
|
||||
A barrier is a simple concept. Also known as a ['rendezvous], it is a synchronization point between multiple threads. The barrier is
|
||||
configured for a particular number of threads (`n`), and as threads reach the barrier they must wait until all `n` threads have
|
||||
arrived. Once the `n`-th thread has reached the barrier, all the waiting threads can proceed, and the barrier is reset.
|
||||
|
||||
[section:barrier Class `barrier`]
|
||||
|
||||
#include <boost/thread/barrier.hpp>
|
||||
|
||||
class barrier
|
||||
{
|
||||
public:
|
||||
barrier(unsigned int count);
|
||||
~barrier();
|
||||
|
||||
bool wait();
|
||||
};
|
||||
|
||||
Instances of __barrier__ are not copyable or movable.
|
||||
|
||||
[heading Constructor]
|
||||
|
||||
barrier(unsigned int count);
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Construct a barrier for `count` threads.]]
|
||||
|
||||
[[Throws:] [__thread_resource_error__ if an error occurs.]]
|
||||
|
||||
]
|
||||
|
||||
[heading Destructor]
|
||||
|
||||
~barrier();
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Precondition:] [No threads are waiting on `*this`.]]
|
||||
|
||||
[[Effects:] [Destroys `*this`.]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
]
|
||||
|
||||
[heading Member function `wait`]
|
||||
|
||||
bool wait();
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Block until `count` threads have called `wait` on `*this`. When the `count`-th thread calls `wait`, all waiting threads
|
||||
are unblocked, and the barrier is reset. ]]
|
||||
|
||||
[[Returns:] [`true` for exactly one thread from each batch of waiting threads, `false` otherwise.]]
|
||||
|
||||
[[Throws:] [__thread_resource_error__ if an error occurs.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
222
doc/bibliography.html
Normal file
222
doc/bibliography.html
Normal file
@@ -0,0 +1,222 @@
|
||||
<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 summary="header" 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 summary="Bibliography" 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.</p>
|
||||
</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.</p>
|
||||
</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.</p>
|
||||
</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.</p>
|
||||
</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.</p>
|
||||
</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 -->05 Nov 2001<!--webbot bot="Timestamp" endspan i-checksum="15246" --></p>
|
||||
|
||||
<p>© Copyright Beman Dawes, 2001</p>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
132
doc/call_once.html
Normal file
132
doc/call_once.html
Normal file
@@ -0,0 +1,132 @@
|
||||
<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 summary="header" 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 -->05 November, 2001<!--webbot bot="Timestamp" endspan i-checksum="39359" --></p>
|
||||
|
||||
<p><i>© Copyright <a href="mailto:williamkempf@hotmail.com">
|
||||
William E. Kempf</a> 2001 all rights reserved.</i></p>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
@@ -1,87 +0,0 @@
|
||||
[/
|
||||
(C) Copyright 2007-8 Anthony Williams.
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt).
|
||||
]
|
||||
|
||||
[section:changes Changes since boost 1.40]
|
||||
|
||||
The 1.41.0 release of Boost adds futures to the thread library. There are also a few minor changes.
|
||||
|
||||
[heading Changes since boost 1.35]
|
||||
|
||||
The 1.36.0 release of Boost includes a few new features in the thread library:
|
||||
|
||||
* New generic __lock_multiple_ref__ and __try_lock_multiple_ref__ functions for locking multiple mutexes at once.
|
||||
|
||||
* Rvalue reference support for move semantics where the compilers supports it.
|
||||
|
||||
* A few bugs fixed and missing functions added (including the serious win32 condition variable bug).
|
||||
|
||||
* `scoped_try_lock` types are now backwards-compatible with Boost 1.34.0 and previous releases.
|
||||
|
||||
* Support for passing function arguments to the thread function by supplying additional arguments to the __thread__ constructor.
|
||||
|
||||
* Backwards-compatibility overloads added for `timed_lock` and `timed_wait` functions to allow use of `xtime` for timeouts.
|
||||
|
||||
[heading Changes since boost 1.34]
|
||||
|
||||
Almost every line of code in __boost_thread__ has been changed since the 1.34 release of boost. However, most of the interface
|
||||
changes have been extensions, so the new code is largely backwards-compatible with the old code. The new features and breaking
|
||||
changes are described below.
|
||||
|
||||
[heading New Features]
|
||||
|
||||
* Instances of __thread__ and of the various lock types are now movable.
|
||||
|
||||
* Threads can be interrupted at __interruption_points__.
|
||||
|
||||
* Condition variables can now be used with any type that implements the __lockable_concept__, through the use of
|
||||
`boost::condition_variable_any` (`boost::condition` is a `typedef` to `boost::condition_variable_any`, provided for backwards
|
||||
compatibility). `boost::condition_variable` is provided as an optimization, and will only work with
|
||||
`boost::unique_lock<boost::mutex>` (`boost::mutex::scoped_lock`).
|
||||
|
||||
* Thread IDs are separated from __thread__, so a thread can obtain it's own ID (using `boost::this_thread::get_id()`), and IDs can
|
||||
be used as keys in associative containers, as they have the full set of comparison operators.
|
||||
|
||||
* Timeouts are now implemented using the Boost DateTime library, through a typedef `boost::system_time` for absolute timeouts, and
|
||||
with support for relative timeouts in many cases. `boost::xtime` is supported for backwards compatibility only.
|
||||
|
||||
* Locks are implemented as publicly accessible templates `boost::lock_guard`, `boost::unique_lock`, `boost::shared_lock`, and
|
||||
`boost::upgrade_lock`, which are templated on the type of the mutex. The __lockable_concept__ has been extended to include publicly
|
||||
available __lock_ref__ and __unlock_ref__ member functions, which are used by the lock types.
|
||||
|
||||
[heading Breaking Changes]
|
||||
|
||||
The list below should cover all changes to the public interface which break backwards compatibility.
|
||||
|
||||
* __try_mutex__ has been removed, and the functionality subsumed into __mutex__. __try_mutex__ is left as a `typedef`,
|
||||
but is no longer a separate class.
|
||||
|
||||
* __recursive_try_mutex__ has been removed, and the functionality subsumed into
|
||||
__recursive_mutex__. __recursive_try_mutex__ is left as a `typedef`, but is no longer a separate class.
|
||||
|
||||
* `boost::detail::thread::lock_ops` has been removed. Code that relies on the `lock_ops` implementation detail will no longer work,
|
||||
as this has been removed, as it is no longer necessary now that mutex types now have public __lock_ref__ and __unlock_ref__ member
|
||||
functions.
|
||||
|
||||
* `scoped_lock` constructors with a second parameter of type `bool` are no longer provided. With previous boost releases,
|
||||
``boost::mutex::scoped_lock some_lock(some_mutex,false);`` could be used to create a lock object that was associated with a mutex,
|
||||
but did not lock it on construction. This facility has now been replaced with the constructor that takes a
|
||||
`boost::defer_lock_type` as the second parameter: ``boost::mutex::scoped_lock some_lock(some_mutex,boost::defer_lock);``
|
||||
|
||||
* The `locked()` member function of the `scoped_lock` types has been renamed to __owns_lock_ref__.
|
||||
|
||||
* You can no longer obtain a __thread__ instance representing the current thread: a default-constructed __thread__ object is not
|
||||
associated with any thread. The only use for such a thread object was to support the comparison operators: this functionality has
|
||||
been moved to __thread_id__.
|
||||
|
||||
* The broken `boost::read_write_mutex` has been replaced with __shared_mutex__.
|
||||
|
||||
* __mutex__ is now never recursive. For Boost releases prior to 1.35 __mutex__ was recursive on Windows and not on POSIX platforms.
|
||||
|
||||
* When using a __recursive_mutex__ with a call to [cond_any_wait_link `boost::condition_variable_any::wait()`], the mutex is only
|
||||
unlocked one level, and not completely. This prior behaviour was not guaranteed and did not feature in the tests.
|
||||
|
||||
[endsect]
|
||||
338
doc/condition.html
Normal file
338
doc/condition.html
Normal file
@@ -0,0 +1,338 @@
|
||||
<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 summary="header" 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 ScopedLock>
|
||||
bool timed_wait(ScopedLock& lock, const <a href=
|
||||
"xtime.html">xtime</a>& xt);
|
||||
</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 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 ScopedLock, typename Pr>
|
||||
bool timed_wait(ScopedLock& lock, const <a href=
|
||||
"xtime.html">xtime</a>& xt, 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())<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 -->05 November, 2001<!--webbot bot="Timestamp" endspan i-checksum="39359" --></p>
|
||||
|
||||
<p><i>© Copyright <a href="mailto:williamkempf@hotmail.com">
|
||||
William E. Kempf</a> 2001 all rights reserved.</i></p>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
@@ -1,513 +0,0 @@
|
||||
[/
|
||||
(C) Copyright 2007-8 Anthony Williams.
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt).
|
||||
]
|
||||
|
||||
[section:condvar_ref Condition Variables]
|
||||
|
||||
[heading Synopsis]
|
||||
|
||||
The classes `condition_variable` and `condition_variable_any` provide a
|
||||
mechanism for one thread to wait for notification from another thread that a
|
||||
particular condition has become true. The general usage pattern is that one
|
||||
thread locks a mutex and then calls `wait` on an instance of
|
||||
`condition_variable` or `condition_variable_any`. When the thread is woken from
|
||||
the wait, then it checks to see if the appropriate condition is now true, and
|
||||
continues if so. If the condition is not true, then the thread then calls `wait`
|
||||
again to resume waiting. In the simplest case, this condition is just a boolean
|
||||
variable:
|
||||
|
||||
boost::condition_variable cond;
|
||||
boost::mutex mut;
|
||||
bool data_ready;
|
||||
|
||||
void process_data();
|
||||
|
||||
void wait_for_data_to_process()
|
||||
{
|
||||
boost::unique_lock<boost::mutex> lock(mut);
|
||||
while(!data_ready)
|
||||
{
|
||||
cond.wait(lock);
|
||||
}
|
||||
process_data();
|
||||
}
|
||||
|
||||
Notice that the `lock` is passed to `wait`: `wait` will atomically add the
|
||||
thread to the set of threads waiting on the condition variable, and unlock the
|
||||
mutex. When the thread is woken, the mutex will be locked again before the call
|
||||
to `wait` returns. This allows other threads to acquire the mutex in order to
|
||||
update the shared data, and ensures that the data associated with the condition
|
||||
is correctly synchronized.
|
||||
|
||||
In the mean time, another thread sets the condition to `true`, and then calls
|
||||
either `notify_one` or `notify_all` on the condition variable to wake one
|
||||
waiting thread or all the waiting threads respectively.
|
||||
|
||||
void retrieve_data();
|
||||
void prepare_data();
|
||||
|
||||
void prepare_data_for_processing()
|
||||
{
|
||||
retrieve_data();
|
||||
prepare_data();
|
||||
{
|
||||
boost::lock_guard<boost::mutex> lock(mut);
|
||||
data_ready=true;
|
||||
}
|
||||
cond.notify_one();
|
||||
}
|
||||
|
||||
Note that the same mutex is locked before the shared data is updated, but that
|
||||
the mutex does not have to be locked across the call to `notify_one`.
|
||||
|
||||
This example uses an object of type `condition_variable`, but would work just as
|
||||
well with an object of type `condition_variable_any`: `condition_variable_any`
|
||||
is more general, and will work with any kind of lock or mutex, whereas
|
||||
`condition_variable` requires that the lock passed to `wait` is an instance of
|
||||
`boost::unique_lock<boost::mutex>`. This enables `condition_variable` to make
|
||||
optimizations in some cases, based on the knowledge of the mutex type;
|
||||
`condition_variable_any` typically has a more complex implementation than
|
||||
`condition_variable`.
|
||||
|
||||
[section:condition_variable Class `condition_variable`]
|
||||
|
||||
#include <boost/thread/condition_variable.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
class condition_variable
|
||||
{
|
||||
public:
|
||||
condition_variable();
|
||||
~condition_variable();
|
||||
|
||||
void notify_one();
|
||||
void notify_all();
|
||||
|
||||
void wait(boost::unique_lock<boost::mutex>& lock);
|
||||
|
||||
template<typename predicate_type>
|
||||
void wait(boost::unique_lock<boost::mutex>& lock,predicate_type predicate);
|
||||
|
||||
bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::system_time const& abs_time);
|
||||
|
||||
template<typename duration_type>
|
||||
bool timed_wait(boost::unique_lock<boost::mutex>& lock,duration_type const& rel_time);
|
||||
|
||||
template<typename predicate_type>
|
||||
bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::system_time const& abs_time,predicate_type predicate);
|
||||
|
||||
template<typename duration_type,typename predicate_type>
|
||||
bool timed_wait(boost::unique_lock<boost::mutex>& lock,duration_type const& rel_time,predicate_type predicate);
|
||||
|
||||
// backwards compatibility
|
||||
|
||||
bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::xtime const& abs_time);
|
||||
|
||||
template<typename predicate_type>
|
||||
bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::xtime const& abs_time,predicate_type predicate);
|
||||
};
|
||||
}
|
||||
|
||||
[section:constructor `condition_variable()`]
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Constructs an object of class `condition_variable`.]]
|
||||
|
||||
[[Throws:] [__thread_resource_error__ if an error occurs.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:destructor `~condition_variable()`]
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Precondition:] [All threads waiting on `*this` have been notified by a call to
|
||||
`notify_one` or `notify_all` (though the respective calls to `wait` or
|
||||
`timed_wait` need not have returned).]]
|
||||
|
||||
[[Effects:] [Destroys the object.]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:notify_one `void notify_one()`]
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [If any threads are currently __blocked__ waiting on `*this` in a call
|
||||
to `wait` or `timed_wait`, unblocks one of those threads.]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:notify_all `void notify_all()`]
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [If any threads are currently __blocked__ waiting on `*this` in a call
|
||||
to `wait` or `timed_wait`, unblocks all of those threads.]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:wait `void wait(boost::unique_lock<boost::mutex>& lock)`]
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Precondition:] [`lock` is locked by the current thread, and either no other
|
||||
thread is currently waiting on `*this`, or the execution of the `mutex()` member
|
||||
function on the `lock` objects supplied in the calls to `wait` or `timed_wait`
|
||||
in all the threads currently waiting on `*this` would return the same value as
|
||||
`lock->mutex()` for this call to `wait`.]]
|
||||
|
||||
[[Effects:] [Atomically call `lock.unlock()` and blocks the current thread. The
|
||||
thread will unblock when notified by a call to `this->notify_one()` or
|
||||
`this->notify_all()`, or spuriously. When the thread is unblocked (for whatever
|
||||
reason), the lock is reacquired by invoking `lock.lock()` before the call to
|
||||
`wait` returns. The lock is also reacquired by invoking `lock.lock()` if the
|
||||
function exits with an exception.]]
|
||||
|
||||
[[Postcondition:] [`lock` is locked by the current thread.]]
|
||||
|
||||
[[Throws:] [__thread_resource_error__ if an error
|
||||
occurs. __thread_interrupted__ if the wait was interrupted by a call to
|
||||
__interrupt__ on the __thread__ object associated with the current thread of execution.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:wait_predicate `template<typename predicate_type> void wait(boost::unique_lock<boost::mutex>& lock, predicate_type pred)`]
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [As-if ``
|
||||
while(!pred())
|
||||
{
|
||||
wait(lock);
|
||||
}
|
||||
``]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:timed_wait `bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::system_time const& abs_time)`]
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Precondition:] [`lock` is locked by the current thread, and either no other
|
||||
thread is currently waiting on `*this`, or the execution of the `mutex()` member
|
||||
function on the `lock` objects supplied in the calls to `wait` or `timed_wait`
|
||||
in all the threads currently waiting on `*this` would return the same value as
|
||||
`lock->mutex()` for this call to `wait`.]]
|
||||
|
||||
[[Effects:] [Atomically call `lock.unlock()` and blocks the current thread. The
|
||||
thread will unblock when notified by a call to `this->notify_one()` or
|
||||
`this->notify_all()`, when the time as reported by `boost::get_system_time()`
|
||||
would be equal to or later than the specified `abs_time`, or spuriously. When
|
||||
the thread is unblocked (for whatever reason), the lock is reacquired by
|
||||
invoking `lock.lock()` before the call to `wait` returns. The lock is also
|
||||
reacquired by invoking `lock.lock()` if the function exits with an exception.]]
|
||||
|
||||
[[Returns:] [`false` if the call is returning because the time specified by
|
||||
`abs_time` was reached, `true` otherwise.]]
|
||||
|
||||
[[Postcondition:] [`lock` is locked by the current thread.]]
|
||||
|
||||
[[Throws:] [__thread_resource_error__ if an error
|
||||
occurs. __thread_interrupted__ if the wait was interrupted by a call to
|
||||
__interrupt__ on the __thread__ object associated with the current thread of execution.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:timed_wait_rel `template<typename duration_type> bool timed_wait(boost::unique_lock<boost::mutex>& lock,duration_type const& rel_time)`]
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Precondition:] [`lock` is locked by the current thread, and either no other
|
||||
thread is currently waiting on `*this`, or the execution of the `mutex()` member
|
||||
function on the `lock` objects supplied in the calls to `wait` or `timed_wait`
|
||||
in all the threads currently waiting on `*this` would return the same value as
|
||||
`lock->mutex()` for this call to `wait`.]]
|
||||
|
||||
[[Effects:] [Atomically call `lock.unlock()` and blocks the current thread. The
|
||||
thread will unblock when notified by a call to `this->notify_one()` or
|
||||
`this->notify_all()`, after the period of time indicated by the `rel_time`
|
||||
argument has elapsed, or spuriously. When the thread is unblocked (for whatever
|
||||
reason), the lock is reacquired by invoking `lock.lock()` before the call to
|
||||
`wait` returns. The lock is also reacquired by invoking `lock.lock()` if the
|
||||
function exits with an exception.]]
|
||||
|
||||
[[Returns:] [`false` if the call is returning because the time period specified
|
||||
by `rel_time` has elapsed, `true` otherwise.]]
|
||||
|
||||
[[Postcondition:] [`lock` is locked by the current thread.]]
|
||||
|
||||
[[Throws:] [__thread_resource_error__ if an error
|
||||
occurs. __thread_interrupted__ if the wait was interrupted by a call to
|
||||
__interrupt__ on the __thread__ object associated with the current thread of execution.]]
|
||||
|
||||
]
|
||||
|
||||
[note The duration overload of timed_wait is difficult to use correctly. The overload taking a predicate should be preferred in most cases.]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:timed_wait_predicate `template<typename predicate_type> bool timed_wait(boost::unique_lock<boost::mutex>& lock, boost::system_time const& abs_time, predicate_type pred)`]
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [As-if ``
|
||||
while(!pred())
|
||||
{
|
||||
if(!timed_wait(lock,abs_time))
|
||||
{
|
||||
return pred();
|
||||
}
|
||||
}
|
||||
return true;
|
||||
``]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:condition_variable_any Class `condition_variable_any`]
|
||||
|
||||
#include <boost/thread/condition_variable.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
class condition_variable_any
|
||||
{
|
||||
public:
|
||||
condition_variable_any();
|
||||
~condition_variable_any();
|
||||
|
||||
void notify_one();
|
||||
void notify_all();
|
||||
|
||||
template<typename lock_type>
|
||||
void wait(lock_type& lock);
|
||||
|
||||
template<typename lock_type,typename predicate_type>
|
||||
void wait(lock_type& lock,predicate_type predicate);
|
||||
|
||||
template<typename lock_type>
|
||||
bool timed_wait(lock_type& lock,boost::system_time const& abs_time);
|
||||
|
||||
template<typename lock_type,typename duration_type>
|
||||
bool timed_wait(lock_type& lock,duration_type const& rel_time);
|
||||
|
||||
template<typename lock_type,typename predicate_type>
|
||||
bool timed_wait(lock_type& lock,boost::system_time const& abs_time,predicate_type predicate);
|
||||
|
||||
template<typename lock_type,typename duration_type,typename predicate_type>
|
||||
bool timed_wait(lock_type& lock,duration_type const& rel_time,predicate_type predicate);
|
||||
|
||||
// backwards compatibility
|
||||
|
||||
template<typename lock_type>
|
||||
bool timed_wait(lock_type>& lock,boost::xtime const& abs_time);
|
||||
|
||||
template<typename lock_type,typename predicate_type>
|
||||
bool timed_wait(lock_type& lock,boost::xtime const& abs_time,predicate_type predicate);
|
||||
};
|
||||
}
|
||||
|
||||
[section:constructor `condition_variable_any()`]
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Constructs an object of class `condition_variable_any`.]]
|
||||
|
||||
[[Throws:] [__thread_resource_error__ if an error occurs.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:destructor `~condition_variable_any()`]
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Precondition:] [All threads waiting on `*this` have been notified by a call to
|
||||
`notify_one` or `notify_all` (though the respective calls to `wait` or
|
||||
`timed_wait` need not have returned).]]
|
||||
|
||||
[[Effects:] [Destroys the object.]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:notify_one `void notify_one()`]
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [If any threads are currently __blocked__ waiting on `*this` in a call
|
||||
to `wait` or `timed_wait`, unblocks one of those threads.]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:notify_all `void notify_all()`]
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [If any threads are currently __blocked__ waiting on `*this` in a call
|
||||
to `wait` or `timed_wait`, unblocks all of those threads.]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:wait `template<typename lock_type> void wait(lock_type& lock)`]
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Atomically call `lock.unlock()` and blocks the current thread. The
|
||||
thread will unblock when notified by a call to `this->notify_one()` or
|
||||
`this->notify_all()`, or spuriously. When the thread is unblocked (for whatever
|
||||
reason), the lock is reacquired by invoking `lock.lock()` before the call to
|
||||
`wait` returns. The lock is also reacquired by invoking `lock.lock()` if the
|
||||
function exits with an exception.]]
|
||||
|
||||
[[Postcondition:] [`lock` is locked by the current thread.]]
|
||||
|
||||
[[Throws:] [__thread_resource_error__ if an error
|
||||
occurs. __thread_interrupted__ if the wait was interrupted by a call to
|
||||
__interrupt__ on the __thread__ object associated with the current thread of execution.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:wait_predicate `template<typename lock_type,typename predicate_type> void wait(lock_type& lock, predicate_type pred)`]
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [As-if ``
|
||||
while(!pred())
|
||||
{
|
||||
wait(lock);
|
||||
}
|
||||
``]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:timed_wait `template<typename lock_type> bool timed_wait(lock_type& lock,boost::system_time const& abs_time)`]
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Atomically call `lock.unlock()` and blocks the current thread. The
|
||||
thread will unblock when notified by a call to `this->notify_one()` or
|
||||
`this->notify_all()`, when the time as reported by `boost::get_system_time()`
|
||||
would be equal to or later than the specified `abs_time`, or spuriously. When
|
||||
the thread is unblocked (for whatever reason), the lock is reacquired by
|
||||
invoking `lock.lock()` before the call to `wait` returns. The lock is also
|
||||
reacquired by invoking `lock.lock()` if the function exits with an exception.]]
|
||||
|
||||
[[Returns:] [`false` if the call is returning because the time specified by
|
||||
`abs_time` was reached, `true` otherwise.]]
|
||||
|
||||
[[Postcondition:] [`lock` is locked by the current thread.]]
|
||||
|
||||
[[Throws:] [__thread_resource_error__ if an error
|
||||
occurs. __thread_interrupted__ if the wait was interrupted by a call to
|
||||
__interrupt__ on the __thread__ object associated with the current thread of execution.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:timed_wait_rel `template<typename lock_type,typename duration_type> bool timed_wait(lock_type& lock,duration_type const& rel_time)`]
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Atomically call `lock.unlock()` and blocks the current thread. The
|
||||
thread will unblock when notified by a call to `this->notify_one()` or
|
||||
`this->notify_all()`, after the period of time indicated by the `rel_time`
|
||||
argument has elapsed, or spuriously. When the thread is unblocked (for whatever
|
||||
reason), the lock is reacquired by invoking `lock.lock()` before the call to
|
||||
`wait` returns. The lock is also reacquired by invoking `lock.lock()` if the
|
||||
function exits with an exception.]]
|
||||
|
||||
[[Returns:] [`false` if the call is returning because the time period specified
|
||||
by `rel_time` has elapsed, `true` otherwise.]]
|
||||
|
||||
[[Postcondition:] [`lock` is locked by the current thread.]]
|
||||
|
||||
[[Throws:] [__thread_resource_error__ if an error
|
||||
occurs. __thread_interrupted__ if the wait was interrupted by a call to
|
||||
__interrupt__ on the __thread__ object associated with the current thread of execution.]]
|
||||
|
||||
]
|
||||
|
||||
[note The duration overload of timed_wait is difficult to use correctly. The overload taking a predicate should be preferred in most cases.]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:timed_wait_predicate `template<typename lock_type,typename predicate_type> bool timed_wait(lock_type& lock, boost::system_time const& abs_time, predicate_type pred)`]
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [As-if ``
|
||||
while(!pred())
|
||||
{
|
||||
if(!timed_wait(lock,abs_time))
|
||||
{
|
||||
return pred();
|
||||
}
|
||||
}
|
||||
return true;
|
||||
``]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:condition Typedef `condition`]
|
||||
|
||||
#include <boost/thread/condition.hpp>
|
||||
|
||||
typedef condition_variable_any condition;
|
||||
|
||||
The typedef `condition` is provided for backwards compatibility with previous boost releases.
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
97
doc/config.html
Normal file
97
doc/config.html
Normal file
@@ -0,0 +1,97 @@
|
||||
<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 summary="header" 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 summary="macros" 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 -->05 November, 2001<!--webbot bot="Timestamp" endspan i-checksum="39359" --></p>
|
||||
|
||||
<p><i>© Copyright <a href="mailto:williamkempf@hotmail.com">
|
||||
William E. Kempf</a> 2001 all rights reserved.</i></p>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
348
doc/definitions.html
Normal file
348
doc/definitions.html
Normal file
@@ -0,0 +1,348 @@
|
||||
<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 summary="header" 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 summary="thread states" 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 summary="state transitions" 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]</p>
|
||||
</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 summary="memory visibility" 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 -->05 Nov 2001<!--webbot bot="Timestamp" endspan i-checksum="15246" --></p>
|
||||
|
||||
<p>© Copyright Beman Dawes, 2001</p>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
193
doc/faq.html
Normal file
193
doc/faq.html
Normal file
@@ -0,0 +1,193 @@
|
||||
<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 summary="header" 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, 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>
|
||||
|
||||
<h2>10. Why has class semaphore disappeared?</h2>
|
||||
|
||||
<p>Semaphore was removed as too error prone. The same effect can be
|
||||
achieved with greater safety by the combination of a mutex and a
|
||||
condition variable.</p>
|
||||
<hr>
|
||||
|
||||
<p>Revised
|
||||
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->05 November, 2001<!--webbot bot="Timestamp" endspan i-checksum="39359" --></p>
|
||||
|
||||
<p><i>© Copyright <a href="mailto:williamkempf@hotmail.com">
|
||||
William E. Kempf</a> 2001 all rights reserved.</i></p>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
@@ -1,968 +0,0 @@
|
||||
[/
|
||||
(C) Copyright 2008-9 Anthony Williams.
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt).
|
||||
]
|
||||
|
||||
[section:reference Futures Reference]
|
||||
|
||||
[section:future_state `state` enum]
|
||||
|
||||
namespace future_state
|
||||
{
|
||||
enum state {uninitialized, waiting, ready};
|
||||
}
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:unique_future `unique_future` class template]
|
||||
|
||||
template <typename R>
|
||||
class unique_future
|
||||
{
|
||||
unique_future(unique_future & rhs);// = delete;
|
||||
unique_future& operator=(unique_future& rhs);// = delete;
|
||||
|
||||
public:
|
||||
typedef future_state::state state;
|
||||
|
||||
unique_future();
|
||||
~unique_future();
|
||||
|
||||
// move support
|
||||
unique_future(unique_future && other);
|
||||
unique_future& operator=(unique_future && other);
|
||||
|
||||
void swap(unique_future& other);
|
||||
|
||||
// retrieving the value
|
||||
R&& get();
|
||||
|
||||
// functions to check state
|
||||
state get_state() const;
|
||||
bool is_ready() const;
|
||||
bool has_exception() const;
|
||||
bool has_value() const;
|
||||
|
||||
// waiting for the result to be ready
|
||||
void wait() const;
|
||||
template<typename Duration>
|
||||
bool timed_wait(Duration const& rel_time) const;
|
||||
bool timed_wait_until(boost::system_time const& abs_time) const;
|
||||
};
|
||||
|
||||
[section:default_constructor Default Constructor]
|
||||
|
||||
unique_future();
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Constructs an uninitialized future.]]
|
||||
|
||||
[[Postconditions:] [[unique_future_is_ready_link `this->is_ready`] returns `false`. [unique_future_get_state_link
|
||||
`this->get_state()`] returns __uninitialized__.]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:destructor Destructor]
|
||||
|
||||
~unique_future();
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Destroys `*this`.]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:move_constructor Move Constructor]
|
||||
|
||||
unique_future(unique_future && other);
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Constructs a new future, and transfers ownership of the asynchronous result associated with `other` to `*this`.]]
|
||||
|
||||
[[Postconditions:] [[unique_future_get_state_link `this->get_state()`] returns the value of `other->get_state()` prior to the
|
||||
call. `other->get_state()` returns __uninitialized__. If `other` was associated with an asynchronous result, that result is now
|
||||
associated with `*this`. `other` is not associated with any asynchronous result.]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
[[Notes:] [If the compiler does not support rvalue-references, this is implemented using the boost.thread move emulation.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:move_assignment Move Assignment Operator]
|
||||
|
||||
unique_future& operator=(unique_future && other);
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Transfers ownership of the asynchronous result associated with `other` to `*this`.]]
|
||||
|
||||
[[Postconditions:] [[unique_future_get_state_link `this->get_state()`] returns the value of `other->get_state()` prior to the
|
||||
call. `other->get_state()` returns __uninitialized__. If `other` was associated with an asynchronous result, that result is now
|
||||
associated with `*this`. `other` is not associated with any asynchronous result. If `*this` was associated with an asynchronous
|
||||
result prior to the call, that result no longer has an associated __unique_future__ instance.]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
[[Notes:] [If the compiler does not support rvalue-references, this is implemented using the boost.thread move emulation.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:swap Member function `swap()`]
|
||||
|
||||
void swap(unique_future & other);
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Swaps ownership of the asynchronous results associated with `other` and `*this`.]]
|
||||
|
||||
[[Postconditions:] [[unique_future_get_state_link `this->get_state()`] returns the value of `other->get_state()` prior to the
|
||||
call. `other->get_state()` returns the value of `this->get_state()` prior to the call. If `other` was associated with an
|
||||
asynchronous result, that result is now associated with `*this`, otherwise `*this` has no associated result. If `*this` was
|
||||
associated with an asynchronous result, that result is now associated with `other`, otherwise `other` has no associated result.]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
|
||||
[section:get Member function `get()`]
|
||||
|
||||
R&& get();
|
||||
R& unique_future<R&>::get();
|
||||
void unique_future<void>::get();
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [If `*this` is associated with an asynchronous result, waits until the result is ready as-if by a call to
|
||||
__unique_future_wait__, and retrieves the result (whether that is a value or an exception).]]
|
||||
|
||||
[[Returns:] [If the result type `R` is a reference, returns the stored reference. If `R` is `void`, there is no return
|
||||
value. Otherwise, returns an rvalue-reference to the value stored in the asynchronous result.]]
|
||||
|
||||
[[Postconditions:] [[unique_future_is_ready_link `this->is_ready()`] returns `true`. [unique_future_get_state_link
|
||||
`this->get_state()`] returns __ready__.]]
|
||||
|
||||
[[Throws:] [__future_uninitialized__ if `*this` is not associated with an asynchronous result. __thread_interrupted__ if the result
|
||||
associated with `*this` is not ready at the point of the call, and the current thread is interrupted. Any exception stored in the
|
||||
asynchronous result in place of a value.]]
|
||||
|
||||
[[Notes:] [`get()` is an ['interruption point].]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:wait Member function `wait()`]
|
||||
|
||||
void wait();
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [If `*this` is associated with an asynchronous result, waits until the result is ready. If the result is not ready on
|
||||
entry, and the result has a ['wait callback] set, that callback is invoked prior to waiting.]]
|
||||
|
||||
[[Throws:] [__future_uninitialized__ if `*this` is not associated with an asynchronous result. __thread_interrupted__ if the result
|
||||
associated with `*this` is not ready at the point of the call, and the current thread is interrupted. Any exception thrown by the
|
||||
['wait callback] if such a callback is called.]]
|
||||
|
||||
[[Postconditions:] [[unique_future_is_ready_link `this->is_ready()`] returns `true`. [unique_future_get_state_link
|
||||
`this->get_state()`] returns __ready__.]]
|
||||
|
||||
[[Notes:] [`wait()` is an ['interruption point].]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:timed_wait_duration Member function `timed_wait()`]
|
||||
|
||||
template<typename Duration>
|
||||
bool timed_wait(Duration const& wait_duration);
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [If `*this` is associated with an asynchronous result, waits until the result is ready, or the time specified by
|
||||
`wait_duration` has elapsed. If the result is not ready on entry, and the result has a ['wait callback] set, that callback is
|
||||
invoked prior to waiting.]]
|
||||
|
||||
[[Returns:] [`true` if `*this` is associated with an asynchronous result, and that result is ready before the specified time has
|
||||
elapsed, `false` otherwise.]]
|
||||
|
||||
[[Throws:] [__future_uninitialized__ if `*this` is not associated with an asynchronous result. __thread_interrupted__ if the result
|
||||
associated with `*this` is not ready at the point of the call, and the current thread is interrupted. Any exception thrown by the
|
||||
['wait callback] if such a callback is called.]]
|
||||
|
||||
[[Postconditions:] [If this call returned `true`, then [unique_future_is_ready_link `this->is_ready()`] returns `true` and
|
||||
[unique_future_get_state_link `this->get_state()`] returns __ready__.]]
|
||||
|
||||
[[Notes:] [`timed_wait()` is an ['interruption point]. `Duration` must be a type that meets the Boost.DateTime time duration requirements.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:timed_wait_absolute Member function `timed_wait()`]
|
||||
|
||||
bool timed_wait(boost::system_time const& wait_timeout);
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [If `*this` is associated with an asynchronous result, waits until the result is ready, or the time point specified by
|
||||
`wait_timeout` has passed. If the result is not ready on entry, and the result has a ['wait callback] set, that callback is invoked
|
||||
prior to waiting.]]
|
||||
|
||||
[[Returns:] [`true` if `*this` is associated with an asynchronous result, and that result is ready before the specified time has
|
||||
passed, `false` otherwise.]]
|
||||
|
||||
[[Throws:] [__future_uninitialized__ if `*this` is not associated with an asynchronous result. __thread_interrupted__ if the result
|
||||
associated with `*this` is not ready at the point of the call, and the current thread is interrupted. Any exception thrown by the
|
||||
['wait callback] if such a callback is called.]]
|
||||
|
||||
[[Postconditions:] [If this call returned `true`, then [unique_future_is_ready_link `this->is_ready()`] returns `true` and
|
||||
[unique_future_get_state_link `this->get_state()`] returns __ready__.]]
|
||||
|
||||
[[Notes:] [`timed_wait()` is an ['interruption point].]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
|
||||
[section:is_ready Member function `is_ready()`]
|
||||
|
||||
bool is_ready();
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Checks to see if the asynchronous result associated with `*this` is set.]]
|
||||
|
||||
[[Returns:] [`true` if `*this` is associated with an asynchronous result, and that result is ready for retrieval, `false`
|
||||
otherwise.]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:has_value Member function `has_value()`]
|
||||
|
||||
bool has_value();
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Checks to see if the asynchronous result associated with `*this` is set with a value rather than an exception.]]
|
||||
|
||||
[[Returns:] [`true` if `*this` is associated with an asynchronous result, that result is ready for retrieval, and the result is a
|
||||
stored value, `false` otherwise.]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:has_exception Member function `has_exception()`]
|
||||
|
||||
bool has_exception();
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Checks to see if the asynchronous result associated with `*this` is set with an exception rather than a value.]]
|
||||
|
||||
[[Returns:] [`true` if `*this` is associated with an asynchronous result, that result is ready for retrieval, and the result is a
|
||||
stored exception, `false` otherwise.]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:get_state Member function `get_state()`]
|
||||
|
||||
future_state::state get_state();
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Determine the state of the asynchronous result associated with `*this`, if any.]]
|
||||
|
||||
[[Returns:] [__uninitialized__ if `*this` is not associated with an asynchronous result. __ready__ if the asynchronous result
|
||||
associated with `*this` is ready for retrieval, __waiting__ otherwise.]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:shared_future `shared_future` class template]
|
||||
|
||||
template <typename R>
|
||||
class shared_future
|
||||
{
|
||||
public:
|
||||
typedef future_state::state state;
|
||||
|
||||
shared_future();
|
||||
~shared_future();
|
||||
|
||||
// copy support
|
||||
shared_future(shared_future const& other);
|
||||
shared_future& operator=(shared_future const& other);
|
||||
|
||||
// move support
|
||||
shared_future(shared_future && other);
|
||||
shared_future(unique_future<R> && other);
|
||||
shared_future& operator=(shared_future && other);
|
||||
shared_future& operator=(unique_future<R> && other);
|
||||
|
||||
void swap(shared_future& other);
|
||||
|
||||
// retrieving the value
|
||||
R get();
|
||||
|
||||
// functions to check state, and wait for ready
|
||||
state get_state() const;
|
||||
bool is_ready() const;
|
||||
bool has_exception() const;
|
||||
bool has_value() const;
|
||||
|
||||
// waiting for the result to be ready
|
||||
void wait() const;
|
||||
template<typename Duration>
|
||||
bool timed_wait(Duration const& rel_time) const;
|
||||
bool timed_wait_until(boost::system_time const& abs_time) const;
|
||||
};
|
||||
|
||||
[section:default_constructor Default Constructor]
|
||||
|
||||
shared_future();
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Constructs an uninitialized future.]]
|
||||
|
||||
[[Postconditions:] [[shared_future_is_ready_link `this->is_ready`] returns `false`. [shared_future_get_state_link
|
||||
`this->get_state()`] returns __uninitialized__.]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:get Member function `get()`]
|
||||
|
||||
const R& get();
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [If `*this` is associated with an asynchronous result, waits until the result is ready as-if by a call to
|
||||
__shared_future_wait__, and returns a `const` reference to the result.]]
|
||||
|
||||
[[Returns:] [If the result type `R` is a reference, returns the stored reference. If `R` is `void`, there is no return
|
||||
value. Otherwise, returns a `const` reference to the value stored in the asynchronous result.]]
|
||||
|
||||
[[Throws:] [__future_uninitialized__ if `*this` is not associated with an asynchronous result. __thread_interrupted__ if the
|
||||
result associated with `*this` is not ready at the point of the call, and the current thread is interrupted.]]
|
||||
|
||||
[[Notes:] [`get()` is an ['interruption point].]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:wait Member function `wait()`]
|
||||
|
||||
void wait();
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [If `*this` is associated with an asynchronous result, waits until the result is ready. If the result is not ready on
|
||||
entry, and the result has a ['wait callback] set, that callback is invoked prior to waiting.]]
|
||||
|
||||
[[Throws:] [__future_uninitialized__ if `*this` is not associated with an asynchronous result. __thread_interrupted__ if the result
|
||||
associated with `*this` is not ready at the point of the call, and the current thread is interrupted. Any exception thrown by the
|
||||
['wait callback] if such a callback is called.]]
|
||||
|
||||
[[Postconditions:] [[shared_future_is_ready_link `this->is_ready()`] returns `true`. [shared_future_get_state_link
|
||||
`this->get_state()`] returns __ready__.]]
|
||||
|
||||
[[Notes:] [`wait()` is an ['interruption point].]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:timed_wait_duration Member function `timed_wait()`]
|
||||
|
||||
template<typename Duration>
|
||||
bool timed_wait(Duration const& wait_duration);
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [If `*this` is associated with an asynchronous result, waits until the result is ready, or the time specified by
|
||||
`wait_duration` has elapsed. If the result is not ready on entry, and the result has a ['wait callback] set, that callback is
|
||||
invoked prior to waiting.]]
|
||||
|
||||
[[Returns:] [`true` if `*this` is associated with an asynchronous result, and that result is ready before the specified time has
|
||||
elapsed, `false` otherwise.]]
|
||||
|
||||
[[Throws:] [__future_uninitialized__ if `*this` is not associated with an asynchronous result. __thread_interrupted__ if the result
|
||||
associated with `*this` is not ready at the point of the call, and the current thread is interrupted. Any exception thrown by the
|
||||
['wait callback] if such a callback is called.]]
|
||||
|
||||
[[Postconditions:] [If this call returned `true`, then [shared_future_is_ready_link `this->is_ready()`] returns `true` and
|
||||
[shared_future_get_state_link `this->get_state()`] returns __ready__.]]
|
||||
|
||||
[[Notes:] [`timed_wait()` is an ['interruption point]. `Duration` must be a type that meets the Boost.DateTime time duration requirements.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:timed_wait_absolute Member function `timed_wait()`]
|
||||
|
||||
bool timed_wait(boost::system_time const& wait_timeout);
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [If `*this` is associated with an asynchronous result, waits until the result is ready, or the time point specified by
|
||||
`wait_timeout` has passed. If the result is not ready on entry, and the result has a ['wait callback] set, that callback is invoked
|
||||
prior to waiting.]]
|
||||
|
||||
[[Returns:] [`true` if `*this` is associated with an asynchronous result, and that result is ready before the specified time has
|
||||
passed, `false` otherwise.]]
|
||||
|
||||
[[Throws:] [__future_uninitialized__ if `*this` is not associated with an asynchronous result. __thread_interrupted__ if the result
|
||||
associated with `*this` is not ready at the point of the call, and the current thread is interrupted. Any exception thrown by the
|
||||
['wait callback] if such a callback is called.]]
|
||||
|
||||
[[Postconditions:] [If this call returned `true`, then [shared_future_is_ready_link `this->is_ready()`] returns `true` and
|
||||
[shared_future_get_state_link `this->get_state()`] returns __ready__.]]
|
||||
|
||||
[[Notes:] [`timed_wait()` is an ['interruption point].]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:is_ready Member function `is_ready()`]
|
||||
|
||||
bool is_ready();
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Checks to see if the asynchronous result associated with `*this` is set.]]
|
||||
|
||||
[[Returns:] [`true` if `*this` is associated with an asynchronous result, and that result is ready for retrieval, `false`
|
||||
otherwise.]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:has_value Member function `has_value()`]
|
||||
|
||||
bool has_value();
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Checks to see if the asynchronous result associated with `*this` is set with a value rather than an exception.]]
|
||||
|
||||
[[Returns:] [`true` if `*this` is associated with an asynchronous result, that result is ready for retrieval, and the result is a
|
||||
stored value, `false` otherwise.]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:has_exception Member function `has_exception()`]
|
||||
|
||||
bool has_exception();
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Checks to see if the asynchronous result associated with `*this` is set with an exception rather than a value.]]
|
||||
|
||||
[[Returns:] [`true` if `*this` is associated with an asynchronous result, that result is ready for retrieval, and the result is a
|
||||
stored exception, `false` otherwise.]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:get_state Member function `get_state()`]
|
||||
|
||||
future_state::state get_state();
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Determine the state of the asynchronous result associated with `*this`, if any.]]
|
||||
|
||||
[[Returns:] [__uninitialized__ if `*this` is not associated with an asynchronous result. __ready__ if the asynchronous result
|
||||
associated with `*this` is ready for retrieval, __waiting__ otherwise.]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:promise `promise` class template]
|
||||
|
||||
template <typename R>
|
||||
class promise
|
||||
{
|
||||
promise(promise & rhs);// = delete;
|
||||
promise & operator=(promise & rhs);// = delete;
|
||||
public:
|
||||
// template <class Allocator> explicit promise(Allocator a);
|
||||
|
||||
promise();
|
||||
~promise();
|
||||
|
||||
// Move support
|
||||
promise(promise && rhs);
|
||||
promise & operator=(promise&& rhs);
|
||||
|
||||
void swap(promise& other);
|
||||
// Result retrieval
|
||||
unique_future<R> get_future();
|
||||
|
||||
// Set the value
|
||||
void set_value(R& r);
|
||||
void set_value(R&& r);
|
||||
void set_exception(boost::exception_ptr e);
|
||||
|
||||
template<typename F>
|
||||
void set_wait_callback(F f);
|
||||
};
|
||||
|
||||
[section:default_constructor Default Constructor]
|
||||
|
||||
promise();
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Constructs a new __promise__ with no associated result.]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:move_constructor Move Constructor]
|
||||
|
||||
promise(promise && other);
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Constructs a new __promise__, and transfers ownership of the result associated with `other` to `*this`, leaving `other`
|
||||
with no associated result.]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
[[Notes:] [If the compiler does not support rvalue-references, this is implemented using the boost.thread move emulation.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:move_assignment Move Assignment Operator]
|
||||
|
||||
promise& operator=(promise && other);
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Transfers ownership of the result associated with `other` to `*this`, leaving `other` with no associated result. If there
|
||||
was already a result associated with `*this`, and that result was not ['ready], sets any futures associated with that result to
|
||||
['ready] with a __broken_promise__ exception as the result. ]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
[[Notes:] [If the compiler does not support rvalue-references, this is implemented using the boost.thread move emulation.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:destructor Destructor]
|
||||
|
||||
~promise();
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Destroys `*this`. If there was a result associated with `*this`, and that result is not ['ready], sets any futures
|
||||
associated with that task to ['ready] with a __broken_promise__ exception as the result.]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:get_future Member Function `get_future()`]
|
||||
|
||||
unique_future<R> get_future();
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [If `*this` was not associated with a result, allocate storage for a new asynchronous result and associate it with
|
||||
`*this`. Returns a __unique_future__ associated with the result associated with `*this`. ]]
|
||||
|
||||
[[Throws:] [__future_already_retrieved__ if the future associated with the task has already been retrieved. `std::bad_alloc` if any
|
||||
memory necessary could not be allocated.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:set_value Member Function `set_value()`]
|
||||
|
||||
void set_value(R&& r);
|
||||
void set_value(const R& r);
|
||||
void promise<R&>::set_value(R& r);
|
||||
void promise<void>::set_value();
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [If `*this` was not associated with a result, allocate storage for a new asynchronous result and associate it with
|
||||
`*this`. Store the value `r` in the asynchronous result associated with `*this`. Any threads blocked waiting for the asynchronous
|
||||
result are woken.]]
|
||||
|
||||
[[Postconditions:] [All futures waiting on the asynchronous result are ['ready] and __unique_future_has_value__ or
|
||||
__shared_future_has_value__ for those futures shall return `true`.]]
|
||||
|
||||
[[Throws:] [__promise_already_satisfied__ if the result associated with `*this` is already ['ready]. `std::bad_alloc` if the memory
|
||||
required for storage of the result cannot be allocated. Any exception thrown by the copy or move-constructor of `R`.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:set_exception Member Function `set_exception()`]
|
||||
|
||||
void set_exception(boost::exception_ptr e);
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [If `*this` was not associated with a result, allocate storage for a new asynchronous result and associate it with
|
||||
`*this`. Store the exception `e` in the asynchronous result associated with `*this`. Any threads blocked waiting for the asynchronous
|
||||
result are woken.]]
|
||||
|
||||
[[Postconditions:] [All futures waiting on the asynchronous result are ['ready] and __unique_future_has_exception__ or
|
||||
__shared_future_has_exception__ for those futures shall return `true`.]]
|
||||
|
||||
[[Throws:] [__promise_already_satisfied__ if the result associated with `*this` is already ['ready]. `std::bad_alloc` if the memory
|
||||
required for storage of the result cannot be allocated.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:set_wait_callback Member Function `set_wait_callback()`]
|
||||
|
||||
template<typename F>
|
||||
void set_wait_callback(F f);
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Preconditions:] [The expression `f(t)` where `t` is a lvalue of type __packaged_task__ shall be well-formed. Invoking a copy of
|
||||
`f` shall have the same effect as invoking `f`]]
|
||||
|
||||
[[Effects:] [Store a copy of `f` with the asynchronous result associated with `*this` as a ['wait callback]. This will replace any
|
||||
existing wait callback store alongside that result. If a thread subsequently calls one of the wait functions on a __unique_future__
|
||||
or __shared_future__ associated with this result, and the result is not ['ready], `f(*this)` shall be invoked.]]
|
||||
|
||||
[[Throws:] [`std::bad_alloc` if memory cannot be allocated for the required storage.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:packaged_task `packaged_task` class template]
|
||||
|
||||
template<typename R>
|
||||
class packaged_task
|
||||
{
|
||||
packaged_task(packaged_task&);// = delete;
|
||||
packaged_task& operator=(packaged_task&);// = delete;
|
||||
|
||||
public:
|
||||
// construction and destruction
|
||||
template <class F>
|
||||
explicit packaged_task(F const& f);
|
||||
|
||||
explicit packaged_task(R(*f)());
|
||||
|
||||
template <class F>
|
||||
explicit packaged_task(F&& f);
|
||||
|
||||
// template <class F, class Allocator>
|
||||
// explicit packaged_task(F const& f, Allocator a);
|
||||
// template <class F, class Allocator>
|
||||
// explicit packaged_task(F&& f, Allocator a);
|
||||
|
||||
~packaged_task()
|
||||
{}
|
||||
|
||||
// move support
|
||||
packaged_task(packaged_task&& other);
|
||||
packaged_task& operator=(packaged_task&& other);
|
||||
|
||||
void swap(packaged_task& other);
|
||||
// result retrieval
|
||||
unique_future<R> get_future();
|
||||
|
||||
// execution
|
||||
void operator()();
|
||||
|
||||
template<typename F>
|
||||
void set_wait_callback(F f);
|
||||
};
|
||||
|
||||
[section:task_constructor Task Constructor]
|
||||
|
||||
template<typename F>
|
||||
packaged_task(F const &f);
|
||||
|
||||
packaged_task(R(*f)());
|
||||
|
||||
template<typename F>
|
||||
packaged_task(F&&f);
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Preconditions:] [`f()` is a valid expression with a return type convertible to `R`. Invoking a copy of `f` shall behave the same
|
||||
as invoking `f`.]]
|
||||
|
||||
[[Effects:] [Constructs a new __packaged_task__ with a copy of `f` stored as the associated task.]]
|
||||
|
||||
[[Throws:] [Any exceptions thrown by the copy (or move) constructor of `f`. `std::bad_alloc` if memory for the internal data
|
||||
structures could not be allocated.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:move_constructor Move Constructor]
|
||||
|
||||
packaged_task(packaged_task && other);
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Constructs a new __packaged_task__, and transfers ownership of the task associated with `other` to `*this`, leaving `other`
|
||||
with no associated task.]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
[[Notes:] [If the compiler does not support rvalue-references, this is implemented using the boost.thread move emulation.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:move_assignment Move Assignment Operator]
|
||||
|
||||
packaged_task& operator=(packaged_task && other);
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Transfers ownership of the task associated with `other` to `*this`, leaving `other` with no associated task. If there
|
||||
was already a task associated with `*this`, and that task has not been invoked, sets any futures associated with that task to
|
||||
['ready] with a __broken_promise__ exception as the result. ]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
[[Notes:] [If the compiler does not support rvalue-references, this is implemented using the boost.thread move emulation.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:destructor Destructor]
|
||||
|
||||
~packaged_task();
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Destroys `*this`. If there was a task associated with `*this`, and that task has not been invoked, sets any futures
|
||||
associated with that task to ['ready] with a __broken_promise__ exception as the result.]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:get_future Member Function `get_future()`]
|
||||
|
||||
unique_future<R> get_future();
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Returns a __unique_future__ associated with the result of the task associated with `*this`. ]]
|
||||
|
||||
[[Throws:] [__task_moved__ if ownership of the task associated with `*this` has been moved to another instance of
|
||||
__packaged_task__. __future_already_retrieved__ if the future associated with the task has already been retrieved.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:call_operator Member Function `operator()()`]
|
||||
|
||||
void operator()();
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Invoke the task associated with `*this` and store the result in the corresponding future. If the task returns normally,
|
||||
the return value is stored as the asynchronous result, otherwise the exception thrown is stored. Any threads blocked waiting for the
|
||||
asynchronous result associated with this task are woken.]]
|
||||
|
||||
[[Postconditions:] [All futures waiting on the asynchronous result are ['ready]]]
|
||||
|
||||
[[Throws:] [__task_moved__ if ownership of the task associated with `*this` has been moved to another instance of
|
||||
__packaged_task__. __task_already_started__ if the task has already been invoked.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:set_wait_callback Member Function `set_wait_callback()`]
|
||||
|
||||
template<typename F>
|
||||
void set_wait_callback(F f);
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Preconditions:] [The expression `f(t)` where `t` is a lvalue of type __packaged_task__ shall be well-formed. Invoking a copy of
|
||||
`f` shall have the same effect as invoking `f`]]
|
||||
|
||||
[[Effects:] [Store a copy of `f` with the task associated with `*this` as a ['wait callback]. This will replace any existing wait
|
||||
callback store alongside that task. If a thread subsequently calls one of the wait functions on a __unique_future__ or
|
||||
__shared_future__ associated with this task, and the result of the task is not ['ready], `f(*this)` shall be invoked.]]
|
||||
|
||||
[[Throws:] [__task_moved__ if ownership of the task associated with `*this` has been moved to another instance of
|
||||
__packaged_task__.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:wait_for_any Non-member function `wait_for_any()`]
|
||||
|
||||
template<typename Iterator>
|
||||
Iterator wait_for_any(Iterator begin,Iterator end);
|
||||
|
||||
template<typename F1,typename F2>
|
||||
unsigned wait_for_any(F1& f1,F2& f2);
|
||||
|
||||
template<typename F1,typename F2,typename F3>
|
||||
unsigned wait_for_any(F1& f1,F2& f2,F3& f3);
|
||||
|
||||
template<typename F1,typename F2,typename F3,typename F4>
|
||||
unsigned wait_for_any(F1& f1,F2& f2,F3& f3,F4& f4);
|
||||
|
||||
template<typename F1,typename F2,typename F3,typename F4,typename F5>
|
||||
unsigned wait_for_any(F1& f1,F2& f2,F3& f3,F4& f4,F5& f5);
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Preconditions:] [The types `Fn` shall be specializations of
|
||||
__unique_future__ or __shared_future__, and `Iterator` shall be a
|
||||
forward iterator with a `value_type` which is a specialization of
|
||||
__unique_future__ or __shared_future__.]]
|
||||
|
||||
[[Effects:] [Waits until at least one of the specified futures is ['ready].]]
|
||||
|
||||
[[Returns:] [The range-based overload returns an `Iterator` identifying the first future in the range that was detected as
|
||||
['ready]. The remaining overloads return the zero-based index of the first future that was detected as ['ready] (first parameter =>
|
||||
0, second parameter => 1, etc.).]]
|
||||
|
||||
[[Throws:] [__thread_interrupted__ if the current thread is interrupted. Any exception thrown by the ['wait callback] associated
|
||||
with any of the futures being waited for. `std::bad_alloc` if memory could not be allocated for the internal wait structures.]]
|
||||
|
||||
[[Notes:] [`wait_for_any()` is an ['interruption point].]]
|
||||
|
||||
]
|
||||
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:wait_for_all Non-member function `wait_for_all()`]
|
||||
|
||||
template<typename Iterator>
|
||||
void wait_for_all(Iterator begin,Iterator end);
|
||||
|
||||
template<typename F1,typename F2>
|
||||
void wait_for_all(F1& f1,F2& f2);
|
||||
|
||||
template<typename F1,typename F2,typename F3>
|
||||
void wait_for_all(F1& f1,F2& f2,F3& f3);
|
||||
|
||||
template<typename F1,typename F2,typename F3,typename F4>
|
||||
void wait_for_all(F1& f1,F2& f2,F3& f3,F4& f4);
|
||||
|
||||
template<typename F1,typename F2,typename F3,typename F4,typename F5>
|
||||
void wait_for_all(F1& f1,F2& f2,F3& f3,F4& f4,F5& f5);
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Preconditions:] [The types `Fn` shall be specializations of
|
||||
__unique_future__ or __shared_future__, and `Iterator` shall be a
|
||||
forward iterator with a `value_type` which is a specialization of
|
||||
__unique_future__ or __shared_future__.]]
|
||||
|
||||
[[Effects:] [Waits until all of the specified futures are ['ready].]]
|
||||
|
||||
[[Throws:] [Any exceptions thrown by a call to `wait()` on the specified futures.]]
|
||||
|
||||
[[Notes:] [`wait_for_all()` is an ['interruption point].]]
|
||||
|
||||
]
|
||||
|
||||
|
||||
[endsect]
|
||||
|
||||
|
||||
[endsect]
|
||||
187
doc/futures.qbk
187
doc/futures.qbk
@@ -1,187 +0,0 @@
|
||||
[/
|
||||
(C) Copyright 2008-9 Anthony Williams.
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt).
|
||||
]
|
||||
|
||||
[section:futures Futures]
|
||||
|
||||
[template future_state_link[link_text] [link thread.synchronization.futures.reference.future_state [link_text]]]
|
||||
[def __uninitialized__ [future_state_link `boost::future_state::uninitialized`]]
|
||||
[def __ready__ [future_state_link `boost::future_state::ready`]]
|
||||
[def __waiting__ [future_state_link `boost::future_state::waiting`]]
|
||||
|
||||
[def __future_uninitialized__ `boost::future_uninitialized`]
|
||||
[def __broken_promise__ `boost::broken_promise`]
|
||||
[def __future_already_retrieved__ `boost::future_already_retrieved`]
|
||||
[def __task_moved__ `boost::task_moved`]
|
||||
[def __task_already_started__ `boost::task_already_started`]
|
||||
[def __promise_already_satisfied__ `boost::promise_already_satisfied`]
|
||||
|
||||
[def __thread_interrupted__ `boost::thread_interrupted`]
|
||||
|
||||
|
||||
[template unique_future_link[link_text] [link thread.synchronization.futures.reference.unique_future [link_text]]]
|
||||
[def __unique_future__ [unique_future_link `boost::unique_future`]]
|
||||
|
||||
[template unique_future_get_link[link_text] [link thread.synchronization.futures.reference.unique_future.get [link_text]]]
|
||||
[def __unique_future_get__ [unique_future_get_link `boost::unique_future<R>::get()`]]
|
||||
|
||||
[template unique_future_wait_link[link_text] [link thread.synchronization.futures.reference.unique_future.wait [link_text]]]
|
||||
[def __unique_future_wait__ [unique_future_wait_link `boost::unique_future<R>::wait()`]]
|
||||
|
||||
[template unique_future_is_ready_link[link_text] [link thread.synchronization.futures.reference.unique_future.is_ready [link_text]]]
|
||||
[def __unique_future_is_ready__ [unique_future_is_ready_link `boost::unique_future<R>::is_ready()`]]
|
||||
|
||||
[template unique_future_has_value_link[link_text] [link thread.synchronization.futures.reference.unique_future.has_value [link_text]]]
|
||||
[def __unique_future_has_value__ [unique_future_has_value_link `boost::unique_future<R>::has_value()`]]
|
||||
|
||||
[template unique_future_has_exception_link[link_text] [link thread.synchronization.futures.reference.unique_future.has_exception [link_text]]]
|
||||
[def __unique_future_has_exception__ [unique_future_has_exception_link `boost::unique_future<R>::has_exception()`]]
|
||||
|
||||
[template unique_future_get_state_link[link_text] [link thread.synchronization.futures.reference.unique_future.get_state [link_text]]]
|
||||
[def __unique_future_get_state__ [unique_future_get_state_link `boost::unique_future<R>::get_state()`]]
|
||||
|
||||
[template shared_future_link[link_text] [link thread.synchronization.futures.reference.shared_future [link_text]]]
|
||||
[def __shared_future__ [shared_future_link `boost::shared_future`]]
|
||||
|
||||
[template shared_future_get_link[link_text] [link thread.synchronization.futures.reference.shared_future.get [link_text]]]
|
||||
[def __shared_future_get__ [shared_future_get_link `boost::shared_future<R>::get()`]]
|
||||
|
||||
[template shared_future_wait_link[link_text] [link thread.synchronization.futures.reference.shared_future.wait [link_text]]]
|
||||
[def __shared_future_wait__ [shared_future_wait_link `boost::shared_future<R>::wait()`]]
|
||||
|
||||
[template shared_future_is_ready_link[link_text] [link thread.synchronization.futures.reference.shared_future.is_ready [link_text]]]
|
||||
[def __shared_future_is_ready__ [shared_future_is_ready_link `boost::shared_future<R>::is_ready()`]]
|
||||
|
||||
[template shared_future_has_value_link[link_text] [link thread.synchronization.futures.reference.shared_future.has_value [link_text]]]
|
||||
[def __shared_future_has_value__ [shared_future_has_value_link `boost::shared_future<R>::has_value()`]]
|
||||
|
||||
[template shared_future_has_exception_link[link_text] [link thread.synchronization.futures.reference.shared_future.has_exception [link_text]]]
|
||||
[def __shared_future_has_exception__ [shared_future_has_exception_link `boost::shared_future<R>::has_exception()`]]
|
||||
|
||||
[template shared_future_get_state_link[link_text] [link thread.synchronization.futures.reference.shared_future.get_state [link_text]]]
|
||||
[def __shared_future_get_state__ [shared_future_get_state_link `boost::shared_future<R>::get_state()`]]
|
||||
|
||||
[template promise_link[link_text] [link thread.synchronization.futures.reference.promise [link_text]]]
|
||||
[def __promise__ [promise_link `boost::promise`]]
|
||||
|
||||
[template packaged_task_link[link_text] [link thread.synchronization.futures.reference.packaged_task [link_text]]]
|
||||
[def __packaged_task__ [packaged_task_link `boost::packaged_task`]]
|
||||
|
||||
[template wait_for_any_link[link_text] [link thread.synchronization.futures.reference.wait_for_any [link_text]]]
|
||||
[def __wait_for_any__ [wait_for_any_link `boost::wait_for_any()`]]
|
||||
|
||||
[template wait_for_all_link[link_text] [link thread.synchronization.futures.reference.wait_for_all [link_text]]]
|
||||
[def __wait_for_all__ [wait_for_all_link `boost::wait_for_all()`]]
|
||||
|
||||
|
||||
[section:overview Overview]
|
||||
|
||||
The futures library provides a means of handling synchronous future values, whether those values are generated by another thread, or
|
||||
on a single thread in response to external stimuli, or on-demand.
|
||||
|
||||
This is done through the provision of four class templates: __unique_future__ and __shared_future__ which are used to retrieve the
|
||||
asynchronous results, and __promise__ and __packaged_task__ which are used to generate the asynchronous results.
|
||||
|
||||
An instance of __unique_future__ holds the one and only reference to a result. Ownership can be transferred between instances using
|
||||
the move constructor or move-assignment operator, but at most one instance holds a reference to a given asynchronous result. When
|
||||
the result is ready, it is returned from __unique_future_get__ by rvalue-reference to allow the result to be moved or copied as
|
||||
appropriate for the type.
|
||||
|
||||
On the other hand, many instances of __shared_future__ may reference the same result. Instances can be freely copied and assigned,
|
||||
and __shared_future_get__ returns a `const` reference so that multiple calls to __shared_future_get__ are safe. You can move an
|
||||
instance of __unique_future__ into an instance of __shared_future__, thus transferring ownership of the associated asynchronous
|
||||
result, but not vice-versa.
|
||||
|
||||
You can wait for futures either individually or with one of the __wait_for_any__ and __wait_for_all__ functions.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:creating Creating asynchronous values]
|
||||
|
||||
You can set the value in a future with either a __promise__ or a __packaged_task__. A __packaged_task__ is a callable object that
|
||||
wraps a function or callable object. When the packaged task is invoked, it invokes the contained function in turn, and populates a
|
||||
future with the return value. This is an answer to the perennial question: "how do I return a value from a thread?": package the
|
||||
function you wish to run as a __packaged_task__ and pass the packaged task to the thread constructor. The future retrieved from the
|
||||
packaged task can then be used to obtain the return value. If the function throws an exception, that is stored in the future in
|
||||
place of the return value.
|
||||
|
||||
int calculate_the_answer_to_life_the_universe_and_everything()
|
||||
{
|
||||
return 42;
|
||||
}
|
||||
|
||||
boost::packaged_task<int> pt(calculate_the_answer_to_life_the_universe_and_everything);
|
||||
boost::unique_future<int> fi=pt.get_future();
|
||||
|
||||
boost::thread task(boost::move(pt)); // launch task on a thread
|
||||
|
||||
fi.wait(); // wait for it to finish
|
||||
|
||||
assert(fi.is_ready());
|
||||
assert(fi.has_value());
|
||||
assert(!fi.has_exception());
|
||||
assert(fi.get_state()==boost::future_state::ready);
|
||||
assert(fi.get()==42);
|
||||
|
||||
|
||||
A __promise__ is a bit more low level: it just provides explicit functions to store a value or an exception in the associated
|
||||
future. A promise can therefore be used where the value may come from more than one possible source, or where a single operation may
|
||||
produce multiple values.
|
||||
|
||||
boost::promise<int> pi;
|
||||
boost::unique_future<int> fi;
|
||||
fi=pi.get_future();
|
||||
|
||||
pi.set_value(42);
|
||||
|
||||
assert(fi.is_ready());
|
||||
assert(fi.has_value());
|
||||
assert(!fi.has_exception());
|
||||
assert(fi.get_state()==boost::future_state::ready);
|
||||
assert(fi.get()==42);
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:lazy_futures Wait Callbacks and Lazy Futures]
|
||||
|
||||
Both __promise__ and __packaged_task__ support ['wait callbacks] that are invoked when a thread blocks in a call to `wait()` or
|
||||
`timed_wait()` on a future that is waiting for the result from the __promise__ or __packaged_task__, in the thread that is doing the
|
||||
waiting. These can be set using the `set_wait_callback()` member function on the __promise__ or __packaged_task__ in question.
|
||||
|
||||
This allows ['lazy futures] where the result is not actually computed until it is needed by some thread. In the example below, the
|
||||
call to `f.get()` invokes the callback `invoke_lazy_task`, which runs the task to set the value. If you remove the call to
|
||||
`f.get()`, the task is not ever run.
|
||||
|
||||
int calculate_the_answer_to_life_the_universe_and_everything()
|
||||
{
|
||||
return 42;
|
||||
}
|
||||
|
||||
void invoke_lazy_task(boost::packaged_task<int>& task)
|
||||
{
|
||||
try
|
||||
{
|
||||
task();
|
||||
}
|
||||
catch(boost::task_already_started&)
|
||||
{}
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
boost::packaged_task<int> task(calculate_the_answer_to_life_the_universe_and_everything);
|
||||
task.set_wait_callback(invoke_lazy_task);
|
||||
boost::unique_future<int> f(task.get_future());
|
||||
|
||||
assert(f.get()==42);
|
||||
}
|
||||
|
||||
|
||||
[endsect]
|
||||
|
||||
[include future_ref.qbk]
|
||||
|
||||
[endsect]
|
||||
146
doc/index.html
146
doc/index.html
@@ -1,12 +1,138 @@
|
||||
<!-- Copyright (c) 2002-2003 Beman Dawes, William E. Kempf.
|
||||
Subject to the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
|
||||
-->
|
||||
<html>
|
||||
<head>
|
||||
<meta http-equiv="refresh" content="0; URL=../../../doc/html/thread.html">
|
||||
</head>
|
||||
<body>
|
||||
Automatic redirection failed, please go to <a href="../../../doc/html/thread.html">../../../doc/html/thread.html</a>
|
||||
</body>
|
||||
<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 summary="header" 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>
|
||||
<a href="mutex_concept.html">Mutex Concepts</a>
|
||||
|
||||
<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>
|
||||
|
||||
<li>
|
||||
Mutex Classes
|
||||
|
||||
<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>
|
||||
|
||||
<li>
|
||||
<a href="lock_concept.html">Lock Concepts</a>
|
||||
|
||||
<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>
|
||||
|
||||
<li>
|
||||
Lock Classes
|
||||
|
||||
<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>
|
||||
|
||||
<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 -->05 November, 2001<!--webbot bot="Timestamp" endspan i-checksum="39359" --></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>
|
||||
|
||||
|
||||
194
doc/introduction.html
Normal file
194
doc/introduction.html
Normal file
@@ -0,0 +1,194 @@
|
||||
<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 summary="header" 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>
|
||||
|
||||
<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.</p>
|
||||
</li>
|
||||
</ul>
|
||||
</li>
|
||||
|
||||
<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>
|
||||
|
||||
<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="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 -->05 November, 2001<!--webbot bot="Timestamp" endspan i-checksum="39359" --></p>
|
||||
|
||||
<p><i>© Copyright <a href="mailto:williamkempf@hotmail.com">
|
||||
William E. Kempf</a> 2001 all rights reserved.</i></p>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
300
doc/lock_concept.html
Normal file
300
doc/lock_concept.html
Normal file
@@ -0,0 +1,300 @@
|
||||
<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 summary="header" 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 summary="Lock expressions" 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 summary="ScopedLock expressions" 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 summary="ScopedTryLock expressions" 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 summary="ScopedTimedLock expressions" 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 summary="Lock concept classes" 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 -->05 November, 2001<!--webbot bot="Timestamp" endspan i-checksum="39359" --></p>
|
||||
|
||||
<p><i>© Copyright <a href="mailto:williamkempf@hotmail.com">
|
||||
William E. Kempf</a> 2001 all rights reserved.</i></p>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
110
doc/lock_error.html
Normal file
110
doc/lock_error.html
Normal file
@@ -0,0 +1,110 @@
|
||||
<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 summary="header" 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 -->05 November, 2001<!--webbot bot="Timestamp" endspan i-checksum="39359" --></p>
|
||||
|
||||
<p><i>© Copyright <a href="mailto:williamkempf@hotmail.com">
|
||||
William E. Kempf</a> 2001 all rights reserved.</i></p>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
359
doc/mutex.html
Normal file
359
doc/mutex.html
Normal file
@@ -0,0 +1,359 @@
|
||||
<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 summary="header" 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 summary="lock types" 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 -->05 November, 2001<!--webbot bot="Timestamp" endspan i-checksum="39359" --></p>
|
||||
|
||||
<p><i>© Copyright <a href="mailto:williamkempf@hotmail.com">
|
||||
William E. Kempf</a> 2001 all rights reserved.</i></p>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
337
doc/mutex_concept.html
Normal file
337
doc/mutex_concept.html
Normal file
@@ -0,0 +1,337 @@
|
||||
<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 summary="header" 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 summary="Mutex expressions" 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 summary="TryMutex expressions" 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 summary="TimedMutex expressions" 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 summary="Mutex concept classes" 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 -->05 November, 2001<!--webbot bot="Timestamp" endspan i-checksum="39359" --></p>
|
||||
|
||||
<p><i>© Copyright <a href="mailto:williamkempf@hotmail.com">
|
||||
William E. Kempf</a> 2001 all rights reserved.</i></p>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
224
doc/mutexes.qbk
224
doc/mutexes.qbk
@@ -1,224 +0,0 @@
|
||||
[/
|
||||
(C) Copyright 2007-8 Anthony Williams.
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt).
|
||||
]
|
||||
|
||||
[section:mutex_types Mutex Types]
|
||||
|
||||
[section:mutex Class `mutex`]
|
||||
|
||||
#include <boost/thread/mutex.hpp>
|
||||
|
||||
class mutex:
|
||||
boost::noncopyable
|
||||
{
|
||||
public:
|
||||
mutex();
|
||||
~mutex();
|
||||
|
||||
void lock();
|
||||
bool try_lock();
|
||||
void unlock();
|
||||
|
||||
typedef platform-specific-type native_handle_type;
|
||||
native_handle_type native_handle();
|
||||
|
||||
typedef unique_lock<mutex> scoped_lock;
|
||||
typedef unspecified-type scoped_try_lock;
|
||||
};
|
||||
|
||||
__mutex__ implements the __lockable_concept__ to provide an exclusive-ownership mutex. At most one thread can own the lock on a given
|
||||
instance of __mutex__ at any time. Multiple concurrent calls to __lock_ref__, __try_lock_ref__ and __unlock_ref__ shall be permitted.
|
||||
|
||||
[section:nativehandle Member function `native_handle()`]
|
||||
|
||||
typedef platform-specific-type native_handle_type;
|
||||
native_handle_type native_handle();
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Returns an instance of `native_handle_type` that can be used with platform-specific APIs to manipulate the underlying
|
||||
implementation. If no such instance exists, `native_handle()` and `native_handle_type` are not present.]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:try_mutex Typedef `try_mutex`]
|
||||
|
||||
#include <boost/thread/mutex.hpp>
|
||||
|
||||
typedef mutex try_mutex;
|
||||
|
||||
__try_mutex__ is a `typedef` to __mutex__, provided for backwards compatibility with previous releases of boost.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:timed_mutex Class `timed_mutex`]
|
||||
|
||||
#include <boost/thread/mutex.hpp>
|
||||
|
||||
class timed_mutex:
|
||||
boost::noncopyable
|
||||
{
|
||||
public:
|
||||
timed_mutex();
|
||||
~timed_mutex();
|
||||
|
||||
void lock();
|
||||
void unlock();
|
||||
bool try_lock();
|
||||
bool timed_lock(system_time const & abs_time);
|
||||
|
||||
template<typename TimeDuration>
|
||||
bool timed_lock(TimeDuration const & relative_time);
|
||||
|
||||
typedef platform-specific-type native_handle_type;
|
||||
native_handle_type native_handle();
|
||||
|
||||
typedef unique_lock<timed_mutex> scoped_timed_lock;
|
||||
typedef unspecified-type scoped_try_lock;
|
||||
typedef scoped_timed_lock scoped_lock;
|
||||
};
|
||||
|
||||
__timed_mutex__ implements the __timed_lockable_concept__ to provide an exclusive-ownership mutex. At most one thread can own the
|
||||
lock on a given instance of __timed_mutex__ at any time. Multiple concurrent calls to __lock_ref__, __try_lock_ref__,
|
||||
__timed_lock_ref__, __timed_lock_duration_ref__ and __unlock_ref__ shall be permitted.
|
||||
|
||||
[section:nativehandle Member function `native_handle()`]
|
||||
|
||||
typedef platform-specific-type native_handle_type;
|
||||
native_handle_type native_handle();
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Returns an instance of `native_handle_type` that can be used with platform-specific APIs to manipulate the underlying
|
||||
implementation. If no such instance exists, `native_handle()` and `native_handle_type` are not present.]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:recursive_mutex Class `recursive_mutex`]
|
||||
|
||||
#include <boost/thread/recursive_mutex.hpp>
|
||||
|
||||
class recursive_mutex:
|
||||
boost::noncopyable
|
||||
{
|
||||
public:
|
||||
recursive_mutex();
|
||||
~recursive_mutex();
|
||||
|
||||
void lock();
|
||||
bool try_lock();
|
||||
void unlock();
|
||||
|
||||
typedef platform-specific-type native_handle_type;
|
||||
native_handle_type native_handle();
|
||||
|
||||
typedef unique_lock<recursive_mutex> scoped_lock;
|
||||
typedef unspecified-type scoped_try_lock;
|
||||
};
|
||||
|
||||
__recursive_mutex__ implements the __lockable_concept__ to provide an exclusive-ownership recursive mutex. At most one thread can
|
||||
own the lock on a given instance of __recursive_mutex__ at any time. Multiple concurrent calls to __lock_ref__, __try_lock_ref__ and
|
||||
__unlock_ref__ shall be permitted. A thread that already has exclusive ownership of a given __recursive_mutex__ instance can call
|
||||
__lock_ref__ or __try_lock_ref__ to acquire an additional level of ownership of the mutex. __unlock_ref__ must be called once for
|
||||
each level of ownership acquired by a single thread before ownership can be acquired by another thread.
|
||||
|
||||
[section:nativehandle Member function `native_handle()`]
|
||||
|
||||
typedef platform-specific-type native_handle_type;
|
||||
native_handle_type native_handle();
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Returns an instance of `native_handle_type` that can be used with platform-specific APIs to manipulate the underlying
|
||||
implementation. If no such instance exists, `native_handle()` and `native_handle_type` are not present.]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:recursive_try_mutex Typedef `recursive_try_mutex`]
|
||||
|
||||
#include <boost/thread/recursive_mutex.hpp>
|
||||
|
||||
typedef recursive_mutex recursive_try_mutex;
|
||||
|
||||
__recursive_try_mutex__ is a `typedef` to __recursive_mutex__, provided for backwards compatibility with previous releases of boost.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:recursive_timed_mutex Class `recursive_timed_mutex`]
|
||||
|
||||
#include <boost/thread/recursive_mutex.hpp>
|
||||
|
||||
class recursive_timed_mutex:
|
||||
boost::noncopyable
|
||||
{
|
||||
public:
|
||||
recursive_timed_mutex();
|
||||
~recursive_timed_mutex();
|
||||
|
||||
void lock();
|
||||
bool try_lock();
|
||||
void unlock();
|
||||
|
||||
bool timed_lock(system_time const & abs_time);
|
||||
|
||||
template<typename TimeDuration>
|
||||
bool timed_lock(TimeDuration const & relative_time);
|
||||
|
||||
typedef platform-specific-type native_handle_type;
|
||||
native_handle_type native_handle();
|
||||
|
||||
typedef unique_lock<recursive_timed_mutex> scoped_lock;
|
||||
typedef unspecified-type scoped_try_lock;
|
||||
typedef scoped_lock scoped_timed_lock;
|
||||
};
|
||||
|
||||
__recursive_timed_mutex__ implements the __timed_lockable_concept__ to provide an exclusive-ownership recursive mutex. At most one
|
||||
thread can own the lock on a given instance of __recursive_timed_mutex__ at any time. Multiple concurrent calls to __lock_ref__,
|
||||
__try_lock_ref__, __timed_lock_ref__, __timed_lock_duration_ref__ and __unlock_ref__ shall be permitted. A thread that already has
|
||||
exclusive ownership of a given __recursive_timed_mutex__ instance can call __lock_ref__, __timed_lock_ref__,
|
||||
__timed_lock_duration_ref__ or __try_lock_ref__ to acquire an additional level of ownership of the mutex. __unlock_ref__ must be
|
||||
called once for each level of ownership acquired by a single thread before ownership can be acquired by another thread.
|
||||
|
||||
[section:nativehandle Member function `native_handle()`]
|
||||
|
||||
typedef platform-specific-type native_handle_type;
|
||||
native_handle_type native_handle();
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Returns an instance of `native_handle_type` that can be used with platform-specific APIs to manipulate the underlying
|
||||
implementation. If no such instance exists, `native_handle()` and `native_handle_type` are not present.]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
|
||||
[include shared_mutex_ref.qbk]
|
||||
|
||||
[endsect]
|
||||
65
doc/once.qbk
65
doc/once.qbk
@@ -1,65 +0,0 @@
|
||||
[/
|
||||
(C) Copyright 2007-8 Anthony Williams.
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt).
|
||||
]
|
||||
|
||||
[section:once One-time Initialization]
|
||||
|
||||
`boost::call_once` provides a mechanism for ensuring that an initialization routine is run exactly once without data races or deadlocks.
|
||||
|
||||
[section:once_flag Typedef `once_flag`]
|
||||
|
||||
#include <boost/thread/once.hpp>
|
||||
|
||||
typedef platform-specific-type once_flag;
|
||||
#define BOOST_ONCE_INIT platform-specific-initializer
|
||||
|
||||
Objects of type `boost::once_flag` shall be initialized with `BOOST_ONCE_INIT`:
|
||||
|
||||
boost::once_flag f=BOOST_ONCE_INIT;
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:call_once Non-member function `call_once`]
|
||||
|
||||
#include <boost/thread/once.hpp>
|
||||
|
||||
template<typename Callable>
|
||||
void call_once(once_flag& flag,Callable func);
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Requires:] [`Callable` is `CopyConstructible`. Copying `func` shall have no side effects, and the effect of calling the copy shall
|
||||
be equivalent to calling the original. ]]
|
||||
|
||||
[[Effects:] [Calls to `call_once` on the same `once_flag` object are serialized. If there has been no prior effective `call_once` on
|
||||
the same `once_flag` object, the argument `func` (or a copy thereof) is called as-if by invoking `func()`, and the invocation of
|
||||
`call_once` is effective if and only if `func()` returns without exception. If an exception is thrown, the exception is
|
||||
propagated to the caller. If there has been a prior effective `call_once` on the same `once_flag` object, the `call_once` returns
|
||||
without invoking `func`. ]]
|
||||
|
||||
[[Synchronization:] [The completion of an effective `call_once` invocation on a `once_flag` object, synchronizes with
|
||||
all subsequent `call_once` invocations on the same `once_flag` object. ]]
|
||||
|
||||
[[Throws:] [`thread_resource_error` when the effects cannot be achieved. or any exception propagated from `func`.]]
|
||||
|
||||
[[Note:] [The function passed to `call_once` must not also call
|
||||
`call_once` passing the same `once_flag` object. This may cause
|
||||
deadlock, or invoking the passed function a second time. The
|
||||
alternative is to allow the second call to return immediately, but
|
||||
that assumes the code knows it has been called recursively, and can
|
||||
proceed even though the call to `call_once` didn't actually call the
|
||||
function, in which case it could also avoid calling `call_once`
|
||||
recursively.]]
|
||||
|
||||
]
|
||||
|
||||
void call_once(void (*func)(),once_flag& flag);
|
||||
|
||||
This second overload is provided for backwards compatibility. The effects of `call_once(func,flag)` shall be the same as those of
|
||||
`call_once(flag,func)`.
|
||||
|
||||
[endsect]
|
||||
[endsect]
|
||||
224
doc/overview.html
Normal file
224
doc/overview.html
Normal file
@@ -0,0 +1,224 @@
|
||||
<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 summary="header" 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 called 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>
|
||||
|
||||
<li><a href="definitions.html#Deadlock">Deadlock</a> (sometimes
|
||||
called "deadly embrace")</li>
|
||||
|
||||
<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>
|
||||
|
||||
<li>Probe effect causes debuggers to produce very different results
|
||||
from non-debug uses.</li>
|
||||
|
||||
<li>Debuggers require special support to show thread state.</li>
|
||||
|
||||
<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>Doing some reading before attempting multi-threaded designs will give
|
||||
you a head start toward 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 -->05 November, 2001<!--webbot bot="Timestamp" endspan i-checksum="39359" --></p>
|
||||
|
||||
<p>© Copyright 2001 Beman Dawes</p>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
@@ -1,30 +0,0 @@
|
||||
[/
|
||||
(C) Copyright 2007-8 Anthony Williams.
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt).
|
||||
]
|
||||
|
||||
[section:overview Overview]
|
||||
|
||||
__boost_thread__ enables the use of multiple threads of execution with shared data in portable C++ code. It provides classes and
|
||||
functions for managing the threads themselves, along with others for synchronizing data between the threads or providing separate
|
||||
copies of data specific to individual threads.
|
||||
|
||||
The __boost_thread__ library was originally written and designed by William E. Kempf. This version is a major rewrite designed to
|
||||
closely follow the proposals presented to the C++ Standards Committee, in particular
|
||||
[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2497.html N2497],
|
||||
[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2320.html N2320],
|
||||
[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2184.html N2184],
|
||||
[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2139.html N2139], and
|
||||
[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2094.html N2094]
|
||||
|
||||
In order to use the classes and functions described here, you can
|
||||
either include the specific headers specified by the descriptions of
|
||||
each class or function, or include the master thread library header:
|
||||
|
||||
#include <boost/thread.hpp>
|
||||
|
||||
which includes all the other headers in turn.
|
||||
|
||||
[endsect]
|
||||
481
doc/rationale.html
Normal file
481
doc/rationale.html
Normal file
@@ -0,0 +1,481 @@
|
||||
<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 summary="header" 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 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 -->05 November, 2001<!--webbot bot="Timestamp" endspan i-checksum="39359" --></p>
|
||||
|
||||
<p><i>© Copyright <a href="mailto:williamkempf@hotmail.com">
|
||||
William E. Kempf</a> 2001 all rights reserved.</i></p>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
368
doc/recursive_mutex.html
Normal file
368
doc/recursive_mutex.html
Normal file
@@ -0,0 +1,368 @@
|
||||
<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 summary="header" 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>
|
||||
|
||||
<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 summary="lock types" 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 -->05 November, 2001<!--webbot bot="Timestamp" endspan i-checksum="39359" --></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 -->05 November, 2001<!--webbot bot="Timestamp" endspan i-checksum="39359" -->
|
||||
</p>
|
||||
|
||||
<p><i>© Copyright <a href="mailto:williamkempf@hotmail.com">William E. Kempf</a>
|
||||
2001 all rights reserved.</i></p>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
227
doc/scoped_lock.html
Normal file
227
doc/scoped_lock.html
Normal file
@@ -0,0 +1,227 @@
|
||||
<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 summary="header" 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 summary="lock effects" 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>
|
||||
|
||||
<p><b>Postcondition:</b> locked()</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>
|
||||
|
||||
<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 -->05 November, 2001<!--webbot bot="Timestamp" endspan i-checksum="39359" --></p>
|
||||
|
||||
<p><i>© Copyright <a href="mailto:williamkempf@hotmail.com">
|
||||
William E. Kempf</a> 2001 all rights reserved.</i></p>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
267
doc/scoped_timed_lock.html
Normal file
267
doc/scoped_timed_lock.html
Normal file
@@ -0,0 +1,267 @@
|
||||
<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 summary="header" 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 summary="lock effects" 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>
|
||||
|
||||
<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 -->November 05, 2001<!--webbot bot="Timestamp" endspan i-checksum="39585" --></p>
|
||||
|
||||
<p><i>© Copyright <a href="mailto:williamkempf@hotmail.com">
|
||||
William E. Kempf</a> 2001 all rights reserved.</i></p>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
305
doc/scoped_try_lock.html
Normal file
305
doc/scoped_try_lock.html
Normal file
@@ -0,0 +1,305 @@
|
||||
<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 summary="header" 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 summary="lock effects" 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 summary="try_lock effects" 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 -->05 November, 2001<!--webbot bot="Timestamp" endspan i-checksum="39359" --></p>
|
||||
|
||||
<p><i>© Copyright <a href="mailto:williamkempf@hotmail.com">
|
||||
William E. Kempf</a> 2001 all rights reserved.</i></p>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
@@ -1,44 +0,0 @@
|
||||
[/
|
||||
(C) Copyright 2007-8 Anthony Williams.
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt).
|
||||
]
|
||||
|
||||
[section:shared_mutex Class `shared_mutex`]
|
||||
|
||||
#include <boost/thread/shared_mutex.hpp>
|
||||
|
||||
class shared_mutex
|
||||
{
|
||||
public:
|
||||
shared_mutex();
|
||||
~shared_mutex();
|
||||
|
||||
void lock_shared();
|
||||
bool try_lock_shared();
|
||||
bool timed_lock_shared(system_time const& timeout);
|
||||
void unlock_shared();
|
||||
|
||||
void lock();
|
||||
bool try_lock();
|
||||
bool timed_lock(system_time const& timeout);
|
||||
void unlock();
|
||||
|
||||
void lock_upgrade();
|
||||
void unlock_upgrade();
|
||||
|
||||
void unlock_upgrade_and_lock();
|
||||
void unlock_and_lock_upgrade();
|
||||
void unlock_and_lock_shared();
|
||||
void unlock_upgrade_and_lock_shared();
|
||||
};
|
||||
|
||||
The class `boost::shared_mutex` provides an implementation of a multiple-reader / single-writer mutex. It implements the
|
||||
__upgrade_lockable_concept__.
|
||||
|
||||
Multiple concurrent calls to __lock_ref__, __try_lock_ref__, __timed_lock_ref__, __lock_shared_ref__, __try_lock_shared_ref__ and
|
||||
__timed_lock_shared_ref__ shall be permitted.
|
||||
|
||||
|
||||
[endsect]
|
||||
4
doc/styles.css
Normal file
4
doc/styles.css
Normal file
@@ -0,0 +1,4 @@
|
||||
PRE
|
||||
{
|
||||
BACKGROUND-COLOR: lightcyan
|
||||
}
|
||||
261
doc/thread.html
Normal file
261
doc/thread.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, 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 summary="header" 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> 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 -->05 November, 2001<!--webbot bot="Timestamp" endspan i-checksum="39359" --></p>
|
||||
|
||||
<p><i>© Copyright <a href="mailto:williamkempf@hotmail.com">
|
||||
William E. Kempf</a> 2001 all rights reserved.</i></p>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
168
doc/thread.qbk
168
doc/thread.qbk
@@ -1,168 +0,0 @@
|
||||
[/
|
||||
(C) Copyright 2007-8 Anthony Williams.
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt).
|
||||
]
|
||||
|
||||
[article Thread
|
||||
[quickbook 1.4]
|
||||
[authors [Williams, Anthony]]
|
||||
[copyright 2007-8 Anthony Williams]
|
||||
[purpose C++ Library for launching threads and synchronizing data between them]
|
||||
[category text]
|
||||
[license
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or copy at
|
||||
[@http://www.boost.org/LICENSE_1_0.txt])
|
||||
]
|
||||
]
|
||||
|
||||
[template lockable_concept_link[link_text] [link thread.synchronization.mutex_concepts.lockable [link_text]]]
|
||||
[def __lockable_concept__ [lockable_concept_link `Lockable` concept]]
|
||||
[def __lockable_concept_type__ [lockable_concept_link `Lockable`]]
|
||||
|
||||
[template timed_lockable_concept_link[link_text] [link thread.synchronization.mutex_concepts.timed_lockable [link_text]]]
|
||||
[def __timed_lockable_concept__ [timed_lockable_concept_link `TimedLockable` concept]]
|
||||
[def __timed_lockable_concept_type__ [timed_lockable_concept_link `TimedLockable`]]
|
||||
|
||||
[template shared_lockable_concept_link[link_text] [link thread.synchronization.mutex_concepts.shared_lockable [link_text]]]
|
||||
[def __shared_lockable_concept__ [shared_lockable_concept_link `SharedLockable` concept]]
|
||||
[def __shared_lockable_concept_type__ [shared_lockable_concept_link `SharedLockable`]]
|
||||
|
||||
[template upgrade_lockable_concept_link[link_text] [link thread.synchronization.mutex_concepts.upgrade_lockable [link_text]]]
|
||||
[def __upgrade_lockable_concept__ [upgrade_lockable_concept_link `UpgradeLockable` concept]]
|
||||
[def __upgrade_lockable_concept_type__ [upgrade_lockable_concept_link `UpgradeLockable`]]
|
||||
|
||||
|
||||
[template lock_ref_link[link_text] [link thread.synchronization.mutex_concepts.lockable.lock [link_text]]]
|
||||
[def __lock_ref__ [lock_ref_link `lock()`]]
|
||||
|
||||
[template lock_multiple_ref_link[link_text] [link thread.synchronization.lock_functions.lock_multiple [link_text]]]
|
||||
[def __lock_multiple_ref__ [lock_multiple_ref_link `lock()`]]
|
||||
|
||||
[template try_lock_multiple_ref_link[link_text] [link thread.synchronization.lock_functions.try_lock_multiple [link_text]]]
|
||||
[def __try_lock_multiple_ref__ [try_lock_multiple_ref_link `try_lock()`]]
|
||||
|
||||
[template unlock_ref_link[link_text] [link thread.synchronization.mutex_concepts.lockable.unlock [link_text]]]
|
||||
[def __unlock_ref__ [unlock_ref_link `unlock()`]]
|
||||
|
||||
[template try_lock_ref_link[link_text] [link thread.synchronization.mutex_concepts.lockable.try_lock [link_text]]]
|
||||
[def __try_lock_ref__ [try_lock_ref_link `try_lock()`]]
|
||||
|
||||
[template timed_lock_ref_link[link_text] [link thread.synchronization.mutex_concepts.timed_lockable.timed_lock [link_text]]]
|
||||
[def __timed_lock_ref__ [timed_lock_ref_link `timed_lock()`]]
|
||||
|
||||
[template timed_lock_duration_ref_link[link_text] [link thread.synchronization.mutex_concepts.timed_lockable.timed_lock_duration [link_text]]]
|
||||
[def __timed_lock_duration_ref__ [timed_lock_duration_ref_link `timed_lock()`]]
|
||||
|
||||
[template lock_shared_ref_link[link_text] [link thread.synchronization.mutex_concepts.shared_lockable.lock_shared [link_text]]]
|
||||
[def __lock_shared_ref__ [lock_shared_ref_link `lock_shared()`]]
|
||||
|
||||
[template unlock_shared_ref_link[link_text] [link thread.synchronization.mutex_concepts.shared_lockable.unlock_shared [link_text]]]
|
||||
[def __unlock_shared_ref__ [unlock_shared_ref_link `unlock_shared()`]]
|
||||
|
||||
[template try_lock_shared_ref_link[link_text] [link thread.synchronization.mutex_concepts.shared_lockable.try_lock_shared [link_text]]]
|
||||
[def __try_lock_shared_ref__ [try_lock_shared_ref_link `try_lock_shared()`]]
|
||||
|
||||
[template timed_lock_shared_ref_link[link_text] [link thread.synchronization.mutex_concepts.shared_lockable.timed_lock_shared [link_text]]]
|
||||
[def __timed_lock_shared_ref__ [timed_lock_shared_ref_link `timed_lock_shared()`]]
|
||||
|
||||
[template timed_lock_shared_duration_ref_link[link_text] [link thread.synchronization.mutex_concepts.shared_lockable.timed_lock_shared_duration [link_text]]]
|
||||
[def __timed_lock_shared_duration_ref__ [timed_lock_shared_duration_ref_link `timed_lock_shared()`]]
|
||||
|
||||
[template lock_upgrade_ref_link[link_text] [link thread.synchronization.mutex_concepts.upgrade_lockable.lock_upgrade [link_text]]]
|
||||
[def __lock_upgrade_ref__ [lock_upgrade_ref_link `lock_upgrade()`]]
|
||||
|
||||
[template unlock_upgrade_ref_link[link_text] [link thread.synchronization.mutex_concepts.upgrade_lockable.unlock_upgrade [link_text]]]
|
||||
[def __unlock_upgrade_ref__ [unlock_upgrade_ref_link `unlock_upgrade()`]]
|
||||
|
||||
[template unlock_upgrade_and_lock_ref_link[link_text] [link thread.synchronization.mutex_concepts.upgrade_lockable.unlock_upgrade_and_lock [link_text]]]
|
||||
[def __unlock_upgrade_and_lock_ref__ [unlock_upgrade_and_lock_ref_link `unlock_upgrade_and_lock()`]]
|
||||
|
||||
[template unlock_and_lock_upgrade_ref_link[link_text] [link thread.synchronization.mutex_concepts.upgrade_lockable.unlock_and_lock_upgrade [link_text]]]
|
||||
[def __unlock_and_lock_upgrade_ref__ [unlock_and_lock_upgrade_ref_link `unlock_and_lock_upgrade()`]]
|
||||
|
||||
[template unlock_upgrade_and_lock_shared_ref_link[link_text] [link thread.synchronization.mutex_concepts.upgrade_lockable.unlock_upgrade_and_lock_shared [link_text]]]
|
||||
[def __unlock_upgrade_and_lock_shared_ref__ [unlock_upgrade_and_lock_shared_ref_link `unlock_upgrade_and_lock_shared()`]]
|
||||
|
||||
[template owns_lock_ref_link[link_text] [link thread.synchronization.locks.unique_lock.owns_lock [link_text]]]
|
||||
[def __owns_lock_ref__ [owns_lock_ref_link `owns_lock()`]]
|
||||
|
||||
[template owns_lock_shared_ref_link[link_text] [link thread.synchronization.locks.shared_lock.owns_lock [link_text]]]
|
||||
[def __owns_lock_shared_ref__ [owns_lock_shared_ref_link `owns_lock()`]]
|
||||
|
||||
[template mutex_func_ref_link[link_text] [link thread.synchronization.locks.unique_lock.mutex [link_text]]]
|
||||
[def __mutex_func_ref__ [mutex_func_ref_link `mutex()`]]
|
||||
|
||||
[def __boost_thread__ [*Boost.Thread]]
|
||||
[def __not_a_thread__ ['Not-a-Thread]]
|
||||
[def __interruption_points__ [link interruption_points ['interruption points]]]
|
||||
|
||||
[def __mutex__ [link thread.synchronization.mutex_types.mutex `boost::mutex`]]
|
||||
[def __try_mutex__ [link thread.synchronization.mutex_types.try_mutex `boost::try_mutex`]]
|
||||
[def __timed_mutex__ [link thread.synchronization.mutex_types.timed_mutex `boost::timed_mutex`]]
|
||||
[def __recursive_mutex__ [link thread.synchronization.mutex_types.recursive_mutex `boost::recursive_mutex`]]
|
||||
[def __recursive_try_mutex__ [link thread.synchronization.mutex_types.recursive_try_mutex `boost::recursive_try_mutex`]]
|
||||
[def __recursive_timed_mutex__ [link thread.synchronization.mutex_types.recursive_timed_mutex `boost::recursive_timed_mutex`]]
|
||||
[def __shared_mutex__ [link thread.synchronization.mutex_types.shared_mutex `boost::shared_mutex`]]
|
||||
|
||||
[template unique_lock_link[link_text] [link thread.synchronization.locks.unique_lock [link_text]]]
|
||||
|
||||
[def __lock_guard__ [link thread.synchronization.locks.lock_guard `boost::lock_guard`]]
|
||||
[def __unique_lock__ [unique_lock_link `boost::unique_lock`]]
|
||||
[def __shared_lock__ [link thread.synchronization.locks.shared_lock `boost::shared_lock`]]
|
||||
[def __upgrade_lock__ [link thread.synchronization.locks.upgrade_lock `boost::upgrade_lock`]]
|
||||
[def __upgrade_to_unique_lock__ [link thread.synchronization.locks.upgrade_to_unique_lock `boost::upgrade_to_unique_lock`]]
|
||||
|
||||
|
||||
[def __thread__ [link thread.thread_management.thread `boost::thread`]]
|
||||
[def __thread_id__ [link thread.thread_management.thread.id `boost::thread::id`]]
|
||||
[template join_link[link_text] [link thread.thread_management.thread.join [link_text]]]
|
||||
[def __join__ [join_link `join()`]]
|
||||
[template timed_join_link[link_text] [link thread.thread_management.thread.timed_join [link_text]]]
|
||||
[def __timed_join__ [timed_join_link `timed_join()`]]
|
||||
[def __detach__ [link thread.thread_management.thread.detach `detach()`]]
|
||||
[def __interrupt__ [link thread.thread_management.thread.interrupt `interrupt()`]]
|
||||
[def __sleep__ [link thread.thread_management.this_thread.sleep `boost::this_thread::sleep()`]]
|
||||
|
||||
[def __interruption_enabled__ [link thread.thread_management.this_thread.interruption_enabled `boost::this_thread::interruption_enabled()`]]
|
||||
[def __interruption_requested__ [link thread.thread_management.this_thread.interruption_requested `boost::this_thread::interruption_requested()`]]
|
||||
[def __interruption_point__ [link thread.thread_management.this_thread.interruption_point `boost::this_thread::interruption_point()`]]
|
||||
[def __disable_interruption__ [link thread.thread_management.this_thread.disable_interruption `boost::this_thread::disable_interruption`]]
|
||||
[def __restore_interruption__ [link thread.thread_management.this_thread.restore_interruption `boost::this_thread::restore_interruption`]]
|
||||
|
||||
[def __thread_resource_error__ `boost::thread_resource_error`]
|
||||
[def __thread_interrupted__ `boost::thread_interrupted`]
|
||||
[def __barrier__ [link thread.synchronization.barriers.barrier `boost::barrier`]]
|
||||
|
||||
[template cond_wait_link[link_text] [link thread.synchronization.condvar_ref.condition_variable.wait [link_text]]]
|
||||
[def __cond_wait__ [cond_wait_link `wait()`]]
|
||||
[template cond_timed_wait_link[link_text] [link thread.synchronization.condvar_ref.condition_variable.timed_wait [link_text]]]
|
||||
[def __cond_timed_wait__ [cond_timed_wait_link `timed_wait()`]]
|
||||
[template cond_any_wait_link[link_text] [link thread.synchronization.condvar_ref.condition_variable_any.wait [link_text]]]
|
||||
[def __cond_any_wait__ [cond_any_wait_link `wait()`]]
|
||||
[template cond_any_timed_wait_link[link_text] [link thread.synchronization.condvar_ref.condition_variable_any.timed_wait [link_text]]]
|
||||
[def __cond_any_timed_wait__ [cond_any_timed_wait_link `timed_wait()`]]
|
||||
|
||||
[def __blocked__ ['blocked]]
|
||||
|
||||
[include overview.qbk]
|
||||
[include changes.qbk]
|
||||
|
||||
[include thread_ref.qbk]
|
||||
|
||||
[section:synchronization Synchronization]
|
||||
[include mutex_concepts.qbk]
|
||||
[include mutexes.qbk]
|
||||
[include condition_variables.qbk]
|
||||
[include once.qbk]
|
||||
[include barrier.qbk]
|
||||
[include futures.qbk]
|
||||
[endsect]
|
||||
|
||||
[include tss.qbk]
|
||||
|
||||
[include time.qbk]
|
||||
|
||||
[include acknowledgements.qbk]
|
||||
182
doc/thread_group.html
Normal file
182
doc/thread_group.html
Normal file
@@ -0,0 +1,182 @@
|
||||
<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 summary="header" 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 -->05 November, 2001<!--webbot bot="Timestamp" endspan i-checksum="39359" --></p>
|
||||
|
||||
<p><i>© Copyright <a href="mailto:williamkempf@hotmail.com">
|
||||
William E. Kempf</a> 2001 all rights reserved.</i></p>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
1129
doc/thread_ref.qbk
1129
doc/thread_ref.qbk
File diff suppressed because it is too large
Load Diff
78
doc/thread_resource_error.html
Normal file
78
doc/thread_resource_error.html
Normal file
@@ -0,0 +1,78 @@
|
||||
<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 summary="header" 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 -->05 November, 2001<!--webbot bot="Timestamp" endspan i-checksum="39359" --></p>
|
||||
|
||||
<p><i>© Copyright <a href="mailto:williamkempf@hotmail.com">
|
||||
William E. Kempf</a> 2001 all rights reserved.</i></p>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
223
doc/thread_specific_ptr.html
Normal file
223
doc/thread_specific_ptr.html
Normal file
@@ -0,0 +1,223 @@
|
||||
<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 summary="header" 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 -->05 November, 2001<!--webbot bot="Timestamp" endspan i-checksum="39359" --></p>
|
||||
|
||||
<p><i>© Copyright <a href="mailto:williamkempf@hotmail.com">
|
||||
William E. Kempf</a> 2001 all rights reserved.</i></p>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
75
doc/time.qbk
75
doc/time.qbk
@@ -1,75 +0,0 @@
|
||||
[/
|
||||
(C) Copyright 2007-8 Anthony Williams.
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt).
|
||||
]
|
||||
|
||||
[section:time Date and Time Requirements]
|
||||
|
||||
As of Boost 1.35.0, the __boost_thread__ library uses the [link date_time Boost.Date_Time] library for all operations that require a
|
||||
time out. These include (but are not limited to):
|
||||
|
||||
* __sleep__
|
||||
* __timed_join__
|
||||
* __cond_timed_wait__
|
||||
* __timed_lock_ref__
|
||||
|
||||
For the overloads that accept an absolute time parameter, an object of type [link thread.time.system_time `boost::system_time`] is
|
||||
required. Typically, this will be obtained by adding a duration to the current time, obtained with a call to [link
|
||||
thread.time.get_system_time `boost::get_system_time()`]. e.g.
|
||||
|
||||
boost::system_time const timeout=boost::get_system_time() + boost::posix_time::milliseconds(500);
|
||||
|
||||
extern bool done;
|
||||
extern boost::mutex m;
|
||||
extern boost::condition_variable cond;
|
||||
|
||||
boost::unique_lock<boost::mutex> lk(m);
|
||||
while(!done)
|
||||
{
|
||||
if(!cond.timed_wait(lk,timeout))
|
||||
{
|
||||
throw "timed out";
|
||||
}
|
||||
}
|
||||
|
||||
For the overloads that accept a ['TimeDuration] parameter, an object of any type that meets the [link
|
||||
date_time.posix_time.time_duration Boost.Date_Time Time Duration requirements] can be used, e.g.
|
||||
|
||||
boost::this_thread::sleep(boost::posix_time::milliseconds(25));
|
||||
|
||||
boost::mutex m;
|
||||
if(m.timed_lock(boost::posix_time::nanoseconds(100)))
|
||||
{
|
||||
// ...
|
||||
}
|
||||
|
||||
[section:system_time Typedef `system_time`]
|
||||
|
||||
#include <boost/thread/thread_time.hpp>
|
||||
|
||||
typedef boost::posix_time::ptime system_time;
|
||||
|
||||
See the documentation for [link date_time.posix_time.ptime_class `boost::posix_time::ptime`] in the Boost.Date_Time library.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:get_system_time Non-member function `get_system_time()`]
|
||||
|
||||
#include <boost/thread/thread_time.hpp>
|
||||
|
||||
system_time get_system_time();
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Returns:] [The current time.]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
|
||||
[endsect]
|
||||
184
doc/tss.qbk
184
doc/tss.qbk
@@ -1,184 +0,0 @@
|
||||
[/
|
||||
(C) Copyright 2007-8 Anthony Williams.
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt).
|
||||
]
|
||||
|
||||
[section Thread Local Storage]
|
||||
|
||||
[heading Synopsis]
|
||||
|
||||
Thread local storage allows multi-threaded applications to have a separate instance of a given data item for each thread. Where a
|
||||
single-threaded application would use static or global data, this could lead to contention, deadlock or data corruption in a
|
||||
multi-threaded application. One example is the C `errno` variable, used for storing the error code related to functions from the
|
||||
Standard C library. It is common practice (and required by POSIX) for compilers that support multi-threaded applications to provide
|
||||
a separate instance of `errno` for each thread, in order to avoid different threads competing to read or update the value.
|
||||
|
||||
Though compilers often provide this facility in the form of extensions to the declaration syntax (such as `__declspec(thread)` or
|
||||
`__thread` annotations on `static` or namespace-scope variable declarations), such support is non-portable, and is often limited in
|
||||
some way, such as only supporting POD types.
|
||||
|
||||
[heading Portable thread-local storage with `boost::thread_specific_ptr`]
|
||||
|
||||
`boost::thread_specific_ptr` provides a portable mechanism for thread-local storage that works on all compilers supported by
|
||||
__boost_thread__. Each instance of `boost::thread_specific_ptr` represents a pointer to an object (such as `errno`) where each
|
||||
thread must have a distinct value. The value for the current thread can be obtained using the `get()` member function, or by using
|
||||
the `*` and `->` pointer deference operators. Initially the pointer has a value of `NULL` in each thread, but the value for the
|
||||
current thread can be set using the `reset()` member function.
|
||||
|
||||
If the value of the pointer for the current thread is changed using `reset()`, then the previous value is destroyed by calling the
|
||||
cleanup routine. Alternatively, the stored value can be reset to `NULL` and the prior value returned by calling the `release()`
|
||||
member function, allowing the application to take back responsibility for destroying the object.
|
||||
|
||||
[heading Cleanup at thread exit]
|
||||
|
||||
When a thread exits, the objects associated with each `boost::thread_specific_ptr` instance are destroyed. By default, the object
|
||||
pointed to by a pointer `p` is destroyed by invoking `delete p`, but this can be overridden for a specific instance of
|
||||
`boost::thread_specific_ptr` by providing a cleanup routine to the constructor. In this case, the object is destroyed by invoking
|
||||
`func(p)` where `func` is the cleanup routine supplied to the constructor. The cleanup functions are called in an unspecified
|
||||
order. If a cleanup routine sets the value of associated with an instance of `boost::thread_specific_ptr` that has already been
|
||||
cleaned up, that value is added to the cleanup list. Cleanup finishes when there are no outstanding instances of
|
||||
`boost::thread_specific_ptr` with values.
|
||||
|
||||
|
||||
[section:thread_specific_ptr Class `thread_specific_ptr`]
|
||||
|
||||
#include <boost/thread/tss.hpp>
|
||||
|
||||
template <typename T>
|
||||
class thread_specific_ptr
|
||||
{
|
||||
public:
|
||||
thread_specific_ptr();
|
||||
explicit thread_specific_ptr(void (*cleanup_function)(T*));
|
||||
~thread_specific_ptr();
|
||||
|
||||
T* get() const;
|
||||
T* operator->() const;
|
||||
T& operator*() const;
|
||||
|
||||
T* release();
|
||||
void reset(T* new_value=0);
|
||||
};
|
||||
|
||||
[section:default_constructor `thread_specific_ptr();`]
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Requires:] [`delete this->get()` is well-formed.]]
|
||||
|
||||
[[Effects:] [Construct a `thread_specific_ptr` object for storing a pointer to an object of type `T` specific to each thread. The
|
||||
default `delete`-based cleanup function will be used to destroy any thread-local objects when `reset()` is called, or the thread
|
||||
exits.]]
|
||||
|
||||
[[Throws:] [`boost::thread_resource_error` if an error occurs.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:constructor_with_custom_cleanup `explicit thread_specific_ptr(void (*cleanup_function)(T*));`]
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Requires:] [`cleanup_function(this->get())` does not throw any exceptions.]]
|
||||
|
||||
[[Effects:] [Construct a `thread_specific_ptr` object for storing a pointer to an object of type `T` specific to each thread. The
|
||||
supplied `cleanup_function` will be used to destroy any thread-local objects when `reset()` is called, or the thread exits.]]
|
||||
|
||||
[[Throws:] [`boost::thread_resource_error` if an error occurs.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:destructor `~thread_specific_ptr();`]
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Calls `this->reset()` to clean up the associated value for the current thread, and destroys `*this`.]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
]
|
||||
|
||||
[note Care needs to be taken to ensure that any threads still running after an instance of `boost::thread_specific_ptr` has been
|
||||
destroyed do not call any member functions on that instance.]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:get `T* get() const;`]
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Returns:] [The pointer associated with the current thread.]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
]
|
||||
|
||||
[note The initial value associated with an instance of `boost::thread_specific_ptr` is `NULL` for each thread.]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:operator_arrow `T* operator->() const;`]
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Returns:] [`this->get()`]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:operator_star `T& operator*() const;`]
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Requires:] [`this->get` is not `NULL`.]]
|
||||
|
||||
[[Returns:] [`*(this->get())`]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:reset `void reset(T* new_value=0);`]
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [If `this->get()!=new_value` and `this->get()` is non-`NULL`, invoke `delete this->get()` or
|
||||
`cleanup_function(this->get())` as appropriate. Store `new_value` as the pointer associated with the current thread.]]
|
||||
|
||||
[[Postcondition:] [`this->get()==new_value`]]
|
||||
|
||||
[[Throws:] [`boost::thread_resource_error` if an error occurs.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:release `T* release();`]
|
||||
|
||||
[variablelist
|
||||
|
||||
[[Effects:] [Return `this->get()` and store `NULL` as the pointer associated with the current thread without invoking the cleanup
|
||||
function.]]
|
||||
|
||||
[[Postcondition:] [`this->get()==0`]]
|
||||
|
||||
[[Throws:] [Nothing.]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
147
doc/xtime.html
Normal file
147
doc/xtime.html
Normal file
@@ -0,0 +1,147 @@
|
||||
<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 summary="header" 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></p>
|
||||
<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>
|
||||
|
||||
<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 -->05 November, 2001<!--webbot bot="Timestamp" endspan i-checksum="39359" --></p>
|
||||
|
||||
<p><i>© Copyright <a href="mailto:williamkempf@hotmail.com">
|
||||
William E. Kempf</a> 2001 all rights reserved.</i></p>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
66
example/Jamfile
Normal file
66
example/Jamfile
Normal file
@@ -0,0 +1,66 @@
|
||||
# (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. monitor, an example program.
|
||||
# 2. starvephil, an example program.
|
||||
# 3. tennis, an example program.
|
||||
|
||||
# declare the location of this subproject relative to the root
|
||||
subproject libs/thread/example ;
|
||||
|
||||
# Do some OS-specific setup
|
||||
if $(NT)
|
||||
{
|
||||
BOOST_THREADMON_LIB = <lib>../build/libboost_threadmon ;
|
||||
}
|
||||
else
|
||||
{
|
||||
BOOST_THREADMON_LIB = ;
|
||||
}
|
||||
|
||||
#######################
|
||||
|
||||
#
|
||||
# Declare the Boost.Threads monitor example program.
|
||||
#
|
||||
|
||||
exe monitor : monitor/monitor.cpp
|
||||
<lib>../build/libboost_thread
|
||||
$(BOOST_THREADMON_LIB)
|
||||
# requirements
|
||||
: <include>$(BOOST_ROOT)
|
||||
<threading>multi
|
||||
: debug release ;
|
||||
|
||||
#######################
|
||||
|
||||
#
|
||||
# Declare the Boost.Threads starvephil example program.
|
||||
#
|
||||
|
||||
exe starvephil : starvephil/starvephil.cpp
|
||||
<lib>../build/libboost_thread
|
||||
$(BOOST_THREADMON_LIB)
|
||||
# requirements
|
||||
: <include>$(BOOST_ROOT)
|
||||
<threading>multi
|
||||
: debug release ;
|
||||
|
||||
#######################
|
||||
|
||||
#
|
||||
# Declare the Boost.Threads tennis example program.
|
||||
#
|
||||
|
||||
exe tennis : tennis/tennis.cpp
|
||||
<lib>../build/libboost_thread
|
||||
$(BOOST_THREADMON_LIB)
|
||||
# requirements
|
||||
: <include>$(BOOST_ROOT)
|
||||
<threading>multi
|
||||
: debug release ;
|
||||
@@ -1,23 +0,0 @@
|
||||
# Copyright (C) 2001-2003
|
||||
# William E. Kempf
|
||||
#
|
||||
# Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
project boost/thread/example
|
||||
: requirements <library>../build//boost_thread <threading>multi
|
||||
;
|
||||
|
||||
|
||||
exe monitor : monitor.cpp ;
|
||||
exe starvephil : starvephil.cpp ;
|
||||
exe tennis : tennis.cpp ;
|
||||
exe condition : condition.cpp ;
|
||||
exe mutex : mutex.cpp ;
|
||||
exe once : once.cpp ;
|
||||
exe recursive_mutex : recursive_mutex.cpp ;
|
||||
exe thread : thread.cpp ;
|
||||
exe thread_group : thread_group.cpp ;
|
||||
exe tss : tss.cpp ;
|
||||
exe xtime : xtime.cpp ;
|
||||
|
||||
@@ -1,89 +0,0 @@
|
||||
// Copyright (C) 2001-2003
|
||||
// William E. Kempf
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
#include <boost/utility.hpp>
|
||||
#include <boost/thread/condition.hpp>
|
||||
#include <boost/thread/thread.hpp>
|
||||
|
||||
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);
|
||||
|
||||
boost::mutex io_mutex;
|
||||
|
||||
void sender() {
|
||||
int n = 0;
|
||||
while (n < 1000000) {
|
||||
buf.send(n);
|
||||
if(!(n%10000))
|
||||
{
|
||||
boost::mutex::scoped_lock io_lock(io_mutex);
|
||||
std::cout << "sent: " << n << std::endl;
|
||||
}
|
||||
++n;
|
||||
}
|
||||
buf.send(-1);
|
||||
}
|
||||
|
||||
void receiver() {
|
||||
int n;
|
||||
do {
|
||||
n = buf.receive();
|
||||
if(!(n%10000))
|
||||
{
|
||||
boost::mutex::scoped_lock io_lock(io_mutex);
|
||||
std::cout << "received: " << n << std::endl;
|
||||
}
|
||||
} while (n != -1); // -1 indicates end of buffer
|
||||
buf.send(-1);
|
||||
}
|
||||
|
||||
int main(int, char*[])
|
||||
{
|
||||
boost::thread thrd1(&sender);
|
||||
boost::thread thrd2(&receiver);
|
||||
boost::thread thrd3(&receiver);
|
||||
boost::thread thrd4(&receiver);
|
||||
thrd1.join();
|
||||
thrd2.join();
|
||||
thrd3.join();
|
||||
thrd4.join();
|
||||
return 0;
|
||||
}
|
||||
@@ -1,9 +1,3 @@
|
||||
// Copyright (C) 2001-2003
|
||||
// William E. Kempf
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <vector>
|
||||
#include <iostream>
|
||||
#include <boost/thread/condition.hpp>
|
||||
@@ -12,21 +6,21 @@
|
||||
#include <boost/thread/thread.hpp>
|
||||
|
||||
namespace {
|
||||
const int ITERS = 100;
|
||||
boost::mutex io_mutex;
|
||||
} // 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);
|
||||
@@ -35,7 +29,7 @@ public:
|
||||
buf[p] = m;
|
||||
p = (p+1) % buf.size();
|
||||
++full;
|
||||
cond.notify_one();
|
||||
cond.notify_all();
|
||||
}
|
||||
int receive()
|
||||
{
|
||||
@@ -45,40 +39,41 @@ public:
|
||||
int i = buf[c];
|
||||
c = (c+1) % buf.size();
|
||||
--full;
|
||||
cond.notify_one();
|
||||
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 << "sending: " << n << std::endl;
|
||||
std::cout << "sent: " << n << std::endl;
|
||||
}
|
||||
get_buffer().send(n);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void do_receiver_thread()
|
||||
{
|
||||
for (int x=0; x < (ITERS/2); ++x)
|
||||
int n;
|
||||
do
|
||||
{
|
||||
int n = get_buffer().receive();
|
||||
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;
|
||||
@@ -91,12 +86,10 @@ void do_test(M* dummy=0)
|
||||
{
|
||||
typedef buffer_t<M> buffer_type;
|
||||
buffer_type::get_buffer();
|
||||
boost::thread thrd1(&buffer_type::do_receiver_thread);
|
||||
boost::thread thrd1(&buffer_type::do_sender_thread);
|
||||
boost::thread thrd2(&buffer_type::do_receiver_thread);
|
||||
boost::thread thrd3(&buffer_type::do_sender_thread);
|
||||
thrd1.join();
|
||||
thrd2.join();
|
||||
thrd3.join();
|
||||
}
|
||||
|
||||
void test_buffer()
|
||||
@@ -1,47 +0,0 @@
|
||||
// Copyright (C) 2001-2003
|
||||
// William E. Kempf
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/thread/mutex.hpp>
|
||||
#include <boost/thread/thread.hpp>
|
||||
#include <iostream>
|
||||
|
||||
boost::mutex io_mutex; // The iostreams are not guaranteed to be thread-safe!
|
||||
|
||||
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()
|
||||
{
|
||||
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);
|
||||
|
||||
thrds.join_all();
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,31 +0,0 @@
|
||||
// Copyright (C) 2001-2003
|
||||
// William E. Kempf
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/thread/thread.hpp>
|
||||
#include <boost/thread/once.hpp>
|
||||
#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);
|
||||
}
|
||||
@@ -1,49 +0,0 @@
|
||||
// Copyright (C) 2001-2003
|
||||
// William E. Kempf
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/thread/recursive_mutex.hpp>
|
||||
#include <boost/thread/thread.hpp>
|
||||
#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()
|
||||
{
|
||||
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);
|
||||
|
||||
threads.join_all();
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,185 +0,0 @@
|
||||
// Copyright (C) 2001-2003
|
||||
// William E. Kempf
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#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;
|
||||
} // namespace
|
||||
|
||||
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;
|
||||
}
|
||||
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;
|
||||
}
|
||||
@@ -1,9 +1,3 @@
|
||||
// Copyright (C) 2001-2003
|
||||
// William E. Kempf
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/thread/mutex.hpp>
|
||||
#include <boost/thread/condition.hpp>
|
||||
#include <boost/thread/thread.hpp>
|
||||
@@ -11,8 +5,8 @@
|
||||
#include <iostream>
|
||||
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
# include <windows.h>
|
||||
# include <process.h>
|
||||
# include <windows.h>
|
||||
# include <process.h>
|
||||
#endif
|
||||
|
||||
enum game_state
|
||||
@@ -55,10 +49,7 @@ void player(void* param)
|
||||
{
|
||||
cond.wait(lock);
|
||||
if (state == other)
|
||||
{
|
||||
std::cout << "---" << player_name(active)
|
||||
<< ": Spurious wakeup!" << std::endl;
|
||||
}
|
||||
std::cout << "---" << player_name(active) << ": Spurious wakeup!" << std::endl;
|
||||
} while (state == other);
|
||||
}
|
||||
|
||||
@@ -69,10 +60,7 @@ void player(void* param)
|
||||
|
||||
struct thread_adapt
|
||||
{
|
||||
thread_adapt(void (*func)(void*), void* param)
|
||||
: _func(func), _param(param)
|
||||
{
|
||||
}
|
||||
thread_adapt(void (*func)(void*), void* param) : _func(func), _param(param) { }
|
||||
int operator()() const
|
||||
{
|
||||
_func(_param);
|
||||
@@ -86,10 +74,7 @@ struct thread_adapt
|
||||
class thread_adapter
|
||||
{
|
||||
public:
|
||||
thread_adapter(void (*func)(void*), void* param)
|
||||
: _func(func), _param(param)
|
||||
{
|
||||
}
|
||||
thread_adapter(void (*func)(void*), void* param) : _func(func), _param(param) { }
|
||||
void operator()() const { _func(_param); }
|
||||
private:
|
||||
void (*_func)(void*);
|
||||
@@ -112,7 +97,7 @@ int main(int argc, char* argv[])
|
||||
std::cout << "---Noise ON..." << std::endl;
|
||||
}
|
||||
|
||||
for (int i = 0; i < 1000000000; ++i)
|
||||
for (int i = 0; i < 1000000; ++i)
|
||||
cond.notify_all();
|
||||
|
||||
{
|
||||
@@ -1,35 +0,0 @@
|
||||
// Copyright (C) 2001-2003
|
||||
// William E. Kempf
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/thread/thread.hpp>
|
||||
#include <boost/thread/xtime.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;
|
||||
thread_alarm alarm(secs);
|
||||
boost::thread thrd(alarm);
|
||||
thrd.join();
|
||||
}
|
||||
@@ -1,25 +0,0 @@
|
||||
// Copyright (C) 2001-2003
|
||||
// William E. Kempf
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/thread/thread.hpp>
|
||||
#include <iostream>
|
||||
|
||||
int count = 0;
|
||||
boost::mutex mutex;
|
||||
|
||||
void increment_count()
|
||||
{
|
||||
boost::mutex::scoped_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();
|
||||
}
|
||||
@@ -1,36 +0,0 @@
|
||||
// Copyright (C) 2001-2003
|
||||
// William E. Kempf
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/thread/thread.hpp>
|
||||
#include <boost/thread/tss.hpp>
|
||||
#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();
|
||||
}
|
||||
@@ -1,16 +0,0 @@
|
||||
// Copyright (C) 2001-2003
|
||||
// William E. Kempf
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/thread/thread.hpp>
|
||||
#include <boost/thread/xtime.hpp>
|
||||
|
||||
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
|
||||
}
|
||||
@@ -1,26 +0,0 @@
|
||||
// Copyright (C) 2001-2003
|
||||
// William E. Kempf
|
||||
// (C) Copyright 2008-9 Anthony Williams
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See www.boost.org/libs/thread for documentation.
|
||||
|
||||
#if !defined(BOOST_THREAD_WEK01082003_HPP)
|
||||
#define BOOST_THREAD_WEK01082003_HPP
|
||||
|
||||
#include <boost/thread/thread.hpp>
|
||||
#include <boost/thread/condition_variable.hpp>
|
||||
#include <boost/thread/exceptions.hpp>
|
||||
#include <boost/thread/mutex.hpp>
|
||||
#include <boost/thread/once.hpp>
|
||||
#include <boost/thread/recursive_mutex.hpp>
|
||||
#include <boost/thread/tss.hpp>
|
||||
#include <boost/thread/thread_time.hpp>
|
||||
#include <boost/thread/locks.hpp>
|
||||
#include <boost/thread/shared_mutex.hpp>
|
||||
#include <boost/thread/barrier.hpp>
|
||||
#include <boost/thread/future.hpp>
|
||||
|
||||
#endif
|
||||
@@ -1,64 +0,0 @@
|
||||
// Copyright (C) 2002-2003
|
||||
// David Moore, William E. Kempf
|
||||
// Copyright (C) 2007-8 Anthony Williams
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_BARRIER_JDM030602_HPP
|
||||
#define BOOST_BARRIER_JDM030602_HPP
|
||||
|
||||
#include <boost/thread/detail/config.hpp>
|
||||
#include <boost/throw_exception.hpp>
|
||||
|
||||
#include <boost/thread/mutex.hpp>
|
||||
#include <boost/thread/condition_variable.hpp>
|
||||
#include <string>
|
||||
#include <stdexcept>
|
||||
|
||||
#include <boost/config/abi_prefix.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
|
||||
class barrier
|
||||
{
|
||||
public:
|
||||
barrier(unsigned int count)
|
||||
: m_threshold(count), m_count(count), m_generation(0)
|
||||
{
|
||||
if (count == 0)
|
||||
boost::throw_exception(std::invalid_argument("count cannot be zero."));
|
||||
}
|
||||
|
||||
bool wait()
|
||||
{
|
||||
boost::mutex::scoped_lock lock(m_mutex);
|
||||
unsigned int gen = m_generation;
|
||||
|
||||
if (--m_count == 0)
|
||||
{
|
||||
m_generation++;
|
||||
m_count = m_threshold;
|
||||
m_cond.notify_all();
|
||||
return true;
|
||||
}
|
||||
|
||||
while (gen == m_generation)
|
||||
m_cond.wait(lock);
|
||||
return false;
|
||||
}
|
||||
|
||||
private:
|
||||
mutex m_mutex;
|
||||
condition_variable m_cond;
|
||||
unsigned int m_threshold;
|
||||
unsigned int m_count;
|
||||
unsigned int m_generation;
|
||||
};
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#include <boost/config/abi_suffix.hpp>
|
||||
|
||||
#endif
|
||||
@@ -1,16 +1,159 @@
|
||||
#ifndef BOOST_THREAD_CONDITION_HPP
|
||||
#define BOOST_THREAD_CONDITION_HPP
|
||||
// (C) Copyright 2007 Anthony Williams
|
||||
// Copyright (C) 2001
|
||||
// William E. Kempf
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// 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_variable.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
typedef condition_variable_any condition;
|
||||
}
|
||||
#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>
|
||||
#include <boost/thread/detail/lock.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
|
||||
|
||||
typedef typename detail::thread::lock_ops<M> lock_ops;
|
||||
lock_ops::lock_state state;
|
||||
lock_ops::unlock(mutex, state);
|
||||
|
||||
#if defined(BOOST_HAS_PTHREADS)
|
||||
do_wait(state.pmutex);
|
||||
#elif defined(BOOST_HAS_WINTHREADS)
|
||||
do_wait();
|
||||
#endif
|
||||
|
||||
lock_ops::lock(mutex, state);
|
||||
}
|
||||
|
||||
template <typename M>
|
||||
bool do_timed_wait(M& mutex, const xtime& xt)
|
||||
{
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
enter_wait();
|
||||
#endif
|
||||
|
||||
typedef typename detail::thread::lock_ops<M> lock_ops;
|
||||
lock_ops::lock_state state;
|
||||
lock_ops::unlock(mutex, 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
|
||||
|
||||
lock_ops::lock(mutex, 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)
|
||||
void* m_gate;
|
||||
void* m_queue;
|
||||
void* 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
|
||||
|
||||
@@ -1,21 +0,0 @@
|
||||
#ifndef BOOST_THREAD_CONDITION_VARIABLE_HPP
|
||||
#define BOOST_THREAD_CONDITION_VARIABLE_HPP
|
||||
|
||||
// condition_variable.hpp
|
||||
//
|
||||
// (C) Copyright 2007 Anthony Williams
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/thread/detail/platform.hpp>
|
||||
#if defined(BOOST_THREAD_PLATFORM_WIN32)
|
||||
#include <boost/thread/win32/condition_variable.hpp>
|
||||
#elif defined(BOOST_THREAD_PLATFORM_PTHREAD)
|
||||
#include <boost/thread/pthread/condition_variable.hpp>
|
||||
#else
|
||||
#error "Boost threads unavailable on this platform"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
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
|
||||
@@ -1,100 +0,0 @@
|
||||
// Copyright (C) 2001-2003
|
||||
// William E. Kempf
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_THREAD_CONFIG_WEK01032003_HPP
|
||||
#define BOOST_THREAD_CONFIG_WEK01032003_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
#if BOOST_WORKAROUND(__BORLANDC__, < 0x600)
|
||||
# pragma warn -8008 // Condition always true/false
|
||||
# pragma warn -8080 // Identifier declared but never used
|
||||
# pragma warn -8057 // Parameter never used
|
||||
# pragma warn -8066 // Unreachable code
|
||||
#endif
|
||||
|
||||
#include "platform.hpp"
|
||||
|
||||
// provided for backwards compatibility, since this
|
||||
// macro was used for several releases by mistake.
|
||||
#if defined(BOOST_THREAD_DYN_DLL)
|
||||
# define BOOST_THREAD_DYN_LINK
|
||||
#endif
|
||||
|
||||
// compatibility with the rest of Boost's auto-linking code:
|
||||
#if defined(BOOST_THREAD_DYN_LINK) || defined(BOOST_ALL_DYN_LINK)
|
||||
# undef BOOST_THREAD_USE_LIB
|
||||
# define BOOST_THREAD_USE_DLL
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_THREAD_BUILD_DLL) //Build dll
|
||||
#elif defined(BOOST_THREAD_BUILD_LIB) //Build lib
|
||||
#elif defined(BOOST_THREAD_USE_DLL) //Use dll
|
||||
#elif defined(BOOST_THREAD_USE_LIB) //Use lib
|
||||
#else //Use default
|
||||
# if defined(BOOST_THREAD_PLATFORM_WIN32)
|
||||
# if defined(BOOST_MSVC) || defined(BOOST_INTEL_WIN)
|
||||
//For compilers supporting auto-tss cleanup
|
||||
//with Boost.Threads lib, use Boost.Threads lib
|
||||
# define BOOST_THREAD_USE_LIB
|
||||
# else
|
||||
//For compilers not yet supporting auto-tss cleanup
|
||||
//with Boost.Threads lib, use Boost.Threads dll
|
||||
# define BOOST_THREAD_USE_DLL
|
||||
# endif
|
||||
# else
|
||||
# define BOOST_THREAD_USE_LIB
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_HAS_DECLSPEC)
|
||||
# if defined(BOOST_THREAD_BUILD_DLL) //Build dll
|
||||
# define BOOST_THREAD_DECL __declspec(dllexport)
|
||||
# elif defined(BOOST_THREAD_USE_DLL) //Use dll
|
||||
# define BOOST_THREAD_DECL __declspec(dllimport)
|
||||
# else
|
||||
# define BOOST_THREAD_DECL
|
||||
# endif
|
||||
#else
|
||||
# define BOOST_THREAD_DECL
|
||||
#endif // BOOST_HAS_DECLSPEC
|
||||
|
||||
//
|
||||
// Automatically link to the correct build variant where possible.
|
||||
//
|
||||
#if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_THREAD_NO_LIB) && !defined(BOOST_THREAD_BUILD_DLL) && !defined(BOOST_THREAD_BUILD_LIB)
|
||||
//
|
||||
// Tell the autolink to link dynamically, this will get undef'ed by auto_link.hpp
|
||||
// once it's done with it:
|
||||
//
|
||||
#if defined(BOOST_THREAD_USE_DLL)
|
||||
# define BOOST_DYN_LINK
|
||||
#endif
|
||||
//
|
||||
// Set the name of our library, this will get undef'ed by auto_link.hpp
|
||||
// once it's done with it:
|
||||
//
|
||||
#if defined(BOOST_THREAD_LIB_NAME)
|
||||
# define BOOST_LIB_NAME BOOST_THREAD_LIB_NAME
|
||||
#else
|
||||
# define BOOST_LIB_NAME boost_thread
|
||||
#endif
|
||||
//
|
||||
// If we're importing code from a dll, then tell auto_link.hpp about it:
|
||||
//
|
||||
// And include the header that does the work:
|
||||
//
|
||||
#include <boost/config/auto_link.hpp>
|
||||
#endif // auto-linking disabled
|
||||
|
||||
#endif // BOOST_THREAD_CONFIG_WEK1032003_HPP
|
||||
|
||||
// Change Log:
|
||||
// 22 Jan 05 Roland Schwarz (speedsnail)
|
||||
// Usage of BOOST_HAS_DECLSPEC macro.
|
||||
// Default again is static lib usage.
|
||||
// BOOST_DYN_LINK only defined when autolink included.
|
||||
@@ -1,39 +0,0 @@
|
||||
// Copyright (C) 2001-2003
|
||||
// Mac Murrett
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
// See http://www.boost.org for most recent version including documentation.
|
||||
|
||||
#ifndef BOOST_FORCE_CAST_MJM012402_HPP
|
||||
#define BOOST_FORCE_CAST_MJM012402_HPP
|
||||
|
||||
#include <boost/thread/detail/config.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace detail {
|
||||
namespace thread {
|
||||
|
||||
// force_cast will convert anything to anything.
|
||||
|
||||
// general case
|
||||
template<class Return_Type, class Argument_Type>
|
||||
inline Return_Type &force_cast(Argument_Type &rSrc)
|
||||
{
|
||||
return(*reinterpret_cast<Return_Type *>(&rSrc));
|
||||
}
|
||||
|
||||
// specialization for const
|
||||
template<class Return_Type, class Argument_Type>
|
||||
inline const Return_Type &force_cast(const Argument_Type &rSrc)
|
||||
{
|
||||
return(*reinterpret_cast<const Return_Type *>(&rSrc));
|
||||
}
|
||||
|
||||
} // namespace thread
|
||||
} // namespace detail
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_FORCE_CAST_MJM012402_HPP
|
||||
207
include/boost/thread/detail/lock.hpp
Normal file
207
include/boost/thread/detail/lock.hpp
Normal file
@@ -0,0 +1,207 @@
|
||||
// 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 lock_ops : private noncopyable
|
||||
{
|
||||
private:
|
||||
lock_ops() { }
|
||||
|
||||
public:
|
||||
typedef typename Mutex::cv_state lock_state;
|
||||
|
||||
static void lock(Mutex& m)
|
||||
{
|
||||
m.do_lock();
|
||||
}
|
||||
static bool trylock(Mutex& m)
|
||||
{
|
||||
return m.do_trylock();
|
||||
}
|
||||
static bool timedlock(Mutex& m, const xtime& xt)
|
||||
{
|
||||
return m.do_timedlock(xt);
|
||||
}
|
||||
static void unlock(Mutex& m)
|
||||
{
|
||||
m.do_unlock();
|
||||
}
|
||||
static void lock(Mutex& m, lock_state& state)
|
||||
{
|
||||
m.do_lock(state);
|
||||
}
|
||||
static void unlock(Mutex& m, lock_state& state)
|
||||
{
|
||||
m.do_unlock(state);
|
||||
}
|
||||
};
|
||||
|
||||
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();
|
||||
lock_ops<Mutex>::lock(m_mutex);
|
||||
m_locked = true;
|
||||
}
|
||||
void unlock()
|
||||
{
|
||||
if (!m_locked) throw lock_error();
|
||||
lock_ops<Mutex>::unlock(m_mutex);
|
||||
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();
|
||||
lock_ops<TryMutex>::lock(m_mutex);
|
||||
m_locked = true;
|
||||
}
|
||||
bool try_lock()
|
||||
{
|
||||
if (m_locked) throw lock_error();
|
||||
return (m_locked = lock_ops<TryMutex>::trylock(m_mutex));
|
||||
}
|
||||
void unlock()
|
||||
{
|
||||
if (!m_locked) throw lock_error();
|
||||
lock_ops<TryMutex>::unlock(m_mutex);
|
||||
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();
|
||||
lock_ops<TimedMutex>::lock(m_mutex);
|
||||
m_locked = true;
|
||||
}
|
||||
bool timed_lock(const xtime& xt)
|
||||
{
|
||||
if (m_locked) throw lock_error();
|
||||
return (m_locked = lock_ops<TimedMutex>::timedlock(m_mutex, xt));
|
||||
}
|
||||
void unlock()
|
||||
{
|
||||
if (!m_locked) throw lock_error();
|
||||
lock_ops<TimedMutex>::unlock(m_mutex);
|
||||
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
|
||||
@@ -1,60 +0,0 @@
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// (C) Copyright 2007-8 Anthony Williams
|
||||
|
||||
#ifndef BOOST_THREAD_MOVE_HPP
|
||||
#define BOOST_THREAD_MOVE_HPP
|
||||
|
||||
#ifndef BOOST_NO_SFINAE
|
||||
#include <boost/utility/enable_if.hpp>
|
||||
#include <boost/type_traits/is_convertible.hpp>
|
||||
#endif
|
||||
|
||||
#include <boost/config/abi_prefix.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace detail
|
||||
{
|
||||
template<typename T>
|
||||
struct thread_move_t
|
||||
{
|
||||
T& t;
|
||||
explicit thread_move_t(T& t_):
|
||||
t(t_)
|
||||
{}
|
||||
|
||||
T& operator*() const
|
||||
{
|
||||
return t;
|
||||
}
|
||||
|
||||
T* operator->() const
|
||||
{
|
||||
return &t;
|
||||
}
|
||||
private:
|
||||
void operator=(thread_move_t&);
|
||||
};
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_SFINAE
|
||||
template<typename T>
|
||||
typename enable_if<boost::is_convertible<T&,detail::thread_move_t<T> >, detail::thread_move_t<T> >::type move(T& t)
|
||||
{
|
||||
return detail::thread_move_t<T>(t);
|
||||
}
|
||||
#endif
|
||||
|
||||
template<typename T>
|
||||
detail::thread_move_t<T> move(detail::thread_move_t<T> t)
|
||||
{
|
||||
return t;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#include <boost/config/abi_suffix.hpp>
|
||||
|
||||
#endif
|
||||
@@ -1,71 +0,0 @@
|
||||
// Copyright 2006 Roland Schwarz.
|
||||
// (C) Copyright 2007 Anthony Williams
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
// This work is a reimplementation along the design and ideas
|
||||
// of William E. Kempf.
|
||||
|
||||
#ifndef BOOST_THREAD_RS06040501_HPP
|
||||
#define BOOST_THREAD_RS06040501_HPP
|
||||
|
||||
// fetch compiler and platform configuration
|
||||
#include <boost/config.hpp>
|
||||
|
||||
// insist on threading support being available:
|
||||
#include <boost/config/requires_threads.hpp>
|
||||
|
||||
// choose platform
|
||||
#if defined(linux) || defined(__linux) || defined(__linux__)
|
||||
# define BOOST_THREAD_LINUX
|
||||
#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
|
||||
# define BOOST_THREAD_BSD
|
||||
#elif defined(sun) || defined(__sun)
|
||||
# define BOOST_THREAD_SOLARIS
|
||||
#elif defined(__sgi)
|
||||
# define BOOST_THREAD_IRIX
|
||||
#elif defined(__hpux)
|
||||
# define BOOST_THREAD_HPUX
|
||||
#elif defined(__CYGWIN__)
|
||||
# define BOOST_THREAD_CYGWIN
|
||||
#elif (defined(_WIN32) || defined(__WIN32__) || defined(WIN32)) && !defined(BOOST_DISABLE_WIN32)
|
||||
# define BOOST_THREAD_WIN32
|
||||
#elif defined(__BEOS__)
|
||||
# define BOOST_THREAD_BEOS
|
||||
#elif defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)
|
||||
# define BOOST_THREAD_MACOS
|
||||
#elif defined(__IBMCPP__) || defined(_AIX)
|
||||
# define BOOST_THREAD_AIX
|
||||
#elif defined(__amigaos__)
|
||||
# define BOOST_THREAD_AMIGAOS
|
||||
#elif defined(__QNXNTO__)
|
||||
# define BOOST_THREAD_QNXNTO
|
||||
#elif defined(unix) || defined(__unix) || defined(_XOPEN_SOURCE) || defined(_POSIX_SOURCE)
|
||||
# if defined(BOOST_HAS_PTHREADS) && !defined(BOOST_THREAD_POSIX)
|
||||
# define BOOST_THREAD_POSIX
|
||||
# endif
|
||||
#endif
|
||||
|
||||
// For every supported platform add a new entry into the dispatch table below.
|
||||
// BOOST_THREAD_POSIX is tested first, so on platforms where posix and native
|
||||
// threading is available, the user may choose, by defining BOOST_THREAD_POSIX
|
||||
// in her source. If a platform is known to support pthreads and no native
|
||||
// port of boost_thread is available just specify "pthread" in the
|
||||
// dispatcher table. If there is no entry for a platform but pthreads is
|
||||
// available on the platform, pthread is choosen as default. If nothing is
|
||||
// available the preprocessor will fail with a diagnostic message.
|
||||
|
||||
#if defined(BOOST_THREAD_POSIX)
|
||||
# define BOOST_THREAD_PLATFORM_PTHREAD
|
||||
#else
|
||||
# if defined(BOOST_THREAD_WIN32)
|
||||
# define BOOST_THREAD_PLATFORM_WIN32
|
||||
# elif defined(BOOST_HAS_PTHREADS)
|
||||
# define BOOST_THREAD_PLATFORM_PTHREAD
|
||||
# else
|
||||
# error "Sorry, no boost threads are available for this platform."
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#endif // BOOST_THREAD_RS06040501_HPP
|
||||
@@ -1,59 +0,0 @@
|
||||
// Copyright (C) 2001-2003
|
||||
// Mac Murrett
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
// See http://www.boost.org for most recent version including documentation.
|
||||
|
||||
#ifndef BOOST_SINGLETON_MJM012402_HPP
|
||||
#define BOOST_SINGLETON_MJM012402_HPP
|
||||
|
||||
#include <boost/thread/detail/config.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace detail {
|
||||
namespace thread {
|
||||
|
||||
// class singleton has the same goal as all singletons: create one instance of
|
||||
// a class on demand, then dish it out as requested.
|
||||
|
||||
template <class T>
|
||||
class singleton : private T
|
||||
{
|
||||
private:
|
||||
singleton();
|
||||
~singleton();
|
||||
|
||||
public:
|
||||
static T &instance();
|
||||
};
|
||||
|
||||
|
||||
template <class T>
|
||||
inline singleton<T>::singleton()
|
||||
{
|
||||
/* no-op */
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline singleton<T>::~singleton()
|
||||
{
|
||||
/* no-op */
|
||||
}
|
||||
|
||||
template <class T>
|
||||
/*static*/ T &singleton<T>::instance()
|
||||
{
|
||||
// function-local static to force this to work correctly at static
|
||||
// initialization time.
|
||||
static singleton<T> s_oT;
|
||||
return(s_oT);
|
||||
}
|
||||
|
||||
} // namespace thread
|
||||
} // namespace detail
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_SINGLETON_MJM012402_HPP
|
||||
@@ -1,532 +0,0 @@
|
||||
#ifndef BOOST_THREAD_THREAD_COMMON_HPP
|
||||
#define BOOST_THREAD_THREAD_COMMON_HPP
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// (C) Copyright 2007-10 Anthony Williams
|
||||
|
||||
#include <boost/thread/exceptions.hpp>
|
||||
#ifndef BOOST_NO_IOSTREAM
|
||||
#include <ostream>
|
||||
#endif
|
||||
#include <boost/thread/detail/move.hpp>
|
||||
#include <boost/thread/mutex.hpp>
|
||||
#include <boost/thread/xtime.hpp>
|
||||
#include <boost/thread/detail/thread_heap_alloc.hpp>
|
||||
#include <boost/utility.hpp>
|
||||
#include <boost/assert.hpp>
|
||||
#include <list>
|
||||
#include <algorithm>
|
||||
#include <boost/ref.hpp>
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/bind.hpp>
|
||||
#include <stdlib.h>
|
||||
#include <memory>
|
||||
#include <boost/utility/enable_if.hpp>
|
||||
#include <boost/type_traits/remove_reference.hpp>
|
||||
|
||||
#include <boost/config/abi_prefix.hpp>
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(push)
|
||||
#pragma warning(disable:4251)
|
||||
#endif
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace detail
|
||||
{
|
||||
template<typename F>
|
||||
class thread_data:
|
||||
public detail::thread_data_base
|
||||
{
|
||||
public:
|
||||
#ifndef BOOST_NO_RVALUE_REFERENCES
|
||||
thread_data(F&& f_):
|
||||
f(static_cast<F&&>(f_))
|
||||
{}
|
||||
thread_data(F& f_):
|
||||
f(f_)
|
||||
{}
|
||||
#else
|
||||
thread_data(F f_):
|
||||
f(f_)
|
||||
{}
|
||||
thread_data(detail::thread_move_t<F> f_):
|
||||
f(f_)
|
||||
{}
|
||||
#endif
|
||||
void run()
|
||||
{
|
||||
f();
|
||||
}
|
||||
private:
|
||||
F f;
|
||||
|
||||
void operator=(thread_data&);
|
||||
thread_data(thread_data&);
|
||||
};
|
||||
|
||||
template<typename F>
|
||||
class thread_data<boost::reference_wrapper<F> >:
|
||||
public detail::thread_data_base
|
||||
{
|
||||
private:
|
||||
F& f;
|
||||
|
||||
void operator=(thread_data&);
|
||||
thread_data(thread_data&);
|
||||
public:
|
||||
thread_data(boost::reference_wrapper<F> f_):
|
||||
f(f_)
|
||||
{}
|
||||
|
||||
void run()
|
||||
{
|
||||
f();
|
||||
}
|
||||
};
|
||||
|
||||
template<typename F>
|
||||
class thread_data<const boost::reference_wrapper<F> >:
|
||||
public detail::thread_data_base
|
||||
{
|
||||
private:
|
||||
F& f;
|
||||
void operator=(thread_data&);
|
||||
thread_data(thread_data&);
|
||||
public:
|
||||
thread_data(const boost::reference_wrapper<F> f_):
|
||||
f(f_)
|
||||
{}
|
||||
|
||||
void run()
|
||||
{
|
||||
f();
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
class BOOST_THREAD_DECL thread
|
||||
{
|
||||
private:
|
||||
thread(thread&);
|
||||
thread& operator=(thread&);
|
||||
|
||||
void release_handle();
|
||||
|
||||
detail::thread_data_ptr thread_info;
|
||||
|
||||
void start_thread();
|
||||
|
||||
explicit thread(detail::thread_data_ptr data);
|
||||
|
||||
detail::thread_data_ptr get_thread_info BOOST_PREVENT_MACRO_SUBSTITUTION () const;
|
||||
|
||||
#ifndef BOOST_NO_RVALUE_REFERENCES
|
||||
template<typename F>
|
||||
static inline detail::thread_data_ptr make_thread_info(F&& f)
|
||||
{
|
||||
return detail::thread_data_ptr(detail::heap_new<detail::thread_data<typename boost::remove_reference<F>::type> >(static_cast<F&&>(f)));
|
||||
}
|
||||
static inline detail::thread_data_ptr make_thread_info(void (*f)())
|
||||
{
|
||||
return detail::thread_data_ptr(detail::heap_new<detail::thread_data<void(*)()> >(static_cast<void(*&&)()>(f)));
|
||||
}
|
||||
#else
|
||||
template<typename F>
|
||||
static inline detail::thread_data_ptr make_thread_info(F f)
|
||||
{
|
||||
return detail::thread_data_ptr(detail::heap_new<detail::thread_data<F> >(f));
|
||||
}
|
||||
template<typename F>
|
||||
static inline detail::thread_data_ptr make_thread_info(boost::detail::thread_move_t<F> f)
|
||||
{
|
||||
return detail::thread_data_ptr(detail::heap_new<detail::thread_data<F> >(f));
|
||||
}
|
||||
|
||||
#endif
|
||||
struct dummy;
|
||||
public:
|
||||
#if BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100)
|
||||
thread(const volatile thread&);
|
||||
#endif
|
||||
thread();
|
||||
~thread();
|
||||
|
||||
#ifndef BOOST_NO_RVALUE_REFERENCES
|
||||
#ifdef BOOST_MSVC
|
||||
template <class F>
|
||||
explicit thread(F f,typename disable_if<boost::is_convertible<F&,detail::thread_move_t<F> >, dummy* >::type=0):
|
||||
thread_info(make_thread_info(static_cast<F&&>(f)))
|
||||
{
|
||||
start_thread();
|
||||
}
|
||||
#else
|
||||
template <class F>
|
||||
thread(F&& f):
|
||||
thread_info(make_thread_info(static_cast<F&&>(f)))
|
||||
{
|
||||
start_thread();
|
||||
}
|
||||
#endif
|
||||
|
||||
thread(thread&& other)
|
||||
{
|
||||
thread_info.swap(other.thread_info);
|
||||
}
|
||||
|
||||
thread& operator=(thread&& other)
|
||||
{
|
||||
thread_info=other.thread_info;
|
||||
other.thread_info.reset();
|
||||
return *this;
|
||||
}
|
||||
|
||||
thread&& move()
|
||||
{
|
||||
return static_cast<thread&&>(*this);
|
||||
}
|
||||
|
||||
#else
|
||||
#ifdef BOOST_NO_SFINAE
|
||||
template <class F>
|
||||
explicit thread(F f):
|
||||
thread_info(make_thread_info(f))
|
||||
{
|
||||
start_thread();
|
||||
}
|
||||
#else
|
||||
template <class F>
|
||||
explicit thread(F f,typename disable_if<boost::is_convertible<F&,detail::thread_move_t<F> >, dummy* >::type=0):
|
||||
thread_info(make_thread_info(f))
|
||||
{
|
||||
start_thread();
|
||||
}
|
||||
#endif
|
||||
|
||||
template <class F>
|
||||
explicit thread(detail::thread_move_t<F> f):
|
||||
thread_info(make_thread_info(f))
|
||||
{
|
||||
start_thread();
|
||||
}
|
||||
|
||||
thread(detail::thread_move_t<thread> x)
|
||||
{
|
||||
thread_info=x->thread_info;
|
||||
x->thread_info.reset();
|
||||
}
|
||||
|
||||
#if BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100)
|
||||
thread& operator=(thread x)
|
||||
{
|
||||
swap(x);
|
||||
return *this;
|
||||
}
|
||||
#else
|
||||
thread& operator=(detail::thread_move_t<thread> x)
|
||||
{
|
||||
thread new_thread(x);
|
||||
swap(new_thread);
|
||||
return *this;
|
||||
}
|
||||
#endif
|
||||
operator detail::thread_move_t<thread>()
|
||||
{
|
||||
return move();
|
||||
}
|
||||
|
||||
detail::thread_move_t<thread> move()
|
||||
{
|
||||
detail::thread_move_t<thread> x(*this);
|
||||
return x;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
template <class F,class A1>
|
||||
thread(F f,A1 a1):
|
||||
thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1)))
|
||||
{
|
||||
start_thread();
|
||||
}
|
||||
template <class F,class A1,class A2>
|
||||
thread(F f,A1 a1,A2 a2):
|
||||
thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2)))
|
||||
{
|
||||
start_thread();
|
||||
}
|
||||
|
||||
template <class F,class A1,class A2,class A3>
|
||||
thread(F f,A1 a1,A2 a2,A3 a3):
|
||||
thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3)))
|
||||
{
|
||||
start_thread();
|
||||
}
|
||||
|
||||
template <class F,class A1,class A2,class A3,class A4>
|
||||
thread(F f,A1 a1,A2 a2,A3 a3,A4 a4):
|
||||
thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4)))
|
||||
{
|
||||
start_thread();
|
||||
}
|
||||
|
||||
template <class F,class A1,class A2,class A3,class A4,class A5>
|
||||
thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5):
|
||||
thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5)))
|
||||
{
|
||||
start_thread();
|
||||
}
|
||||
|
||||
template <class F,class A1,class A2,class A3,class A4,class A5,class A6>
|
||||
thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6):
|
||||
thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5,a6)))
|
||||
{
|
||||
start_thread();
|
||||
}
|
||||
|
||||
template <class F,class A1,class A2,class A3,class A4,class A5,class A6,class A7>
|
||||
thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7):
|
||||
thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5,a6,a7)))
|
||||
{
|
||||
start_thread();
|
||||
}
|
||||
|
||||
template <class F,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8>
|
||||
thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8):
|
||||
thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5,a6,a7,a8)))
|
||||
{
|
||||
start_thread();
|
||||
}
|
||||
|
||||
template <class F,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9>
|
||||
thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8,A9 a9):
|
||||
thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5,a6,a7,a8,a9)))
|
||||
{
|
||||
start_thread();
|
||||
}
|
||||
|
||||
void swap(thread& x)
|
||||
{
|
||||
thread_info.swap(x.thread_info);
|
||||
}
|
||||
|
||||
class id;
|
||||
id get_id() const;
|
||||
|
||||
|
||||
bool joinable() const;
|
||||
void join();
|
||||
bool timed_join(const system_time& wait_until);
|
||||
|
||||
template<typename TimeDuration>
|
||||
inline bool timed_join(TimeDuration const& rel_time)
|
||||
{
|
||||
return timed_join(get_system_time()+rel_time);
|
||||
}
|
||||
void detach();
|
||||
|
||||
static unsigned hardware_concurrency();
|
||||
|
||||
typedef detail::thread_data_base::native_handle_type native_handle_type;
|
||||
native_handle_type native_handle();
|
||||
|
||||
// backwards compatibility
|
||||
bool operator==(const thread& other) const;
|
||||
bool operator!=(const thread& other) const;
|
||||
|
||||
static inline void yield()
|
||||
{
|
||||
this_thread::yield();
|
||||
}
|
||||
|
||||
static inline void sleep(const system_time& xt)
|
||||
{
|
||||
this_thread::sleep(xt);
|
||||
}
|
||||
|
||||
// extensions
|
||||
void interrupt();
|
||||
bool interruption_requested() const;
|
||||
};
|
||||
|
||||
inline void swap(thread& lhs,thread& rhs)
|
||||
{
|
||||
return lhs.swap(rhs);
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_RVALUE_REFERENCES
|
||||
inline thread&& move(thread& t)
|
||||
{
|
||||
return static_cast<thread&&>(t);
|
||||
}
|
||||
inline thread&& move(thread&& t)
|
||||
{
|
||||
return static_cast<thread&&>(t);
|
||||
}
|
||||
#else
|
||||
inline detail::thread_move_t<thread> move(detail::thread_move_t<thread> t)
|
||||
{
|
||||
return t;
|
||||
}
|
||||
#endif
|
||||
|
||||
namespace this_thread
|
||||
{
|
||||
thread::id BOOST_THREAD_DECL get_id();
|
||||
|
||||
void BOOST_THREAD_DECL interruption_point();
|
||||
bool BOOST_THREAD_DECL interruption_enabled();
|
||||
bool BOOST_THREAD_DECL interruption_requested();
|
||||
|
||||
inline void sleep(xtime const& abs_time)
|
||||
{
|
||||
sleep(system_time(abs_time));
|
||||
}
|
||||
}
|
||||
|
||||
class thread::id
|
||||
{
|
||||
private:
|
||||
detail::thread_data_ptr thread_data;
|
||||
|
||||
id(detail::thread_data_ptr thread_data_):
|
||||
thread_data(thread_data_)
|
||||
{}
|
||||
friend class thread;
|
||||
friend id BOOST_THREAD_DECL this_thread::get_id();
|
||||
public:
|
||||
id():
|
||||
thread_data()
|
||||
{}
|
||||
|
||||
bool operator==(const id& y) const
|
||||
{
|
||||
return thread_data==y.thread_data;
|
||||
}
|
||||
|
||||
bool operator!=(const id& y) const
|
||||
{
|
||||
return thread_data!=y.thread_data;
|
||||
}
|
||||
|
||||
bool operator<(const id& y) const
|
||||
{
|
||||
return thread_data<y.thread_data;
|
||||
}
|
||||
|
||||
bool operator>(const id& y) const
|
||||
{
|
||||
return y.thread_data<thread_data;
|
||||
}
|
||||
|
||||
bool operator<=(const id& y) const
|
||||
{
|
||||
return !(y.thread_data<thread_data);
|
||||
}
|
||||
|
||||
bool operator>=(const id& y) const
|
||||
{
|
||||
return !(thread_data<y.thread_data);
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_IOSTREAM
|
||||
#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
|
||||
template<class charT, class traits>
|
||||
friend std::basic_ostream<charT, traits>&
|
||||
operator<<(std::basic_ostream<charT, traits>& os, const id& x)
|
||||
{
|
||||
if(x.thread_data)
|
||||
{
|
||||
return os<<x.thread_data;
|
||||
}
|
||||
else
|
||||
{
|
||||
return os<<"{Not-any-thread}";
|
||||
}
|
||||
}
|
||||
#else
|
||||
template<class charT, class traits>
|
||||
std::basic_ostream<charT, traits>&
|
||||
print(std::basic_ostream<charT, traits>& os)
|
||||
{
|
||||
if(thread_data)
|
||||
{
|
||||
return os<<thread_data;
|
||||
}
|
||||
else
|
||||
{
|
||||
return os<<"{Not-any-thread}";
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
#endif
|
||||
};
|
||||
|
||||
#if !defined(BOOST_NO_IOSTREAM) && defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
|
||||
template<class charT, class traits>
|
||||
std::basic_ostream<charT, traits>&
|
||||
operator<<(std::basic_ostream<charT, traits>& os, const thread::id& x)
|
||||
{
|
||||
return x.print(os);
|
||||
}
|
||||
#endif
|
||||
|
||||
inline bool thread::operator==(const thread& other) const
|
||||
{
|
||||
return get_id()==other.get_id();
|
||||
}
|
||||
|
||||
inline bool thread::operator!=(const thread& other) const
|
||||
{
|
||||
return get_id()!=other.get_id();
|
||||
}
|
||||
|
||||
namespace detail
|
||||
{
|
||||
struct thread_exit_function_base
|
||||
{
|
||||
virtual ~thread_exit_function_base()
|
||||
{}
|
||||
virtual void operator()()=0;
|
||||
};
|
||||
|
||||
template<typename F>
|
||||
struct thread_exit_function:
|
||||
thread_exit_function_base
|
||||
{
|
||||
F f;
|
||||
|
||||
thread_exit_function(F f_):
|
||||
f(f_)
|
||||
{}
|
||||
|
||||
void operator()()
|
||||
{
|
||||
f();
|
||||
}
|
||||
};
|
||||
|
||||
void BOOST_THREAD_DECL add_thread_exit_function(thread_exit_function_base*);
|
||||
}
|
||||
|
||||
namespace this_thread
|
||||
{
|
||||
template<typename F>
|
||||
void at_thread_exit(F f)
|
||||
{
|
||||
detail::thread_exit_function_base* const thread_exit_func=detail::heap_new<detail::thread_exit_function<F> >(f);
|
||||
detail::add_thread_exit_function(thread_exit_func);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/config/abi_suffix.hpp>
|
||||
|
||||
#endif
|
||||
@@ -1,108 +0,0 @@
|
||||
#ifndef BOOST_THREAD_DETAIL_THREAD_GROUP_HPP
|
||||
#define BOOST_THREAD_DETAIL_THREAD_GROUP_HPP
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// (C) Copyright 2007-9 Anthony Williams
|
||||
|
||||
#include <list>
|
||||
#include <boost/thread/shared_mutex.hpp>
|
||||
#include <boost/thread/mutex.hpp>
|
||||
|
||||
#include <boost/config/abi_prefix.hpp>
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(push)
|
||||
#pragma warning(disable:4251)
|
||||
#endif
|
||||
|
||||
namespace boost
|
||||
{
|
||||
class thread_group
|
||||
{
|
||||
private:
|
||||
thread_group(thread_group const&);
|
||||
thread_group& operator=(thread_group const&);
|
||||
public:
|
||||
thread_group() {}
|
||||
~thread_group()
|
||||
{
|
||||
for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
|
||||
it!=end;
|
||||
++it)
|
||||
{
|
||||
delete *it;
|
||||
}
|
||||
}
|
||||
|
||||
template<typename F>
|
||||
thread* create_thread(F threadfunc)
|
||||
{
|
||||
boost::lock_guard<shared_mutex> guard(m);
|
||||
std::auto_ptr<thread> new_thread(new thread(threadfunc));
|
||||
threads.push_back(new_thread.get());
|
||||
return new_thread.release();
|
||||
}
|
||||
|
||||
void add_thread(thread* thrd)
|
||||
{
|
||||
if(thrd)
|
||||
{
|
||||
boost::lock_guard<shared_mutex> guard(m);
|
||||
threads.push_back(thrd);
|
||||
}
|
||||
}
|
||||
|
||||
void remove_thread(thread* thrd)
|
||||
{
|
||||
boost::lock_guard<shared_mutex> guard(m);
|
||||
std::list<thread*>::iterator const it=std::find(threads.begin(),threads.end(),thrd);
|
||||
if(it!=threads.end())
|
||||
{
|
||||
threads.erase(it);
|
||||
}
|
||||
}
|
||||
|
||||
void join_all()
|
||||
{
|
||||
boost::shared_lock<shared_mutex> guard(m);
|
||||
|
||||
for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
|
||||
it!=end;
|
||||
++it)
|
||||
{
|
||||
(*it)->join();
|
||||
}
|
||||
}
|
||||
|
||||
void interrupt_all()
|
||||
{
|
||||
boost::shared_lock<shared_mutex> guard(m);
|
||||
|
||||
for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
|
||||
it!=end;
|
||||
++it)
|
||||
{
|
||||
(*it)->interrupt();
|
||||
}
|
||||
}
|
||||
|
||||
size_t size() const
|
||||
{
|
||||
boost::shared_lock<shared_mutex> guard(m);
|
||||
return threads.size();
|
||||
}
|
||||
|
||||
private:
|
||||
std::list<thread*> threads;
|
||||
mutable shared_mutex m;
|
||||
};
|
||||
}
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/config/abi_suffix.hpp>
|
||||
|
||||
#endif
|
||||
@@ -1,23 +0,0 @@
|
||||
#ifndef BOOST_THREAD_THREAD_HEAP_ALLOC_HPP
|
||||
#define BOOST_THREAD_THREAD_HEAP_ALLOC_HPP
|
||||
|
||||
// thread_heap_alloc.hpp
|
||||
//
|
||||
// (C) Copyright 2008 Anthony Williams
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/thread/detail/platform.hpp>
|
||||
|
||||
#if defined(BOOST_THREAD_PLATFORM_WIN32)
|
||||
#include <boost/thread/win32/thread_heap_alloc.hpp>
|
||||
#elif defined(BOOST_THREAD_PLATFORM_PTHREAD)
|
||||
#include <boost/thread/pthread/thread_heap_alloc.hpp>
|
||||
#else
|
||||
#error "Boost threads unavailable on this platform"
|
||||
#endif
|
||||
|
||||
|
||||
#endif
|
||||
@@ -1,35 +0,0 @@
|
||||
#ifndef BOOST_THREAD_DETAIL_THREAD_INTERRUPTION_HPP
|
||||
#define BOOST_THREAD_DETAIL_THREAD_INTERRUPTION_HPP
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// (C) Copyright 2007-9 Anthony Williams
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace this_thread
|
||||
{
|
||||
class BOOST_THREAD_DECL disable_interruption
|
||||
{
|
||||
disable_interruption(const disable_interruption&);
|
||||
disable_interruption& operator=(const disable_interruption&);
|
||||
|
||||
bool interruption_was_enabled;
|
||||
friend class restore_interruption;
|
||||
public:
|
||||
disable_interruption();
|
||||
~disable_interruption();
|
||||
};
|
||||
|
||||
class BOOST_THREAD_DECL restore_interruption
|
||||
{
|
||||
restore_interruption(const restore_interruption&);
|
||||
restore_interruption& operator=(const restore_interruption&);
|
||||
public:
|
||||
explicit restore_interruption(disable_interruption& d);
|
||||
~restore_interruption();
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -1,65 +0,0 @@
|
||||
// (C) Copyright Michael Glassford 2004.
|
||||
// Use, modification and distribution are subject to the
|
||||
// Boost Software License, Version 1.0. (See accompanying file
|
||||
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#if !defined(BOOST_TLS_HOOKS_HPP)
|
||||
#define BOOST_TLS_HOOKS_HPP
|
||||
|
||||
#include <boost/thread/detail/config.hpp>
|
||||
|
||||
#include <boost/config/abi_prefix.hpp>
|
||||
|
||||
#if defined(BOOST_HAS_WINTHREADS)
|
||||
|
||||
namespace boost
|
||||
{
|
||||
BOOST_THREAD_DECL void __cdecl on_process_enter(void);
|
||||
//Function to be called when the exe or dll
|
||||
//that uses Boost.Threads first starts
|
||||
//or is first loaded.
|
||||
//Should be called only before the first call to
|
||||
//on_thread_enter().
|
||||
//Called automatically by Boost.Threads when
|
||||
//a method for doing so has been discovered.
|
||||
//May be omitted; may be called multiple times.
|
||||
|
||||
BOOST_THREAD_DECL void __cdecl on_process_exit(void);
|
||||
//Function to be called when the exe or dll
|
||||
//that uses Boost.Threads first starts
|
||||
//or is first loaded.
|
||||
//Should be called only after the last call to
|
||||
//on_exit_thread().
|
||||
//Called automatically by Boost.Threads when
|
||||
//a method for doing so has been discovered.
|
||||
//Must not be omitted; may be called multiple times.
|
||||
|
||||
BOOST_THREAD_DECL void __cdecl on_thread_enter(void);
|
||||
//Function to be called just after a thread starts
|
||||
//in an exe or dll that uses Boost.Threads.
|
||||
//Must be called in the context of the thread
|
||||
//that is starting.
|
||||
//Called automatically by Boost.Threads when
|
||||
//a method for doing so has been discovered.
|
||||
//May be omitted; may be called multiple times.
|
||||
|
||||
BOOST_THREAD_DECL void __cdecl on_thread_exit(void);
|
||||
//Function to be called just be fore a thread ends
|
||||
//in an exe or dll that uses Boost.Threads.
|
||||
//Must be called in the context of the thread
|
||||
//that is ending.
|
||||
//Called automatically by Boost.Threads when
|
||||
//a method for doing so has been discovered.
|
||||
//Must not be omitted; may be called multiple times.
|
||||
|
||||
void tss_cleanup_implemented();
|
||||
//Dummy function used both to detect whether tss cleanup
|
||||
//cleanup has been implemented and to force
|
||||
//it to be linked into the Boost.Threads library.
|
||||
}
|
||||
|
||||
#endif //defined(BOOST_HAS_WINTHREADS)
|
||||
|
||||
#include <boost/config/abi_suffix.hpp>
|
||||
|
||||
#endif //!defined(BOOST_TLS_HOOKS_HPP)
|
||||
@@ -1,182 +1,39 @@
|
||||
// Copyright (C) 2001-2003
|
||||
// Copyright (C) 2001
|
||||
// William E. Kempf
|
||||
// Copyright (C) 2007-9 Anthony Williams
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
// 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_EXCEPTIONS_PDM070801_H
|
||||
#define BOOST_THREAD_EXCEPTIONS_PDM070801_H
|
||||
|
||||
#include <boost/thread/detail/config.hpp>
|
||||
|
||||
// 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 <string>
|
||||
#include <stdexcept>
|
||||
|
||||
#include <boost/config/abi_prefix.hpp>
|
||||
namespace boost {
|
||||
|
||||
namespace boost
|
||||
class lock_error : public std::runtime_error
|
||||
{
|
||||
public:
|
||||
lock_error();
|
||||
};
|
||||
|
||||
class thread_interrupted
|
||||
{};
|
||||
|
||||
class thread_exception:
|
||||
public std::exception
|
||||
{
|
||||
protected:
|
||||
thread_exception():
|
||||
m_sys_err(0)
|
||||
{}
|
||||
|
||||
thread_exception(int sys_err_code):
|
||||
m_sys_err(sys_err_code)
|
||||
{}
|
||||
|
||||
|
||||
public:
|
||||
~thread_exception() throw()
|
||||
{}
|
||||
|
||||
|
||||
int native_error() const
|
||||
{
|
||||
return m_sys_err;
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
int m_sys_err;
|
||||
};
|
||||
|
||||
class condition_error:
|
||||
public std::exception
|
||||
{
|
||||
public:
|
||||
const char* what() const throw()
|
||||
{
|
||||
return "Condition error";
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
class lock_error:
|
||||
public thread_exception
|
||||
{
|
||||
public:
|
||||
lock_error()
|
||||
{}
|
||||
|
||||
lock_error(int sys_err_code):
|
||||
thread_exception(sys_err_code)
|
||||
{}
|
||||
|
||||
~lock_error() throw()
|
||||
{}
|
||||
|
||||
|
||||
virtual const char* what() const throw()
|
||||
{
|
||||
return "boost::lock_error";
|
||||
}
|
||||
};
|
||||
|
||||
class thread_resource_error:
|
||||
public thread_exception
|
||||
{
|
||||
public:
|
||||
thread_resource_error()
|
||||
{}
|
||||
|
||||
thread_resource_error(int sys_err_code):
|
||||
thread_exception(sys_err_code)
|
||||
{}
|
||||
|
||||
~thread_resource_error() throw()
|
||||
{}
|
||||
|
||||
|
||||
virtual const char* what() const throw()
|
||||
{
|
||||
return "boost::thread_resource_error";
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
class unsupported_thread_option:
|
||||
public thread_exception
|
||||
{
|
||||
public:
|
||||
unsupported_thread_option()
|
||||
{}
|
||||
|
||||
unsupported_thread_option(int sys_err_code):
|
||||
thread_exception(sys_err_code)
|
||||
{}
|
||||
|
||||
~unsupported_thread_option() throw()
|
||||
{}
|
||||
|
||||
|
||||
virtual const char* what() const throw()
|
||||
{
|
||||
return "boost::unsupported_thread_option";
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
class invalid_thread_argument:
|
||||
public thread_exception
|
||||
{
|
||||
public:
|
||||
invalid_thread_argument()
|
||||
{}
|
||||
|
||||
invalid_thread_argument(int sys_err_code):
|
||||
thread_exception(sys_err_code)
|
||||
{}
|
||||
|
||||
~invalid_thread_argument() throw()
|
||||
{}
|
||||
|
||||
|
||||
virtual const char* what() const throw()
|
||||
{
|
||||
return "boost::invalid_thread_argument";
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
class thread_permission_error:
|
||||
public thread_exception
|
||||
{
|
||||
public:
|
||||
thread_permission_error()
|
||||
{}
|
||||
|
||||
thread_permission_error(int sys_err_code):
|
||||
thread_exception(sys_err_code)
|
||||
{}
|
||||
|
||||
~thread_permission_error() throw()
|
||||
{}
|
||||
|
||||
|
||||
virtual const char* what() const throw()
|
||||
{
|
||||
return "boost::thread_permission_error";
|
||||
}
|
||||
|
||||
};
|
||||
class thread_resource_error : public std::runtime_error
|
||||
{
|
||||
public:
|
||||
thread_resource_error();
|
||||
};
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#include <boost/config/abi_suffix.hpp>
|
||||
|
||||
#endif
|
||||
#endif // BOOST_THREAD_CONFIG_PDM070801_H
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -1,21 +1,139 @@
|
||||
#ifndef BOOST_THREAD_MUTEX_HPP
|
||||
#define BOOST_THREAD_MUTEX_HPP
|
||||
|
||||
// mutex.hpp
|
||||
// Copyright (C) 2001
|
||||
// William E. Kempf
|
||||
//
|
||||
// (C) Copyright 2007 Anthony Williams
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// 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/detail/platform.hpp>
|
||||
#if defined(BOOST_THREAD_PLATFORM_WIN32)
|
||||
#include <boost/thread/win32/mutex.hpp>
|
||||
#elif defined(BOOST_THREAD_PLATFORM_PTHREAD)
|
||||
#include <boost/thread/pthread/mutex.hpp>
|
||||
#else
|
||||
#error "Boost threads unavailable on this platform"
|
||||
#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 {
|
||||
|
||||
struct xtime;
|
||||
|
||||
class mutex : private noncopyable
|
||||
{
|
||||
public:
|
||||
friend class detail::thread::lock_ops<mutex>;
|
||||
|
||||
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)
|
||||
void* m_mutex;
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
pthread_mutex_t m_mutex;
|
||||
#endif
|
||||
};
|
||||
|
||||
class try_mutex : private noncopyable
|
||||
{
|
||||
public:
|
||||
friend class detail::thread::lock_ops<try_mutex>;
|
||||
|
||||
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)
|
||||
void* m_mutex;
|
||||
#elif defined(BOOST_HAS_PTHREADS)
|
||||
pthread_mutex_t m_mutex;
|
||||
#endif
|
||||
};
|
||||
|
||||
class timed_mutex : private noncopyable
|
||||
{
|
||||
public:
|
||||
friend class detail::thread::lock_ops<timed_mutex>;
|
||||
|
||||
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)
|
||||
void* 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
|
||||
|
||||
@@ -1,33 +1,45 @@
|
||||
#ifndef BOOST_THREAD_ONCE_HPP
|
||||
#define BOOST_THREAD_ONCE_HPP
|
||||
|
||||
// once.hpp
|
||||
// Copyright (C) 2001
|
||||
// William E. Kempf
|
||||
//
|
||||
// (C) Copyright 2006-7 Anthony Williams
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// 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/detail/platform.hpp>
|
||||
#if defined(BOOST_THREAD_PLATFORM_WIN32)
|
||||
#include <boost/thread/win32/once.hpp>
|
||||
#elif defined(BOOST_THREAD_PLATFORM_PTHREAD)
|
||||
#include <boost/thread/pthread/once.hpp>
|
||||
#else
|
||||
#error "Boost threads unavailable on this platform"
|
||||
#ifndef BOOST_ONCE_WEK080101_HPP
|
||||
#define BOOST_ONCE_WEK080101_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#ifndef BOOST_HAS_THREADS
|
||||
# error Thread support is unavailable!
|
||||
#endif
|
||||
|
||||
#include <boost/config/abi_prefix.hpp>
|
||||
#if defined(BOOST_HAS_PTHREADS)
|
||||
# include <pthread.h>
|
||||
#endif
|
||||
|
||||
namespace boost
|
||||
{
|
||||
inline void call_once(void (*func)(),once_flag& flag)
|
||||
{
|
||||
call_once(flag,func);
|
||||
}
|
||||
}
|
||||
namespace boost {
|
||||
|
||||
#include <boost/config/abi_suffix.hpp>
|
||||
#if defined(BOOST_HAS_PTHREADS)
|
||||
|
||||
typedef pthread_once_t once_flag;
|
||||
#define BOOST_ONCE_INIT PTHREAD_ONCE_INIT
|
||||
|
||||
#elif defined(BOOST_HAS_WINTHREADS)
|
||||
|
||||
typedef bool once_flag;
|
||||
#define BOOST_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
|
||||
|
||||
@@ -1,176 +0,0 @@
|
||||
#ifndef BOOST_THREAD_CONDITION_VARIABLE_PTHREAD_HPP
|
||||
#define BOOST_THREAD_CONDITION_VARIABLE_PTHREAD_HPP
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// (C) Copyright 2007-10 Anthony Williams
|
||||
|
||||
#include "timespec.hpp"
|
||||
#include "pthread_mutex_scoped_lock.hpp"
|
||||
#include "thread_data.hpp"
|
||||
#include "condition_variable_fwd.hpp"
|
||||
|
||||
#include <boost/config/abi_prefix.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
inline void condition_variable::wait(unique_lock<mutex>& m)
|
||||
{
|
||||
detail::interruption_checker check_for_interruption(&cond);
|
||||
BOOST_VERIFY(!pthread_cond_wait(&cond,m.mutex()->native_handle()));
|
||||
}
|
||||
|
||||
inline bool condition_variable::timed_wait(unique_lock<mutex>& m,boost::system_time const& wait_until)
|
||||
{
|
||||
detail::interruption_checker check_for_interruption(&cond);
|
||||
struct timespec const timeout=detail::get_timespec(wait_until);
|
||||
int const cond_res=pthread_cond_timedwait(&cond,m.mutex()->native_handle(),&timeout);
|
||||
if(cond_res==ETIMEDOUT)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
BOOST_ASSERT(!cond_res);
|
||||
return true;
|
||||
}
|
||||
|
||||
inline void condition_variable::notify_one()
|
||||
{
|
||||
BOOST_VERIFY(!pthread_cond_signal(&cond));
|
||||
}
|
||||
|
||||
inline void condition_variable::notify_all()
|
||||
{
|
||||
BOOST_VERIFY(!pthread_cond_broadcast(&cond));
|
||||
}
|
||||
|
||||
class condition_variable_any
|
||||
{
|
||||
pthread_mutex_t internal_mutex;
|
||||
pthread_cond_t cond;
|
||||
|
||||
condition_variable_any(condition_variable_any&);
|
||||
condition_variable_any& operator=(condition_variable_any&);
|
||||
|
||||
public:
|
||||
condition_variable_any()
|
||||
{
|
||||
int const res=pthread_mutex_init(&internal_mutex,NULL);
|
||||
if(res)
|
||||
{
|
||||
boost::throw_exception(thread_resource_error());
|
||||
}
|
||||
int const res2=pthread_cond_init(&cond,NULL);
|
||||
if(res2)
|
||||
{
|
||||
BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
|
||||
boost::throw_exception(thread_resource_error());
|
||||
}
|
||||
}
|
||||
~condition_variable_any()
|
||||
{
|
||||
BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
|
||||
BOOST_VERIFY(!pthread_cond_destroy(&cond));
|
||||
}
|
||||
|
||||
template<typename lock_type>
|
||||
void wait(lock_type& m)
|
||||
{
|
||||
int res=0;
|
||||
{
|
||||
detail::interruption_checker check_for_interruption(&cond);
|
||||
{
|
||||
boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
|
||||
m.unlock();
|
||||
res=pthread_cond_wait(&cond,&internal_mutex);
|
||||
}
|
||||
m.lock();
|
||||
}
|
||||
if(res)
|
||||
{
|
||||
boost::throw_exception(condition_error());
|
||||
}
|
||||
}
|
||||
|
||||
template<typename lock_type,typename predicate_type>
|
||||
void wait(lock_type& m,predicate_type pred)
|
||||
{
|
||||
while(!pred()) wait(m);
|
||||
}
|
||||
|
||||
template<typename lock_type>
|
||||
bool timed_wait(lock_type& m,boost::system_time const& wait_until)
|
||||
{
|
||||
struct timespec const timeout=detail::get_timespec(wait_until);
|
||||
int res=0;
|
||||
{
|
||||
detail::interruption_checker check_for_interruption(&cond);
|
||||
{
|
||||
boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
|
||||
m.unlock();
|
||||
res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout);
|
||||
}
|
||||
m.lock();
|
||||
}
|
||||
if(res==ETIMEDOUT)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if(res)
|
||||
{
|
||||
boost::throw_exception(condition_error());
|
||||
}
|
||||
return true;
|
||||
}
|
||||
template<typename lock_type>
|
||||
bool timed_wait(lock_type& m,xtime const& wait_until)
|
||||
{
|
||||
return timed_wait(m,system_time(wait_until));
|
||||
}
|
||||
|
||||
template<typename lock_type,typename duration_type>
|
||||
bool timed_wait(lock_type& m,duration_type const& wait_duration)
|
||||
{
|
||||
return timed_wait(m,get_system_time()+wait_duration);
|
||||
}
|
||||
|
||||
template<typename lock_type,typename predicate_type>
|
||||
bool timed_wait(lock_type& m,boost::system_time const& wait_until,predicate_type pred)
|
||||
{
|
||||
while (!pred())
|
||||
{
|
||||
if(!timed_wait(m, wait_until))
|
||||
return pred();
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename lock_type,typename predicate_type>
|
||||
bool timed_wait(lock_type& m,xtime const& wait_until,predicate_type pred)
|
||||
{
|
||||
return timed_wait(m,system_time(wait_until),pred);
|
||||
}
|
||||
|
||||
template<typename lock_type,typename duration_type,typename predicate_type>
|
||||
bool timed_wait(lock_type& m,duration_type const& wait_duration,predicate_type pred)
|
||||
{
|
||||
return timed_wait(m,get_system_time()+wait_duration,pred);
|
||||
}
|
||||
|
||||
void notify_one()
|
||||
{
|
||||
boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
|
||||
BOOST_VERIFY(!pthread_cond_signal(&cond));
|
||||
}
|
||||
|
||||
void notify_all()
|
||||
{
|
||||
boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
|
||||
BOOST_VERIFY(!pthread_cond_broadcast(&cond));
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#include <boost/config/abi_suffix.hpp>
|
||||
|
||||
#endif
|
||||
@@ -1,99 +0,0 @@
|
||||
#ifndef BOOST_THREAD_PTHREAD_CONDITION_VARIABLE_FWD_HPP
|
||||
#define BOOST_THREAD_PTHREAD_CONDITION_VARIABLE_FWD_HPP
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// (C) Copyright 2007-8 Anthony Williams
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
#include <boost/throw_exception.hpp>
|
||||
#include <pthread.h>
|
||||
#include <boost/thread/mutex.hpp>
|
||||
#include <boost/thread/locks.hpp>
|
||||
#include <boost/thread/thread_time.hpp>
|
||||
#include <boost/thread/xtime.hpp>
|
||||
|
||||
#include <boost/config/abi_prefix.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
class condition_variable
|
||||
{
|
||||
private:
|
||||
pthread_cond_t cond;
|
||||
|
||||
condition_variable(condition_variable&);
|
||||
condition_variable& operator=(condition_variable&);
|
||||
|
||||
public:
|
||||
condition_variable()
|
||||
{
|
||||
int const res=pthread_cond_init(&cond,NULL);
|
||||
if(res)
|
||||
{
|
||||
boost::throw_exception(thread_resource_error());
|
||||
}
|
||||
}
|
||||
~condition_variable()
|
||||
{
|
||||
BOOST_VERIFY(!pthread_cond_destroy(&cond));
|
||||
}
|
||||
|
||||
void wait(unique_lock<mutex>& m);
|
||||
|
||||
template<typename predicate_type>
|
||||
void wait(unique_lock<mutex>& m,predicate_type pred)
|
||||
{
|
||||
while(!pred()) wait(m);
|
||||
}
|
||||
|
||||
inline bool timed_wait(unique_lock<mutex>& m,
|
||||
boost::system_time const& wait_until);
|
||||
bool timed_wait(unique_lock<mutex>& m,xtime const& wait_until)
|
||||
{
|
||||
return timed_wait(m,system_time(wait_until));
|
||||
}
|
||||
|
||||
template<typename duration_type>
|
||||
bool timed_wait(unique_lock<mutex>& m,duration_type const& wait_duration)
|
||||
{
|
||||
return timed_wait(m,get_system_time()+wait_duration);
|
||||
}
|
||||
|
||||
template<typename predicate_type>
|
||||
bool timed_wait(unique_lock<mutex>& m,boost::system_time const& wait_until,predicate_type pred)
|
||||
{
|
||||
while (!pred())
|
||||
{
|
||||
if(!timed_wait(m, wait_until))
|
||||
return pred();
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename predicate_type>
|
||||
bool timed_wait(unique_lock<mutex>& m,xtime const& wait_until,predicate_type pred)
|
||||
{
|
||||
return timed_wait(m,system_time(wait_until),pred);
|
||||
}
|
||||
|
||||
template<typename duration_type,typename predicate_type>
|
||||
bool timed_wait(unique_lock<mutex>& m,duration_type const& wait_duration,predicate_type pred)
|
||||
{
|
||||
return timed_wait(m,get_system_time()+wait_duration,pred);
|
||||
}
|
||||
|
||||
typedef pthread_cond_t* native_handle_type;
|
||||
native_handle_type native_handle()
|
||||
{
|
||||
return &cond;
|
||||
}
|
||||
|
||||
void notify_one();
|
||||
void notify_all();
|
||||
};
|
||||
}
|
||||
|
||||
#include <boost/config/abi_suffix.hpp>
|
||||
|
||||
#endif
|
||||
@@ -1,222 +0,0 @@
|
||||
#ifndef BOOST_THREAD_PTHREAD_MUTEX_HPP
|
||||
#define BOOST_THREAD_PTHREAD_MUTEX_HPP
|
||||
// (C) Copyright 2007-8 Anthony Williams
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <pthread.h>
|
||||
#include <boost/utility.hpp>
|
||||
#include <boost/throw_exception.hpp>
|
||||
#include <boost/thread/exceptions.hpp>
|
||||
#include <boost/thread/locks.hpp>
|
||||
#include <boost/thread/thread_time.hpp>
|
||||
#include <boost/thread/xtime.hpp>
|
||||
#include <boost/assert.hpp>
|
||||
#include <errno.h>
|
||||
#include "timespec.hpp"
|
||||
#include "pthread_mutex_scoped_lock.hpp"
|
||||
|
||||
#ifdef _POSIX_TIMEOUTS
|
||||
#if _POSIX_TIMEOUTS >= 0
|
||||
#define BOOST_PTHREAD_HAS_TIMEDLOCK
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#include <boost/config/abi_prefix.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
class mutex
|
||||
{
|
||||
private:
|
||||
mutex(mutex const&);
|
||||
mutex& operator=(mutex const&);
|
||||
pthread_mutex_t m;
|
||||
public:
|
||||
mutex()
|
||||
{
|
||||
int const res=pthread_mutex_init(&m,NULL);
|
||||
if(res)
|
||||
{
|
||||
boost::throw_exception(thread_resource_error());
|
||||
}
|
||||
}
|
||||
~mutex()
|
||||
{
|
||||
BOOST_VERIFY(!pthread_mutex_destroy(&m));
|
||||
}
|
||||
|
||||
void lock()
|
||||
{
|
||||
int const res=pthread_mutex_lock(&m);
|
||||
if(res)
|
||||
{
|
||||
boost::throw_exception(lock_error(res));
|
||||
}
|
||||
}
|
||||
|
||||
void unlock()
|
||||
{
|
||||
BOOST_VERIFY(!pthread_mutex_unlock(&m));
|
||||
}
|
||||
|
||||
bool try_lock()
|
||||
{
|
||||
int const res=pthread_mutex_trylock(&m);
|
||||
if(res && (res!=EBUSY))
|
||||
{
|
||||
boost::throw_exception(lock_error(res));
|
||||
}
|
||||
|
||||
return !res;
|
||||
}
|
||||
|
||||
typedef pthread_mutex_t* native_handle_type;
|
||||
native_handle_type native_handle()
|
||||
{
|
||||
return &m;
|
||||
}
|
||||
|
||||
typedef unique_lock<mutex> scoped_lock;
|
||||
typedef detail::try_lock_wrapper<mutex> scoped_try_lock;
|
||||
};
|
||||
|
||||
typedef mutex try_mutex;
|
||||
|
||||
class timed_mutex
|
||||
{
|
||||
private:
|
||||
timed_mutex(timed_mutex const&);
|
||||
timed_mutex& operator=(timed_mutex const&);
|
||||
private:
|
||||
pthread_mutex_t m;
|
||||
#ifndef BOOST_PTHREAD_HAS_TIMEDLOCK
|
||||
pthread_cond_t cond;
|
||||
bool is_locked;
|
||||
#endif
|
||||
public:
|
||||
timed_mutex()
|
||||
{
|
||||
int const res=pthread_mutex_init(&m,NULL);
|
||||
if(res)
|
||||
{
|
||||
boost::throw_exception(thread_resource_error());
|
||||
}
|
||||
#ifndef BOOST_PTHREAD_HAS_TIMEDLOCK
|
||||
int const res2=pthread_cond_init(&cond,NULL);
|
||||
if(res2)
|
||||
{
|
||||
BOOST_VERIFY(!pthread_mutex_destroy(&m));
|
||||
boost::throw_exception(thread_resource_error());
|
||||
}
|
||||
is_locked=false;
|
||||
#endif
|
||||
}
|
||||
~timed_mutex()
|
||||
{
|
||||
BOOST_VERIFY(!pthread_mutex_destroy(&m));
|
||||
#ifndef BOOST_PTHREAD_HAS_TIMEDLOCK
|
||||
BOOST_VERIFY(!pthread_cond_destroy(&cond));
|
||||
#endif
|
||||
}
|
||||
|
||||
template<typename TimeDuration>
|
||||
bool timed_lock(TimeDuration const & relative_time)
|
||||
{
|
||||
return timed_lock(get_system_time()+relative_time);
|
||||
}
|
||||
bool timed_lock(boost::xtime const & absolute_time)
|
||||
{
|
||||
return timed_lock(system_time(absolute_time));
|
||||
}
|
||||
|
||||
#ifdef BOOST_PTHREAD_HAS_TIMEDLOCK
|
||||
void lock()
|
||||
{
|
||||
BOOST_VERIFY(!pthread_mutex_lock(&m));
|
||||
}
|
||||
|
||||
void unlock()
|
||||
{
|
||||
BOOST_VERIFY(!pthread_mutex_unlock(&m));
|
||||
}
|
||||
|
||||
bool try_lock()
|
||||
{
|
||||
int const res=pthread_mutex_trylock(&m);
|
||||
BOOST_ASSERT(!res || res==EBUSY);
|
||||
return !res;
|
||||
}
|
||||
bool timed_lock(system_time const & abs_time)
|
||||
{
|
||||
struct timespec const timeout=detail::get_timespec(abs_time);
|
||||
int const res=pthread_mutex_timedlock(&m,&timeout);
|
||||
BOOST_ASSERT(!res || res==ETIMEDOUT);
|
||||
return !res;
|
||||
}
|
||||
|
||||
typedef pthread_mutex_t* native_handle_type;
|
||||
native_handle_type native_handle()
|
||||
{
|
||||
return &m;
|
||||
}
|
||||
|
||||
#else
|
||||
void lock()
|
||||
{
|
||||
boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
|
||||
while(is_locked)
|
||||
{
|
||||
BOOST_VERIFY(!pthread_cond_wait(&cond,&m));
|
||||
}
|
||||
is_locked=true;
|
||||
}
|
||||
|
||||
void unlock()
|
||||
{
|
||||
boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
|
||||
is_locked=false;
|
||||
BOOST_VERIFY(!pthread_cond_signal(&cond));
|
||||
}
|
||||
|
||||
bool try_lock()
|
||||
{
|
||||
boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
|
||||
if(is_locked)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
is_locked=true;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool timed_lock(system_time const & abs_time)
|
||||
{
|
||||
struct timespec const timeout=detail::get_timespec(abs_time);
|
||||
boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
|
||||
while(is_locked)
|
||||
{
|
||||
int const cond_res=pthread_cond_timedwait(&cond,&m,&timeout);
|
||||
if(cond_res==ETIMEDOUT)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
BOOST_ASSERT(!cond_res);
|
||||
}
|
||||
is_locked=true;
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
|
||||
typedef unique_lock<timed_mutex> scoped_timed_lock;
|
||||
typedef detail::try_lock_wrapper<timed_mutex> scoped_try_lock;
|
||||
typedef scoped_timed_lock scoped_lock;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#include <boost/config/abi_suffix.hpp>
|
||||
|
||||
|
||||
#endif
|
||||
@@ -1,95 +0,0 @@
|
||||
#ifndef BOOST_THREAD_PTHREAD_ONCE_HPP
|
||||
#define BOOST_THREAD_PTHREAD_ONCE_HPP
|
||||
|
||||
// once.hpp
|
||||
//
|
||||
// (C) Copyright 2007-8 Anthony Williams
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/thread/detail/config.hpp>
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#include <pthread.h>
|
||||
#include <boost/assert.hpp>
|
||||
#include "pthread_mutex_scoped_lock.hpp"
|
||||
#include <boost/thread/pthread/pthread_mutex_scoped_lock.hpp>
|
||||
#include <boost/cstdint.hpp>
|
||||
|
||||
#include <boost/config/abi_prefix.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
|
||||
struct once_flag
|
||||
{
|
||||
boost::uintmax_t epoch;
|
||||
};
|
||||
|
||||
namespace detail
|
||||
{
|
||||
BOOST_THREAD_DECL boost::uintmax_t& get_once_per_thread_epoch();
|
||||
BOOST_THREAD_DECL extern boost::uintmax_t once_global_epoch;
|
||||
BOOST_THREAD_DECL extern pthread_mutex_t once_epoch_mutex;
|
||||
BOOST_THREAD_DECL extern pthread_cond_t once_epoch_cv;
|
||||
}
|
||||
|
||||
#define BOOST_ONCE_INITIAL_FLAG_VALUE 0
|
||||
#define BOOST_ONCE_INIT {BOOST_ONCE_INITIAL_FLAG_VALUE}
|
||||
|
||||
|
||||
// Based on Mike Burrows fast_pthread_once algorithm as described in
|
||||
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2444.html
|
||||
template<typename Function>
|
||||
void call_once(once_flag& flag,Function f)
|
||||
{
|
||||
static boost::uintmax_t const uninitialized_flag=BOOST_ONCE_INITIAL_FLAG_VALUE;
|
||||
static boost::uintmax_t const being_initialized=uninitialized_flag+1;
|
||||
boost::uintmax_t const epoch=flag.epoch;
|
||||
boost::uintmax_t& this_thread_epoch=detail::get_once_per_thread_epoch();
|
||||
|
||||
if(epoch<this_thread_epoch)
|
||||
{
|
||||
pthread::pthread_mutex_scoped_lock lk(&detail::once_epoch_mutex);
|
||||
|
||||
while(flag.epoch<=being_initialized)
|
||||
{
|
||||
if(flag.epoch==uninitialized_flag)
|
||||
{
|
||||
flag.epoch=being_initialized;
|
||||
#ifndef BOOST_NO_EXCEPTIONS
|
||||
try
|
||||
{
|
||||
#endif
|
||||
pthread::pthread_mutex_scoped_unlock relocker(&detail::once_epoch_mutex);
|
||||
f();
|
||||
#ifndef BOOST_NO_EXCEPTIONS
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
flag.epoch=uninitialized_flag;
|
||||
BOOST_VERIFY(!pthread_cond_broadcast(&detail::once_epoch_cv));
|
||||
throw;
|
||||
}
|
||||
#endif
|
||||
flag.epoch=--detail::once_global_epoch;
|
||||
BOOST_VERIFY(!pthread_cond_broadcast(&detail::once_epoch_cv));
|
||||
}
|
||||
else
|
||||
{
|
||||
while(flag.epoch==being_initialized)
|
||||
{
|
||||
BOOST_VERIFY(!pthread_cond_wait(&detail::once_epoch_cv,&detail::once_epoch_mutex));
|
||||
}
|
||||
}
|
||||
}
|
||||
this_thread_epoch=detail::once_global_epoch;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#include <boost/config/abi_suffix.hpp>
|
||||
|
||||
#endif
|
||||
@@ -1,54 +0,0 @@
|
||||
#ifndef BOOST_PTHREAD_MUTEX_SCOPED_LOCK_HPP
|
||||
#define BOOST_PTHREAD_MUTEX_SCOPED_LOCK_HPP
|
||||
// (C) Copyright 2007-8 Anthony Williams
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <pthread.h>
|
||||
#include <boost/assert.hpp>
|
||||
|
||||
#include <boost/config/abi_prefix.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace pthread
|
||||
{
|
||||
class pthread_mutex_scoped_lock
|
||||
{
|
||||
pthread_mutex_t* m;
|
||||
public:
|
||||
explicit pthread_mutex_scoped_lock(pthread_mutex_t* m_):
|
||||
m(m_)
|
||||
{
|
||||
BOOST_VERIFY(!pthread_mutex_lock(m));
|
||||
}
|
||||
~pthread_mutex_scoped_lock()
|
||||
{
|
||||
BOOST_VERIFY(!pthread_mutex_unlock(m));
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
class pthread_mutex_scoped_unlock
|
||||
{
|
||||
pthread_mutex_t* m;
|
||||
public:
|
||||
explicit pthread_mutex_scoped_unlock(pthread_mutex_t* m_):
|
||||
m(m_)
|
||||
{
|
||||
BOOST_VERIFY(!pthread_mutex_unlock(m));
|
||||
}
|
||||
~pthread_mutex_scoped_unlock()
|
||||
{
|
||||
BOOST_VERIFY(!pthread_mutex_lock(m));
|
||||
}
|
||||
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
#include <boost/config/abi_suffix.hpp>
|
||||
|
||||
#endif
|
||||
@@ -1,345 +0,0 @@
|
||||
#ifndef BOOST_THREAD_PTHREAD_RECURSIVE_MUTEX_HPP
|
||||
#define BOOST_THREAD_PTHREAD_RECURSIVE_MUTEX_HPP
|
||||
// (C) Copyright 2007-8 Anthony Williams
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <pthread.h>
|
||||
#include <boost/utility.hpp>
|
||||
#include <boost/throw_exception.hpp>
|
||||
#include <boost/thread/exceptions.hpp>
|
||||
#include <boost/thread/locks.hpp>
|
||||
#include <boost/thread/thread_time.hpp>
|
||||
#include <boost/assert.hpp>
|
||||
#ifndef _WIN32
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
#include <boost/date_time/posix_time/conversion.hpp>
|
||||
#include <errno.h>
|
||||
#include "timespec.hpp"
|
||||
#include "pthread_mutex_scoped_lock.hpp"
|
||||
|
||||
#ifdef _POSIX_TIMEOUTS
|
||||
#if _POSIX_TIMEOUTS >= 0
|
||||
#define BOOST_PTHREAD_HAS_TIMEDLOCK
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_PTHREAD_HAS_MUTEXATTR_SETTYPE) && defined(BOOST_PTHREAD_HAS_TIMEDLOCK)
|
||||
#define BOOST_USE_PTHREAD_RECURSIVE_TIMEDLOCK
|
||||
#endif
|
||||
|
||||
#include <boost/config/abi_prefix.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
class recursive_mutex
|
||||
{
|
||||
private:
|
||||
recursive_mutex(recursive_mutex const&);
|
||||
recursive_mutex& operator=(recursive_mutex const&);
|
||||
pthread_mutex_t m;
|
||||
#ifndef BOOST_PTHREAD_HAS_MUTEXATTR_SETTYPE
|
||||
pthread_cond_t cond;
|
||||
bool is_locked;
|
||||
pthread_t owner;
|
||||
unsigned count;
|
||||
#endif
|
||||
public:
|
||||
recursive_mutex()
|
||||
{
|
||||
#ifdef BOOST_PTHREAD_HAS_MUTEXATTR_SETTYPE
|
||||
pthread_mutexattr_t attr;
|
||||
|
||||
int const init_attr_res=pthread_mutexattr_init(&attr);
|
||||
if(init_attr_res)
|
||||
{
|
||||
boost::throw_exception(thread_resource_error());
|
||||
}
|
||||
int const set_attr_res=pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE);
|
||||
if(set_attr_res)
|
||||
{
|
||||
BOOST_VERIFY(!pthread_mutexattr_destroy(&attr));
|
||||
boost::throw_exception(thread_resource_error());
|
||||
}
|
||||
|
||||
int const res=pthread_mutex_init(&m,&attr);
|
||||
if(res)
|
||||
{
|
||||
BOOST_VERIFY(!pthread_mutexattr_destroy(&attr));
|
||||
boost::throw_exception(thread_resource_error());
|
||||
}
|
||||
BOOST_VERIFY(!pthread_mutexattr_destroy(&attr));
|
||||
#else
|
||||
int const res=pthread_mutex_init(&m,NULL);
|
||||
if(res)
|
||||
{
|
||||
boost::throw_exception(thread_resource_error());
|
||||
}
|
||||
int const res2=pthread_cond_init(&cond,NULL);
|
||||
if(res2)
|
||||
{
|
||||
BOOST_VERIFY(!pthread_mutex_destroy(&m));
|
||||
boost::throw_exception(thread_resource_error());
|
||||
}
|
||||
is_locked=false;
|
||||
count=0;
|
||||
#endif
|
||||
}
|
||||
~recursive_mutex()
|
||||
{
|
||||
BOOST_VERIFY(!pthread_mutex_destroy(&m));
|
||||
#ifndef BOOST_PTHREAD_HAS_MUTEXATTR_SETTYPE
|
||||
BOOST_VERIFY(!pthread_cond_destroy(&cond));
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef BOOST_PTHREAD_HAS_MUTEXATTR_SETTYPE
|
||||
void lock()
|
||||
{
|
||||
BOOST_VERIFY(!pthread_mutex_lock(&m));
|
||||
}
|
||||
|
||||
void unlock()
|
||||
{
|
||||
BOOST_VERIFY(!pthread_mutex_unlock(&m));
|
||||
}
|
||||
|
||||
bool try_lock()
|
||||
{
|
||||
int const res=pthread_mutex_trylock(&m);
|
||||
BOOST_ASSERT(!res || res==EBUSY);
|
||||
return !res;
|
||||
}
|
||||
typedef pthread_mutex_t* native_handle_type;
|
||||
native_handle_type native_handle()
|
||||
{
|
||||
return &m;
|
||||
}
|
||||
|
||||
#else
|
||||
void lock()
|
||||
{
|
||||
boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
|
||||
if(is_locked && pthread_equal(owner,pthread_self()))
|
||||
{
|
||||
++count;
|
||||
return;
|
||||
}
|
||||
|
||||
while(is_locked)
|
||||
{
|
||||
BOOST_VERIFY(!pthread_cond_wait(&cond,&m));
|
||||
}
|
||||
is_locked=true;
|
||||
++count;
|
||||
owner=pthread_self();
|
||||
}
|
||||
|
||||
void unlock()
|
||||
{
|
||||
boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
|
||||
if(!--count)
|
||||
{
|
||||
is_locked=false;
|
||||
}
|
||||
BOOST_VERIFY(!pthread_cond_signal(&cond));
|
||||
}
|
||||
|
||||
bool try_lock()
|
||||
{
|
||||
boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
|
||||
if(is_locked && !pthread_equal(owner,pthread_self()))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
is_locked=true;
|
||||
++count;
|
||||
owner=pthread_self();
|
||||
return true;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
typedef unique_lock<recursive_mutex> scoped_lock;
|
||||
typedef detail::try_lock_wrapper<recursive_mutex> scoped_try_lock;
|
||||
};
|
||||
|
||||
typedef recursive_mutex recursive_try_mutex;
|
||||
|
||||
class recursive_timed_mutex
|
||||
{
|
||||
private:
|
||||
recursive_timed_mutex(recursive_timed_mutex const&);
|
||||
recursive_timed_mutex& operator=(recursive_timed_mutex const&);
|
||||
private:
|
||||
pthread_mutex_t m;
|
||||
#ifndef BOOST_USE_PTHREAD_RECURSIVE_TIMEDLOCK
|
||||
pthread_cond_t cond;
|
||||
bool is_locked;
|
||||
pthread_t owner;
|
||||
unsigned count;
|
||||
#endif
|
||||
public:
|
||||
recursive_timed_mutex()
|
||||
{
|
||||
#ifdef BOOST_USE_PTHREAD_RECURSIVE_TIMEDLOCK
|
||||
pthread_mutexattr_t attr;
|
||||
|
||||
int const init_attr_res=pthread_mutexattr_init(&attr);
|
||||
if(init_attr_res)
|
||||
{
|
||||
boost::throw_exception(thread_resource_error());
|
||||
}
|
||||
int const set_attr_res=pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE);
|
||||
if(set_attr_res)
|
||||
{
|
||||
boost::throw_exception(thread_resource_error());
|
||||
}
|
||||
|
||||
int const res=pthread_mutex_init(&m,&attr);
|
||||
if(res)
|
||||
{
|
||||
BOOST_VERIFY(!pthread_mutexattr_destroy(&attr));
|
||||
boost::throw_exception(thread_resource_error());
|
||||
}
|
||||
BOOST_VERIFY(!pthread_mutexattr_destroy(&attr));
|
||||
#else
|
||||
int const res=pthread_mutex_init(&m,NULL);
|
||||
if(res)
|
||||
{
|
||||
boost::throw_exception(thread_resource_error());
|
||||
}
|
||||
int const res2=pthread_cond_init(&cond,NULL);
|
||||
if(res2)
|
||||
{
|
||||
BOOST_VERIFY(!pthread_mutex_destroy(&m));
|
||||
boost::throw_exception(thread_resource_error());
|
||||
}
|
||||
is_locked=false;
|
||||
count=0;
|
||||
#endif
|
||||
}
|
||||
~recursive_timed_mutex()
|
||||
{
|
||||
BOOST_VERIFY(!pthread_mutex_destroy(&m));
|
||||
#ifndef BOOST_USE_PTHREAD_RECURSIVE_TIMEDLOCK
|
||||
BOOST_VERIFY(!pthread_cond_destroy(&cond));
|
||||
#endif
|
||||
}
|
||||
|
||||
template<typename TimeDuration>
|
||||
bool timed_lock(TimeDuration const & relative_time)
|
||||
{
|
||||
return timed_lock(get_system_time()+relative_time);
|
||||
}
|
||||
|
||||
#ifdef BOOST_USE_PTHREAD_RECURSIVE_TIMEDLOCK
|
||||
void lock()
|
||||
{
|
||||
BOOST_VERIFY(!pthread_mutex_lock(&m));
|
||||
}
|
||||
|
||||
void unlock()
|
||||
{
|
||||
BOOST_VERIFY(!pthread_mutex_unlock(&m));
|
||||
}
|
||||
|
||||
bool try_lock()
|
||||
{
|
||||
int const res=pthread_mutex_trylock(&m);
|
||||
BOOST_ASSERT(!res || res==EBUSY);
|
||||
return !res;
|
||||
}
|
||||
bool timed_lock(system_time const & abs_time)
|
||||
{
|
||||
struct timespec const timeout=detail::get_timespec(abs_time);
|
||||
int const res=pthread_mutex_timedlock(&m,&timeout);
|
||||
BOOST_ASSERT(!res || res==ETIMEDOUT);
|
||||
return !res;
|
||||
}
|
||||
|
||||
typedef pthread_mutex_t* native_handle_type;
|
||||
native_handle_type native_handle()
|
||||
{
|
||||
return &m;
|
||||
}
|
||||
|
||||
#else
|
||||
void lock()
|
||||
{
|
||||
boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
|
||||
if(is_locked && pthread_equal(owner,pthread_self()))
|
||||
{
|
||||
++count;
|
||||
return;
|
||||
}
|
||||
|
||||
while(is_locked)
|
||||
{
|
||||
BOOST_VERIFY(!pthread_cond_wait(&cond,&m));
|
||||
}
|
||||
is_locked=true;
|
||||
++count;
|
||||
owner=pthread_self();
|
||||
}
|
||||
|
||||
void unlock()
|
||||
{
|
||||
boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
|
||||
if(!--count)
|
||||
{
|
||||
is_locked=false;
|
||||
}
|
||||
BOOST_VERIFY(!pthread_cond_signal(&cond));
|
||||
}
|
||||
|
||||
bool try_lock()
|
||||
{
|
||||
boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
|
||||
if(is_locked && !pthread_equal(owner,pthread_self()))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
is_locked=true;
|
||||
++count;
|
||||
owner=pthread_self();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool timed_lock(system_time const & abs_time)
|
||||
{
|
||||
struct timespec const timeout=detail::get_timespec(abs_time);
|
||||
boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
|
||||
if(is_locked && pthread_equal(owner,pthread_self()))
|
||||
{
|
||||
++count;
|
||||
return true;
|
||||
}
|
||||
while(is_locked)
|
||||
{
|
||||
int const cond_res=pthread_cond_timedwait(&cond,&m,&timeout);
|
||||
if(cond_res==ETIMEDOUT)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
BOOST_ASSERT(!cond_res);
|
||||
}
|
||||
is_locked=true;
|
||||
++count;
|
||||
owner=pthread_self();
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
|
||||
typedef unique_lock<recursive_timed_mutex> scoped_timed_lock;
|
||||
typedef detail::try_lock_wrapper<recursive_timed_mutex> scoped_try_lock;
|
||||
typedef scoped_timed_lock scoped_lock;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#include <boost/config/abi_suffix.hpp>
|
||||
|
||||
#endif
|
||||
@@ -1,303 +0,0 @@
|
||||
#ifndef BOOST_THREAD_PTHREAD_SHARED_MUTEX_HPP
|
||||
#define BOOST_THREAD_PTHREAD_SHARED_MUTEX_HPP
|
||||
|
||||
// (C) Copyright 2006-8 Anthony Williams
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/thread/mutex.hpp>
|
||||
#include <boost/thread/condition_variable.hpp>
|
||||
#include <boost/thread/detail/thread_interruption.hpp>
|
||||
|
||||
#include <boost/config/abi_prefix.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
class shared_mutex
|
||||
{
|
||||
private:
|
||||
struct state_data
|
||||
{
|
||||
unsigned shared_count;
|
||||
bool exclusive;
|
||||
bool upgrade;
|
||||
bool exclusive_waiting_blocked;
|
||||
};
|
||||
|
||||
|
||||
|
||||
state_data state;
|
||||
boost::mutex state_change;
|
||||
boost::condition_variable shared_cond;
|
||||
boost::condition_variable exclusive_cond;
|
||||
boost::condition_variable upgrade_cond;
|
||||
|
||||
void release_waiters()
|
||||
{
|
||||
exclusive_cond.notify_one();
|
||||
shared_cond.notify_all();
|
||||
}
|
||||
|
||||
|
||||
public:
|
||||
shared_mutex()
|
||||
{
|
||||
state_data state_={0,0,0,0};
|
||||
state=state_;
|
||||
}
|
||||
|
||||
~shared_mutex()
|
||||
{
|
||||
}
|
||||
|
||||
void lock_shared()
|
||||
{
|
||||
boost::this_thread::disable_interruption do_not_disturb;
|
||||
boost::mutex::scoped_lock lk(state_change);
|
||||
|
||||
while(state.exclusive || state.exclusive_waiting_blocked)
|
||||
{
|
||||
shared_cond.wait(lk);
|
||||
}
|
||||
++state.shared_count;
|
||||
}
|
||||
|
||||
bool try_lock_shared()
|
||||
{
|
||||
boost::mutex::scoped_lock lk(state_change);
|
||||
|
||||
if(state.exclusive || state.exclusive_waiting_blocked)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
else
|
||||
{
|
||||
++state.shared_count;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
bool timed_lock_shared(system_time const& timeout)
|
||||
{
|
||||
boost::this_thread::disable_interruption do_not_disturb;
|
||||
boost::mutex::scoped_lock lk(state_change);
|
||||
|
||||
while(state.exclusive || state.exclusive_waiting_blocked)
|
||||
{
|
||||
if(!shared_cond.timed_wait(lk,timeout))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
++state.shared_count;
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename TimeDuration>
|
||||
bool timed_lock_shared(TimeDuration const & relative_time)
|
||||
{
|
||||
return timed_lock_shared(get_system_time()+relative_time);
|
||||
}
|
||||
|
||||
void unlock_shared()
|
||||
{
|
||||
boost::mutex::scoped_lock lk(state_change);
|
||||
bool const last_reader=!--state.shared_count;
|
||||
|
||||
if(last_reader)
|
||||
{
|
||||
if(state.upgrade)
|
||||
{
|
||||
state.upgrade=false;
|
||||
state.exclusive=true;
|
||||
upgrade_cond.notify_one();
|
||||
}
|
||||
else
|
||||
{
|
||||
state.exclusive_waiting_blocked=false;
|
||||
}
|
||||
release_waiters();
|
||||
}
|
||||
}
|
||||
|
||||
void lock()
|
||||
{
|
||||
boost::this_thread::disable_interruption do_not_disturb;
|
||||
boost::mutex::scoped_lock lk(state_change);
|
||||
|
||||
while(state.shared_count || state.exclusive)
|
||||
{
|
||||
state.exclusive_waiting_blocked=true;
|
||||
exclusive_cond.wait(lk);
|
||||
}
|
||||
state.exclusive=true;
|
||||
}
|
||||
|
||||
bool timed_lock(system_time const& timeout)
|
||||
{
|
||||
boost::this_thread::disable_interruption do_not_disturb;
|
||||
boost::mutex::scoped_lock lk(state_change);
|
||||
|
||||
while(state.shared_count || state.exclusive)
|
||||
{
|
||||
state.exclusive_waiting_blocked=true;
|
||||
if(!exclusive_cond.timed_wait(lk,timeout))
|
||||
{
|
||||
if(state.shared_count || state.exclusive)
|
||||
{
|
||||
state.exclusive_waiting_blocked=false;
|
||||
exclusive_cond.notify_one();
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
state.exclusive=true;
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename TimeDuration>
|
||||
bool timed_lock(TimeDuration const & relative_time)
|
||||
{
|
||||
return timed_lock(get_system_time()+relative_time);
|
||||
}
|
||||
|
||||
bool try_lock()
|
||||
{
|
||||
boost::mutex::scoped_lock lk(state_change);
|
||||
|
||||
if(state.shared_count || state.exclusive)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
else
|
||||
{
|
||||
state.exclusive=true;
|
||||
return true;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void unlock()
|
||||
{
|
||||
boost::mutex::scoped_lock lk(state_change);
|
||||
state.exclusive=false;
|
||||
state.exclusive_waiting_blocked=false;
|
||||
release_waiters();
|
||||
}
|
||||
|
||||
void lock_upgrade()
|
||||
{
|
||||
boost::this_thread::disable_interruption do_not_disturb;
|
||||
boost::mutex::scoped_lock lk(state_change);
|
||||
while(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
|
||||
{
|
||||
shared_cond.wait(lk);
|
||||
}
|
||||
++state.shared_count;
|
||||
state.upgrade=true;
|
||||
}
|
||||
|
||||
bool timed_lock_upgrade(system_time const& timeout)
|
||||
{
|
||||
boost::this_thread::disable_interruption do_not_disturb;
|
||||
boost::mutex::scoped_lock lk(state_change);
|
||||
while(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
|
||||
{
|
||||
if(!shared_cond.timed_wait(lk,timeout))
|
||||
{
|
||||
if(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
++state.shared_count;
|
||||
state.upgrade=true;
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename TimeDuration>
|
||||
bool timed_lock_upgrade(TimeDuration const & relative_time)
|
||||
{
|
||||
return timed_lock_upgrade(get_system_time()+relative_time);
|
||||
}
|
||||
|
||||
bool try_lock_upgrade()
|
||||
{
|
||||
boost::mutex::scoped_lock lk(state_change);
|
||||
if(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
else
|
||||
{
|
||||
++state.shared_count;
|
||||
state.upgrade=true;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
void unlock_upgrade()
|
||||
{
|
||||
boost::mutex::scoped_lock lk(state_change);
|
||||
state.upgrade=false;
|
||||
bool const last_reader=!--state.shared_count;
|
||||
|
||||
if(last_reader)
|
||||
{
|
||||
state.exclusive_waiting_blocked=false;
|
||||
release_waiters();
|
||||
}
|
||||
}
|
||||
|
||||
void unlock_upgrade_and_lock()
|
||||
{
|
||||
boost::this_thread::disable_interruption do_not_disturb;
|
||||
boost::mutex::scoped_lock lk(state_change);
|
||||
--state.shared_count;
|
||||
while(state.shared_count)
|
||||
{
|
||||
upgrade_cond.wait(lk);
|
||||
}
|
||||
state.upgrade=false;
|
||||
state.exclusive=true;
|
||||
}
|
||||
|
||||
void unlock_and_lock_upgrade()
|
||||
{
|
||||
boost::mutex::scoped_lock lk(state_change);
|
||||
state.exclusive=false;
|
||||
state.upgrade=true;
|
||||
++state.shared_count;
|
||||
state.exclusive_waiting_blocked=false;
|
||||
release_waiters();
|
||||
}
|
||||
|
||||
void unlock_and_lock_shared()
|
||||
{
|
||||
boost::mutex::scoped_lock lk(state_change);
|
||||
state.exclusive=false;
|
||||
++state.shared_count;
|
||||
state.exclusive_waiting_blocked=false;
|
||||
release_waiters();
|
||||
}
|
||||
|
||||
void unlock_upgrade_and_lock_shared()
|
||||
{
|
||||
boost::mutex::scoped_lock lk(state_change);
|
||||
state.upgrade=false;
|
||||
state.exclusive_waiting_blocked=false;
|
||||
release_waiters();
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
#include <boost/config/abi_suffix.hpp>
|
||||
|
||||
#endif
|
||||
@@ -1,129 +0,0 @@
|
||||
#ifndef BOOST_THREAD_PTHREAD_THREAD_DATA_HPP
|
||||
#define BOOST_THREAD_PTHREAD_THREAD_DATA_HPP
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// (C) Copyright 2007 Anthony Williams
|
||||
|
||||
#include <boost/thread/detail/config.hpp>
|
||||
#include <boost/thread/exceptions.hpp>
|
||||
#include <boost/shared_ptr.hpp>
|
||||
#include <boost/enable_shared_from_this.hpp>
|
||||
#include <boost/thread/mutex.hpp>
|
||||
#include <boost/optional.hpp>
|
||||
#include <pthread.h>
|
||||
#include "condition_variable_fwd.hpp"
|
||||
#include <map>
|
||||
|
||||
#include <boost/config/abi_prefix.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
class thread;
|
||||
|
||||
namespace detail
|
||||
{
|
||||
struct tss_cleanup_function;
|
||||
struct thread_exit_callback_node;
|
||||
struct tss_data_node
|
||||
{
|
||||
boost::shared_ptr<boost::detail::tss_cleanup_function> func;
|
||||
void* value;
|
||||
|
||||
tss_data_node(boost::shared_ptr<boost::detail::tss_cleanup_function> func_,
|
||||
void* value_):
|
||||
func(func_),value(value_)
|
||||
{}
|
||||
};
|
||||
|
||||
struct thread_data_base;
|
||||
typedef boost::shared_ptr<thread_data_base> thread_data_ptr;
|
||||
|
||||
struct BOOST_THREAD_DECL thread_data_base:
|
||||
enable_shared_from_this<thread_data_base>
|
||||
{
|
||||
thread_data_ptr self;
|
||||
pthread_t thread_handle;
|
||||
boost::mutex data_mutex;
|
||||
boost::condition_variable done_condition;
|
||||
boost::mutex sleep_mutex;
|
||||
boost::condition_variable sleep_condition;
|
||||
bool done;
|
||||
bool join_started;
|
||||
bool joined;
|
||||
boost::detail::thread_exit_callback_node* thread_exit_callbacks;
|
||||
std::map<void const*,boost::detail::tss_data_node> tss_data;
|
||||
bool interrupt_enabled;
|
||||
bool interrupt_requested;
|
||||
pthread_cond_t* current_cond;
|
||||
|
||||
thread_data_base():
|
||||
done(false),join_started(false),joined(false),
|
||||
thread_exit_callbacks(0),
|
||||
interrupt_enabled(true),
|
||||
interrupt_requested(false),
|
||||
current_cond(0)
|
||||
{}
|
||||
virtual ~thread_data_base();
|
||||
|
||||
typedef pthread_t native_handle_type;
|
||||
|
||||
virtual void run()=0;
|
||||
};
|
||||
|
||||
BOOST_THREAD_DECL thread_data_base* get_current_thread_data();
|
||||
|
||||
class interruption_checker
|
||||
{
|
||||
thread_data_base* const thread_info;
|
||||
|
||||
void check_for_interruption()
|
||||
{
|
||||
if(thread_info->interrupt_requested)
|
||||
{
|
||||
thread_info->interrupt_requested=false;
|
||||
throw thread_interrupted();
|
||||
}
|
||||
}
|
||||
|
||||
void operator=(interruption_checker&);
|
||||
public:
|
||||
explicit interruption_checker(pthread_cond_t* cond):
|
||||
thread_info(detail::get_current_thread_data())
|
||||
{
|
||||
if(thread_info && thread_info->interrupt_enabled)
|
||||
{
|
||||
lock_guard<mutex> guard(thread_info->data_mutex);
|
||||
check_for_interruption();
|
||||
thread_info->current_cond=cond;
|
||||
}
|
||||
}
|
||||
~interruption_checker()
|
||||
{
|
||||
if(thread_info && thread_info->interrupt_enabled)
|
||||
{
|
||||
lock_guard<mutex> guard(thread_info->data_mutex);
|
||||
thread_info->current_cond=NULL;
|
||||
check_for_interruption();
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
namespace this_thread
|
||||
{
|
||||
void BOOST_THREAD_DECL yield();
|
||||
|
||||
void BOOST_THREAD_DECL sleep(system_time const& abs_time);
|
||||
|
||||
template<typename TimeDuration>
|
||||
inline void sleep(TimeDuration const& rel_time)
|
||||
{
|
||||
this_thread::sleep(get_system_time()+rel_time);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#include <boost/config/abi_suffix.hpp>
|
||||
|
||||
#endif
|
||||
@@ -1,242 +0,0 @@
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// (C) Copyright 2008 Anthony Williams
|
||||
#ifndef THREAD_HEAP_ALLOC_PTHREAD_HPP
|
||||
#define THREAD_HEAP_ALLOC_PTHREAD_HPP
|
||||
|
||||
#include <boost/config/abi_prefix.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace detail
|
||||
{
|
||||
template<typename T>
|
||||
inline T* heap_new()
|
||||
{
|
||||
return new T();
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_RVALUE_REFERENCES
|
||||
template<typename T,typename A1>
|
||||
inline T* heap_new(A1&& a1)
|
||||
{
|
||||
return new T(static_cast<A1&&>(a1));
|
||||
}
|
||||
template<typename T,typename A1,typename A2>
|
||||
inline T* heap_new(A1&& a1,A2&& a2)
|
||||
{
|
||||
return new T(static_cast<A1&&>(a1),static_cast<A2&&>(a2));
|
||||
}
|
||||
template<typename T,typename A1,typename A2,typename A3>
|
||||
inline T* heap_new(A1&& a1,A2&& a2,A3&& a3)
|
||||
{
|
||||
return new T(static_cast<A1&&>(a1),static_cast<A2&&>(a2),
|
||||
static_cast<A3&&>(a3));
|
||||
}
|
||||
template<typename T,typename A1,typename A2,typename A3,typename A4>
|
||||
inline T* heap_new(A1&& a1,A2&& a2,A3&& a3,A4&& a4)
|
||||
{
|
||||
return new T(static_cast<A1&&>(a1),static_cast<A2&&>(a2),
|
||||
static_cast<A3&&>(a3),static_cast<A4&&>(a4));
|
||||
}
|
||||
#else
|
||||
template<typename T,typename A1>
|
||||
inline T* heap_new_impl(A1 a1)
|
||||
{
|
||||
return new T(a1);
|
||||
}
|
||||
template<typename T,typename A1,typename A2>
|
||||
inline T* heap_new_impl(A1 a1,A2 a2)
|
||||
{
|
||||
return new T(a1,a2);
|
||||
}
|
||||
template<typename T,typename A1,typename A2,typename A3>
|
||||
inline T* heap_new_impl(A1 a1,A2 a2,A3 a3)
|
||||
{
|
||||
return new T(a1,a2,a3);
|
||||
}
|
||||
template<typename T,typename A1,typename A2,typename A3,typename A4>
|
||||
inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4)
|
||||
{
|
||||
return new T(a1,a2,a3,a4);
|
||||
}
|
||||
|
||||
template<typename T,typename A1>
|
||||
inline T* heap_new(A1 const& a1)
|
||||
{
|
||||
return heap_new_impl<T,A1 const&>(a1);
|
||||
}
|
||||
template<typename T,typename A1>
|
||||
inline T* heap_new(A1& a1)
|
||||
{
|
||||
return heap_new_impl<T,A1&>(a1);
|
||||
}
|
||||
|
||||
template<typename T,typename A1,typename A2>
|
||||
inline T* heap_new(A1 const& a1,A2 const& a2)
|
||||
{
|
||||
return heap_new_impl<T,A1 const&,A2 const&>(a1,a2);
|
||||
}
|
||||
template<typename T,typename A1,typename A2>
|
||||
inline T* heap_new(A1& a1,A2 const& a2)
|
||||
{
|
||||
return heap_new_impl<T,A1&,A2 const&>(a1,a2);
|
||||
}
|
||||
template<typename T,typename A1,typename A2>
|
||||
inline T* heap_new(A1 const& a1,A2& a2)
|
||||
{
|
||||
return heap_new_impl<T,A1 const&,A2&>(a1,a2);
|
||||
}
|
||||
template<typename T,typename A1,typename A2>
|
||||
inline T* heap_new(A1& a1,A2& a2)
|
||||
{
|
||||
return heap_new_impl<T,A1&,A2&>(a1,a2);
|
||||
}
|
||||
|
||||
template<typename T,typename A1,typename A2,typename A3>
|
||||
inline T* heap_new(A1 const& a1,A2 const& a2,A3 const& a3)
|
||||
{
|
||||
return heap_new_impl<T,A1 const&,A2 const&,A3 const&>(a1,a2,a3);
|
||||
}
|
||||
template<typename T,typename A1,typename A2,typename A3>
|
||||
inline T* heap_new(A1& a1,A2 const& a2,A3 const& a3)
|
||||
{
|
||||
return heap_new_impl<T,A1&,A2 const&,A3 const&>(a1,a2,a3);
|
||||
}
|
||||
template<typename T,typename A1,typename A2,typename A3>
|
||||
inline T* heap_new(A1 const& a1,A2& a2,A3 const& a3)
|
||||
{
|
||||
return heap_new_impl<T,A1 const&,A2&,A3 const&>(a1,a2,a3);
|
||||
}
|
||||
template<typename T,typename A1,typename A2,typename A3>
|
||||
inline T* heap_new(A1& a1,A2& a2,A3 const& a3)
|
||||
{
|
||||
return heap_new_impl<T,A1&,A2&,A3 const&>(a1,a2,a3);
|
||||
}
|
||||
|
||||
template<typename T,typename A1,typename A2,typename A3>
|
||||
inline T* heap_new(A1 const& a1,A2 const& a2,A3& a3)
|
||||
{
|
||||
return heap_new_impl<T,A1 const&,A2 const&,A3&>(a1,a2,a3);
|
||||
}
|
||||
template<typename T,typename A1,typename A2,typename A3>
|
||||
inline T* heap_new(A1& a1,A2 const& a2,A3& a3)
|
||||
{
|
||||
return heap_new_impl<T,A1&,A2 const&,A3&>(a1,a2,a3);
|
||||
}
|
||||
template<typename T,typename A1,typename A2,typename A3>
|
||||
inline T* heap_new(A1 const& a1,A2& a2,A3& a3)
|
||||
{
|
||||
return heap_new_impl<T,A1 const&,A2&,A3&>(a1,a2,a3);
|
||||
}
|
||||
template<typename T,typename A1,typename A2,typename A3>
|
||||
inline T* heap_new(A1& a1,A2& a2,A3& a3)
|
||||
{
|
||||
return heap_new_impl<T,A1&,A2&,A3&>(a1,a2,a3);
|
||||
}
|
||||
|
||||
template<typename T,typename A1,typename A2,typename A3,typename A4>
|
||||
inline T* heap_new(A1 const& a1,A2 const& a2,A3 const& a3,A4 const& a4)
|
||||
{
|
||||
return heap_new_impl<T,A1 const&,A2 const&,A3 const&,A4 const&>(a1,a2,a3,a4);
|
||||
}
|
||||
template<typename T,typename A1,typename A2,typename A3,typename A4>
|
||||
inline T* heap_new(A1& a1,A2 const& a2,A3 const& a3,A4 const& a4)
|
||||
{
|
||||
return heap_new_impl<T,A1&,A2 const&,A3 const&,A4 const&>(a1,a2,a3,a4);
|
||||
}
|
||||
template<typename T,typename A1,typename A2,typename A3,typename A4>
|
||||
inline T* heap_new(A1 const& a1,A2& a2,A3 const& a3,A4 const& a4)
|
||||
{
|
||||
return heap_new_impl<T,A1 const&,A2&,A3 const&,A4 const&>(a1,a2,a3,a4);
|
||||
}
|
||||
template<typename T,typename A1,typename A2,typename A3,typename A4>
|
||||
inline T* heap_new(A1& a1,A2& a2,A3 const& a3,A4 const& a4)
|
||||
{
|
||||
return heap_new_impl<T,A1&,A2&,A3 const&,A4 const&>(a1,a2,a3,a4);
|
||||
}
|
||||
|
||||
template<typename T,typename A1,typename A2,typename A3,typename A4>
|
||||
inline T* heap_new(A1 const& a1,A2 const& a2,A3& a3,A4 const& a4)
|
||||
{
|
||||
return heap_new_impl<T,A1 const&,A2 const&,A3&,A4 const&>(a1,a2,a3,a4);
|
||||
}
|
||||
template<typename T,typename A1,typename A2,typename A3,typename A4>
|
||||
inline T* heap_new(A1& a1,A2 const& a2,A3& a3,A4 const& a4)
|
||||
{
|
||||
return heap_new_impl<T,A1&,A2 const&,A3&,A4 const&>(a1,a2,a3,a4);
|
||||
}
|
||||
template<typename T,typename A1,typename A2,typename A3,typename A4>
|
||||
inline T* heap_new(A1 const& a1,A2& a2,A3& a3,A4 const& a4)
|
||||
{
|
||||
return heap_new_impl<T,A1 const&,A2&,A3&,A4 const&>(a1,a2,a3,a4);
|
||||
}
|
||||
template<typename T,typename A1,typename A2,typename A3,typename A4>
|
||||
inline T* heap_new(A1& a1,A2& a2,A3& a3,A4 const& a4)
|
||||
{
|
||||
return heap_new_impl<T,A1&,A2&,A3&,A4 const&>(a1,a2,a3,a4);
|
||||
}
|
||||
template<typename T,typename A1,typename A2,typename A3,typename A4>
|
||||
inline T* heap_new(A1 const& a1,A2 const& a2,A3 const& a3,A4& a4)
|
||||
{
|
||||
return heap_new_impl<T,A1 const&,A2 const&,A3 const&,A4&>(a1,a2,a3,a4);
|
||||
}
|
||||
template<typename T,typename A1,typename A2,typename A3,typename A4>
|
||||
inline T* heap_new(A1& a1,A2 const& a2,A3 const& a3,A4& a4)
|
||||
{
|
||||
return heap_new_impl<T,A1&,A2 const&,A3 const&,A4&>(a1,a2,a3,a4);
|
||||
}
|
||||
template<typename T,typename A1,typename A2,typename A3,typename A4>
|
||||
inline T* heap_new(A1 const& a1,A2& a2,A3 const& a3,A4& a4)
|
||||
{
|
||||
return heap_new_impl<T,A1 const&,A2&,A3 const&,A4&>(a1,a2,a3,a4);
|
||||
}
|
||||
template<typename T,typename A1,typename A2,typename A3,typename A4>
|
||||
inline T* heap_new(A1& a1,A2& a2,A3 const& a3,A4& a4)
|
||||
{
|
||||
return heap_new_impl<T,A1&,A2&,A3 const&,A4&>(a1,a2,a3,a4);
|
||||
}
|
||||
|
||||
template<typename T,typename A1,typename A2,typename A3,typename A4>
|
||||
inline T* heap_new(A1 const& a1,A2 const& a2,A3& a3,A4& a4)
|
||||
{
|
||||
return heap_new_impl<T,A1 const&,A2 const&,A3&,A4&>(a1,a2,a3,a4);
|
||||
}
|
||||
template<typename T,typename A1,typename A2,typename A3,typename A4>
|
||||
inline T* heap_new(A1& a1,A2 const& a2,A3& a3,A4& a4)
|
||||
{
|
||||
return heap_new_impl<T,A1&,A2 const&,A3&,A4&>(a1,a2,a3,a4);
|
||||
}
|
||||
template<typename T,typename A1,typename A2,typename A3,typename A4>
|
||||
inline T* heap_new(A1 const& a1,A2& a2,A3& a3,A4& a4)
|
||||
{
|
||||
return heap_new_impl<T,A1 const&,A2&,A3&,A4&>(a1,a2,a3,a4);
|
||||
}
|
||||
template<typename T,typename A1,typename A2,typename A3,typename A4>
|
||||
inline T* heap_new(A1& a1,A2& a2,A3& a3,A4& a4)
|
||||
{
|
||||
return heap_new_impl<T,A1&,A2&,A3&,A4&>(a1,a2,a3,a4);
|
||||
}
|
||||
|
||||
#endif
|
||||
template<typename T>
|
||||
inline void heap_delete(T* data)
|
||||
{
|
||||
delete data;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
struct do_heap_delete
|
||||
{
|
||||
void operator()(T* data) const
|
||||
{
|
||||
detail::heap_delete(data);
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
#include <boost/config/abi_suffix.hpp>
|
||||
|
||||
#endif
|
||||
@@ -1,36 +0,0 @@
|
||||
#ifndef BOOST_THREAD_PTHREAD_TIMESPEC_HPP
|
||||
#define BOOST_THREAD_PTHREAD_TIMESPEC_HPP
|
||||
// (C) Copyright 2007-8 Anthony Williams
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/thread/thread_time.hpp>
|
||||
#include <boost/date_time/posix_time/conversion.hpp>
|
||||
#include <pthread.h>
|
||||
#ifndef _WIN32
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
#include <boost/config/abi_prefix.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace detail
|
||||
{
|
||||
inline struct timespec get_timespec(boost::system_time const& abs_time)
|
||||
{
|
||||
struct timespec timeout={0,0};
|
||||
boost::posix_time::time_duration const time_since_epoch=abs_time-boost::posix_time::from_time_t(0);
|
||||
|
||||
timeout.tv_sec=time_since_epoch.total_seconds();
|
||||
timeout.tv_nsec=(long)(time_since_epoch.fractional_seconds()*(1000000000l/time_since_epoch.ticks_per_second()));
|
||||
return timeout;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#include <boost/config/abi_suffix.hpp>
|
||||
|
||||
#endif
|
||||
@@ -1,21 +1,160 @@
|
||||
#ifndef BOOST_THREAD_RECURSIVE_MUTEX_HPP
|
||||
#define BOOST_THREAD_RECURSIVE_MUTEX_HPP
|
||||
|
||||
// recursive_mutex.hpp
|
||||
// Copyright (C) 2001
|
||||
// William E. Kempf
|
||||
//
|
||||
// (C) Copyright 2007 Anthony Williams
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// 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/detail/platform.hpp>
|
||||
#if defined(BOOST_THREAD_PLATFORM_WIN32)
|
||||
#include <boost/thread/win32/recursive_mutex.hpp>
|
||||
#elif defined(BOOST_THREAD_PLATFORM_PTHREAD)
|
||||
#include <boost/thread/pthread/recursive_mutex.hpp>
|
||||
#else
|
||||
#error "Boost threads unavailable on this platform"
|
||||
#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 {
|
||||
|
||||
struct xtime;
|
||||
|
||||
class recursive_mutex : private noncopyable
|
||||
{
|
||||
public:
|
||||
friend class detail::thread::lock_ops<recursive_mutex>;
|
||||
|
||||
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)
|
||||
void* 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::lock_ops<recursive_try_mutex>;
|
||||
|
||||
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)
|
||||
void* 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::lock_ops<recursive_timed_mutex>;
|
||||
|
||||
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)
|
||||
void* 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
|
||||
|
||||
@@ -1,21 +0,0 @@
|
||||
#ifndef BOOST_THREAD_SHARED_MUTEX_HPP
|
||||
#define BOOST_THREAD_SHARED_MUTEX_HPP
|
||||
|
||||
// shared_mutex.hpp
|
||||
//
|
||||
// (C) Copyright 2007 Anthony Williams
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/thread/detail/platform.hpp>
|
||||
#if defined(BOOST_THREAD_PLATFORM_WIN32)
|
||||
#include <boost/thread/win32/shared_mutex.hpp>
|
||||
#elif defined(BOOST_THREAD_PLATFORM_PTHREAD)
|
||||
#include <boost/thread/pthread/shared_mutex.hpp>
|
||||
#else
|
||||
#error "Boost threads unavailable on this platform"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -1,27 +1,84 @@
|
||||
#ifndef BOOST_THREAD_THREAD_HPP
|
||||
#define BOOST_THREAD_THREAD_HPP
|
||||
|
||||
// thread.hpp
|
||||
// Copyright (C) 2001
|
||||
// William E. Kempf
|
||||
//
|
||||
// (C) Copyright 2007-8 Anthony Williams
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// 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/detail/platform.hpp>
|
||||
#ifndef BOOST_THREAD_WEK070601_HPP
|
||||
#define BOOST_THREAD_WEK070601_HPP
|
||||
|
||||
#if defined(BOOST_THREAD_PLATFORM_WIN32)
|
||||
#include <boost/thread/win32/thread_data.hpp>
|
||||
#elif defined(BOOST_THREAD_PLATFORM_PTHREAD)
|
||||
#include <boost/thread/pthread/thread_data.hpp>
|
||||
#else
|
||||
#error "Boost threads unavailable on this platform"
|
||||
#include <boost/config.hpp>
|
||||
#ifndef BOOST_HAS_THREADS
|
||||
# error Thread support is unavailable!
|
||||
#endif
|
||||
|
||||
#include <boost/thread/detail/thread.hpp>
|
||||
#include <boost/thread/detail/thread_interruption.hpp>
|
||||
#include <boost/thread/detail/thread_group.hpp>
|
||||
|
||||
#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)
|
||||
void* 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
|
||||
|
||||
@@ -1,50 +0,0 @@
|
||||
#ifndef BOOST_THREAD_TIME_HPP
|
||||
#define BOOST_THREAD_TIME_HPP
|
||||
// (C) Copyright 2007 Anthony Williams
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/date_time/microsec_time_clock.hpp>
|
||||
#include <boost/date_time/posix_time/posix_time_types.hpp>
|
||||
|
||||
#include <boost/config/abi_prefix.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
typedef boost::posix_time::ptime system_time;
|
||||
|
||||
inline system_time get_system_time()
|
||||
{
|
||||
return boost::date_time::microsec_clock<system_time>::universal_time();
|
||||
}
|
||||
|
||||
namespace detail
|
||||
{
|
||||
inline system_time get_system_time_sentinel()
|
||||
{
|
||||
return system_time(boost::posix_time::pos_infin);
|
||||
}
|
||||
|
||||
inline unsigned long get_milliseconds_until(system_time const& target_time)
|
||||
{
|
||||
if(target_time.is_pos_infinity())
|
||||
{
|
||||
return ~(unsigned long)0;
|
||||
}
|
||||
system_time const now=get_system_time();
|
||||
if(target_time<=now)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
return static_cast<unsigned long>((target_time-now).total_milliseconds()+1);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#include <boost/config/abi_suffix.hpp>
|
||||
|
||||
#endif
|
||||
@@ -1,113 +1,72 @@
|
||||
#ifndef BOOST_THREAD_TSS_HPP
|
||||
#define BOOST_THREAD_TSS_HPP
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// (C) Copyright 2007-8 Anthony Williams
|
||||
// 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/detail/config.hpp>
|
||||
#include <boost/shared_ptr.hpp>
|
||||
#include <boost/thread/detail/thread_heap_alloc.hpp>
|
||||
#ifndef BOOST_TSS_WEK070601_HPP
|
||||
#define BOOST_TSS_WEK070601_HPP
|
||||
|
||||
#include <boost/config/abi_prefix.hpp>
|
||||
#include <boost/config.hpp>
|
||||
#ifndef BOOST_HAS_THREADS
|
||||
# error Thread support is unavailable!
|
||||
#endif
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace detail
|
||||
{
|
||||
struct tss_cleanup_function
|
||||
#include <boost/utility.hpp>
|
||||
|
||||
#if defined(BOOST_HAS_PTHREADS)
|
||||
# include <pthread.h>
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
|
||||
namespace detail {
|
||||
class tss : private noncopyable
|
||||
{
|
||||
virtual ~tss_cleanup_function()
|
||||
{}
|
||||
|
||||
virtual void operator()(void* data)=0;
|
||||
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
|
||||
};
|
||||
|
||||
BOOST_THREAD_DECL void set_tss_data(void const* key,boost::shared_ptr<tss_cleanup_function> func,void* tss_data,bool cleanup_existing);
|
||||
BOOST_THREAD_DECL void* get_tss_data(void const* key);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
class thread_specific_ptr
|
||||
{
|
||||
private:
|
||||
thread_specific_ptr(thread_specific_ptr&);
|
||||
thread_specific_ptr& operator=(thread_specific_ptr&);
|
||||
template <typename T>
|
||||
class thread_specific_ptr : private noncopyable
|
||||
{
|
||||
public:
|
||||
thread_specific_ptr() : m_tss(&thread_specific_ptr<T>::cleanup) { }
|
||||
|
||||
struct delete_data:
|
||||
detail::tss_cleanup_function
|
||||
{
|
||||
void operator()(void* data)
|
||||
{
|
||||
delete static_cast<T*>(data);
|
||||
}
|
||||
};
|
||||
|
||||
struct run_custom_cleanup_function:
|
||||
detail::tss_cleanup_function
|
||||
{
|
||||
void (*cleanup_function)(T*);
|
||||
|
||||
explicit run_custom_cleanup_function(void (*cleanup_function_)(T*)):
|
||||
cleanup_function(cleanup_function_)
|
||||
{}
|
||||
|
||||
void operator()(void* data)
|
||||
{
|
||||
cleanup_function(static_cast<T*>(data));
|
||||
}
|
||||
};
|
||||
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); }
|
||||
|
||||
boost::shared_ptr<detail::tss_cleanup_function> cleanup;
|
||||
|
||||
public:
|
||||
typedef T element_type;
|
||||
|
||||
thread_specific_ptr():
|
||||
cleanup(detail::heap_new<delete_data>(),detail::do_heap_delete<delete_data>())
|
||||
{}
|
||||
explicit thread_specific_ptr(void (*func_)(T*))
|
||||
{
|
||||
if(func_)
|
||||
{
|
||||
cleanup.reset(detail::heap_new<run_custom_cleanup_function>(func_),detail::do_heap_delete<run_custom_cleanup_function>());
|
||||
}
|
||||
}
|
||||
~thread_specific_ptr()
|
||||
{
|
||||
detail::set_tss_data(this,boost::shared_ptr<detail::tss_cleanup_function>(),0,true);
|
||||
}
|
||||
mutable detail::tss m_tss;
|
||||
};
|
||||
|
||||
T* get() const
|
||||
{
|
||||
return static_cast<T*>(detail::get_tss_data(this));
|
||||
}
|
||||
T* operator->() const
|
||||
{
|
||||
return get();
|
||||
}
|
||||
T& operator*() const
|
||||
{
|
||||
return *get();
|
||||
}
|
||||
T* release()
|
||||
{
|
||||
T* const temp=get();
|
||||
detail::set_tss_data(this,boost::shared_ptr<detail::tss_cleanup_function>(),0,false);
|
||||
return temp;
|
||||
}
|
||||
void reset(T* new_value=0)
|
||||
{
|
||||
T* const current_value=get();
|
||||
if(current_value!=new_value)
|
||||
{
|
||||
detail::set_tss_data(this,cleanup,new_value,true);
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
} // namespace boost
|
||||
|
||||
#include <boost/config/abi_suffix.hpp>
|
||||
// Change Log:
|
||||
// 6 Jun 01 WEKEMPF Initial version.
|
||||
|
||||
#endif // BOOST_TSS_WEK070601_HPP
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,120 +0,0 @@
|
||||
#ifndef BOOST_BASIC_RECURSIVE_MUTEX_WIN32_HPP
|
||||
#define BOOST_BASIC_RECURSIVE_MUTEX_WIN32_HPP
|
||||
|
||||
// basic_recursive_mutex.hpp
|
||||
//
|
||||
// (C) Copyright 2006-8 Anthony Williams
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include "thread_primitives.hpp"
|
||||
#include "basic_timed_mutex.hpp"
|
||||
|
||||
#include <boost/config/abi_prefix.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace detail
|
||||
{
|
||||
template<typename underlying_mutex_type>
|
||||
struct basic_recursive_mutex_impl
|
||||
{
|
||||
long recursion_count;
|
||||
long locking_thread_id;
|
||||
underlying_mutex_type mutex;
|
||||
|
||||
void initialize()
|
||||
{
|
||||
recursion_count=0;
|
||||
locking_thread_id=0;
|
||||
mutex.initialize();
|
||||
}
|
||||
|
||||
void destroy()
|
||||
{
|
||||
mutex.destroy();
|
||||
}
|
||||
|
||||
bool try_lock()
|
||||
{
|
||||
long const current_thread_id=win32::GetCurrentThreadId();
|
||||
return try_recursive_lock(current_thread_id) || try_basic_lock(current_thread_id);
|
||||
}
|
||||
|
||||
void lock()
|
||||
{
|
||||
long const current_thread_id=win32::GetCurrentThreadId();
|
||||
if(!try_recursive_lock(current_thread_id))
|
||||
{
|
||||
mutex.lock();
|
||||
BOOST_INTERLOCKED_EXCHANGE(&locking_thread_id,current_thread_id);
|
||||
recursion_count=1;
|
||||
}
|
||||
}
|
||||
bool timed_lock(::boost::system_time const& target)
|
||||
{
|
||||
long const current_thread_id=win32::GetCurrentThreadId();
|
||||
return try_recursive_lock(current_thread_id) || try_timed_lock(current_thread_id,target);
|
||||
}
|
||||
template<typename Duration>
|
||||
bool timed_lock(Duration const& timeout)
|
||||
{
|
||||
return timed_lock(get_system_time()+timeout);
|
||||
}
|
||||
|
||||
void unlock()
|
||||
{
|
||||
if(!--recursion_count)
|
||||
{
|
||||
BOOST_INTERLOCKED_EXCHANGE(&locking_thread_id,0);
|
||||
mutex.unlock();
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
bool try_recursive_lock(long current_thread_id)
|
||||
{
|
||||
if(::boost::detail::interlocked_read_acquire(&locking_thread_id)==current_thread_id)
|
||||
{
|
||||
++recursion_count;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool try_basic_lock(long current_thread_id)
|
||||
{
|
||||
if(mutex.try_lock())
|
||||
{
|
||||
BOOST_INTERLOCKED_EXCHANGE(&locking_thread_id,current_thread_id);
|
||||
recursion_count=1;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool try_timed_lock(long current_thread_id,::boost::system_time const& target)
|
||||
{
|
||||
if(mutex.timed_lock(target))
|
||||
{
|
||||
BOOST_INTERLOCKED_EXCHANGE(&locking_thread_id,current_thread_id);
|
||||
recursion_count=1;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
typedef basic_recursive_mutex_impl<basic_timed_mutex> basic_recursive_mutex;
|
||||
typedef basic_recursive_mutex_impl<basic_timed_mutex> basic_recursive_timed_mutex;
|
||||
}
|
||||
}
|
||||
|
||||
#define BOOST_BASIC_RECURSIVE_MUTEX_INITIALIZER {0}
|
||||
|
||||
#include <boost/config/abi_suffix.hpp>
|
||||
|
||||
#endif
|
||||
@@ -1,209 +0,0 @@
|
||||
#ifndef BOOST_BASIC_TIMED_MUTEX_WIN32_HPP
|
||||
#define BOOST_BASIC_TIMED_MUTEX_WIN32_HPP
|
||||
|
||||
// basic_timed_mutex_win32.hpp
|
||||
//
|
||||
// (C) Copyright 2006-8 Anthony Williams
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
#include "thread_primitives.hpp"
|
||||
#include "interlocked_read.hpp"
|
||||
#include <boost/thread/thread_time.hpp>
|
||||
#include <boost/thread/xtime.hpp>
|
||||
#include <boost/detail/interlocked.hpp>
|
||||
|
||||
#include <boost/config/abi_prefix.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace detail
|
||||
{
|
||||
struct basic_timed_mutex
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(unsigned char,lock_flag_bit=31);
|
||||
BOOST_STATIC_CONSTANT(unsigned char,event_set_flag_bit=30);
|
||||
BOOST_STATIC_CONSTANT(long,lock_flag_value=1<<lock_flag_bit);
|
||||
BOOST_STATIC_CONSTANT(long,event_set_flag_value=1<<event_set_flag_bit);
|
||||
long active_count;
|
||||
void* event;
|
||||
|
||||
void initialize()
|
||||
{
|
||||
active_count=0;
|
||||
event=0;
|
||||
}
|
||||
|
||||
void destroy()
|
||||
{
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(push)
|
||||
#pragma warning(disable:4312)
|
||||
#endif
|
||||
void* const old_event=BOOST_INTERLOCKED_EXCHANGE_POINTER(&event,0);
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
if(old_event)
|
||||
{
|
||||
win32::CloseHandle(old_event);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
bool try_lock()
|
||||
{
|
||||
return !win32::interlocked_bit_test_and_set(&active_count,lock_flag_bit);
|
||||
}
|
||||
|
||||
void lock()
|
||||
{
|
||||
if(try_lock())
|
||||
{
|
||||
return;
|
||||
}
|
||||
long old_count=active_count;
|
||||
mark_waiting_and_try_lock(old_count);
|
||||
|
||||
if(old_count&lock_flag_value)
|
||||
{
|
||||
bool lock_acquired=false;
|
||||
void* const sem=get_event();
|
||||
|
||||
do
|
||||
{
|
||||
BOOST_VERIFY(win32::WaitForSingleObject(
|
||||
sem,::boost::detail::win32::infinite)==0);
|
||||
clear_waiting_and_try_lock(old_count);
|
||||
lock_acquired=!(old_count&lock_flag_value);
|
||||
}
|
||||
while(!lock_acquired);
|
||||
}
|
||||
}
|
||||
void mark_waiting_and_try_lock(long& old_count)
|
||||
{
|
||||
for(;;)
|
||||
{
|
||||
long const new_count=(old_count&lock_flag_value)?(old_count+1):(old_count|lock_flag_value);
|
||||
long const current=BOOST_INTERLOCKED_COMPARE_EXCHANGE(&active_count,new_count,old_count);
|
||||
if(current==old_count)
|
||||
{
|
||||
break;
|
||||
}
|
||||
old_count=current;
|
||||
}
|
||||
}
|
||||
|
||||
void clear_waiting_and_try_lock(long& old_count)
|
||||
{
|
||||
old_count&=~lock_flag_value;
|
||||
old_count|=event_set_flag_value;
|
||||
for(;;)
|
||||
{
|
||||
long const new_count=((old_count&lock_flag_value)?old_count:((old_count-1)|lock_flag_value))&~event_set_flag_value;
|
||||
long const current=BOOST_INTERLOCKED_COMPARE_EXCHANGE(&active_count,new_count,old_count);
|
||||
if(current==old_count)
|
||||
{
|
||||
break;
|
||||
}
|
||||
old_count=current;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
bool timed_lock(::boost::system_time const& wait_until)
|
||||
{
|
||||
if(try_lock())
|
||||
{
|
||||
return true;
|
||||
}
|
||||
long old_count=active_count;
|
||||
mark_waiting_and_try_lock(old_count);
|
||||
|
||||
if(old_count&lock_flag_value)
|
||||
{
|
||||
bool lock_acquired=false;
|
||||
void* const sem=get_event();
|
||||
|
||||
do
|
||||
{
|
||||
if(win32::WaitForSingleObject(sem,::boost::detail::get_milliseconds_until(wait_until))!=0)
|
||||
{
|
||||
BOOST_INTERLOCKED_DECREMENT(&active_count);
|
||||
return false;
|
||||
}
|
||||
clear_waiting_and_try_lock(old_count);
|
||||
lock_acquired=!(old_count&lock_flag_value);
|
||||
}
|
||||
while(!lock_acquired);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename Duration>
|
||||
bool timed_lock(Duration const& timeout)
|
||||
{
|
||||
return timed_lock(get_system_time()+timeout);
|
||||
}
|
||||
|
||||
bool timed_lock(boost::xtime const& timeout)
|
||||
{
|
||||
return timed_lock(system_time(timeout));
|
||||
}
|
||||
|
||||
void unlock()
|
||||
{
|
||||
long const offset=lock_flag_value;
|
||||
long const old_count=BOOST_INTERLOCKED_EXCHANGE_ADD(&active_count,lock_flag_value);
|
||||
if(!(old_count&event_set_flag_value) && (old_count>offset))
|
||||
{
|
||||
if(!win32::interlocked_bit_test_and_set(&active_count,event_set_flag_bit))
|
||||
{
|
||||
win32::SetEvent(get_event());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
void* get_event()
|
||||
{
|
||||
void* current_event=::boost::detail::interlocked_read_acquire(&event);
|
||||
|
||||
if(!current_event)
|
||||
{
|
||||
void* const new_event=win32::create_anonymous_event(win32::auto_reset_event,win32::event_initially_reset);
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(push)
|
||||
#pragma warning(disable:4311)
|
||||
#pragma warning(disable:4312)
|
||||
#endif
|
||||
void* const old_event=BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(&event,new_event,0);
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
if(old_event!=0)
|
||||
{
|
||||
win32::CloseHandle(new_event);
|
||||
return old_event;
|
||||
}
|
||||
else
|
||||
{
|
||||
return new_event;
|
||||
}
|
||||
}
|
||||
return current_event;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
#define BOOST_BASIC_TIMED_MUTEX_INITIALIZER {0}
|
||||
|
||||
#include <boost/config/abi_suffix.hpp>
|
||||
|
||||
#endif
|
||||
@@ -1,418 +0,0 @@
|
||||
#ifndef BOOST_THREAD_CONDITION_VARIABLE_WIN32_HPP
|
||||
#define BOOST_THREAD_CONDITION_VARIABLE_WIN32_HPP
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// (C) Copyright 2007-8 Anthony Williams
|
||||
|
||||
#include <boost/thread/mutex.hpp>
|
||||
#include "thread_primitives.hpp"
|
||||
#include <limits.h>
|
||||
#include <boost/assert.hpp>
|
||||
#include <algorithm>
|
||||
#include <boost/thread/thread.hpp>
|
||||
#include <boost/thread/thread_time.hpp>
|
||||
#include "interlocked_read.hpp"
|
||||
#include <boost/thread/xtime.hpp>
|
||||
#include <vector>
|
||||
#include <boost/intrusive_ptr.hpp>
|
||||
|
||||
#include <boost/config/abi_prefix.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace detail
|
||||
{
|
||||
class basic_cv_list_entry;
|
||||
void intrusive_ptr_add_ref(basic_cv_list_entry * p);
|
||||
void intrusive_ptr_release(basic_cv_list_entry * p);
|
||||
|
||||
class basic_cv_list_entry
|
||||
{
|
||||
private:
|
||||
detail::win32::handle_manager semaphore;
|
||||
detail::win32::handle_manager wake_sem;
|
||||
long waiters;
|
||||
bool notified;
|
||||
long references;
|
||||
|
||||
basic_cv_list_entry(basic_cv_list_entry&);
|
||||
void operator=(basic_cv_list_entry&);
|
||||
|
||||
public:
|
||||
explicit basic_cv_list_entry(detail::win32::handle_manager const& wake_sem_):
|
||||
semaphore(detail::win32::create_anonymous_semaphore(0,LONG_MAX)),
|
||||
wake_sem(wake_sem_.duplicate()),
|
||||
waiters(1),notified(false),references(0)
|
||||
{}
|
||||
|
||||
static bool no_waiters(boost::intrusive_ptr<basic_cv_list_entry> const& entry)
|
||||
{
|
||||
return !detail::interlocked_read_acquire(&entry->waiters);
|
||||
}
|
||||
|
||||
void add_waiter()
|
||||
{
|
||||
BOOST_INTERLOCKED_INCREMENT(&waiters);
|
||||
}
|
||||
|
||||
void remove_waiter()
|
||||
{
|
||||
BOOST_INTERLOCKED_DECREMENT(&waiters);
|
||||
}
|
||||
|
||||
void release(unsigned count_to_release)
|
||||
{
|
||||
notified=true;
|
||||
detail::win32::ReleaseSemaphore(semaphore,count_to_release,0);
|
||||
}
|
||||
|
||||
void release_waiters()
|
||||
{
|
||||
release(detail::interlocked_read_acquire(&waiters));
|
||||
}
|
||||
|
||||
bool is_notified() const
|
||||
{
|
||||
return notified;
|
||||
}
|
||||
|
||||
bool wait(timeout wait_until)
|
||||
{
|
||||
return this_thread::interruptible_wait(semaphore,wait_until);
|
||||
}
|
||||
|
||||
bool woken()
|
||||
{
|
||||
unsigned long const woken_result=detail::win32::WaitForSingleObject(wake_sem,0);
|
||||
BOOST_ASSERT((woken_result==detail::win32::timeout) || (woken_result==0));
|
||||
return woken_result==0;
|
||||
}
|
||||
|
||||
friend void intrusive_ptr_add_ref(basic_cv_list_entry * p);
|
||||
friend void intrusive_ptr_release(basic_cv_list_entry * p);
|
||||
};
|
||||
|
||||
inline void intrusive_ptr_add_ref(basic_cv_list_entry * p)
|
||||
{
|
||||
BOOST_INTERLOCKED_INCREMENT(&p->references);
|
||||
}
|
||||
|
||||
inline void intrusive_ptr_release(basic_cv_list_entry * p)
|
||||
{
|
||||
if(!BOOST_INTERLOCKED_DECREMENT(&p->references))
|
||||
{
|
||||
delete p;
|
||||
}
|
||||
}
|
||||
|
||||
class basic_condition_variable
|
||||
{
|
||||
boost::mutex internal_mutex;
|
||||
long total_count;
|
||||
unsigned active_generation_count;
|
||||
|
||||
typedef basic_cv_list_entry list_entry;
|
||||
|
||||
typedef boost::intrusive_ptr<list_entry> entry_ptr;
|
||||
typedef std::vector<entry_ptr> generation_list;
|
||||
|
||||
generation_list generations;
|
||||
detail::win32::handle_manager wake_sem;
|
||||
|
||||
void wake_waiters(long count_to_wake)
|
||||
{
|
||||
detail::interlocked_write_release(&total_count,total_count-count_to_wake);
|
||||
detail::win32::ReleaseSemaphore(wake_sem,count_to_wake,0);
|
||||
}
|
||||
|
||||
template<typename lock_type>
|
||||
struct relocker
|
||||
{
|
||||
lock_type& lock;
|
||||
bool unlocked;
|
||||
|
||||
relocker(lock_type& lock_):
|
||||
lock(lock_),unlocked(false)
|
||||
{}
|
||||
void unlock()
|
||||
{
|
||||
lock.unlock();
|
||||
unlocked=true;
|
||||
}
|
||||
~relocker()
|
||||
{
|
||||
if(unlocked)
|
||||
{
|
||||
lock.lock();
|
||||
}
|
||||
|
||||
}
|
||||
private:
|
||||
relocker(relocker&);
|
||||
void operator=(relocker&);
|
||||
};
|
||||
|
||||
|
||||
entry_ptr get_wait_entry()
|
||||
{
|
||||
boost::lock_guard<boost::mutex> internal_lock(internal_mutex);
|
||||
|
||||
if(!wake_sem)
|
||||
{
|
||||
wake_sem=detail::win32::create_anonymous_semaphore(0,LONG_MAX);
|
||||
BOOST_ASSERT(wake_sem);
|
||||
}
|
||||
|
||||
detail::interlocked_write_release(&total_count,total_count+1);
|
||||
if(generations.empty() || generations.back()->is_notified())
|
||||
{
|
||||
entry_ptr new_entry(new list_entry(wake_sem));
|
||||
generations.push_back(new_entry);
|
||||
return new_entry;
|
||||
}
|
||||
else
|
||||
{
|
||||
generations.back()->add_waiter();
|
||||
return generations.back();
|
||||
}
|
||||
}
|
||||
|
||||
struct entry_manager
|
||||
{
|
||||
entry_ptr const entry;
|
||||
|
||||
entry_manager(entry_ptr const& entry_):
|
||||
entry(entry_)
|
||||
{}
|
||||
|
||||
~entry_manager()
|
||||
{
|
||||
entry->remove_waiter();
|
||||
}
|
||||
|
||||
list_entry* operator->()
|
||||
{
|
||||
return entry.get();
|
||||
}
|
||||
|
||||
private:
|
||||
void operator=(entry_manager&);
|
||||
entry_manager(entry_manager&);
|
||||
};
|
||||
|
||||
|
||||
protected:
|
||||
template<typename lock_type>
|
||||
bool do_wait(lock_type& lock,timeout wait_until)
|
||||
{
|
||||
relocker<lock_type> locker(lock);
|
||||
|
||||
entry_manager entry(get_wait_entry());
|
||||
|
||||
locker.unlock();
|
||||
|
||||
bool woken=false;
|
||||
while(!woken)
|
||||
{
|
||||
if(!entry->wait(wait_until))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
woken=entry->woken();
|
||||
}
|
||||
return woken;
|
||||
}
|
||||
|
||||
template<typename lock_type,typename predicate_type>
|
||||
bool do_wait(lock_type& m,timeout const& wait_until,predicate_type pred)
|
||||
{
|
||||
while (!pred())
|
||||
{
|
||||
if(!do_wait(m, wait_until))
|
||||
return pred();
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
basic_condition_variable(const basic_condition_variable& other);
|
||||
basic_condition_variable& operator=(const basic_condition_variable& other);
|
||||
|
||||
public:
|
||||
basic_condition_variable():
|
||||
total_count(0),active_generation_count(0),wake_sem(0)
|
||||
{}
|
||||
|
||||
~basic_condition_variable()
|
||||
{}
|
||||
|
||||
void notify_one()
|
||||
{
|
||||
if(detail::interlocked_read_acquire(&total_count))
|
||||
{
|
||||
boost::lock_guard<boost::mutex> internal_lock(internal_mutex);
|
||||
if(!total_count)
|
||||
{
|
||||
return;
|
||||
}
|
||||
wake_waiters(1);
|
||||
|
||||
for(generation_list::iterator it=generations.begin(),
|
||||
end=generations.end();
|
||||
it!=end;++it)
|
||||
{
|
||||
(*it)->release(1);
|
||||
}
|
||||
generations.erase(std::remove_if(generations.begin(),generations.end(),&basic_cv_list_entry::no_waiters),generations.end());
|
||||
}
|
||||
}
|
||||
|
||||
void notify_all()
|
||||
{
|
||||
if(detail::interlocked_read_acquire(&total_count))
|
||||
{
|
||||
boost::lock_guard<boost::mutex> internal_lock(internal_mutex);
|
||||
if(!total_count)
|
||||
{
|
||||
return;
|
||||
}
|
||||
wake_waiters(total_count);
|
||||
for(generation_list::iterator it=generations.begin(),
|
||||
end=generations.end();
|
||||
it!=end;++it)
|
||||
{
|
||||
(*it)->release_waiters();
|
||||
}
|
||||
generations.clear();
|
||||
wake_sem=detail::win32::handle(0);
|
||||
}
|
||||
}
|
||||
|
||||
};
|
||||
}
|
||||
|
||||
class condition_variable:
|
||||
private detail::basic_condition_variable
|
||||
{
|
||||
private:
|
||||
condition_variable(condition_variable&);
|
||||
void operator=(condition_variable&);
|
||||
public:
|
||||
condition_variable()
|
||||
{}
|
||||
|
||||
using detail::basic_condition_variable::notify_one;
|
||||
using detail::basic_condition_variable::notify_all;
|
||||
|
||||
void wait(unique_lock<mutex>& m)
|
||||
{
|
||||
do_wait(m,detail::timeout::sentinel());
|
||||
}
|
||||
|
||||
template<typename predicate_type>
|
||||
void wait(unique_lock<mutex>& m,predicate_type pred)
|
||||
{
|
||||
while(!pred()) wait(m);
|
||||
}
|
||||
|
||||
|
||||
bool timed_wait(unique_lock<mutex>& m,boost::system_time const& wait_until)
|
||||
{
|
||||
return do_wait(m,wait_until);
|
||||
}
|
||||
|
||||
bool timed_wait(unique_lock<mutex>& m,boost::xtime const& wait_until)
|
||||
{
|
||||
return do_wait(m,system_time(wait_until));
|
||||
}
|
||||
template<typename duration_type>
|
||||
bool timed_wait(unique_lock<mutex>& m,duration_type const& wait_duration)
|
||||
{
|
||||
return do_wait(m,wait_duration.total_milliseconds());
|
||||
}
|
||||
|
||||
template<typename predicate_type>
|
||||
bool timed_wait(unique_lock<mutex>& m,boost::system_time const& wait_until,predicate_type pred)
|
||||
{
|
||||
return do_wait(m,wait_until,pred);
|
||||
}
|
||||
template<typename predicate_type>
|
||||
bool timed_wait(unique_lock<mutex>& m,boost::xtime const& wait_until,predicate_type pred)
|
||||
{
|
||||
return do_wait(m,system_time(wait_until),pred);
|
||||
}
|
||||
template<typename duration_type,typename predicate_type>
|
||||
bool timed_wait(unique_lock<mutex>& m,duration_type const& wait_duration,predicate_type pred)
|
||||
{
|
||||
return do_wait(m,wait_duration.total_milliseconds(),pred);
|
||||
}
|
||||
};
|
||||
|
||||
class condition_variable_any:
|
||||
private detail::basic_condition_variable
|
||||
{
|
||||
private:
|
||||
condition_variable_any(condition_variable_any&);
|
||||
void operator=(condition_variable_any&);
|
||||
public:
|
||||
condition_variable_any()
|
||||
{}
|
||||
|
||||
using detail::basic_condition_variable::notify_one;
|
||||
using detail::basic_condition_variable::notify_all;
|
||||
|
||||
template<typename lock_type>
|
||||
void wait(lock_type& m)
|
||||
{
|
||||
do_wait(m,detail::timeout::sentinel());
|
||||
}
|
||||
|
||||
template<typename lock_type,typename predicate_type>
|
||||
void wait(lock_type& m,predicate_type pred)
|
||||
{
|
||||
while(!pred()) wait(m);
|
||||
}
|
||||
|
||||
template<typename lock_type>
|
||||
bool timed_wait(lock_type& m,boost::system_time const& wait_until)
|
||||
{
|
||||
return do_wait(m,wait_until);
|
||||
}
|
||||
|
||||
template<typename lock_type>
|
||||
bool timed_wait(lock_type& m,boost::xtime const& wait_until)
|
||||
{
|
||||
return do_wait(m,system_time(wait_until));
|
||||
}
|
||||
|
||||
template<typename lock_type,typename duration_type>
|
||||
bool timed_wait(lock_type& m,duration_type const& wait_duration)
|
||||
{
|
||||
return do_wait(m,wait_duration.total_milliseconds());
|
||||
}
|
||||
|
||||
template<typename lock_type,typename predicate_type>
|
||||
bool timed_wait(lock_type& m,boost::system_time const& wait_until,predicate_type pred)
|
||||
{
|
||||
return do_wait(m,wait_until,pred);
|
||||
}
|
||||
|
||||
template<typename lock_type,typename predicate_type>
|
||||
bool timed_wait(lock_type& m,boost::xtime const& wait_until,predicate_type pred)
|
||||
{
|
||||
return do_wait(m,system_time(wait_until),pred);
|
||||
}
|
||||
|
||||
template<typename lock_type,typename duration_type,typename predicate_type>
|
||||
bool timed_wait(lock_type& m,duration_type const& wait_duration,predicate_type pred)
|
||||
{
|
||||
return do_wait(m,wait_duration.total_milliseconds(),pred);
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#include <boost/config/abi_suffix.hpp>
|
||||
|
||||
#endif
|
||||
@@ -1,80 +0,0 @@
|
||||
#ifndef BOOST_THREAD_DETAIL_INTERLOCKED_READ_WIN32_HPP
|
||||
#define BOOST_THREAD_DETAIL_INTERLOCKED_READ_WIN32_HPP
|
||||
|
||||
// interlocked_read_win32.hpp
|
||||
//
|
||||
// (C) Copyright 2005-8 Anthony Williams
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/detail/interlocked.hpp>
|
||||
|
||||
#include <boost/config/abi_prefix.hpp>
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
|
||||
extern "C" void _ReadWriteBarrier(void);
|
||||
#pragma intrinsic(_ReadWriteBarrier)
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace detail
|
||||
{
|
||||
inline long interlocked_read_acquire(long volatile* x)
|
||||
{
|
||||
long const res=*x;
|
||||
_ReadWriteBarrier();
|
||||
return res;
|
||||
}
|
||||
inline void* interlocked_read_acquire(void* volatile* x)
|
||||
{
|
||||
void* const res=*x;
|
||||
_ReadWriteBarrier();
|
||||
return res;
|
||||
}
|
||||
|
||||
inline void interlocked_write_release(long volatile* x,long value)
|
||||
{
|
||||
_ReadWriteBarrier();
|
||||
*x=value;
|
||||
}
|
||||
inline void interlocked_write_release(void* volatile* x,void* value)
|
||||
{
|
||||
_ReadWriteBarrier();
|
||||
*x=value;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace detail
|
||||
{
|
||||
inline long interlocked_read_acquire(long volatile* x)
|
||||
{
|
||||
return BOOST_INTERLOCKED_COMPARE_EXCHANGE(x,0,0);
|
||||
}
|
||||
inline void* interlocked_read_acquire(void* volatile* x)
|
||||
{
|
||||
return BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(x,0,0);
|
||||
}
|
||||
inline void interlocked_write_release(long volatile* x,long value)
|
||||
{
|
||||
BOOST_INTERLOCKED_EXCHANGE(x,value);
|
||||
}
|
||||
inline void interlocked_write_release(void* volatile* x,void* value)
|
||||
{
|
||||
BOOST_INTERLOCKED_EXCHANGE_POINTER(x,value);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#include <boost/config/abi_suffix.hpp>
|
||||
|
||||
#endif
|
||||
@@ -1,69 +0,0 @@
|
||||
#ifndef BOOST_THREAD_WIN32_MUTEX_HPP
|
||||
#define BOOST_THREAD_WIN32_MUTEX_HPP
|
||||
// (C) Copyright 2005-7 Anthony Williams
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include "basic_timed_mutex.hpp"
|
||||
#include <boost/utility.hpp>
|
||||
#include <boost/thread/exceptions.hpp>
|
||||
#include <boost/thread/locks.hpp>
|
||||
|
||||
#include <boost/config/abi_prefix.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace detail
|
||||
{
|
||||
typedef ::boost::detail::basic_timed_mutex underlying_mutex;
|
||||
}
|
||||
|
||||
class mutex:
|
||||
public ::boost::detail::underlying_mutex
|
||||
{
|
||||
private:
|
||||
mutex(mutex const&);
|
||||
mutex& operator=(mutex const&);
|
||||
public:
|
||||
mutex()
|
||||
{
|
||||
initialize();
|
||||
}
|
||||
~mutex()
|
||||
{
|
||||
destroy();
|
||||
}
|
||||
|
||||
typedef unique_lock<mutex> scoped_lock;
|
||||
typedef detail::try_lock_wrapper<mutex> scoped_try_lock;
|
||||
};
|
||||
|
||||
typedef mutex try_mutex;
|
||||
|
||||
class timed_mutex:
|
||||
public ::boost::detail::basic_timed_mutex
|
||||
{
|
||||
private:
|
||||
timed_mutex(timed_mutex const&);
|
||||
timed_mutex& operator=(timed_mutex const&);
|
||||
public:
|
||||
timed_mutex()
|
||||
{
|
||||
initialize();
|
||||
}
|
||||
|
||||
~timed_mutex()
|
||||
{
|
||||
destroy();
|
||||
}
|
||||
|
||||
typedef unique_lock<timed_mutex> scoped_timed_lock;
|
||||
typedef detail::try_lock_wrapper<timed_mutex> scoped_try_lock;
|
||||
typedef scoped_timed_lock scoped_lock;
|
||||
};
|
||||
}
|
||||
|
||||
#include <boost/config/abi_suffix.hpp>
|
||||
|
||||
#endif
|
||||
@@ -1,205 +0,0 @@
|
||||
#ifndef BOOST_THREAD_WIN32_ONCE_HPP
|
||||
#define BOOST_THREAD_WIN32_ONCE_HPP
|
||||
|
||||
// once.hpp
|
||||
//
|
||||
// (C) Copyright 2005-7 Anthony Williams
|
||||
// (C) Copyright 2005 John Maddock
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <cstring>
|
||||
#include <cstddef>
|
||||
#include <boost/assert.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/detail/interlocked.hpp>
|
||||
#include <boost/thread/win32/thread_primitives.hpp>
|
||||
#include <boost/thread/win32/interlocked_read.hpp>
|
||||
|
||||
#include <boost/config/abi_prefix.hpp>
|
||||
|
||||
#ifdef BOOST_NO_STDC_NAMESPACE
|
||||
namespace std
|
||||
{
|
||||
using ::memcpy;
|
||||
using ::ptrdiff_t;
|
||||
}
|
||||
#endif
|
||||
|
||||
namespace boost
|
||||
{
|
||||
struct once_flag
|
||||
{
|
||||
long status;
|
||||
long count;
|
||||
};
|
||||
|
||||
#define BOOST_ONCE_INIT {0,0}
|
||||
|
||||
namespace detail
|
||||
{
|
||||
#ifdef BOOST_NO_ANSI_APIS
|
||||
typedef wchar_t once_char_type;
|
||||
#else
|
||||
typedef char once_char_type;
|
||||
#endif
|
||||
unsigned const once_mutex_name_fixed_length=54;
|
||||
unsigned const once_mutex_name_length=once_mutex_name_fixed_length+
|
||||
sizeof(void*)*2+sizeof(unsigned long)*2+1;
|
||||
|
||||
template <class I>
|
||||
void int_to_string(I p, once_char_type* buf)
|
||||
{
|
||||
for(unsigned i=0; i < sizeof(I)*2; ++i,++buf)
|
||||
{
|
||||
#ifdef BOOST_NO_ANSI_APIS
|
||||
once_char_type const a=L'A';
|
||||
#else
|
||||
once_char_type const a='A';
|
||||
#endif
|
||||
*buf = a + static_cast<once_char_type>((p >> (i*4)) & 0x0f);
|
||||
}
|
||||
*buf = 0;
|
||||
}
|
||||
|
||||
inline void name_once_mutex(once_char_type* mutex_name,void* flag_address)
|
||||
{
|
||||
#ifdef BOOST_NO_ANSI_APIS
|
||||
static const once_char_type fixed_mutex_name[]=L"Local\\{C15730E2-145C-4c5e-B005-3BC753F42475}-once-flag";
|
||||
#else
|
||||
static const once_char_type fixed_mutex_name[]="Local\\{C15730E2-145C-4c5e-B005-3BC753F42475}-once-flag";
|
||||
#endif
|
||||
BOOST_STATIC_ASSERT(sizeof(fixed_mutex_name) ==
|
||||
(sizeof(once_char_type)*(once_mutex_name_fixed_length+1)));
|
||||
|
||||
std::memcpy(mutex_name,fixed_mutex_name,sizeof(fixed_mutex_name));
|
||||
detail::int_to_string(reinterpret_cast<std::ptrdiff_t>(flag_address),
|
||||
mutex_name + once_mutex_name_fixed_length);
|
||||
detail::int_to_string(win32::GetCurrentProcessId(),
|
||||
mutex_name + once_mutex_name_fixed_length + sizeof(void*)*2);
|
||||
}
|
||||
|
||||
inline void* open_once_event(once_char_type* mutex_name,void* flag_address)
|
||||
{
|
||||
if(!*mutex_name)
|
||||
{
|
||||
name_once_mutex(mutex_name,flag_address);
|
||||
}
|
||||
|
||||
#ifdef BOOST_NO_ANSI_APIS
|
||||
return ::boost::detail::win32::OpenEventW(
|
||||
#else
|
||||
return ::boost::detail::win32::OpenEventA(
|
||||
#endif
|
||||
::boost::detail::win32::synchronize |
|
||||
::boost::detail::win32::event_modify_state,
|
||||
false,
|
||||
mutex_name);
|
||||
}
|
||||
|
||||
inline void* create_once_event(once_char_type* mutex_name,void* flag_address)
|
||||
{
|
||||
if(!*mutex_name)
|
||||
{
|
||||
name_once_mutex(mutex_name,flag_address);
|
||||
}
|
||||
#ifdef BOOST_NO_ANSI_APIS
|
||||
return ::boost::detail::win32::CreateEventW(
|
||||
#else
|
||||
return ::boost::detail::win32::CreateEventA(
|
||||
#endif
|
||||
0,::boost::detail::win32::manual_reset_event,
|
||||
::boost::detail::win32::event_initially_reset,
|
||||
mutex_name);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template<typename Function>
|
||||
void call_once(once_flag& flag,Function f)
|
||||
{
|
||||
// Try for a quick win: if the procedure has already been called
|
||||
// just skip through:
|
||||
long const function_complete_flag_value=0xc15730e2;
|
||||
long const running_value=0x7f0725e3;
|
||||
long status;
|
||||
bool counted=false;
|
||||
detail::win32::handle_manager event_handle;
|
||||
detail::once_char_type mutex_name[detail::once_mutex_name_length];
|
||||
mutex_name[0]=0;
|
||||
|
||||
while((status=::boost::detail::interlocked_read_acquire(&flag.status))
|
||||
!=function_complete_flag_value)
|
||||
{
|
||||
status=BOOST_INTERLOCKED_COMPARE_EXCHANGE(&flag.status,running_value,0);
|
||||
if(!status)
|
||||
{
|
||||
try
|
||||
{
|
||||
if(!event_handle)
|
||||
{
|
||||
event_handle=detail::open_once_event(mutex_name,&flag);
|
||||
}
|
||||
if(event_handle)
|
||||
{
|
||||
::boost::detail::win32::ResetEvent(event_handle);
|
||||
}
|
||||
f();
|
||||
if(!counted)
|
||||
{
|
||||
BOOST_INTERLOCKED_INCREMENT(&flag.count);
|
||||
counted=true;
|
||||
}
|
||||
BOOST_INTERLOCKED_EXCHANGE(&flag.status,function_complete_flag_value);
|
||||
if(!event_handle &&
|
||||
(::boost::detail::interlocked_read_acquire(&flag.count)>1))
|
||||
{
|
||||
event_handle=detail::create_once_event(mutex_name,&flag);
|
||||
}
|
||||
if(event_handle)
|
||||
{
|
||||
::boost::detail::win32::SetEvent(event_handle);
|
||||
}
|
||||
break;
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
BOOST_INTERLOCKED_EXCHANGE(&flag.status,0);
|
||||
if(!event_handle)
|
||||
{
|
||||
event_handle=detail::open_once_event(mutex_name,&flag);
|
||||
}
|
||||
if(event_handle)
|
||||
{
|
||||
::boost::detail::win32::SetEvent(event_handle);
|
||||
}
|
||||
throw;
|
||||
}
|
||||
}
|
||||
|
||||
if(!counted)
|
||||
{
|
||||
BOOST_INTERLOCKED_INCREMENT(&flag.count);
|
||||
counted=true;
|
||||
status=::boost::detail::interlocked_read_acquire(&flag.status);
|
||||
if(status==function_complete_flag_value)
|
||||
{
|
||||
break;
|
||||
}
|
||||
if(!event_handle)
|
||||
{
|
||||
event_handle=detail::create_once_event(mutex_name,&flag);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObject(
|
||||
event_handle,::boost::detail::win32::infinite));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#include <boost/config/abi_suffix.hpp>
|
||||
|
||||
#endif
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user