Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members   Related Pages  

ACE_Thread_Manager Class Reference

Manages a pool of threads. More...

#include <Thread_Manager.h>

Collaboration diagram for ACE_Thread_Manager:

Collaboration graph
[legend]
List of all members.

Public Types

typedef int(ACE_Thread_Manager::* ACE_THR_MEMBER_FUNC )(ACE_Thread_Descriptor *, int)
enum  {
  ACE_THR_IDLE = 0x00000000, ACE_THR_SPAWNED = 0x00000001, ACE_THR_RUNNING = 0x00000002, ACE_THR_SUSPENDED = 0x00000004,
  ACE_THR_CANCELLED = 0x00000008, ACE_THR_TERMINATED = 0x00000010, ACE_THR_JOINING = 0x10000000
}

Public Methods

 ACE_Thread_Manager (size_t preaolloc=ACE_DEFAULT_THREAD_MANAGER_PREALLOC, size_t lwm=ACE_DEFAULT_THREAD_MANAGER_LWM, size_t inc=ACE_DEFAULT_THREAD_MANAGER_INC, size_t hwm=ACE_DEFAULT_THREAD_MANAGER_HWM)
 Initialization and termination methods. More...

virtual ~ACE_Thread_Manager (void)
int open (size_t size=0)
 No-op. Currently unused. More...

int close (void)
int spawn (ACE_THR_FUNC func, void *args=0, long flags=THR_NEW_LWP|THR_JOINABLE, ACE_thread_t *=0, ACE_hthread_t *t_handle=0, long priority=ACE_DEFAULT_THREAD_PRIORITY, int grp_id=-1, void *stack=0, size_t stack_size=0)
int spawn_n (size_t n, ACE_THR_FUNC func, void *args=0, long flags=THR_NEW_LWP|THR_JOINABLE, 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)
int spawn_n (ACE_thread_t thread_ids[], size_t n, ACE_THR_FUNC func, void *args, long flags, long priority=ACE_DEFAULT_THREAD_PRIORITY, int grp_id=-1, void *stack[]=0, size_t stack_size[]=0, ACE_hthread_t thread_handles[]=0, ACE_Task_Base *task=0)
ACE_THR_FUNC_RETURN exit (ACE_THR_FUNC_RETURN status=0, int do_thread_exit=1)
int wait (const ACE_Time_Value *timeout=0, int abandon_detached_threads=0)
int join (ACE_thread_t tid, ACE_THR_FUNC_RETURN *status=0)
 Join a thread specified by <tid>. Do not wait on a detached thread. More...

int wait_grp (int grp_id)
int thr_self (ACE_hthread_t &)
ACE_thread_t thr_self (void)
ACE_Task_Basetask (void)
int suspend_all (void)
 Suspend all threads. More...

int suspend (ACE_thread_t)
 Suspend a single thread. More...

int suspend_grp (int grp_id)
 Suspend a group of threads. More...

int testsuspend (ACE_thread_t t_id)
int resume_all (void)
 Resume all stopped threads. More...

int resume (ACE_thread_t)
 Resume a single thread. More...

int resume_grp (int grp_id)
 Resume a group of threads. More...

int testresume (ACE_thread_t t_id)
int kill_all (int signum)
int kill (ACE_thread_t, int signum)
int kill_grp (int grp_id, int signum)
int cancel_all (int async_cancel=0)
int cancel (ACE_thread_t, int async_cancel=0)
int cancel_grp (int grp_id, int async_cancel=0)
int testcancel (ACE_thread_t t_id)
int set_grp (ACE_thread_t, int grp_id)
 Set group ids for a particular thread id. More...

int get_grp (ACE_thread_t, int &grp_id)
 Get group ids for a particular thread id. More...

int wait_task (ACE_Task_Base *task)
int suspend_task (ACE_Task_Base *task)
int resume_task (ACE_Task_Base *task)
int kill_task (ACE_Task_Base *task, int signum)
int cancel_task (ACE_Task_Base *task, int async_cancel=0)
int hthread_within (ACE_hthread_t handle)
 Check if the thread is managed by the thread manager. Return true if the thread is found, false otherwise. More...

int thread_within (ACE_thread_t tid)
int num_tasks_in_group (int grp_id)
 Returns the number of <ACE_Task_Base> in a group. More...

int num_threads_in_task (ACE_Task_Base *task)
 Returns the number of threads in an <ACE_Task_Base>. More...

ssize_t task_list (int grp_id, ACE_Task_Base *task_list[], size_t n)
ssize_t thread_list (ACE_Task_Base *task, ACE_thread_t thread_list[], size_t n)
ssize_t hthread_list (ACE_Task_Base *task, ACE_hthread_t hthread_list[], size_t n)
ssize_t thread_grp_list (int grp_id, ACE_thread_t thread_list[], size_t n)
ssize_t hthread_grp_list (int grp_id, ACE_hthread_t hthread_list[], size_t n)
ssize_t task_all_list (ACE_Task_Base *task_list[], size_t n)
ssize_t thread_all_list (ACE_thread_t thread_list[], size_t n)
int set_grp (ACE_Task_Base *task, int grp_id)
 Set group ids for a particular task. More...

int get_grp (ACE_Task_Base *task, int &grp_id)
 Get group ids for a particular task. More...

size_t count_threads (void) const
 Return a count of the current number of threads active in the <Thread_Manager>. More...

int at_exit (ACE_At_Thread_Exit *cleanup)
int at_exit (ACE_At_Thread_Exit &cleanup)
 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. More...

int at_exit (void *object, ACE_CLEANUP_FUNC cleanup_hook, void *param)
void wait_on_exit (int dowait)
 Access function to determine whether the Thread_Manager will wait for its thread to exit or not when being closing down. More...

int wait_on_exit (void)
void dump (void)
 Dump the state of an object. More...


Static Public Methods

ACE_Thread_Manager * instance (void)
 Get pointer to a process-wide <ACE_Thread_Manager>. More...

ACE_Thread_Manager * instance (ACE_Thread_Manager *)
 Set pointer to a process-wide <ACE_Thread_Manager> and return existing pointer. More...

void close_singleton (void)
 Delete the dynamically allocated Singleton. More...


Public Attributes

 ACE_ALLOC_HOOK_DECLARE
 Declare the dynamic allocation hooks. More...


Protected Methods

ACE_Thread_Descriptorthread_desc_self (void)
ACE_Thread_Descriptorthread_descriptor (ACE_thread_t)
 Return a pointer to the thread's Thread_Descriptor, 0 if fail. More...

ACE_Thread_Descriptorhthread_descriptor (ACE_hthread_t)
 Return a pointer to the thread's Thread_Descriptor, 0 if fail. More...

virtual int spawn_i (ACE_THR_FUNC func, void *args, long flags, ACE_thread_t *=0, ACE_hthread_t *t_handle=0, long priority=ACE_DEFAULT_THREAD_PRIORITY, int grp_id=-1, void *stack=0, size_t stack_size=0, ACE_Task_Base *task=0)
 Create a new thread (must be called with locks held). More...

void run_thread_exit_hooks (int i)
 Run the registered hooks when the thread exits. More...

ACE_Thread_Descriptorfind_thread (ACE_thread_t t_id)
 Locate the index of the table slot occupied by <t_id>. Returns -1 if <t_id> is not in the table doesn't contain <t_id>. More...

ACE_Thread_Descriptorfind_hthread (ACE_hthread_t h_id)
 Locate the index of the table slot occupied by <h_id>. Returns -1 if <h_id> is not in the table doesn't contain <h_id>. More...

ACE_Thread_Descriptorfind_task (ACE_Task_Base *task, size_t slot=0)
int insert_thr (ACE_thread_t t_id, ACE_hthread_t, int grp_id=-1, long flags=0)
 Insert a thread in the table (checks for duplicates). More...

int append_thr (ACE_thread_t t_id, ACE_hthread_t, ACE_UINT32, int grp_id, ACE_Task_Base *task=0, long flags=0, ACE_Thread_Descriptor *td=0)
 Append a thread in the table (adds at the end, growing the table if necessary). More...

void remove_thr (ACE_Thread_Descriptor *td, int close_handler)
 Remove thread from the table. More...

void remove_thr_all (void)
 Remove all threads from the table. More...

int check_state (ACE_UINT32 state, ACE_thread_t thread, int enable=1)
int apply_task (ACE_Task_Base *task, ACE_THR_MEMBER_FUNC, int=0)
 Apply <func> to all members of the table that match the <task>. More...

int apply_grp (int grp_id, ACE_THR_MEMBER_FUNC func, int arg=0)
 Apply <func> to all members of the table that match the <grp_id>. More...

int apply_all (ACE_THR_MEMBER_FUNC, int=0)
 Apply <func> to all members of the table. More...

int join_thr (ACE_Thread_Descriptor *td, int=0)
 Join the thread described in <tda>. More...

int resume_thr (ACE_Thread_Descriptor *td, int=0)
 Resume the thread described in <tda>. More...

int suspend_thr (ACE_Thread_Descriptor *td, int=0)
 Suspend the thread described in <tda>. More...

int kill_thr (ACE_Thread_Descriptor *td, int signum)
 Send signal <signum> to the thread described in <tda>. More...

int cancel_thr (ACE_Thread_Descriptor *td, int async_cancel=0)
 Set the cancellation flag for the thread described in <tda>. More...

int register_as_terminated (ACE_Thread_Descriptor *td)
 Register a thread as terminated and put it into the <terminated_thr_list_>. More...


Static Protected Methods

int set_thr_exit (ACE_TSS_TYPE(ACE_Thread_Exit)*ptr)
 Setting the static ACE_TSS_TYPE (ACE_Thread_Exit) *thr_exit_ pointer. More...


Protected Attributes

ACE_Double_Linked_List< ACE_Thread_Descriptorthr_list_
ACE_Double_Linked_List< ACE_Thread_Descriptor_Baseterminated_thr_list_
 Collect terminated but not yet joined thread entries. More...

ACE_Unbounded_Queue< ACE_Thread_Descriptor * > thr_to_be_removed_
 Collect pointers to thread descriptors of threads to be removed later. More...

int grp_id_
 Keeps track of the next group id to assign. More...

int automatic_wait_
 Set if we want the Thread_Manager to wait on all threads before being closed, reset otherwise. More...

ACE_Thread_Mutex lock_
 Serialize access to the <zero_cond_>. More...

ACE_Condition_Thread_Mutex zero_cond_
 Keep track of when there are no more threads. More...


Static Private Methods

 ACE_TSS_TYPE (ACE_Thread_Exit)*thr_exit_
 Global ACE_TSS (ACE_Thread_Exit) object ptr. More...


Private Attributes

ACE_Locked_Free_List< ACE_Thread_Descriptor,
ACE_SYNCH_MUTEX > 
thread_desc_freelist_

Static Private Attributes

ACE_Thread_Manager * thr_mgr_ = 0
 Pointer to a process-wide <ACE_Thread_Manager>. More...

int delete_thr_mgr_ = 0
 Must delete the <thr_mgr_> if non-0. More...


Friends

class ACE_Thread_Control
class ACE_Thread_Exit
class ACE_Thread_Descriptor

Detailed Description

Manages a pool of threads.

This class allows operations on groups of threads atomically. The default behavior of thread manager is to wait on all threads under it's management when it gets destructed. Therefore, remember to remove a thread from thread manager if you don't want it to wait for the thread. There are also function to disable this default wait-on-exit behavior. However, if your program depends on turning this off to run correctly, you are probably doing something wrong. Rule of thumb, use ACE_Thread to manage your daemon threads. Notice that if there're threads live beyond the scope of <main>, you are sure to have resource leaks in your program. Remember to wait on threads before exiting <main> if that could happen in your programs.

Definition at line 387 of file Thread_Manager.h.


Member Typedef Documentation

typedef int(ACE_Thread_Manager::* ACE_Thread_Manager::ACE_THR_MEMBER_FUNC)(ACE_Thread_Descriptor *, int)
 

Definition at line 399 of file Thread_Manager.h.

Referenced by cancel_all, cancel_grp, cancel_task, kill_grp, kill_task, resume_all, resume_grp, resume_task, suspend_all, suspend_grp, and suspend_task.


Member Enumeration Documentation

anonymous enum
 

