blocxx
Thread.hpp
Go to the documentation of this file.
1/*******************************************************************************
2* Copyright (C) 2005, Vintela, Inc. All rights reserved.
3* Copyright (C) 2006, Novell, Inc. All rights reserved.
4*
5* Redistribution and use in source and binary forms, with or without
6* modification, are permitted provided that the following conditions are met:
7*
8* * Redistributions of source code must retain the above copyright notice,
9* this list of conditions and the following disclaimer.
10* * Redistributions in binary form must reproduce the above copyright
11* notice, this list of conditions and the following disclaimer in the
12* documentation and/or other materials provided with the distribution.
13* * Neither the name of
14* Vintela, Inc.,
15* nor Novell, Inc.,
16* nor the names of its contributors or employees may be used to
17* endorse or promote products derived from this software without
18* specific prior written permission.
19*
20* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
24* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30* POSSIBILITY OF SUCH DAMAGE.
31*******************************************************************************/
32
33
38
39#ifndef BLOCXX_THREAD_HPP_INCLUDE_GUARD_
40#define BLOCXX_THREAD_HPP_INCLUDE_GUARD_
41#include "blocxx/BLOCXX_config.h"
42#include "blocxx/Exception.hpp"
43#include "blocxx/String.hpp"
44#include "blocxx/ThreadImpl.hpp"
47#include "blocxx/Assertion.hpp"
48#include "blocxx/Condition.hpp"
52#include "blocxx/Timeout.hpp"
53#include "blocxx/AtomicOps.hpp"
54
55namespace BLOCXX_NAMESPACE
56{
57
59BLOCXX_DECLARE_APIEXCEPTION(CancellationDenied, BLOCXX_COMMON_API);
62
66class BLOCXX_COMMON_API Thread : public IntrusiveCountableBase
67{
68public:
73 Thread();
79 virtual ~Thread();
88 virtual void start(const ThreadDoneCallbackRef& cb = ThreadDoneCallbackRef(0));
89
95 void shutdown();
96
104 bool shutdown(const Timeout& timeout);
105
133 void cooperativeCancel();
134
173 bool definitiveCancel(const Timeout& timeout = Timeout::relative(60));
174 bool definitiveCancel(UInt32 waitForCooperativeSecs) BLOCXX_DEPRECATED; // in 4.0.0
196 void cancel();
226 static void testCancel();
227private:
228
229 void cancel_internal(bool is_locked);
230
240 virtual void doShutdown();
241
256 virtual void doCooperativeCancel();
257
265 virtual void doDefinitiveCancel();
266public:
271 {
272 return m_isRunning == true;
273 }
274
282 bool timedWait(const Timeout& timeout);
295 Int32 join();
306 Thread_t getId()
307 {
308 return m_id;
309 }
310
317 static void sleep(UInt32 milliSeconds)
318 {
319 ThreadImpl::sleep(milliSeconds);
320 }
321
328 static void sleep(const Timeout& timeout)
329 {
330 ThreadImpl::sleep(timeout);
331 }
332
338 static void yield()
339 {
341 }
342private:
346 virtual Int32 run() = 0;
347 // thread state
348 Thread_t m_id;
351 // used to implement cancellation.
355
358
359 static Int32 threadRunner(void* paramPtr);
360 void doneRunning(const ThreadDoneCallbackRef& cb);
361
362 // non-copyable
363 Thread(const Thread&);
365
366};
368
369} // end namespace BLOCXX_NAMESPACE
370
371#endif
372
#define BLOCXX_DECLARE_APIEXCEPTION(NAME, LINKAGE_SPEC)
Declare a new exception class named <NAME>Exception that derives from Exception This macro is typical...
The Condition class represents a synchronization device that allows threads to suspend execution and ...
Definition Condition.hpp:63
Note that descriptions of what exceptions may be thrown assumes that object is used correctly,...
Descriptions of exceptions thrown assume that the object is used correctly, i.e., method precondition...
Definition Thread.hpp:67
static void sleep(const Timeout &timeout)
Suspend execution of the current thread until the given number of seconds have elapsed.
Definition Thread.hpp:328
static void testCancel()
Test if this thread has been cancelled.
Definition Thread.cpp:432
Thread()
Create a new Thread object.
Definition Thread.cpp:108
virtual void start(const ThreadDoneCallbackRef &cb=ThreadDoneCallbackRef(0))
Start this Thread's execution.
Definition Thread.cpp:140
Thread_t getId()
Get this Thread object's id.
Definition Thread.hpp:306
Thread(const Thread &)
void cancel()
Definitively cancel this Threads execution.
Definition Thread.cpp:404
Thread & operator=(const Thread &)
NonRecursiveMutex m_stateGuard
Definition Thread.hpp:356
void doneRunning(const ThreadDoneCallbackRef &cb)
Definition Thread.cpp:289
virtual void doDefinitiveCancel()
See the documentation for doCooperativeCancel().
Definition Thread.cpp:449
void shutdown()
Call the thread's doShutdown(), which may be used by the thread to safely stop.
Definition Thread.cpp:309
virtual void doCooperativeCancel()
This function is available for subclasses of Thread to override if they wish to be notified when a co...
Definition Thread.cpp:444
virtual void doShutdown()
This function is available for subclasses of Thread to override if they wish to be notified when shut...
Definition Thread.cpp:439
static Int32 threadRunner(void *paramPtr)
Definition Thread.cpp:183
static void yield()
Voluntarily yield to the processor giving the next thread in the chain the opportunity to run.
Definition Thread.hpp:338
virtual Int32 run()=0
The method that will be run when the start method is called.
void cancel_internal(bool is_locked)
Definition Thread.cpp:411
static void sleep(UInt32 milliSeconds)
Suspend execution of the current thread until the given number of milliSeconds have elapsed.
Definition Thread.hpp:317
bool definitiveCancel(const Timeout &timeout=Timeout::relative(60))
Attempt to cooperatively and then definitively cancel this Thread's execution.
Definition Thread.cpp:355
void cooperativeCancel()
Attempt to cooperatively cancel this Threads execution.
Definition Thread.cpp:322
A timeout can be absolute, which means that it will happen at the specified DateTime.
Definition Timeout.hpp:56
static Timeout relative(float seconds)
Definition Timeout.cpp:58
BLOCXX_COMMON_API void testCancel()
Test if this thread has been cancelled.
void yield()
Voluntarily yield to the processor giving the next thread in the chain the opportunity to run.
void sleep(UInt32 milliSeconds)
Suspend execution of the current thread until the given number of milliSeconds have elapsed.
Taken from RFC 1321.
IntrusiveReference< ThreadDoneCallback > ThreadDoneCallbackRef
BLOCXX_EXPORT_TEMPLATE(BLOCXX_COMMON_API, Array, Bool)