Added a proxy layer to handlers in the proactor framework.

15 files changed, 952 insertions, 760 deletions

diff --git a/ChangeLog b/ChangeLog
index 48046566c35..c73fe567a8a 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,29 @@
+(not committed)  Steve Huston  <shuston@riverace.com>
+
+	* ace/Asynch_IO.{h cpp}:
+	* ace/Asynch_IO_Impl.h:
+	* ace/POSIX_Asynch_IO.{h cpp}:
+	* ace/POSIX_Proactor.{h cpp}:
+	* ace/Proactor.{h cpp}:
+	* ace/Proactor_Impl.h:
+	* ace/WIN32_Asynch_IO.{h cpp}:
+	* ace/WIN32_Proactor.{h cpp}: All methods that accepted an ACE_Handler
+	  below the user-accessed methods were changed to accept an
+	  ACE_Handler::Proxy_Ptr instead. The ACE_Handler class has a new
+	  Proxy_Ptr typedef which is an ACE_Refcounted_Auto_Ptr for
+	  a Proxy class. When an ACE_Handler is created, it allocates a
+	  Proxy to refer to itself. The Proxy carries a pointer to the
+	  ACE_Handler it proxies for in lower levels of the framework.
+	  When the ACE_Handler is destroyed, it clears the ACE_Handler
+	  pointer in the proxy.
+	  Any part of the framework that dispatches completions gets the
+	  ACE_Handler pointer from the proxy and only dispatches if the
+	  pointer is not 0. This allows ACE_Handlers to be deleted while
+	  operations may be outstanding, a previously vexing issue since one
+	  can never be sure how many operations are outstanding at any given
+	  time. The Proxy remains valid until all references to it are
+	  released.
+
 Wed Jan  5 14:34:12 UTC 2005  Johnny Willemsen  <jwillemsen@remedy.nl>
 
         * ace/Dev_Poll_Reactor.cpp:
diff --git a/ace/Asynch_IO.cpp b/ace/Asynch_IO.cpp
index 93d33c6f6ca..7b652ca0525 100644
--- a/ace/Asynch_IO.cpp
+++ b/ace/Asynch_IO.cpp
@@ -96,7 +96,7 @@ ACE_Asynch_Operation::open (ACE_Handler &handler,
                             const void *completion_key,
                             ACE_Proactor *proactor)
 {
-  return this->implementation ()->open (handler,
+  return this->implementation ()->open (handler.proxy (),
                                         handle,
                                         completion_key,
                                         proactor);
@@ -182,7 +182,7 @@ ACE_Asynch_Read_Stream::read (ACE_Message_Block &message_block,
                                       bytes_to_read,
                                       act,
                                       priority,
-                                     signal_number);
+                                      signal_number);
 }
 
 #if (defined (ACE_WIN32) && !defined (ACE_HAS_WINCE) && (ACE_HAS_WINNT4) && (ACE_HAS_WINNT4 != 0))
@@ -985,15 +985,24 @@ ACE_Asynch_Transmit_File::Header_And_Trailer::transmit_buffers (void)
 ACE_Handler::ACE_Handler (void)
   : proactor_ (0), handle_ (ACE_INVALID_HANDLE)
 {
+  ACE_Handler::Proxy *p;
+  ACE_NEW (p, ACE_Handler::Proxy (this));
+  this->proxy_.reset (p);
 }
 
 ACE_Handler::ACE_Handler (ACE_Proactor *d)
   : proactor_ (d), handle_ (ACE_INVALID_HANDLE)
 {
+  ACE_Handler::Proxy *p;
+  ACE_NEW (p, ACE_Handler::Proxy (this));
+  this->proxy_.reset (p);
 }
 
 ACE_Handler::~ACE_Handler (void)
 {
+  ACE_Handler::Proxy *p = this->proxy_.get ();
+  if (p)
+    p->reset ();
 }
 
 void
@@ -1076,6 +1085,12 @@ ACE_Handler::handle (ACE_HANDLE h)
   this->handle_ = h;
 }
 
+ACE_Refcounted_Auto_Ptr<ACE_Handler::Proxy, ACE_SYNCH_MUTEX> &
+ACE_Handler::proxy (void)
+{
+  return this->proxy_;
+}
+
 // ************************************************************
 
 ACE_Service_Handler::ACE_Service_Handler (void)
diff --git a/ace/Asynch_IO.h b/ace/Asynch_IO.h
index 8af31d3e167..4ae52ea7c3c 100644
--- a/ace/Asynch_IO.h
+++ b/ace/Asynch_IO.h
@@ -35,6 +35,14 @@
 
 #if (defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) || (defined (ACE_HAS_AIO_CALLS))
 
+#include "ace/Synch_Traits.h"
+#if defined (ACE_HAS_THREADS)
+#  include "ace/Thread_Mutex.h"
+#else
+#  include "ace/Null_Mutex.h"
+#endif /* ACE_HAS_THREADS */
+#include "ace/Refcounted_Auto_Ptr.h"
+
 #include "ace/os_include/os_signal.h"
 #include "ace/os_include/sys/os_socket.h"
 #include "ace/os_include/sys/os_types.h"
@@ -1550,12 +1558,38 @@ public:
   /// Set the ACE_HANDLE value for this Handler.
   virtual void handle (ACE_HANDLE);
 
+  /**
+   * @class Proxy
+   *
+   * @brief The Proxy class acts as a proxy for dispatch of completions
+   * to operations issued for the associated handler. It allows the handler
+   * to be deleted while operations are outstanding. The proxy must be used
+   * to get the ACE_Handler pointer for dispatching, and if it's 0, the
+   * handler is no longer valid and the result should not be dispatched.
+   */
+  class ACE_Export Proxy
+  {
+  public:
+    Proxy (ACE_Handler *handler) : handler_ (handler) {};
+    void reset (void) { this->handler_ = 0; };
+    ACE_Handler *handler (void) { return this->handler_; };
+  private:
+    ACE_Handler *handler_;
+  };
+  typedef ACE_Refcounted_Auto_Ptr<ACE_Handler::Proxy,ACE_SYNCH_MUTEX>
+    Proxy_Ptr;
+
+  ACE_Handler::Proxy_Ptr &proxy (void);
+
 protected:
   /// The proactor associated with this handler.
   ACE_Proactor *proactor_;
 
   /// The ACE_HANDLE in use with this handler.
   ACE_HANDLE    handle_;
+
+  /// Refers to proxy for this handler.
+  ACE_Refcounted_Auto_Ptr<ACE_Handler::Proxy, ACE_SYNCH_MUTEX> proxy_;
 };
 
 // Forward declarations
diff --git a/ace/Asynch_IO_Impl.h b/ace/Asynch_IO_Impl.h
index c1ad52825b6..5657c2c49dc 100644
--- a/ace/Asynch_IO_Impl.h
+++ b/ace/Asynch_IO_Impl.h
@@ -117,11 +117,11 @@ public:
 
   /**
    * Initializes the factory with information which will be used with
-   * each asynchronous call.  If (<handle> == ACE_INVALID_HANDLE),
-   * <ACE_Handler::handle> will be called on the <handler> to get the
+   * each asynchronous call.  If @a handle == ACE_INVALID_HANDLE,
+   * ACE_Handler::handle() will be called on the proxied handler to get the
    * correct handle.
    */
-  virtual int open (ACE_Handler &handler,
+  virtual int open (ACE_Handler::Proxy_Ptr &handler_proxy,
                     ACE_HANDLE handle,
                     const void *completion_key,
                     ACE_Proactor *proactor) = 0;
diff --git a/ace/POSIX_Asynch_IO.cpp b/ace/POSIX_Asynch_IO.cpp
index 10558ce4fa7..bdf706b0c5b 100644
--- a/ace/POSIX_Asynch_IO.cpp
+++ b/ace/POSIX_Asynch_IO.cpp
@@ -110,16 +110,17 @@ ACE_POSIX_Asynch_Result::~ACE_POSIX_Asynch_Result (void)
 {
 }
 
-ACE_POSIX_Asynch_Result::ACE_POSIX_Asynch_Result (ACE_Handler &handler,
-                                                  const void* act,
-                                                  ACE_HANDLE event,
-                                                  u_long offset,
-                                                  u_long offset_high,
-                                                  int priority,
-                                                  int signal_number)
+ACE_POSIX_Asynch_Result::ACE_POSIX_Asynch_Result
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   const void* act,
+   ACE_HANDLE event,
+   u_long offset,
+   u_long offset_high,
+   int priority,
+   int signal_number)
   : ACE_Asynch_Result_Impl (),
     aiocb (),
-    handler_ (handler),
+    handler_proxy_ (handler_proxy),
     act_ (act),
     bytes_transferred_ (0),
     success_ (0),
