这是广泛使用的通信开源项目,对于大容量,高并发的通讯要求完全能够胜任,他广泛可用于网络游戏医学图像网关的高qos要求.更详细的内容可阅读相应的材料

				// server.cpp,v 1.2 2002/12/28 02:03:53 bala Exp
				
				#include "Echo_Caller.h"
				#include "tao/Messaging/Messaging.h"
				#include "tao/Utils/Servant_Var.h"
				#include "tao/ORB_Core.h"
				#include "ace/Get_Opt.h"
				#include "Server_Thread_Pool.h"
				#include "ORB_Task.h"
				
				ACE_RCSID(Bug_1270_Regression, server, "server.cpp,v 1.2 2002/12/28 02:03:53 bala Exp")
				
				const char *ior_output_file = "test.ior";
				
				int
				parse_args (int argc, char *argv[]);
				
				int
				main (int argc, char *argv[])
				{
				  ACE_TRY_NEW_ENV
				    {
				      CORBA::ORB_var orb =
				        CORBA::ORB_init (argc, argv, ""
				                         ACE_ENV_ARG_PARAMETER);
				      ACE_TRY_CHECK;
				
				      CORBA::Object_var poa_object =
				        orb->resolve_initial_references("RootPOA"
				                                        ACE_ENV_ARG_PARAMETER);
				      ACE_TRY_CHECK;
				
				      PortableServer::POA_var root_poa =
				        PortableServer::POA::_narrow (poa_object.in ()
				                                      ACE_ENV_ARG_PARAMETER);
				      ACE_TRY_CHECK;
				
				      if (CORBA::is_nil (root_poa.in ()))
				        ACE_ERROR_RETURN ((LM_ERROR,
				                           " (%P|%t) Panic: nil RootPOA\n"),
				                          1);
				
				      PortableServer::POAManager_var poa_manager =
				        root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER);
				      ACE_TRY_CHECK;
				
				      CORBA::Object_var object =
				        orb->resolve_initial_references ("PolicyCurrent"
				                                         ACE_ENV_ARG_PARAMETER);
				      ACE_TRY_CHECK;
				
				      if (parse_args (argc, argv) != 0)
				        return 1;
				
				      ACE_Thread_Manager mymanager;
				      Thread_Pool callback_pool (&mymanager, 10);
				
				      TAO::Utils::Servant_Var impl;
				      {
				        Echo_Caller * tmp;
				        // ACE_NEW_RETURN is the worst possible way to handle
				        // exceptions (think: what if the constructor allocates memory
				        // and fails?), but I'm not in the mood to fight for a more
				        // reasonable way to handle allocation errors in ACE.
				        ACE_NEW_RETURN (tmp,
				                        Echo_Caller(orb.in(), &callback_pool),
				                        1);
				        impl = tmp;
				      }
				
				      Test::Echo_Caller_var server =
				        impl->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
				      ACE_TRY_CHECK;
				
				      CORBA::String_var ior =
				        orb->object_to_string (server.in ()
				                               ACE_ENV_ARG_PARAMETER);
				      ACE_TRY_CHECK;
				
				      // If the ior_output_file exists, output the ior to it
				      FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
				      if (output_file == 0)
				        ACE_ERROR_RETURN ((LM_ERROR,
				                           "Cannot open output file for writing IOR: %s",
				                           ior_output_file),
				                              1);
				      ACE_OS::fprintf (output_file, "%s", ior.in ());
				      ACE_OS::fclose (output_file);
				
				      poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER);
				      ACE_TRY_CHECK;
				
				      ORB_Task worker (orb.in ());
				      worker.activate (THR_NEW_LWP | THR_JOINABLE,
				                       4);
				
				      orb->run(ACE_ENV_SINGLE_ARG_PARAMETER);
				      ACE_TRY_CHECK;
				
				      ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n"));
				
				      callback_pool.shutdown ();
				      mymanager.wait ();
				      worker.wait ();
				
				      root_poa->destroy (1,
				                         1
				                         ACE_ENV_ARG_PARAMETER);
				      ACE_TRY_CHECK;
				
				      orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
				      ACE_TRY_CHECK;
				    }
				  ACE_CATCHANY
				    {
				      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
				                           "Exception caught:");
				      return 1;
				    }
				  ACE_ENDTRY;
				
				  return 0;
				}
				
				int
				parse_args (int argc, char *argv[])
				{
				  ACE_Get_Opt get_opts (argc, argv, "o:");
				  int c;
				
				  while ((c = get_opts ()) != -1)
				    switch (c)
				      {
				      case 'o':
				        ior_output_file = get_opts.opt_arg ();
				        break;
				
				      case '?':
				      default:
				        ACE_ERROR_RETURN ((LM_ERROR,
				                           "usage:  %s "
				                           "-o  "
				                           "\n",
				                           argv [0]),
				                          -1);
				      }
				  // Indicates sucessful parsing of the command line
				  return 0;
				}