Stowage/cpython
2
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-10-31 13:41:24 +00:00
Code Issues Projects Releases Packages Wiki Activity

give the threading API PEP 8 names

Browse source
This commit is contained in:
Benjamin Peterson 2008-06-11 17:27:50 +00:00
parent 32c2e41c82
commit 0fbcf69455
20 changed files with 127 additions and 126 deletions
Download patch file Download diff file Expand all files Collapse all files

38
Doc/library/threading.rst
View file

@ -16,7 +16,7 @@ The :mod:`dummy_threading` module is provided for situations where
This module defines the following functions and objects:
.. function:: activeCount()
.. function:: active_count()
Return the number of :class:`Thread` objects currently alive. The returned
count is equal to the length of the list returned by :func:`enumerate`.
@ -30,7 +30,7 @@ This module defines the following functions and objects:
thread.
.. function:: currentThread()
.. function:: current_thread()
Return the current :class:`Thread` object, corresponding to the caller's thread
of control. If the caller's thread of control was not created through the
@ -40,10 +40,10 @@ This module defines the following functions and objects:
.. function:: enumerate()
Return a list of all :class:`Thread` objects currently alive. The list includes
daemonic threads, dummy thread objects created by :func:`currentThread`, and the
main thread. It excludes terminated threads and threads that have not yet been
started.
Return a list of all :class:`Thread` objects currently alive. The list
includes daemonic threads, dummy thread objects created by
:func:`current_thread`, and the main thread. It excludes terminated threads
and threads that have not yet been started.
.. function:: Event()
@ -395,7 +395,7 @@ needs to wake up one consumer thread.
lock, its caller should.
.. method:: Condition.notifyAll()
.. method:: Condition.notify_all()
Wake up all threads waiting on this condition. This method acts like
:meth:`notify`, but wakes up all waiting threads instead of one. If the calling
@ -552,12 +552,12 @@ Other threads can call a thread's :meth:`join` method. This blocks the calling
thread until the thread whose :meth:`join` method is called is terminated.
A thread has a name. The name can be passed to the constructor, set with the
:meth:`setName` method, and retrieved with the :meth:`getName` method.
:meth:`set_name` method, and retrieved with the :meth:`get_name` method.
A thread can be flagged as a "daemon thread". The significance of this flag is
that the entire Python program exits when only daemon threads are left. The
initial value is inherited from the creating thread. The flag can be set with
the :meth:`setDaemon` method and retrieved with the :meth:`isDaemon` method.
the :meth:`set_daemon` method and retrieved with the :meth:`is_daemon` method.
There is a "main thread" object; this corresponds to the initial thread of
control in the Python program. It is not a daemon thread.
@ -637,12 +637,12 @@ impossible to detect the termination of alien threads.
raises the same exception.
.. method:: Thread.getName()
.. method:: Thread.get_name()
Return the thread's name.
.. method:: Thread.setName(name)
.. method:: Thread.set_same(name)
Set the thread's name.
@ -651,18 +651,18 @@ impossible to detect the termination of alien threads.
constructor.
.. method:: Thread.getIdent()
.. method:: Thread.get_ddent()
Return the 'thread identifier' of this thread or None if the thread has not
been started. This is a nonzero integer. See the :mod:`thread` module's
:func:`get_ident()` function. Thread identifiers may be recycled when a
thread exits and another thread is created. The identifier is returned
even after the thread has exited.
been started. This is a nonzero integer. See the :func:`thread.get_ident()`
function. Thread identifiers may be recycled when a thread exits and another
thread is created. The identifier is returned even after the thread has
exited.
.. versionadded:: 2.6
.. method:: Thread.isAlive()
.. method:: Thread.is_alive()
Return whether the thread is alive.
@ -671,12 +671,12 @@ impossible to detect the termination of alien threads.
returns a list of all alive threads.
.. method:: Thread.isDaemon()
.. method:: Thread.is_daemon()
Return the thread's daemon flag.
.. method:: Thread.setDaemon(daemonic)
.. method:: Thread.set_daemon(daemonic)
Set the thread's daemon flag to the Boolean value *daemonic*. This must be
called before :meth:`start` is called, otherwise :exc:`RuntimeError` is raised.

2
Lib/Queue.py
View file