Enumeration values:
ACE_THR_IDLE  Uninitialized.
ACE_THR_SPAWNED  Created but not yet running.
ACE_THR_RUNNING  Thread is active (naturally, we don't know if it's actually *running* because we aren't the scheduler...).
ACE_THR_SUSPENDED  Thread is suspended.
ACE_THR_CANCELLED  Thread has been cancelled (which is an indiction that it needs to terminate...).
ACE_THR_TERMINATED  Thread has shutdown, but the slot in the thread manager hasn't been reclaimed yet.
ACE_THR_JOINING  Join operation has been invoked on the thread by thread manager.

Definition at line 404 of file Thread_Manager.h.

00405   {
00406     /// Uninitialized.
00407     ACE_THR_IDLE = 0x00000000,
00408 
00409     /// Created but not yet running.
00410     ACE_THR_SPAWNED = 0x00000001,
00411 
00412     /// Thread is active (naturally, we don't know if it's actually
00413     /// *running* because we aren't the scheduler...).
00414     ACE_THR_RUNNING = 0x00000002,
00415 
00416     /// Thread is suspended.
00417     ACE_THR_SUSPENDED = 0x00000004,
00418 
00419     /// Thread has been cancelled (which is an indiction that it needs to
00420     /// terminate...).
00421     ACE_THR_CANCELLED = 0x00000008,
00422 
00423     /// Thread has shutdown, but the slot in the thread manager hasn't
00424     /// been reclaimed yet.
00425     ACE_THR_TERMINATED = 0x00000010,
00426 
00427     /// Join operation has been invoked on the thread by thread manager.
00428     ACE_THR_JOINING = 0x10000000
00429   };


Constructor & Destructor Documentation

ACE_Thread_Manager::ACE_Thread_Manager size_t    preaolloc = ACE_DEFAULT_THREAD_MANAGER_PREALLOC,
size_t    lwm = ACE_DEFAULT_THREAD_MANAGER_LWM,
size_t    inc = ACE_DEFAULT_THREAD_MANAGER_INC,
size_t    hwm = ACE_DEFAULT_THREAD_MANAGER_HWM
 

Initialization and termination methods.

Internally, ACE_Thread_Manager keeps a freelist for caching resources it uses to keep track of managed threads (not the threads themselves.) prealloc, lwm, inc, @hwm determine the initial size, the low water mark, increment step, and high water mark of the freelist.

See also:
ACE_Free_List

Definition at line 324 of file Thread_Manager.cpp.

References ACE_FREE_LIST_WITH_POOL, and ACE_TRACE.

00328   : grp_id_ (1),
00329     automatic_wait_ (1)
00330 #if defined (ACE_HAS_THREADS)
00331     , zero_cond_ (lock_)
00332 #endif /* ACE_HAS_THREADS */
00333     , thread_desc_freelist_ (ACE_FREE_LIST_WITH_POOL,
00334                              prealloc, lwm, hwm, inc)
00335 {
00336   ACE_TRACE ("ACE_Thread_Manager::ACE_Thread_Manager");
00337 }

ACE_Thread_Manager::~ACE_Thread_Manager void    [virtual]
 

Definition at line 419 of file Thread_Manager.cpp.

References ACE_TRACE, and close.

00420 {
00421   ACE_TRACE ("ACE_Thread_Manager::~ACE_Thread_Manager");
00422   this->close ();
00423 }


Member Function Documentation

ACE_Thread_Manager::ACE_TSS_TYPE ACE_Thread_Exit    [static, private]
 

Global ACE_TSS (ACE_Thread_Exit) object ptr.

int ACE_Thread_Manager::append_thr ACE_thread_t    t_id,
ACE_hthread_t   ,
ACE_UINT32   ,
int    grp_id,
ACE_Task_Base   task = 0,
long    flags = 0,
ACE_Thread_Descriptor   td = 0
[protected]
 

Append a thread in the table (adds at the end, growing the table if necessary).

Definition at line 751 of file Thread_Manager.cpp.

References ACE_hthread_t, ACE_NEW_RETURN, ACE_SET_BITS, ACE_thread_t, ACE_TRACE, ACE_OS_Thread_Descriptor::flags_, ACE_Thread_Descriptor_Base::grp_id_, ACE_Double_Linked_List< ACE_Thread_Descriptor >::insert_head, ACE_Thread_Descriptor::sync_, ACE_Thread_Descriptor_Base::task_, ACE_Thread_Descriptor_Base::thr_handle_, ACE_Thread_Descriptor_Base::thr_id_, thr_list_, ACE_Thread_Descriptor_Base::thr_state_, and ACE_Thread_Descriptor::tm_.

Referenced by insert_thr, and spawn_i.

00758 {
00759   ACE_TRACE ("ACE_Thread_Manager::append_thr");
00760   ACE_Thread_Descriptor *thr_desc;
00761 
00762   if (td == 0)
00763     {
00764     ACE_NEW_RETURN (thr_desc,
00765                     ACE_Thread_Descriptor,
00766                     -1);
00767 #if !defined(ACE_USE_ONE_SHOT_AT_THREAD_EXIT)
00768     thr_desc->tm_ = this;
00769     // Setup the Thread_Manager.
00770 #endif /* !ACE_USE_ONE_SHOT_AT_THREAD_EXIT */
00771   }
00772   else
00773     thr_desc = td;
00774 
00775   thr_desc->thr_id_ = t_id;
00776   thr_desc->thr_handle_ = t_handle;
00777   thr_desc->grp_id_ = grp_id;
00778   thr_desc->task_ = task;
00779   thr_desc->flags_ = flags;
00780 
00781   this->thr_list_.insert_head (thr_desc);
00782   ACE_SET_BITS (thr_desc->thr_state_, thr_state);
00783   thr_desc->sync_->release ();
00784 
00785   return 0;
00786 }

int ACE_Thread_Manager::apply_all ACE_THR_MEMBER_FUNC   ,
int    = 0
[protected]
 

Apply <func> to all members of the table.

Definition at line 1317 of file Thread_Manager.cpp.

References ACE_ASSERT, ACE_GUARD_RETURN, ACE_MT, ACE_TRACE, ACE_Double_Linked_List_Iterator::advance, ACE_Unbounded_Queue< ACE_Thread_Descriptor * >::dequeue_head, ACE_Double_Linked_List_Iterator_Base::done, ACE_Unbounded_Queue< ACE_Thread_Descriptor * >::is_empty, ACE_Double_Linked_List_Iterator_Base::next, remove_thr, and thr_to_be_removed_.

Referenced by cancel_all, kill_all, resume_all, and suspend_all.

01318 {
01319   ACE_TRACE ("ACE_Thread_Manager::apply_all");
01320   ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
01321   ACE_ASSERT (this->thr_to_be_removed_.is_empty ());
01322 
01323   int result = 0;
01324 
01325   for (ACE_Double_Linked_List_Iterator<ACE_Thread_Descriptor> iter (this->thr_list_);
01326        !iter.done ();
01327        iter.advance ())
01328     if ((this->*func)(iter.next (), arg) == -1)
01329       result = -1;
01330 
01331   // Must remove threads after we have traversed the thr_list_ to
01332   // prevent clobber thr_list_'s integrity.
01333 
01334   if (! this->thr_to_be_removed_.is_empty ())
01335     {
01336       // Save/restore errno.
01337       ACE_Errno_Guard error (errno);
01338 
01339       for (ACE_Thread_Descriptor *td;
01340            this->thr_to_be_removed_.dequeue_head (td) != -1;
01341            )
01342         this->remove_thr (td, 1);
01343     }
01344 
01345   return result;
01346 }

int ACE_Thread_Manager::apply_grp int    grp_id,
ACE_THR_MEMBER_FUNC    func,
int    arg = 0
[protected]
 

Apply <func> to all members of the table that match the <grp_id>.

Definition at line 1243 of file Thread_Manager.cpp.

References ACE_ASSERT, ACE_GUARD_RETURN, ACE_MT, ACE_TRACE, ACE_Double_Linked_List_Iterator::advance, ACE_Unbounded_Queue< ACE_Thread_Descriptor * >::dequeue_head, ACE_Double_Linked_List_Iterator_Base::done, ACE_Unbounded_Queue< ACE_Thread_Descriptor * >::is_empty, ACE_Double_Linked_List_Iterator_Base::next, remove_thr, and thr_to_be_removed_.

Referenced by cancel_grp, kill_grp, resume_grp, and suspend_grp.

01246 {
01247   ACE_TRACE ("ACE_Thread_Manager::apply_grp");
01248   ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_monx, this->lock_, -1));
01249   ACE_ASSERT (this->thr_to_be_removed_.is_empty ());
01250 
01251   int result = 0;
01252 
01253   for (ACE_Double_Linked_List_Iterator<ACE_Thread_Descriptor> iter (this->thr_list_);
01254        !iter.done ();
01255        iter.advance ())
01256     if (iter.next ()->grp_id_ == grp_id)
01257       if ((this->*func) (iter.next (), arg) == -1)
01258         result = -1;
01259 
01260   // Must remove threads after we have traversed the thr_list_ to
01261   // prevent clobber thr_list_'s integrity.
01262 
01263   if (! this->thr_to_be_removed_.is_empty ())
01264     {
01265       // Save/restore errno.
01266       ACE_Errno_Guard error (errno);
01267 
01268       for (ACE_Thread_Descriptor *td;
01269            this->thr_to_be_removed_.dequeue_head (td) != -1;
01270            )
01271         this->remove_thr (td, 1);
01272     }
01273 
01274   return result;
01275 }

int ACE_Thread_Manager::apply_task ACE_Task_Base   task,
ACE_THR_MEMBER_FUNC   ,
int    = 0
[protected]
 

Apply <func> to all members of the table that match the <task>.

Definition at line 1774 of file Thread_Manager.cpp.

References ACE_ASSERT, ACE_GUARD_RETURN, ACE_MT, ACE_TRACE, ACE_Double_Linked_List_Iterator::advance, ACE_Unbounded_Queue< ACE_Thread_Descriptor * >::dequeue_head, ACE_Double_Linked_List_Iterator_Base::done, ACE_Unbounded_Queue< ACE_Thread_Descriptor * >::is_empty, ACE_Double_Linked_List_Iterator_Base::next, remove_thr, and thr_to_be_removed_.

Referenced by cancel_task, kill_task, resume_task, and suspend_task.

01777 {
01778   ACE_TRACE ("ACE_Thread_Manager::apply_task");
01779   ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
01780   ACE_ASSERT (this->thr_to_be_removed_.is_empty ());
01781 
01782   int result = 0;
01783 
01784   for (ACE_Double_Linked_List_Iterator<ACE_Thread_Descriptor> iter (this->thr_list_);
01785        !iter.done ();
01786        iter.advance ())
01787     if (iter.next ()->task_ == task
01788         && (this->*func) (iter.next (), arg) == -1)
01789       result = -1;
01790 
01791   // Must remove threads after we have traversed the thr_list_ to
01792   // prevent clobber thr_list_'s integrity.
01793 
01794   if (! this->thr_to_be_removed_.is_empty ())
01795     {
01796       // Save/restore errno.
01797       ACE_Errno_Guard error (errno);
01798 
01799       for (ACE_Thread_Descriptor *td;
01800            this->thr_to_be_removed_.dequeue_head (td) != -1;
01801            )
01802         this->remove_thr (td, 1);
01803     }
01804 
01805   return result;
01806 }

ACE_INLINE int ACE_Thread_Manager::at_exit void *    object,
ACE_CLEANUP_FUNC    cleanup_hook,
void *    param
 

Deprecated:
This function is deprecated. Please use the previous two at_exit method. Notice that you should avoid mixing this method with the previous two at_exit methods.
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. "cleanup_hook", for example, may delete the object (or array). If <cleanup_hook> == 0, the <object> will _NOT_ get cleanup at thread exit. You can use this to cancel the previously added at_exit.

Definition at line 292 of file Thread_Manager.i.

References ACE_CLEANUP_FUNC, ACE_Thread_Descriptor::at_exit, and thread_desc_self.

00295 {
00296   ACE_Thread_Descriptor *td = this->thread_desc_self ();
00297   if (td == 0)
00298     return -1;
00299   else
00300     return td->at_exit (object,
00301                         cleanup_hook,
00302                         param);
00303 }

ACE_INLINE int ACE_Thread_Manager::at_exit ACE_At_Thread_Exit   cleanup
 

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 281 of file Thread_Manager.i.

References ACE_Thread_Descriptor::at_exit, and thread_desc_self.

00282 {
00283   ACE_Thread_Descriptor *td = this->thread_desc_self ();
00284   if (td == 0)
00285     return -1;
00286   else
00287     return td->at_exit (at);
00288 }

ACE_INLINE int ACE_Thread_Manager::at_exit ACE_At_Thread_Exit   cleanup
 

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 271 of file Thread_Manager.i.

References ACE_Thread_Descriptor::at_exit, and thread_desc_self.

Referenced by ACE_OS_Thread_Adapter::invoke, ACE_Thread_Adapter::invoke_i, and ACE_Task_Base::svc_run.

00272 {
00273   ACE_Thread_Descriptor *td = this->thread_desc_self ();
00274   if (td == 0)
00275     return -1;
00276   else
00277     return td->at_exit (at);
00278 }

int ACE_Thread_Manager::cancel ACE_thread_t   ,
int    async_cancel = 0
 

Cancel a single thread.

Definition at line 1098 of file Thread_Manager.cpp.

References ACE_EXECUTE_OP, ACE_thread_t, and ACE_TRACE.

01099 {
01100   ACE_TRACE ("ACE_Thread_Manager::cancel");
01101   ACE_EXECUTE_OP (this->cancel_thr, async_cancel);
01102 }

int ACE_Thread_Manager::cancel_all int    async_cancel = 0
 

Cancel's all the threads.

Definition at line 1372 of file Thread_Manager.cpp.

References ACE_THR_MEMBER_FUNC, ACE_TRACE, apply_all, and cancel_thr.

01373 {
01374   ACE_TRACE ("ACE_Thread_Manager::cancel_all");
01375   return this->apply_all (ACE_THR_MEMBER_FUNC (&ACE_Thread_Manager::cancel_thr),
01376                           async_cancel);
01377 }

int ACE_Thread_Manager::cancel_grp int    grp_id,
int    async_cancel = 0
 

Cancel a group of threads.

Definition at line 1308 of file Thread_Manager.cpp.

References ACE_THR_MEMBER_FUNC, ACE_TRACE, apply_grp, and cancel_thr.

01309 {
01310   ACE_TRACE ("ACE_Thread_Manager::cancel_grp");
01311   return this->apply_grp (grp_id,
01312                           ACE_THR_MEMBER_FUNC (&ACE_Thread_Manager::cancel_thr),
01313                           async_cancel);
01314 }

int ACE_Thread_Manager::cancel_task ACE_Task_Base   task,
int    async_cancel = 0
 

Cancel all threads in an <ACE_Task>. If <async_cancel> is non-0, then asynchronously cancel these threads if the OS platform supports cancellation. Otherwise, perform a "cooperative" cancellation.

Definition at line 1917 of file Thread_Manager.cpp.

References ACE_THR_MEMBER_FUNC, ACE_TRACE, apply_task, and cancel_thr.

01919 {
01920   ACE_TRACE ("ACE_Thread_Manager::cancel_task");
01921   return this->apply_task (task,
01922                            ACE_THR_MEMBER_FUNC (&ACE_Thread_Manager::cancel_thr),
01923                            async_cancel);
01924 }

int ACE_Thread_Manager::cancel_thr ACE_Thread_Descriptor   td,
int    async_cancel = 0
[protected]
 

Set the cancellation flag for the thread described in <tda>.

Definition at line 1013 of file Thread_Manager.cpp.

References ACE_SET_BITS, ACE_THR_CANCELLED, ACE_TRACE, ACE_Thread::cancel, ACE_Thread_Descriptor_Base::thr_id_, and ACE_Thread_Descriptor_Base::thr_state_.

Referenced by cancel_all, cancel_grp, and cancel_task.

01014 {
01015   ACE_TRACE ("ACE_Thread_Manager::cancel_thr");
01016   // Must set the state first and then try to cancel the thread.
01017   ACE_SET_BITS (td->thr_state_, ACE_THR_CANCELLED);
01018 
01019   if (async_cancel != 0)
01020     // Note that this call only does something relevant if the OS
01021     // platform supports asynchronous thread cancellation.  Otherwise,
01022     // it's a no-op.
01023     return ACE_Thread::cancel (td->thr_id_);
01024 
01025   return 0;
01026 }

int ACE_Thread_Manager::check_state ACE_UINT32    state,
ACE_thread_t    thread,
int    enable = 1
[protected]
 

Efficiently check whether <thread> is in a particular <state>. This call updates the TSS cache if possible to speed up subsequent searches.

Definition at line 1114 of file Thread_Manager.cpp.

References ACE_BIT_DISABLED, ACE_BIT_ENABLED, ACE_FIND, ACE_GUARD_RETURN, ACE_LOG_MSG, ACE_MT, ACE_thread_t, ACE_TRACE, ACE_OS::thr_equal, ACE_OS::thr_self, and ACE_Thread_Descriptor_Base::thr_state_.

Referenced by testcancel, testresume, and testsuspend.

01117 {
01118   ACE_TRACE ("ACE_Thread_Manager::check_state");
01119   ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
01120 
01121   ACE_UINT32 thr_state;
01122 
01123   int self_check = ACE_OS::thr_equal (id, ACE_OS::thr_self ());
01124 
01125   // If we're checking the state of our thread, try to get the cached
01126   // value out of TSS to avoid lookup.
01127   if (self_check)
01128     {
01129       ACE_Thread_Descriptor *desc = ACE_LOG_MSG->thr_desc ();
01130       if (desc == 0)
01131         return 0;               // Always return false.
01132       thr_state = desc->thr_state_;
01133     }
01134   else
01135     {
01136       // Not calling from self, have to look it up from the list.
01137       ACE_FIND (this->find_thread (id), ptr);
01138       if (ptr == 0)
01139         return 0;
01140       thr_state = ptr->thr_state_;
01141     }
01142   if (enable)
01143     return ACE_BIT_ENABLED (thr_state, state);
01144 
01145   return ACE_BIT_DISABLED (thr_state, state);
01146 }

