self.collect_children(blocking=self.block_on_close)

class _Threads(list):

"""

Joinable list of all non-daemon threads.

"""

def append(self, thread):

self.reap()

if thread.daemon:

return

super().append(thread)

def pop_all(self):

self[:], result = [], self[:]

return result

def join(self):

for thread in self.pop_all():

thread.join()

def reap(self):

self[:] = (thread for thread in self if thread.is_alive())

class _NoThreads:

"""

Degenerate version of _Threads.

"""

def append(self, thread):

pass

def join(self):

pass

class ThreadingMixIn:

"""Mix-in class to handle each request in a new thread."""

daemon_threads = False

# If true, server_close() waits until all non-daemonic threads terminate.

block_on_close = True

# For non-daemonic threads, list of threading.Threading objects

# Threads object

# used by server_close() to wait for all threads completion.

_threads = None

_threads = _NoThreads()

def process_request_thread(self, request, client_address):

"""Same as in BaseServer but as a thread.

def process_request(self, request, client_address):

"""Start a new thread to process the request."""

if self.block_on_close:

vars(self).setdefault('_threads', _Threads())

t = threading.Thread(target = self.process_request_thread,

args = (request, client_address))

t.daemon = self.daemon_threads

if not t.daemon and self.block_on_close:

if self._threads is None:

self._threads = []

self._threads.append(t)

self._threads.append(t)

t.start()

def server_close(self):

super().server_close()

if self.block_on_close:

threads = self._threads

self._threads = None

if threads:

for thread in threads:

thread.join()

self._threads.join()

if hasattr(os, "fork"):