diff options
| -rw-r--r-- | Doc/includes/mp_distributing.py | 2 | ||||
| -rw-r--r-- | Doc/library/queue.rst | 2 | ||||
| -rw-r--r-- | Doc/library/socketserver.rst | 8 | ||||
| -rw-r--r-- | Doc/library/threading.rst | 22 | ||||
| -rw-r--r-- | Lib/decimal.py | 12 | ||||
| -rw-r--r-- | Lib/idlelib/rpc.py | 2 | ||||
| -rw-r--r-- | Misc/NEWS | 2 |
7 files changed, 25 insertions, 25 deletions
diff --git a/Doc/includes/mp_distributing.py b/Doc/includes/mp_distributing.py index 24ae8f8..5cd12bb 100644 --- a/Doc/includes/mp_distributing.py +++ b/Doc/includes/mp_distributing.py @@ -243,7 +243,7 @@ class SettableQueue(Queue.Queue): try: self.queue.clear() self.queue.extend(contents) - self.not_empty.notifyAll() + self.not_empty.notify_all() finally: self.not_empty.release() diff --git a/Doc/library/queue.rst b/Doc/library/queue.rst index 4b9a1eb..fa09fc5 100644 --- a/Doc/library/queue.rst +++ b/Doc/library/queue.rst @@ -147,7 +147,7 @@ Example of how to wait for enqueued tasks to be completed:: q = Queue() for i in range(num_worker_threads): t = Thread(target=worker) - t.setDaemon(True) + t.set_daemon(True) t.start() for item in source(): diff --git a/Doc/library/socketserver.rst b/Doc/library/socketserver.rst index b176ca3..221de2e 100644 --- a/Doc/library/socketserver.rst +++ b/Doc/library/socketserver.rst @@ -480,8 +480,8 @@ An example for the :class:`ThreadingMixIn` class:: def handle(self): data = self.request.recv(1024) - cur_thread = threading.currentThread() - response = "%s: %s" % (cur_thread.getName(), data) + cur_thread = threading.current_thread() + response = "%s: %s" % (cur_thread.get_name(), data) self.request.send(response) class ThreadedTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer): @@ -506,9 +506,9 @@ An example for the :class:`ThreadingMixIn` class:: # more thread for each request server_thread = threading.Thread(target=server.serve_forever) # Exit the server thread when the main thread terminates - server_thread.setDaemon(True) + server_thread.set_daemon(True) server_thread.start() - print "Server loop running in thread:", t.getName() + print "Server loop running in thread:", t.get_name() client(ip, port, "Hello World 1") client(ip, port, "Hello World 2") diff --git a/Doc/library/threading.rst b/Doc/library/threading.rst index f37c73b..3c5fefd 100644 --- a/Doc/library/threading.rst +++ b/Doc/library/threading.rst @@ -283,29 +283,29 @@ several condition variables must share the same lock.) A condition variable has :meth:`acquire` and :meth:`release` methods that call the corresponding methods of the associated lock. It also has a :meth:`wait` -method, and :meth:`notify` and :meth:`notifyAll` methods. These three must only +method, and :meth:`notify` and :meth:`notify_all` methods. These three must only be called when the calling thread has acquired the lock, otherwise a :exc:`RuntimeError` is raised. The :meth:`wait` method releases the lock, and then blocks until it is awakened -by a :meth:`notify` or :meth:`notifyAll` call for the same condition variable in +by a :meth:`notify` or :meth:`notify_all` call for the same condition variable in another thread. Once awakened, it re-acquires the lock and returns. It is also possible to specify a timeout. The :meth:`notify` method wakes up one of the threads waiting for the condition -variable, if any are waiting. The :meth:`notifyAll` method wakes up all threads +variable, if any are waiting. The :meth:`notify_all` method wakes up all threads waiting for the condition variable. -Note: the :meth:`notify` and :meth:`notifyAll` methods don't release the lock; +Note: the :meth:`notify` and :meth:`notify_all` methods don't release the lock; this means that the thread or threads awakened will not return from their :meth:`wait` call immediately, but only when the thread that called -:meth:`notify` or :meth:`notifyAll` finally relinquishes ownership of the lock. +:meth:`notify` or :meth:`notify_all` finally relinquishes ownership of the lock. Tip: the typical programming style using condition variables uses the lock to synchronize access to some shared state; threads that are interested in a particular change of state call :meth:`wait` repeatedly until they see the desired state, while threads that modify the state call :meth:`notify` or -:meth:`notifyAll` when they change the state in such a way that it could +:meth:`notify_all` when they change the state in such a way that it could possibly be a desired state for one of the waiters. For example, the following code is a generic producer-consumer situation with unlimited buffer capacity:: @@ -322,7 +322,7 @@ code is a generic producer-consumer situation with unlimited buffer capacity:: cv.notify() cv.release() -To choose between :meth:`notify` and :meth:`notifyAll`, consider whether one +To choose between :meth:`notify` and :meth:`notify_all`, consider whether one state change can be interesting for only one or several waiting threads. E.g. in a typical producer-consumer situation, adding one item to the buffer only needs to wake up one consumer thread. @@ -353,7 +353,7 @@ needs to wake up one consumer thread. acquired the lock when this method is called, a :exc:`RuntimeError` is raised. This method releases the underlying lock, and then blocks until it is awakened - by a :meth:`notify` or :meth:`notifyAll` call for the same condition variable in + by a :meth:`notify` or :meth:`notify_all` call for the same condition variable in another thread, or until the optional timeout occurs. Once awakened or timed out, it re-acquires the lock and returns. @@ -490,7 +490,7 @@ An event object manages an internal flag that can be set to true with the The internal flag is initially false. -.. method:: Event.isSet() +.. method:: Event.is_set() Return true if and only if the internal flag is true. @@ -537,7 +537,7 @@ separate thread of control. Once the thread's activity is started, the thread is considered 'alive'. It stops being alive when its :meth:`run` method terminates -- either normally, or -by raising an unhandled exception. The :meth:`isAlive` method tests whether the +by raising an unhandled exception. The :meth:`is_alive` method tests whether the thread is alive. Other threads can call a thread's :meth:`join` method. This blocks the calling @@ -614,7 +614,7 @@ impossible to detect the termination of alien threads. When the *timeout* argument is present and not ``None``, it should be a floating point number specifying a timeout for the operation in seconds (or fractions - thereof). As :meth:`join` always returns ``None``, you must call :meth:`isAlive` + thereof). As :meth:`join` always returns ``None``, you must call :meth:`is_alive` after :meth:`join` to decide whether a timeout happened -- if the thread is still alive, the :meth:`join` call timed out. diff --git a/Lib/decimal.py b/Lib/decimal.py index a61025a..e1d69fd 100644 --- a/Lib/decimal.py +++ b/Lib/decimal.py @@ -383,7 +383,7 @@ _condition_map = {ConversionSyntax:InvalidOperation, # The getcontext() and setcontext() function manage access to a thread-local # current context. Py2.4 offers direct support for thread locals. If that -# is not available, use threading.currentThread() which is slower but will +# is not available, use threading.current_thread() which is slower but will # work for older Pythons. If threads are not part of the build, create a # mock threading object with threading.local() returning the module namespace. @@ -405,15 +405,15 @@ except AttributeError: # To fix reloading, force it to create a new context # Old contexts have different exceptions in their dicts, making problems. - if hasattr(threading.currentThread(), '__decimal_context__'): - del threading.currentThread().__decimal_context__ + if hasattr(threading.current_thread(), '__decimal_context__'): + del threading.current_thread().__decimal_context__ def setcontext(context): """Set this thread's context to context.""" if context in (DefaultContext, BasicContext, ExtendedContext): context = context.copy() context.clear_flags() - threading.currentThread().__decimal_context__ = context + threading.current_thread().__decimal_context__ = context def getcontext(): """Returns this thread's context. @@ -423,10 +423,10 @@ except AttributeError: New contexts are copies of DefaultContext. """ try: - return threading.currentThread().__decimal_context__ + return threading.current_thread().__decimal_context__ except AttributeError: context = Context() - threading.currentThread().__decimal_context__ = context + threading.current_thread().__decimal_context__ = context return context else: diff --git a/Lib/idlelib/rpc.py b/Lib/idlelib/rpc.py index a749353..d4af81d 100644 --- a/Lib/idlelib/rpc.py +++ b/Lib/idlelib/rpc.py @@ -149,7 +149,7 @@ class SocketIO(object): def debug(self, *args): if not self.debugging: return - s = self.location + " " + str(threading.current_thread().getName()) + s = self.location + " " + str(threading.current_thread().get_name()) for a in args: s = s + " " + str(a) print(s, file=sys.__stderr__) @@ -175,7 +175,7 @@ Library - The test.test_support module has been renamed to test.support. -- The threading module API's were renamed to by PEP 8 complaint. +- The threading module API was renamed to be PEP 8 complaint. Tools/Demos ----------- |