int ACE_Thread_Manager::close void   
 

Release all resources. By default, this method will wait till all threads exit. However, when called from <close_singleton>, most global resources are destroyed and thus, we don't try to wait but just clean up the thread descriptor list.

Definition at line 402 of file Thread_Manager.cpp.

References ACE_GUARD_RETURN, ACE_MT, ACE_TRACE, automatic_wait_, remove_thr_all, and wait.

Referenced by close_singleton, and ~ACE_Thread_Manager.

00403 {
00404   ACE_TRACE ("ACE_Thread_Manager::close");
00405 
00406   // Clean up the thread descriptor list.
00407   if (this->automatic_wait_)
00408     this->wait (0, 1);
00409   else
00410     {
00411       ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
00412 
00413       this->remove_thr_all ();
00414     }
00415 
00416   return 0;
00417 }

void ACE_Thread_Manager::close_singleton void    [static]
 

Delete the dynamically allocated Singleton.

Definition at line 379 of file Thread_Manager.cpp.

References ACE_GUARD, ACE_MT, ACE_TRACE, ACE_Thread_Exit::cleanup, close, delete_thr_mgr_, ACE_Static_Object_Lock::instance, and thr_mgr_.

Referenced by ACE_Object_Manager::fini.

00380 {
00381   ACE_TRACE ("ACE_Thread_Manager::close_singleton");
00382 
00383   ACE_MT (ACE_GUARD (ACE_Recursive_Thread_Mutex, ace_mon,
00384                      *ACE_Static_Object_Lock::instance ()));
00385 
00386   if (ACE_Thread_Manager::delete_thr_mgr_)
00387     {
00388       // First, we clean up the thread descriptor list.
00389       ACE_Thread_Manager::thr_mgr_->close ();
00390       delete ACE_Thread_Manager::thr_mgr_;
00391       ACE_Thread_Manager::thr_mgr_ = 0;
00392       ACE_Thread_Manager::delete_thr_mgr_ = 0;
00393     }
00394 
00395   ACE_Thread_Exit::cleanup (ACE_Thread_Manager::thr_exit_);
00396 }

ACE_INLINE size_t ACE_Thread_Manager::count_threads void    const
 

Return a count of the current number of threads active in the <Thread_Manager>.

Definition at line 331 of file Thread_Manager.i.

References ACE_Double_Linked_List< ACE_Thread_Descriptor >::size, and thr_list_.

00332 {
00333   return this->thr_list_.size ();
00334 }

void ACE_Thread_Manager::dump void   
 

Dump the state of an object.

Definition at line 42 of file Thread_Manager.cpp.

References ACE_BEGIN_DUMP, ACE_DEBUG, ACE_END_DUMP, ACE_GUARD, ACE_LIB_TEXT, ACE_MT, ACE_TRACE, ACE_Double_Linked_List_Iterator::advance, ACE_Double_Linked_List_Iterator_Base::done, LM_DEBUG, lock_, and ACE_Double_Linked_List_Iterator_Base::next.

00043 {
00044   ACE_TRACE ("ACE_Thread_Manager::dump");
00045   // Cast away const-ness of this in order to use its non-const lock_.
00046   ACE_MT (ACE_GUARD (ACE_Thread_Mutex, ace_mon,
00047                      ((ACE_Thread_Manager *) this)->lock_));
00048 
00049   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
00050 
00051   ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\ngrp_id_ = %d"), this->grp_id_));
00052   ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\ncurrent_count_ = %d"), this->thr_list_.size ()));
00053 
00054   for (ACE_Double_Linked_List_Iterator<ACE_Thread_Descriptor> iter (this->thr_list_);
00055        !iter.done ();
00056        iter.advance ())
00057     iter.next ()->dump ();
00058 
00059   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
00060 }

ACE_THR_FUNC_RETURN ACE_Thread_Manager::exit ACE_THR_FUNC_RETURN    status = 0,
int    do_thread_exit = 1
 

Called to clean up when a thread exits.

Parameters:
do_thread_exit  If non-0 then ACE_Thread::exit is called to exit the thread
status  If ACE_Thread_Exit is called, this is passed as the exit value of the thread. Should _not_ be called by main thread.

Definition at line 1558 of file Thread_Manager.cpp.

References ACE_BIT_DISABLED, ACE_BIT_ENABLED, ACE_GUARD_RETURN, ACE_hthread_t, ACE_MT, ACE_SET_BITS, ACE_THR_JOINING, ACE_THR_TERMINATED, ACE_thread_t, ACE_TRACE, ACE_Cleanup_Info::cleanup_hook_, ACE_Thread_Descriptor::cleanup_info_, ACE_Thread::exit, find_hthread, find_thread, ACE_OS_Thread_Descriptor::flags_, ACE_Thread_Exit::instance, ACE_Cleanup_Info::object_, ACE_Cleanup_Info::param_, register_as_terminated, remove_thr, ACE_Thread_Descriptor::terminate, ACE_OS::thr_self, and ACE_Thread_Descriptor_Base::thr_state_.

Referenced by ACE_Thread_Control::exit.

01559 {
01560   ACE_TRACE ("ACE_Thread_Manager::exit");
01561 #if defined(ACE_USE_ONE_SHOT_AT_THREAD_EXIT)
01562   int close_handle = 0;
01563 #endif /* ACE_USE_ONE_SHOT_AT_THREAD_EXIT */
01564 
01565 #if defined (ACE_WIN32)
01566   // Remove detached thread handle.
01567 
01568   if (do_thr_exit)
01569     {
01570 #if 0
01571       // @@ This callback is now taken care of by TSS_Cleanup.  Do we
01572       //    need it anymore?
01573 
01574       // On Win32, if we really wants to exit from a thread, we must
01575       // first  clean up the thread specific storage.  By doing so,
01576       // ACE_Thread_Manager::exit will be called again with
01577       // do_thr_exit = 0 and cleaning up the ACE_Cleanup_Info (but not
01578       // exiting the thread.)  After the following call returns, we
01579       // are safe to exit this thread.
01580       delete ACE_Thread_Exit::instance ();
01581 #endif /* 0 */
01582       ACE_Thread::exit (status);
01583     }
01584 #endif /* ACE_WIN32 */
01585 
01586 #if defined(ACE_USE_ONE_SHOT_AT_THREAD_EXIT)
01587   ACE_Cleanup_Info cleanup_info;
01588 
01589   // Just hold onto the guard while finding this thread's id and
01590   // copying the exit hook.
01591   {
01592     ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, 0));
01593 
01594     // Find the thread id, but don't use the cache.  It might have been
01595     // deleted already.
01596 #if defined (VXWORKS)
01597     ACE_hthread_t id;
01598     ACE_OS::thr_self (id);
01599     ACE_Thread_Descriptor *td = this->find_hthread (id);
01600 #else  /* ! VXWORKS */
01601     ACE_thread_t id = ACE_OS::thr_self ();
01602     ACE_Thread_Descriptor *td = this->find_thread (id);
01603 #endif /* ! VXWORKS */
01604 
01605     // Locate thread id.
01606     if (td != 0)
01607       {
01608         // @@ Currently, we have just one hook.  This should clearly
01609         // be generalized to support an arbitrary number of hooks.
01610 
01611         if (td->cleanup_info_.cleanup_hook_ != 0)
01612           {
01613             // Copy the hook so that we can call it after releasing
01614             // the guard.
01615             cleanup_info = td->cleanup_info_;
01616             td->cleanup_info_.cleanup_hook_ = 0;
01617           }
01618 
01619 #if !defined (VXWORKS)
01620         // Threads created with THR_DAEMON shouldn't exist here, but
01621         // just to be safe, let's put it here.
01622 
01623         if (ACE_BIT_DISABLED (td->thr_state_, ACE_THR_JOINING))
01624           if (ACE_BIT_DISABLED (td->flags_, THR_DETACHED | THR_DAEMON)
01625               || ACE_BIT_ENABLED (td->flags_, THR_JOINABLE))
01626             {
01627               // Mark thread as terminated.
01628               ACE_SET_BITS (td->thr_state_, ACE_THR_TERMINATED);
01629               this->register_as_terminated (td);
01630               // Must copy the information here because td will be "freed" below.
01631             }
01632 #if defined (ACE_WIN32)
01633           else
01634             {
01635               close_handle = 1;
01636             }
01637 #endif /* ACE_WIN32 */
01638 #endif /* ! VXWORKS */
01639 
01640         // Remove thread descriptor from the table.
01641         this->remove_thr (td, close_handle);
01642       }
01643     // Release the guard.
01644   }
01645 
01646   // Call the cleanup hook.
01647   if (cleanup_info.cleanup_hook_ != 0)
01648     (*cleanup_info.cleanup_hook_) (cleanup_info.object_,
01649                                    cleanup_info.param_);
01650 #else /* !ACE_USE_ONE_SHOT_AT_THREAD_EXIT */
01651   // Just hold onto the guard while finding this thread's id and
01652   {
01653     ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, 0));
01654 
01655     // Find the thread id, but don't use the cache.  It might have been
01656     // deleted already.
01657 #if defined (VXWORKS)
01658     ACE_hthread_t id;
01659     ACE_OS::thr_self (id);
01660     ACE_Thread_Descriptor* td = this->find_hthread (id);
01661 #else  /* ! VXWORKS */
01662     ACE_thread_t id = ACE_OS::thr_self ();
01663     ACE_Thread_Descriptor* td = this->find_thread (id);
01664 #endif /* ! VXWORKS */
01665     if (td != 0)
01666      {
01667        // @@ We call Thread_Descriptor terminate this realize the cleanup
01668        // process itself.
01669        td->terminate();
01670      }
01671   }
01672 
01673 
01674 #endif /* !ACE_USE_ONE_SHOT_AT_THREAD_EXIT */
01675 
01676   if (do_thr_exit)
01677     {
01678       ACE_Thread::exit (status);
01679       // On reasonable systems <ACE_Thread::exit> should not return.
01680       // However, due to horrible semantics with Win32 thread-specific
01681       // storage this call can return (don't ask...).
01682     }
01683 
01684   return 0;
01685 }

ACE_Thread_Descriptor * ACE_Thread_Manager::find_hthread ACE_hthread_t    h_id [protected]
 

Locate the index of the table slot occupied by <h_id>. Returns -1 if <h_id> is not in the table doesn't contain <h_id>.

Definition at line 791 of file Thread_Manager.cpp.

References ACE_hthread_t, ACE_Double_Linked_List_Iterator::advance, ACE_Double_Linked_List_Iterator_Base::done, ACE_Double_Linked_List_Iterator_Base::next, and ACE_OS::thr_cmp.

Referenced by exit, and insert_thr.

00792 {
00793   for (ACE_Double_Linked_List_Iterator<ACE_Thread_Descriptor> iter (this->thr_list_);
00794        !iter.done ();
00795        iter.advance ())
00796     if (ACE_OS::thr_cmp (iter.next ()->thr_handle_, h_id))
00797       return iter.next ();
00798 
00799   return 0;
00800 }

ACE_Thread_Descriptor * ACE_Thread_Manager::find_task ACE_Task_Base   task,
size_t    slot = 0
[protected]
 

Locate the thread descriptor address of the list occupied by <task>. Returns 0 if <task> is not in the table doesn't contain <task>.

Definition at line 1931 of file Thread_Manager.cpp.

References ACE_TRACE, ACE_Double_Linked_List_Iterator::advance, ACE_Double_Linked_List_Iterator_Base::done, and ACE_Double_Linked_List_Iterator_Base::next.

Referenced by num_tasks_in_group, and task_list.

01932 {
01933   ACE_TRACE ("ACE_Thread_Manager::find_task");
01934 
01935   size_t i = 0;
01936 
01937   for (ACE_Double_Linked_List_Iterator<ACE_Thread_Descriptor> iter (this->thr_list_);
01938        !iter.done ();
01939        iter.advance ())
01940     {
01941       if (i >= slot)
01942         break;
01943 
01944       if (task == iter.next ()->task_)
01945         return iter.next ();
01946 
01947       i++;
01948     }
01949 
01950   return 0;
01951 }

ACE_Thread_Descriptor * ACE_Thread_Manager::find_thread ACE_thread_t    t_id [protected]
 

Locate the index of the table slot occupied by <t_id>. Returns -1 if <t_id> is not in the table doesn't contain <t_id>.

Definition at line 806 of file Thread_Manager.cpp.

References ACE_thread_t, ACE_TRACE, ACE_Double_Linked_List_Iterator::advance, ACE_Double_Linked_List_Iterator_Base::done, ACE_Double_Linked_List_Iterator_Base::next, and ACE_OS::thr_equal.

Referenced by exit, insert_thr, and thread_desc_self.

00807 {
00808   ACE_TRACE ("ACE_Thread_Manager::find_thread");
00809 
00810   for (ACE_Double_Linked_List_Iterator<ACE_Thread_Descriptor> iter (this->thr_list_);
00811        !iter.done ();
00812        iter.advance ())
00813     if (ACE_OS::thr_equal (iter.next ()->thr_id_, t_id))
00814       return iter.next ();
00815   return 0;
00816 }

int ACE_Thread_Manager::get_grp ACE_Task_Base   task,
int &    grp_id
 

Get group ids for a particular task.

Definition at line 2221 of file Thread_Manager.cpp.

References ACE_FIND, ACE_GUARD_RETURN, ACE_MT, and ACE_TRACE.

02222 {
02223   ACE_TRACE ("ACE_Thread_Manager::get_grp");
02224   ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
02225 
02226   ACE_FIND (this->find_task (task), ptr);
02227   grp_id = ptr->grp_id_;
02228   return 0;
02229 }

int ACE_Thread_Manager::get_grp ACE_thread_t   ,
int &    grp_id
 

Get group ids for a particular thread id.

Definition at line 1210 of file Thread_Manager.cpp.

References ACE_FIND, ACE_GUARD_RETURN, ACE_MT, ACE_thread_t, and ACE_TRACE.

01211 {
01212   ACE_TRACE ("ACE_Thread_Manager::get_grp");
01213   ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
01214 
01215   ACE_FIND (this->find_thread (t_id), ptr);
01216 
01217   if (ptr)
01218     grp_id = ptr->grp_id_;
01219   else
01220     return -1;
01221   return 0;
01222 }

ACE_Thread_Descriptor * ACE_Thread_Manager::hthread_descriptor ACE_hthread_t    [protected]
 

Return a pointer to the thread's Thread_Descriptor, 0 if fail.

Definition at line 295 of file Thread_Manager.cpp.

References ACE_FIND, ACE_GUARD_RETURN, ACE_hthread_t, ACE_MT, and ACE_TRACE.

00296 {
00297   ACE_TRACE ("ACE_Thread_Manager::hthread_descriptor");
00298   ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, 0));
00299 
00300   ACE_FIND (this->find_hthread (thr_handle), ptr);
00301   return ptr;
00302 }

ssize_t ACE_Thread_Manager::hthread_grp_list int    grp_id,
ACE_hthread_t    hthread_list[],
size_t    n
 

Returns in <hthread_list> a list of up to <n> thread handles in a group <grp_id>. The caller must allocate memory for <hthread_list>.

