ACE
6.0.6
|
Defines the interface for specifying a concurrency strategy for a SVC_HANDLER
based on multiprocessing.
More...
#include <Strategies_T.h>
Public Types | |
typedef ACE_Concurrency_Strategy < SVC_HANDLER > | base_type |
Public Member Functions | |
ACE_Process_Strategy (size_t n_processes=1, ACE_Event_Handler *acceptor=0, ACE_Reactor *=0, int avoid_zombies=0) | |
virtual int | open (size_t n_processes=1, ACE_Event_Handler *acceptor=0, ACE_Reactor *=0, int avoid_zombies=0) |
virtual | ~ACE_Process_Strategy (void) |
virtual int | activate_svc_handler (SVC_HANDLER *svc_handler, void *arg=0) |
void | dump (void) const |
Dump the state of an object. | |
Public Attributes | |
ACE_ALLOC_HOOK_DECLARE | |
Declare the dynamic allocation hooks. | |
Protected Types | |
typedef ACE_Concurrency_Strategy < SVC_HANDLER > | inherited |
Protected Attributes | |
size_t | n_processes_ |
Number of processes to spawn. | |
ACE_Event_Handler * | acceptor_ |
ACE_Reactor * | reactor_ |
Defines the interface for specifying a concurrency strategy for a SVC_HANDLER
based on multiprocessing.
This class provides a strategy that manages the creation of processes to handle requests from clients concurrently using a process-per-connection model. It behaves as a "process factory", using ACE::fork()
to fork threads "on-demand" to run the service specified by a user-supplied SVC_HANDLER
in a separate process.
typedef ACE_Concurrency_Strategy<SVC_HANDLER> ACE_Process_Strategy::base_type |
typedef ACE_Concurrency_Strategy<SVC_HANDLER> ACE_Process_Strategy::inherited [protected] |
ACE_Process_Strategy::ACE_Process_Strategy | ( | size_t | n_processes = 1 , |
ACE_Event_Handler * | acceptor = 0 , |
||
ACE_Reactor * | reactor = 0 , |
||
int | avoid_zombies = 0 |
||
) | [inline] |
Initialize the strategy. If avoid_zombies is non-0 then set a flag to ACE::fork() to avoid zombies.
ACE_Process_Strategy::~ACE_Process_Strategy | ( | void | ) | [virtual] |
int ACE_Process_Strategy::activate_svc_handler | ( | SVC_HANDLER * | svc_handler, |
void * | arg = 0 |
||
) | [virtual] |
Activate the svc_handler with an appropriate concurrency strategy. This method activates the SVC_HANDLER by first forking and then calling the open()
method of the SVC_HANDLER in the child.
Reimplemented from ACE_Concurrency_Strategy< SVC_HANDLER >.
void ACE_Process_Strategy::dump | ( | void | ) | const |
Dump the state of an object.
Reimplemented from ACE_Concurrency_Strategy< SVC_HANDLER >.
int ACE_Process_Strategy::open | ( | size_t | n_processes = 1 , |
ACE_Event_Handler * | acceptor = 0 , |
||
ACE_Reactor * | reactor = 0 , |
||
int | avoid_zombies = 0 |
||
) | [virtual] |
Initialize the strategy. If avoid_zombies is non-0 then set a flag to ACE::fork() to avoid zombies.
ACE_Event_Handler* ACE_Process_Strategy::acceptor_ [protected] |
This is the Acceptor
in the parent is listening on. We need to make sure that we remove it from the Reactor and close it down in the child.
Declare the dynamic allocation hooks.
Reimplemented from ACE_Concurrency_Strategy< SVC_HANDLER >.
size_t ACE_Process_Strategy::n_processes_ [protected] |
Number of processes to spawn.
ACE_Reactor* ACE_Process_Strategy::reactor_ [protected] |
This is the reactor the child is using in conjunction with the acceptor. We need to remove the acceptor from this reactor in the child.