@ -62,7 +62,7 @@ def task_done(self):
if unfinished <= 0:
if unfinished < 0:
raise ValueError('task_done() called too many times')
self.all_tasks_done.notifyAll()
self.all_tasks_done.notify_all()
self.unfinished_tasks = unfinished
finally:
self.all_tasks_done.release()

8
Lib/_threading_local.py
View file

@ -162,16 +162,16 @@ def __new__(cls, *args, **kw):
# __init__ being called, to make sure we don't call it
# again ourselves.
dict = object.__getattribute__(self, '__dict__')
currentThread().__dict__[key] = dict
current_thread().__dict__[key] = dict
return self
def _patch(self):
key = object.__getattribute__(self, '_local__key')
d = currentThread().__dict__.get(key)
d = current_thread().__dict__.get(key)
if d is None:
d = {}
currentThread().__dict__[key] = d
current_thread().__dict__[key] = d
object.__setattr__(self, '__dict__', d)
# we have a new instance dict, so call out __init__ if we have
@ -238,4 +238,4 @@ def __del__(self):
except KeyError:
pass # didn't have anything in this thread
from threading import currentThread, RLock
from threading import current_thread, RLock

2
Lib/logging/__init__.py
View file

@ -262,7 +262,7 @@ def __init__(self, name, level, pathname, lineno,
self.relativeCreated = (self.created - _startTime) * 1000
if logThreads and thread:
self.thread = thread.get_ident()
self.threadName = threading.currentThread().getName()
self.threadName = threading.current_thread().get_name()
else:
self.thread = None
self.threadName = None

30
Lib/multiprocessing/dummy/__init__.py
View file

@ -48,24 +48,24 @@ def start(self):
threading.Thread.start(self)
def get_exitcode(self):
if self._start_called and not self.isAlive():
if self._start_called and not self.is_alive():
return 0
else:
return None
# XXX
if sys.version_info < (3, 0):
is_alive = threading.Thread.isAlive.im_func
get_name = threading.Thread.getName.im_func
set_name = threading.Thread.setName.im_func
is_daemon = threading.Thread.isDaemon.im_func
set_daemon = threading.Thread.setDaemon.im_func
is_alive = threading.Thread.is_alive.im_func
get_name = threading.Thread.get_name.im_func
set_name = threading.Thread.set_name.im_func
is_daemon = threading.Thread.is_daemon.im_func
set_daemon = threading.Thread.set_daemon.im_func
else:
is_alive = threading.Thread.isAlive
get_name = threading.Thread.getName
set_name = threading.Thread.setName
is_daemon = threading.Thread.isDaemon
set_daemon = threading.Thread.setDaemon
is_alive = threading.Thread.is_alive
get_name = threading.Thread.get_name
set_name = threading.Thread.set_name
is_daemon = threading.Thread.is_daemon
set_daemon = threading.Thread.set_daemon
#
#
@ -74,22 +74,22 @@ def get_exitcode(self):
class Condition(threading._Condition):
# XXX
if sys.version_info < (3, 0):
notify_all = threading._Condition.notifyAll.im_func
notify_all = threading._Condition.notify_all.im_func
else:
notify_all = threading._Condition.notifyAll
notify_all = threading._Condition.notify_all
#
#
#
Process = DummyProcess
current_process = threading.currentThread
current_process = threading.current_thread
current_process()._children = weakref.WeakKeyDictionary()
def active_children():
children = current_process()._children
for p in list(children):
if not p.isAlive():
if not p.is_alive():
children.pop(p, None)
return list(children)

22
Lib/multiprocessing/managers.py
View file

@ -169,7 +169,7 @@ def serve_forever(self):
except (OSError, IOError):
continue
t = threading.Thread(target=self.handle_request, args=(c,))
t.setDaemon(True)
t.set_daemon(True)
t.start()
except (KeyboardInterrupt, SystemExit):
pass
@ -216,7 +216,7 @@ def serve_client(self, conn):
Handle requests from the proxies in a particular process/thread
'''
util.debug('starting server thread to service %r',
threading.currentThread().getName())
threading.current_thread().get_name())
recv = conn.recv
send = conn.send
@ -266,7 +266,7 @@ def serve_client(self, conn):
except EOFError:
util.debug('got EOF -- exiting thread serving %r',
threading.currentThread().getName())
threading.current_thread().get_name())
sys.exit(0)
except Exception:
@ -279,7 +279,7 @@ def serve_client(self, conn):
send(('#UNSERIALIZABLE', repr(msg)))
except Exception, e:
util.info('exception in thread serving %r',
threading.currentThread().getName())
threading.current_thread().get_name())
util.info(' ... message was %r', msg)
util.info(' ... exception was %r', e)
conn.close()
@ -401,7 +401,7 @@ def accept_connection(self, c, name):
'''
Spawn a new thread to serve this connection
'''
threading.currentThread().setName(name)
threading.current_thread().set_name(name)
c.send(('#RETURN', None))
self.serve_client(c)
@ -715,8 +715,8 @@ def __init__(self, token, serializer, manager=None,
def _connect(self):
util.debug('making connection to manager')
name = current_process().get_name()
if threading.currentThread().getName() != 'MainThread':
name += '|' + threading.currentThread().getName()
if threading.current_thread().get_name() != 'MainThread':
name += '|' + threading.current_thread().get_name()
conn = self._Client(self._token.address, authkey=self._authkey)
dispatch(conn, None, 'accept_connection', (name,))
self._tls.connection = conn
@ -729,7 +729,7 @@ def _callmethod(self, methodname, args=(), kwds={}):
conn = self._tls.connection
except AttributeError:
util.debug('thread %r does not own a connection',
threading.currentThread().getName())
threading.current_thread().get_name())
self._connect()
conn = self._tls.connection
@ -790,7 +790,7 @@ def _decref(token, authkey, state, tls, idset, _Client):
# the process owns no more references to objects for this manager
if not idset and hasattr(tls, 'connection'):
util.debug('thread %r has no more proxies so closing conn',
threading.currentThread().getName())
threading.current_thread().get_name())
tls.connection.close()
del tls.connection
@ -969,13 +969,13 @@ def __exit__(self, exc_type, exc_val, exc_tb):
class ConditionProxy(AcquirerProxy):
# XXX will Condition.notfyAll() name be available in Py3.0?
_exposed_ = ('acquire', 'release', 'wait', 'notify', 'notifyAll')
_exposed_ = ('acquire', 'release', 'wait', 'notify', 'notify_all')
def wait(self, timeout=None):
return self._callmethod('wait', (timeout,))
def notify(self):
return self._callmethod('notify')
def notify_all(self):
return self._callmethod('notifyAll')
return self._callmethod('notify_all')
class EventProxy(BaseProxy):
# XXX will Event.isSet name be available in Py3.0?

14
Lib/multiprocessing/pool.py
View file

@ -107,7 +107,7 @@ def __init__(self, processes=None, initializer=None, initargs=()):
target=Pool._handle_tasks,
args=(self._taskqueue, self._quick_put, self._outqueue, self._pool)
)
self._task_handler.setDaemon(True)
self._task_handler.set_daemon(True)
self._task_handler._state = RUN
self._task_handler.start()
@ -115,7 +115,7 @@ def __init__(self, processes=None, initializer=None, initargs=()):
target=Pool._handle_results,
args=(self._outqueue, self._quick_get, self._cache)
)
self._result_handler.setDaemon(True)
self._result_handler.set_daemon(True)
self._result_handler._state = RUN
self._result_handler.start()
@ -213,7 +213,7 @@ def map_async(self, func, iterable, chunksize=None, callback=None):
@staticmethod
def _handle_tasks(taskqueue, put, outqueue, pool):
thread = threading.currentThread()
thread = threading.current_thread()
for taskseq, set_length in iter(taskqueue.get, None):
i = -1
@ -252,7 +252,7 @@ def _handle_tasks(taskqueue, put, outqueue, pool):
@staticmethod
def _handle_results(outqueue, get, cache):
thread = threading.currentThread()
thread = threading.current_thread()
while 1:
try:
@ -346,7 +346,7 @@ def _help_stuff_finish(inqueue, task_handler, size):
# task_handler may be blocked trying to put items on inqueue
debug('removing tasks from inqueue until task handler finished')
inqueue._rlock.acquire()
while task_handler.isAlive() and inqueue._reader.poll():
while task_handler.is_alive() and inqueue._reader.poll():
inqueue._reader.recv()
time.sleep(0)
@ -362,7 +362,7 @@ def _terminate_pool(cls, taskqueue, inqueue, outqueue, pool,
debug('helping task handler/workers to finish')
cls._help_stuff_finish(inqueue, task_handler, len(pool))
assert result_handler.isAlive() or len(cache) == 0
assert result_handler.is_alive() or len(cache) == 0
result_handler._state = TERMINATE
outqueue.put(None) # sentinel
@ -591,6 +591,6 @@ def _help_stuff_finish(inqueue, task_handler, size):
try:
inqueue.queue.clear()
inqueue.queue.extend([None] * size)
inqueue.not_empty.notifyAll()
inqueue.not_empty.notify_all()
finally:
inqueue.not_empty.release()

2
Lib/multiprocessing/queues.py
View file

@ -155,7 +155,7 @@ def _start_thread(self):
self._wlock, self._writer.close),
name='QueueFeederThread'
)
self._thread.setDaemon(True)
self._thread.set_daemon(True)
debug('doing self._thread.start()')
self._thread.start()

2
Lib/multiprocessing/reduction.py
View file

@ -84,7 +84,7 @@ def _get_listener():
debug('starting listener and thread for sending handles')
_listener = Listener(authkey=current_process().get_authkey())
t = threading.Thread(target=_serve)
t.setDaemon(True)
t.set_daemon(True)
t.start()
finally:
_lock.release()

8
Lib/multiprocessing/synchronize.py
View file

@ -109,8 +109,8 @@ def __repr__(self):
try:
if self._semlock._is_mine():
name = current_process().get_name()
if threading.currentThread().getName() != 'MainThread':
name += '|' + threading.currentThread().getName()
if threading.current_thread().get_name() != 'MainThread':
name += '|' + threading.current_thread().get_name()
elif self._semlock._get_value() == 1:
name = 'None'
elif self._semlock._count() > 0:
@ -134,8 +134,8 @@ def __repr__(self):
try:
if self._semlock._is_mine():
name = current_process().get_name()
if threading.currentThread().getName() != 'MainThread':
name += '|' + threading.currentThread().getName()
if threading.current_thread().get_name() != 'MainThread':
name += '|' + threading.current_thread().get_name()
count = self._semlock._count()
elif self._semlock._get_value() == 1:
name, count = 'None', 0

6
Lib/test/test_dummy_threading.py
View file

@ -16,7 +16,7 @@ def run(self):
#delay = random.random() * 2
delay = 0
if test_support.verbose:
print 'task', self.getName(), 'will run for', delay, 'sec'
print 'task', self.get_name(), 'will run for', delay, 'sec'
sema.acquire()
mutex.acquire()
running += 1
@ -25,11 +25,11 @@ def run(self):
mutex.release()
time.sleep(delay)
if test_support.verbose:
print 'task', self.getName(), 'done'
print 'task', self.get_name(), 'done'
mutex.acquire()
running -= 1
if test_support.verbose:
print self.getName(), 'is finished.', running, 'tasks are running'
print self.get_name(), 'is finished.', running, 'tasks are running'
mutex.release()
sema.release()

6
Lib/test/test_multiprocessing.py
View file

@ -632,7 +632,7 @@ def test_notify(self):
p.start()
p = threading.Thread(target=self.f, args=(cond, sleeping, woken))
p.setDaemon(True)
p.set_daemon(True)
p.start()
# wait for both children to start sleeping
@ -679,7 +679,7 @@ def test_notify_all(self):
t = threading.Thread(target=self.f,
args=(cond, sleeping, woken, TIMEOUT1))
t.setDaemon(True)
t.set_daemon(True)
t.start()
# wait for them all to sleep
@ -701,7 +701,7 @@ def test_notify_all(self):
p.start()
t = threading.Thread(target=self.f, args=(cond, sleeping, woken))
t.setDaemon(True)
t.set_daemon(True)
t.start()
# wait for them to all sleep

8
Lib/test/test_queue.py
View file

@ -49,11 +49,11 @@ def do_blocking_test(self, block_func, block_args, trigger_func, trigger_args):
self.t.start()
self.result = block_func(*block_args)
# If block_func returned before our thread made the call, we failed!
if not self.t.startedEvent.isSet():
if not self.t.startedEvent.is_set():
self.fail("blocking function '%r' appeared not to block" %
block_func)
self.t.join(10) # make sure the thread terminates
if self.t.isAlive():
if self.t.is_alive():
self.fail("trigger function '%r' appeared to not return" %
trigger_func)
return self.result
@ -73,10 +73,10 @@ def do_exceptional_blocking_test(self,block_func, block_args, trigger_func,
expected_exception_class)
finally:
self.t.join(10) # make sure the thread terminates
if self.t.isAlive():
if self.t.is_alive():
self.fail("trigger function '%r' appeared to not return" %
trigger_func)
if not self.t.startedEvent.isSet():
if not self.t.startedEvent.is_set():
self.fail("trigger thread ended but event never set")

4
Lib/test/test_smtplib.py
View file

@ -109,7 +109,7 @@ def debugging_server(serv, serv_evt, client_evt):
# when the client conversation is finished, it will
# set client_evt, and it's then ok to kill the server
if client_evt.isSet():
if client_evt.is_set():
serv.close()
break
@ -118,7 +118,7 @@ def debugging_server(serv, serv_evt, client_evt):
except socket.timeout:
pass
finally:
if not client_evt.isSet():
if not client_evt.is_set():
# allow some time for the client to read the result
time.sleep(0.5)
serv.close()

2
Lib/test/test_socket.py
View file

@ -107,7 +107,7 @@ def _setUp(self):
self.clientRun, (test_method,))
self.__setUp()
if not self.server_ready.isSet():
if not self.server_ready.is_set():
self.server_ready.set()
self.client_ready.wait()

2
Lib/test/test_socketserver.py
View file

@ -139,7 +139,7 @@ def run_server(self, svrcls, hdlrbase, testfunc):
# Time between requests is short enough that we won't wake
# up spuriously too many times.
kwargs={'poll_interval':0.01})
t.setDaemon(True) # In case this function raises.
t.set_daemon(True) # In case this function raises.
t.start()
if verbose: print "server running"
for i in range(3):

24
Lib/test/test_threading.py
View file

@ -34,7 +34,7 @@ def run(self):
delay = random.random() / 10000.0
if verbose:
print 'task %s will run for %.1f usec' % (
self.getName(), delay * 1e6)
self.get_name(), delay * 1e6)
with self.sema:
with self.mutex:
@ -45,14 +45,14 @@ def run(self):
time.sleep(delay)
if verbose:
print 'task', self.getName(), 'done'
print 'task', self.get_name(), 'done'
with self.mutex:
self.nrunning.dec()
self.testcase.assert_(self.nrunning.get() >= 0)
if verbose:
print '%s is finished. %d tasks are running' % (
self.getName(), self.nrunning.get())
self.get_name(), self.nrunning.get())
class ThreadTests(unittest.TestCase):
@ -73,7 +73,7 @@ def test_various_ops(self):
for i in range(NUMTASKS):
t = TestThread("<thread %d>"%i, self, sema, mutex, numrunning)
threads.append(t)
self.failUnlessEqual(t.getIdent(), None)
self.failUnlessEqual(t.get_ident(), None)
self.assert_(re.match('<TestThread\(.*, initial\)>', repr(t)))
t.start()
@ -81,8 +81,8 @@ def test_various_ops(self):
print 'waiting for all tasks to complete'
for t in threads:
t.join(NUMTASKS)
self.assert_(not t.isAlive())
self.failIfEqual(t.getIdent(), 0)
self.assert_(not t.is_alive())
self.failIfEqual(t.get_ident(), 0)
self.assert_(re.match('<TestThread\(.*, \w+ -?\d+\)>', repr(t)))
if verbose:
print 'all tasks done'
@ -172,7 +172,7 @@ def run(self):
worker_saw_exception.set()
t = Worker()
t.setDaemon(True) # so if this fails, we don't hang Python at shutdown
t.set_daemon(True) # so if this fails, we don't hang Python at shutdown
t.start()
if verbose:
print " started worker thread"
@ -258,12 +258,12 @@ def killer():
print 'program blocked; aborting'
os._exit(2)
t = threading.Thread(target=killer)
t.setDaemon(True)
t.set_daemon(True)
t.start()
# This is the trace function
def func(frame, event, arg):
threading.currentThread()
threading.current_thread()
return func
sys.settrace(func)
@ -348,8 +348,8 @@ def test_semaphore_with_negative_value(self):
self.assertRaises(ValueError, threading.Semaphore, value = -sys.maxint)
def test_joining_current_thread(self):
currentThread = threading.currentThread()
self.assertRaises(RuntimeError, currentThread.join);
current_thread = threading.current_thread()
self.assertRaises(RuntimeError, current_thread.join);
def test_joining_inactive_thread(self):
thread = threading.Thread()
@ -358,7 +358,7 @@ def test_joining_inactive_thread(self):
def test_daemonize_active_thread(self):
thread = threading.Thread()
thread.start()
self.assertRaises(RuntimeError, thread.setDaemon, True)
self.assertRaises(RuntimeError, thread.set_daemon, True)
def test_main():

2
Lib/test/threaded_import_hangers.py
View file

@ -38,5 +38,5 @@ def run(self):
t = Worker(func, args)
t.start()
t.join(TIMEOUT)
if t.isAlive():
if t.is_alive():
errors.append("%s appeared to hang" % name)

70
Lib/threading.py
View file

@ -14,7 +14,7 @@
from collections import deque
# Rename some stuff so "from threading import *" is safe
__all__ = ['activeCount', 'Condition', 'currentThread', 'enumerate', 'Event',
__all__ = ['active_count', 'Condition', 'current_thread', 'enumerate', 'Event',
'Lock', 'RLock', 'Semaphore', 'BoundedSemaphore', 'Thread',
'Timer', 'setprofile', 'settrace', 'local', 'stack_size']
@ -52,7 +52,7 @@ def _note(self, format, *args):
if self.__verbose:
format = format % args
format = "%s: %s\n" % (
currentThread().getName(), format)
current_thread().get_name(), format)
_sys.stderr.write(format)
else:
@ -95,11 +95,11 @@ def __repr__(self):
owner = self.__owner
return "<%s(%s, %d)>" % (
self.__class__.__name__,
owner and owner.getName(),
owner and owner.get_name(),
self.__count)
def acquire(self, blocking=1):
me = currentThread()
me = current_thread()
if self.__owner is me:
self.__count = self.__count + 1
if __debug__:
@ -119,7 +119,7 @@ def acquire(self, blocking=1):
__enter__ = acquire
def release(self):
if self.__owner is not currentThread():
if self.__owner is not current_thread():
raise RuntimeError("cannot release un-aquired lock")
self.__count = count = self.__count - 1
if not count:
@ -154,7 +154,7 @@ def _release_save(self):
return (count, owner)
def _is_owned(self):
return self.__owner is currentThread()
return self.__owner is current_thread()
def Condition(*args, **kwargs):
@ -203,7 +203,7 @@ def _acquire_restore(self, x):
self.__lock.acquire() # Ignore saved state
def _is_owned(self):
# Return True if lock is owned by currentThread.
# Return True if lock is owned by current_thread.
# This method is called only if __lock doesn't have _is_owned().
if self.__lock.acquire(0):
self.__lock.release()
@ -271,7 +271,7 @@ def notify(self, n=1):
except ValueError:
pass
def notifyAll(self):
def notify_all(self):
self.notify(len(self.__waiters))
@ -350,14 +350,14 @@ def __init__(self, verbose=None):
self.__cond = Condition(Lock())
self.__flag = False
def isSet(self):
def is_set(self):
return self.__flag
def set(self):
self.__cond.acquire()
try:
self.__flag = True
self.__cond.notifyAll()
self.__cond.notify_all()
finally:
self.__cond.release()
@ -425,12 +425,12 @@ def __init__(self, group=None, target=None, name=None,
def _set_daemon(self):
# Overridden in _MainThread and _DummyThread
return currentThread().isDaemon()
return current_thread().is_daemon()
def __repr__(self):
assert self.__initialized, "Thread.__init__() was not called"
status = "initial"
if self.__started.isSet():
if self.__started.is_set():
status = "started"
if self.__stopped:
status = "stopped"
@ -443,7 +443,7 @@ def __repr__(self):
def start(self):
if not self.__initialized:
raise RuntimeError("thread.__init__() not called")
if self.__started.isSet():
if self.__started.is_set():
raise RuntimeError("thread already started")
if __debug__:
self._note("%s.start(): starting thread", self)
@ -514,7 +514,7 @@ def __bootstrap_inner(self):
# self.
if _sys:
_sys.stderr.write("Exception in thread %s:\n%s\n" %
(self.getName(), _format_exc()))
(self.get_name(), _format_exc()))
else:
# Do the best job possible w/o a huge amt. of code to
# approximate a traceback (code ideas from
@ -522,7 +522,7 @@ def __bootstrap_inner(self):
exc_type, exc_value, exc_tb = self.__exc_info()
try:
print>>self.__stderr, (
"Exception in thread " + self.getName() +
"Exception in thread " + self.get_name() +
" (most likely raised during interpreter shutdown):")
print>>self.__stderr, (
"Traceback (most recent call last):")
@ -560,7 +560,7 @@ def __bootstrap_inner(self):
def __stop(self):
self.__block.acquire()
self.__stopped = True
self.__block.notifyAll()
self.__block.notify_all()
self.__block.release()
def __delete(self):
@ -593,7 +593,7 @@ def __delete(self):
# There must not be any python code between the previous line
# and after the lock is released. Otherwise a tracing function
# could try to acquire the lock again in the same thread, (in
# currentThread()), and would block.
# current_thread()), and would block.
except KeyError:
if 'dummy_threading' not in _sys.modules:
raise
@ -601,9 +601,9 @@ def __delete(self):
def join(self, timeout=None):
if not self.__initialized:
raise RuntimeError("Thread.__init__() not called")
if not self.__started.isSet():
if not self.__started.is_set():
raise RuntimeError("cannot join thread before it is started")
if self is currentThread():
if self is current_thread():
raise RuntimeError("cannot join current thread")
if __debug__:
@ -631,30 +631,30 @@ def join(self, timeout=None):
finally:
self.__block.release()
def getName(self):
def get_name(self):
assert self.__initialized, "Thread.__init__() not called"
return self.__name
def setName(self, name):
def set_name(self, name):
assert self.__initialized, "Thread.__init__() not called"
self.__name = str(name)
def getIdent(self):
def get_ident(self):
assert self.__initialized, "Thread.__init__() not called"
return self.__ident
def isAlive(self):
def is_alive(self):
assert self.__initialized, "Thread.__init__() not called"
return self.__started.isSet() and not self.__stopped
return self.__started.is_set() and not self.__stopped
def isDaemon(self):
def is_daemon(self):
assert self.__initialized, "Thread.__init__() not called"
return self.__daemonic
def setDaemon(self, daemonic):
def set_daemon(self, daemonic):
if not self.__initialized:
raise RuntimeError("Thread.__init__() not called")
if self.__started.isSet():
if self.__started.is_set():
raise RuntimeError("cannot set daemon status of active thread");
self.__daemonic = daemonic
@ -685,7 +685,7 @@ def cancel(self):
def run(self):
self.finished.wait(self.interval)
if not self.finished.isSet():
if not self.finished.is_set():
self.function(*self.args, **self.kwargs)
self.finished.set()
@ -719,16 +719,16 @@ def _exitfunc(self):
def _pickSomeNonDaemonThread():
for t in enumerate():
if not t.isDaemon() and t.isAlive():
if not t.is_daemon() and t.is_alive():
return t
return None
# Dummy thread class to represent threads not started here.
# These aren't garbage collected when they die, nor can they be waited for.
# If they invoke anything in threading.py that calls currentThread(), they
# If they invoke anything in threading.py that calls current_thread(), they
# leave an entry in the _active dict forever after.
# Their purpose is to return *something* from currentThread().
# Their purpose is to return *something* from current_thread().
# They are marked as daemon threads so we won't wait for them
# when we exit (conform previous semantics).
@ -756,14 +756,14 @@ def join(self, timeout=None):
# Global API functions
def currentThread():
def current_thread():
try:
return _active[_get_ident()]
except KeyError:
##print "currentThread(): no current thread for", _get_ident()
##print "current_thread(): no current thread for", _get_ident()
return _DummyThread()
def activeCount():
def active_count():
_active_limbo_lock.acquire()
count = len(_active) + len(_limbo)
_active_limbo_lock.release()
@ -840,7 +840,7 @@ def run(self):
counter = 0
while counter < self.quota:
counter = counter + 1
self.queue.put("%s.%d" % (self.getName(), counter))
self.queue.put("%s.%d" % (self.get_name(), counter))
_sleep(random() * 0.00001)

1
Misc/NEWS
View file

@ -291,6 +291,7 @@ Library
- The bundled OSX-specific copy of libbffi is now in sync with the version
shipped with PyObjC 2.0 and includes support for x86_64 and ppc64 platforms.
Build
-----