More scalable connection reaping

6 files changed, 180 insertions, 186 deletions

diff --git a/java/src/Ice/ConnectionI.java b/java/src/Ice/ConnectionI.java
index d00ce4499a6..99bff2c7ab7 100644
--- a/java/src/Ice/ConnectionI.java
+++ b/java/src/Ice/ConnectionI.java
@@ -775,6 +775,10 @@ public final class ConnectionI extends IceInternal.EventHandler implements Conne
         {
             if(--_dispatchCount == 0)
             {
+                if(_state == StateFinished)
+                {
+                    _reaper.add(this);
+                }
                 notifyAll();
             }
 
@@ -805,6 +809,10 @@ public final class ConnectionI extends IceInternal.EventHandler implements Conne
         {
             if(--_dispatchCount == 0)
             {
+                if(_state == StateFinished)
+                {
+                    _reaper.add(this);
+                }
                 notifyAll();
             }
 
@@ -831,6 +839,12 @@ public final class ConnectionI extends IceInternal.EventHandler implements Conne
         return _endpoint; // No mutex protection necessary, _endpoint is immutable.
     }
 
+    public IceInternal.Connector
+    connector()
+    {
+        return _connector; // No mutex protection necessary, _connector is immutable.
+    }
+
     public synchronized void
     setAdapter(ObjectAdapter adapter)
     {
@@ -1175,6 +1189,10 @@ public final class ConnectionI extends IceInternal.EventHandler implements Conne
         synchronized(this)
         {
             setState(StateFinished);
+            if(_dispatchCount == 0)
+            {
+                _reaper.add(this);
+            }
         }
     }
 
@@ -1262,21 +1280,28 @@ public final class ConnectionI extends IceInternal.EventHandler implements Conne
             assert(_dispatchCount >= 0);
             if(_dispatchCount == 0)
             {
+                if(_state == StateFinished)
+                {
+                    _reaper.add(this);
+                }
                 notifyAll();
             }
         }
     }
 
-    public ConnectionI(IceInternal.Instance instance, IceInternal.Transceiver transceiver,
+    public ConnectionI(IceInternal.Instance instance, IceInternal.ConnectionReaper reaper,
+                       IceInternal.Transceiver transceiver, IceInternal.Connector connector,
                        IceInternal.EndpointI endpoint, ObjectAdapter adapter)
     {
         _instance = instance;
-        final Ice.InitializationData initData = instance.initializationData();
+        _reaper = reaper;
         _transceiver = transceiver;
         _desc = transceiver.toString();
         _type = transceiver.type();
+        _connector = connector;
         _endpoint = endpoint;
         _adapter = adapter;
+        final Ice.InitializationData initData = instance.initializationData();
         _logger = initData.logger; // Cached for better performance.
         _traceLevels = instance.traceLevels(); // Cached for better performance.
         _timer = instance.timer();
@@ -2423,9 +2448,11 @@ public final class ConnectionI extends IceInternal.EventHandler implements Conne
     }
 
     private final IceInternal.Instance _instance;
+    private final IceInternal.ConnectionReaper _reaper;
     private final IceInternal.Transceiver _transceiver;
     private String _desc;
     private final String _type;
+    private final IceInternal.Connector _connector;
     private final IceInternal.EndpointI _endpoint;
 
     private ObjectAdapter _adapter;
diff --git a/java/src/IceInternal/ConnectionReaper.java b/java/src/IceInternal/ConnectionReaper.java
new file mode 100644
index 00000000000..c6afc2b8f13
--- /dev/null
+++ b/java/src/IceInternal/ConnectionReaper.java
@@ -0,0 +1,33 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2009 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+package IceInternal;
+
+public class ConnectionReaper
+{
+    synchronized public void
+    add(Ice.ConnectionI connection)
+    {
+        _connections.add(connection);
+    }
+
+    synchronized public java.util.List<Ice.ConnectionI>
+    swapConnections()
+    {
+        if(_connections.isEmpty())
+        {
+            return null;
+        }
+        java.util.List<Ice.ConnectionI> connections = _connections;
+        _connections = new java.util.ArrayList<Ice.ConnectionI>();
+        return connections;
+    }
+
+    private java.util.List<Ice.ConnectionI> _connections = new java.util.ArrayList<Ice.ConnectionI>();
+};
\ No newline at end of file
diff --git a/java/src/IceInternal/IncomingConnectionFactory.java b/java/src/IceInternal/IncomingConnectionFactory.java
index d13039c1995..17d046cb4f0 100644
--- a/java/src/IceInternal/IncomingConnectionFactory.java
+++ b/java/src/IceInternal/IncomingConnectionFactory.java
@@ -61,10 +61,8 @@ public final class IncomingConnectionFactory extends EventHandler implements Ice
         //
         // Now we wait until each connection is in holding state.
         //
-        java.util.ListIterator<Ice.ConnectionI> p = connections.listIterator();
-        while(p.hasNext())
+        for(Ice.ConnectionI connection : connections)
         {
-            Ice.ConnectionI connection = p.next();
             connection.waitUntilHolding();
         }
     }
