python-multiprocessing: einige Funktionen nicht zurückgegeben werden, wenn Sie komplett sind (Warteschlange material zu groß)

Okay, es scheint, dass das Rohr zum füllen der Warteschlange eingesteckt werden, wenn die Ausgabe einer Funktion ist zu groß (meinem groben Verständnis? Dies ist eine ungelöste/geschlossen Fehler? http://bugs.python.org/issue8237). Ich veränderte den code in meiner Frage, so dass es eine gewisse Pufferung (Warteschlangen werden regelmäßig geleert, während Prozesse, die ausgeführt werden), das löst alle meine Probleme. So, jetzt dauert dies eine Sammlung von Aufgaben (Funktionen und deren Argumente), startet Sie, und sammelt die Ausgänge. Ich wünschte, es wäre einfacher /sauberer suchen.

Bearbeiten (2014 Sep; update 2017 Nov: neu geschrieben, für bessere Lesbarkeit): ich aktualisiere den code mit den Erweiterungen, die ich gemacht habe seit. Der neue code (gleiche Funktion, aber bessere Funktionen) ist hier:
https://gitlab.com/cpbl/cpblUtilities/blob/master/parallel.py

Den Aufruf Beschreibung ist auch unten.

def runFunctionsInParallel(*args, **kwargs):
    """ This is the main/only interface to class cRunFunctionsInParallel. See its documentation for arguments.
    """
    return cRunFunctionsInParallel(*args, **kwargs).launch_jobs()

###########################################################################################
###
class cRunFunctionsInParallel():
    ###
    #######################################################################################
    """Run any list of functions, each with any arguments and keyword-arguments, in parallel.
The functions/jobs should return (if anything) pickleable results. In order to avoid processes getting stuck due to the output queues overflowing, the queues are regularly collected and emptied.
You can now pass os.system or etc to this as the function, in order to parallelize at the OS level, with no need for a wrapper: I made use of hasattr(builtinfunction,'func_name') to check for a name.
Parameters
----------
listOf_FuncAndArgLists : a list of lists 
    List of up-to-three-element-lists, like [function, args, kwargs],
    specifying the set of functions to be launched in parallel.  If an
    element is just a function, rather than a list, then it is assumed
    to have no arguments or keyword arguments. Thus, possible formats
    for elements of the outer list are:
      function
      [function, list]
      [function, list, dict]
kwargs: dict
    One can also supply the kwargs once, for all jobs (or for those
    without their own non-empty kwargs specified in the list)
names: an optional list of names to identify the processes.
    If omitted, the function name is used, so if all the functions are
    the same (ie merely with different arguments), then they would be
    named indistinguishably
offsetsSeconds: int or list of ints
    delay some functions' start times
expectNonzeroExit: True/False
    Normal behaviour is to not proceed if any function exits with a
    failed exit code. This can be used to override this behaviour.
parallel: True/False
    Whenever the list of functions is longer than one, functions will
    be run in parallel unless this parameter is passed as False
maxAtOnce: int
    If nonzero, this limits how many jobs will be allowed to run at
    once.  By default, this is set according to how many processors
    the hardware has available.
showFinished : int
    Specifies the maximum number of successfully finished jobs to show
    in the text interface (before the last report, which should always
    show them all).
Returns
-------
Returns a tuple of (return codes, return values), each a list in order of the jobs provided.
Issues
-------
Only tested on POSIX OSes.
Examples
--------
See the testParallel() method in this module
    """