Definition at line 2179 of file Thread_Manager.cpp.

References ACE_GUARD_RETURN, ACE_hthread_t, ACE_MT, ACE_TRACE, ACE_Double_Linked_List_Iterator::advance, ACE_Double_Linked_List_Iterator_Base::done, hthread_list, and ACE_Double_Linked_List_Iterator_Base::next.

02182 {
02183   ACE_TRACE ("ACE_Thread_Manager::hthread_grp_list");
02184   ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
02185 
02186   size_t hthread_count = 0;
02187 
02188   for (ACE_Double_Linked_List_Iterator<ACE_Thread_Descriptor> iter (this->thr_list_);
02189        !iter.done ();
02190        iter.advance ())
02191     {
02192       if (hthread_count >= n)
02193         break;
02194 
02195       if (iter.next ()->grp_id_ == grp_id)
02196         {
02197           hthread_list[hthread_count] = iter.next ()->thr_handle_;
02198           hthread_count++;
02199         }
02200     }
02201 
02202   return hthread_count;
02203 }

ssize_t ACE_Thread_Manager::hthread_list ACE_Task_Base   task,
ACE_hthread_t    hthread_list[],
size_t    n
 

Returns in <hthread_list> a list of up to <n> thread handles in an <ACE_Task_Base>. The caller must allocate memory for <hthread_list>. In case of an error, -1 is returned. If no requested values are found, 0 is returned, otherwise correct number of retrieved values are returned.

Definition at line 2123 of file Thread_Manager.cpp.

References ACE_GUARD_RETURN, ACE_hthread_t, ACE_MT, ACE_TRACE, ACE_Double_Linked_List_Iterator::advance, ACE_Double_Linked_List_Iterator_Base::done, hthread_list, and ACE_Double_Linked_List_Iterator_Base::next.

Referenced by hthread_grp_list, and hthread_list.

02126 {
02127   ACE_TRACE ("ACE_Thread_Manager::hthread_list");
02128   ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
02129 
02130   size_t hthread_count = 0;
02131 
02132   for (ACE_Double_Linked_List_Iterator<ACE_Thread_Descriptor> iter (this->thr_list_);
02133        !iter.done ();
02134        iter.advance ())
02135     {
02136       if (hthread_count >= n)
02137         break;
02138 
02139       if (iter.next ()->task_ == task)
02140         {
02141           hthread_list[hthread_count] = iter.next ()->thr_handle_;
02142           hthread_count++;
02143         }
02144     }
02145 
02146   return hthread_count;
02147 }

int ACE_Thread_Manager::hthread_within ACE_hthread_t    handle
 

Check if the thread is managed by the thread manager. Return true if the thread is found, false otherwise.

Definition at line 1178 of file Thread_Manager.cpp.

References ACE_GUARD_RETURN, ACE_hthread_t, ACE_MT, ACE_TRACE, ACE_Double_Linked_List_Iterator::advance, ACE_Double_Linked_List_Iterator_Base::done, ACE_Double_Linked_List_Iterator_Base::next, and ACE_OS::thr_cmp.

01179 {
01180   ACE_TRACE ("ACE_Thread_Manager::hthread_within");
01181   ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_monx, this->lock_, -1));
01182 
01183   for (ACE_Double_Linked_List_Iterator<ACE_Thread_Descriptor> iter (this->thr_list_);
01184        !iter.done ();
01185        iter.advance ())
01186     if (ACE_OS::thr_cmp(iter.next ()->thr_handle_, handle))
01187       return 1;
01188 
01189   return 0;
01190 }

int ACE_Thread_Manager::insert_thr ACE_thread_t    t_id,
ACE_hthread_t   ,
int    grp_id = -1,
long    flags = 0
[protected]
 

Insert a thread in the table (checks for duplicates).

Definition at line 822 of file Thread_Manager.cpp.

References ACE_GUARD_RETURN, ACE_hthread_t, ACE_MT, ACE_THR_SPAWNED, ACE_thread_t, ACE_TRACE, append_thr, find_hthread, find_thread, and grp_id_.

Referenced by ACE_Thread_Control::ACE_Thread_Control, and ACE_Thread_Control::insert.

00826 {
00827   ACE_TRACE ("ACE_Thread_Manager::insert_thr");
00828   ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
00829 
00830   // Check for duplicates and bail out if we're already registered...
00831 #if defined (VXWORKS)
00832   if (this->find_hthread (t_handle) != 0 )
00833     return -1;
00834 #else  /* ! VXWORKS */
00835   if (this->find_thread (t_id) != 0 )
00836     return -1;
00837 #endif /* ! VXWORKS */
00838 
00839   if (grp_id == -1)
00840     grp_id = this->grp_id_++;
00841 
00842   if (this->append_thr (t_id,
00843                         t_handle,
00844                         ACE_THR_SPAWNED,
00845                         grp_id,
00846                         0,
00847                         flags) == -1)
00848     return -1;
00849 
00850   return grp_id;
00851 }

ACE_Thread_Manager * ACE_Thread_Manager::instance ACE_Thread_Manager *    [static]
 

Set pointer to a process-wide <ACE_Thread_Manager> and return existing pointer.

Definition at line 364 of file Thread_Manager.cpp.

References ACE_GUARD_RETURN, ACE_MT, ACE_TRACE, delete_thr_mgr_, ACE_Static_Object_Lock::instance, and thr_mgr_.

00365 {
00366   ACE_TRACE ("ACE_Thread_Manager::instance");
00367   ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
00368                             *ACE_Static_Object_Lock::instance (), 0));
00369 
00370   ACE_Thread_Manager *t = ACE_Thread_Manager::thr_mgr_;
00371   // We can't safely delete it since we don't know who created it!
00372   ACE_Thread_Manager::delete_thr_mgr_ = 0;
00373 
00374   ACE_Thread_Manager::thr_mgr_ = tm;
00375   return t;
00376 }

ACE_Thread_Manager * ACE_Thread_Manager::instance void    [static]
 

Get pointer to a process-wide <ACE_Thread_Manager>.

Definition at line 341 of file Thread_Manager.cpp.

References ACE_GUARD_RETURN, ACE_MT, ACE_NEW_RETURN, ACE_TRACE, delete_thr_mgr_, ACE_Static_Object_Lock::instance, and thr_mgr_.

Referenced by ACE_Schedule_All_Threaded_Strategy::ACE_Schedule_All_Threaded_Strategy, and ACE_Task_Base::activate.

00342 {
00343   ACE_TRACE ("ACE_Thread_Manager::instance");
00344 
00345   if (ACE_Thread_Manager::thr_mgr_ == 0)
00346     {
00347       // Perform Double-Checked Locking Optimization.
00348       ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
00349                                 *ACE_Static_Object_Lock::instance (), 0));
00350 
00351       if (ACE_Thread_Manager::thr_mgr_ == 0)
00352         {
00353           ACE_NEW_RETURN (ACE_Thread_Manager::thr_mgr_,
00354                           ACE_Thread_Manager,
00355                           0);
00356           ACE_Thread_Manager::delete_thr_mgr_ = 1;
00357         }
00358     }
00359 
00360   return ACE_Thread_Manager::thr_mgr_;
00361 }

int ACE_Thread_Manager::join ACE_thread_t    tid,
ACE_THR_FUNC_RETURN *    status = 0
 

Join a thread specified by <tid>. Do not wait on a detached thread.

Definition at line 1380 of file Thread_Manager.cpp.

References ACE_BIT_DISABLED, ACE_BIT_ENABLED, ACE_GUARD_RETURN, ACE_MT, ACE_SET_BITS, ACE_THR_JOINING, ACE_thread_t, ACE_TRACE, ACE_Double_Linked_List_Iterator::advance, ACE_Double_Linked_List_Iterator::advance_and_remove, ACE_Double_Linked_List_Iterator_Base::done, ACE_Thread::join, ACE_Double_Linked_List_Iterator_Base::next, ACE_OS::thr_equal, and ACE_Thread_Descriptor_Base::thr_handle_.

01381 {
01382   ACE_TRACE ("ACE_Thread_Manager::join");
01383 
01384   ACE_Thread_Descriptor_Base tdb;
01385   int found = 0;
01386 
01387   {
01388     ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
01389 
01390 #if !defined (VXWORKS)
01391     for (ACE_Double_Linked_List_Iterator<ACE_Thread_Descriptor_Base> biter (this->terminated_thr_list_);
01392          !biter.done ();
01393          biter.advance ())
01394       if (ACE_OS::thr_equal (biter.next ()->thr_id_, tid))
01395         {
01396           ACE_Thread_Descriptor_Base *tdb = biter.advance_and_remove (0);
01397 # if defined (_AIX)
01398   // The AIX xlC compiler does not match the proper function here - it
01399   // confuses ACE_Thread::join(ACE_thread_t, ACE_thread_t *, void **=0) and
01400   // ACE_Thread::join(ACE_hthread_t, void **=0).  At least at 3.1.4.7 and .8.
01401   // The 2nd arg is ignored for pthreads anyway.
01402 
01403   // And, g++ on AIX needs the three-arg thr_join, also, to pick up the
01404   // proper version from the AIX libraries.
01405           if (ACE_Thread::join (tdb->thr_handle_,
01406                                 &tdb->thr_handle_,
01407                                 status) == -1)
01408 # else  /* ! _AIX */
01409           if (ACE_Thread::join (tdb->thr_handle_, status) == -1)
01410 # endif /* ! _AIX */
01411             return -1;
01412 
01413 # if defined (ACE_HAS_PTHREADS_DRAFT4)  &&  defined (ACE_LACKS_SETDETACH)
01414           // Must explicitly detach threads.  Threads without THR_DETACHED
01415           // were detached in ACE_OS::thr_create ().
01416           ::pthread_detach (&tdb->thr_handle_);
01417 # endif /* ACE_HAS_PTHREADS_DRAFT4 && ACE_LACKS_SETDETACH */
01418 
01419           delete tdb;
01420           return 0;
01421           // return immediately if we've found the thread we want to join.
01422         }
01423 #endif /* !VXWORKS */
01424 
01425     for (ACE_Double_Linked_List_Iterator<ACE_Thread_Descriptor> iter (this->thr_list_);
01426          !iter.done ();
01427          iter.advance ())
01428       // If threads are created as THR_DETACHED or THR_DAEMON, we
01429       // can't help much.
01430       if (ACE_OS::thr_equal (iter.next ()->thr_id_,tid) &&
01431           (ACE_BIT_DISABLED (iter.next ()->flags_, THR_DETACHED | THR_DAEMON)
01432            || ACE_BIT_ENABLED (iter.next ()->flags_, THR_JOINABLE)))
01433         {
01434           tdb = *iter.next ();
01435           ACE_SET_BITS (iter.next ()->thr_state_, ACE_THR_JOINING);
01436           found = 1;
01437           break;
01438         }
01439 
01440     if (found == 0)
01441       return -1;
01442     // Didn't find the thread we want or the thread is not joinable.
01443   }
01444 
01445 # if defined (_AIX)
01446   // The AIX xlC compiler does not match the proper function here - it
01447   // confuses ACE_Thread::join(ACE_thread_t, ACE_thread_t *, void **=0) and
01448   // ACE_Thread::join(ACE_hthread_t, void **=0).  At least at 3.1.4.7 and .8.
01449   // The 2nd arg is ignored for pthreads anyway.
01450 
01451   // And, g++ on AIX needs the three-arg thr_join, also, to pick up the
01452   // proper version from the AIX libraries.
01453   if (ACE_Thread::join (tdb.thr_handle_, &tdb.thr_handle_, status) == -1)
01454 # else  /* ! _AIX */
01455   if (ACE_Thread::join (tdb.thr_handle_, status) == -1)
01456 # endif /* ! _AIX */
01457     return -1;
01458 
01459 # if defined (ACE_HAS_PTHREADS_DRAFT4)  &&  defined (ACE_LACKS_SETDETACH)
01460   // Must explicitly detach threads.  Threads without THR_DETACHED
01461   // were detached in ACE_OS::thr_create ().
01462 
01463 #   if defined (HPUX_10)
01464   // HP-UX DCE threads' pthread_detach will smash thr_id if it's just given
01465   // as an argument.  Since the thread handle is still needed, give
01466   // pthread_detach a junker to scribble on.
01467   ACE_thread_t  junker;
01468   cma_handle_assign(&tdb.thr_handle_, &junker);
01469   ::pthread_detach (&junker);
01470 #   else
01471   ::pthread_detach (&tdb.thr_handle_);
01472     #endif /* HPUX_10 */
01473 # endif /* ACE_HAS_PTHREADS_DRAFT4 && ACE_LACKS_SETDETACH */
01474   return 0;
01475 }

int ACE_Thread_Manager::join_thr ACE_Thread_Descriptor   td,
int    = 0
[protected]
 

Join the thread described in <tda>.

Definition at line 961 of file Thread_Manager.cpp.

References ACE_TRACE, ACE_Thread::join, and ACE_Thread_Descriptor_Base::thr_handle_.

00962 {
00963   ACE_TRACE ("ACE_Thread_Manager::join_thr");
00964   int result = ACE_Thread::join (td->thr_handle_);
00965   if (result != 0)
00966     {
00967       // Since the thread are being joined, we should
00968       // let it remove itself from the list.
00969 
00970       //      this->remove_thr (td);
00971       errno = result;
00972       return -1;
00973     }
00974 
00975   return 0;
00976 }

int ACE_Thread_Manager::kill ACE_thread_t   ,
int    signum
 

Definition at line 1107 of file Thread_Manager.cpp.

References ACE_EXECUTE_OP, ACE_thread_t, and ACE_TRACE.

01108 {
01109   ACE_TRACE ("ACE_Thread_Manager::kill");
01110   ACE_EXECUTE_OP (this->kill_thr, signum);
01111 }

int ACE_Thread_Manager::kill_all int    signum
 

Send <signum> to all stopped threads. Not supported on platforms that do not have advanced signal support, such as Win32. Send the <signum> to a single thread. Not supported on platforms that do not have advanced signal support, such as Win32. Send <signum> to a group of threads, not supported on platforms that do not have advanced signal support, such as Win32.

Definition at line 1365 of file Thread_Manager.cpp.

References ACE_TRACE, apply_all, and kill_thr.

01366 {
01367   ACE_TRACE ("ACE_Thread_Manager::kill_all");
01368   return this->apply_all (&ACE_Thread_Manager::kill_thr, sig);
01369 }

int ACE_Thread_Manager::kill_grp int    grp_id,
int    signum
 

Definition at line 1298 of file Thread_Manager.cpp.

References ACE_THR_MEMBER_FUNC, ACE_TRACE, apply_grp, and kill_thr.

01299 {
01300   ACE_TRACE ("ACE_Thread_Manager::kill_grp");
01301   return this->apply_grp (grp_id,
01302                           ACE_THR_MEMBER_FUNC (&ACE_Thread_Manager::kill_thr), signum);
01303 }

int ACE_Thread_Manager::kill_task ACE_Task_Base   task,
int    signum
 

Send a signal <signum> to all threads in an <ACE_Task>.

Definition at line 1908 of file Thread_Manager.cpp.

References ACE_THR_MEMBER_FUNC, ACE_TRACE, apply_task, and kill_thr.

