Logo ROOT   6.08/07
Reference Guide
TThread.h
Go to the documentation of this file.
1 // @(#)root/thread:$Id$
2 // Author: Fons Rademakers 02/07/97
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 
12 #ifndef ROOT_TThread
13 #define ROOT_TThread
14 
15 
16 //////////////////////////////////////////////////////////////////////////
17 // //
18 // TThread //
19 // //
20 // This class implements threads. A thread is an execution environment //
21 // much lighter than a process. A single process can have multiple //
22 // threads. The actual work is done via the TThreadImp class (either //
23 // TPosixThread or TWin32Thread). //
24 // //
25 //////////////////////////////////////////////////////////////////////////
26 
27 #ifndef ROOT_TObject
28 #include "TObject.h"
29 #endif
30 #ifndef ROOT_TCondition
31 #include "TCondition.h"
32 #endif
33 #ifndef ROOT_TSystem
34 #include "TSystem.h"
35 #endif
36 #ifndef ROOT_TTimer
37 #include "TTimer.h"
38 #endif
39 #ifndef ROOT_Varargs
40 #include "Varargs.h"
41 #endif
42 
43 class TMutex;
44 class TThreadImp;
45 
46 
47 class TThread : public TNamed {
48 
49 friend class TThreadImp;
50 friend class TPosixThread;
51 friend class TThreadTimer;
52 friend class TThreadCleaner;
53 friend class TWin32Thread;
54 friend class TThreadTearDownGuard;
55 friend class TJoinHelper;
56 
57 public:
58 
59  typedef void *(*VoidRtnFunc_t)(void *);
60  typedef void (*VoidFunc_t)(void *);
61 
62  enum EPriority {
66  };
67 
68  enum EState {
69  kInvalidState, // thread was not created properly
70  kNewState, // thread object exists but hasn't started
71  kRunningState, // thread is running
72  kTerminatedState, // thread has terminated but storage has not
73  // yet been reclaimed (i.e. waiting to be joined)
74  kFinishedState, // thread has finished
75  kCancelingState, // thread in process of canceling
76  kCanceledState, // thread has been canceled
77  kDeletingState // thread in process of deleting
78  };
79 
80 private:
81  TThread *fNext; // pointer to next thread
82  TThread *fPrev; // pointer to prev thread
83  TThread **fHolder; // pointer to holder of this (delete only)
84  EPriority fPriority; // thread priority
85  EState fState; // thread state
86  EState fStateComing; // coming thread state
87  Long_t fId; // thread id
88  Long_t fHandle; // Win32 thread handle
89  Bool_t fDetached; // kTRUE if thread is Detached
90  Bool_t fNamed; // kTRUE if thread is Named
91  VoidRtnFunc_t fFcnRetn; // void* start function of thread
92  VoidFunc_t fFcnVoid; // void start function of thread
93  void *fThreadArg; // thread start function arguments
94  void *fClean; // support of cleanup structure
95  char fComment[100]; // thread specific state comment
96 
97  static TThreadImp *fgThreadImp; // static pointer to thread implementation
98  static char * volatile fgXAct; // Action name to do by main thread
99  static void ** volatile fgXArr; // pointer to control array of void pointers for action
100  static volatile Int_t fgXAnb; // size of array above
101  static volatile Int_t fgXArt; // return XA flag
102  static Long_t fgMainId; // thread id of main thread
103  static TThread *fgMain; // pointer to chain of TThread's
104  static TMutex *fgMainMutex; // mutex to protect chain of threads
105  static TMutex *fgXActMutex; // mutex to protect XAction
106  static TCondition *fgXActCondi; // condition for XAction
107 
108  // Private Member functions
109  void Constructor();
110  void SetComment(const char *txt = 0)
111  { fComment[0] = 0; if (txt) { strncpy(fComment, txt, 99); fComment[99] = 0; } }
112  void DoError(Int_t level, const char *location, const char *fmt, va_list va) const;
113  void ErrorHandler(int level, const char *location, const char *fmt, va_list ap) const;
114  static void Init();
115  static void *Function(void *ptr);
116  static Int_t XARequest(const char *xact, Int_t nb, void **ar, Int_t *iret);
117  static void AfterCancel(TThread *th);
118  static void **GetTls(Int_t k);
119 
120  TThread(const TThread&); // not implemented
121  TThread& operator=(const TThread&); // not implemented
122 
123 public:
124  TThread(VoidRtnFunc_t fn, void *arg = 0, EPriority pri = kNormalPriority);
125  TThread(VoidFunc_t fn, void *arg = 0, EPriority pri = kNormalPriority);
126  TThread(const char *thname, VoidRtnFunc_t fn, void *arg = 0, EPriority pri = kNormalPriority);
127  TThread(const char *thname, VoidFunc_t fn, void *arg = 0, EPriority pri = kNormalPriority);
128  TThread(Long_t id = 0);
129  virtual ~TThread();
130 
131  Int_t Kill();
132  Int_t Run(void *arg = 0);
133  void SetPriority(EPriority pri);
134  void Delete(Option_t *option="") { TObject::Delete(option); }
135  EPriority GetPriority() const { return fPriority; }
136  EState GetState() const { return fState; }
137  Long_t GetId() const { return fId; }
138  static void Ps();
139  static void ps() { Ps(); }
140 
141  static void Initialize();
142  static Bool_t IsInitialized();
143 
144  Long_t Join(void **ret = 0);
145  static Long_t Join(Long_t id, void **ret = 0);
146 
147  static Int_t Exit(void *ret = 0);
148  static Int_t Exists();
149  static TThread *GetThread(Long_t id);
150  static TThread *GetThread(const char *name);
151 
152  static Int_t Lock(); //User's lock of main mutex
153  static Int_t TryLock(); //User's try lock of main mutex
154  static Int_t UnLock(); //User's unlock of main mutex
155  static TThread *Self();
156  static Long_t SelfId();
157  static Int_t Sleep(ULong_t secs, ULong_t nanos = 0);
158  static Int_t GetTime(ULong_t *absSec, ULong_t *absNanoSec);
159 
160  static Int_t Delete(TThread *&th);
161  static void **Tsd(void *dflt, Int_t k);
162 
163  // Cancellation
164  // there are two types of TThread cancellation:
165  // DEFERRED - Cancellation only in user provided cancel-points
166  // ASYNCHRONOUS - In any point
167  // DEFERRED is more safe, it is DEFAULT.
168  static Int_t SetCancelOn();
169  static Int_t SetCancelOff();
170  static Int_t SetCancelAsynchronous();
171  static Int_t SetCancelDeferred();
172  static Int_t CancelPoint();
173  static Int_t Kill(Long_t id);
174  static Int_t Kill(const char *name);
175  static Int_t CleanUpPush(void *free, void *arg = 0);
176  static Int_t CleanUpPop(Int_t exe = 0);
177  static Int_t CleanUp();
178 
179  // XActions
180  static void Printf(const char *fmt, ...) // format and print
181 #if defined(__GNUC__) && !defined(__CINT__)
182  __attribute__((format(printf, 1, 2)))
183 #endif
184  ;
185  static void XAction();
186 
187  ClassDef(TThread,0) // Thread class
188 };
189 
190 
191 //////////////////////////////////////////////////////////////////////////
192 // //
193 // TThreadCleaner //
194 // //
195 //////////////////////////////////////////////////////////////////////////
196 
198 public:
200  ~TThreadCleaner();
201 };
202 
203 
204 //////////////////////////////////////////////////////////////////////////
205 // //
206 // TThreadTimer //
207 // //
208 //////////////////////////////////////////////////////////////////////////
209 
210 class TThreadTimer : public TTimer {
211 public:
212  // if this time is less or equal to kItimerResolution, TUnixSystem::DispatchOneEvent i
213  // can not exit and have its caller react to the other TTimer's actions (like the request
214  // to stop the event loop) until there is another type of event.
216  Bool_t Notify();
217 };
218 
219 #endif
static void ** GetTls(Int_t k)
Static method that initializes the TLS array of a thread and returns the reference to a given positio...
Definition: TThread.cxx:893
static void AfterCancel(TThread *th)
Static method which is called after the thread has been canceled.
Definition: TThread.cxx:715
static Int_t SetCancelDeferred()
Static method to set the cancellation response type of the calling thread to deferred, i.e.
Definition: TThread.cxx:653
Definition: TMutex.h:34
void *(* VoidRtnFunc_t)(void *)
Definition: TThread.h:59
static Bool_t IsInitialized()
Return true, if the TThread objects have been initialize.
Definition: TThread.cxx:305
TThread & operator=(const TThread &)
EState
Definition: TThread.h:68
friend class TJoinHelper
Definition: TThread.h:55
static void XAction()
Static method called via the thread timer to execute in the main thread certain commands.
Definition: TThread.cxx:1061
EState fStateComing
Definition: TThread.h:86
static TCondition * fgXActCondi
Definition: TThread.h:106
friend class TThreadTimer
Definition: TThread.h:51
static TThread * fgMain
Definition: TThread.h:103
friend class TThreadTearDownGuard
Definition: TThread.h:54
static void Initialize()
Initialize the Thread package.
Definition: TThread.cxx:296
const char Option_t
Definition: RtypesCore.h:62
void Constructor()
Common thread constructor.
Definition: TThread.cxx:353
void * fThreadArg
Definition: TThread.h:93
EState GetState() const
Definition: TThread.h:136
static Int_t SetCancelOff()
Static method to turn off thread cancellation.
Definition: TThread.cxx:624
static void Printf(const char *fmt,...)
Static method providing a thread safe printf. Appends a newline.
Definition: TThread.cxx:910
static Int_t SetCancelOn()
Static method to turn on thread cancellation.
Definition: TThread.cxx:633
int Int_t
Definition: RtypesCore.h:41
bool Bool_t
Definition: RtypesCore.h:59
static TThreadImp * fgThreadImp
Definition: TThread.h:97
TThread * fPrev
Definition: TThread.h:82
static Int_t TryLock()
Static method to try to lock the main thread mutex.
Definition: TThread.cxx:766
EState fState
Definition: TThread.h:85
static std::string format(double x, double y, int digits, int width)
static Int_t CleanUpPop(Int_t exe=0)
Static method which pops thread cleanup method off stack.
Definition: TThread.cxx:683
Long_t fHandle
Definition: TThread.h:88
static volatile Int_t fgXArt
Definition: TThread.h:101
TThread(const TThread &)
static Int_t SetCancelAsynchronous()
Static method to set the cancellation response type of the calling thread to asynchronous, i.e.
Definition: TThread.cxx:643
EPriority GetPriority() const
Definition: TThread.h:135
#define ClassDef(name, id)
Definition: Rtypes.h:254
void SetComment(const char *txt=0)
Definition: TThread.h:110
The TNamed class is the base class for all named ROOT classes.
Definition: TNamed.h:33
virtual Bool_t Notify()
This method must be overridden to handle object notification.
Definition: TObject.cxx:551
static Int_t XARequest(const char *xact, Int_t nb, void **ar, Int_t *iret)
Static method used to allow commands to be executed by the main thread.
Definition: TThread.cxx:1011
static Long_t SelfId()
Static method returning the id for the current thread.
Definition: TThread.cxx:538
Int_t Run(void *arg=0)
Start the thread.
Definition: TThread.cxx:552
VoidFunc_t fFcnVoid
Definition: TThread.h:92
virtual ~TThread()
Cleanup the thread.
Definition: TThread.cxx:379
virtual void Delete(Option_t *option="")
Delete this object.
Definition: TObject.cxx:229
static TThread * GetThread(Long_t id)
Static method to find a thread by id.
Definition: TThread.cxx:452
EPriority fPriority
Definition: TThread.h:84
static TMutex * fgMainMutex
Definition: TThread.h:104
static Int_t Exists()
Static method to check if threads exist.
Definition: TThread.cxx:428
static void Init()
Initialize global state and variables once.
Definition: TThread.cxx:315
static char *volatile fgXAct
Definition: TThread.h:98
void DoError(Int_t level, const char *location, const char *fmt, va_list va) const
Interface to ErrorHandler.
Definition: TThread.cxx:990
Handles synchronous and a-synchronous timer events.
Definition: TTimer.h:57
static Long_t fgMainId
Definition: TThread.h:102
static Int_t CleanUpPush(void *free, void *arg=0)
Static method which pushes thread cleanup method on stack.
Definition: TThread.cxx:671
static Int_t CancelPoint()
Static method to set a cancellation point.
Definition: TThread.cxx:662
Long_t Join(void **ret=0)
Join this thread.
Definition: TThread.cxx:499
Int_t Kill()
Kill this thread.
Definition: TThread.cxx:576
static Int_t Lock()
Static method to lock the main thread mutex.
Definition: TThread.cxx:758
VoidRtnFunc_t fFcnRetn
Definition: TThread.h:91
static void Ps()
Static method listing the existing threads.
Definition: TThread.cxx:829
static TMutex * fgXActMutex
Definition: TThread.h:105
static void **volatile fgXArr
Definition: TThread.h:99
static Int_t CleanUp()
Static method to cleanup the calling thread.
Definition: TThread.cxx:694
long Long_t
Definition: RtypesCore.h:50
static void ** Tsd(void *dflt, Int_t k)
Static method returning a pointer to thread specific data container of the calling thread...
Definition: TThread.cxx:880
static Int_t UnLock()
Static method to unlock the main thread mutex.
Definition: TThread.cxx:774
EPriority
Definition: TThread.h:62
static TThread * Self()
Static method returning pointer to current thread.
Definition: TThread.cxx:484
#define free
Definition: civetweb.c:821
unsigned long ULong_t
Definition: RtypesCore.h:51
void SetPriority(EPriority pri)
Set thread priority.
Definition: TThread.cxx:444
Long_t fId
Definition: TThread.h:87
void * fClean
Definition: TThread.h:94
Long_t GetId() const
Definition: TThread.h:137
char fComment[100]
Definition: TThread.h:95
static Int_t GetTime(ULong_t *absSec, ULong_t *absNanoSec)
Static method to get the current time.
Definition: TThread.cxx:747
Bool_t fDetached
Definition: TThread.h:89
typedef void((*Func_t)())
Bool_t fNamed
Definition: TThread.h:90
static Int_t Exit(void *ret=0)
Static method which terminates the execution of the calling thread.
Definition: TThread.cxx:728
void(* VoidFunc_t)(void *)
Definition: TThread.h:60
TThread * fNext
Definition: TThread.h:81
static Int_t Sleep(ULong_t secs, ULong_t nanos=0)
Static method to sleep the calling thread.
Definition: TThread.cxx:736
static void ps()
Definition: TThread.h:139
TThread ** fHolder
Definition: TThread.h:83
char name[80]
Definition: TGX11.cxx:109
void ErrorHandler(int level, const char *location, const char *fmt, va_list ap) const
Thread specific error handler function.
Definition: TThread.cxx:946
static void * Function(void *ptr)
Static method which is called by the system thread function and which in turn calls the actual user f...
Definition: TThread.cxx:783
static volatile Int_t fgXAnb
Definition: TThread.h:100
void Delete(Option_t *option="")
Delete this object.
Definition: TThread.h:134