#include <ace/Thread.h>
class ACE_Thread {
public:
static int spawn ( ACE_THR_FUNC func, void *arg = 0, long flags = THR_NEW_LWP | THR_JOINABLE, ACE_thread_t *t_id = 0, ACE_hthread_t *t_handle = 0, long priority = ACE_DEFAULT_THREAD_PRIORITY, void *stack = 0, size_t stack_size = 0, ACE_Thread_Adapter *thread_adapter = 0 );
static int spawn_n ( size_t n, ACE_THR_FUNC func, void *arg = 0, long flags = THR_NEW_LWP | THR_JOINABLE, long priority = ACE_DEFAULT_THREAD_PRIORITY, void *stack[] = 0, size_t stack_size[] = 0, ACE_Thread_Adapter *thread_adapter = 0 );
static int spawn_n ( ACE_thread_t thread_ids[], size_t n, ACE_THR_FUNC func, void *arg, long flags, long priority = ACE_DEFAULT_THREAD_PRIORITY, void *stack[] = 0, size_t stack_size[] = 0, ACE_hthread_t thread_handles[] = 0, ACE_Thread_Adapter *thread_adapter = 0 );
static int join (ACE_thread_t, ACE_thread_t *, void **status = 0);
static int join (ACE_hthread_t, void ** = 0);
static int resume (ACE_hthread_t);
static int suspend (ACE_hthread_t);
static int getprio (ACE_hthread_t, int &prio);
static int setprio (ACE_hthread_t, int prio);
static int kill (ACE_thread_t, int signum);
static void yield (void);
static void self (ACE_hthread_t &t_handle);
static ACE_thread_t self (void);
static void exit (void *status = 0);
static int getconcurrency (void);
static int setconcurrency (int new_level);
static int sigsetmask ( int how, const sigset_t *sigset, sigset_t *osigset = 0 );
static int keycreate ( ACE_thread_key_t *keyp, ACE_THR_C_DEST destructor, ACE_THR_DEST destructor, void * = 0 );
static int keyfree (ACE_thread_key_t key);
static int setspecific (ACE_thread_key_t key, void *value);
static int getspecific (ACE_thread_key_t key, void **valuep);
static int disablecancel (struct cancel_state *old_state);
static int enablecancel ( struct cancel_state *old_state, int flag );
static int setcancelstate ( struct cancel_state &new_state, struct cancel_state *old_state );
static int cancel (ACE_thread_t t_id);
static void testcancel (void);
private:
ACE_Thread (void);
};
ACE_Thread_Manager
programming API rather than the ACE_Thread
API since the
thread manager is more powerful.
static int spawn (
ACE_THR_FUNC func,
void *arg = 0,
long flags = THR_NEW_LWP | THR_JOINABLE,
ACE_thread_t *t_id = 0,
ACE_hthread_t *t_handle = 0,
long priority = ACE_DEFAULT_THREAD_PRIORITY,
void *stack = 0,
size_t stack_size = 0,
ACE_Thread_Adapter *thread_adapter = 0
);
flags
attributes and running func
with args
(if thread_adapter
is non-0 then func
and args
are ignored and are obtained from thread_adapter
). thr_id
and t_handle
are set to the thread's ID and handle (?),
respectively. The thread runs at priority
priority (see
below).
The flags
are a bitwise-OR of the following:
By default, or if priority
is set to
ACE_DEFAULT_THREAD_PRIORITY, an "appropriate" priority value for
the given scheduling policy (specified in flags
, e.g.,
THR_SCHED_DEFAULT
) is used. This value is calculated
dynamically, and is the median value between the minimum and
maximum priority values for the given policy. If an explicit
value is given, it is used. Note that actual priority values are
EXTREMEMLY implementation-dependent, and are probably best
avoided.
Note that thread_adapter
is always deleted by thr_create
,
therefore it must be allocated with global operator new.
static int spawn_n (
size_t n,
ACE_THR_FUNC func,
void *arg = 0,
long flags = THR_NEW_LWP | THR_JOINABLE,
long priority = ACE_DEFAULT_THREAD_PRIORITY,
void *stack[] = 0,
size_t stack_size[] = 0,
ACE_Thread_Adapter *thread_adapter = 0
);
func
with argument arg
(if
thread_adapter
is non-0 then func
and args
are ignored and
are obtained from thread_adapter
). If stack
!= 0 it is
assumed to be an array of n
pointers to the base of the stacks
to use for the threads being spawned. Likewise, if stack_size
!= 0 it is assumed to be an array of n
values indicating how
big each of the corresponding stack
s are. Returns the number
of threads actually spawned (if this doesn't equal the number
requested then something has gone wrong and errno
will
explain...).
See also spawn
.
static int spawn_n (
ACE_thread_t thread_ids[],
size_t n,
ACE_THR_FUNC func,
void *arg,
long flags,
long priority = ACE_DEFAULT_THREAD_PRIORITY,
void *stack[] = 0,
size_t stack_size[] = 0,
ACE_hthread_t thread_handles[] = 0,
ACE_Thread_Adapter *thread_adapter = 0
);
n
new threads, which execute func
with argument arg
(if thread_adapter
is non-0 then func
and args
are ignored
and are obtained from thread_adapter
). 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. Returns
the number of threads actually spawned (if this doesn't equal the
number requested then something has gone wrong and errno
will
explain...).
See also spawn
.
static int join (ACE_thread_t, ACE_thread_t *, void **status = 0);
static int join (ACE_hthread_t, void ** = 0);
static int resume (ACE_hthread_t);
static int suspend (ACE_hthread_t);
static int getprio (ACE_hthread_t, int &prio);
static int setprio (ACE_hthread_t, int prio);
static int kill (ACE_thread_t, int signum);
static void yield (void);
static void self (ACE_hthread_t &t_handle);
ACE_Thread_Manager::thr_self
method.
static ACE_thread_t self (void);
static void exit (void *status = 0);
static int getconcurrency (void);
static int setconcurrency (int new_level);
static int sigsetmask (
int how,
const sigset_t *sigset,
sigset_t *osigset = 0
);
static int keycreate (
ACE_thread_key_t *keyp,
ACE_THR_C_DEST destructor,
ACE_THR_DEST destructor,
void * = 0
);
keyp
that is used to identify data that is specific
to each thread in the process. The key is global to all threads
in the process.
static int keyfree (ACE_thread_key_t key);
static int setspecific (ACE_thread_key_t key, void *value);
key
, for the calling
thread.
static int getspecific (ACE_thread_key_t key, void **valuep);
key
for the calling thread
into the location pointed to by valuep
.
static int disablecancel (struct cancel_state *old_state);
static int enablecancel (struct cancel_state *old_state, int flag);
static int setcancelstate (
struct cancel_state &new_state,
struct cancel_state *old_state
);
static int cancel (ACE_thread_t t_id);
static void testcancel (void);
ACE_Thread (void);