01909 {
01910   ACE_TRACE ("ACE_Thread_Manager::kill_task");
01911   return this->apply_task (task,
01912                            ACE_THR_MEMBER_FUNC (&ACE_Thread_Manager::kill_thr));
01913 }

int ACE_Thread_Manager::kill_thr ACE_Thread_Descriptor   td,
int    signum
[protected]
 

Send signal <signum> to the thread described in <tda>.

Definition at line 1029 of file Thread_Manager.cpp.

References ACE_thread_t, ACE_TRACE, ENOTSUP, ACE_Unbounded_Queue< ACE_Thread_Descriptor * >::enqueue_tail, ACE_Thread::kill, ACE_Thread_Descriptor_Base::thr_id_, and thr_to_be_removed_.

Referenced by kill_all, kill_grp, and kill_task.

01030 {
01031   ACE_TRACE ("ACE_Thread_Manager::kill_thr");
01032 
01033   ACE_thread_t tid = td->thr_id_;
01034 #if defined (VXWORKS)
01035   // Skip over the ID-allocated marker, if present.
01036   tid += tid[0] == ACE_THR_ID_ALLOCATED  ?  1  :  0;
01037 #endif /* VXWORKS */
01038 
01039   int result = ACE_Thread::kill (tid, signum);
01040 
01041   if (result != 0)
01042     {
01043       // Only remove a thread from us when there is a "real" error.
01044       if (errno != ENOTSUP)
01045         this->thr_to_be_removed_.enqueue_tail (td);
01046 
01047       return -1;
01048     }
01049 #if defined (CHORUS)
01050   else if (signum == SIGTHREADKILL)
01051     this->thr_to_be_removed_.enqueue_tail (td);
01052 #endif /* CHORUS */
01053 
01054     return 0;
01055 }

int ACE_Thread_Manager::num_tasks_in_group int    grp_id
 

Returns the number of <ACE_Task_Base> in a group.

Definition at line 1956 of file Thread_Manager.cpp.

References ACE_GUARD_RETURN, ACE_MT, ACE_TRACE, ACE_Double_Linked_List_Iterator::advance, ACE_Double_Linked_List_Iterator_Base::done, find_task, and ACE_Double_Linked_List_Iterator_Base::next.

01957 {
01958   ACE_TRACE ("ACE_Thread_Manager::num_tasks_in_group");
01959   ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
01960 
01961   int tasks_count = 0;
01962   size_t i = 0;
01963 
01964   for (ACE_Double_Linked_List_Iterator<ACE_Thread_Descriptor> iter (this->thr_list_);
01965        !iter.done ();
01966        iter.advance ())
01967     {
01968       if (iter.next ()->grp_id_ == grp_id
01969           && this->find_task (iter.next ()->task_, i) == 0
01970           && iter.next ()->task_ != 0)
01971         tasks_count++;
01972 
01973       i++;
01974     }
01975   return tasks_count;
01976 }

int ACE_Thread_Manager::num_threads_in_task ACE_Task_Base   task
 

Returns the number of threads in an <ACE_Task_Base>.

Definition at line 1981 of file Thread_Manager.cpp.

References ACE_GUARD_RETURN, ACE_MT, ACE_TRACE, ACE_Double_Linked_List_Iterator::advance, ACE_Double_Linked_List_Iterator_Base::done, and ACE_Double_Linked_List_Iterator_Base::next.

01982 {
01983   ACE_TRACE ("ACE_Thread_Manager::num_threads_in_task");
01984   ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
01985 
01986   int threads_count = 0;
01987 
01988   for (ACE_Double_Linked_List_Iterator<ACE_Thread_Descriptor> iter (this->thr_list_);
01989        !iter.done ();
01990        iter.advance ())
01991     if (iter.next ()->task_ == task)
01992       threads_count++;
01993 
01994   return threads_count;
01995 }

ACE_INLINE int ACE_Thread_Manager::open size_t    size = 0
 

No-op. Currently unused.

Definition at line 263 of file Thread_Manager.i.

00264 {
00265   // Currently no-op.
00266   return 0;
00267 }

ACE_INLINE int ACE_Thread_Manager::register_as_terminated ACE_Thread_Descriptor   td [protected]
 

Register a thread as terminated and put it into the <terminated_thr_list_>.

Definition at line 318 of file Thread_Manager.i.

References ACE_NEW_RETURN, ACE_Double_Linked_List< ACE_Thread_Descriptor_Base >::insert_tail, and terminated_thr_list_.

Referenced by exit, and ACE_Thread_Descriptor::terminate.

00319 {
00320 #if defined (VXWORKS)
00321   ACE_UNUSED_ARG (td);
00322 #else  /* ! VXWORKS */
00323   ACE_Thread_Descriptor_Base *tdb;
00324   ACE_NEW_RETURN (tdb, ACE_Thread_Descriptor_Base (*td), -1);
00325   this->terminated_thr_list_.insert_tail (tdb);
00326 #endif /* ! VXWORKS */
00327   return 0;
00328 }

void ACE_Thread_Manager::remove_thr ACE_Thread_Descriptor   td,
int    close_handler
[protected]
 

Remove thread from the table.

Definition at line 882 of file Thread_Manager.cpp.

References ACE_thread_t, ACE_TRACE, ACE_Locked_Free_List< ACE_Thread_Descriptor, ACE_SYNCH_MUTEX >::add, ACE_Condition_Thread_Mutex::broadcast, ACE_Double_Linked_List< ACE_Thread_Descriptor >::remove, ACE_Thread_Descriptor::self, ACE_Double_Linked_List< ACE_Thread_Descriptor >::size, ACE_Thread_Descriptor_Base::thr_handle_, thr_list_, thread_desc_freelist_, ACE_Thread_Descriptor::tm_, and zero_cond_.

Referenced by apply_all, apply_grp, apply_task, exit, ACE_Thread_Descriptor::terminate, and wait.

00884 {
00885   ACE_TRACE ("ACE_Thread_Manager::remove_thr");
00886 
00887 #if defined (VXWORKS)
00888   ACE_thread_t tid = td->self ();
00889 #endif /* VXWORKS */
00890 
00891 #if !defined(ACE_USE_ONE_SHOT_AT_THREAD_EXIT)
00892   td->tm_ = 0;
00893 #endif /* !ACE_USE_ONE_SHOT_AT_THREAD_EXIT */
00894   this->thr_list_.remove (td);
00895 
00896 #if defined (VXWORKS)
00897   // Delete the thread ID, if the ACE_Thread_Manager allocated it.
00898   if (tid  &&  tid[0] == ACE_THR_ID_ALLOCATED)
00899     {
00900       delete [] tid;
00901     }
00902 #endif /* VXWORKS */
00903 
00904 #if defined (ACE_WIN32)
00905   if (close_handler != 0)
00906     ::CloseHandle (td->thr_handle_);
00907 #else
00908   ACE_UNUSED_ARG (close_handler);
00909 #endif /* ACE_WIN32 */
00910 
00911 #if 1
00912 
00913   this->thread_desc_freelist_.add (td);
00914 #else
00915   delete td;
00916 #endif /* 1 */
00917 
00918 #if defined (ACE_HAS_THREADS)
00919   // Tell all waiters when there are no more threads left in the pool.
00920   if (this->thr_list_.size () == 0)
00921     this->zero_cond_.broadcast ();
00922 #endif /* ACE_HAS_THREADS */
00923 }

void ACE_Thread_Manager::remove_thr_all void    [protected]
 

Remove all threads from the table.

Definition at line 929 of file Thread_Manager.cpp.

References ACE_Double_Linked_List< ACE_Thread_Descriptor >::delete_head, ACE_Thread_Descriptor_Base::thr_handle_, and thr_list_.

Referenced by close, and wait.

00930 {
00931   ACE_Thread_Descriptor *td;
00932 
00933   while ((td = this->thr_list_.delete_head ()) != 0)
00934     {
00935 #if defined (ACE_WIN32)
00936       // We need to let go handles if we want to let the threads
00937       // run wild.
00938       // @@ Do we need to close down AIX thread handles too?
00939       ::CloseHandle (td->thr_handle_);
00940 #endif /* ACE_WIN32 */
00941       delete td;
00942     }
00943 
00944 }

int ACE_Thread_Manager::resume ACE_thread_t   
 

Resume a single thread.

Definition at line 1089 of file Thread_Manager.cpp.

References ACE_EXECUTE_OP, ACE_thread_t, and ACE_TRACE.

01090 {
01091   ACE_TRACE ("ACE_Thread_Manager::resume");
01092   ACE_EXECUTE_OP (this->resume_thr, 0);
01093 }

int ACE_Thread_Manager::resume_all void   
 

Resume all stopped threads.

Definition at line 1351 of file Thread_Manager.cpp.

References ACE_THR_MEMBER_FUNC, ACE_TRACE, apply_all, and resume_thr.

Referenced by ACE_Schedule_All_Threaded_Strategy::resume.

01352 {
01353   ACE_TRACE ("ACE_Thread_Manager::resume_all");
01354   return this->apply_all (ACE_THR_MEMBER_FUNC (&ACE_Thread_Manager::resume_thr));
01355 }

int ACE_Thread_Manager::resume_grp int    grp_id
 

Resume a group of threads.

Definition at line 1288 of file Thread_Manager.cpp.

References ACE_THR_MEMBER_FUNC, ACE_TRACE, apply_grp, and resume_thr.

01289 {
01290   ACE_TRACE ("ACE_Thread_Manager::resume_grp");
01291   return this->apply_grp (grp_id,
01292                           ACE_THR_MEMBER_FUNC (&ACE_Thread_Manager::resume_thr));
01293 }

int ACE_Thread_Manager::resume_task ACE_Task_Base   task
 

Resume all threads in an ACE_Task.

Definition at line 1898 of file Thread_Manager.cpp.

References ACE_THR_MEMBER_FUNC, ACE_TRACE, apply_task, and resume_thr.

Referenced by ACE_Task_Base::resume.

01899 {
01900   ACE_TRACE ("ACE_Thread_Manager::resume_task");
01901   return this->apply_task (task,
01902                            ACE_THR_MEMBER_FUNC (&ACE_Thread_Manager::resume_thr));
01903 }

int ACE_Thread_Manager::resume_thr ACE_Thread_Descriptor   td,
int    = 0
[protected]
 

Resume the thread described in <tda>.

Definition at line 996 of file Thread_Manager.cpp.

References ACE_CLR_BITS, ACE_THR_SUSPENDED, ACE_TRACE, ENOTSUP, ACE_Unbounded_Queue< ACE_Thread_Descriptor * >::enqueue_tail, ACE_Thread::resume, ACE_Thread_Descriptor_Base::thr_handle_, ACE_Thread_Descriptor_Base::thr_state_, and thr_to_be_removed_.

Referenced by resume_all, resume_grp, and resume_task.

00997 {
00998   ACE_TRACE ("ACE_Thread_Manager::resume_thr");
00999 
01000   int result = ACE_Thread::resume (td->thr_handle_);
01001   if (result == -1) {
01002     if (errno != ENOTSUP)
01003       this->thr_to_be_removed_.enqueue_tail (td);
01004     return -1;
01005   }
01006   else {
01007     ACE_CLR_BITS (td->thr_state_, ACE_THR_SUSPENDED);
01008     return 0;
01009   }
01010 }

void ACE_Thread_Manager::run_thread_exit_hooks int    i [protected]
 

Run the registered hooks when the thread exits.

Definition at line 856 of file Thread_Manager.cpp.

References ACE_TRACE, ACE_Cleanup_Info::cleanup_hook_, ACE_Thread_Descriptor::cleanup_info_, ACE_Cleanup_Info::object_, ACE_Cleanup_Info::param_, and thread_desc_self.

00857 {
00858 #if 0 // currently unused!
00859   ACE_TRACE ("ACE_Thread_Manager::run_thread_exit_hooks");
00860 
00861   // @@ Currently, we have just one hook.  This should clearly be
00862   // generalized to support an arbitrary number of hooks.
00863 
00864   ACE_Thread_Descriptor *td = this->thread_desc_self ();
00865   if (td != 0 && td->cleanup_info.cleanup_hook_ != 0)
00866     {
00867       (*td->cleanup_info_.cleanup_hook_)
00868         (td->cleanup_info_.object_,
00869          td->cleanup_info_.param_);
00870 
00871       td->cleanup_info_.cleanup_hook_ = 0;
00872     }
00873   ACE_UNUSED_ARG (i);
00874 #else
00875   ACE_UNUSED_ARG (i);
00876 #endif /* 0 */
00877 }

int ACE_Thread_Manager::set_grp ACE_Task_Base   task,
int    grp_id
 

Set group ids for a particular task.

Definition at line 2206 of file Thread_Manager.cpp.

References ACE_GUARD_RETURN, ACE_MT, ACE_TRACE, ACE_Double_Linked_List_Iterator::advance, ACE_Double_Linked_List_Iterator_Base::done, and ACE_Double_Linked_List_Iterator_Base::next.

02207 {
02208   ACE_TRACE ("ACE_Thread_Manager::set_grp");
02209   ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
02210 
02211   for (ACE_Double_Linked_List_Iterator<ACE_Thread_Descriptor> iter (this->thr_list_);
02212        !iter.done ();
02213        iter.advance ())
02214     if (iter.next ()->task_ == task)
02215       iter.next ()->grp_id_ = grp_id;
02216 
02217   return 0;
02218 }

int ACE_Thread_Manager::set_grp ACE_thread_t   ,
int    grp_id
 

Set group ids for a particular thread id.

Definition at line 1227 of file Thread_Manager.cpp.

References ACE_FIND, ACE_GUARD_RETURN, ACE_MT, ACE_thread_t, and ACE_TRACE.

Referenced by ACE_Task_Base::grp_id.

01228 {
01229   ACE_TRACE ("ACE_Thread_Manager::set_grp");
01230   ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
01231 
01232   ACE_FIND (this->find_thread (t_id), ptr);
01233   if (ptr)
01234     ptr->grp_id_ = grp_id;
01235   else
01236     return -1;
01237   return 0;
01238 }

int ACE_Thread_Manager::set_thr_exit ACE_TSS_TYPE(ACE_Thread_Exit)*    ptr [static, protected]
 

Setting the static ACE_TSS_TYPE (ACE_Thread_Exit) *thr_exit_ pointer.

Referenced by ACE_Thread_Exit::instance.

int ACE_Thread_Manager::spawn ACE_THR_FUNC    func,
void *    args = 0,
long    flags = THR_NEW_LWP|THR_JOINABLE,
ACE_thread_t   = 0,
ACE_hthread_t   t_handle = 0,
long    priority = ACE_DEFAULT_THREAD_PRIORITY,
int    grp_id = -1,
void *    stack = 0,
size_t    stack_size = 0
 

Create a new thread, which executes <func>. Returns: on success a unique group id that can be used to control other threads added to the same group. On failure, returns -1.

Definition at line 642 of file Thread_Manager.cpp.

References ACE_GUARD_RETURN, ACE_hthread_t, ACE_MT, ACE_thread_t, ACE_TRACE, grp_id_, and spawn_i.

Referenced by ACE_Event_Handler::register_stdin_handler.

