Some nits. Improve wordings in docstrings and comments, and avoid relying on

sys.getrefcount() in tests.

Author: pitrou

Lib/concurrent/futures/_base.py

@@ -172,11 +172,15 @@ def _create_and_install_waiters(fs, return_when):
 
 
 def _yield_and_decref(fs, ref_collect):
-    """Yields a future. Before yielding, removes the future
-    from each set in collection of sets (`ref_collect`)."""
+    """
+    Iterate on the list *fs*, yielding objects one by one in reverse order.
+    Before yielding an object, it is removed from each set in
+    the collection of sets *ref_collect*.
+    """
     while fs:
         for futures_set in ref_collect:
             futures_set.remove(fs[-1])
+        # Careful not to keep a reference to the popped value
         yield fs.pop()
 
 
@@ -566,6 +570,7 @@ def result_iterator():
                 # reverse to keep finishing order
                 fs.reverse()
                 while fs:
+                    # Careful not to keep a reference to the popped future
                     if timeout is None:
                         yield fs.pop().result()
                     else:

Lib/concurrent/futures/process.py

@@ -357,12 +357,12 @@ def _check_system_limits():
     raise NotImplementedError(_system_limited)
 
 
-def _chain_from_iterable(iterable):
+def _chain_from_iterable_of_lists(iterable):
     """
-    Different implementation of itertools.chain.from_iterable.
-    The difference is _chain_from_iterable do not keep reference to returned objects.
+    Specialized implementation of itertools.chain.from_iterable.
+    Each item in *iterable* should be a list.  This function is
+    careful not to keep references to yielded objects.
     """
-
     for element in iterable:
         element.reverse()
         while element:
@@ -494,7 +494,7 @@ def map(self, fn, *iterables, timeout=None, chunksize=1):
         results = super().map(partial(_process_chunk, fn),
                               _get_chunks(*iterables, chunksize=chunksize),
                               timeout=timeout)
-        return _chain_from_iterable(results)
+        return _chain_from_iterable_of_lists(results)
 
     def shutdown(self, wait=True):
         with self._shutdown_lock:

Lib/test/test_concurrent_futures.py

@@ -54,15 +54,15 @@ def sleep_and_print(t, msg):
     sys.stdout.flush()
 
 
-def _dummy_object_fn(_):
-    return object()
-
-
 class MyObject(object):
     def my_method(self):
         pass
 
 
+def make_dummy_object(_):
+    return MyObject()
+
+
 class BaseTestCase(unittest.TestCase):
     def setUp(self):
         self._thread_key = test.support.threading_setup()
@@ -401,27 +401,31 @@ def test_duplicate_futures(self):
         self.assertEqual(len(completed), 1)
 
     def test_free_reference_yielded_future(self):
-        # Issue #14406: Generator should not keep reference
-        # for finished futures.
+        # Issue #14406: Generator should not keep references
+        # to finished futures.
         futures_list = [Future() for _ in range(8)]
         futures_list.append(create_future(state=CANCELLED_AND_NOTIFIED))
         futures_list.append(create_future(state=SUCCESSFUL_FUTURE))
 
         with self.assertRaises(futures.TimeoutError):
             for future in futures.as_completed(futures_list, timeout=0):
                 futures_list.remove(future)
-                self.assertEqual(sys.getrefcount(future), 2)
+                wr = weakref.ref(future)
+                del future
+                self.assertIsNone(wr())
 
         futures_list[0].set_result("test")
         for future in futures.as_completed(futures_list):
             futures_list.remove(future)
-            self.assertEqual(sys.getrefcount(future), 2)
+            wr = weakref.ref(future)
+            del future
+            self.assertIsNone(wr())
             if futures_list:
                 futures_list[0].set_result("test")
 
     def test_correct_timeout_exception_msg(self):
         futures_list = [CANCELLED_AND_NOTIFIED_FUTURE, PENDING_FUTURE,
-                   RUNNING_FUTURE, SUCCESSFUL_FUTURE]
+                        RUNNING_FUTURE, SUCCESSFUL_FUTURE]
 
         with self.assertRaises(futures.TimeoutError) as cm:
             list(futures.as_completed(futures_list, timeout=0))
@@ -508,10 +512,12 @@ def test_max_workers_negative(self):
                 self.executor_type(max_workers=number)
 
     def test_free_reference(self):
-        # Issue #14406: Result iterator should not keep reference
-        # for finished futures.
-        for result_object in self.executor.map(_dummy_object_fn, range(10)):
-            self.assertEqual(sys.getrefcount(result_object), 2)
+        # Issue #14406: Result iterator should not keep an internal
+        # reference to result objects.
+        for obj in self.executor.map(make_dummy_object, range(10)):
+            wr = weakref.ref(obj)
+            del obj
+            self.assertIsNone(wr())
 
 
 class ThreadPoolExecutorTest(ThreadPoolMixin, ExecutorTest, BaseTestCase):

Misc/NEWS.d/next/Library/2017-08-30-11-26-14.bpo-27144.PEDJsE.rst

@@ -1,2 +1,2 @@
-concurrent.futures as_complie and map iterators do not keep reference to
-returned object
+The ``map()`` and ``as_completed()`` iterators in ``concurrent.futures``
+now avoid keeping a reference to yielded objects.