@@ -100,30 +98,27 @@ public final class IncomingConnectionFactory extends EventHandler implements Ice
             // We want to wait until all connections are finished outside the
             // thread synchronization.
             //
-            if(_connections != null)
-            {
-                connections = new java.util.LinkedList<Ice.ConnectionI>(_connections);
-            }
+            connections = new java.util.LinkedList<Ice.ConnectionI>(_connections);
         }
 
         if(connections != null)
         {
-            java.util.ListIterator<Ice.ConnectionI> p = connections.listIterator();
-            while(p.hasNext())
+            for(Ice.ConnectionI connection : connections)
             {
-                Ice.ConnectionI connection = p.next();
                 connection.waitUntilFinished();
             }
         }
 
         synchronized(this)
         {
-            //
-            // For consistency with C#, we set _connections to null rather than to a
-            // new empty list so that our finalizer does not try to invoke any
-            // methods on member objects.
-            //
-            _connections = null;
+            // Ensure all the connections are finished and reapable at this point.
+            java.util.List<Ice.ConnectionI> cons = _reaper.swapConnections();
+            assert((cons == null ? 0 : cons.size()) == _connections.size());
+            if(cons != null)
+            {
+                cons.clear();
+            }
+            _connections.clear();
         }
     }
 
@@ -142,10 +137,8 @@ public final class IncomingConnectionFactory extends EventHandler implements Ice
         //
         // Only copy connections which have not been destroyed.
         //