00651 {
00652   ACE_TRACE ("ACE_Thread_Manager::spawn");
00653 
00654   ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
00655 
00656   if (grp_id == -1)
00657     grp_id = this->grp_id_++; // Increment the group id.
00658 
00659   if (this->spawn_i (func, args, flags, t_id, t_handle,
00660                      priority, grp_id, stack, stack_size) == -1)
00661     return -1;
00662 
00663   return grp_id;
00664 }

int ACE_Thread_Manager::spawn_i ACE_THR_FUNC    func,
void *    args,
long    flags,
ACE_thread_t   = 0,
ACE_hthread_t   t_handle = 0,
long    priority = ACE_DEFAULT_THREAD_PRIORITY,
int    grp_id = -1,
void *    stack = 0,
size_t    stack_size = 0,
ACE_Task_Base   task = 0
[protected, virtual]
 

Create a new thread (must be called with locks held).

Definition at line 505 of file Thread_Manager.cpp.

References ACE_ASSERT, ACE_BIT_DISABLED, ACE_hthread_t, ACE_NEW_RETURN, ACE_THR_SPAWNED, ACE_thread_t, ACE_TRACE, append_thr, ACE_Auto_Basic_Ptr::get, ACE_Auto_Basic_Ptr::release, ACE_Auto_Basic_Ptr::reset, and ACE_Thread::spawn.

Referenced by spawn, and spawn_n.

00515 {
00516   // First, threads created by Thread Manager should not be daemon threads.
00517   // Using assertion is probably a bit too strong.  However, it helps
00518   // finding this kind of error as early as possible.  Perhaps we can replace
00519   // assertion by returning error.
00520   ACE_ASSERT (ACE_BIT_DISABLED (flags, THR_DAEMON));
00521 
00522   // Create a new thread running <func>.  *Must* be called with the
00523   // <lock_> held...
00524   // Get a "new" Thread Descriptor from the freelist.
00525   auto_ptr<ACE_Thread_Descriptor> new_thr_desc (this->thread_desc_freelist_.remove ());
00526 
00527   // Reset thread descriptor status
00528   new_thr_desc->reset (this);
00529 
00530   ACE_Thread_Adapter *thread_args = 0;
00531 # if defined (ACE_HAS_WIN32_STRUCTURAL_EXCEPTIONS)
00532   ACE_NEW_RETURN (thread_args,
00533                   ACE_Thread_Adapter (func,
00534                                       args,
00535                                       (ACE_THR_C_FUNC) ace_thread_adapter,
00536                                       this,
00537                                       new_thr_desc.get (),
00538                                       ACE_OS_Object_Manager::seh_except_selector(),
00539                                       ACE_OS_Object_Manager::seh_except_handler()),
00540                   -1);
00541 #else
00542   ACE_NEW_RETURN (thread_args,
00543                   ACE_Thread_Adapter (func,
00544                                       args,
00545                                       (ACE_THR_C_FUNC) ace_thread_adapter,
00546                                       this,
00547                                       new_thr_desc.get ()),
00548                   -1);
00549 # endif /* ACE_HAS_WIN32_STRUCTURAL_EXCEPTIONS */
00550 
00551   ACE_TRACE ("ACE_Thread_Manager::spawn_i");
00552   ACE_hthread_t thr_handle;
00553 
00554 #if defined (VXWORKS)
00555   // On VxWorks, ACE_thread_t is char *.  If t_id is 0, allocate space
00556   // for ACE_OS::thr_create () to store the task name.  If t_id is not
00557   // 0, and it doesn't point to a 0 char *, then the non-zero char *
00558   // will be used for the task name in ACE_OS::thr_create ().  If t_id
00559   // is not 0, but does point to a 0 char *, the t_id will be set to
00560   // point to the task name in the TCB in ACE_OS::thr_create ().
00561   if (t_id == 0)
00562     {
00563       char *thr_id;
00564       ACE_NEW_RETURN (thr_id,
00565                       char[16],
00566                       -1);
00567       // Mark the thread ID to show that the ACE_Thread_Manager
00568       // allocated it.
00569       thr_id[0] = ACE_THR_ID_ALLOCATED;
00570       thr_id[1] = '\0';
00571       t_id = &thr_id;
00572     }
00573 #else  /* ! VXWORKS */
00574   ACE_thread_t thr_id;
00575   if (t_id == 0)
00576     t_id = &thr_id;
00577 #endif /* ! VXWORKS */
00578 
00579   new_thr_desc->sync_->acquire ();
00580   // Acquire the <sync_> lock to block the spawned thread from
00581   // removing this Thread Descriptor before it gets put into our
00582   // thread table.
00583 
00584   int result = ACE_Thread::spawn (func,
00585                                   args,
00586                                   flags,
00587                                   t_id,
00588                                   &thr_handle,
00589                                   priority,
00590                                   stack,
00591                                   stack_size,
00592                                   thread_args);
00593 
00594   if (result != 0)
00595     {
00596       // _Don't_ clobber errno here!  result is either 0 or -1, and
00597       // ACE_OS::thr_create () already set errno!  D. Levine 28 Mar 1997
00598       // errno = result;
00599       ACE_Errno_Guard guard (errno);     // Lock release may smash errno
00600       new_thr_desc->sync_->release ();
00601       return -1;
00602     }
00603   else
00604     {
00605 #if defined (ACE_HAS_WTHREADS)
00606       // Have to duplicate handle if client asks for it.
00607       // @@ How are thread handles implemented on AIX?  Do they
00608       // also need to be duplicated?
00609       if (t_handle != 0)
00610 # if defined (ACE_HAS_WINCE)
00611         *t_handle = thr_handle;
00612 # else  /* ! ACE_HAS_WINCE */
00613         (void) ::DuplicateHandle (::GetCurrentProcess (),
00614                                   thr_handle,
00615                                   ::GetCurrentProcess (),
00616                                   t_handle,
00617                                   0,
00618                                   TRUE,
00619                                   DUPLICATE_SAME_ACCESS);
00620 # endif /* ! ACE_HAS_WINCE */
00621 #elif defined (VXWORKS)
00622      if (t_handle != 0)
00623        *t_handle = thr_handle;
00624 #else  /* ! ACE_HAS_WTHREADS && ! VXWORKS */
00625       ACE_UNUSED_ARG (t_handle);
00626 #endif /* ! ACE_HAS_WTHREADS && ! VXWORKS */
00627 
00628       // append_thr also put the <new_thr_desc> into Thread_Manager's
00629       // double-linked list.  Only after this point, can we manipulate
00630       // double-linked list from a spawned thread's context.
00631       return this->append_thr (*t_id,
00632                                thr_handle,
00633                                ACE_THR_SPAWNED,
00634                                grp_id,
00635                                task,
00636                                flags,
00637                                new_thr_desc.release ());
00638     }
00639 }

int ACE_Thread_Manager::spawn_n ACE_thread_t    thread_ids[],
size_t    n,
ACE_THR_FUNC    func,
void *    args,
long    flags,
long    priority = ACE_DEFAULT_THREAD_PRIORITY,
int    grp_id = -1,
void *    stack[] = 0,
size_t    stack_size[] = 0,
ACE_hthread_t    thread_handles[] = 0,
ACE_Task_Base   task = 0
 

Spawn N new threads, which execute <func> with argument <arg>. If <thread_ids> != 0 the thread_ids of successfully spawned threads will be placed into the <thread_ids> buffer (which must be the same size as <n>). 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. If <stack_size> != 0 it is assumed to be an array of <n> values indicating how big each of the corresponding <stack>s are. 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.

Threads in Thread_Manager can be manipulated in groups based on <grp_id> or <task> using functions such as kill_grp() or cancel_task().

If <grp_id> is assigned, the newly spawned threads are added into the group. Otherwise, the Thread_Manager assigns these <n> threads with a grp_id. You should choose either assigning <grp_id> everytime, or let the Thread_Manager handles it for you consistently.

The argument <task> is usually assigned by <ACE_Task_Base::activate>. It associates the newly spawned threads with an ACE_Task instance, which defaults to <this>.

Return values:
-1  on failure (<errno> will explain...), otherwise returns the group id of the threads.

Definition at line 709 of file Thread_Manager.cpp.

References ACE_GUARD_RETURN, ACE_hthread_t, ACE_MT, ACE_thread_t, ACE_TRACE, grp_id_, and spawn_i.

00720 {
00721   ACE_TRACE ("ACE_Thread_Manager::spawn_n");
00722   ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
00723 
00724   if (grp_id == -1)
00725     grp_id = this->grp_id_++; // Increment the group id.
00726 
00727   for (size_t i = 0; i < n; i++)
00728     {
00729       // @@ What should happen if this fails?! e.g., should we try to
00730       // cancel the other threads that we've already spawned or what?
00731       if (this->spawn_i (func,
00732                          args,
00733                          flags,
00734                          thread_ids == 0 ? 0 : &thread_ids[i],
00735                          thread_handles == 0 ? 0 : &thread_handles[i],
00736                          priority,
00737                          grp_id,
00738                          stack == 0 ? 0 : stack[i],
00739                          stack_size == 0 ? 0 : stack_size[i],
00740                          task) == -1)
00741         return -1;
00742     }
00743 
00744   return grp_id;
00745 }

int ACE_Thread_Manager::spawn_n size_t    n,
ACE_THR_FUNC    func,
void *    args = 0,
long    flags = THR_NEW_LWP|THR_JOINABLE,
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
 

Spawn N new threads, which execute <func> with argument <arg>. If <thread_ids> != 0 the thread_ids of successfully spawned threads will be placed into the <thread_ids> buffer (which must be the same size as <n>). 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. If <stack_size> != 0 it is assumed to be an array of <n> values indicating how big each of the corresponding <stack>s are. 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.

Threads in Thread_Manager can be manipulated in groups based on <grp_id> or <task> using functions such as kill_grp() or cancel_task().

If <grp_id> is assigned, the newly spawned threads are added into the group. Otherwise, the Thread_Manager assigns these <n> threads with a grp_id. You should choose either assigning <grp_id> everytime, or let the Thread_Manager handles it for you consistently.

The argument <task> is usually assigned by <ACE_Task_Base::activate>. It associates the newly spawned threads with an ACE_Task instance, which defaults to <this>.

Return values:
-1  on failure (<errno> will explain...), otherwise returns the group id of the threads.

Definition at line 669 of file Thread_Manager.cpp.

References ACE_GUARD_RETURN, ACE_hthread_t, ACE_MT, ACE_TRACE, grp_id_, and spawn_i.

Referenced by ACE_Task_Base::activate.

00679 {
00680   ACE_TRACE ("ACE_Thread_Manager::spawn_n");
00681   ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
00682 
00683   if (grp_id == -1)
00684     grp_id = this->grp_id_++; // Increment the group id.
00685 
00686   for (size_t i = 0; i < n; i++)
00687     {
00688       // @@ What should happen if this fails?! e.g., should we try to
00689       // cancel the other threads that we've already spawned or what?
00690       if (this->spawn_i (func,
00691                          args,
00692                          flags,
00693                          0,
00694                          thread_handles == 0 ? 0 : &thread_handles[i],
00695                          priority,
00696                          grp_id,
00697                          stack == 0 ? 0 : stack[i],
00698                          stack_size == 0 ? 0 : stack_size[i],
00699                          task) == -1)
00700         return -1;
00701     }
00702 
00703   return grp_id;
00704 }

int ACE_Thread_Manager::suspend ACE_thread_t   
 

Suspend a single thread.

Definition at line 1080 of file Thread_Manager.cpp.

References ACE_EXECUTE_OP, ACE_thread_t, and ACE_TRACE.

01081 {
01082   ACE_TRACE ("ACE_Thread_Manager::suspend");
01083   ACE_EXECUTE_OP (this->suspend_thr, 0);
01084 }

int ACE_Thread_Manager::suspend_all void   
 

Suspend all threads.

Definition at line 1358 of file Thread_Manager.cpp.

References ACE_THR_MEMBER_FUNC, ACE_TRACE, apply_all, and suspend_thr.

Referenced by ACE_Schedule_All_Threaded_Strategy::suspend.

01359 {
01360   ACE_TRACE ("ACE_Thread_Manager::suspend_all");
01361   return this->apply_all (ACE_THR_MEMBER_FUNC (&ACE_Thread_Manager::suspend_thr));
01362 }

int ACE_Thread_Manager::suspend_grp int    grp_id
 

Suspend a group of threads.

Definition at line 1278 of file Thread_Manager.cpp.

References ACE_THR_MEMBER_FUNC, ACE_TRACE, apply_grp, and suspend_thr.

01279 {
01280   ACE_TRACE ("ACE_Thread_Manager::suspend_grp");
01281   return this->apply_grp (grp_id,
01282                           ACE_THR_MEMBER_FUNC (&ACE_Thread_Manager::suspend_thr));
01283 }

int ACE_Thread_Manager::suspend_task ACE_Task_Base   task
 

Suspend all threads in an ACE_Task.

Definition at line 1889 of file Thread_Manager.cpp.

References ACE_THR_MEMBER_FUNC, ACE_TRACE, apply_task, and suspend_thr.

Referenced by ACE_Task_Base::suspend.

01890 {
01891   ACE_TRACE ("ACE_Thread_Manager::suspend_task");
01892   return this->apply_task (task,
01893                            ACE_THR_MEMBER_FUNC (&ACE_Thread_Manager::suspend_thr));
01894 }

int ACE_Thread_Manager::suspend_thr ACE_Thread_Descriptor   td,
int    = 0
[protected]
 

Suspend the thread described in <tda>.

Definition at line 979 of file Thread_Manager.cpp.

References ACE_SET_BITS, ACE_THR_SUSPENDED, ACE_TRACE, ENOTSUP, ACE_Unbounded_Queue< ACE_Thread_Descriptor * >::enqueue_tail, ACE_Thread::suspend, ACE_Thread_Descriptor_Base::thr_handle_, ACE_Thread_Descriptor_Base::thr_state_, and thr_to_be_removed_.

Referenced by suspend_all, suspend_grp, and suspend_task.

00980 {
00981   ACE_TRACE ("ACE_Thread_Manager::suspend_thr");
00982 
00983   int result = ACE_Thread::suspend (td->thr_handle_);
00984   if (result == -1) {
00985     if (errno != ENOTSUP)
00986       this->thr_to_be_removed_.enqueue_tail (td);
00987     return -1;
00988   }
00989   else {
00990     ACE_SET_BITS (td->thr_state_, ACE_THR_SUSPENDED);
00991     return 0;
00992   }
00993 }

ACE_INLINE ACE_Task_Base * ACE_Thread_Manager::task void   
 

Returns a pointer to the current <ACE_Task_Base> we're executing in if this thread is indeed running in an <ACE_Task_Base>, else return 0.

Definition at line 250 of file Thread_Manager.i.

References ACE_TRACE, ACE_Thread_Descriptor_Base::task, and thread_desc_self.

00251 {
00252   ACE_TRACE ("ACE_Thread_Manager::task");
00253 
00254   ACE_Thread_Descriptor *td = this->thread_desc_self () ;
00255 
00256   if (td == 0)
00257     return 0;
00258   else
00259     return td->task ();
00260 }

ssize_t ACE_Thread_Manager::task_all_list ACE_Task_Base   task_list[],
size_t    n
 

