o bring in Java 6's Collections.newSetFromMap as Generic.newSetFromMap which

pjenvey · pjenvey · commit 21554e873248 · 2010-04-10T20:50:46.000Z
makes our ConcurrentHashSet redundant
o hold PyConnection cursors/statements in a weak Set so they can be GC'd
easier. synchronize these sets too
fixes #1582
diff --git a/NEWS b/NEWS
@@ -26,6 +26,7 @@ Jython 2.5.2a1
     - [ 1502 ] string-escape codec incorrect
     - [ 1534 ] new style object __dict__[name] ignored
     - [ 1479 ] xml parser file lock
+    - [ 1582 ] com.ziclix.python.sql.PyConnection leaks memory
     - Fix runtime issues during exitfuncs triggered via SystemRestart (such as
       during Django or Pylons development mode reloading)
     - Fix pickling of collections.defaultdict objects
diff --git a/src/com/ziclix/python/sql/PyConnection.java b/src/com/ziclix/python/sql/PyConnection.java
@@ -11,10 +11,11 @@
 import java.sql.Connection;
 import java.sql.SQLException;
 import java.util.Collections;
-import java.util.HashSet;
+import java.util.WeakHashMap;
 import java.util.Set;
 
 import org.python.core.ClassDictInit;
+import org.python.core.ContextManager;
 import org.python.core.Py;
 import org.python.core.PyBuiltinMethodSet;
 import org.python.core.PyException;
@@ -23,11 +24,10 @@
 import org.python.core.PyObject;
 import org.python.core.PyString;
 import org.python.core.PyUnicode;
-
-import com.ziclix.python.sql.util.PyArgParser;
-import org.python.core.ContextManager;
 import org.python.core.ThreadState;
+import org.python.util.Generic;
 
+import com.ziclix.python.sql.util.PyArgParser;
 
 /**
  * A connection to the database.
@@ -93,9 +93,11 @@ public class PyConnection extends PyObject implements ClassDictInit, ContextMana
      */
     public PyConnection(Connection connection) throws SQLException {
         this.closed = false;
-        this.cursors = new HashSet<PyCursor>();
+        cursors = Generic.newSetFromMap(new WeakHashMap<PyCursor, Boolean>());
+        cursors = Collections.synchronizedSet(cursors);
         this.connection = connection;
-        this.statements = new HashSet<PyStatement>();
+        statements = Generic.newSetFromMap(new WeakHashMap<PyStatement, Boolean>());
+        statements = Collections.synchronizedSet(statements);
         this.supportsTransactions = this.connection.getMetaData().supportsTransactions();
         this.supportsMultipleResultSets =
                 this.connection.getMetaData().supportsMultipleResultSets();
diff --git a/src/org/python/core/util/ConcurrentHashSet.java b/src/org/python/core/util/ConcurrentHashSet.java
diff --git a/src/org/python/util/Generic.java b/src/org/python/util/Generic.java
@@ -1,16 +1,20 @@
 package org.python.util;
 
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.Serializable;
+import java.util.AbstractSet;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 
-import org.python.core.util.ConcurrentHashSet;
-
 /**
  * Static methods to make instances of collections with their generic types inferred from what
  * they're being assigned to. The idea is stolen from <code>Sets</code>, <code>Lists</code> and
@@ -64,8 +68,8 @@ public static <K, V> ConcurrentMap<K, V> concurrentMap() {
     /**
      * Makes a Set using the generic type inferred from whatever this is being assigned to.
      */
-    public static <T> Set<T> set() {
-        return new HashSet<T>();
+    public static <E> Set<E> set() {
+        return new HashSet<E>();
     }
 
     /**
@@ -84,8 +88,128 @@ public static <T, U extends T> Set<T> set(U...contents) {
      * Makes a Set, ensuring safe concurrent operations, using generic types inferred from
      * whatever this is being assigned to.
      */
-    public static <T> Set<T> concurrentSet() {
-        return new ConcurrentHashSet<T>(CHM_INITIAL_CAPACITY, CHM_LOAD_FACTOR,
-                                        CHM_CONCURRENCY_LEVEL);
+    public static <E> Set<E> concurrentSet() {
+        return newSetFromMap(new ConcurrentHashMap<E, Boolean>(CHM_INITIAL_CAPACITY,
+                                                               CHM_LOAD_FACTOR,
+                                                               CHM_CONCURRENCY_LEVEL));
+    }
+
+    /**
+     * Return a Set backed by the specified Map with the same ordering, concurrency and
+     * performance characteristics.
+     *
+     * The specified Map must be empty at the time this method is invoked.
+     *
+     * Note that this method is based on Java 6's Collections.newSetFromMap, and will be
+     * removed in a future version of Jython (likely 2.6) that will rely on Java 6.
+     *
+     * @param map the backing Map
+     * @return a Set backed by the Map
+     * @throws IllegalArgumentException if Map is not empty
+     */
+    public static <E> Set<E> newSetFromMap(Map<E, Boolean> map) {
+        return new SetFromMap<E>(map);
+    }
+
+    /**
+     * A Set backed by a generic Map.
+     */
+    private static class SetFromMap<E> extends AbstractSet<E>
+        implements Serializable {
+
+        /** The backing Map. */
+        private final Map<E, Boolean> map;
+
+        /** Backing's KeySet. */
+        private transient Set<E> keySet;
+
+        public SetFromMap(Map<E, Boolean> map) {
+            if (!map.isEmpty()) {
+                throw new IllegalArgumentException("Map is non-empty");
+            }
+            this.map = map;
+            keySet = map.keySet();
+        }
+
+        @Override
+        public int size() {
+            return map.size();
+        }
+
+        @Override
+        public boolean isEmpty() {
+            return map.isEmpty();
+        }
+
+        @Override
+        public boolean contains(Object o) {
+            return map.containsKey(o);
+        }
+
+        @Override
+        public boolean containsAll(Collection<?> c) {
+            return keySet.containsAll(c);
+        }
+
+        @Override
+        public Iterator<E> iterator() {
+            return keySet.iterator();
+        }
+
+        @Override
+        public Object[] toArray() {
+            return keySet.toArray();
+        }
+
+        @Override
+        public <T> T[] toArray(T[] a) {
+            return keySet.toArray(a);
+        }
+
+        @Override
+        public boolean add(E e) {
+            return map.put(e, Boolean.TRUE) == null;
+        }
+
+        @Override
+        public boolean remove(Object o) {
+            return map.remove(o) != null;
+        }
+
+        @Override
+        public boolean removeAll(Collection<?> c) {
+            return keySet.removeAll(c);
+        }
+
+        @Override
+        public boolean retainAll(Collection<?> c) {
+            return keySet.retainAll(c);
+        }
+
+        @Override
+        public void clear() {
+            map.clear();
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            return o == this || keySet.equals(o);
+        }
+
+        @Override
+        public int hashCode() {
+            return keySet.hashCode();
+        }
+
+        @Override
+        public String toString() {
+            return keySet.toString();
+        }
+
+        private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
+            in.defaultReadObject();
+            keySet = map.keySet();
+        }
     }
+
 }
