Logo ROOT   6.30.04
Reference Guide
 All Namespaces Files Pages
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 #include "TObject.h"
28 #include "TCondition.h"
29 #include "TSystem.h"
30 #include "TTimer.h"
31 #include "Varargs.h"
32 
33 class TMutex;
34 class TThreadImp;
35 
36 
37 class TThread : public TNamed {
38 
39 friend class TThreadImp;
40 friend class TPosixThread;
41 friend class TThreadTimer;
42 friend class TThreadCleaner;
43 friend class TWin32Thread;
44 friend class TThreadTearDownGuard;
45 friend class TJoinHelper;
46 
47 public:
48 
49  typedef void *(*VoidRtnFunc_t)(void *);
50  typedef void (*VoidFunc_t)(void *);
51 
52  enum EPriority {
53  kLowPriority,
54  kNormalPriority,
55  kHighPriority
56  };
57 
58  enum EState {
59  kInvalidState, // thread was not created properly
60  kNewState, // thread object exists but hasn't started
61  kRunningState, // thread is running
62  kTerminatedState, // thread has terminated but storage has not
63  // yet been reclaimed (i.e. waiting to be joined)
64  kFinishedState, // thread has finished
65  kCancelingState, // thread in process of canceling
66  kCanceledState, // thread has been canceled
67  kDeletingState // thread in process of deleting
68  };
69 
70 private:
71  TThread *fNext; // pointer to next thread
72  TThread *fPrev; // pointer to prev thread
73  TThread **fHolder; // pointer to holder of this (delete only)
74  EPriority fPriority; // thread priority
75  EState fState; // thread state
76  EState fStateComing; // coming thread state
77  Long_t fId; // thread id
78  Long_t fHandle; // Win32 thread handle
79  Bool_t fDetached; // kTRUE if thread is Detached
80  Bool_t fNamed; // kTRUE if thread is Named
81  VoidRtnFunc_t fFcnRetn; // void* start function of thread
82  VoidFunc_t fFcnVoid; // void start function of thread
83  void *fThreadArg; // thread start function arguments
84  void *fClean; // support of cleanup structure
85  char fComment[100]; // thread specific state comment
86 
87  static TThreadImp *fgThreadImp; // static pointer to thread implementation
88  static char * volatile fgXAct; // Action name to do by main thread
89  static void ** volatile fgXArr; // pointer to control array of void pointers for action
90  static volatile Int_t fgXAnb; // size of array above
91  static volatile Int_t fgXArt; // return XA flag
92  static Long_t fgMainId; // thread id of main thread
93  static TThread *fgMain; // pointer to chain of TThread's
94  static TMutex *fgMainMutex; // mutex to protect chain of threads
95  static TMutex *fgXActMutex; // mutex to protect XAction
96  static TCondition *fgXActCondi; // condition for XAction
97 
98  // Private Member functions
99  void Constructor();
100  void SetComment(const char *txt = 0)
101  { fComment[0] = 0; if (txt) { strncpy(fComment, txt, 99); fComment[99] = 0; } }
102  void DoError(Int_t level, const char *location, const char *fmt, va_list va) const;
103  void ErrorHandler(int level, const char *location, const char *fmt, va_list ap) const;
104  static void Init();
105  static void *Function(void *ptr);
106  static Int_t XARequest(const char *xact, Int_t nb, void **ar, Int_t *iret);
107  static void AfterCancel(TThread *th);
108  static void **GetTls(Int_t k);
109 
110  TThread(const TThread&); // not implemented
111  TThread& operator=(const TThread&); // not implemented
112 
113 public:
114  TThread(VoidRtnFunc_t fn, void *arg = 0, EPriority pri = kNormalPriority);
115  TThread(VoidFunc_t fn, void *arg = 0, EPriority pri = kNormalPriority);
116  TThread(const char *thname, VoidRtnFunc_t fn, void *arg = 0, EPriority pri = kNormalPriority);
117  TThread(const char *thname, VoidFunc_t fn, void *arg = 0, EPriority pri = kNormalPriority);
118  TThread(Long_t id = 0);
119  virtual ~TThread();
120 
121  Int_t Kill();
122  Int_t Run(void *arg = 0);
123  void SetPriority(EPriority pri);
124  void Delete(Option_t *option="") { TObject::Delete(option); }
125  EPriority GetPriority() const { return fPriority; }
126  EState GetState() const { return fState; }
127  Long_t GetId() const { return fId; }
128  static void Ps();
129  static void ps() { Ps(); }
130 
131  static void Initialize();
132  static Bool_t IsInitialized();
133 
134  Long_t Join(void **ret = 0);
135  static Long_t Join(Long_t id, void **ret = 0);
136 
137  static Int_t Exit(void *ret = 0);
138  static Int_t Exists();
139  static TThread *GetThread(Long_t id);
140  static TThread *GetThread(const char *name);
141 
142  static Int_t Lock(); //User's lock of main mutex
143  static Int_t TryLock(); //User's try lock of main mutex
144  static Int_t UnLock(); //User's unlock of main mutex
145  static TThread *Self();
146  static Long_t SelfId();
147  static Int_t Sleep(ULong_t secs, ULong_t nanos = 0);
148  static Int_t GetTime(ULong_t *absSec, ULong_t *absNanoSec);
149 
150  static Int_t Delete(TThread *&th);
151  static void **Tsd(void *dflt, Int_t k);
152 
153  // Cancellation
154  // there are two types of TThread cancellation:
155  // DEFERRED - Cancellation only in user provided cancel-points
156  // ASYNCHRONOUS - In any point
157  // DEFERRED is more safe, it is DEFAULT.
158  static Int_t SetCancelOn();
159  static Int_t SetCancelOff();
160  static Int_t SetCancelAsynchronous();
161  static Int_t SetCancelDeferred();
162  static Int_t CancelPoint();
163  static Int_t Kill(Long_t id);
164  static Int_t Kill(const char *name);
165  static Int_t CleanUpPush(void *free, void *arg = 0);
166  static Int_t CleanUpPop(Int_t exe = 0);
167  static Int_t CleanUp();
168 
169  // XActions
170  static void Printf(const char *fmt, ...) // format and print
171 #if defined(__GNUC__) && !defined(__CINT__)
172  __attribute__((format(printf, 1, 2)))
173 #endif
174  ;
175  static void XAction();
176 
177  ClassDef(TThread,0) // Thread class
178 };
179 
180 
181 //////////////////////////////////////////////////////////////////////////
182 // //
183 // TThreadCleaner //
184 // //
185 //////////////////////////////////////////////////////////////////////////
186 
187 class TThreadCleaner {
188 public:
189  TThreadCleaner() { }
190  ~TThreadCleaner();
191 };
192 
193 
194 //////////////////////////////////////////////////////////////////////////
195 // //
196 // TThreadTimer //
197 // //
198 //////////////////////////////////////////////////////////////////////////
199 
200 class TThreadTimer : public TTimer {
201 public:
202  // if this time is less or equal to kItimerResolution, TUnixSystem::DispatchOneEvent i
203  // can not exit and have its caller react to the other TTimer's actions (like the request
204  // to stop the event loop) until there is another type of event.
205  TThreadTimer(Long_t ms = kItimerResolution + 10);
206  Bool_t Notify();
207 };
208 
209 #endif