Returns in <task_list> a list of up to <n> <ACE_Tasks>. The caller must allocate the memory for <task_list>. In case of an error, -1 is returned. If no requested values are found, 0 is returned, otherwise correct number of retrieved values are returned.

Definition at line 2000 of file Thread_Manager.cpp.

References ACE_GUARD_RETURN, ACE_MT, ACE_TRACE, ACE_Double_Linked_List_Iterator::advance, ACE_Double_Linked_List_Iterator_Base::done, and ACE_Double_Linked_List_Iterator_Base::next.

02002 {
02003   ACE_TRACE ("ACE_Thread_Manager::task_all_list");
02004   ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
02005 
02006   size_t task_list_count = 0;
02007 
02008   for (ACE_Double_Linked_List_Iterator<ACE_Thread_Descriptor> iter (this->thr_list_);
02009        !iter.done ();
02010        iter.advance ())
02011     {
02012       if (task_list_count >= n)
02013         break;
02014 
02015       ACE_Task_Base *task_p = iter.next ()->task_;
02016       if (0 != task_p)
02017         {
02018           // This thread has a task pointer; see if it's already in the
02019           // list. Don't add duplicates.
02020           size_t i = 0;
02021           for (; i < task_list_count; ++i)
02022             if (task_list[i] == task_p)
02023               break;
02024           if (i == task_list_count)        // No match - add this one
02025             task_list[task_list_count++] = task_p;
02026         }
02027     }
02028 
02029   return task_list_count;
02030 }

ssize_t ACE_Thread_Manager::task_list int    grp_id,
ACE_Task_Base   task_list[],
size_t    n
 

Returns in <task_list> a list of up to <n> <ACE_Tasks> in a group. The caller must allocate the memory for <task_list>. In case of an error, -1 is returned. If no requested values are found, 0 is returned, otherwise correct number of retrieved values are returned.

Definition at line 2060 of file Thread_Manager.cpp.

References ACE_GUARD_RETURN, ACE_MT, ACE_TRACE, ACE_Double_Linked_List_Iterator::advance, ACE_Double_Linked_List_Iterator_Base::done, find_task, and ACE_Double_Linked_List_Iterator_Base::next.

02063 {
02064   ACE_TRACE ("ACE_Thread_Manager::task_list");
02065   ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
02066 
02067   ACE_Task_Base **task_list_iterator = task_list;
02068   size_t task_list_count = 0;
02069   size_t i = 0;
02070 
02071   for (ACE_Double_Linked_List_Iterator<ACE_Thread_Descriptor> iter (this->thr_list_);
02072        !iter.done ();
02073        iter.advance ())
02074     {
02075       if (task_list_count >= n)
02076         break;
02077 
02078       if (iter.next ()->grp_id_ == grp_id
02079           && this->find_task (iter.next ()->task_, i) == 0)
02080         {
02081           task_list_iterator[task_list_count] = iter.next ()->task_;
02082           task_list_count++;
02083         }
02084 
02085       i++;
02086     }
02087 
02088   return task_list_count;
02089 }

int ACE_Thread_Manager::testcancel ACE_thread_t    t_id
 

True if <t_id> is cancelled, else false. Always return false if <t_id> is not managed by the Thread_Manager.

Definition at line 1169 of file Thread_Manager.cpp.

References ACE_THR_CANCELLED, ACE_thread_t, ACE_TRACE, and check_state.

01170 {
01171   ACE_TRACE ("ACE_Thread_Manager::testcancel");
01172   return this->check_state (ACE_THR_CANCELLED, t_id);
01173 }

int ACE_Thread_Manager::testresume ACE_thread_t    t_id
 

True if <t_id> is active (i.e., resumed), else false. Always return false if <t_id> is not managed by the Thread_Manager.

Definition at line 1160 of file Thread_Manager.cpp.

References ACE_THR_SUSPENDED, ACE_thread_t, ACE_TRACE, and check_state.

01161 {
01162   ACE_TRACE ("ACE_Thread_Manager::testresume");
01163   return this->check_state (ACE_THR_SUSPENDED, t_id, 0);
01164 }

int ACE_Thread_Manager::testsuspend ACE_thread_t    t_id
 

True if <t_id> is inactive (i.e., suspended), else false. Always return false if <t_id> is not managed by the Thread_Manager.

Definition at line 1151 of file Thread_Manager.cpp.

References ACE_THR_SUSPENDED, ACE_thread_t, ACE_TRACE, and check_state.

01152 {
01153   ACE_TRACE ("ACE_Thread_Manager::testsuspend");
01154   return this->check_state (ACE_THR_SUSPENDED, t_id);
01155 }

ACE_INLINE ACE_thread_t ACE_Thread_Manager::thr_self void   
 

Return the unique ID of the thread. This is not strictly necessary (because a thread can always just call <ACE_Thread::self>). However, we put it here to be complete.

Definition at line 243 of file Thread_Manager.i.

References ACE_TRACE, and ACE_Thread::self.

00244 {
00245   ACE_TRACE ("ACE_Thread_Manager::thr_self");
00246   return ACE_Thread::self ();
00247 }

int ACE_Thread_Manager::thr_self ACE_hthread_t  
 

Return the "real" handle to the calling thread, caching it if necessary in TSS to speed up subsequent lookups. This is necessary since on some platforms (e.g., Win32) we can't get this handle via direct method calls. Notice that you should *not* close the handle passed back from this method. It is used internally by Thread Manager. On the other hand, you *have to* use this internal thread handle when working on Thread_Manager. Return -1 if fail.

Definition at line 307 of file Thread_Manager.cpp.

References ACE_hthread_t, ACE_TRACE, ACE_Thread_Descriptor::self, and thread_desc_self.

00308 {
00309   ACE_TRACE ("ACE_Thread_Manager::thr_self");
00310 
00311   ACE_Thread_Descriptor *desc =
00312     this->thread_desc_self ();
00313 
00314   if (desc == 0)
00315     return -1;
00316   else
00317     desc->self (self);
00318 
00319   return 0;
00320 }

ssize_t ACE_Thread_Manager::thread_all_list ACE_thread_t    thread_list[],
size_t    n
 

Returns in <thread_list> a list of up to <n> thread ids. The caller must allocate the memory for <thread_list>. In case of an error, -1 is returned. If no requested values are found, 0 is returned, otherwise correct number of retrieved values are returned.

Definition at line 2035 of file Thread_Manager.cpp.

References ACE_GUARD_RETURN, ACE_MT, ACE_thread_t, ACE_TRACE, ACE_Double_Linked_List_Iterator::advance, ACE_Double_Linked_List_Iterator_Base::done, ACE_Double_Linked_List_Iterator_Base::next, and thread_list.

02037 {
02038   ACE_TRACE ("ACE_Thread_Manager::thread_all_list");
02039   ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
02040 
02041   size_t thread_count = 0;
02042 
02043   for (ACE_Double_Linked_List_Iterator<ACE_Thread_Descriptor> iter (this->thr_list_);
02044        !iter.done ();
02045        iter.advance ())
02046     {
02047       if (thread_count >= n)
02048         break;
02049 
02050       thread_list[thread_count] = iter.next ()->thr_id_;
02051       thread_count ++;
02052     }
02053 
02054   return thread_count;
02055 }

ACE_INLINE ACE_Thread_Descriptor * ACE_Thread_Manager::thread_desc_self void    [protected]
 

Get a pointer to the calling thread's own thread_descriptor. This must be called from a spawn thread. This function will fetch the info from TSS.

Definition at line 213 of file Thread_Manager.i.

References ACE_LOG_MSG, ACE_thread_t, find_thread, and ACE_OS::thr_self.

Referenced by at_exit, run_thread_exit_hooks, task, and thr_self.

00214 {
00215   // This method must be called with lock held.
00216 
00217   // Try to get it from cache.
00218   ACE_Thread_Descriptor *desc = ACE_LOG_MSG->thr_desc ();
00219 
00220 #if 1
00221   //  ACE_ASSERT (desc != 0);
00222   // Thread descriptor should always get cached.
00223 #else
00224   if (desc == 0)
00225     {
00226       ACE_thread_t id = ACE_OS::thr_self ();
00227 
00228       desc = this->find_thread (id);
00229 
00230       // Thread descriptor adapter might not have been put into the
00231       // list yet.
00232       if (desc != 0)
00233         // Update the TSS cache.
00234         ACE_LOG_MSG->thr_desc (desc);
00235     }
00236 #endif
00237   return desc;
00238 }

ACE_Thread_Descriptor * ACE_Thread_Manager::thread_descriptor ACE_thread_t    [protected]
 

Return a pointer to the thread's Thread_Descriptor, 0 if fail.

Definition at line 285 of file Thread_Manager.cpp.

References ACE_FIND, ACE_GUARD_RETURN, ACE_MT, ACE_thread_t, and ACE_TRACE.

00286 {
00287   ACE_TRACE ("ACE_Thread_Manager::thread_descriptor");
00288   ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, 0));
00289 
00290   ACE_FIND (this->find_thread (thr_id), ptr);
00291   return ptr;
00292 }

ssize_t ACE_Thread_Manager::thread_grp_list int    grp_id,
ACE_thread_t    thread_list[],
size_t    n
 

Returns in <thread_list> a list of up to <n> thread ids in a group <grp_id>. The caller must allocate the memory for <thread_list>. In case of an error, -1 is returned. If no requested values are found, 0 is returned, otherwise correct number of retrieved values are returned.

Definition at line 2150 of file Thread_Manager.cpp.

References ACE_GUARD_RETURN, ACE_MT, ACE_thread_t, ACE_TRACE, ACE_Double_Linked_List_Iterator::advance, ACE_Double_Linked_List_Iterator_Base::done, ACE_Double_Linked_List_Iterator_Base::next, and thread_list.

02153 {
02154   ACE_TRACE ("ACE_Thread_Manager::thread_grp_list");
02155   ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
02156 
02157   size_t thread_count = 0;
02158 
02159   for (ACE_Double_Linked_List_Iterator<ACE_Thread_Descriptor> iter (this->thr_list_);
02160        !iter.done ();
02161        iter.advance ())
02162     {
02163       if (thread_count >= n)
02164         break;
02165 
02166       if (iter.next ()->grp_id_ == grp_id)
02167         {
02168           thread_list[thread_count] = iter.next ()->thr_id_;
02169           thread_count++;
02170         }
02171     }
02172 
02173   return thread_count;
02174 }

ssize_t ACE_Thread_Manager::thread_list ACE_Task_Base   task,
ACE_thread_t    thread_list[],
size_t    n
 

Returns in <thread_list> a list of up to <n> thread ids in an <ACE_Task_Base>. The caller must allocate the memory for <thread_list>. In case of an error, -1 is returned. If no requested values are found, 0 is returned, otherwise correct number of retrieved values are returned.

Definition at line 2094 of file Thread_Manager.cpp.

References ACE_GUARD_RETURN, ACE_MT, ACE_thread_t, ACE_TRACE, ACE_Double_Linked_List_Iterator::advance, ACE_Double_Linked_List_Iterator_Base::done, ACE_Double_Linked_List_Iterator_Base::next, and thread_list.

Referenced by thread_all_list, thread_grp_list, and thread_list.

02097 {
02098   ACE_TRACE ("ACE_Thread_Manager::thread_list");
02099   ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
02100 
02101   size_t thread_count = 0;
02102 
02103   for (ACE_Double_Linked_List_Iterator<ACE_Thread_Descriptor> iter (this->thr_list_);
02104        !iter.done ();
02105        iter.advance ())
02106     {
02107       if (thread_count >= n)
02108         break;
02109 
02110       if (iter.next ()->task_ == task)
02111         {
02112           thread_list[thread_count] = iter.next ()->thr_id_;
02113           thread_count++;
02114         }
02115     }
02116 
02117   return thread_count;
02118 }

int ACE_Thread_Manager::thread_within ACE_thread_t    tid
 

Definition at line 1193 of file Thread_Manager.cpp.

References ACE_GUARD_RETURN, ACE_MT, ACE_thread_t, ACE_TRACE, ACE_Double_Linked_List_Iterator::advance, ACE_Double_Linked_List_Iterator_Base::done, ACE_Double_Linked_List_Iterator_Base::next, and ACE_OS::thr_equal.

01194 {
01195   ACE_TRACE ("ACE_Thread_Manager::thread_within");
01196   ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_monx, this->lock_, -1));
01197 
01198   for (ACE_Double_Linked_List_Iterator<ACE_Thread_Descriptor> iter (this->thr_list_);
01199        !iter.done ();
01200        iter.advance ())
01201     if (ACE_OS::thr_equal (iter.next ()->thr_id_, tid))
01202       return 1;
01203 
01204   return 0;
01205 }

int ACE_Thread_Manager::wait const ACE_Time_Value   timeout = 0,
int    abandon_detached_threads = 0
 

Block until there are no more threads running in the <Thread_Manager> or <timeout> expires. Note that <timeout> is treated as "absolute" time. Returns 0 on success and -1 on failure. If <abandon_detached_threads> is set, wait will first check thru its thread list for threads with THR_DETACHED or THR_DAEMON flags set and remove these threads. Notice that unlike other wait_* function, by default, <wait> does wait on all thread spawned by this thread_manager no matter the detached flags are set or not unless it is called with <abandon_detached_threads> flag set. NOTE that if this function is called while the ACE_Object_Manager is shutting down (as a result of program rundown via ACE::fini), it will not wait for any threads to complete. If you must wait for threads spawned by this thread manager to complete and you are in a ACE rundown situation (such as your object is being destroyed by the ACE_Object_Manager) you can use wait_grp instead.

Definition at line 1690 of file Thread_Manager.cpp.

References ACE_ASSERT, ACE_BIT_DISABLED, ACE_BIT_ENABLED, ACE_GUARD_RETURN, ACE_MT, ACE_SET_BITS, ACE_THR_JOINING, ACE_TRACE, ACE_Double_Linked_List_Iterator::advance, ACE_Double_Linked_List< ACE_Thread_Descriptor_Base >::delete_head, ACE_Unbounded_Queue< ACE_Thread_Descriptor * >::dequeue_head, ACE_Double_Linked_List_Iterator_Base::done, ACE_Unbounded_Queue< ACE_Thread_Descriptor * >::enqueue_tail, ACE_OS_Thread_Descriptor::flags_, ACE_Unbounded_Queue< ACE_Thread_Descriptor * >::is_empty, ACE_Thread::join, ACE_Double_Linked_List_Iterator_Base::next, remove_thr, remove_thr_all, ACE_Object_Manager::shutting_down, ACE_Double_Linked_List< ACE_Thread_Descriptor >::size, terminated_thr_list_, ACE_Thread_Descriptor_Base::thr_handle_, thr_list_, thr_to_be_removed_, ACE_Condition_Thread_Mutex::wait, and zero_cond_.

Referenced by close.

