python 子进程退出_Python子进程执行完但是不结束？

# queues.py

class Queue(object):

def __init__(self, maxsize=0):

if maxsize <= 0:

maxsize = _multiprocessing.SemLock.SEM_VALUE_MAX

self._maxsize = maxsize

self._reader, self._writer = Pipe(duplex=False)

self._rlock = Lock()

self._opid = os.getpid()

if sys.platform == 'win32':

self._wlock = None

else:

self._wlock = Lock()

self._sem = BoundedSemaphore(maxsize)

self._after_fork()

if sys.platform != 'win32':

register_after_fork(self, Queue._after_fork)

def _after_fork(self):

debug('Queue._after_fork()')

self._notempty = threading.Condition(threading.Lock())

self._buffer = collections.deque()

self._thread = None

self._jointhread = None

self._joincancelled = False

self._closed = False

self._close = None

self._send = self._writer.send

self._recv = self._reader.recv

self._poll = self._reader.poll

def put(self, obj, block=True, timeout=None):

assert not self._closed

if not self._sem.acquire(block, timeout):

raise Full

self._notempty.acquire()

try:

if self._thread is None:

self._start_thread()

self._buffer.append(obj)

self._notempty.notify()

finally:

self._notempty.release()

def get(self, block=True, timeout=None):

if block and timeout is None:

self._rlock.acquire()

try:

res = self._recv()

self._sem.release()

return res

finally:

self._rlock.release()

else:

if block:

deadline = time.time() + timeout

if not self._rlock.acquire(block, timeout):

raise Empty

try:

if block:

timeout = deadline - time.time()

if timeout < 0 or not self._poll(timeout):

raise Empty

elif not self._poll():

raise Empty

res = self._recv()

self._sem.release()

return res

finally:

self._rlock.release()

def _start_thread(self):

debug('Queue._start_thread()')

# Start thread which transfers data from buffer to pipe

self._buffer.clear()

self._thread = threading.Thread(

target=Queue._feed,

args=(self._buffer, self._notempty, self._send,

self._wlock, self._writer.close),

name='QueueFeederThread'

)

self._thread.daemon = True

debug('doing self._thread.start()')

self._thread.start()

debug('... done self._thread.start()')

# On process exit we will wait for data to be flushed to pipe.

if not self._joincancelled:

self._jointhread = Finalize(

self._thread, Queue._finalize_join,

[weakref.ref(self._thread)],

exitpriority=-5

)

# Send sentinel to the thread queue object when garbage collected

self._close = Finalize(

self, Queue._finalize_close,

[self._buffer, self._notempty],

exitpriority=10

)

@staticmethod

def _feed(buffer, notempty, send, writelock, close):

debug('starting thread to feed data to pipe')

nacquire = notempty.acquire

nrelease = notempty.release

nwait = notempty.wait

bpopleft = buffer.popleft

sentinel = _sentinel

if sys.platform != 'win32':

wacquire = writelock.acquire

wrelease = writelock.release

else:

wacquire = None

try:

while 1:

nacquire()

try:

if not buffer:

nwait()

finally:

nrelease()

try:

while 1:

obj = bpopleft()

if obj is sentinel:

debug('feeder thread got sentinel -- exiting')

close()

return

if wacquire is None:

send(obj)

else:

wacquire()

try:

send(obj)

finally:

wrelease()

except IndexError:

pass

except Exception, e:

# Since this runs in a daemon thread the resources it uses

# may be become unusable while the process is cleaning up.

# We ignore errors which happen after the process has

# started to cleanup.

try:

if is_exiting():

info('error in queue thread:%s', e)

else:

import traceback

traceback.print_exc()

except Exception:

pass