title: python multiprocessing: some functions do not return when they are complete (queue material too big)
body: <p>I am using multiprocessing's Process and Queue.
  I start several functions in parallel and most behave nicely: they finish, their output goes to their Queue, and they show up as .is_alive() == False.  But for some reason a couple of functions are not behaving.  They always show .is_alive() == True, even after the last line in the function (a print statement saying "Finished") is complete.   This happens regardless of the set of functions I launch, even it there's only one.  If not run in parallel, the functions behave fine and return normally. What <em>kind</em> of thing might be the problem? </p>
  
  <p>Here's the generic function I'm using to manage the jobs. All I'm not showing is the functions I'm passing to it. They're long, often use matplotlib, sometimes launch some shell commands, but I cannot figure out what the failing ones have in common.</p>
  
  <pre><code>def  runFunctionsInParallel(listOf_FuncAndArgLists):
      """
      Take a list of lists like [function, arg1, arg2, ...]. Run those functions in parallel, wait for them all to finish, and return the list of their return values, in order.   
      """
      from multiprocessing import Process, Queue
  
      def storeOutputFFF(fff,theArgs,que): #add a argument to function for assigning a queue
          print 'MULTIPROCESSING: Launching %s in parallel '%fff.func_name
          que.put(fff(*theArgs)) #we're putting return value into queue
          print 'MULTIPROCESSING: Finished %s in parallel! '%fff.func_name
          # We get this far even for "bad" functions
          return
  
      queues=[Queue() for fff in listOf_FuncAndArgLists] #create a queue object for each function
      jobs = [Process(target=storeOutputFFF,args=[funcArgs[0],funcArgs[1:],queues[iii]]) for iii,funcArgs in enumerate(listOf_FuncAndArgLists)]
      for job in jobs: job.start() # Launch them all
      import time
      from math import sqrt
      n=1
      while any([jj.is_alive() for jj in jobs]): # debugging section shows progress updates
          n+=1
          time.sleep(5+sqrt(n)) # Wait a while before next update. Slow down updates for really long runs.
          print('\n---------------------------------------------------\n'+ '\t'.join(['alive?','Job','exitcode','Func',])+ '\n---------------------------------------------------')
          print('\n'.join(['%s:\t%s:\t%s:\t%s'%(job.is_alive()*'Yes',job.name,job.exitcode,listOf_FuncAndArgLists[ii][0].func_name) for ii,job in enumerate(jobs)]))
          print('---------------------------------------------------\n')
      # I never get to the following line when one of the "bad" functions is running.
      for job in jobs: job.join() # Wait for them all to finish... Hm, Is this needed to get at the Queues?
      # And now, collect all the outputs:
      return([queue.get() for queue in queues])
  </code></pre>