|
|
Boost.ThreadsHeader <boost/thread.hpp> |
threadthread synopsisthread constructors
and destructorthread comparison
functionsthread modifier
functionsthread static functionsthread_groupthread_group
synopsisthread_group
constructors and destructorthread_group
modifier functionsboost::threadboost::thread_groupThe header <boost/thread.hpp> defines the classes thread and thread_group which are used to create, observe and manage threads and groups of threads.
threadThe thread class represents threads of execution, and provides
the functionality to create and manage threads within the Boost.Threads
library. See Definitions for a precise description
of "thread of execution", and for definitions of threading related
terms and of thread states such as "blocked".
A thread of execution has an initial function. For the program's initial
thread, the initial function is main(). For other threads, the
initial function is operator() of the function object passed to
the class thread constructor.
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.
A thread object has an associated state which is either "joinable" or "non-joinable".
Except as described below, the policy used by an implementation of Boost.Threads to schedule transitions between thread states is unspecified.
Note: 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 thread object which represents
the thread of execution. In particular, after a call to join(),
the thread of execution will no longer exist even though the thread
object continues to exist until the end of its normal lifetime. The converse
is also possible; if a thread object is destroyed without join()
having first been called, the thread of execution continues until its initial
function completes.
thread synopsis
namespace boost {
class thread : boost::noncopyable // Exposition only.
// Class thread meets the NonCopyable 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
thread constructors and
destructorthread();
thread object representing the
current thread of execution.*this is non-joinable.*this is valid only within the current thread.thread(const boost::function0<void>& threadfunc);
thread
object representing it. Copies threadfunc (which in turn copies
the function object wrapped by threadfunc) to an internal location
which persists for the lifetime of the new thread of execution. Calls operator()
on the copy of the threadfunc function object in the new thread
of execution.*this is joinable.boost::thread_resource_error if a new thread
of execution cannot be started.~Thread();
*this. The actual thread of execution
may continue to execute after the thread object has been destroyed.*this 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 thread object is destroyed, call
join().thread comparison
functionsbool operator==(const thread& rhs) const;
*this is joinable.true if *this and rhs
represent the same thread of execution.bool operator!=(const thread& rhs) const;
*this is joinable.!(*this==rhs).thread modifier functionsvoid join();
*this is joinable. *this finishes
and all resources are reclaimed.*this is non-joinable.*this == thread() the result is implementation
defined. If the implementation doesn't detect this the result will be
deadlock.thread static functionsstatic void sleep(const xtime& XT);
XT
is reached.static void yield();
thread_groupThe thread_group class provides a container for easy grouping of threads to simplify several common thread creation and management idioms.
All thread_group member functions are thread-safe, except destruction.
thread_group
synopsis
namespace boost {
class thread_group : boost::noncopyable
{
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();
};
} // namespace boost
thread_group constructors
and destructorthread_group();
thread_group container.~thread_group();
*this.thread_group
modifier functionsthread* create_thread(const boost::function0<void>& threadfunc);
void add_thread(thread* thrd);
Void remove_thread(thread* thrd);
*this's list of managed thread
objects.*this's list
of managed thread objects.Void join_all();
join() on each of the managed thread
objects.
{{function}}
boost::threadlibs/thread/example/thread.cpp
The output is:
setting alarm for 5 seconds... alarm sounded...
boost::thread_grouplibs/thread/example/thread_group.cpp
The output is:
count = 1 count = 2 count = 3 count = 4 count = 5 count = 6 count = 7 count = 8 count = 9 count = 10
Revised 05 November, 2001
© Copyright William E. Kempf 2001-2002. All Rights Reserved.
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.