blob: 9686b5a29daf98700624f23bb4a1d6d048cb4e37 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
|
// $Id$
#ifndef THREAD_POOL_H
#define THREAD_POOL_H
/* In order to implement a thread pool, we have to have an object that
can create a thread. The ACE_Task<> is the basis for doing just
such a thing. */
#include "ace/Task.h"
#if !defined (ACE_LACKS_PRAGMA_ONCE)
# pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */
/* We need a forward reference for ACE_Event_Handler so that our
enqueue() method can accept a pointer to one. */
class ACE_Event_Handler;
/* Although we modified the rest of our program to make use of the
thread pool implementation, if you look closely you'll see that the
changes were rather minor. The "ACE way" is generally to create a
helper object that abstracts away the details not relevant to your
application. That's what I'm trying to do here by creating the
Thread_Pool object. */
class Thread_Pool : public ACE_Task<ACE_MT_SYNCH>
{
public:
typedef ACE_Task<ACE_MT_SYNCH> inherited;
/* Provide an enumeration for the default pool size. By doing this,
other objects can use the value when they want a default. */
enum size_t
{
default_pool_size_ = 5
};
// Basic constructor
Thread_Pool (void);
/* Opening the thread pool causes one or more threads to be
activated. When activated, they all execute the svc() method
declared below. */
int open (int pool_size = default_pool_size_);
/* Some compilers will complain that our open() above attempts to
override a virtual function in the baseclass. We have no
intention of overriding that method but in order to keep the
compiler quiet we have to add this method as a pass-thru to the
baseclass method. */
virtual int open (void *void_data)
{
return inherited::open (void_data);
}
/*
*/
virtual int close (u_long flags = 0);
/* To use the thread pool, you have to put some unit of work into
it. Since we're dealing with event handlers (or at least their
derivatives), I've chosen to provide an enqueue() method that
takes a pointer to an ACE_Event_Handler. The handler's
handle_input() method will be called, so your object has to know
when it is being called by the thread pool. */
int enqueue (ACE_Event_Handler *handler);
/* Another handy ACE template is ACE_Atomic_Op<>. When
parameterized, this allows is to have a thread-safe counting
object. The typical arithmetic operators are all internally
thread-safe so that you can share it across threads without
worrying about any contention issues. */
typedef ACE_Atomic_Op<ACE_Mutex, int> counter_t;
protected:
/* Our svc() method will dequeue the enqueued event handler objects
and invoke the handle_input() method on each. Since we're likely
running in more than one thread, idle threads can take work from
the queue while other threads are busy executing handle_input() on
some object. */
int svc (void);
/* We use the atomic op to keep a count of the number of threads in
which our svc() method is running. This is particularly important
when we want to close() it down! */
counter_t active_threads_;
};
#endif /* THREAD_POOL_H */
|
