#include <Thread_Manager.h>
Inheritance diagram for ACE_Thread_Descriptor:
Public Member Functions | |
ACE_Thread_Descriptor (void) | |
ACE_thread_t | self (void) const |
Unique thread id. | |
void | self (ACE_hthread_t &) |
Unique handle to thread (used by Win32 and AIX). | |
void | dump (void) const |
Dump the state of an object. | |
void | log_msg_cleanup (ACE_Log_Msg *log_msg) |
int | at_exit (ACE_At_Thread_Exit *cleanup) |
int | at_exit (ACE_At_Thread_Exit &cleanup) |
int | at_exit (void *object, ACE_CLEANUP_FUNC cleanup_hook, void *param) |
~ACE_Thread_Descriptor (void) | |
Do nothing destructor to keep some compilers happy. | |
void | acquire_release (void) |
void | acquire (void) |
void | release (void) |
void | set_next (ACE_Thread_Descriptor *td) |
ACE_Thread_Descriptor * | get_next (void) const |
Private Member Functions | |
void | reset (ACE_Thread_Manager *tm) |
Reset this thread descriptor. | |
void | at_pop (int apply=1) |
void | at_push (ACE_At_Thread_Exit *cleanup, int is_owner=0) |
void | do_at_exit (void) |
Run the AT_Thread_Exit hooks. | |
void | terminate (void) |
Terminate realize the cleanup process to thread termination. | |
Private Attributes | |
ACE_Log_Msg * | log_msg_ |
ACE_At_Thread_Exit * | at_exit_list_ |
The AT_Thread_Exit list. | |
ACE_Cleanup_Info | cleanup_info_ |
ACE_Thread_Manager * | tm_ |
ACE_DEFAULT_THREAD_MANAGER_LOCK * | sync_ |
Registration lock to prevent premature removal of thread descriptor. | |
bool | terminated_ |
Keep track of termination status. | |
Friends | |
class | ACE_At_Thread_Exit |
class | ACE_Thread_Manager |
class | ACE_Double_Linked_List< ACE_Thread_Descriptor > |
class | ACE_Double_Linked_List_Iterator< ACE_Thread_Descriptor > |
Definition at line 229 of file Thread_Manager.h.
|
Definition at line 262 of file Thread_Manager.cpp. References ACE_DEFAULT_THREAD_MANAGER_LOCK, ACE_NEW, and ACE_TRACE.
00263 : log_msg_ (0), 00264 at_exit_list_ (0), 00265 terminated_ (false) 00266 { 00267 ACE_TRACE ("ACE_Thread_Descriptor::ACE_Thread_Descriptor"); 00268 ACE_NEW (this->sync_, 00269 ACE_DEFAULT_THREAD_MANAGER_LOCK); 00270 } |
|
Do nothing destructor to keep some compilers happy.
Definition at line 89 of file Thread_Manager.cpp. References sync_.
00090 { 00091 delete this->sync_; 00092 } |
|
Definition at line 294 of file Thread_Manager.cpp. References ACE_BIT_DISABLED, and sync_.
00295 { 00296 // Just try to acquire the lock then release it. 00297 #if defined (ACE_THREAD_MANAGER_USES_SAFE_SPAWN) 00298 if (ACE_BIT_DISABLED (this->thr_state_, ACE_Thread_Manager::ACE_THR_SPAWNED)) 00299 #endif /* ACE_THREAD_MANAGER_USES_SAFE_SPAWN */ 00300 { 00301 this->sync_->acquire (); 00302 } 00303 } |
|
Do nothing but to acquire the thread descriptor's lock and release. This will first check if the thread is registered or not. If it is already registered, there's no need to reacquire the lock again. This is used mainly to get newly spawned thread in synch with thread manager and prevent it from accessing its thread descriptor before it gets fully built. This function is only called from ACE_Log_Msg::thr_desc. Definition at line 273 of file Thread_Manager.cpp. References ACE_ASSERT, ACE_BIT_DISABLED, ACE_BIT_ENABLED, and sync_. Referenced by ACE_Log_Msg::thr_desc().
00274 { 00275 // Just try to acquire the lock then release it. 00276 #if defined (ACE_THREAD_MANAGER_USES_SAFE_SPAWN) 00277 if (ACE_BIT_DISABLED (this->thr_state_, ACE_Thread_Manager::ACE_THR_SPAWNED)) 00278 #endif /* ACE_THREAD_MANAGER_USES_SAFE_SPAWN */ 00279 { 00280 this->sync_->acquire (); 00281 // Acquire the lock before removing <td> from the thread table. If 00282 // this thread is in the table already, it should simply acquire the 00283 // lock easily. 00284 00285 // Once we get the lock, we must have registered. 00286 ACE_ASSERT (ACE_BIT_ENABLED (this->thr_state_, ACE_Thread_Manager::ACE_THR_SPAWNED)); 00287 00288 this->sync_->release (); 00289 // Release the lock before putting it back to freelist. 00290 } 00291 } |
|
Register an object (or array) for cleanup at thread termination. "cleanup_hook" points to a (global, or static member) function that is called for the object or array when it to be destroyed. It may perform any necessary cleanup specific for that object or its class. "param" is passed as the second parameter to the "cleanup_hook" function; the first parameter is the object (or array) to be destroyed. Returns 0 on success, non-zero on failure: -1 if virtual memory is exhausted or 1 if the object (or arrayt) had already been registered. Definition at line 219 of file Thread_Manager.cpp. References ACE_CLEANUP_FUNC, ACE_NEW_RETURN, ACE_TRACE, at_exit_list_, at_pop(), and at_push().
00222 { 00223 ACE_TRACE ("ACE_Thread_Descriptor::at_exit"); 00224 // To keep compatibility, when cleanup_hook is null really is a at_pop 00225 // without apply. 00226 if (cleanup_hook == 0) 00227 { 00228 if (this->at_exit_list_!= 0) 00229 this->at_pop(0); 00230 } 00231 else 00232 { 00233 ACE_At_Thread_Exit* cleanup = 0; 00234 ACE_NEW_RETURN (cleanup, 00235 ACE_At_Thread_Exit_Func (object, 00236 cleanup_hook, 00237 param), 00238 -1); 00239 this->at_push (cleanup); 00240 } 00241 return 0; 00242 } |
|
Register an At_Thread_Exit hook and the ownership is retained for the caller. Normally used when the at_exit hook is created in stack. Definition at line 127 of file Thread_Manager.cpp. References ACE_TRACE, and at_push().
|
|
Register an At_Thread_Exit hook and the ownership is acquire by Thread_Descriptor, this is the usual case when the AT is dynamically allocated. Definition at line 135 of file Thread_Manager.cpp. References ACE_TRACE, and at_push(). Referenced by ACE_Thread_Manager::at_exit().
|
|
Pop an At_Thread_Exit from at thread termination list, apply the at if apply is true. Definition at line 95 of file Thread_Manager.cpp. References ACE_TRACE, ACE_At_Thread_Exit::apply(), at_exit_list_, ACE_At_Thread_Exit::is_owner(), ACE_At_Thread_Exit::next_, and ACE_At_Thread_Exit::was_applied(). Referenced by at_exit(), ACE_At_Thread_Exit::do_apply(), and do_at_exit().
00096 { 00097 ACE_TRACE ("ACE_Thread_Descriptor::at_pop"); 00098 // Get first at from at_exit_list 00099 ACE_At_Thread_Exit* at = this->at_exit_list_; 00100 // Remove at from at_exit list 00101 this->at_exit_list_ = at->next_; 00102 // Apply if required 00103 if (apply) 00104 { 00105 at->apply (); 00106 // Do the apply method 00107 at->was_applied (1); 00108 // Mark at has been applied to avoid double apply from 00109 // at destructor 00110 } 00111 // If at is not owner delete at. 00112 if (!at->is_owner ()) 00113 delete at; 00114 } |
|
Push an At_Thread_Exit to at thread termination list and set the ownership of at. Definition at line 117 of file Thread_Manager.cpp. References ACE_TRACE, at_exit_list_, ACE_At_Thread_Exit::is_owner(), ACE_At_Thread_Exit::next_, and ACE_At_Thread_Exit::td_. Referenced by at_exit().
00118 { 00119 ACE_TRACE ("ACE_Thread_Descriptor::at_push"); 00120 cleanup->is_owner (is_owner); 00121 cleanup->td_ = this; 00122 cleanup->next_ = at_exit_list_; 00123 at_exit_list_ = cleanup; 00124 } |
|
Run the AT_Thread_Exit hooks.
Definition at line 148 of file Thread_Manager.cpp. References ACE_TRACE, at_exit_list_, and at_pop(). Referenced by terminate().
00149 { 00150 ACE_TRACE ("ACE_Thread_Descriptor::do_at_exit"); 00151 while (at_exit_list_!=0) 00152 this->at_pop (); 00153 } |
|
Dump the state of an object.
Definition at line 245 of file Thread_Manager.cpp. References ACE_BEGIN_DUMP, ACE_DEBUG, ACE_END_DUMP, ACE_TEXT, ACE_TRACE, and LM_DEBUG.
00246 { 00247 #if defined (ACE_HAS_DUMP) 00248 ACE_TRACE ("ACE_Thread_Descriptor::dump"); 00249 ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); 00250 00251 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nthr_id_ = %d"), this->thr_id_)); 00252 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nthr_handle_ = %d"), this->thr_handle_)); 00253 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\ngrp_id_ = %d"), this->grp_id_)); 00254 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nthr_state_ = %d"), this->thr_state_)); 00255 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\ncleanup_info_.cleanup_hook_ = %x"), this->cleanup_info_.cleanup_hook_)); 00256 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nflags_ = %x\n"), this->flags_)); 00257 00258 ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); 00259 #endif /* ACE_HAS_DUMP */ 00260 } |
|
Definition at line 166 of file Thread_Manager.inl. References ACE_TRACE.
|
|
This cleanup function must be called only for ACE_TSS_cleanup. The ACE_TSS_cleanup delegate Log_Msg instance destruction when Log_Msg cleanup is called before terminate. Definition at line 150 of file Thread_Manager.inl.
00152 { 00153 log_msg_ = log_msg; 00154 } |
|
Definition at line 306 of file Thread_Manager.cpp. References ACE_BIT_DISABLED, and sync_.
00307 { 00308 // Just try to acquire the lock then release it. 00309 #if defined (ACE_THREAD_MANAGER_USES_SAFE_SPAWN) 00310 if (ACE_BIT_DISABLED (this->thr_state_, ACE_Thread_Manager::ACE_THR_SPAWNED)) 00311 #endif /* ACE_THREAD_MANAGER_USES_SAFE_SPAWN */ 00312 { 00313 this->sync_->release (); 00314 // Release the lock before putting it back to freelist. 00315 } 00316 } |
|
Reset this thread descriptor.
Definition at line 174 of file Thread_Manager.inl. References ACE_TRACE, at_exit_list_, ACE_Thread_Descriptor_Base::reset(), and terminated_.
00175 { 00176 ACE_TRACE ("ACE_Thread_Descriptor::reset"); 00177 this->ACE_Thread_Descriptor_Base::reset (); 00178 this->at_exit_list_ = 0; 00179 // Start the at_exit hook list. 00180 this->tm_ = tm; 00181 // Setup the Thread_Manager. 00182 this->log_msg_ = 0; 00183 this->terminated_ = false; 00184 } |
|
Unique handle to thread (used by Win32 and AIX).
Definition at line 143 of file Thread_Manager.inl. References ACE_hthread_t, and ACE_TRACE.
00144 { 00145 ACE_TRACE ("ACE_Thread_Descriptor::self"); 00146 handle = this->thr_handle_; 00147 } |
|
Unique thread id.
Definition at line 134 of file Thread_Manager.inl. References ACE_TRACE. Referenced by ACE_Thread_Manager::remove_thr(), and ACE_Thread_Manager::thr_self().
|
|
Set/get the Definition at line 158 of file Thread_Manager.inl. References ACE_TRACE.
|
|
Terminate realize the cleanup process to thread termination.
Definition at line 156 of file Thread_Manager.cpp. References ACE_BIT_DISABLED, ACE_BIT_ENABLED, ACE_LOG_MSG, ACE_SET_BITS, ACE_TRACE, do_at_exit(), ACE_Thread_Manager::register_as_terminated(), ACE_Thread_Manager::remove_thr(), and terminated_. Referenced by ACE_Thread_Manager::exit().
00157 { 00158 ACE_TRACE ("ACE_Thread_Descriptor::terminate"); 00159 00160 if (!terminated_) 00161 { 00162 ACE_Log_Msg* log_msg = this->log_msg_; 00163 terminated_ = true; 00164 // Run at_exit hooks 00165 this->do_at_exit (); 00166 // We must remove Thread_Descriptor from Thread_Manager list 00167 if (this->tm_ != 0) 00168 { 00169 int close_handle = 0; 00170 00171 #if !defined (ACE_VXWORKS) 00172 // Threads created with THR_DAEMON shouldn't exist here, but 00173 // just to be safe, let's put it here. 00174 00175 if (ACE_BIT_DISABLED (this->thr_state_, ACE_Thread_Manager::ACE_THR_JOINING)) 00176 { 00177 if (ACE_BIT_DISABLED (this->flags_, THR_DETACHED | THR_DAEMON) 00178 || ACE_BIT_ENABLED (this->flags_, THR_JOINABLE)) 00179 { 00180 // Mark thread as terminated. 00181 ACE_SET_BITS (this->thr_state_, ACE_Thread_Manager::ACE_THR_TERMINATED); 00182 tm_->register_as_terminated (this); 00183 // Must copy the information here because td will be 00184 // "freed" below. 00185 } 00186 #if defined (ACE_WIN32) 00187 else 00188 { 00189 close_handle = 1; 00190 } 00191 #endif /* ACE_WIN32 */ 00192 } 00193 #endif /* ! ACE_VXWORKS */ 00194 00195 // Remove thread descriptor from the table. 00196 if (this->tm_ != 0) 00197 tm_->remove_thr (this, close_handle); 00198 } 00199 00200 // Check if we need delete ACE_Log_Msg instance 00201 // If ACE_TSS_cleanup was not executed first log_msg == 0 00202 if (log_msg == 0) 00203 { 00204 // Only inform to ACE_TSS_cleanup that it must delete the log instance 00205 // setting ACE_LOG_MSG thr_desc to 0. 00206 ACE_LOG_MSG->thr_desc (0); 00207 } 00208 else 00209 { 00210 // Thread_Descriptor is the owner of the Log_Msg instance!! 00211 // deleted. 00212 this->log_msg_ = 0; 00213 delete log_msg; 00214 } 00215 } 00216 } |
|
Definition at line 231 of file Thread_Manager.h. |
|
Reimplemented from ACE_Thread_Descriptor_Base. Definition at line 233 of file Thread_Manager.h. |
|
Reimplemented from ACE_Thread_Descriptor_Base. Definition at line 234 of file Thread_Manager.h. |
|
Reimplemented from ACE_Thread_Descriptor_Base. Definition at line 232 of file Thread_Manager.h. |
|
The AT_Thread_Exit list.
Definition at line 329 of file Thread_Manager.h. Referenced by at_exit(), at_pop(), at_push(), do_at_exit(), and reset(). |
|
Stores the cleanup info for a thread.
Definition at line 335 of file Thread_Manager.h. Referenced by ACE_Thread_Manager::run_thread_exit_hooks(). |
|
Thread_Descriptor is the ownership of ACE_Log_Msg if log_msg_!=0 This can occur because ACE_TSS_cleanup was executed before terminate. Definition at line 326 of file Thread_Manager.h. |
|
Registration lock to prevent premature removal of thread descriptor.
Definition at line 342 of file Thread_Manager.h. Referenced by acquire(), acquire_release(), ACE_Thread_Manager::append_thr(), release(), and ~ACE_Thread_Descriptor(). |
|
Keep track of termination status.
Definition at line 345 of file Thread_Manager.h. Referenced by reset(), and terminate(). |
|
Pointer to an ACE_Thread_Manager or NULL if there's no ACE_Thread_Manager> Definition at line 339 of file Thread_Manager.h. Referenced by ACE_Thread_Manager::append_thr(), and ACE_Thread_Manager::remove_thr(). |