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
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 }
282 bool timedWait(const Timeout& timeout);
295 Int32 join();
306 Thread_t getId()
307 {
308 return m_id;
309 }
317 static void sleep(UInt32 milliSeconds)
318 {
319 ThreadImpl::sleep(milliSeconds);
320 }
328 static void sleep(const Timeout& timeout)
329 {
330 ThreadImpl::sleep(timeout);
331 }
338 static void yield()
339 {
340 ThreadImpl::yield();
341 }
342private:
346 virtual Int32 run() = 0;
347 // thread state
348 Thread_t m_id;
351 // used to implement cancellation.
352 friend void ThreadImpl::testCancel();
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...
ThreadDoneCallbackRef cb
Definition Thread.cpp:84
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
Thread_t getId()
Get this Thread object's id.
Definition Thread.hpp:306
Thread(const Thread &)
Thread & operator=(const Thread &)
NonRecursiveMutex m_stateGuard
Definition Thread.hpp:356
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.
static void sleep(UInt32 milliSeconds)
Suspend execution of the current thread until the given number of milliSeconds have elapsed.
Definition Thread.hpp:317
A timeout can be absolute, which means that it will happen at the specified DateTime.
Definition Timeout.hpp:56
Taken from RFC 1321.
BLOCXX_EXPORT_TEMPLATE(BLOCXX_COMMON_API, Array, Bool)