-        java.util.ListIterator<Ice.ConnectionI> p = _connections.listIterator();
-        while(p.hasNext())
+        for(Ice.ConnectionI connection : _connections)
         {
-            Ice.ConnectionI connection = p.next();
             if(connection.isActiveOrHolding())
             {
                 connections.add(connection);
@@ -192,15 +185,14 @@ public final class IncomingConnectionFactory extends EventHandler implements Ice
             }
                 
             //
-            // Reap connections for which destruction has completed.
+            // Reap closed connections.
             //
-            java.util.ListIterator<Ice.ConnectionI> p = _connections.listIterator();
-            while(p.hasNext())
+            java.util.List<Ice.ConnectionI> cons = _reaper.swapConnections();
+            if(cons != null)
             {
-                Ice.ConnectionI con = p.next();
-                if(con.isFinished())
+                for(Ice.ConnectionI c : cons)
                 {
-                    p.remove();
+                    _connections.remove(c);
                 }
             }
 
@@ -245,7 +237,7 @@ public final class IncomingConnectionFactory extends EventHandler implements Ice
 
             try
             {
-                connection = new Ice.ConnectionI(_instance, transceiver, _endpoint, _adapter);
+                connection = new Ice.ConnectionI(_instance, _reaper, transceiver, null, _endpoint, _adapter);
             }
             catch(Ice.LocalException ex)
             {
@@ -333,16 +325,6 @@ public final class IncomingConnectionFactory extends EventHandler implements Ice
         {
             warning(ex);
         }
-        
-        //
-        // If the connection is finished, remove it right away from
-        // the connection map. Otherwise, we keep it in the map, it
-        // will eventually be reaped.
-        //
-        if(connection.isFinished())
-        {
-            _connections.remove(connection);
-        }
     }
 
     public
@@ -378,7 +360,7 @@ public final class IncomingConnectionFactory extends EventHandler implements Ice
                 Ice.ConnectionI connection;
 		try
 		{
-		    connection = new Ice.ConnectionI(_instance, _transceiver, _endpoint, _adapter);
+		    connection = new Ice.ConnectionI(_instance, _reaper, _transceiver, null, _endpoint, _adapter);
 		}
 		catch(Ice.LocalException ex)
 		{
@@ -428,7 +410,7 @@ public final class IncomingConnectionFactory extends EventHandler implements Ice
             {
                 _state = StateClosed;
                 _acceptor = null;
-                _connections = null;
+                _connections.clear();
             }
 
             if(ex instanceof Ice.LocalException)
@@ -449,7 +431,7 @@ public final class IncomingConnectionFactory extends EventHandler implements Ice
         throws Throwable
     {
         IceUtilInternal.Assert.FinalizerAssert(_state == StateFinished);
-        IceUtilInternal.Assert.FinalizerAssert(_connections == null);
+        //IceUtilInternal.Assert.FinalizerAssert(_connections.isEmpty());
 
         super.finalize();
     }
@@ -480,10 +462,8 @@ public final class IncomingConnectionFactory extends EventHandler implements Ice
                     ((Ice.ObjectAdapterI)_adapter).getThreadPool().register(this, SocketOperation.Read);
                 }
 
-                java.util.ListIterator<Ice.ConnectionI> p = _connections.listIterator();
-                while(p.hasNext())
+                for(Ice.ConnectionI connection : _connections)
                 {
-                    Ice.ConnectionI connection = p.next();
                     connection.activate();
                 }
                 break;
@@ -500,10 +480,8 @@ public final class IncomingConnectionFactory extends EventHandler implements Ice
                     ((Ice.ObjectAdapterI)_adapter).getThreadPool().unregister(this, SocketOperation.Read);
                 }
 
-                java.util.ListIterator<Ice.ConnectionI> p = _connections.listIterator();
-                while(p.hasNext())
+                for(Ice.ConnectionI connection : _connections)
                 {
-                    Ice.ConnectionI connection = p.next();
                     connection.hold();
                 }
                 break;
@@ -520,10 +498,8 @@ public final class IncomingConnectionFactory extends EventHandler implements Ice
                     state = StateFinished;
                 }
 
-                java.util.ListIterator<Ice.ConnectionI> p = _connections.listIterator();
-                while(p.hasNext())
-                {   
-                    Ice.ConnectionI connection = p.next();
+                for(Ice.ConnectionI connection : _connections)
+                {
                     connection.destroy(Ice.ConnectionI.ObjectAdapterDeactivated);
                 }
                 break;
@@ -551,7 +527,8 @@ public final class IncomingConnectionFactory extends EventHandler implements Ice
         _instance.initializationData().logger.warning(s);
     }
 
-    private final IceInternal.Instance _instance;
+    private final Instance _instance;
+    private final ConnectionReaper _reaper = new ConnectionReaper();
 
     private Acceptor _acceptor;
     private final Transceiver _transceiver;
@@ -561,7 +538,7 @@ public final class IncomingConnectionFactory extends EventHandler implements Ice
 
     private final boolean _warn;
 
-    private java.util.List<Ice.ConnectionI> _connections = new java.util.LinkedList<Ice.ConnectionI>();
+    private java.util.Set<Ice.ConnectionI> _connections = new java.util.HashSet<Ice.ConnectionI>();
 
     private int _state;
 }