@@ -145,18 +146,22 @@ ACE_POSIX_Asynch_Result::ACE_POSIX_Asynch_Result (ACE_Handler &handler,
 // ****************************************************************
 
 int
-ACE_POSIX_Asynch_Operation::open (ACE_Handler &handler,
+ACE_POSIX_Asynch_Operation::open (ACE_Handler::Proxy_Ptr &handler_proxy,
                                   ACE_HANDLE handle,
                                   const void *completion_key,
                                   ACE_Proactor *proactor)
 {
   this->proactor_ = proactor;
-  this->handler_ = &handler;
+  this->handler_proxy_ = handler_proxy;
   this->handle_ = handle;
 
   // Grab the handle from the <handler> if <handle> is invalid
   if (this->handle_ == ACE_INVALID_HANDLE)
-    this->handle_ = this->handler_->handle ();
+    {
+      ACE_Handler *handler = handler_proxy.get ()->handler ();
+      if (handler != 0)
+        this->handle_ = handler->handle ();
+    }
   if (this->handle_ == ACE_INVALID_HANDLE)
     return -1;
 
@@ -208,7 +213,6 @@ ACE_POSIX_Asynch_Operation::~ACE_POSIX_Asynch_Operation (void)
 ACE_POSIX_Asynch_Operation::ACE_POSIX_Asynch_Operation (ACE_POSIX_Proactor *posix_proactor)
   : ACE_Asynch_Operation_Impl (),
     posix_proactor_ (posix_proactor),
-    handler_ (0),
     handle_  (ACE_INVALID_HANDLE)
 {
 }
@@ -233,17 +237,19 @@ ACE_POSIX_Asynch_Read_Stream_Result::handle (void) const
   return this->aio_fildes;
 }
 
-ACE_POSIX_Asynch_Read_Stream_Result::ACE_POSIX_Asynch_Read_Stream_Result (ACE_Handler &handler,
-                                                                          ACE_HANDLE handle,
-                                                                          ACE_Message_Block &message_block,
-                                                                          size_t bytes_to_read,
-                                                                          const void* act,
-                                                                          ACE_HANDLE event,
-                                                                          int priority,
-                                                                          int signal_number)
+ACE_POSIX_Asynch_Read_Stream_Result::ACE_POSIX_Asynch_Read_Stream_Result
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   ACE_HANDLE handle,
+   ACE_Message_Block &message_block,
+   size_t bytes_to_read,
+   const void* act,
+   ACE_HANDLE event,
+   int priority,
+   int signal_number)
   : ACE_Asynch_Result_Impl (),
     ACE_Asynch_Read_Stream_Result_Impl (),
-    ACE_POSIX_Asynch_Result (handler, act, event, 0, 0, priority, signal_number),
+    ACE_POSIX_Asynch_Result
+      (handler_proxy, act, event, 0, 0, priority, signal_number),
     message_block_ (message_block)
 {
   this->aio_fildes = handle;
@@ -273,7 +279,9 @@ ACE_POSIX_Asynch_Read_Stream_Result::complete (size_t bytes_transferred,
   ACE_Asynch_Read_Stream::Result result (this);
 
   // Call the application handler.
-  this->handler_.handle_read_stream (result);
+  ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
+  if (handler != 0)
+    handler->handle_read_stream (result);
 }
 
 ACE_POSIX_Asynch_Read_Stream_Result::~ACE_POSIX_Asynch_Read_Stream_Result (void)
@@ -310,7 +318,7 @@ ACE_POSIX_Asynch_Read_Stream::read (ACE_Message_Block &message_block,
   ACE_POSIX_Asynch_Read_Stream_Result *result = 0;
   ACE_POSIX_Proactor *proactor = this->posix_proactor ();
   ACE_NEW_RETURN (result,
-                  ACE_POSIX_Asynch_Read_Stream_Result (*this->handler_,
+                  ACE_POSIX_Asynch_Read_Stream_Result (this->handler_proxy_,
                                                        this->handle_,
                                                        message_block,
                                                        bytes_to_read,
@@ -352,7 +360,7 @@ ACE_POSIX_Asynch_Write_Stream_Result::handle (void) const
 }
 
 ACE_POSIX_Asynch_Write_Stream_Result::ACE_POSIX_Asynch_Write_Stream_Result
-  (ACE_Handler &handler,
+  (ACE_Handler::Procy_Ptr &handler_proxy,
    ACE_HANDLE handle,
    ACE_Message_Block &message_block,
    size_t bytes_to_write,
@@ -362,7 +370,8 @@ ACE_POSIX_Asynch_Write_Stream_Result::ACE_POSIX_Asynch_Write_Stream_Result
    int signal_number)
   : ACE_Asynch_Result_Impl (),
     ACE_Asynch_Write_Stream_Result_Impl (),
-    ACE_POSIX_Asynch_Result (handler, act, event, 0, 0, priority, signal_number),
+    ACE_POSIX_Asynch_Result
+      (handler_proxy, act, event, 0, 0, priority, signal_number),
     message_block_ (message_block)
 {
   this->aio_fildes = handle;
@@ -393,7 +402,9 @@ ACE_POSIX_Asynch_Write_Stream_Result::complete (size_t bytes_transferred,
   ACE_Asynch_Write_Stream::Result result (this);
 
   // Call the application handler.
-  this->handler_.handle_write_stream (result);
+  ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
+  if (handler != 0)
+    handler->handle_write_stream (result);
 }
 
 ACE_POSIX_Asynch_Write_Stream_Result::~ACE_POSIX_Asynch_Write_Stream_Result (void)
@@ -430,7 +441,7 @@ ACE_POSIX_Asynch_Write_Stream::write (ACE_Message_Block &message_block,
   ACE_POSIX_Asynch_Write_Stream_Result *result = 0;
   ACE_POSIX_Proactor *proactor = this->posix_proactor ();
   ACE_NEW_RETURN (result,
-                  ACE_POSIX_Asynch_Write_Stream_Result (*this->handler_,
+                  ACE_POSIX_Asynch_Write_Stream_Result (this->handler_proxy_,
                                                         this->handle_,
                                                         message_block,
                                                         bytes_to_write,
@@ -454,7 +465,7 @@ ACE_POSIX_Asynch_Write_Stream::~ACE_POSIX_Asynch_Write_Stream (void)
 // *********************************************************************
 
 ACE_POSIX_Asynch_Read_File_Result::ACE_POSIX_Asynch_Read_File_Result
-  (ACE_Handler &handler,
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
    ACE_HANDLE handle,
    ACE_Message_Block &message_block,
    size_t bytes_to_read,
@@ -467,7 +478,7 @@ ACE_POSIX_Asynch_Read_File_Result::ACE_POSIX_Asynch_Read_File_Result
   : ACE_Asynch_Result_Impl (),
     ACE_Asynch_Read_Stream_Result_Impl (),
     ACE_Asynch_Read_File_Result_Impl (),
-    ACE_POSIX_Asynch_Read_Stream_Result (handler,
+    ACE_POSIX_Asynch_Read_Stream_Result (handler_proxy,
                                          handle,
                                          message_block,
                                          bytes_to_read,
@@ -505,7 +516,9 @@ ACE_POSIX_Asynch_Read_File_Result::complete (size_t bytes_transferred,
   ACE_Asynch_Read_File::Result result (this);
 
   // Call the application handler.
-  this->handler_.handle_read_file (result);
+  ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
+  if (handler != 0)
+    handler->handle_read_file (result);
 }
 
 ACE_POSIX_Asynch_Read_File_Result::~ACE_POSIX_Asynch_Read_File_Result (void)
@@ -545,7 +558,7 @@ ACE_POSIX_Asynch_Read_File::read (ACE_Message_Block &message_block,
   ACE_POSIX_Asynch_Read_File_Result *result = 0;
   ACE_POSIX_Proactor *proactor = this->posix_proactor ();
   ACE_NEW_RETURN (result,
-                  ACE_POSIX_Asynch_Read_File_Result (*this->handler_,
+                  ACE_POSIX_Asynch_Read_File_Result (this->handler_proxy_,
                                                      this->handle_,
                                                      message_block,
                                                      bytes_to_read,
@@ -576,16 +589,16 @@ ACE_POSIX_Asynch_Read_File::read (ACE_Message_Block &message_block,
                                   int signal_number)
 {
   return ACE_POSIX_Asynch_Read_Stream::read (message_block,
-                                                   bytes_to_read,
-                                                   act,
-                                                   priority,
-                                                   signal_number);
+                                             bytes_to_read,
+                                             act,
+                                             priority,
+                                             signal_number);
 }
 
 // ************************************************************
 
 ACE_POSIX_Asynch_Write_File_Result::ACE_POSIX_Asynch_Write_File_Result
-  (ACE_Handler &handler,
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
    ACE_HANDLE handle,
    ACE_Message_Block &message_block,
    size_t bytes_to_write,
@@ -598,7 +611,7 @@ ACE_POSIX_Asynch_Write_File_Result::ACE_POSIX_Asynch_Write_File_Result
   : ACE_Asynch_Result_Impl (),
     ACE_Asynch_Write_Stream_Result_Impl (),
     ACE_Asynch_Write_File_Result_Impl (),
-    ACE_POSIX_Asynch_Write_Stream_Result (handler,
+    ACE_POSIX_Asynch_Write_Stream_Result (handler_proxy,
                                           handle,
                                           message_block,
                                           bytes_to_write,
@@ -636,7 +649,9 @@ ACE_POSIX_Asynch_Write_File_Result::complete (size_t bytes_transferred,
   ACE_Asynch_Write_File::Result result (this);
 
   // Call the application handler.
-  this->handler_.handle_write_file (result);
+  ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
+  if (handler != 0)
+    handler->handle_write_file (result);
 }
 
 ACE_POSIX_Asynch_Write_File_Result::~ACE_POSIX_Asynch_Write_File_Result  (void)
@@ -676,7 +691,7 @@ ACE_POSIX_Asynch_Write_File::write (ACE_Message_Block &message_block,
   ACE_POSIX_Asynch_Write_File_Result *result = 0;
   ACE_POSIX_Proactor *proactor = this->posix_proactor ();
   ACE_NEW_RETURN (result,
-                  ACE_POSIX_Asynch_Write_File_Result (*this->handler_,
+                  ACE_POSIX_Asynch_Write_File_Result (this->handler_proxy_,
                                                       this->handle_,
                                                       message_block,
                                                       bytes_to_write,
@@ -741,7 +756,7 @@ ACE_POSIX_Asynch_Accept_Result::accept_handle (void) const
 }
 
 ACE_POSIX_Asynch_Accept_Result::ACE_POSIX_Asynch_Accept_Result
-  (ACE_Handler &handler,
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
    ACE_HANDLE listen_handle,
    ACE_HANDLE accept_handle,
    ACE_Message_Block &message_block,
@@ -753,7 +768,8 @@ ACE_POSIX_Asynch_Accept_Result::ACE_POSIX_Asynch_Accept_Result
 
   : ACE_Asynch_Result_Impl (),
     ACE_Asynch_Accept_Result_Impl (),
-    ACE_POSIX_Asynch_Result (handler, act, event, 0, 0, priority, signal_number),
+    ACE_POSIX_Asynch_Result
+      (handler_proxy, act, event, 0, 0, priority, signal_number),
     message_block_ (message_block),
     listen_handle_ (listen_handle)
 {
@@ -780,7 +796,9 @@ ACE_POSIX_Asynch_Accept_Result::complete (size_t bytes_transferred,
   ACE_Asynch_Accept::Result result (this);
 
   // Call the application handler.
-  this->handler_.handle_accept (result);
+  ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
+  if (handler != 0)
+    handler->handle_accept (result);
 }
 
 ACE_POSIX_Asynch_Accept_Result::~ACE_POSIX_Asynch_Accept_Result (void)
@@ -818,7 +836,7 @@ ACE_POSIX_Asynch_Accept::set_handle (ACE_HANDLE handle)
 }
 
 int
-ACE_POSIX_Asynch_Accept::open (ACE_Handler &handler,
+ACE_POSIX_Asynch_Accept::open (ACE_Handler::Proxy_Ptr &handler_proxy,
                                ACE_HANDLE handle,
                                const void *completion_key,
                                ACE_Proactor *proactor)
@@ -838,7 +856,7 @@ ACE_POSIX_Asynch_Accept::open (ACE_Handler &handler,
                        ACE_LIB_TEXT("acceptor already open \n")),
                       -1);
 
-  result = ACE_POSIX_Asynch_Operation::open (handler,
+  result = ACE_POSIX_Asynch_Operation::open (handler_proxy,
                                              handle,
                                              completion_key,
                                              proactor);
@@ -909,7 +927,7 @@ ACE_POSIX_Asynch_Accept::accept (ACE_Message_Block &message_block,
     // Create future Asynch_Accept_Result
     ACE_POSIX_Asynch_Accept_Result *result = 0;
     ACE_NEW_RETURN (result,
-                    ACE_POSIX_Asynch_Accept_Result (*this->handler_,
+                    ACE_POSIX_Asynch_Accept_Result (this->handler_proxy_,
                                                     this->handle_,
                                                     accept_handle,
                                                     message_block,
@@ -1233,7 +1251,7 @@ void ACE_POSIX_Asynch_Connect_Result::connect_handle (ACE_HANDLE handle)
 
 
 ACE_POSIX_Asynch_Connect_Result::ACE_POSIX_Asynch_Connect_Result
-  (ACE_Handler &handler,
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
    ACE_HANDLE connect_handle,
    const void* act,
    ACE_HANDLE event,
@@ -1242,7 +1260,8 @@ ACE_POSIX_Asynch_Connect_Result::ACE_POSIX_Asynch_Connect_Result
 
   : ACE_Asynch_Result_Impl (),
     ACE_Asynch_Connect_Result_Impl (),
-    ACE_POSIX_Asynch_Result (handler, act, event, 0, 0, priority, signal_number)
+    ACE_POSIX_Asynch_Result
+      (handler_proxy, act, event, 0, 0, priority, signal_number)
 {
   this->aio_fildes = connect_handle;
   this->aio_nbytes = 0;
@@ -1264,7 +1283,9 @@ ACE_POSIX_Asynch_Connect_Result::complete (size_t bytes_transferred,
   ACE_Asynch_Connect::Result result (this);
 
   // Call the application handler.
-  this->handler_.handle_connect (result);
+  ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
+  if (handler != 0)
+    handler->handle_connect (result);
 }
 
 ACE_POSIX_Asynch_Connect_Result::~ACE_POSIX_Asynch_Connect_Result (void)
@@ -1303,7 +1324,7 @@ ACE_POSIX_Asynch_Connect::set_handle (ACE_HANDLE)
 }
 
 int
-ACE_POSIX_Asynch_Connect::open (ACE_Handler &handler,
+ACE_POSIX_Asynch_Connect::open (ACE_Handler::Proxy_Ptr &handler_proxy,
                                 ACE_HANDLE handle,
                                 const void *completion_key,
                                 ACE_Proactor *proactor)
@@ -1322,7 +1343,7 @@ ACE_POSIX_Asynch_Connect::open (ACE_Handler &handler,
                       -1);
 
   //int result =
-  ACE_POSIX_Asynch_Operation::open (handler,
+  ACE_POSIX_Asynch_Operation::open (handler_proxy,
                                     handle,
                                     completion_key,
                                     proactor);
@@ -1360,13 +1381,13 @@ ACE_POSIX_Asynch_Connect::connect (ACE_HANDLE connect_handle,
     // Create future Asynch_Connect_Result
     ACE_POSIX_Asynch_Connect_Result *result = 0;
     ACE_NEW_RETURN (result,
-                    ACE_POSIX_Asynch_Connect_Result (*this->handler_,
-                                                    connect_handle,
-                                                    act,
-                                                    this->posix_proactor ()->get_handle (),
-                                                    priority,
-                                                    signal_number),
-                  -1);
+                    ACE_POSIX_Asynch_Connect_Result (this->handler_proxy_,
+                                                     connect_handle,
+                                                     act,
+                                                     this->posix_proactor ()->get_handle (),
+                                                     priority,
+                                                     signal_number),
+                    -1);
 
     int rc = connect_i (result,
                         remote_sap,
@@ -1826,7 +1847,7 @@ ACE_POSIX_Asynch_Transmit_File_Result::flags (void) const
 }
 
 ACE_POSIX_Asynch_Transmit_File_Result::ACE_POSIX_Asynch_Transmit_File_Result
-  (ACE_Handler &handler,
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
    ACE_HANDLE socket,
    ACE_HANDLE file,
    ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer,
@@ -1842,7 +1863,8 @@ ACE_POSIX_Asynch_Transmit_File_Result::ACE_POSIX_Asynch_Transmit_File_Result
 
   : ACE_Asynch_Result_Impl (),
     ACE_Asynch_Transmit_File_Result_Impl (),
-    ACE_POSIX_Asynch_Result (handler, act, event, offset, offset_high, priority, signal_number),
+    ACE_POSIX_Asynch_Result
+     (handler_proxy, act, event, offset, offset_high, priority, signal_number),
     socket_ (socket),
     header_and_trailer_ (header_and_trailer),
     bytes_per_send_ (bytes_per_send),
@@ -1884,7 +1906,9 @@ ACE_POSIX_Asynch_Transmit_File_Result::complete (size_t bytes_transferred,
   ACE_Asynch_Transmit_File::Result result (this);
 
   // Call the application handler.
-  this->handler_.handle_transmit_file (result);
+  ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
+  if (handler != 0)
+    handler->handle_transmit_file (result);
 }
 
 ACE_POSIX_Asynch_Transmit_File_Result::~ACE_POSIX_Asynch_Transmit_File_Result (void)
@@ -2272,7 +2296,7 @@ ACE_POSIX_Asynch_Transmit_File::transmit_file (ACE_HANDLE file,
   ACE_POSIX_Asynch_Transmit_File_Result *result = 0;
 
   ACE_NEW_RETURN (result,
-                  ACE_POSIX_Asynch_Transmit_File_Result (*this->handler_,
+                  ACE_POSIX_Asynch_Transmit_File_Result (this->handler_proxy_,
                                                          this->handle_,
                                                          file,
                                                          header_and_trailer,
@@ -2357,7 +2381,7 @@ ACE_POSIX_Asynch_Read_Dgram_Result::message_block () const
 }
 
 ACE_POSIX_Asynch_Read_Dgram_Result::ACE_POSIX_Asynch_Read_Dgram_Result
-  (ACE_Handler &handler,
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
    ACE_HANDLE handle,
    ACE_Message_Block *message_block,
    size_t bytes_to_read,
@@ -2370,7 +2394,8 @@ ACE_POSIX_Asynch_Read_Dgram_Result::ACE_POSIX_Asynch_Read_Dgram_Result
 
   : ACE_Asynch_Result_Impl (),
     ACE_Asynch_Read_Dgram_Result_Impl(),
-    ACE_POSIX_Asynch_Result (handler, act, event, 0, 0, priority, signal_number),
+    ACE_POSIX_Asynch_Result
+      (handler_proxy, act, event, 0, 0, priority, signal_number),
     bytes_to_read_ (bytes_to_read),
     message_block_ (message_block),
     remote_address_ (0),
@@ -2405,7 +2430,9 @@ ACE_POSIX_Asynch_Read_Dgram_Result::complete (size_t bytes_transferred,
   ACE_Asynch_Read_Dgram::Result result (this);
 
   // Call the application handler.
-  this->handler_.handle_read_dgram (result);
+  ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
+  if (handler != 0)
+    handler->handle_read_dgram (result);
 }
 
 ACE_POSIX_Asynch_Read_Dgram_Result::~ACE_POSIX_Asynch_Read_Dgram_Result (void)
@@ -2440,7 +2467,7 @@ ACE_POSIX_Asynch_Write_Dgram_Result::message_block () const
 }
 
 ACE_POSIX_Asynch_Write_Dgram_Result::ACE_POSIX_Asynch_Write_Dgram_Result
-  (ACE_Handler &handler,
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
    ACE_HANDLE handle,
    ACE_Message_Block *message_block,
    size_t bytes_to_write,
@@ -2452,7 +2479,8 @@ ACE_POSIX_Asynch_Write_Dgram_Result::ACE_POSIX_Asynch_Write_Dgram_Result
 
   : ACE_Asynch_Result_Impl (),
     ACE_Asynch_Write_Dgram_Result_Impl(),
-    ACE_POSIX_Asynch_Result (handler, act, event, 0, 0, priority, signal_number),
+    ACE_POSIX_Asynch_Result
+     (handler_proxy, act, event, 0, 0, priority, signal_number),
     bytes_to_write_ (bytes_to_write),
     message_block_ (message_block),
     flags_ (flags),
@@ -2485,7 +2513,9 @@ ACE_POSIX_Asynch_Write_Dgram_Result::complete (size_t bytes_transferred,
   ACE_Asynch_Write_Dgram::Result result (this);
 
   // Call the application handler.
-  this->handler_.handle_write_dgram (result);
+  ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
+  if (handler != 0)
+    handler->handle_write_dgram (result);
 }
 
 ACE_POSIX_Asynch_Write_Dgram_Result::~ACE_POSIX_Asynch_Write_Dgram_Result (void)
@@ -2511,7 +2541,7 @@ ACE_POSIX_Asynch_Read_Dgram::recv (ACE_Message_Block *message_block,
   ACE_POSIX_Asynch_Read_Dgram_Result *result = 0;
   ACE_POSIX_Proactor *proactor = this->posix_proactor ();
   ACE_NEW_RETURN (result,
-                  ACE_POSIX_Asynch_Read_Dgram_Result (*this->handler_,
+                  ACE_POSIX_Asynch_Read_Dgram_Result (this->handler_proxy_,
                                                       this->handle_,
                                                       message_block,
                                                       space,
@@ -2563,7 +2593,7 @@ ACE_POSIX_Asynch_Write_Dgram::send (ACE_Message_Block *message_block,
   ACE_POSIX_Asynch_Write_Dgram_Result *result = 0;
   ACE_POSIX_Proactor *proactor = this->posix_proactor ();
   ACE_NEW_RETURN (result,
-                  ACE_POSIX_Asynch_Write_Dgram_Result (*this->handler_,
+                  ACE_POSIX_Asynch_Write_Dgram_Result (this->handler_proxy_,
                                                        this->handle_,
                                                        message_block,
                                                        len,
diff --git a/ace/POSIX_Asynch_IO.h b/ace/POSIX_Asynch_IO.h
index dae1bb2b359..2a40c48c688 100644
--- a/ace/POSIX_Asynch_IO.h
+++ b/ace/POSIX_Asynch_IO.h
@@ -114,7 +114,7 @@ public:
 
 protected:
   /// Constructor. <Event> is not used on POSIX.
-  ACE_POSIX_Asynch_Result (ACE_Handler &handler,
+  ACE_POSIX_Asynch_Result (ACE_Handler::Proxy_Ptr &handler_proxy,
                            const void* act,
                            ACE_HANDLE event,
                            u_long offset,
@@ -123,7 +123,7 @@ protected:
                            int signal_number);
 
   /// Handler that will be called back.
-  ACE_Handler &handler_;
+  ACE_Handler::Proxy_Ptr &handler_proxy_;
 
   /**
    * ACT for this operation.
@@ -166,7 +166,7 @@ public:
    * Operation class itself was created by the correct implementation
    * Proactor class.
    */
-  int open (ACE_Handler &handler,
+  int open (ACE_Handler::Proxy_Ptr &handler_proxy,
             ACE_HANDLE handle,
             const void *completion_key,
             ACE_Proactor *proactor = 0);
@@ -209,7 +209,7 @@ protected:
   ACE_Proactor *proactor_;
 
   /// Handler that will receive the callback.
-  ACE_Handler *handler_;
+  ACE_Handler::Proxy_Ptr *handler_proxy_;
 
   /// I/O handle used for reading.
   ACE_HANDLE handle_;
@@ -243,7 +243,7 @@ public:
   ACE_HANDLE handle (void) const;
 
 protected:
-  ACE_POSIX_Asynch_Read_Stream_Result (ACE_Handler &handler,
+  ACE_POSIX_Asynch_Read_Stream_Result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                        ACE_HANDLE handle,
                                        ACE_Message_Block &message_block,
                                        size_t bytes_to_read,
@@ -335,7 +335,7 @@ public:
 protected:
   /// Constructor is protected since creation is limited to
   /// ACE_Asynch_Write_Stream factory.
-  ACE_POSIX_Asynch_Write_Stream_Result (ACE_Handler &handler,
+  ACE_POSIX_Asynch_Write_Stream_Result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                         ACE_HANDLE handle,
                                         ACE_Message_Block &message_block,
                                         size_t bytes_to_write,
@@ -410,7 +410,7 @@ public:
 protected:
   /// Constructor is protected since creation is limited to
   /// ACE_Asynch_Read_File factory.
-  ACE_POSIX_Asynch_Read_File_Result (ACE_Handler &handler,
+  ACE_POSIX_Asynch_Read_File_Result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                      ACE_HANDLE handle,
                                      ACE_Message_Block &message_block,
                                      size_t bytes_to_read,
@@ -514,7 +514,7 @@ class ACE_Export ACE_POSIX_Asynch_Write_File_Result : public virtual ACE_Asynch_
 protected:
   /// Constructor is protected since creation is limited to
   /// ACE_Asynch_Write_File factory.
-  ACE_POSIX_Asynch_Write_File_Result (ACE_Handler &handler,
+  ACE_POSIX_Asynch_Write_File_Result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                       ACE_HANDLE handle,
                                       ACE_Message_Block &message_block,
                                       size_t bytes_to_write,
@@ -618,7 +618,7 @@ public:
 protected:
   /// Constructor is protected since creation is limited to
   /// ACE_Asynch_Accept factory.
-  ACE_POSIX_Asynch_Accept_Result (ACE_Handler &handler,
+  ACE_POSIX_Asynch_Accept_Result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                   ACE_HANDLE listen_handle,
                                   ACE_HANDLE accept_handle,
                                   ACE_Message_Block &message_block,
@@ -676,7 +676,7 @@ public:
    * this call to that method. We have put this here to avoid the
    * compiler warnings.
    */
-  int open (ACE_Handler &handler,
+  int open (ACE_Handler::Proxy_Ptr &handler_proxy,
             ACE_HANDLE handle,
             const void *completion_key,
             ACE_Proactor *proactor = 0);
@@ -784,7 +784,7 @@ public:
 protected:
   /// Constructor is protected since creation is limited to
   /// ACE_Asynch_Connect factory.
-  ACE_POSIX_Asynch_Connect_Result (ACE_Handler &handler,
+  ACE_POSIX_Asynch_Connect_Result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                    ACE_HANDLE  connect_handle,
                                    const void* act,
                                    ACE_HANDLE  event,
@@ -828,7 +828,7 @@ public:
    * this call to that method. We have put this here to avoid the
    * compiler warnings.
    */
-  int open (ACE_Handler &handler,
+  int open (ACE_Handler::Proxy_Ptr &handler_proxy,
             ACE_HANDLE handle,
             const void *completion_key,
             ACE_Proactor *proactor = 0);
@@ -969,7 +969,7 @@ public:
   u_long flags (void) const;
 
 protected:
-  ACE_POSIX_Asynch_Transmit_File_Result (ACE_Handler &handler,
+  ACE_POSIX_Asynch_Transmit_File_Result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                          ACE_HANDLE socket,
                                          ACE_HANDLE file,
                                          ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer,
@@ -1142,7 +1142,7 @@ public:
 protected:
   /// Constructor is protected since creation is limited to
   /// ACE_Asynch_Write_Stream factory.
-  ACE_POSIX_Asynch_Write_Dgram_Result (ACE_Handler &handler,
+  ACE_POSIX_Asynch_Write_Dgram_Result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                        ACE_HANDLE handle,
                                        ACE_Message_Block *message_block,
                                        size_t bytes_to_write,
@@ -1275,7 +1275,7 @@ public:
 protected:
   /// Constructor is protected since creation is limited to
   /// ACE_Asynch_Read_Dgram factory.
-  ACE_POSIX_Asynch_Read_Dgram_Result (ACE_Handler &handler,
+  ACE_POSIX_Asynch_Read_Dgram_Result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                       ACE_HANDLE handle,
                                       ACE_Message_Block *message_block,
                                       size_t bytes_to_read,
diff --git a/ace/POSIX_Proactor.cpp b/ace/POSIX_Proactor.cpp
index 08f23facffc..fe0ab467e9e 100644
--- a/ace/POSIX_Proactor.cpp
+++ b/ace/POSIX_Proactor.cpp
@@ -38,7 +38,7 @@ class ACE_Export ACE_POSIX_Wakeup_Completion : public ACE_POSIX_Asynch_Result
 {
 public:
   /// Constructor.
-  ACE_POSIX_Wakeup_Completion (ACE_Handler &handler,
+  ACE_POSIX_Wakeup_Completion (ACE_Handler::Proxy_Ptr &handler_proxy,
                                const void *act = 0,
                                ACE_HANDLE event = ACE_INVALID_HANDLE,
                                int priority = 0,
@@ -158,18 +158,19 @@ ACE_POSIX_Proactor::create_asynch_read_stream (void)
 }
 
 ACE_Asynch_Read_Stream_Result_Impl *
-ACE_POSIX_Proactor::create_asynch_read_stream_result (ACE_Handler &handler,
-                                                      ACE_HANDLE handle,
-                                                      ACE_Message_Block &message_block,
-                                                      size_t bytes_to_read,
-                                                      const void* act,
-                                                      ACE_HANDLE event,
-                                                      int priority,
-                                                      int signal_number)
+ACE_POSIX_Proactor::create_asynch_read_stream_result
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   ACE_HANDLE handle,
+   ACE_Message_Block &message_block,
+   size_t bytes_to_read,
+   const void* act,
+   ACE_HANDLE event,
+   int priority,
+   int signal_number)
 {
   ACE_Asynch_Read_Stream_Result_Impl *implementation;
   ACE_NEW_RETURN (implementation,
-                  ACE_POSIX_Asynch_Read_Stream_Result (handler,
+                  ACE_POSIX_Asynch_Read_Stream_Result (handler_proxy,
                                                        handle,
                                                        message_block,
                                                        bytes_to_read,
@@ -193,18 +194,19 @@ ACE_POSIX_Proactor::create_asynch_write_stream (void)
 }
 
 ACE_Asynch_Write_Stream_Result_Impl *
-ACE_POSIX_Proactor::create_asynch_write_stream_result (ACE_Handler &handler,
-                                                       ACE_HANDLE handle,
-                                                       ACE_Message_Block &message_block,
-                                                       size_t bytes_to_write,
-                                                       const void* act,
-                                                       ACE_HANDLE event,
-                                                       int priority,
-                                                       int signal_number)
+ACE_POSIX_Proactor::create_asynch_write_stream_result
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   ACE_HANDLE handle,
+   ACE_Message_Block &message_block,
+   size_t bytes_to_write,
+   const void* act,
+   ACE_HANDLE event,
+   int priority,
+   int signal_number)
 {
   ACE_Asynch_Write_Stream_Result_Impl *implementation;
   ACE_NEW_RETURN (implementation,
-                  ACE_POSIX_Asynch_Write_Stream_Result (handler,
+                  ACE_POSIX_Asynch_Write_Stream_Result (handler_proxy,
                                                         handle,
                                                         message_block,
                                                         bytes_to_write,
@@ -228,20 +230,21 @@ ACE_POSIX_Proactor::create_asynch_read_file (void)
 }
 
 ACE_Asynch_Read_File_Result_Impl *
-ACE_POSIX_Proactor::create_asynch_read_file_result (ACE_Handler &handler,
-                                                    ACE_HANDLE handle,
-                                                    ACE_Message_Block &message_block,
-                                                    size_t bytes_to_read,
-                                                    const void* act,
-                                                    u_long offset,
-                                                    u_long offset_high,
-                                                    ACE_HANDLE event,
-                                                    int priority,
-                                                    int signal_number)
+ACE_POSIX_Proactor::create_asynch_read_file_result
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   ACE_HANDLE handle,
+   ACE_Message_Block &message_block,
+   size_t bytes_to_read,
+   const void* act,
+   u_long offset,
+   u_long offset_high,
+   ACE_HANDLE event,
+   int priority,
+   int signal_number)
 {
   ACE_Asynch_Read_File_Result_Impl *implementation;
   ACE_NEW_RETURN (implementation,
-                  ACE_POSIX_Asynch_Read_File_Result (handler,
+                  ACE_POSIX_Asynch_Read_File_Result (handler_proxy,
                                                      handle,
                                                      message_block,
                                                      bytes_to_read,
@@ -267,20 +270,21 @@ ACE_POSIX_Proactor::create_asynch_write_file (void)
 }
 
 ACE_Asynch_Write_File_Result_Impl *
-ACE_POSIX_Proactor::create_asynch_write_file_result (ACE_Handler &handler,
-                                                     ACE_HANDLE handle,
-                                                     ACE_Message_Block &message_block,
-                                                     size_t bytes_to_write,
-                                                     const void* act,
-                                                     u_long offset,
-                                                     u_long offset_high,
-                                                     ACE_HANDLE event,
-                                                     int priority,
-                                                     int signal_number)
+ACE_POSIX_Proactor::create_asynch_write_file_result
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   ACE_HANDLE handle,
+   ACE_Message_Block &message_block,
+   size_t bytes_to_write,
+   const void* act,
+   u_long offset,
+   u_long offset_high,
+   ACE_HANDLE event,
+   int priority,
+   int signal_number)
 {
   ACE_Asynch_Write_File_Result_Impl *implementation;
   ACE_NEW_RETURN (implementation,
-                  ACE_POSIX_Asynch_Write_File_Result (handler,
+                  ACE_POSIX_Asynch_Write_File_Result (handler_proxy,
                                                       handle,
                                                       message_block,
                                                       bytes_to_write,
@@ -306,20 +310,21 @@ ACE_POSIX_Proactor::create_asynch_read_dgram (void)
 }
 
 ACE_Asynch_Read_Dgram_Result_Impl *
-ACE_POSIX_Proactor::create_asynch_read_dgram_result (ACE_Handler &handler,
-                                                     ACE_HANDLE handle,
-                                                     ACE_Message_Block *message_block,
-                                                     size_t bytes_to_read,
-                                                     int flags,
-                                                     int protocol_family,
-                                                     const void* act,
-                                                     ACE_HANDLE event ,
-                                                     int priority ,
-                                                     int signal_number)
+ACE_POSIX_Proactor::create_asynch_read_dgram_result
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   ACE_HANDLE handle,
+   ACE_Message_Block *message_block,
+   size_t bytes_to_read,
+   int flags,
+   int protocol_family,
+   const void* act,
+   ACE_HANDLE event ,
+   int priority ,
+   int signal_number)
 {
   ACE_Asynch_Read_Dgram_Result_Impl *implementation=0;
   ACE_NEW_RETURN (implementation,
-                  ACE_POSIX_Asynch_Read_Dgram_Result(handler,
+                  ACE_POSIX_Asynch_Read_Dgram_Result(handler_proxy,
                                                      handle,
                                                      message_block,
                                                      bytes_to_read,
@@ -347,19 +352,20 @@ ACE_POSIX_Proactor::create_asynch_write_dgram (void)
 }
 
 ACE_Asynch_Write_Dgram_Result_Impl *
-ACE_POSIX_Proactor::create_asynch_write_dgram_result (ACE_Handler &handler,
-                                                      ACE_HANDLE handle,
-                                                      ACE_Message_Block *message_block,
-                                                      size_t bytes_to_write,
-                                                      int flags,
-                                                      const void* act,
-                                                      ACE_HANDLE event,
-                                                      int priority ,
-                                                      int signal_number)
+ACE_POSIX_Proactor::create_asynch_write_dgram_result
+  (ACE_Handler::Proxy_ptr &handler_proxy,
+   ACE_HANDLE handle,
+   ACE_Message_Block *message_block,
+   size_t bytes_to_write,
+   int flags,
+   const void* act,
+   ACE_HANDLE event,
+   int priority ,
+   int signal_number)
 {
   ACE_Asynch_Write_Dgram_Result_Impl *implementation=0;
   ACE_NEW_RETURN (implementation,
-                  ACE_POSIX_Asynch_Write_Dgram_Result(handler,
+                  ACE_POSIX_Asynch_Write_Dgram_Result(handler_proxy,
                                                       handle,
                                                       message_block,
                                                       bytes_to_write,
@@ -386,19 +392,20 @@ ACE_POSIX_Proactor::create_asynch_accept (void)
 }
 
 ACE_Asynch_Accept_Result_Impl *
-ACE_POSIX_Proactor::create_asynch_accept_result (ACE_Handler &handler,
-                                                 ACE_HANDLE listen_handle,
-                                                 ACE_HANDLE accept_handle,
-                                                 ACE_Message_Block &message_block,
-                                                 size_t bytes_to_read,
-                                                 const void* act,
-                                                 ACE_HANDLE event,
-                                                 int priority,
-                                                 int signal_number)
+ACE_POSIX_Proactor::create_asynch_accept_result
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   ACE_HANDLE listen_handle,
+   ACE_HANDLE accept_handle,
+   ACE_Message_Block &message_block,
+   size_t bytes_to_read,
+   const void* act,
+   ACE_HANDLE event,
+   int priority,
+   int signal_number)
 {
   ACE_Asynch_Accept_Result_Impl *implementation;
   ACE_NEW_RETURN (implementation,
-                  ACE_POSIX_Asynch_Accept_Result (handler,
+                  ACE_POSIX_Asynch_Accept_Result (handler_proxy,
                                                   listen_handle,
                                                   accept_handle,
                                                   message_block,
@@ -424,16 +431,17 @@ ACE_POSIX_Proactor::create_asynch_connect (void)
 }
 
 ACE_Asynch_Connect_Result_Impl *
-ACE_POSIX_Proactor::create_asynch_connect_result (ACE_Handler &handler,
-                                                  ACE_HANDLE  connect_handle,
-                                                  const void* act,
-                                                  ACE_HANDLE event,
-                                                  int priority,
-                                                  int signal_number)
+ACE_POSIX_Proactor::create_asynch_connect_result
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   ACE_HANDLE connect_handle,
+   const void* act,
+   ACE_HANDLE event,
+   int priority,
+   int signal_number)
 {
   ACE_Asynch_Connect_Result_Impl *implementation;
   ACE_NEW_RETURN (implementation,
-                  ACE_POSIX_Asynch_Connect_Result (handler,
+                  ACE_POSIX_Asynch_Connect_Result (handler_proxy,
                                                    connect_handle,
                                                    act,
                                                    event,
@@ -455,23 +463,24 @@ ACE_POSIX_Proactor::create_asynch_transmit_file (void)
 }
 
 ACE_Asynch_Transmit_File_Result_Impl *
-ACE_POSIX_Proactor::create_asynch_transmit_file_result (ACE_Handler &handler,
-                                                        ACE_HANDLE socket,
-                                                        ACE_HANDLE file,
-                                                        ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer,
-                                                        size_t bytes_to_write,
-                                                        u_long offset,
-                                                        u_long offset_high,
-                                                        size_t bytes_per_send,
-                                                        u_long flags,
-                                                        const void *act,
-                                                        ACE_HANDLE event,
-                                                        int priority,
-                                                        int signal_number)
+ACE_POSIX_Proactor::create_asynch_transmit_file_result
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   ACE_HANDLE socket,
+   ACE_HANDLE file,
+   ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer,
+   size_t bytes_to_write,
+   u_long offset,
+   u_long offset_high,
+   size_t bytes_per_send,
+   u_long flags,
+   const void *act,
+   ACE_HANDLE event,
+   int priority,
+   int signal_number)
 {
   ACE_Asynch_Transmit_File_Result_Impl *implementation;
   ACE_NEW_RETURN (implementation,
-                  ACE_POSIX_Asynch_Transmit_File_Result (handler,
+                  ACE_POSIX_Asynch_Transmit_File_Result (handler_proxy,
                                                          socket,
                                                          file,
                                                          header_and_trailer,
@@ -489,16 +498,17 @@ ACE_POSIX_Proactor::create_asynch_transmit_file_result (ACE_Handler &handler,
 }
 
 ACE_Asynch_Result_Impl *
-ACE_POSIX_Proactor::create_asynch_timer (ACE_Handler &handler,
-                                         const void *act,
-                                         const ACE_Time_Value &tv,
-                                         ACE_HANDLE event,
-                                         int priority,
-                                         int signal_number)
+ACE_POSIX_Proactor::create_asynch_timer
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   const void *act,
+   const ACE_Time_Value &tv,
+   ACE_HANDLE event,
+   int priority,
+   int signal_number)
 {
   ACE_Asynch_Result_Impl *implementation;
   ACE_NEW_RETURN (implementation,
-                  ACE_POSIX_Asynch_Timer (handler,
+                  ACE_POSIX_Asynch_Timer (handler_proxy,
                                           act,
                                           tv,
                                           event,
@@ -569,9 +579,10 @@ ACE_POSIX_Proactor::post_wakeup_completions (int how_many)
 
   for (int ci = 0; ci < how_many; ci++)
     {
-      ACE_NEW_RETURN (wakeup_completion,
-                      ACE_POSIX_Wakeup_Completion (this->wakeup_handler_),
-                      -1);
+      ACE_NEW_RETURN
+        (wakeup_completion,
+         ACE_POSIX_Wakeup_Completion (this->wakeup_handler_.proxy ()),
+         -1);
       if (this->post_completion (wakeup_completion) == -1)
         return -1;
     }
@@ -1715,12 +1726,13 @@ ACE_POSIX_SIG_Proactor::notify_completion (int sig_num)
 }
 
 ACE_Asynch_Result_Impl *
-ACE_POSIX_SIG_Proactor::create_asynch_timer (ACE_Handler &handler,
-                                             const void *act,
-                                             const ACE_Time_Value &tv,
-                                             ACE_HANDLE event,
-                                             int priority,
-                                             int signal_number)
+ACE_POSIX_SIG_Proactor::create_asynch_timer
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   const void *act,
+   const ACE_Time_Value &tv,
+   ACE_HANDLE event,
+   int priority,
+   int signal_number)
 {
   int is_member = 0;
 
@@ -1755,7 +1767,7 @@ ACE_POSIX_SIG_Proactor::create_asynch_timer (ACE_Handler &handler,
 
   ACE_Asynch_Result_Impl *implementation;
   ACE_NEW_RETURN (implementation,
-                  ACE_POSIX_Asynch_Timer (handler,
+                  ACE_POSIX_Asynch_Timer (handler_proxy,
                                           act,
                                           tv,
                                           event,
@@ -1962,14 +1974,16 @@ ACE_POSIX_SIG_Proactor::handle_events_i (const ACE_Time_Value *timeout)
 
 // *********************************************************************
 
-ACE_POSIX_Asynch_Timer::ACE_POSIX_Asynch_Timer (ACE_Handler &handler,
-                                                const void *act,
-                                                const ACE_Time_Value &tv,
-                                                ACE_HANDLE event,
-                                                int priority,
-                                                int signal_number)
+ACE_POSIX_Asynch_Timer::ACE_POSIX_Asynch_Timer
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   const void *act,
+   const ACE_Time_Value &tv,
+   ACE_HANDLE event,
+   int priority,
+   int signal_number)
   : ACE_Asynch_Result_Impl (),
-    ACE_POSIX_Asynch_Result (handler, act, event, 0, 0, priority, signal_number),
+    ACE_POSIX_Asynch_Result
+     (handler_proxy, act, event, 0, 0, priority, signal_number),
     time_ (tv)
 {
 }
@@ -1980,19 +1994,28 @@ ACE_POSIX_Asynch_Timer::complete (size_t       /* bytes_transferred */,
                                   const void * /* completion_key */,
                                   u_long       /* error */)
 {
-  this->handler_.handle_time_out (this->time_, this->act ());
+  ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
+  if (handler != 0)
+    handler->handle_time_out (this->time_, this->act ());
 }
 
 
 // *********************************************************************
 
-ACE_POSIX_Wakeup_Completion::ACE_POSIX_Wakeup_Completion (ACE_Handler &handler,
-                                                          const void *act,
-                                                          ACE_HANDLE event,
-                                                          int priority,
-                                                          int signal_number)
+ACE_POSIX_Wakeup_Completion::ACE_POSIX_Wakeup_Completion
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   const void *act,
+   ACE_HANDLE event,
+   int priority,
+   int signal_number)
   : ACE_Asynch_Result_Impl (),
-    ACE_POSIX_Asynch_Result (handler, act, event, 0, 0, priority, signal_number)
+    ACE_POSIX_Asynch_Result (handler_proxy,
+                             act,
+                             event,
+                             0,
+                             0,
+                             priority,
+                             signal_number)
 {
 }
 
@@ -2007,7 +2030,9 @@ ACE_POSIX_Wakeup_Completion::complete (size_t       /* bytes_transferred */,
                                        u_long       /*  error */)
 {
 
-  this->handler_.handle_wakeup ();
+  ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
+  if (handler != 0)
+    handler->handle_wakeup ();
 }
 
 
diff --git a/ace/POSIX_Proactor.h b/ace/POSIX_Proactor.h
index e8e0897e3d4..37cdbba197b 100644
--- a/ace/POSIX_Proactor.h
+++ b/ace/POSIX_Proactor.h
@@ -160,7 +160,7 @@ public:
 
   virtual ACE_Asynch_Read_Stream_Impl *create_asynch_read_stream (void);
   virtual ACE_Asynch_Read_Stream_Result_Impl *
-    create_asynch_read_stream_result (ACE_Handler &handler,
+    create_asynch_read_stream_result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                       ACE_HANDLE handle,
                                       ACE_Message_Block &message_block,
                                       size_t bytes_to_read,
@@ -171,7 +171,7 @@ public:
 
   virtual ACE_Asynch_Write_Stream_Impl *create_asynch_write_stream (void);
   virtual ACE_Asynch_Write_Stream_Result_Impl *
-    create_asynch_write_stream_result (ACE_Handler &handler,
+    create_asynch_write_stream_result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                        ACE_HANDLE handle,
                                        ACE_Message_Block &message_block,
                                        size_t bytes_to_write,
@@ -182,7 +182,7 @@ public:
 
   virtual ACE_Asynch_Read_File_Impl *create_asynch_read_file (void);
   virtual ACE_Asynch_Read_File_Result_Impl *
-    create_asynch_read_file_result (ACE_Handler &handler,
+    create_asynch_read_file_result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                     ACE_HANDLE handle,
                                     ACE_Message_Block &message_block,
                                     size_t bytes_to_read,
@@ -195,7 +195,7 @@ public:
 
   virtual ACE_Asynch_Write_File_Impl *create_asynch_write_file (void);
   virtual ACE_Asynch_Write_File_Result_Impl *
-    create_asynch_write_file_result (ACE_Handler &handler,
+    create_asynch_write_file_result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                      ACE_HANDLE handle,
                                      ACE_Message_Block &message_block,
                                      size_t bytes_to_write,
@@ -208,7 +208,7 @@ public:
 
   virtual ACE_Asynch_Read_Dgram_Impl *create_asynch_read_dgram (void);
   virtual ACE_Asynch_Read_Dgram_Result_Impl *
-    create_asynch_read_dgram_result (ACE_Handler &handler,
+    create_asynch_read_dgram_result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                      ACE_HANDLE handle,
                                      ACE_Message_Block *message_block,
                                      size_t bytes_to_read,
@@ -221,7 +221,7 @@ public:
 
   virtual ACE_Asynch_Write_Dgram_Impl *create_asynch_write_dgram (void);
   virtual ACE_Asynch_Write_Dgram_Result_Impl *
-    create_asynch_write_dgram_result (ACE_Handler &handler,
+    create_asynch_write_dgram_result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                       ACE_HANDLE handle,
                                       ACE_Message_Block *message_block,
                                       size_t bytes_to_write,
@@ -233,7 +233,7 @@ public:
 
   virtual ACE_Asynch_Accept_Impl *create_asynch_accept (void);
   virtual ACE_Asynch_Accept_Result_Impl *
-    create_asynch_accept_result (ACE_Handler &handler,
+    create_asynch_accept_result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                  ACE_HANDLE listen_handle,
                                  ACE_HANDLE accept_handle,
                                  ACE_Message_Block &message_block,
@@ -245,7 +245,7 @@ public:
 
   virtual ACE_Asynch_Connect_Impl *create_asynch_connect (void);
   virtual ACE_Asynch_Connect_Result_Impl *
-    create_asynch_connect_result (ACE_Handler & handler,
+    create_asynch_connect_result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                   ACE_HANDLE connect_handle,
                                   const void *act,
                                   ACE_HANDLE event = ACE_INVALID_HANDLE,
@@ -254,7 +254,7 @@ public:
 
   virtual ACE_Asynch_Transmit_File_Impl *create_asynch_transmit_file (void);
   virtual ACE_Asynch_Transmit_File_Result_Impl *
-    create_asynch_transmit_file_result (ACE_Handler &handler,
+    create_asynch_transmit_file_result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                         ACE_HANDLE socket,
                                         ACE_HANDLE file,
                                         ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer,
@@ -271,7 +271,7 @@ public:
   /// Create a timer result object which can be used with the Timer
   /// mechanism of the Proactor.
   virtual ACE_Asynch_Result_Impl *
-    create_asynch_timer (ACE_Handler &handler,
+    create_asynch_timer (ACE_Handler::Proxy_Ptr &handler_proxy,
                          const void *act,
                          const ACE_Time_Value &tv,
                          ACE_HANDLE event = ACE_INVALID_HANDLE,
@@ -563,12 +563,13 @@ public:
    * which the Proactor will be waiting) of the Proactor. If there are
    * more than one signal, the higher numbered signal will be chosen.
    */
-  virtual ACE_Asynch_Result_Impl *create_asynch_timer (ACE_Handler &handler,
-                                                       const void *act,
-                                                       const ACE_Time_Value &tv,
-                                                       ACE_HANDLE event = ACE_INVALID_HANDLE,
-                                                       int priority = 0,
-                                                       int signal_number = ACE_SIGRTMIN);
+  virtual ACE_Asynch_Result_Impl *create_asynch_timer
+    (ACE_Handler::Proxy_Ptr &handler_proxy,
+     const void *act,
+     const ACE_Time_Value &tv,
+     ACE_HANDLE event = ACE_INVALID_HANDLE,
+     int priority = 0,
+     int signal_number = ACE_SIGRTMIN);
 
 protected:
   /// To setup the handler for a real-time signbal.
@@ -628,7 +629,7 @@ class ACE_Export ACE_POSIX_Asynch_Timer : public ACE_POSIX_Asynch_Result
 
 protected:
   /// Constructor.
-  ACE_POSIX_Asynch_Timer (ACE_Handler &handler,
+  ACE_POSIX_Asynch_Timer (ACE_Handler::Proxy_Ptr &handler_proxy,
                           const void *act,
                           const ACE_Time_Value &tv,
                           ACE_HANDLE event = ACE_INVALID_HANDLE,
diff --git a/ace/Proactor.cpp b/ace/Proactor.cpp
index 6da0e3229d9..c8012d7727b 100644
--- a/ace/Proactor.cpp
+++ b/ace/Proactor.cpp
@@ -218,7 +218,7 @@ ACE_Proactor_Handle_Timeout_Upcall::timeout (TIMER_QUEUE &,
 
   // Create the Asynch_Timer.
   ACE_Asynch_Result_Impl *asynch_timer =
-    this->proactor_->create_asynch_timer (*handler,
+    this->proactor_->create_asynch_timer (handler->proxy (),
                                           act,
                                           time,
                                           ACE_INVALID_HANDLE,
@@ -856,228 +856,242 @@ ACE_Proactor::create_asynch_transmit_file (void)
 }
 
 ACE_Asynch_Read_Stream_Result_Impl *
-ACE_Proactor::create_asynch_read_stream_result (ACE_Handler &handler,
-                                                ACE_HANDLE handle,
-                                                ACE_Message_Block &message_block,
-                                                u_long bytes_to_read,
-                                                const void* act,
-                                                ACE_HANDLE event,
-                                                int priority,
-                                                int signal_number)
-{
-  return this->implementation ()->create_asynch_read_stream_result (handler,
-                                                                    handle,
-                                                                    message_block,
-                                                                    bytes_to_read,
-                                                                    act,
-                                                                    event,
-                                                                    priority,
-                                                                    signal_number);
+ACE_Proactor::create_asynch_read_stream_result
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   ACE_HANDLE handle,
+   ACE_Message_Block &message_block,
+   u_long bytes_to_read,
+   const void* act,
+   ACE_HANDLE event,
+   int priority,
+   int signal_number)
+{
+  return this->implementation ()->create_asynch_read_stream_result
+    (handler_proxy,
+     handle,
+     message_block,
+     bytes_to_read,
+     act,
+     event,
+     priority,
+     signal_number);
 }
 
 
 ACE_Asynch_Write_Stream_Result_Impl *
-ACE_Proactor::create_asynch_write_stream_result (ACE_Handler &handler,
-                                                 ACE_HANDLE handle,
-                                                 ACE_Message_Block &message_block,
-                                                 u_long bytes_to_write,
-                                                 const void* act,
-                                                 ACE_HANDLE event,
-                                                 int priority,
-                                                 int signal_number)
-
-{
-  return this->implementation ()->create_asynch_write_stream_result (handler,
-                                                                     handle,
-                                                                     message_block,
-                                                                     bytes_to_write,
-                                                                     act,
-                                                                     event,
-                                                                     priority,
-                                                                     signal_number);
+ACE_Proactor::create_asynch_write_stream_result
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   ACE_HANDLE handle,
+   ACE_Message_Block &message_block,
+   u_long bytes_to_write,
+   const void* act,
+   ACE_HANDLE event,
+   int priority,
+   int signal_number)
+{
+  return this->implementation ()->create_asynch_write_stream_result
+    (handler_proxy,
+     handle,
+     message_block,
+     bytes_to_write,
+     act,
+     event,
+     priority,
+     signal_number);
 }
 
 ACE_Asynch_Read_File_Result_Impl *
-ACE_Proactor::create_asynch_read_file_result (ACE_Handler &handler,
-                                              ACE_HANDLE handle,
-                                              ACE_Message_Block &message_block,
-                                              u_long bytes_to_read,
-                                              const void* act,
-                                              u_long offset,
-                                              u_long offset_high,
-                                              ACE_HANDLE event,
-                                              int priority,
-                                              int signal_number)
-
-{
-  return this->implementation ()->create_asynch_read_file_result (handler,
-                                                                  handle,
-                                                                  message_block,
-                                                                  bytes_to_read,
-                                                                  act,
-                                                                  offset,
-                                                                  offset_high,
-                                                                  event,
-                                                                  priority,
-                                                                  signal_number);
+ACE_Proactor::create_asynch_read_file_result
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   ACE_HANDLE handle,
+   ACE_Message_Block &message_block,
+   u_long bytes_to_read,
+   const void* act,
+   u_long offset,
+   u_long offset_high,
+   ACE_HANDLE event,
+   int priority,
+   int signal_number)
+{
+  return this->implementation ()->create_asynch_read_file_result
+    (handler_proxy,
+     handle,
+     message_block,
+     bytes_to_read,
+     act,
+     offset,
+     offset_high,
+     event,
+     priority,
+     signal_number);
 }
 
 ACE_Asynch_Write_File_Result_Impl *
-ACE_Proactor::create_asynch_write_file_result (ACE_Handler &handler,
-                                               ACE_HANDLE handle,
-                                               ACE_Message_Block &message_block,
-                                               u_long bytes_to_write,
-                                               const void* act,
-                                               u_long offset,
-                                               u_long offset_high,
-                                               ACE_HANDLE event,
-                                               int priority,
-                                               int signal_number)
-
-{
-  return this->implementation ()->create_asynch_write_file_result (handler,
-                                                                   handle,
-                                                                   message_block,
-                                                                   bytes_to_write,
-                                                                   act,
-                                                                   offset,
-                                                                   offset_high,
-                                                                   event,
-                                                                   priority,
-                                                                   signal_number);
+ACE_Proactor::create_asynch_write_file_result
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   ACE_HANDLE handle,
+   ACE_Message_Block &message_block,
+   u_long bytes_to_write,
+   const void* act,
+   u_long offset,
+   u_long offset_high,
+   ACE_HANDLE event,
+   int priority,
+   int signal_number)
+{
+  return this->implementation ()->create_asynch_write_file_result
+    (handler_proxy,
+     handle,
+     message_block,
+     bytes_to_write,
+     act,
+     offset,
+     offset_high,
+     event,
+     priority,
+     signal_number);
 }
 
 ACE_Asynch_Read_Dgram_Result_Impl *
-ACE_Proactor::create_asynch_read_dgram_result (ACE_Handler &handler,
-                                               ACE_HANDLE handle,
-                                               ACE_Message_Block *message_block,
-                                               size_t bytes_to_read,
-                                               int flags,
-                                               int protocol_family,
-                                               const void* act,
-                                               ACE_HANDLE event,
-                                               int priority,
-                                               int signal_number)
-{
-  return this->implementation()->create_asynch_read_dgram_result (handler,
-                                                                  handle,
-                                                                  message_block,
-                                                                  bytes_to_read,
-                                                                  flags,
-                                                                  protocol_family,
-                                                                  act,
-                                                                  event,
-                                                                  priority,
-                                                                  signal_number);
+ACE_Proactor::create_asynch_read_dgram_result
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   ACE_HANDLE handle,
+   ACE_Message_Block *message_block,
+   size_t bytes_to_read,
+   int flags,
+   int protocol_family,
+   const void* act,
+   ACE_HANDLE event,
+   int priority,
+   int signal_number)
+{
+  return this->implementation()->create_asynch_read_dgram_result
+    (handler_proxy,
+     handle,
+     message_block,
+     bytes_to_read,
+     flags,
+     protocol_family,
+     act,
+     event,
+     priority,
+     signal_number);
 }
 
 ACE_Asynch_Write_Dgram_Result_Impl *
-ACE_Proactor::create_asynch_write_dgram_result (ACE_Handler &handler,
-                                                ACE_HANDLE handle,
-                                                ACE_Message_Block *message_block,
-                                                size_t bytes_to_write,
-                                                int flags,
-                                                const void* act,
-                                                ACE_HANDLE event,
-                                                int priority,
-                                                int signal_number)
-{
-  return this->implementation()->create_asynch_write_dgram_result (handler,
-                                                                   handle,
-                                                                   message_block,
-                                                                   bytes_to_write,
-                                                                   flags,
-                                                                   act,
-                                                                   event,
-                                                                   priority,
-                                                                   signal_number);
+ACE_Proactor::create_asynch_write_dgram_result
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   ACE_HANDLE handle,
+   ACE_Message_Block *message_block,
+   size_t bytes_to_write,
+   int flags,
+   const void* act,
+   ACE_HANDLE event,
+   int priority,
+   int signal_number)
+{
+  return this->implementation()->create_asynch_write_dgram_result
+    (handler_proxy,
+     handle,
+     message_block,
+     bytes_to_write,
+     flags,
+     act,
+     event,
+     priority,
+     signal_number);
 }
 
 ACE_Asynch_Accept_Result_Impl *
-ACE_Proactor::create_asynch_accept_result (ACE_Handler &handler,
-                                           ACE_HANDLE listen_handle,
-                                           ACE_HANDLE accept_handle,
-                                           ACE_Message_Block &message_block,
-                                           u_long bytes_to_read,
-                                           const void* act,
-                                           ACE_HANDLE event,
-                                           int priority,
-                                           int signal_number)
-
-{
-  return this->implementation ()->create_asynch_accept_result (handler,
-                                                               listen_handle,
-                                                               accept_handle,
-                                                               message_block,
-                                                               bytes_to_read,
-                                                               act,
-                                                               event,
-                                                               priority,
-                                                               signal_number);
+ACE_Proactor::create_asynch_accept_result
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   ACE_HANDLE listen_handle,
+   ACE_HANDLE accept_handle,
+   ACE_Message_Block &message_block,
+   u_long bytes_to_read,
+   const void* act,
+   ACE_HANDLE event,
+   int priority,
+   int signal_number)
+{
+  return this->implementation ()->create_asynch_accept_result
+    (handler_proxy,
+     listen_handle,
+     accept_handle,
+     message_block,
+     bytes_to_read,
+     act,
+     event,
+     priority,
+     signal_number);
 }
 
 ACE_Asynch_Connect_Result_Impl *
-ACE_Proactor::create_asynch_connect_result (ACE_Handler &handler,
-                                            ACE_HANDLE  connect_handle,
-                                            const void* act,
-                                            ACE_HANDLE event,
-                                            int priority,
-                                            int signal_number)
-
-{
-  return this->implementation ()->create_asynch_connect_result (handler,
-                                                                connect_handle,
-                                                                act,
-                                                                event,
-                                                                priority,
-                                                                signal_number);
+ACE_Proactor::create_asynch_connect_result
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   ACE_HANDLE  connect_handle,
+   const void* act,
+   ACE_HANDLE event,
+   int priority,
+   int signal_number)
+{
+  return this->implementation ()->create_asynch_connect_result
+    (handler_proxy,
+     connect_handle,
+     act,
+     event,
+     priority,
+     signal_number);
 }
 
 ACE_Asynch_Transmit_File_Result_Impl *
-ACE_Proactor::create_asynch_transmit_file_result (ACE_Handler &handler,
-                                                  ACE_HANDLE socket,
-                                                  ACE_HANDLE file,
-                                                  ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer,
-                                                  u_long bytes_to_write,
-                                                  u_long offset,
-                                                  u_long offset_high,
-                                                  u_long bytes_per_send,
-                                                  u_long flags,
-                                                  const void *act,
-                                                  ACE_HANDLE event,
-                                                  int priority,
-                                                  int signal_number)
-
-{
-  return this->implementation ()->create_asynch_transmit_file_result (handler,
-                                                                      socket,
-                                                                      file,
-                                                                      header_and_trailer,
-                                                                      bytes_to_write,
-                                                                      offset,
-                                                                      offset_high,
-                                                                      bytes_per_send,
-                                                                      flags,
-                                                                      act,
-                                                                      event,
-                                                                      priority,
-                                                                      signal_number);
+ACE_Proactor::create_asynch_transmit_file_result
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   ACE_HANDLE socket,
+   ACE_HANDLE file,
+   ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer,
+   u_long bytes_to_write,
+   u_long offset,
+   u_long offset_high,
+   u_long bytes_per_send,
+   u_long flags,
+   const void *act,
+   ACE_HANDLE event,
+   int priority,
+   int signal_number)
+{
+  return this->implementation ()->create_asynch_transmit_file_result
+    (handler_proxy,
+     socket,
+     file,
+     header_and_trailer,
+     bytes_to_write,
+     offset,
+     offset_high,
+     bytes_per_send,
+     flags,
+     act,
+     event,
+     priority,
+     signal_number);
 }
 
 ACE_Asynch_Result_Impl *
-ACE_Proactor::create_asynch_timer (ACE_Handler &handler,
-                                   const void *act,
-                                   const ACE_Time_Value &tv,
-                                   ACE_HANDLE event,
-                                   int priority,
-                                   int signal_number)
-{
-  return this->implementation ()->create_asynch_timer (handler,
-                                                       act,
-                                                       tv,
-                                                       event,
-                                                       priority,
-                                                       signal_number);
+ACE_Proactor::create_asynch_timer
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   const void *act,
+   const ACE_Time_Value &tv,
+   ACE_HANDLE event,
+   int priority,
+   int signal_number)
+{
+  return this->implementation ()->create_asynch_timer
+    (handler_proxy,
+     act,
+     tv,
+     event,
+     priority,
+     signal_number);
 }
 
 int
diff --git a/ace/Proactor.h b/ace/Proactor.h
index b78142619b7..8ed6aa83a02 100644
--- a/ace/Proactor.h
+++ b/ace/Proactor.h
@@ -443,7 +443,7 @@ public:
   /// Create the correct implementation class for
   /// ACE_Asynch_Read_Stream::Result class.
   virtual ACE_Asynch_Read_Stream_Result_Impl *
-    create_asynch_read_stream_result (ACE_Handler &handler,
+    create_asynch_read_stream_result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                       ACE_HANDLE handle,
                                       ACE_Message_Block &message_block,
                                       u_long bytes_to_read,
@@ -455,7 +455,7 @@ public:
   /// Create the correct implementation class for
   /// ACE_Asynch_Write_Stream::Result.
   virtual ACE_Asynch_Write_Stream_Result_Impl *
-    create_asynch_write_stream_result (ACE_Handler &handler,
+    create_asynch_write_stream_result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                        ACE_HANDLE handle,
                                        ACE_Message_Block &message_block,
                                        u_long bytes_to_write,
@@ -467,7 +467,7 @@ public:
   /// Create the correct implementation class for
   /// ACE_Asynch_Read_File::Result.
   virtual ACE_Asynch_Read_File_Result_Impl *
-    create_asynch_read_file_result (ACE_Handler &handler,
+    create_asynch_read_file_result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                     ACE_HANDLE handle,
                                     ACE_Message_Block &message_block,
                                     u_long bytes_to_read,
@@ -481,7 +481,7 @@ public:
   /// Create the correct implementation class for
   /// ACE_Asynch_Write_File::Result.
   virtual ACE_Asynch_Write_File_Result_Impl *
-    create_asynch_write_file_result (ACE_Handler &handler,
+    create_asynch_write_file_result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                      ACE_HANDLE handle,
                                      ACE_Message_Block &message_block,
                                      u_long bytes_to_write,
@@ -495,7 +495,7 @@ public:
   /// Create the correct implementation class for
   /// ACE_Asynch_Read_Dgram::Result.
   virtual ACE_Asynch_Read_Dgram_Result_Impl *
-    create_asynch_read_dgram_result (ACE_Handler &handler,
+    create_asynch_read_dgram_result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                      ACE_HANDLE handle,
                                      ACE_Message_Block *message_block,
                                      size_t bytes_to_read,
@@ -509,7 +509,7 @@ public:
   /// Create the correct implementation class for
   /// ACE_Asynch_Write_Dgram::Result.
   virtual ACE_Asynch_Write_Dgram_Result_Impl *
-    create_asynch_write_dgram_result (ACE_Handler &handler,
+    create_asynch_write_dgram_result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                       ACE_HANDLE handle,
                                       ACE_Message_Block *message_block,
                                       size_t bytes_to_write,
@@ -521,7 +521,7 @@ public:
 
   /// Create the correct implementation class for ACE_Asynch_Accept::Result.
   virtual ACE_Asynch_Accept_Result_Impl *
-    create_asynch_accept_result (ACE_Handler &handler,
+    create_asynch_accept_result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                  ACE_HANDLE listen_handle,
                                  ACE_HANDLE accept_handle,
                                  ACE_Message_Block &message_block,
@@ -533,7 +533,7 @@ public:
 
   /// Create the correct implementation class for ACE_Asynch_Connect::Result
   virtual ACE_Asynch_Connect_Result_Impl *
-    create_asynch_connect_result (ACE_Handler &handler,
+    create_asynch_connect_result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                   ACE_HANDLE  connect_handle,
                                   const void* act,
                                   ACE_HANDLE event = ACE_INVALID_HANDLE,
@@ -543,7 +543,7 @@ public:
   /// Create the correct implementation class for
   /// ACE_Asynch_Transmit_File::Result.
   virtual ACE_Asynch_Transmit_File_Result_Impl *
-    create_asynch_transmit_file_result (ACE_Handler &handler,
+    create_asynch_transmit_file_result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                         ACE_HANDLE socket,
                                         ACE_HANDLE file,
                                         ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer,
@@ -564,12 +564,13 @@ public:
    * Timer object with a meaningful signal number, choosing the
    * largest signal number from the signal mask of the Proactor.
    */
-  virtual ACE_Asynch_Result_Impl *create_asynch_timer (ACE_Handler &handler,
-                                                       const void *act,
-                                                       const ACE_Time_Value &tv,
-                                                       ACE_HANDLE event = ACE_INVALID_HANDLE,
-                                                       int priority = 0,
-                                                       int signal_number = ACE_SIGRTMIN);
+  virtual ACE_Asynch_Result_Impl *
+    create_asynch_timer (ACE_Handler::Proxy_Ptr &handler_proxy,
+                         const void *act,
+                         const ACE_Time_Value &tv,
+                         ACE_HANDLE event = ACE_INVALID_HANDLE,
+                         int priority = 0,
+                         int signal_number = ACE_SIGRTMIN);
 
 protected:
 
diff --git a/ace/Proactor_Impl.h b/ace/Proactor_Impl.h
index ae41266d180..96a9e1bdab3 100644
--- a/ace/Proactor_Impl.h
+++ b/ace/Proactor_Impl.h
@@ -125,117 +125,127 @@ public:
   // methods unless they want to "fake" results.
 
   /// Create the correct implementation class for ACE_Asynch_Read_Stream::Result class.
-  virtual ACE_Asynch_Read_Stream_Result_Impl *create_asynch_read_stream_result (ACE_Handler &handler,
-                                                                                ACE_HANDLE handle,
-                                                                                ACE_Message_Block &message_block,
-                                                                                size_t bytes_to_read,
-                                                                                const void* act,
-                                                                                ACE_HANDLE event = ACE_INVALID_HANDLE,
-                                                                                int priority = 0,
-                                                                                int signal_number = ACE_SIGRTMIN) = 0;
+  virtual ACE_Asynch_Read_Stream_Result_Impl *
+    create_asynch_read_stream_result (ACE_Handler::Proxy_Ptr &handler_proxy,
+                                      ACE_HANDLE handle,
+                                      ACE_Message_Block &message_block,
+                                      size_t bytes_to_read,
+                                      const void* act,
+                                      ACE_HANDLE event = ACE_INVALID_HANDLE,
+                                      int priority = 0,
+                                      int signal_number = ACE_SIGRTMIN) = 0;
 
   /// Create the correct implementation class for ACE_Asynch_Write_Stream::Result.
-  virtual ACE_Asynch_Write_Stream_Result_Impl *create_asynch_write_stream_result (ACE_Handler &handler,
-                                                                                  ACE_HANDLE handle,
-                                                                                  ACE_Message_Block &message_block,
-                                                                                  size_t bytes_to_write,
-                                                                                  const void* act,
-                                                                                  ACE_HANDLE event = ACE_INVALID_HANDLE,
-                                                                                  int priority = 0,
-                                                                                  int signal_number = ACE_SIGRTMIN) = 0;
+  virtual ACE_Asynch_Write_Stream_Result_Impl *
+    create_asynch_write_stream_result (ACE_Handler::Proxy_Ptr &handler_proxy,
+                                       ACE_HANDLE handle,
+                                       ACE_Message_Block &message_block,
+                                       size_t bytes_to_write,
+                                       const void* act,
+                                       ACE_HANDLE event = ACE_INVALID_HANDLE,
+                                       int priority = 0,
+                                       int signal_number = ACE_SIGRTMIN) = 0;
 
   /// Create the correct implementation class for ACE_Asynch_Read_File::Result.
-  virtual ACE_Asynch_Read_File_Result_Impl *create_asynch_read_file_result (ACE_Handler &handler,
-                                                                            ACE_HANDLE handle,
-                                                                            ACE_Message_Block &message_block,
-                                                                            size_t bytes_to_read,
-                                                                            const void* act,
-                                                                            u_long offset,
-                                                                            u_long offset_high,
-                                                                            ACE_HANDLE event = ACE_INVALID_HANDLE,
-                                                                            int priority = 0,
-                                                                            int signal_number = ACE_SIGRTMIN) = 0;
+  virtual ACE_Asynch_Read_File_Result_Impl *
+    create_asynch_read_file_result (ACE_Handler::Proxy_Ptr &handler_proxy,
+                                    ACE_HANDLE handle,
+                                    ACE_Message_Block &message_block,
+                                    size_t bytes_to_read,
+                                    const void* act,
+                                    u_long offset,
+                                    u_long offset_high,
+                                    ACE_HANDLE event = ACE_INVALID_HANDLE,
+                                    int priority = 0,
+                                    int signal_number = ACE_SIGRTMIN) = 0;
 
     /// Create the correct implementation class for ACE_Asynch_Write_File::Result.
-  virtual ACE_Asynch_Write_File_Result_Impl *create_asynch_write_file_result (ACE_Handler &handler,
-                                                                              ACE_HANDLE handle,
-                                                                              ACE_Message_Block &message_block,
-                                                                              size_t bytes_to_write,
-                                                                              const void* act,
-                                                                              u_long offset,
-                                                                              u_long offset_high,
-                                                                              ACE_HANDLE event = ACE_INVALID_HANDLE,
-                                                                              int priority = 0,
-                                                                              int signal_number = ACE_SIGRTMIN) = 0;
+  virtual ACE_Asynch_Write_File_Result_Impl *
+    create_asynch_write_file_result (ACE_Handler::Proxy_Ptr &handler,
+                                     ACE_HANDLE handle,
+                                     ACE_Message_Block &message_block,
+                                     size_t bytes_to_write,
+                                     const void* act,
+                                     u_long offset,
+                                     u_long offset_high,
+                                     ACE_HANDLE event = ACE_INVALID_HANDLE,
+                                     int priority = 0,
+                                     int signal_number = ACE_SIGRTMIN) = 0;
 
   /// Create the correct implementation class for ACE_Asynch_Read_Dgram::Result.
-  virtual ACE_Asynch_Read_Dgram_Result_Impl *create_asynch_read_dgram_result (ACE_Handler &handler,
-                                                                              ACE_HANDLE handle,
-                                                                              ACE_Message_Block *message_block,
-                                                                              size_t bytes_to_read,
-                                                                              int flags,
-                                                                              int protocol_family,
-                                                                              const void* act,
-                                                                              ACE_HANDLE event = ACE_INVALID_HANDLE,
-                                                                              int priority = 0,
-                                                                              int signal_number = ACE_SIGRTMIN) = 0;
+  virtual ACE_Asynch_Read_Dgram_Result_Impl *
+    create_asynch_read_dgram_result (ACE_Handler::Proxy_Ptr &handler_proxy,
+                                     ACE_HANDLE handle,
+                                     ACE_Message_Block *message_block,
+                                     size_t bytes_to_read,
+                                     int flags,
+                                     int protocol_family,
+                                     const void* act,
+                                     ACE_HANDLE event = ACE_INVALID_HANDLE,
+                                     int priority = 0,
+                                     int signal_number = ACE_SIGRTMIN) = 0;
 
   /// Create the correct implementation class for ACE_Asynch_Write_Dgram::Result.
-  virtual ACE_Asynch_Write_Dgram_Result_Impl *create_asynch_write_dgram_result (ACE_Handler &handler,
-                                                                                ACE_HANDLE handle,
-                                                                                ACE_Message_Block *message_block,
-                                                                                size_t bytes_to_write,
-                                                                                int flags,
-                                                                                const void* act,
-                                                                                ACE_HANDLE event = ACE_INVALID_HANDLE,
-                                                                                int priority = 0,
-                                                                                int signal_number = ACE_SIGRTMIN) = 0;
+  virtual ACE_Asynch_Write_Dgram_Result_Impl *
+    create_asynch_write_dgram_result (ACE_Handler::Proxy_Ptr &handler_proxy,
+                                      ACE_HANDLE handle,
+                                      ACE_Message_Block *message_block,
+                                      size_t bytes_to_write,
+                                      int flags,
+                                      const void* act,
+                                      ACE_HANDLE event = ACE_INVALID_HANDLE,
+                                      int priority = 0,
+                                      int signal_number = ACE_SIGRTMIN) = 0;
 
   /// Create the correct implementation class for ACE_Asynch_Accept::Result.
-  virtual ACE_Asynch_Accept_Result_Impl *create_asynch_accept_result (ACE_Handler &handler,
-                                                                      ACE_HANDLE listen_handle,
-                                                                      ACE_HANDLE accept_handle,
-                                                                      ACE_Message_Block &message_block,
-                                                                      size_t bytes_to_read,
-                                                                      const void* act,
-                                                                      ACE_HANDLE event = ACE_INVALID_HANDLE,
-                                                                      int priority = 0,
-                                                                      int signal_number = ACE_SIGRTMIN) = 0;
+  virtual ACE_Asynch_Accept_Result_Impl *
+    create_asynch_accept_result (ACE_Handler::Proxy_Ptr &handler_proxy,
+                                 ACE_HANDLE listen_handle,
+                                 ACE_HANDLE accept_handle,
+                                 ACE_Message_Block &message_block,
+                                 size_t bytes_to_read,
+                                 const void* act,
+                                 ACE_HANDLE event = ACE_INVALID_HANDLE,
+                                 int priority = 0,
+                                 int signal_number = ACE_SIGRTMIN) = 0;
 
   /// Create the correct implementation class for ACE_Asynch_Connect::Result.
-  virtual ACE_Asynch_Connect_Result_Impl *create_asynch_connect_result (ACE_Handler &handler,
-                                                                        ACE_HANDLE connect_handle,
-                                                                        const void* act,
-                                                                        ACE_HANDLE event = ACE_INVALID_HANDLE,
-                                                                        int priority = 0,
-                                                                        int signal_number = ACE_SIGRTMIN) = 0;
+  virtual ACE_Asynch_Connect_Result_Impl *
+    create_asynch_connect_result (ACE_Handler::Proxy_Ptr &handler_proxy,
+                                  ACE_HANDLE connect_handle,
+                                  const void* act,
+                                  ACE_HANDLE event = ACE_INVALID_HANDLE,
+                                  int priority = 0,
+                                  int signal_number = ACE_SIGRTMIN) = 0;
 
   /// Create the correct implementation class for ACE_Asynch_Transmit_File::Result.
-  virtual ACE_Asynch_Transmit_File_Result_Impl *create_asynch_transmit_file_result (ACE_Handler &handler,
-                                                                                    ACE_HANDLE socket,
-                                                                                    ACE_HANDLE file,
-                                                                                    ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer,
-                                                                                    size_t bytes_to_write,
-                                                                                    u_long offset,
-                                                                                    u_long offset_high,
-                                                                                    size_t bytes_per_send,
-                                                                                    u_long flags,
-                                                                                    const void *act,
-                                                                                    ACE_HANDLE event = ACE_INVALID_HANDLE,
-                                                                                    int priority = 0,
-                                                                                    int signal_number = ACE_SIGRTMIN) = 0;
+  virtual ACE_Asynch_Transmit_File_Result_Impl *
+    create_asynch_transmit_file_result (ACE_Handler::Proxy_Ptr &handler_proxy,
+                                        ACE_HANDLE socket,
+                                        ACE_HANDLE file,
+                                        ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer,
+                                        size_t bytes_to_write,
+                                        u_long offset,
+                                        u_long offset_high,
+                                        size_t bytes_per_send,
+                                        u_long flags,
+                                        const void *act,
+                                        ACE_HANDLE event = ACE_INVALID_HANDLE,
+                                        int priority = 0,
+                                        int signal_number = ACE_SIGRTMIN) = 0;
 
   /**
    * Create the correct implementation object for the Timer
    * result. POSIX_SIG_Proactor will create a Timer object with a
    * meaningful signal number, if you leave the signal number as 0.
    */
-  virtual ACE_Asynch_Result_Impl *create_asynch_timer (ACE_Handler &handler,
-                                                       const void *act,
-                                                       const ACE_Time_Value &tv,
-                                                       ACE_HANDLE event = ACE_INVALID_HANDLE,
-                                                       int priority = 0,
-                                                       int signal_number = 0) = 0;
+  virtual ACE_Asynch_Result_Impl *
+    create_asynch_timer (ACE_Handler::Proxy_Ptr &handler_proxy,
+                         const void *act,
+                         const ACE_Time_Value &tv,
+                         ACE_HANDLE event = ACE_INVALID_HANDLE,
+                         int priority = 0,
+                         int signal_number = 0) = 0;
 
   /**
    * Post <how_many> completions to the completion port so that all
diff --git a/ace/WIN32_Asynch_IO.cpp b/ace/WIN32_Asynch_IO.cpp
index 1d4807f548a..1e15721cd0f 100644
--- a/ace/WIN32_Asynch_IO.cpp
+++ b/ace/WIN32_Asynch_IO.cpp
@@ -109,16 +109,17 @@ ACE_WIN32_Asynch_Result::~ACE_WIN32_Asynch_Result (void)
 {
 }
 
-ACE_WIN32_Asynch_Result::ACE_WIN32_Asynch_Result (ACE_Handler &handler,
-                                                  const void* act,
-                                                  ACE_HANDLE event,
-                                                  u_long offset,
-                                                  u_long offset_high,
-                                                  int priority,
-                                                  int signal_number)
+ACE_WIN32_Asynch_Result::ACE_WIN32_Asynch_Result
+   (ACE_Handler::Proxy_Ptr &handler_proxy,
+    const void* act,
+    ACE_HANDLE event,
+    u_long offset,
+    u_long offset_high,
+    int priority,
+    int signal_number)
   : ACE_Asynch_Result_Impl (),
     OVERLAPPED (),
-    handler_ (handler),
+    handler_proxy_ (handler_proxy),
     act_ (act),
     bytes_transferred_ (0),
     success_ (0),
@@ -137,18 +138,22 @@ ACE_WIN32_Asynch_Result::ACE_WIN32_Asynch_Result (ACE_Handler &handler,
 }
 
 int
-ACE_WIN32_Asynch_Operation::open (ACE_Handler &handler,
+ACE_WIN32_Asynch_Operation::open (ACE_Handler::Proxy_Ptr &handler_proxy,
                                   ACE_HANDLE handle,
                                   const void *completion_key,
                                   ACE_Proactor *proactor)
 {
   this->proactor_ = proactor;
-  this->handler_ = &handler;
+  this->handler_proxy_ = handler_proxy;
   this->handle_ = handle;
 
   // Grab the handle from the <handler> if <handle> is invalid
   if (this->handle_ == ACE_INVALID_HANDLE)
-    this->handle_ = this->handler_->handle ();
+    {
+      ACE_Handler *handler = handler_proxy.get ()->handler ();
+      if (handler != 0)
+        this->handle_ = handler->handle ();
+    }
   if (this->handle_ == ACE_INVALID_HANDLE)
     return -1;
 
@@ -195,7 +200,6 @@ ACE_WIN32_Asynch_Operation::ACE_WIN32_Asynch_Operation (ACE_WIN32_Proactor *win3
   : ACE_Asynch_Operation_Impl (),
     win32_proactor_ (win32_proactor),
     proactor_ (0),
-    handler_ (0),
     handle_ (ACE_INVALID_HANDLE)
 {
 }
@@ -225,7 +229,7 @@ ACE_WIN32_Asynch_Read_Stream_Result::handle (void) const
 }
 
 ACE_WIN32_Asynch_Read_Stream_Result::ACE_WIN32_Asynch_Read_Stream_Result (
-  ACE_Handler &handler,
+  ACE_Handler::Proxy_Ptr &handler_proxy,
   ACE_HANDLE handle,
   ACE_Message_Block &message_block,
   size_t bytes_to_read,
@@ -236,7 +240,7 @@ ACE_WIN32_Asynch_Read_Stream_Result::ACE_WIN32_Asynch_Read_Stream_Result (
   int scatter_enabled)
   : ACE_Asynch_Result_Impl (),
     ACE_Asynch_Read_Stream_Result_Impl (),
-    ACE_WIN32_Asynch_Result (handler,
+    ACE_WIN32_Asynch_Result (handler_proxy,
                              act,
                              event,
                              0,
@@ -286,7 +290,9 @@ ACE_WIN32_Asynch_Read_Stream_Result::complete (size_t bytes_transferred,
   ACE_Asynch_Read_Stream::Result result (this);
 
   // Call the application handler.
-  this->handler_.handle_read_stream (result);
+  ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
+  if (handler != 0)
+    handler->handle_read_stream (result);
 }
 
 ACE_WIN32_Asynch_Read_Stream_Result::~ACE_WIN32_Asynch_Read_Stream_Result (void)
@@ -395,7 +401,7 @@ ACE_WIN32_Asynch_Read_Stream::read (ACE_Message_Block &message_block,
   // Create the Asynch_Result.
   ACE_WIN32_Asynch_Read_Stream_Result *result = 0;
   ACE_NEW_RETURN (result,
-                  ACE_WIN32_Asynch_Read_Stream_Result (*this->handler_,
+                  ACE_WIN32_Asynch_Read_Stream_Result (this->handler_proxy_,
                                                        this->handle_,
                                                        message_block,
                                                        bytes_to_read,
@@ -487,7 +493,7 @@ ACE_WIN32_Asynch_Read_Stream::readv (ACE_Message_Block &message_block,
   // Create the Asynch_Result.
   ACE_WIN32_Asynch_Read_Stream_Result *result = 0;
   ACE_NEW_RETURN (result,
-                  ACE_WIN32_Asynch_Read_Stream_Result (*this->handler_,
+                  ACE_WIN32_Asynch_Read_Stream_Result (this->handler_proxy_,
                                                        this->handle_,
                                                        message_block,
                                                        bytes_to_read,
@@ -613,12 +619,12 @@ ACE_WIN32_Asynch_Read_Stream::shared_read (ACE_WIN32_Asynch_Read_Stream_Result *
 // call to the ACE_WIN32_Asynch_Operation base class.
 
 int
-ACE_WIN32_Asynch_Read_Stream::open (ACE_Handler &handler,
+ACE_WIN32_Asynch_Read_Stream::open (ACE_Handler::Proxy_Ptr &handler_proxy,
                                     ACE_HANDLE handle,
                                     const void *completion_key,
                                     ACE_Proactor *proactor)
 {
-  return ACE_WIN32_Asynch_Operation::open (handler,
+  return ACE_WIN32_Asynch_Operation::open (handler_proxy,
                                            handle,
                                            completion_key,
                                            proactor);
@@ -655,7 +661,7 @@ ACE_WIN32_Asynch_Write_Stream_Result::handle (void) const
 }
 
 ACE_WIN32_Asynch_Write_Stream_Result::ACE_WIN32_Asynch_Write_Stream_Result (
-  ACE_Handler &handler,
+  ACE_Handler::Proxy_Ptr &handler_proxy,
   ACE_HANDLE handle,
   ACE_Message_Block &message_block,
   size_t bytes_to_write,
@@ -666,7 +672,8 @@ ACE_WIN32_Asynch_Write_Stream_Result::ACE_WIN32_Asynch_Write_Stream_Result (
   int gather_enabled)
   : ACE_Asynch_Result_Impl (),
     ACE_Asynch_Write_Stream_Result_Impl (),
-    ACE_WIN32_Asynch_Result (handler, act, event, 0, 0, priority, signal_number),
+    ACE_WIN32_Asynch_Result
+      (handler_proxy, act, event, 0, 0, priority, signal_number),
     bytes_to_write_ (bytes_to_write),
     message_block_ (message_block),
     handle_ (handle),
@@ -710,7 +717,9 @@ ACE_WIN32_Asynch_Write_Stream_Result::complete (size_t bytes_transferred,
   ACE_Asynch_Write_Stream::Result result (this);
 
   // Call the application handler.
-  this->handler_.handle_write_stream (result);
+  ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
+  if (handler != 0)
+    handler->handle_write_stream (result);
 }
 
 ACE_WIN32_Asynch_Write_Stream_Result::~ACE_WIN32_Asynch_Write_Stream_Result (void)
@@ -820,7 +829,7 @@ ACE_WIN32_Asynch_Write_Stream::write (ACE_Message_Block &message_block,
 
   ACE_WIN32_Asynch_Write_Stream_Result *result = 0;
   ACE_NEW_RETURN (result,
-                  ACE_WIN32_Asynch_Write_Stream_Result (*this->handler_,
+                  ACE_WIN32_Asynch_Write_Stream_Result (this->handler_proxy_,
                                                         this->handle_,
                                                         message_block,
                                                         bytes_to_write,
@@ -909,7 +918,7 @@ ACE_WIN32_Asynch_Write_Stream::writev (ACE_Message_Block &message_block,
 
   ACE_WIN32_Asynch_Write_Stream_Result *result = 0;
   ACE_NEW_RETURN (result,
-                  ACE_WIN32_Asynch_Write_Stream_Result (*this->handler_,
+                  ACE_WIN32_Asynch_Write_Stream_Result (this->handler_proxy_,
                                                         this->handle_,
                                                         message_block,
                                                         bytes_to_write,
@@ -1028,12 +1037,12 @@ ACE_WIN32_Asynch_Write_Stream::shared_write (ACE_WIN32_Asynch_Write_Stream_Resul
 // call to the ACE_WIN32_Asynch_Operation base class.
 
 int
-ACE_WIN32_Asynch_Write_Stream::open (ACE_Handler &handler,
+ACE_WIN32_Asynch_Write_Stream::open (ACE_Handler::Proxy_Ptr &handler_proxy,
                                      ACE_HANDLE handle,
                                      const void *completion_key,
                                      ACE_Proactor *proactor)
 {
-  return ACE_WIN32_Asynch_Operation::open (handler,
+  return ACE_WIN32_Asynch_Operation::open (handler_proxy,
                                            handle,
                                            completion_key,
                                            proactor);
@@ -1052,7 +1061,7 @@ ACE_WIN32_Asynch_Write_Stream::proactor (void) const
 }
 
 ACE_WIN32_Asynch_Read_File_Result::ACE_WIN32_Asynch_Read_File_Result (
-  ACE_Handler &handler,
+  ACE_Handler::Proxy_Ptr &handler_proxy,
   ACE_HANDLE handle,
   ACE_Message_Block &message_block,
   size_t bytes_to_read,
@@ -1066,7 +1075,7 @@ ACE_WIN32_Asynch_Read_File_Result::ACE_WIN32_Asynch_Read_File_Result (
   : ACE_Asynch_Result_Impl (),
     ACE_Asynch_Read_Stream_Result_Impl (),
     ACE_Asynch_Read_File_Result_Impl (),
-    ACE_WIN32_Asynch_Read_Stream_Result (handler,
+    ACE_WIN32_Asynch_Read_Stream_Result (handler_proxy,
                                          handle,
                                          message_block,
                                          bytes_to_read,
@@ -1122,7 +1131,9 @@ ACE_WIN32_Asynch_Read_File_Result::complete (size_t bytes_transferred,
   ACE_Asynch_Read_File::Result result (this);
 
   // Call the application handler.
-  this->handler_.handle_read_file (result);
+  ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
+  if (handler != 0)
+    handler->handle_read_file (result);
 }
 
 ACE_WIN32_Asynch_Read_File_Result::~ACE_WIN32_Asynch_Read_File_Result (void)
@@ -1254,7 +1265,7 @@ ACE_WIN32_Asynch_Read_File::read (ACE_Message_Block &message_block,
 
   ACE_WIN32_Asynch_Read_File_Result *result = 0;
   ACE_NEW_RETURN (result,
-                  ACE_WIN32_Asynch_Read_File_Result (*this->handler_,
+                  ACE_WIN32_Asynch_Read_File_Result (this->handler_proxy_,
                                                      this->handle_,
                                                      message_block,
                                                      bytes_to_read,
@@ -1332,7 +1343,7 @@ ACE_WIN32_Asynch_Read_File::readv (ACE_Message_Block &message_block,
 
   ACE_WIN32_Asynch_Read_File_Result *result = 0;
   ACE_NEW_RETURN (result,
-                  ACE_WIN32_Asynch_Read_File_Result (*this->handler_,
+                  ACE_WIN32_Asynch_Read_File_Result (this->handler_proxy_,
                                                      this->handle_,
                                                      message_block,
                                                      bytes_to_read,
@@ -1428,12 +1439,12 @@ ACE_WIN32_Asynch_Read_File::readv (ACE_Message_Block &message_block,
 // call to the ACE_WIN32_Asynch_Operation base class.
 
 int
-ACE_WIN32_Asynch_Read_File::open (ACE_Handler &handler,
+ACE_WIN32_Asynch_Read_File::open (ACE_Handler::Proxy_Ptr &handler_proxy,
                                   ACE_HANDLE handle,
                                   const void *completion_key,
                                   ACE_Proactor *proactor)
 {
-  return ACE_WIN32_Asynch_Operation::open (handler,
+  return ACE_WIN32_Asynch_Operation::open (handler_proxy,
                                            handle,
                                            completion_key,
                                            proactor);
@@ -1452,7 +1463,7 @@ ACE_WIN32_Asynch_Read_File::proactor (void) const
 }
 
 ACE_WIN32_Asynch_Write_File_Result::ACE_WIN32_Asynch_Write_File_Result (
-  ACE_Handler &handler,
+  ACE_Handler::Proxy_Ptr &handler_proxy,
   ACE_HANDLE handle,
   ACE_Message_Block &message_block,
   size_t bytes_to_write,
@@ -1466,7 +1477,7 @@ ACE_WIN32_Asynch_Write_File_Result::ACE_WIN32_Asynch_Write_File_Result (
   : ACE_Asynch_Result_Impl (),
     ACE_Asynch_Write_Stream_Result_Impl (),
     ACE_Asynch_Write_File_Result_Impl (),
-    ACE_WIN32_Asynch_Write_Stream_Result (handler,
+    ACE_WIN32_Asynch_Write_Stream_Result (handler_proxy,
                                           handle,
                                           message_block,
                                           bytes_to_write,
@@ -1523,7 +1534,9 @@ ACE_WIN32_Asynch_Write_File_Result::complete (size_t bytes_transferred,
   ACE_Asynch_Write_File::Result result (this);
 
   // Call the application handler.
-  this->handler_.handle_write_file (result);
+  ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
+  if (handler != 0)
+    handler->handle_write_file (result);
 }
 
 ACE_WIN32_Asynch_Write_File_Result::~ACE_WIN32_Asynch_Write_File_Result  (void)
@@ -1652,7 +1665,7 @@ ACE_WIN32_Asynch_Write_File::write (ACE_Message_Block &message_block,
 
   ACE_WIN32_Asynch_Write_File_Result *result = 0;
   ACE_NEW_RETURN (result,
-                  ACE_WIN32_Asynch_Write_File_Result (*this->handler_,
+                  ACE_WIN32_Asynch_Write_File_Result (this->handler_proxy_,
                                                       this->handle_,
                                                       message_block,
                                                       bytes_to_write,
@@ -1735,7 +1748,7 @@ ACE_WIN32_Asynch_Write_File::writev (ACE_Message_Block &message_block,
 
   ACE_WIN32_Asynch_Write_File_Result *result = 0;
   ACE_NEW_RETURN (result,
-                  ACE_WIN32_Asynch_Write_File_Result (*this->handler_,
+                  ACE_WIN32_Asynch_Write_File_Result (this->handler_proxy_,
                                                       this->handle_,
                                                       message_block,
                                                       bytes_to_write,
@@ -1833,12 +1846,12 @@ ACE_WIN32_Asynch_Write_File::writev (ACE_Message_Block &message_block,
 // call to the ACE_WIN32_Asynch_Operation base class.
 
 int
-ACE_WIN32_Asynch_Write_File::open (ACE_Handler &handler,
+ACE_WIN32_Asynch_Write_File::open (ACE_Handler::Proxy_Ptr &handler_proxy,
                                    ACE_HANDLE handle,
                                    const void *completion_key,
                                    ACE_Proactor *proactor)
 {
-  return ACE_WIN32_Asynch_Operation::open (handler,
+  return ACE_WIN32_Asynch_Operation::open (handler_proxy,
                                            handle,
                                            completion_key,
                                            proactor);
@@ -1881,7 +1894,7 @@ ACE_WIN32_Asynch_Accept_Result::accept_handle (void) const
 }
 
 ACE_WIN32_Asynch_Accept_Result::ACE_WIN32_Asynch_Accept_Result (
-  ACE_Handler &handler,
+  ACE_Handler::Proxy_Ptr &handler_proxy,
   ACE_HANDLE listen_handle,
   ACE_HANDLE accept_handle,
   ACE_Message_Block &message_block,
@@ -1892,7 +1905,7 @@ ACE_WIN32_Asynch_Accept_Result::ACE_WIN32_Asynch_Accept_Result (
   int signal_number)
   : ACE_Asynch_Result_Impl (),
     ACE_Asynch_Accept_Result_Impl (),
-    ACE_WIN32_Asynch_Result (handler,
+    ACE_WIN32_Asynch_Result (handler_proxy,
                              act,
                              event,
                              0,
@@ -1925,7 +1938,9 @@ ACE_WIN32_Asynch_Accept_Result::complete (size_t bytes_transferred,
   ACE_Asynch_Accept::Result result (this);
 
   // Call the application handler.
-  this->handler_.handle_accept (result);
+  ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
+  if (handler != 0)
+    handler->handle_accept (result);
 }
 
 ACE_WIN32_Asynch_Accept_Result::~ACE_WIN32_Asynch_Accept_Result (void)
@@ -2062,7 +2077,7 @@ ACE_WIN32_Asynch_Accept::accept (ACE_Message_Block &message_block,
   // Common code for both WIN and POSIX.
   ACE_WIN32_Asynch_Accept_Result *result = 0;
   ACE_NEW_RETURN (result,
-                  ACE_WIN32_Asynch_Accept_Result (*this->handler_,
+                  ACE_WIN32_Asynch_Accept_Result (this->handler_proxy_,
                                                   this->handle_,
                                                   accept_handle,
                                                   message_block,
@@ -2136,12 +2151,12 @@ ACE_WIN32_Asynch_Accept::~ACE_WIN32_Asynch_Accept (void)
 // call to the ACE_WIN32_Asynch_Operation base class.
 
 int
-ACE_WIN32_Asynch_Accept::open (ACE_Handler &handler,
+ACE_WIN32_Asynch_Accept::open (ACE_Handler::Proxy_Ptr &handler_proxy,
                                ACE_HANDLE handle,
                                const void *completion_key,
                                ACE_Proactor *proactor)
 {
-  return ACE_WIN32_Asynch_Operation::open (handler,
+  return ACE_WIN32_Asynch_Operation::open (handler_proxy,
                                            handle,
                                            completion_key,
                                            proactor);
@@ -2174,7 +2189,7 @@ void ACE_WIN32_Asynch_Connect_Result::connect_handle ( ACE_HANDLE handle )
 
 
 ACE_WIN32_Asynch_Connect_Result::ACE_WIN32_Asynch_Connect_Result
-            (ACE_Handler &handler,
+            (ACE_Handler::Proxy_Ptr &handler_proxy,
              ACE_HANDLE connect_handle,
              const void* act,
              ACE_HANDLE event,
@@ -2182,8 +2197,9 @@ ACE_WIN32_Asynch_Connect_Result::ACE_WIN32_Asynch_Connect_Result
              int signal_number)
   : ACE_Asynch_Result_Impl (),
     ACE_Asynch_Connect_Result_Impl (),
-    ACE_WIN32_Asynch_Result (handler, act, event, 0, 0, priority, signal_number),
-    connect_handle_ ( connect_handle )
+    ACE_WIN32_Asynch_Result
+      (handler_proxy, act, event, 0, 0, priority, signal_number),
+    connect_handle_ (connect_handle)
 {
   ;
 }
@@ -2204,7 +2220,9 @@ ACE_WIN32_Asynch_Connect_Result::complete (size_t bytes_transferred,
   ACE_Asynch_Connect::Result result (this);
 
   // Call the application handler.
-  this->handler_.handle_connect (result);
+  ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
+  if (handler != 0)
+    handler->handle_connect (result);
 }
 
 ACE_WIN32_Asynch_Connect_Result::~ACE_WIN32_Asynch_Connect_Result (void)
@@ -2318,7 +2336,7 @@ ACE_WIN32_Asynch_Connect::set_handle (ACE_HANDLE)
 }
 
 int
-ACE_WIN32_Asynch_Connect::open (ACE_Handler &handler,
+ACE_WIN32_Asynch_Connect::open (ACE_Handler::Proxy_Ptr &handler_proxy,
                                 ACE_HANDLE,
                                 const void *completion_key,
                                 ACE_Proactor *proactor)
@@ -2336,7 +2354,7 @@ ACE_WIN32_Asynch_Connect::open (ACE_Handler &handler,
                       -1);
 
   //int result =
-  ACE_WIN32_Asynch_Operation::open (handler,
+  ACE_WIN32_Asynch_Operation::open (handler_proxy,
                                     ACE_INVALID_HANDLE,
                                     completion_key,
                                     proactor);
@@ -2374,7 +2392,7 @@ ACE_WIN32_Asynch_Connect::connect (ACE_HANDLE connect_handle,
     // Create future Asynch_Connect_Result
     ACE_WIN32_Asynch_Connect_Result *result = 0;
     ACE_NEW_RETURN (result,
-                    ACE_WIN32_Asynch_Connect_Result (*this->handler_,
+                    ACE_WIN32_Asynch_Connect_Result (this->handler_proxy_,
                                                      connect_handle,
                                                      act,
                                                      this->win32_proactor_->get_handle (),
@@ -2840,7 +2858,7 @@ ACE_WIN32_Asynch_Transmit_File_Result::flags (void) const
 }
 
 ACE_WIN32_Asynch_Transmit_File_Result::ACE_WIN32_Asynch_Transmit_File_Result (
-  ACE_Handler &handler,
+  ACE_Handler::Proxy_Ptr &handler_proxy,
   ACE_HANDLE socket,
   ACE_HANDLE file,
   ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer,
@@ -2855,7 +2873,7 @@ ACE_WIN32_Asynch_Transmit_File_Result::ACE_WIN32_Asynch_Transmit_File_Result (
   int signal_number)
   : ACE_Asynch_Result_Impl (),
     ACE_Asynch_Transmit_File_Result_Impl (),
-    ACE_WIN32_Asynch_Result (handler,
+    ACE_WIN32_Asynch_Result (handler_proxy,
                              act,
                              event,
                              offset,
@@ -2903,7 +2921,9 @@ ACE_WIN32_Asynch_Transmit_File_Result::complete (size_t bytes_transferred,
   ACE_Asynch_Transmit_File::Result result (this);
 
   // Call the application handler.
-  this->handler_.handle_transmit_file (result);
+  ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
+  if (handler != 0)
+    handler->handle_transmit_file (result);
 }
 
 ACE_WIN32_Asynch_Transmit_File_Result::~ACE_WIN32_Asynch_Transmit_File_Result (void)
@@ -3011,7 +3031,7 @@ ACE_WIN32_Asynch_Transmit_File::transmit_file (ACE_HANDLE file,
 
   ACE_WIN32_Asynch_Transmit_File_Result *result = 0;
   ACE_NEW_RETURN (result,
-                  ACE_WIN32_Asynch_Transmit_File_Result (*this->handler_,
+                  ACE_WIN32_Asynch_Transmit_File_Result (this->handler_proxy_,
                                                          this->handle_,
                                                          file,
                                                          header_and_trailer,
@@ -3090,12 +3110,12 @@ ACE_WIN32_Asynch_Transmit_File::~ACE_WIN32_Asynch_Transmit_File (void)
 // call to the ACE_WIN32_Asynch_Operation base class.
 
 int
-ACE_WIN32_Asynch_Transmit_File::open (ACE_Handler &handler,
+ACE_WIN32_Asynch_Transmit_File::open (ACE_Handler::Proxy_Ptr &handler_proxy,
                                       ACE_HANDLE handle,
                                       const void *completion_key,
                                       ACE_Proactor *proactor)
 {
-  return ACE_WIN32_Asynch_Operation::open (handler,
+  return ACE_WIN32_Asynch_Operation::open (handler_proxy,
                                            handle,
                                            completion_key,
                                            proactor);
@@ -3228,7 +3248,7 @@ ACE_WIN32_Asynch_Read_Dgram_Result::post_completion (ACE_Proactor_Impl *proactor
 }
 
 ACE_WIN32_Asynch_Read_Dgram_Result::ACE_WIN32_Asynch_Read_Dgram_Result (
-  ACE_Handler &handler,
+  ACE_Handler::Proxy_Ptr &handler_proxy,
   ACE_HANDLE handle,
   ACE_Message_Block *message_block,
   size_t bytes_to_read,
@@ -3240,7 +3260,7 @@ ACE_WIN32_Asynch_Read_Dgram_Result::ACE_WIN32_Asynch_Read_Dgram_Result (
   int signal_number)
   : ACE_Asynch_Result_Impl (),
     ACE_Asynch_Read_Dgram_Result_Impl(),
-    ACE_WIN32_Asynch_Result (handler, act, event, 0, 0, priority, signal_number),
+    ACE_WIN32_Asynch_Result (handler_proxy, act, event, 0, 0, priority, signal_number),
     bytes_to_read_ (bytes_to_read),
     message_block_ (message_block),
     remote_address_ (0),
@@ -3290,7 +3310,9 @@ ACE_WIN32_Asynch_Read_Dgram_Result::complete (size_t bytes_transferred,
   ACE_Asynch_Read_Dgram::Result result (this);
 
   // Call the application handler.
-  this->handler_.handle_read_dgram (result);
+  ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
+  if (handler != 0)
+    handler->handle_read_dgram (result);
 }
 
 ACE_WIN32_Asynch_Read_Dgram_Result::~ACE_WIN32_Asynch_Read_Dgram_Result (void)
@@ -3370,7 +3392,7 @@ ACE_WIN32_Asynch_Read_Dgram::recv (ACE_Message_Block *message_block,
   // Create the Asynch_Result.
   ACE_WIN32_Asynch_Read_Dgram_Result *result = 0;
   ACE_NEW_RETURN (result,
-                  ACE_WIN32_Asynch_Read_Dgram_Result (*this->handler_,
+                  ACE_WIN32_Asynch_Read_Dgram_Result (this->handler_proxy_,
                                                       this->handle_,
                                                       message_block,
                                                       bytes_to_read,
@@ -3436,12 +3458,12 @@ ACE_WIN32_Asynch_Read_Dgram::recv (ACE_Message_Block *message_block,
 }
 
 int
-ACE_WIN32_Asynch_Read_Dgram::open (ACE_Handler &handler,
+ACE_WIN32_Asynch_Read_Dgram::open (ACE_Handler::Proxy_Ptr &handler_proxy,
                                    ACE_HANDLE handle,
                                    const void *completion_key,
                                    ACE_Proactor *proactor)
 {
-  return ACE_WIN32_Asynch_Operation::open (handler,
+  return ACE_WIN32_Asynch_Operation::open (handler_proxy,
                                            handle,
                                            completion_key,
                                            proactor);
@@ -3559,7 +3581,7 @@ ACE_WIN32_Asynch_Write_Dgram_Result::post_completion (ACE_Proactor_Impl *proacto
 }
 
 ACE_WIN32_Asynch_Write_Dgram_Result::ACE_WIN32_Asynch_Write_Dgram_Result (
-  ACE_Handler &handler,
+  ACE_Handler::Proxy_Ptr &handler_proxy,
   ACE_HANDLE handle,
   ACE_Message_Block *message_block,
   size_t bytes_to_write,
@@ -3570,7 +3592,7 @@ ACE_WIN32_Asynch_Write_Dgram_Result::ACE_WIN32_Asynch_Write_Dgram_Result (
   int signal_number)
   : ACE_Asynch_Result_Impl (),
     ACE_Asynch_Write_Dgram_Result_Impl(),
-    ACE_WIN32_Asynch_Result (handler,
+    ACE_WIN32_Asynch_Result (handler_proxy,
                              act,
                              event,
                              0,
@@ -3615,7 +3637,9 @@ ACE_WIN32_Asynch_Write_Dgram_Result::complete (size_t bytes_transferred,
   ACE_Asynch_Write_Dgram::Result result (this);
 
   // Call the application handler.
-  this->handler_.handle_write_dgram (result);
+  ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
+  if (handler != 0)
+    handler->handle_write_dgram (result);
 }
 
 ACE_WIN32_Asynch_Write_Dgram_Result::~ACE_WIN32_Asynch_Write_Dgram_Result (void)
@@ -3695,7 +3719,7 @@ ACE_WIN32_Asynch_Write_Dgram::send (ACE_Message_Block *message_block,
   // Create the Asynch_Result.
   ACE_WIN32_Asynch_Write_Dgram_Result *result = 0;
   ACE_NEW_RETURN (result,
-                  ACE_WIN32_Asynch_Write_Dgram_Result (*this->handler_,
+                  ACE_WIN32_Asynch_Write_Dgram_Result (this->handler_proxy_,
                                                        this->handle_,
                                                        message_block,
                                                        bytes_to_write,
@@ -3763,12 +3787,12 @@ ACE_WIN32_Asynch_Write_Dgram::send (ACE_Message_Block *message_block,
 }
 
 int
-ACE_WIN32_Asynch_Write_Dgram::open (ACE_Handler &handler,
+ACE_WIN32_Asynch_Write_Dgram::open (ACE_Handler::Proxy_Ptr &handler_proxy,
                                     ACE_HANDLE handle,
                                     const void *completion_key,
                                     ACE_Proactor *proactor)
 {
-  return ACE_WIN32_Asynch_Operation::open (handler,
+  return ACE_WIN32_Asynch_Operation::open (handler_proxy,
                                            handle,
                                            completion_key,
                                            proactor);
diff --git a/ace/WIN32_Asynch_IO.h b/ace/WIN32_Asynch_IO.h
index b9d875164b1..c9d26ff00a6 100644
--- a/ace/WIN32_Asynch_IO.h
+++ b/ace/WIN32_Asynch_IO.h
@@ -116,7 +116,7 @@ public:
 
 protected:
   /// Constructor.
-  ACE_WIN32_Asynch_Result (ACE_Handler &handler,
+  ACE_WIN32_Asynch_Result (ACE_Handler::Proxy_Ptr &handler_proxy,
                            const void* act,
                            ACE_HANDLE event,
                            u_long offset,
@@ -124,8 +124,8 @@ protected:
                            int priority,
                            int signal_number = 0);
 
-  /// Handler that will be called back.
-  ACE_Handler &handler_;
+  /// Proxy for the ACE_Handler that will be called back.
+  ACE_Handler::Proxy_Ptr &handler_proxy_;
 
   /// ACT for this operation.
   const void *act_;
@@ -159,7 +159,7 @@ public:
    * <ACE_Handler::handle> will be called on the <handler> to get the
    * correct handle.
    */
-  int open (ACE_Handler &handler,
+  int open (ACE_Handler::Proxy_Ptr &handler_proxy,
             ACE_HANDLE handle,
             const void *completion_key,
             ACE_Proactor *proactor);
@@ -190,7 +190,7 @@ protected:
   ACE_Proactor *proactor_;
 
   /// Handler that will receive the callback.
-  ACE_Handler *handler_;
+  ACE_Handler::Proxy_Ptr handler_proxy_;
 
   /// I/O handle used for reading.
   ACE_HANDLE handle_;
@@ -269,7 +269,7 @@ public:
 protected:
   /// Constructor is protected since creation is limited to
   /// ACE_Asynch_Read_Stream factory.
-  ACE_WIN32_Asynch_Read_Stream_Result (ACE_Handler &handler,
+  ACE_WIN32_Asynch_Read_Stream_Result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                        ACE_HANDLE handle,
                                        ACE_Message_Block &message_block,
                                        size_t bytes_to_read,
@@ -352,7 +352,7 @@ public:
    * <ACE_Handler::handle> will be called on the <handler> to get the
    * correct handle.
    */
-  int open (ACE_Handler &handler,
+  int open (ACE_Handler::Proxy_Ptr &handler_proxy,
             ACE_HANDLE handle,
             const void *completion_key,
             ACE_Proactor *proactor);
@@ -446,7 +446,7 @@ public:
 protected:
   /// Constructor is protected since creation is limited to
   /// ACE_Asynch_Write_Stream factory.
-  ACE_WIN32_Asynch_Write_Stream_Result (ACE_Handler &handler,
+  ACE_WIN32_Asynch_Write_Stream_Result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                         ACE_HANDLE handle,
                                         ACE_Message_Block &message_block,
                                         size_t bytes_to_write,
@@ -531,7 +531,7 @@ public:
    * <ACE_Handler::handle> will be called on the <handler> to get the
    * correct handle.
    */
-  int open (ACE_Handler &handler,
+  int open (ACE_Handler::Proxy_Ptr &handler_proxy,
             ACE_HANDLE handle,
             const void *completion_key,
             ACE_Proactor *proactor);
@@ -628,7 +628,7 @@ public:
 protected:
   /// Constructor is protected since creation is limited to
   /// ACE_Asynch_Read_File factory.
-  ACE_WIN32_Asynch_Read_File_Result (ACE_Handler &handler,
+  ACE_WIN32_Asynch_Read_File_Result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                      ACE_HANDLE handle,
                                      ACE_Message_Block &message_block,
                                      size_t bytes_to_read,
@@ -715,7 +715,7 @@ public:
    * <ACE_Handler::handle> will be called on the <handler> to get the
    * correct handle.
    */
-  int open (ACE_Handler &handler,
+  int open (ACE_Handler::Proxy_Ptr &handler_proxy,
             ACE_HANDLE handle,
             const void *completion_key,
             ACE_Proactor *proactor);
@@ -839,7 +839,7 @@ public:
 protected:
   /// Constructor is protected since creation is limited to
   /// ACE_Asynch_Write_File factory.
-  ACE_WIN32_Asynch_Write_File_Result (ACE_Handler &handler,
+  ACE_WIN32_Asynch_Write_File_Result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                       ACE_HANDLE handle,
                                       ACE_Message_Block &message_block,
                                       size_t bytes_to_write,
@@ -921,7 +921,7 @@ public:
    * <ACE_Handler::handle> will be called on the <handler> to get the
    * correct handle.
    */
-  int open (ACE_Handler &handler,
+  int open (ACE_Handler::Proxy_Ptr &handler_proxy,
             ACE_HANDLE handle,
             const void *completion_key,
             ACE_Proactor *proactor);
@@ -1036,7 +1036,7 @@ public:
 protected:
   /// Constructor is protected since creation is limited to
   /// ACE_Asynch_Accept factory.
-  ACE_WIN32_Asynch_Accept_Result (ACE_Handler &handler,
+  ACE_WIN32_Asynch_Accept_Result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                   ACE_HANDLE listen_handle,
                                   ACE_HANDLE accept_handle,
                                   ACE_Message_Block &message_block,
@@ -1118,7 +1118,7 @@ public:
    * <ACE_Handler::handle> will be called on the <handler> to get the
    * correct handle.
    */
-  int open (ACE_Handler &handler,
+  int open (ACE_Handler::Proxy_Ptr &handler_proxy,
             ACE_HANDLE handle,
             const void *completion_key,
             ACE_Proactor *proactor);
@@ -1202,7 +1202,7 @@ public:
 protected:
   /// Constructor is protected since creation is limited to
   /// ACE_Asynch_Connect factory.
-  ACE_WIN32_Asynch_Connect_Result (ACE_Handler &handler,
+  ACE_WIN32_Asynch_Connect_Result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                    ACE_HANDLE  connect_handle,
                                    const void* act,
                                    ACE_HANDLE  event,
@@ -1246,7 +1246,7 @@ public:
    * this call to that method. We have put this here to avoid the
    * compiler warnings.
    */
-  int open (ACE_Handler &handler,
+  int open (ACE_Handler::Proxy_Ptr &handler_proxy,
             ACE_HANDLE handle,
             const void *completion_key,
             ACE_Proactor *proactor = 0);
@@ -1440,7 +1440,7 @@ public:
 protected:
   /// Constructor is protected since creation is limited to
   /// ACE_Asynch_Transmit_File factory.
-  ACE_WIN32_Asynch_Transmit_File_Result (ACE_Handler &handler,
+  ACE_WIN32_Asynch_Transmit_File_Result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                          ACE_HANDLE socket,
                                          ACE_HANDLE file,
                                          ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer,
@@ -1545,7 +1545,7 @@ public:
    * <ACE_Handler::handle> will be called on the <handler> to get the
    * correct handle.
    */
-  int open (ACE_Handler &handler,
+  int open (ACE_Handler::Proxy_Ptr &handler_proxy,
             ACE_HANDLE handle,
             const void *completion_key,
             ACE_Proactor *proactor);
@@ -1639,7 +1639,7 @@ public:
 protected:
   /// Constructor is protected since creation is limited to
   /// ACE_Asynch_Read_Dgram factory.
-  ACE_WIN32_Asynch_Read_Dgram_Result (ACE_Handler &handler,
+  ACE_WIN32_Asynch_Read_Dgram_Result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                       ACE_HANDLE handle,
                                       ACE_Message_Block *message_block,
                                       size_t bytes_to_read,
@@ -1735,7 +1735,7 @@ public:
    * <ACE_Handler::handle> will be called on the <handler> to get the
    * correct handle.
    */
-  int open (ACE_Handler &handler,
+  int open (ACE_Handler::Proxy_Ptr &handler_proxy,
             ACE_HANDLE handle,
             const void *completion_key,
             ACE_Proactor *proactor);
@@ -1828,7 +1828,7 @@ public:
 protected:
   /// Constructor is protected since creation is limited to
   /// ACE_Asynch_Write_Stream factory.
-  ACE_WIN32_Asynch_Write_Dgram_Result (ACE_Handler &handler,
+  ACE_WIN32_Asynch_Write_Dgram_Result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                        ACE_HANDLE handle,
                                        ACE_Message_Block *message_block,
                                        size_t bytes_to_write,
@@ -1920,7 +1920,7 @@ public:
    * <ACE_Handler::handle> will be called on the <handler> to get the
    * correct handle.
    */
-  int open (ACE_Handler &handler,
+  int open (ACE_Handler::Proxy_Ptr &handler_proxy,
             ACE_HANDLE handle,
             const void *completion_key,
             ACE_Proactor *proactor);
diff --git a/ace/WIN32_Proactor.cpp b/ace/WIN32_Proactor.cpp
index 6905c0d7912..f4e9a3283ff 100644
--- a/ace/WIN32_Proactor.cpp
+++ b/ace/WIN32_Proactor.cpp
@@ -24,7 +24,7 @@ class ACE_Export ACE_WIN32_Wakeup_Completion : public ACE_WIN32_Asynch_Result
 
 public:
   /// Constructor.
-  ACE_WIN32_Wakeup_Completion (ACE_Handler &handler,
+  ACE_WIN32_Wakeup_Completion (ACE_Handler::Proxy_Ptr &handler_proxy,
                                const void *act = 0,
                                ACE_HANDLE event = ACE_INVALID_HANDLE,
                                int priority = 0,
@@ -241,18 +241,19 @@ ACE_WIN32_Proactor::create_asynch_transmit_file (void)
 }
 
 ACE_Asynch_Read_Stream_Result_Impl *
-ACE_WIN32_Proactor::create_asynch_read_stream_result (ACE_Handler &handler,
-                                                      ACE_HANDLE handle,
-                                                      ACE_Message_Block &message_block,
-                                                      size_t bytes_to_read,
-                                                      const void* act,
-                                                      ACE_HANDLE event,
-                                                      int priority,
-                                                      int signal_number)
+ACE_WIN32_Proactor::create_asynch_read_stream_result
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   ACE_HANDLE handle,
+   ACE_Message_Block &message_block,
+   size_t bytes_to_read,
+   const void* act,
+   ACE_HANDLE event,
+   int priority,
+   int signal_number)
 {
   ACE_Asynch_Read_Stream_Result_Impl *implementation = 0;
   ACE_NEW_RETURN (implementation,
-                  ACE_WIN32_Asynch_Read_Stream_Result (handler,
+                  ACE_WIN32_Asynch_Read_Stream_Result (handler_proxy,
                                                        handle,
                                                        message_block,
                                                        bytes_to_read,
@@ -265,18 +266,19 @@ ACE_WIN32_Proactor::create_asynch_read_stream_result (ACE_Handler &handler,
 }
 
 ACE_Asynch_Write_Stream_Result_Impl *
-ACE_WIN32_Proactor::create_asynch_write_stream_result (ACE_Handler &handler,
-                                                       ACE_HANDLE handle,
-                                                       ACE_Message_Block &message_block,
-                                                       size_t bytes_to_write,
-                                                       const void* act,
-                                                       ACE_HANDLE event,
-                                                       int priority,
-                                                       int signal_number)
+ACE_WIN32_Proactor::create_asynch_write_stream_result
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   ACE_HANDLE handle,
+   ACE_Message_Block &message_block,
+   size_t bytes_to_write,
+   const void* act,
+   ACE_HANDLE event,
+   int priority,
+   int signal_number)
 {
   ACE_Asynch_Write_Stream_Result_Impl *implementation = 0;
   ACE_NEW_RETURN (implementation,
-                  ACE_WIN32_Asynch_Write_Stream_Result (handler,
+                  ACE_WIN32_Asynch_Write_Stream_Result (handler_proxy,
                                                         handle,
                                                         message_block,
                                                         bytes_to_write,
@@ -289,20 +291,21 @@ ACE_WIN32_Proactor::create_asynch_write_stream_result (ACE_Handler &handler,
 }
 
 ACE_Asynch_Read_File_Result_Impl *
-ACE_WIN32_Proactor::create_asynch_read_file_result (ACE_Handler &handler,
-                                                    ACE_HANDLE handle,
-                                                    ACE_Message_Block &message_block,
-                                                    size_t bytes_to_read,
-                                                    const void* act,
-                                                    u_long offset,
-                                                    u_long offset_high,
-                                                    ACE_HANDLE event,
-                                                    int priority,
-                                                    int signal_number)
+ACE_WIN32_Proactor::create_asynch_read_file_result
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   ACE_HANDLE handle,
+   ACE_Message_Block &message_block,
+   size_t bytes_to_read,
+   const void* act,
+   u_long offset,
+   u_long offset_high,
+   ACE_HANDLE event,
+   int priority,
+   int signal_number)
 {
   ACE_Asynch_Read_File_Result_Impl *implementation = 0;
   ACE_NEW_RETURN (implementation,
-                  ACE_WIN32_Asynch_Read_File_Result (handler,
+                  ACE_WIN32_Asynch_Read_File_Result (handler_proxy,
                                                      handle,
                                                      message_block,
                                                      bytes_to_read,
@@ -317,20 +320,21 @@ ACE_WIN32_Proactor::create_asynch_read_file_result (ACE_Handler &handler,
 }
 
 ACE_Asynch_Write_File_Result_Impl *
-ACE_WIN32_Proactor::create_asynch_write_file_result (ACE_Handler &handler,
-                                                     ACE_HANDLE handle,
-                                                     ACE_Message_Block &message_block,
-                                                     size_t bytes_to_write,
-                                                     const void* act,
-                                                     u_long offset,
-                                                     u_long offset_high,
-                                                     ACE_HANDLE event,
-                                                     int priority,
-                                                     int signal_number)
+ACE_WIN32_Proactor::create_asynch_write_file_result
+ (ACE_Handler::Proxy_Ptr &handler_proxy,
+  ACE_HANDLE handle,
+  ACE_Message_Block &message_block,
+  size_t bytes_to_write,
+  const void* act,
+  u_long offset,
+  u_long offset_high,
+  ACE_HANDLE event,
+  int priority,
+  int signal_number)
 {
   ACE_Asynch_Write_File_Result_Impl *implementation = 0;
   ACE_NEW_RETURN (implementation,
-                  ACE_WIN32_Asynch_Write_File_Result (handler,
+                  ACE_WIN32_Asynch_Write_File_Result (handler_proxy,
                                                       handle,
                                                       message_block,
                                                       bytes_to_write,
@@ -345,20 +349,21 @@ ACE_WIN32_Proactor::create_asynch_write_file_result (ACE_Handler &handler,
 }
 
 ACE_Asynch_Read_Dgram_Result_Impl *
-ACE_WIN32_Proactor::create_asynch_read_dgram_result (ACE_Handler &handler,
-                                                     ACE_HANDLE handle,
-                                                     ACE_Message_Block *message_block,
-                                                     size_t bytes_to_read,
-                                                     int flags,
-                                                     int protocol_family,
-                                                     const void* act,
-                                                     ACE_HANDLE event ,
-                                                     int priority ,
-                                                     int signal_number)
+ACE_WIN32_Proactor::create_asynch_read_dgram_result
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   ACE_HANDLE handle,
+   ACE_Message_Block *message_block,
+   size_t bytes_to_read,
+   int flags,
+   int protocol_family,
+   const void* act,
+   ACE_HANDLE event,
+   int priority,
+   int signal_number)
 {
   ACE_Asynch_Read_Dgram_Result_Impl *implementation = 0;
   ACE_NEW_RETURN (implementation,
-                  ACE_WIN32_Asynch_Read_Dgram_Result (handler,
+                  ACE_WIN32_Asynch_Read_Dgram_Result (handler_proxy,
                                                       handle,
                                                       message_block,
                                                       bytes_to_read,
@@ -373,19 +378,20 @@ ACE_WIN32_Proactor::create_asynch_read_dgram_result (ACE_Handler &handler,
 }
 
 ACE_Asynch_Write_Dgram_Result_Impl *
-ACE_WIN32_Proactor::create_asynch_write_dgram_result (ACE_Handler &handler,
-                                                      ACE_HANDLE handle,
-                                                      ACE_Message_Block *message_block,
-                                                      size_t bytes_to_read,
-                                                      int flags,
-                                                      const void* act,
-                                                      ACE_HANDLE event ,
-                                                      int priority ,
-                                                      int signal_number)
+ACE_WIN32_Proactor::create_asynch_write_dgram_result
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   ACE_HANDLE handle,
+   ACE_Message_Block *message_block,
+   size_t bytes_to_read,
+   int flags,
+   const void* act,
+   ACE_HANDLE event,
+   int priority,
+   int signal_number)
 {
   ACE_Asynch_Write_Dgram_Result_Impl *implementation = 0;
   ACE_NEW_RETURN (implementation,
-                  ACE_WIN32_Asynch_Write_Dgram_Result(handler,
+                  ACE_WIN32_Asynch_Write_Dgram_Result(handler_proxy,
                                                       handle,
                                                       message_block,
                                                       bytes_to_read,
@@ -399,19 +405,20 @@ ACE_WIN32_Proactor::create_asynch_write_dgram_result (ACE_Handler &handler,
 }
 
 ACE_Asynch_Accept_Result_Impl *
-ACE_WIN32_Proactor::create_asynch_accept_result (ACE_Handler &handler,
-                                                 ACE_HANDLE listen_handle,
-                                                 ACE_HANDLE accept_handle,
-                                                 ACE_Message_Block &message_block,
-                                                 size_t bytes_to_read,
-                                                 const void* act,
-                                                 ACE_HANDLE event,
-                                                 int priority,
-                                                 int signal_number)
+ACE_WIN32_Proactor::create_asynch_accept_result
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   ACE_HANDLE listen_handle,
+   ACE_HANDLE accept_handle,
+   ACE_Message_Block &message_block,
+   size_t bytes_to_read,
+   const void* act,
+   ACE_HANDLE event,
+   int priority,
+   int signal_number)
 {
   ACE_Asynch_Accept_Result_Impl *implementation = 0;
   ACE_NEW_RETURN (implementation,
-                  ACE_WIN32_Asynch_Accept_Result (handler,
+                  ACE_WIN32_Asynch_Accept_Result (handler_proxy,
                                                   listen_handle,
                                                   accept_handle,
                                                   message_block,
@@ -425,16 +432,17 @@ ACE_WIN32_Proactor::create_asynch_accept_result (ACE_Handler &handler,
 }
 
 ACE_Asynch_Connect_Result_Impl *
-ACE_WIN32_Proactor::create_asynch_connect_result (ACE_Handler & handler,
-                                                  ACE_HANDLE connect_handle,
-                                                  const void *act,
-                                                  ACE_HANDLE event,
-                                                  int priority ,
-                                                  int signal_number)
+ACE_WIN32_Proactor::create_asynch_connect_result
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   ACE_HANDLE connect_handle,
+   const void *act,
+   ACE_HANDLE event,
+   int priority,
+   int signal_number)
 {
   ACE_Asynch_Connect_Result_Impl *implementation = 0;
   ACE_NEW_RETURN (implementation,
-                  ACE_WIN32_Asynch_Connect_Result (handler,
+                  ACE_WIN32_Asynch_Connect_Result (handler_proxy,
                                                    connect_handle,
                                                    act,
                                                    event,
@@ -445,23 +453,24 @@ ACE_WIN32_Proactor::create_asynch_connect_result (ACE_Handler & handler,
 }
 
 ACE_Asynch_Transmit_File_Result_Impl *
-ACE_WIN32_Proactor::create_asynch_transmit_file_result (ACE_Handler &handler,
-                                                        ACE_HANDLE socket,
-                                                        ACE_HANDLE file,
-                                                        ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer,
-                                                        size_t bytes_to_write,
-                                                        u_long offset,
-                                                        u_long offset_high,
-                                                        size_t bytes_per_send,
-                                                        u_long flags,
-                                                        const void *act,
-                                                        ACE_HANDLE event,
-                                                        int priority,
-                                                        int signal_number)
+ACE_WIN32_Proactor::create_asynch_transmit_file_result
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   ACE_HANDLE socket,
+   ACE_HANDLE file,
+   ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer,
+   size_t bytes_to_write,
+   u_long offset,
+   u_long offset_high,
+   size_t bytes_per_send,
+   u_long flags,
+   const void *act,
+   ACE_HANDLE event,
+   int priority,
+   int signal_number)
 {
   ACE_Asynch_Transmit_File_Result_Impl *implementation = 0;
   ACE_NEW_RETURN (implementation,
-                  ACE_WIN32_Asynch_Transmit_File_Result (handler,
+                  ACE_WIN32_Asynch_Transmit_File_Result (handler_proxy,
                                                          socket,
                                                          file,
                                                          header_and_trailer,
@@ -479,7 +488,7 @@ ACE_WIN32_Proactor::create_asynch_transmit_file_result (ACE_Handler &handler,
 }
 
 ACE_Asynch_Result_Impl *
-ACE_WIN32_Proactor::create_asynch_timer (ACE_Handler &handler,
+ACE_WIN32_Proactor::create_asynch_timer (ACE_Handler::Proxy_Ptr &handler_proxy,
                                          const void *act,
                                          const ACE_Time_Value &tv,
                                          ACE_HANDLE event,
@@ -488,7 +497,7 @@ ACE_WIN32_Proactor::create_asynch_timer (ACE_Handler &handler,
 {
   ACE_Asynch_Result_Impl *implementation = 0;
   ACE_NEW_RETURN (implementation,
-                  ACE_WIN32_Asynch_Timer (handler,
+                  ACE_WIN32_Asynch_Timer (handler_proxy,
                                           act,
                                           tv,
                                           event,
@@ -717,9 +726,10 @@ ACE_WIN32_Proactor::post_wakeup_completions (int how_many)
 
   for (ssize_t ci = 0; ci < how_many; ci++)
     {
-      ACE_NEW_RETURN (wakeup_completion,
-                      ACE_WIN32_Wakeup_Completion (this->wakeup_handler_),
-                      -1);
+      ACE_NEW_RETURN
+        (wakeup_completion,
+         ACE_WIN32_Wakeup_Completion (this->wakeup_handler_.proxy ()),
+         -1);
 
       if (wakeup_completion->post_completion (this) == -1)
         return -1;
@@ -752,40 +762,40 @@ ACE_WIN32_Proactor::number_of_threads (size_t threads)
   this->number_of_threads_ = ACE_static_cast (DWORD, threads);
 }
 
-ACE_WIN32_Asynch_Timer::ACE_WIN32_Asynch_Timer (ACE_Handler &handler,
-                                                const void *act,
-                                                const ACE_Time_Value &tv,
-                                                ACE_HANDLE event,
-                                                int priority,
-                                                int signal_number)
+ACE_WIN32_Asynch_Timer::ACE_WIN32_Asynch_Timer
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   const void *act,
+   const ACE_Time_Value &tv,
+   ACE_HANDLE event,
+   int priority,
+   int signal_number)
   : ACE_Asynch_Result_Impl (),
-    ACE_WIN32_Asynch_Result (handler, act, event, 0, 0, priority,
+    ACE_WIN32_Asynch_Result (handler_proxy, act, event, 0, 0, priority,
                              signal_number),
     time_ (tv)
 {
 }
 
 void
-ACE_WIN32_Asynch_Timer::complete (size_t bytes_transferred,
-                                  int success,
-                                  const void *completion_key,
-                                  u_long error)
-{
-  ACE_UNUSED_ARG (error);
-  ACE_UNUSED_ARG (completion_key);
-  ACE_UNUSED_ARG (success);
-  ACE_UNUSED_ARG (bytes_transferred);
-
-  this->handler_.handle_time_out (this->time_, this->act ());
-}
-
-ACE_WIN32_Wakeup_Completion::ACE_WIN32_Wakeup_Completion (ACE_Handler &handler,
-                                                          const void *act,
-                                                          ACE_HANDLE event,
-                                                          int priority,
-                                                          int signal_number)
+ACE_WIN32_Asynch_Timer::complete (size_t,
+                                  int,
+                                  const void *,
+                                  u_long)
+{
+  ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
+  if (handler != 0)
+    handler->handle_time_out (this->time_, this->act ());
+}
+
+ACE_WIN32_Wakeup_Completion::ACE_WIN32_Wakeup_Completion
+  (ACE_Handler::Proxy_Ptr &handler_proxy,
+   const void *act,
+   ACE_HANDLE event,
+   int priority,
+   int signal_number)
   : ACE_Asynch_Result_Impl (),
-    ACE_WIN32_Asynch_Result (handler, act, event, 0, 0, priority, signal_number)
+    ACE_WIN32_Asynch_Result
+     (handler_proxy, act, event, 0, 0, priority, signal_number)
 {
 }
 
@@ -799,7 +809,9 @@ ACE_WIN32_Wakeup_Completion::complete (size_t       /* bytes_transferred */,
                                        const void * /* completion_key */,
                                        u_long       /*  error */)
 {
-  this->handler_.handle_wakeup ();
+  ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
+  if (handler != 0)
+    handler->handle_wakeup ();
 }
 
 #endif /* ACE_WIN32 */
diff --git a/ace/WIN32_Proactor.h b/ace/WIN32_Proactor.h
index 0afec3db432..57bfe943e5f 100644
--- a/ace/WIN32_Proactor.h
+++ b/ace/WIN32_Proactor.h
@@ -121,7 +121,7 @@ public:
   // Methods used to create Asynch_IO_Result objects. We create the right
   // objects here in these methods.
 
-  virtual ACE_Asynch_Read_Stream_Result_Impl *create_asynch_read_stream_result (ACE_Handler &handler,
+  virtual ACE_Asynch_Read_Stream_Result_Impl *create_asynch_read_stream_result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                                                                 ACE_HANDLE handle,
                                                                                 ACE_Message_Block &message_block,
                                                                                 size_t bytes_to_read,
@@ -130,7 +130,7 @@ public:
                                                                                 int priority,
                                                                                 int signal_number = 0);
 
-  virtual ACE_Asynch_Write_Stream_Result_Impl *create_asynch_write_stream_result (ACE_Handler &handler,
+  virtual ACE_Asynch_Write_Stream_Result_Impl *create_asynch_write_stream_result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                                                                   ACE_HANDLE handle,
                                                                                   ACE_Message_Block &message_block,
                                                                                   size_t bytes_to_write,
@@ -139,7 +139,7 @@ public:
                                                                                   int priority,
                                                                                   int signal_number = 0);
 
-  virtual ACE_Asynch_Read_File_Result_Impl *create_asynch_read_file_result (ACE_Handler &handler,
+  virtual ACE_Asynch_Read_File_Result_Impl *create_asynch_read_file_result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                                                             ACE_HANDLE handle,
                                                                             ACE_Message_Block &message_block,
                                                                             size_t bytes_to_read,
@@ -150,7 +150,7 @@ public:
                                                                             int priority,
                                                                             int signal_number = 0);
 
-  virtual ACE_Asynch_Write_File_Result_Impl *create_asynch_write_file_result (ACE_Handler &handler,
+  virtual ACE_Asynch_Write_File_Result_Impl *create_asynch_write_file_result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                                                               ACE_HANDLE handle,
                                                                               ACE_Message_Block &message_block,
                                                                               size_t bytes_to_write,
@@ -162,7 +162,7 @@ public:
                                                                               int signal_number = 0);
 
   /// Create the correct implementation class for ACE_Asynch_Read_Dgram::Result.
-  virtual ACE_Asynch_Read_Dgram_Result_Impl *create_asynch_read_dgram_result (ACE_Handler &handler,
+  virtual ACE_Asynch_Read_Dgram_Result_Impl *create_asynch_read_dgram_result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                                                               ACE_HANDLE handle,
                                                                               ACE_Message_Block *message_block,
                                                                               size_t bytes_to_read,
@@ -174,7 +174,7 @@ public:
                                                                               int signal_number = 0);
 
   /// Create the correct implementation class for ACE_Asynch_Write_Dgram::Result.
-  virtual ACE_Asynch_Write_Dgram_Result_Impl *create_asynch_write_dgram_result (ACE_Handler &handler,
+  virtual ACE_Asynch_Write_Dgram_Result_Impl *create_asynch_write_dgram_result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                                                                 ACE_HANDLE handle,
                                                                                 ACE_Message_Block *message_block,
                                                                                 size_t bytes_to_write,
@@ -184,7 +184,7 @@ public:
                                                                                 int priority,
                                                                                 int signal_number = 0);
 
-  virtual ACE_Asynch_Accept_Result_Impl *create_asynch_accept_result (ACE_Handler &handler,
+  virtual ACE_Asynch_Accept_Result_Impl *create_asynch_accept_result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                                                       ACE_HANDLE listen_handle,
                                                                       ACE_HANDLE accept_handle,
                                                                       ACE_Message_Block &message_block,
@@ -194,7 +194,7 @@ public:
                                                                       int priority,
                                                                       int signal_number = 0);
 
-  virtual ACE_Asynch_Connect_Result_Impl *create_asynch_connect_result (ACE_Handler & handler,
+  virtual ACE_Asynch_Connect_Result_Impl *create_asynch_connect_result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                                                         ACE_HANDLE connect_handle,
                                                                         const void *act,
                                                                         ACE_HANDLE event,
@@ -202,7 +202,7 @@ public:
                                                                         int signal_number = 0);
 
 
-  virtual ACE_Asynch_Transmit_File_Result_Impl *create_asynch_transmit_file_result (ACE_Handler &handler,
+  virtual ACE_Asynch_Transmit_File_Result_Impl *create_asynch_transmit_file_result (ACE_Handler::Proxy_Ptr &handler_proxy,
                                                                                     ACE_HANDLE socket,
                                                                                     ACE_HANDLE file,
                                                                                     ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer,
@@ -218,7 +218,7 @@ public:
 
   /// Create a timer result object which can be used with the Timer
   /// mechanism of the Proactor.
-  virtual ACE_Asynch_Result_Impl *create_asynch_timer (ACE_Handler &handler,
+  virtual ACE_Asynch_Result_Impl *create_asynch_timer (ACE_Handler::Proxy_Ptr &handler_proxy,
                                                        const void *act,
                                                        const ACE_Time_Value &tv,
                                                        ACE_HANDLE event,
@@ -299,7 +299,7 @@ class ACE_Export ACE_WIN32_Asynch_Timer : public ACE_WIN32_Asynch_Result
 
 protected:
   /// Constructor.
-  ACE_WIN32_Asynch_Timer (ACE_Handler &handler,
+  ACE_WIN32_Asynch_Timer (ACE_Handler::Proxy_Ptr &handler_proxy,
                           const void *act,
                           const ACE_Time_Value &tv,
                           ACE_HANDLE event = ACE_INVALID_HANDLE,