The Server class in multiprocessing.managers creates daemon threads and never joins them. This is in contrast with e.g. the Pool class, which creates daemon threads but uses util.Finalize to join them.

(not joining daemon threads may have adverse effects such as resource leaks or otherwise unexpected glitches)

Issue spawned from http://bugs.python.org/issue8713#msg195178.

I've checked the code and this doesn't appear to have been implemented.  I looked into providing a patch myself, but all the returns from calls to util.Finalize that I could find were assigned to different attribute names, so I'm not confident enough to proceed, sorry :(

Capturing some notes from looking at this after Dan Sully asked me questions about the issue during today's pycon sprints:

within multiprocessing/managers.py serve_forever():

the accepter thread is an infinite loop. i think this issue also wants to join() on the threads that the accepter spawns. which also implies they need to be kept track of and that we should change the accepter's while True: into a "while some event that indicates it should exit is not set"...

but we'd also not want a pool keeping track of accepter's infinitely spawned threads to grow forever, so something needs to effectively garbage collect those periodically.

I'm interested in taking this on. I can do the following:

* keep track of the threads in a field attached to the class
* handle thread synchronization and cleanup in the finally block
* set a flag on the exception, which ensures the loop completes, vs immediately passing.

The part I'm unclear on is a good garbage collection strategy. I'm thinking:

* set some configurable period to clean up the threads (every 10s by default. Rapid enough to ensure cleanup, but not fast enough to run every time and significantly slow down responses)
* at the specific threshold, run the cleanup script.
* on cleanup, check every thread if it's alive. explicit del the ones that are not. 

If it sounds good, I can start a patch.