diff --git a/java/src/IceInternal/OutgoingConnectionFactory.java b/java/src/IceInternal/OutgoingConnectionFactory.java
index 02eabeb4e81..638f84aab15 100644
--- a/java/src/IceInternal/OutgoingConnectionFactory.java
+++ b/java/src/IceInternal/OutgoingConnectionFactory.java
@@ -11,6 +11,36 @@ package IceInternal;
 
 public final class OutgoingConnectionFactory
 {
+    //
+    // Helper class to to multi hash map.
+    //
+    private static class MultiHashMap<K, V> extends java.util.HashMap<K, java.util.List<V>>
+    {
+        public void
+        put(K key, V value)
+        {
+            java.util.List<V> list = this.get(key);
+            if(list == null)
+            {
+                list = new java.util.LinkedList<V>();
+                this.put(key, list);
+            }
+            list.add(value);
+        }
+
+        public void
+        remove(K key, V value)
+        {
+            java.util.List<V> list = this.get(key);
+            assert(list != null);
+            list.remove(value);
+            if(list.isEmpty())
+            {
+                this.remove(key);
+            }
+        }
+    };
+    
     interface CreateConnectionCallback
     {
         void setConnection(Ice.ConnectionI connection, boolean compress);
@@ -40,7 +70,7 @@ public final class OutgoingConnectionFactory
     public void
     waitUntilFinished()
     {
-        java.util.Map<ConnectorInfo, java.util.List<Ice.ConnectionI> > connections = null;
+        java.util.Map<Connector, java.util.List<Ice.ConnectionI> > connections = null;
 
         synchronized(this)
         {
@@ -65,10 +95,7 @@ public final class OutgoingConnectionFactory
             // We want to wait until all connections are finished outside the
             // thread synchronization.
             //
-            if(_connections != null)
-            {
-                connections = new java.util.HashMap<ConnectorInfo, java.util.List<Ice.ConnectionI> >(_connections);
-            }
+            connections = new java.util.HashMap<Connector, java.util.List<Ice.ConnectionI> >(_connections);
         }
 
         //
@@ -84,13 +111,24 @@ public final class OutgoingConnectionFactory
 
         synchronized(this)
         {
-            //
-            // For consistency with C#, we set _connections to null rather than to a
-            // new empty list so that our finalizer does not try to invoke any
-            // methods on member objects.
-            //
-            _connections = null;
-            _connectionsByEndpoint = null;
+            // Ensure all the connections are finished and reapable at this point.
+            java.util.List<Ice.ConnectionI> cons = _reaper.swapConnections();
+            if(cons != null)
+            {
+                int size = 0;
+                for(java.util.List<Ice.ConnectionI> connectionList : _connections.values())
+                {
+                    size += connectionList.size();
+                }
+                assert(cons.size() == size);
+                _connections.clear();
+                _connectionsByEndpoint.clear();
+            }
+            else
+            {
+                assert(_connections.isEmpty());
+                assert(_connectionsByEndpoint.isEmpty());
+            }
         }
     }
 
@@ -199,14 +237,14 @@ public final class OutgoingConnectionFactory
             catch(Ice.CommunicatorDestroyedException ex)
             {
                 exception = ex;
-                handleException(exception, ci, connection, hasMore || p.hasNext());
+                handleConnectionException(exception, hasMore || p.hasNext());
                 connection = null;
                 break; // No need to continue
             }
             catch(Ice.LocalException ex)
             {
                 exception = ex;
-                handleException(exception, ci, connection, hasMore || p.hasNext());
+                handleConnectionException(exception, hasMore || p.hasNext());
                 connection = null;
             }
         }
@@ -346,6 +384,11 @@ public final class OutgoingConnectionFactory
 
         synchronized(this)
         {
+            if(_destroyed)
+            {
+                return;
+            }
+
             for(java.util.List<Ice.ConnectionI> connectionList : _connections.values())
             {
                 for(Ice.ConnectionI connection : connectionList)
@@ -382,8 +425,8 @@ public final class OutgoingConnectionFactory
         throws Throwable
     {
         IceUtilInternal.Assert.FinalizerAssert(_destroyed);
-        IceUtilInternal.Assert.FinalizerAssert(_connections == null);
-        IceUtilInternal.Assert.FinalizerAssert(_connectionsByEndpoint == null);
+        //IceUtilInternal.Assert.FinalizerAssert(_connections.isEmpty());
+        //IceUtilInternal.Assert.FinalizerAssert(_connectionsByEndpoint.isEmpty());
         IceUtilInternal.Assert.FinalizerAssert(_pendingConnectCount == 0);
         IceUtilInternal.Assert.FinalizerAssert(_pending.isEmpty());
 
@@ -461,12 +504,12 @@ public final class OutgoingConnectionFactory
         DefaultsAndOverrides defaultsAndOverrides = _instance.defaultsAndOverrides();
         for(ConnectorInfo ci : connectors)
         {
-            if(_pending.containsKey(ci))
+            if(_pending.containsKey(ci.connector))
             {
                 continue;
             }
 
-            java.util.List<Ice.ConnectionI> connectionList = _connections.get(ci);
+            java.util.List<Ice.ConnectionI> connectionList = _connections.get(ci.connector);
             if(connectionList == null)
             {
                 continue;
@@ -476,17 +519,6 @@ public final class OutgoingConnectionFactory
             {
                 if(connection.isActiveOrHolding()) // Don't return destroyed or un-validated connections
                 {
-                    if(!connection.endpoint().equals(ci.endpoint))
-                    {
-                        java.util.List<Ice.ConnectionI> conList = _connectionsByEndpoint.get(ci.endpoint);
-                        if(conList == null)
-                        {
-                            conList = new java.util.LinkedList<Ice.ConnectionI>();
-                            _connectionsByEndpoint.put(ci.endpoint, conList);
-                        }
-                        conList.add(connection);
-                    }
-
                     if(defaultsAndOverrides.overrideCompress)
                     {
                         compress.value = defaultsAndOverrides.overrideCompressValue;
@@ -543,49 +575,16 @@ public final class OutgoingConnectionFactory
             }
 
             //
-            // Reap connections for which destruction has completed.
+            // Reap closed connections
             //
+            java.util.List<Ice.ConnectionI> cons = _reaper.swapConnections();
+            if(cons != null)
             {
-                java.util.Iterator<java.util.List<Ice.ConnectionI> > p = _connections.values().iterator();
-                while(p.hasNext())
+                for(Ice.ConnectionI c : cons)
                 {
-                    java.util.List<Ice.ConnectionI> connectionList = p.next();
-                    java.util.Iterator<Ice.ConnectionI> q = connectionList.iterator();
-                    while(q.hasNext())
-                    {
-                        Ice.ConnectionI con = q.next();
-                        if(con.isFinished())
-                        {
-                            q.remove();
-                        }
-                    }
-
-                    if(connectionList.isEmpty())
-                    {
-                        p.remove();
-                    }
-                }
-            }
-
-            {
-                java.util.Iterator<java.util.List<Ice.ConnectionI> > p = _connectionsByEndpoint.values().iterator();
-                while(p.hasNext())
-                {
-                    java.util.List<Ice.ConnectionI> connectionList = p.next();
-                    java.util.Iterator<Ice.ConnectionI> q = connectionList.iterator();
-                    while(q.hasNext())
-                    {
-                        Ice.ConnectionI con = q.next();
-                        if(con.isFinished())
-                        {
-                            q.remove();
-                        }
-                    }
-
-                    if(connectionList.isEmpty())
-                    {
-                        p.remove();
-                    }
+                    _connections.remove(c.connector(), c);
+                    _connectionsByEndpoint.remove(c.endpoint(), c);
+                    _connectionsByEndpoint.remove(c.endpoint().compress(true), c);
                 }
             }
 
@@ -662,7 +661,7 @@ public final class OutgoingConnectionFactory
     private synchronized Ice.ConnectionI
     createConnection(Transceiver transceiver, ConnectorInfo ci)
     {
-        assert(_pending.containsKey(ci) && transceiver != null);
+        assert(_pending.containsKey(ci.connector) && transceiver != null);
 
         //
         // Create and add the connection to the connection map. Adding the connection to the map
@@ -677,7 +676,8 @@ public final class OutgoingConnectionFactory
                 throw new Ice.CommunicatorDestroyedException();
             }
 
-            connection = new Ice.ConnectionI(_instance, transceiver, ci.endpoint.compress(false),null);
+            connection = new Ice.ConnectionI(_instance, _reaper, transceiver, ci.connector, 
+                                             ci.endpoint.compress(false), null);
 	}
 	catch(Ice.LocalException ex)
 	{
@@ -692,20 +692,9 @@ public final class OutgoingConnectionFactory
             throw ex;
 	}
 
-        java.util.List<Ice.ConnectionI> connectionList = _connections.get(ci);
-        if(connectionList == null)
-        {
-            connectionList = new java.util.LinkedList<Ice.ConnectionI>();
-            _connections.put(ci, connectionList);
-        }
-        connectionList.add(connection);
-        connectionList = _connectionsByEndpoint.get(ci.endpoint);
-        if(connectionList == null)
-        {
-            connectionList = new java.util.LinkedList<Ice.ConnectionI>();
-            _connectionsByEndpoint.put(ci.endpoint, connectionList);
-        }
-        connectionList.add(connection);
+        _connections.put(ci.connector, connection);
+        _connectionsByEndpoint.put(connection.endpoint(), connection);
+        _connectionsByEndpoint.put(connection.endpoint().compress(true), connection);
         return connection;
     }
 
@@ -726,7 +715,7 @@ public final class OutgoingConnectionFactory
         {
             for(ConnectorInfo c : connectors)
             {
-                java.util.Set<ConnectCallback> cbs = _pending.remove(c);
+                java.util.Set<ConnectCallback> cbs = _pending.remove(c.connector);
                 if(cbs != null)
                 {
                     for(ConnectCallback cc : cbs)
@@ -790,7 +779,7 @@ public final class OutgoingConnectionFactory
         {
             for(ConnectorInfo c : connectors)
             {
-                java.util.Set<ConnectCallback> cbs = _pending.remove(c);
+                java.util.Set<ConnectCallback> cbs = _pending.remove(c.connector);
                 if(cbs != null)
                 {
                     for(ConnectCallback cc : cbs)
@@ -834,7 +823,7 @@ public final class OutgoingConnectionFactory
         boolean found = false;
         for(ConnectorInfo p : connectors)
         {
-            java.util.Set<ConnectCallback> cbs = _pending.get(p);
+            java.util.Set<ConnectCallback> cbs = _pending.get(p.connector);
             if(cbs != null)
             {
                 found = true;
@@ -857,9 +846,9 @@ public final class OutgoingConnectionFactory
         //
         for(ConnectorInfo p : connectors)
         {
-            if(!_pending.containsKey(p))
+            if(!_pending.containsKey(p.connector))
             {
-                _pending.put(p, new java.util.HashSet<ConnectCallback>());
+                _pending.put(p.connector, new java.util.HashSet<ConnectCallback>());
             }
         }
 
@@ -871,7 +860,7 @@ public final class OutgoingConnectionFactory
     {
         for(ConnectorInfo p : connectors)
         {
-            java.util.Set<ConnectCallback> cbs = _pending.get(p);
+            java.util.Set<ConnectCallback> cbs = _pending.get(p.connector);
             if(cbs != null)
             {
                 cbs.remove(cb);
@@ -880,7 +869,7 @@ public final class OutgoingConnectionFactory
     }
 
     private void
-    handleException(Ice.LocalException ex, ConnectorInfo ci, Ice.ConnectionI connection, boolean hasMore)
+    handleConnectionException(Ice.LocalException ex, boolean hasMore)
     {
         TraceLevels traceLevels = _instance.traceLevels();
         if(traceLevels.retry >= 2)
@@ -905,38 +894,6 @@ public final class OutgoingConnectionFactory
             s.append(ex.toString());
             _instance.initializationData().logger.trace(traceLevels.retryCat, s.toString());
         }
-
-        if(connection != null && connection.isFinished())
-        {
-            //
-            // If the connection is finished, we remove it right away instead of
-            // waiting for the reaping.
-            //
-            // NOTE: it's possible for the connection to not be finished yet.
-            //
-            synchronized(this)
-            {
-                java.util.List<Ice.ConnectionI> connectionList = _connections.get(ci);
-                if(connectionList != null) // It might have already been reaped!
-                {
-                    connectionList.remove(connection);
-                    if(connectionList.isEmpty())
-                    {
-                        _connections.remove(ci);
-                    }
-                }
-
-                connectionList = _connectionsByEndpoint.get(ci.endpoint);
-                if(connectionList != null) // It might have already been reaped!
-                {
-                    connectionList.remove(connection);
-                    if(connectionList.isEmpty())
-                    {
-                        _connectionsByEndpoint.remove(ci.endpoint);
-                    }
-                }
-            }
-        }
     }
 
     private void
@@ -1020,7 +977,7 @@ public final class OutgoingConnectionFactory
         {
             assert(_current != null);
 
-            _factory.handleException(ex, _current, connection, _hasMore || _iter.hasNext());
+            _factory.handleConnectionException(ex, _hasMore || _iter.hasNext());
             if(ex instanceof Ice.CommunicatorDestroyedException) // No need to continue.
             {
                 _factory.finishGetConnection(_connectors, ex, this);
@@ -1234,13 +1191,13 @@ public final class OutgoingConnectionFactory
     }
 
     private final Instance _instance;
+    private final ConnectionReaper _reaper = new ConnectionReaper();
     private boolean _destroyed;
 
-    private java.util.Map<ConnectorInfo, java.util.List<Ice.ConnectionI> > _connections =
-        new java.util.HashMap<ConnectorInfo, java.util.List<Ice.ConnectionI> >();
-    private java.util.Map<EndpointI, java.util.List<Ice.ConnectionI> > _connectionsByEndpoint =
-        new java.util.HashMap<EndpointI, java.util.List<Ice.ConnectionI> >();
-    private java.util.Map<ConnectorInfo, java.util.HashSet<ConnectCallback> > _pending =
-        new java.util.HashMap<ConnectorInfo, java.util.HashSet<ConnectCallback> >();
+    private MultiHashMap<Connector, Ice.ConnectionI> _connections = new MultiHashMap<Connector, Ice.ConnectionI>();
+    private MultiHashMap<EndpointI, Ice.ConnectionI> _connectionsByEndpoint = 
+        new MultiHashMap<EndpointI, Ice.ConnectionI>();
+    private java.util.Map<Connector, java.util.HashSet<ConnectCallback> > _pending =
+        new java.util.HashMap<Connector, java.util.HashSet<ConnectCallback> >();
     private int _pendingConnectCount = 0;
 }
diff --git a/java/src/IceInternal/UdpConnector.java b/java/src/IceInternal/UdpConnector.java
index 5ef3ada65bc..edff81e92a2 100644
--- a/java/src/IceInternal/UdpConnector.java
+++ b/java/src/IceInternal/UdpConnector.java
@@ -81,7 +81,7 @@ final class UdpConnector implements Connector
 
         if(this == p)
         {
-            return false;
+            return true;
         }
 
         if(!_connectionId.equals(p._connectionId))
diff --git a/java/src/IceSSL/ConnectorI.java b/java/src/IceSSL/ConnectorI.java
index 1cdaccb5019..32e8d4cf817 100644
--- a/java/src/IceSSL/ConnectorI.java
+++ b/java/src/IceSSL/ConnectorI.java
@@ -110,7 +110,7 @@ final class ConnectorI implements IceInternal.Connector
 
         if(this == p)
         {
-            return false;
+            return true;
         }
 
         if(_timeout != p._timeout)