01692 {
01693   ACE_TRACE ("ACE_Thread_Manager::wait");
01694 
01695 #if defined (ACE_HAS_THREADS)
01696   {
01697     // Just hold onto the guard while waiting.
01698     ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
01699 
01700     if (ACE_Object_Manager::shutting_down () != 1)
01701       {
01702         // Program is not shutting down.  Perform a normal wait on threads.
01703         if (abandon_detached_threads != 0)
01704           {
01705             ACE_ASSERT (this->thr_to_be_removed_.is_empty ());
01706             for (ACE_Double_Linked_List_Iterator<ACE_Thread_Descriptor>
01707                    iter (this->thr_list_);
01708                  !iter.done ();
01709                  iter.advance ())
01710               if (ACE_BIT_ENABLED (iter.next ()->flags_,
01711                                    THR_DETACHED | THR_DAEMON)
01712                   && ACE_BIT_DISABLED (iter.next ()->flags_, THR_JOINABLE))
01713                 {
01714                   this->thr_to_be_removed_.enqueue_tail (iter.next ());
01715                   ACE_SET_BITS (iter.next ()->thr_state_, ACE_THR_JOINING);
01716                 }
01717 
01718             if (! this->thr_to_be_removed_.is_empty ())
01719               {
01720                 ACE_Thread_Descriptor *td;
01721                 while (this->thr_to_be_removed_.dequeue_head (td) != -1)
01722                   this->remove_thr (td, 1);
01723               }
01724           }
01725 
01726         while (this->thr_list_.size () > 0)
01727           if (this->zero_cond_.wait (timeout) == -1)
01728             return -1;
01729       }
01730     else
01731         // Program is shutting down, no chance to wait on threads.
01732         // Therefore, we'll just remove threads from the list.
01733         this->remove_thr_all ();
01734     // Release the guard, giving other threads a chance to run.
01735   }
01736 
01737 #if !defined (VXWORKS)
01738   // @@ VxWorks doesn't support thr_join (yet.)  We are working
01739   //on our implementation.   Chorus'es thr_join seems broken.
01740   ACE_Thread_Descriptor_Base *item;
01741 
01742 #if defined (CHORUS)
01743   if (ACE_Object_Manager::shutting_down () != 1)
01744     {
01745 #endif /* CHORUS */
01746       while ((item = this->terminated_thr_list_.delete_head ()) != 0)
01747         {
01748           if (ACE_BIT_DISABLED (item->flags_, THR_DETACHED | THR_DAEMON)
01749               || ACE_BIT_ENABLED (item->flags_, THR_JOINABLE))
01750             // Detached handles shouldn't reached here.
01751               ACE_Thread::join (item->thr_handle_);
01752 
01753 # if defined (ACE_HAS_PTHREADS_DRAFT4)  &&  defined (ACE_LACKS_SETDETACH)
01754           // Must explicitly detach threads.  Threads without
01755           // THR_DETACHED were detached in ACE_OS::thr_create ().
01756           ::pthread_detach (&item->thr_handle_);
01757 # endif /* ACE_HAS_PTHREADS_DRAFT4 && ACE_LACKS_SETDETACH */
01758           delete item;
01759         }
01760 #if defined (CHORUS)
01761     }
01762 #endif /* CHORUS */
01763 
01764 #endif /* ! VXWORKS */
01765 #else
01766   ACE_UNUSED_ARG (timeout);
01767   ACE_UNUSED_ARG (abandon_detached_threads);
01768 #endif /* ACE_HAS_THREADS */
01769 
01770   return 0;
01771 }

int ACE_Thread_Manager::wait_grp int    grp_id
 

Block until there are no more threads running in a group. Returns 0 on success and -1 on failure. Notice that wait_grp will not wait on detached threads.

Definition at line 1480 of file Thread_Manager.cpp.

References ACE_BIT_DISABLED, ACE_BIT_ENABLED, ACE_GUARD_RETURN, ACE_MT, ACE_NEW_RETURN, ACE_SET_BITS, ACE_THR_JOINING, ACE_TRACE, ACE_Double_Linked_List_Iterator::advance, ACE_Double_Linked_List_Iterator::advance_and_remove, ACE_Double_Linked_List_Iterator_Base::done, ACE_Thread::join, ACE_Double_Linked_List_Iterator_Base::next, ACE_Double_Linked_List< ACE_Thread_Descriptor_Base >::size, terminated_thr_list_, and ACE_Thread_Descriptor_Base::thr_handle_.

Referenced by ACE_Proactor_Timer_Handler::~ACE_Proactor_Timer_Handler.

01481 {
01482   ACE_TRACE ("ACE_Thread_Manager::wait_grp");
01483 
01484   int copy_count = 0;
01485   ACE_Thread_Descriptor_Base *copy_table = 0;
01486 
01487   // We have to make sure that while we wait for these threads to
01488   // exit, we do not have the lock.  Therefore we make a copy of all
01489   // interesting entries and let go of the lock.
01490   {
01491     ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
01492 
01493 #if !defined (VXWORKS)
01494     ACE_NEW_RETURN (copy_table,
01495                     ACE_Thread_Descriptor_Base [this->thr_list_.size ()
01496                                                + this->terminated_thr_list_.size ()],
01497                     -1);
01498 #else
01499     ACE_NEW_RETURN (copy_table,
01500                     ACE_Thread_Descriptor_Base [this->thr_list_.size ()],
01501                     -1);
01502 #endif /* VXWORKS */
01503 
01504     for (ACE_Double_Linked_List_Iterator<ACE_Thread_Descriptor> iter (this->thr_list_);
01505          !iter.done ();
01506          iter.advance ())
01507       // If threads are created as THR_DETACHED or THR_DAEMON, we
01508       // can't help much.
01509       if (iter.next ()->grp_id_ == grp_id &&
01510           (ACE_BIT_DISABLED (iter.next ()->flags_, THR_DETACHED | THR_DAEMON)
01511            || ACE_BIT_ENABLED (iter.next ()->flags_, THR_JOINABLE)))
01512         {
01513           ACE_SET_BITS (iter.next ()->thr_state_, ACE_THR_JOINING);
01514           copy_table[copy_count++] = *iter.next ();
01515         }
01516 
01517 #if !defined (VXWORKS)
01518     for (ACE_Double_Linked_List_Iterator<ACE_Thread_Descriptor_Base> biter (this->terminated_thr_list_);
01519          !biter.done ();
01520          biter.advance ())
01521       // If threads are created as THR_DETACHED or THR_DAEMON, we
01522       // can't help much.
01523       if (biter.next ()->grp_id_ == grp_id)
01524         {
01525           ACE_Thread_Descriptor_Base *tdb = biter.advance_and_remove (0);
01526           copy_table[copy_count++] = *tdb;
01527           delete tdb;
01528         }
01529 #endif /* !VXWORKS */
01530   }
01531 
01532   // Now actually join() with all the threads in this group.
01533   int result = 0;
01534 
01535   for (int i = 0;
01536        i < copy_count && result != -1;
01537        i++)
01538     {
01539       if (ACE_Thread::join (copy_table[i].thr_handle_) == -1)
01540         result = -1;
01541 
01542 # if defined (ACE_HAS_PTHREADS_DRAFT4)  &&  defined (ACE_LACKS_SETDETACH)
01543       // Must explicitly detach threads.  Threads without THR_DETACHED
01544       // were detached in ACE_OS::thr_create ().
01545       ::pthread_detach (&copy_table[i].thr_handle_);
01546 # endif /* ACE_HAS_PTHREADS_DRAFT4 && ACE_LACKS_SETDETACH */
01547     }
01548 
01549   delete [] copy_table;
01550 
01551   return result;
01552 }

ACE_INLINE int ACE_Thread_Manager::wait_on_exit void   
 

Definition at line 312 of file Thread_Manager.i.

References automatic_wait_.

00313 {
00314   return this->automatic_wait_;
00315 }

ACE_INLINE void ACE_Thread_Manager::wait_on_exit int    dowait
 

Access function to determine whether the Thread_Manager will wait for its thread to exit or not when being closing down.

Definition at line 306 of file Thread_Manager.i.

References automatic_wait_.

00307 {
00308   this->automatic_wait_ = do_wait;
00309 }

int ACE_Thread_Manager::wait_task ACE_Task_Base   task
 

Block until there are no more threads running in a specified 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.

Parameters:
task  The ACE_Task_Base object whose threads are to waited for.
Return values:
0  Success.
-1  Failure (consult errno for further information).

Definition at line 1811 of file Thread_Manager.cpp.

References ACE_BIT_DISABLED, ACE_BIT_ENABLED, ACE_GUARD_RETURN, ACE_MT, ACE_NEW_RETURN, ACE_SET_BITS, ACE_THR_JOINING, ACE_Double_Linked_List_Iterator::advance, ACE_Double_Linked_List_Iterator::advance_and_remove, ACE_Double_Linked_List_Iterator_Base::done, ACE_Thread::join, ACE_Double_Linked_List_Iterator_Base::next, ACE_Double_Linked_List< ACE_Thread_Descriptor_Base >::size, terminated_thr_list_, and ACE_Thread_Descriptor_Base::thr_handle_.

Referenced by ACE_Task_Base::wait.

01812 {
01813   int copy_count = 0;
01814   ACE_Thread_Descriptor_Base *copy_table = 0;
01815 
01816   // We have to make sure that while we wait for these threads to
01817   // exit, we do not have the lock.  Therefore we make a copy of all
01818   // interesting entries and let go of the lock.
01819   {
01820     ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
01821 
01822 #if !defined (VXWORKS)
01823     ACE_NEW_RETURN (copy_table,
01824                     ACE_Thread_Descriptor_Base [this->thr_list_.size ()
01825                                                 + this->terminated_thr_list_.size ()],
01826                     -1);
01827 #else
01828     ACE_NEW_RETURN (copy_table,
01829                     ACE_Thread_Descriptor_Base [this->thr_list_.size ()],
01830                     -1);
01831 #endif /* VXWORKS */
01832 
01833     for (ACE_Double_Linked_List_Iterator<ACE_Thread_Descriptor> iter (this->thr_list_);
01834          !iter.done ();
01835          iter.advance ())
01836       // If threads are created as THR_DETACHED or THR_DAEMON, we
01837       // can't wait on them here.
01838       if (iter.next ()->task_ == task &&
01839           (ACE_BIT_DISABLED (iter.next ()->flags_,
01840                              THR_DETACHED | THR_DAEMON)
01841            || ACE_BIT_ENABLED (iter.next ()->flags_,
01842                                THR_JOINABLE)))
01843         {
01844           ACE_SET_BITS (iter.next ()->thr_state_,
01845                         ACE_THR_JOINING);
01846           copy_table[copy_count++] = *iter.next ();
01847         }
01848 
01849 #if !defined (VXWORKS)
01850     for (ACE_Double_Linked_List_Iterator<ACE_Thread_Descriptor_Base> titer (this->terminated_thr_list_);
01851          !titer.done ();
01852          titer.advance ())
01853       // If threads are created as THR_DETACHED or THR_DAEMON, we can't help much here.
01854       if (titer.next ()->task_ == task)
01855         {
01856           ACE_Thread_Descriptor_Base *tdb =
01857             titer.advance_and_remove (0);
01858           copy_table[copy_count++] = *tdb;
01859           delete tdb;
01860         }
01861 #endif /* VXWORKS */
01862   }
01863 
01864   // Now to do the actual work
01865   int result = 0;
01866 
01867   for (int i = 0;
01868        i < copy_count && result != -1;
01869        i++)
01870     {
01871       if (ACE_Thread::join (copy_table[i].thr_handle_) == -1)
01872         result = -1;
01873 
01874 # if defined (ACE_HAS_PTHREADS_DRAFT4)  &&  defined (ACE_LACKS_SETDETACH)
01875       // Must explicitly detach threads.  Threads without THR_DETACHED
01876       // were detached in ACE_OS::thr_create ().
01877       ::pthread_detach (&copy_table[i].thr_handle_);
01878 # endif /* ACE_HAS_PTHREADS_DRAFT4 && ACE_LACKS_SETDETACH */
01879     }
01880 
01881   delete [] copy_table;
01882 
01883   return result;
01884 }


Friends And Related Function Documentation

friend class ACE_Thread_Control [friend]
 

Definition at line 390 of file Thread_Manager.h.

friend class ACE_Thread_Descriptor [friend]
 

Definition at line 395 of file Thread_Manager.h.

friend class ACE_Thread_Exit [friend]
 

Definition at line 393 of file Thread_Manager.h.


Member Data Documentation

ACE_Thread_Manager::ACE_ALLOC_HOOK_DECLARE
 

Declare the dynamic allocation hooks.

Definition at line 916 of file Thread_Manager.h.

int ACE_Thread_Manager::automatic_wait_ [protected]
 

Set if we want the Thread_Manager to wait on all threads before being closed, reset otherwise.

Definition at line 1061 of file Thread_Manager.h.

Referenced by close, and wait_on_exit.

int ACE_Thread_Manager::delete_thr_mgr_ = 0 [static, private]
 

Must delete the <thr_mgr_> if non-0.

Definition at line 26 of file Thread_Manager.cpp.

Referenced by close_singleton, and instance.

int ACE_Thread_Manager::grp_id_ [protected]
 

Keeps track of the next group id to assign.

Definition at line 1057 of file Thread_Manager.h.

Referenced by insert_thr, spawn, and spawn_n.

ACE_Thread_Mutex ACE_Thread_Manager::lock_ [protected]
 

Serialize access to the <zero_cond_>.

Definition at line 1066 of file Thread_Manager.h.

Referenced by dump.

ACE_Double_Linked_List<ACE_Thread_Descriptor_Base> ACE_Thread_Manager::terminated_thr_list_ [protected]
 

Collect terminated but not yet joined thread entries.

Definition at line 1050 of file Thread_Manager.h.

Referenced by register_as_terminated, wait, wait_grp, and wait_task.

ACE_Double_Linked_List<ACE_Thread_Descriptor> ACE_Thread_Manager::thr_list_ [protected]
 

Keeping a list of thread descriptors within the thread manager. Double-linked list enables us to cache the entries in TSS and adding/removing thread descriptor entries without affecting other thread's descriptor entries.

Definition at line 1046 of file Thread_Manager.h.

Referenced by append_thr, count_threads, remove_thr, remove_thr_all, and wait.

ACE_Thread_Manager * ACE_Thread_Manager::thr_mgr_ = 0 [static, private]
 

Pointer to a process-wide <ACE_Thread_Manager>.

Definition at line 22 of file Thread_Manager.cpp.

Referenced by close_singleton, and instance.

ACE_Unbounded_Queue<ACE_Thread_Descriptor*> ACE_Thread_Manager::thr_to_be_removed_ [protected]
 

Collect pointers to thread descriptors of threads to be removed later.

Definition at line 1054 of file Thread_Manager.h.

Referenced by apply_all, apply_grp, apply_task, kill_thr, resume_thr, suspend_thr, and wait.

ACE_Locked_Free_List<ACE_Thread_Descriptor, ACE_SYNCH_MUTEX> ACE_Thread_Manager::thread_desc_freelist_ [private]
 

Definition at line 1073 of file Thread_Manager.h.

Referenced by remove_thr.

ACE_Condition_Thread_Mutex ACE_Thread_Manager::zero_cond_ [protected]
 

Keep track of when there are no more threads.

Definition at line 1069 of file Thread_Manager.h.

Referenced by remove_thr, and wait.


The documentation for this class was generated from the following files:
Generated on Mon Jun 16 12:57:40 2003 for ACE by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002