#include <Task.h>
Inheritance diagram for ACE_Task_Base:
Public Member Functions | |
ACE_Task_Base (ACE_Thread_Manager *=0) | |
Constructor. | |
virtual | ~ACE_Task_Base (void) |
Destructor. | |
virtual int | open (void *args=0) |
virtual int | close (u_long flags=0) |
virtual int | module_closed (void) |
virtual int | put (ACE_Message_Block *, ACE_Time_Value *=0) |
virtual int | svc (void) |
Run by a daemon thread to handle deferred processing. | |
virtual int | activate (long flags=THR_NEW_LWP|THR_JOINABLE|THR_INHERIT_SCHED, int n_threads=1, int force_active=0, long priority=ACE_DEFAULT_THREAD_PRIORITY, int grp_id=-1, ACE_Task_Base *task=0, ACE_hthread_t thread_handles[]=0, void *stack[]=0, size_t stack_size[]=0, ACE_thread_t thread_ids[]=0, const char *thr_name[]=0) |
virtual int | wait (void) |
virtual int | suspend (void) |
Suspend a task. | |
virtual int | resume (void) |
Resume a suspended task. | |
int | grp_id (void) const |
Get the current group id. | |
void | grp_id (int) |
Set the current group id. | |
ACE_Thread_Manager * | thr_mgr (void) const |
Get the thread manager associated with this Task. | |
void | thr_mgr (ACE_Thread_Manager *) |
Set the thread manager associated with this Task. | |
int | is_reader (void) const |
True if queue is a reader, else false. | |
int | is_writer (void) const |
True if queue is a writer, else false. | |
size_t | thr_count (void) const |
ACE_thread_t | last_thread (void) const |
Static Public Member Functions | |
static ACE_THR_FUNC_RETURN | svc_run (void *) |
Routine that runs the service routine as a daemon thread. | |
static void | cleanup (void *object, void *params) |
Protected Attributes | |
size_t | thr_count_ |
ACE_Thread_Manager * | thr_mgr_ |
Multi-threading manager. | |
u_long | flags_ |
ACE_Task flags. | |
int | grp_id_ |
This maintains the group id of the Task. | |
ACE_thread_t | last_thread_id_ |
Holds the thread ID of the last thread to exit svc() in this object. | |
Private Member Functions | |
ACE_Task_Base & | operator= (const ACE_Task_Base &) |
ACE_Task_Base (const ACE_Task_Base &) |
This class factors out the non-template code in order to reduce template bloat, as well as to make it possible for the ACE_Thread_Manager to store ACE_Task_Base *'s polymorphically.
Definition at line 66 of file Task.h.
ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_Task_Base::ACE_Task_Base | ( | ACE_Thread_Manager * | = 0 |
) |
Constructor.
Definition at line 17 of file Task.cpp.
References ACE_OS::memset().
00018 : thr_count_ (0), 00019 thr_mgr_ (thr_man), 00020 flags_ (0), 00021 grp_id_ (-1) 00022 #if !(defined (ACE_MVS) || defined(__TANDEM)) 00023 ,last_thread_id_ (0) 00024 #endif /* !defined (ACE_MVS) */ 00025 { 00026 #if (defined (ACE_MVS) || defined(__TANDEM)) 00027 ACE_OS::memset( &this->last_thread_id_, '\0', sizeof( this->last_thread_id_ )); 00028 #endif /* defined (ACE_MVS) */ 00029 }
ACE_Task_Base::~ACE_Task_Base | ( | void | ) | [virtual] |
ACE_Task_Base::ACE_Task_Base | ( | const ACE_Task_Base & | ) | [private] |
int ACE_Task_Base::activate | ( | long | flags = THR_NEW_LWP|THR_JOINABLE|THR_INHERIT_SCHED , |
|
int | n_threads = 1 , |
|||
int | force_active = 0 , |
|||
long | priority = ACE_DEFAULT_THREAD_PRIORITY , |
|||
int | grp_id = -1 , |
|||
ACE_Task_Base * | task = 0 , |
|||
ACE_hthread_t | thread_handles[] = 0 , |
|||
void * | stack[] = 0 , |
|||
size_t | stack_size[] = 0 , |
|||
ACE_thread_t | thread_ids[] = 0 , |
|||
const char * | thr_name[] = 0 | |||
) | [virtual] |
Turn the task into an active object, i.e., having n_threads of control, all running at the priority level (see below) with the same grp_id, all of which invoke <Task::svc>. Returns -1 if failure occurs, returns 1 if Task is already an active object and force_active is false (i.e., do *not* create a new thread in this case), and returns 0 if Task was not already an active object and a thread is created successfully or thread is an active object and force_active is true. Note that if force_active is true and there are already threads spawned in this <Task>, the grp_id parameter is ignored and the grp_id of any newly activated thread(s) will inherit the existing grp_id of the existing thread(s) in the <Task>.
The <{flags}> are a bitwise-OR of the following: = BEGIN<INDENT> THR_CANCEL_DISABLE, THR_CANCEL_ENABLE, THR_CANCEL_DEFERRED, THR_CANCEL_ASYNCHRONOUS, THR_BOUND, THR_NEW_LWP, THR_DETACHED, THR_SUSPENDED, THR_DAEMON, THR_JOINABLE, THR_SCHED_FIFO, THR_SCHED_RR, THR_SCHED_DEFAULT, THR_EXPLICIT_SCHED, THR_SCOPE_SYSTEM, THR_SCOPE_PROCESS = END<INDENT> If THR_SCHED_INHERIT is not desirable, applications should specifically pass in THR_EXPLICIT_SCHED.
By default, or if <{priority}> is set to ACE_DEFAULT_THREAD_PRIORITY, an "appropriate" priority value for the given scheduling policy (specified in <{flags}>, e.g., <THR_SCHED_DEFAULT>) is used. This value is calculated dynamically, and is the median value between the minimum and maximum priority values for the given policy. If an explicit value is given, it is used. Note that actual priority values are EXTREMEMLY implementation-dependent, and are probably best avoided.
If thread_handles != 0 it is assumed to be an array of n thread_handles that will be assigned the values of the thread handles being spawned. Returns -1 on failure (errno
will explain...), otherwise returns the group id of the threads.
Assigning task allows you to associate the newly spawned threads with an instance of ACE_Task_Base. If task == 0, then the new threads are associated automatically with this
ACE_Task_Base. Setting the task argument to value other than this
makes the thread manipulating methods, such as wait(), suspend(), resume(), useless. Threads spawned with user specified task value must therefore be manipulated thru ACE_Thread_Manager directly.
If stack != 0 it is assumed to be an array of n pointers to the base of the stacks to use for the threads being spawned. Likewise, if stack_size != 0 it is assumed to be an array of n values indicating how big each of the corresponding stacks are.
Reimplemented in ACE_Thread_Timer_Queue_Adapter< TQ >.
Definition at line 120 of file Task.cpp.
References ACE_GUARD_RETURN, ACE_NOTSUP_RETURN, ACE_TRACE, grp_id_, ACE_Thread_Manager::instance(), last_thread_id_, ACE_OS::memcpy(), ACE_Thread_Manager::spawn_n(), svc_run(), and thr_mgr_.
Referenced by ACE_Thread_Timer_Queue_Adapter< TQ >::activate(), and ACE_Asynch_Pseudo_Task::start().
00131 { 00132 ACE_TRACE ("ACE_Task_Base::activate"); 00133 00134 #if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0) 00135 ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1); 00136 00137 // If the task passed in is zero, we will use <this> 00138 if (task == 0) 00139 task = this; 00140 00141 if (this->thr_count_ > 0 && force_active == 0) 00142 return 1; // Already active. 00143 else 00144 { 00145 if (this->thr_count_ > 0 && this->grp_id_ != -1) 00146 // If we're joining an existing group of threads then make 00147 // sure to use its group id. 00148 grp_id = this->grp_id_; 00149 this->thr_count_ += n_threads; 00150 } 00151 00152 // Use the ACE_Thread_Manager singleton if we're running as an 00153 // active object and the caller didn't supply us with a 00154 // Thread_Manager. 00155 if (this->thr_mgr_ == 0) 00156 # if defined (ACE_THREAD_MANAGER_LACKS_STATICS) 00157 this->thr_mgr_ = ACE_THREAD_MANAGER_SINGLETON::instance (); 00158 # else /* ! ACE_THREAD_MANAGER_LACKS_STATICS */ 00159 this->thr_mgr_ = ACE_Thread_Manager::instance (); 00160 # endif /* ACE_THREAD_MANAGER_LACKS_STATICS */ 00161 00162 int grp_spawned = -1; 00163 if (thread_ids == 0) 00164 // Thread Ids were not specified 00165 grp_spawned = 00166 this->thr_mgr_->spawn_n (n_threads, 00167 &ACE_Task_Base::svc_run, 00168 (void *) this, 00169 flags, 00170 priority, 00171 grp_id, 00172 task, 00173 thread_handles, 00174 stack, 00175 stack_size, 00176 thr_name); 00177 else 00178 // thread names were specified 00179 grp_spawned = 00180 this->thr_mgr_->spawn_n (thread_ids, 00181 n_threads, 00182 &ACE_Task_Base::svc_run, 00183 (void *) this, 00184 flags, 00185 priority, 00186 grp_id, 00187 stack, 00188 stack_size, 00189 thread_handles, 00190 task, 00191 thr_name); 00192 if (grp_spawned == -1) 00193 { 00194 // If spawn_n fails, restore original thread count. 00195 this->thr_count_ -= n_threads; 00196 return -1; 00197 } 00198 00199 if (this->grp_id_ == -1) 00200 this->grp_id_ = grp_spawned; 00201 00202 #if defined (ACE_MVS) || defined(__TANDEM) 00203 ACE_OS::memcpy( &this->last_thread_id_, '\0', sizeof(this->last_thread_id_)); 00204 #else 00205 this->last_thread_id_ = 0; // Reset to prevent inadvertant match on ID 00206 #endif /* defined (ACE_MVS) */ 00207 00208 return 0; 00209 00210 #else 00211 { 00212 // Keep the compiler from complaining. 00213 ACE_UNUSED_ARG (flags); 00214 ACE_UNUSED_ARG (n_threads); 00215 ACE_UNUSED_ARG (force_active); 00216 ACE_UNUSED_ARG (priority); 00217 ACE_UNUSED_ARG (grp_id); 00218 ACE_UNUSED_ARG (task); 00219 ACE_UNUSED_ARG (thread_handles); 00220 ACE_UNUSED_ARG (stack); 00221 ACE_UNUSED_ARG (stack_size); 00222 ACE_UNUSED_ARG (thread_ids); 00223 ACE_UNUSED_ARG (thr_name); 00224 ACE_NOTSUP_RETURN (-1); 00225 } 00226 #endif /* ACE_MT_SAFE */ 00227 }
void ACE_Task_Base::cleanup | ( | void * | object, | |
void * | params | |||
) | [static] |
Cleanup hook that is called when a thread exits to gracefully shutdown an ACE_Task.
Definition at line 230 of file Task.cpp.
References ACE_GUARD, close(), last_thread_id_, ACE_Thread::self(), and thr_count_.
Referenced by ACE_OS_Thread_Adapter::invoke(), ACE_Thread_Adapter::invoke_i(), and svc_run().
00231 { 00232 ACE_Task_Base *t = (ACE_Task_Base *) object; 00233 00234 // The thread count must be decremented first in case the <close> 00235 // hook does something crazy like "delete this". 00236 { 00237 ACE_MT (ACE_GUARD (ACE_Thread_Mutex, ace_mon, t->lock_)); 00238 t->thr_count_--; 00239 if (0 == t->thr_count_) 00240 t->last_thread_id_ = ACE_Thread::self (); 00241 } 00242 00243 // @@ Is it possible to pass in the exit status somehow? 00244 t->close (); 00245 // t is undefined here. close() could have deleted it. 00246 }
int ACE_Task_Base::close | ( | u_long | flags = 0 |
) | [virtual] |
Hook called from ACE_Thread_Exit when during thread exit and from the default implementation of <module_closed>. In general, this method shouldn't be called directly by an application, particularly if the <Task> is running as an Active Object. Instead, a special message should be passed into the <Task> via the <put> method defined below, and the <svc> method should interpret this as a flag to shut down the <Task>.
Reimplemented in ACE_Stream_Head<>, ACE_Stream_Tail<>, ACE_Thru_Task<>, ACE_Svc_Handler<, >, and ACE_Svc_Handler< ACE_PEER_STREAM_2, ACE_SYNCH_USE >.
Definition at line 56 of file Task.cpp.
References ACE_TRACE.
Referenced by cleanup(), and module_closed().
00057 { 00058 ACE_TRACE ("ACE_Task_Base::close"); 00059 return 0; 00060 }
ACE_INLINE void ACE_Task_Base::grp_id | ( | int | ) |
Set the current group id.
Definition at line 19 of file Task.inl.
References ACE_GUARD, ACE_TRACE, and grp_id_.
00020 { 00021 ACE_TRACE ("ACE_Task_Base::grp_id"); 00022 ACE_MT (ACE_GUARD (ACE_Thread_Mutex, ace_mon, this->lock_)); 00023 00024 // Cache the group id in the task and then set it in the 00025 // Thread_Manager, if there is one. 00026 this->grp_id_ = identifier; 00027 if (this->thr_mgr ()) 00028 this->thr_mgr ()->set_grp (this, identifier); 00029 }
ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE int ACE_Task_Base::grp_id | ( | void | ) | const |
Get the current group id.
Definition at line 9 of file Task.inl.
References ACE_GUARD_RETURN, ACE_TRACE, and grp_id_.
00010 { 00011 ACE_TRACE ("ACE_Task_Base::grp_id"); 00012 ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, const_cast <ACE_Thread_Mutex&>(this->lock_), -1)); 00013 return this->grp_id_; 00014 }
ACE_INLINE int ACE_Task_Base::is_reader | ( | void | ) | const |
True if queue is a reader, else false.
Definition at line 46 of file Task.inl.
References ACE_BIT_ENABLED, ACE_Task_Flags::ACE_READER, and ACE_TRACE.
00047 { 00048 ACE_TRACE ("ACE_Task_Base::is_reader"); 00049 return (ACE_BIT_ENABLED (this->flags_, ACE_Task_Flags::ACE_READER)); 00050 }
ACE_INLINE int ACE_Task_Base::is_writer | ( | void | ) | const |
True if queue is a writer, else false.
Definition at line 53 of file Task.inl.
References ACE_BIT_DISABLED, ACE_Task_Flags::ACE_READER, and ACE_TRACE.
00054 { 00055 ACE_TRACE ("ACE_Task_Base::is_writer"); 00056 return (ACE_BIT_DISABLED (this->flags_, ACE_Task_Flags::ACE_READER)); 00057 }
ACE_INLINE ACE_thread_t ACE_Task_Base::last_thread | ( | void | ) | const |
Returns the thread ID of the thread whose exit caused this object's thread count to be decremented to 0.
When a thread spawned in the context of this object (using activate()) returns from its svc() method ACE calls the close() hook. Before it does so, it decrements the number of active threads. If the number of threads is decremented to 0, the thread ID of the current thread is stored for access by this method. If the returned thread ID matches the calling thread's ID, the calling thread knows that there are no other threads still active in the ACE_Task.
ACE_thread_t | of the last thread to close. 0 if the last thread is not yet known; for example, if no threads are active, or if multiple threads are active. |
Definition at line 71 of file Task.inl.
References ACE_TRACE, and last_thread_id_.
00072 { 00073 ACE_TRACE ("ACE_Task_Base::last_thread"); 00074 return this->last_thread_id_; 00075 }
int ACE_Task_Base::module_closed | ( | void | ) | [virtual] |
Hook called during <ACE_Module::close>. The default implementation calls forwards the call to close(1). Please notice the changed value of the default argument of <close>. This allows tasks to differ between the call has been originated from <ACE_Thread_Exit> or from <module_closed>. Be aware that close(0) will be also called when a thread associated with the ACE_Task instance exits.
Definition at line 66 of file Task.cpp.
References close().
Referenced by ACE_Module< ACE_SYNCH_USE >::close_i().
00067 { 00068 return this->close (1); 00069 }
int ACE_Task_Base::open | ( | void * | args = 0 |
) | [virtual] |
Hook called to initialize a task and prepare it for execution. args can be used to pass arbitrary information into <open>.
Reimplemented in ACE_Stream_Head<>, ACE_Stream_Tail<>, ACE_Thru_Task<>, ACE_Svc_Handler<, >, and ACE_Svc_Handler< ACE_PEER_STREAM_2, ACE_SYNCH_USE >.
Definition at line 47 of file Task.cpp.
References ACE_TRACE.
Referenced by ACE_Stream<>::insert(), and ACE_Stream<>::push_module().
00048 { 00049 ACE_TRACE ("ACE_Task_Base::open"); 00050 return 0; 00051 }
ACE_Task_Base& ACE_Task_Base::operator= | ( | const ACE_Task_Base & | ) | [private] |
int ACE_Task_Base::put | ( | ACE_Message_Block * | , | |
ACE_Time_Value * | = 0 | |||
) | [virtual] |
A hook method that can be used to pass a message to a task, where it can be processed immediately or queued for subsequent processing in the <svc> hook method.
Reimplemented in ACE_Stream_Head<>, ACE_Stream_Tail<>, ACE_Thru_Task<>, and ACE_Buffered_Svc_Handler<, >.
Definition at line 74 of file Task.cpp.
References ACE_TRACE.
Referenced by ACE_Stream<>::put(), and ACE_Task< ACE_SYNCH_USE >::put_next().
00075 { 00076 ACE_TRACE ("ACE_Task_Base::put"); 00077 return 0; 00078 }
int ACE_Task_Base::resume | ( | void | ) | [virtual] |
Resume a suspended task.
Reimplemented from ACE_Service_Object.
Definition at line 109 of file Task.cpp.
References ACE_GUARD_RETURN, ACE_TRACE, ACE_Thread_Manager::resume_task(), and thr_mgr_.
Referenced by ACE_Module_Type::resume().
00110 { 00111 ACE_TRACE ("ACE_Task_Base::resume"); 00112 ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1)); 00113 if (this->thr_count_ > 0) 00114 return this->thr_mgr_->resume_task (this); 00115 00116 return 0; 00117 }
int ACE_Task_Base::suspend | ( | void | ) | [virtual] |
Suspend a task.
Reimplemented from ACE_Service_Object.
Definition at line 97 of file Task.cpp.
References ACE_GUARD_RETURN, ACE_TRACE, ACE_Thread_Manager::suspend_task(), and thr_mgr_.
Referenced by ACE_Module_Type::suspend().
00098 { 00099 ACE_TRACE ("ACE_Task_Base::suspend"); 00100 ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1)); 00101 if (this->thr_count_ > 0) 00102 return this->thr_mgr_->suspend_task (this); 00103 00104 return 0; 00105 }
int ACE_Task_Base::svc | ( | void | ) | [virtual] |
Run by a daemon thread to handle deferred processing.
Reimplemented in ACE_Asynch_Pseudo_Task, ACE_Stream_Head<>, ACE_Stream_Tail<>, ACE_Thru_Task<>, and ACE_Thread_Timer_Queue_Adapter< TQ >.
Definition at line 38 of file Task.cpp.
References ACE_TRACE.
00039 { 00040 ACE_TRACE ("ACE_Task_Base::svc"); 00041 return 0; 00042 }
ACE_THR_FUNC_RETURN ACE_Task_Base::svc_run | ( | void * | ) | [static] |
Routine that runs the service routine as a daemon thread.
Definition at line 258 of file Task.cpp.
References ACE_TRACE, ACE_Thread_Manager::at_exit(), cleanup(), and thr_mgr().
Referenced by activate(), ACE_OS_Thread_Adapter::invoke(), and ACE_Thread_Adapter::invoke_i().
00259 { 00260 ACE_TRACE ("ACE_Task_Base::svc_run"); 00261 00262 ACE_Task_Base *t = (ACE_Task_Base *) args; 00263 00264 // Register ourself with our <Thread_Manager>'s thread exit hook 00265 // mechanism so that our close() hook will be sure to get invoked 00266 // when this thread exits. 00267 00268 #if defined ACE_HAS_SIG_C_FUNC 00269 t->thr_mgr ()->at_exit (t, ACE_Task_Base_cleanup, 0); 00270 #else 00271 t->thr_mgr ()->at_exit (t, ACE_Task_Base::cleanup, 0); 00272 #endif /* ACE_HAS_SIG_C_FUNC */ 00273 00274 // Call the Task's svc() hook method. 00275 int const svc_status = t->svc (); 00276 ACE_THR_FUNC_RETURN status; 00277 #if defined (ACE_HAS_INTEGRAL_TYPE_THR_FUNC_RETURN) 00278 // Reinterpret case between integral types is not mentioned in the C++ spec 00279 status = static_cast<ACE_THR_FUNC_RETURN> (svc_status); 00280 #else 00281 status = reinterpret_cast<ACE_THR_FUNC_RETURN> (svc_status); 00282 #endif /* ACE_HAS_INTEGRAL_TYPE_THR_FUNC_RETURN */ 00283 00284 // If we changed this zero change the other if in OS.cpp Thread_Adapter::invoke 00285 #if 1 00286 // Call the <Task->close> hook. 00287 ACE_Thread_Manager *thr_mgr_ptr = t->thr_mgr (); 00288 00289 // This calls the Task->close () hook. 00290 t->cleanup (t, 0); 00291 00292 // This prevents a second invocation of the cleanup code 00293 // (called later by <ACE_Thread_Manager::exit>. 00294 thr_mgr_ptr->at_exit (t, 0, 0); 00295 #endif 00296 return status; 00297 }
ACE_INLINE size_t ACE_Task_Base::thr_count | ( | void | ) | const |
Returns the number of threads currently running within a task. If we're a passive object this value is 0, else it's greater than 0.
Definition at line 61 of file Task.inl.
References ACE_GUARD_RETURN, ACE_TRACE, and thr_count_.
Referenced by ACE_Module< ACE_SYNCH_USE >::close_i().
00062 { 00063 ACE_TRACE ("ACE_Task_Base::thr_count"); 00064 ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, const_cast <ACE_Thread_Mutex&>(this->lock_), 0)); 00065 00066 return this->thr_count_; 00067 }
ACE_INLINE void ACE_Task_Base::thr_mgr | ( | ACE_Thread_Manager * | ) |
ACE_INLINE ACE_Thread_Manager * ACE_Task_Base::thr_mgr | ( | void | ) | const |
Get the thread manager associated with this Task.
Definition at line 32 of file Task.inl.
References ACE_TRACE, and thr_mgr_.
Referenced by ACE_OS_Thread_Adapter::invoke(), ACE_Thread_Adapter::invoke_i(), svc_run(), and thr_mgr().
int ACE_Task_Base::wait | ( | void | ) | [virtual] |
Block until there are no more threads running in this task. This method will not wait for either detached or daemon threads; the threads must have been spawned with the THR_JOINABLE
flag. Upon successful completion, the threads have been joined, so further attempts to join with any of the waited-for threads will fail.
0 | Success. | |
-1 | Failure (consult errno for further information). |
Definition at line 83 of file Task.cpp.
References ACE_TRACE.
Referenced by ACE_Module< ACE_SYNCH_USE >::close_i(), and ACE_Asynch_Pseudo_Task::stop().
00084 { 00085 ACE_TRACE ("ACE_Task_Base::wait"); 00086 00087 // If we don't have a thread manager, we probably were never 00088 // activated. 00089 if (this->thr_mgr () != 0) 00090 return this->thr_mgr ()->wait_task (this); 00091 else 00092 return 0; 00093 }
u_long ACE_Task_Base::flags_ [protected] |
ACE_Task flags.
Definition at line 276 of file Task.h.
Referenced by ACE_Module< ACE_SYNCH_USE >::reader(), and ACE_Module< ACE_SYNCH_USE >::writer().
int ACE_Task_Base::grp_id_ [protected] |
This maintains the group id of the Task.
Definition at line 279 of file Task.h.
Referenced by activate(), and grp_id().
ACE_thread_t ACE_Task_Base::last_thread_id_ [protected] |
Holds the thread ID of the last thread to exit svc() in this object.
Definition at line 288 of file Task.h.
Referenced by activate(), cleanup(), and last_thread().
size_t ACE_Task_Base::thr_count_ [protected] |
Count of the number of threads running within the task. If this value is greater than 0 then we're an active object and the value of <thr_count_> is the number of active threads at this instant. If the value == 0, then we're a passive object.
Definition at line 270 of file Task.h.
Referenced by cleanup(), and thr_count().
ACE_Thread_Manager* ACE_Task_Base::thr_mgr_ [protected] |