CINXE.COM

<!DOCTYPE html> <html lang="en"> <head> <meta charset="utf-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <meta name="color-scheme" content="light dark"> <title>PEP 319 – Python Synchronize/Asynchronize Block | peps.python.org</title> <link rel="shortcut icon" href="../_static/py.png"> <link rel="canonical" href="https://peps.python.org/pep-0319/"> <link rel="stylesheet" href="../_static/style.css" type="text/css"> <link rel="stylesheet" href="../_static/mq.css" type="text/css"> <link rel="stylesheet" href="../_static/pygments.css" type="text/css" media="(prefers-color-scheme: light)" id="pyg-light"> <link rel="stylesheet" href="../_static/pygments_dark.css" type="text/css" media="(prefers-color-scheme: dark)" id="pyg-dark"> <link rel="alternate" type="application/rss+xml" title="Latest PEPs" href="https://peps.python.org/peps.rss"> <meta property="og:title" content='PEP 319 – Python Synchronize/Asynchronize Block | peps.python.org'> <meta property="og:description" content="This PEP proposes adding two new keywords to Python, ‘synchronize’ and ‘asynchronize’."> <meta property="og:type" content="website"> <meta property="og:url" content="https://peps.python.org/pep-0319/"> <meta property="og:site_name" content="Python Enhancement Proposals (PEPs)"> <meta property="og:image" content="https://peps.python.org/_static/og-image.png"> <meta property="og:image:alt" content="Python PEPs"> <meta property="og:image:width" content="200"> <meta property="og:image:height" content="200"> <meta name="description" content="This PEP proposes adding two new keywords to Python, ‘synchronize’ and ‘asynchronize’."> <meta name="theme-color" content="#3776ab"> </head> <body> <svg xmlns="http://www.w3.org/2000/svg" style="display: none;"> <symbol id="svg-sun-half" viewBox="0 0 24 24" pointer-events="all"> <title>Following system colour scheme</title> <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"> <circle cx="12" cy="12" r="9"></circle> <path d="M12 3v18m0-12l4.65-4.65M12 14.3l7.37-7.37M12 19.6l8.85-8.85"></path> </svg> </symbol> <symbol id="svg-moon" viewBox="0 0 24 24" pointer-events="all"> <title>Selected dark colour scheme</title> <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"> <path stroke="none" d="M0 0h24v24H0z" fill="none"></path> <path d="M12 3c.132 0 .263 0 .393 0a7.5 7.5 0 0 0 7.92 12.446a9 9 0 1 1 -8.313 -12.454z"></path> </svg> </symbol> <symbol id="svg-sun" viewBox="0 0 24 24" pointer-events="all"> <title>Selected light colour scheme</title> <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"> <circle cx="12" cy="12" r="5"></circle> <line x1="12" y1="1" x2="12" y2="3"></line> <line x1="12" y1="21" x2="12" y2="23"></line> <line x1="4.22" y1="4.22" x2="5.64" y2="5.64"></line> <line x1="18.36" y1="18.36" x2="19.78" y2="19.78"></line> <line x1="1" y1="12" x2="3" y2="12"></line> <line x1="21" y1="12" x2="23" y2="12"></line> <line x1="4.22" y1="19.78" x2="5.64" y2="18.36"></line> <line x1="18.36" y1="5.64" x2="19.78" y2="4.22"></line> </svg> </symbol> </svg> <script> document.documentElement.dataset.colour_scheme = localStorage.getItem("colour_scheme") || "auto" </script> <section id="pep-page-section"> <header> <h1>Python Enhancement Proposals</h1> <ul class="breadcrumbs"> <li><a href="https://www.python.org/" title="The Python Programming Language">Python</a> » </li> <li><a href="../pep-0000/">PEP Index</a> » </li> <li>PEP 319</li> </ul> <button id="colour-scheme-cycler" onClick="setColourScheme(nextColourScheme())"> <svg aria-hidden="true" class="colour-scheme-icon-when-auto"><use href="#svg-sun-half"></use></svg> <svg aria-hidden="true" class="colour-scheme-icon-when-dark"><use href="#svg-moon"></use></svg> <svg aria-hidden="true" class="colour-scheme-icon-when-light"><use href="#svg-sun"></use></svg> Toggle light / dark / auto colour theme </button> </header> <article> <section id="pep-content"> <h1 class="page-title">PEP 319 – Python Synchronize/Asynchronize Block</h1> <dl class="rfc2822 field-list simple"> <dt class="field-odd">Author:</dt> <dd class="field-odd">Michel Pelletier <michel at users.sourceforge.net></dd> <dt class="field-even">Status:</dt> <dd class="field-even"><abbr title="Formally declined and will not be accepted">Rejected</abbr></dd> <dt class="field-odd">Type:</dt> <dd class="field-odd"><abbr title="Normative PEP with a new feature for Python, implementation change for CPython or interoperability standard for the ecosystem">Standards Track</abbr></dd> <dt class="field-even">Created:</dt> <dd class="field-even">24-Feb-2003</dd> <dt class="field-odd">Python-Version:</dt> <dd class="field-odd">2.4</dd> <dt class="field-even">Post-History:</dt> <dd class="field-even"></dd> </dl> <hr class="docutils" /> <section id="contents"> <details><summary>Table of Contents</summary><ul class="simple"> <li><a class="reference internal" href="#abstract">Abstract</a></li> <li><a class="reference internal" href="#pronouncement">Pronouncement</a></li> <li><a class="reference internal" href="#synchronization-targets">Synchronization Targets</a></li> <li><a class="reference internal" href="#other-patterns-that-synchronize">Other Patterns that Synchronize</a></li> <li><a class="reference internal" href="#formal-syntax">Formal Syntax</a></li> <li><a class="reference internal" href="#proposed-implementation">Proposed Implementation</a></li> <li><a class="reference internal" href="#backward-compatibility">Backward Compatibility</a></li> <li><a class="reference internal" href="#pep-310-reliable-acquisition-release-pairs">PEP 310 Reliable Acquisition/Release Pairs</a></li> <li><a class="reference internal" href="#how-java-does-it">How Java Does It</a></li> <li><a class="reference internal" href="#how-jython-does-it">How Jython Does It</a></li> <li><a class="reference internal" href="#summary-of-proposed-changes-to-python">Summary of Proposed Changes to Python</a></li> <li><a class="reference internal" href="#risks">Risks</a></li> <li><a class="reference internal" href="#dissenting-opinion">Dissenting Opinion</a></li> <li><a class="reference internal" href="#references">References</a></li> <li><a class="reference internal" href="#copyright">Copyright</a></li> </ul> </details></section> <section id="abstract"> <h2><a class="toc-backref" href="#abstract" role="doc-backlink">Abstract</a></h2> This PEP proposes adding two new keywords to Python, ‘synchronize’ and ‘asynchronize’. </section> <section id="pronouncement"> <h2><a class="toc-backref" href="#pronouncement" role="doc-backlink">Pronouncement</a></h2> This PEP is rejected in favor of <a class="pep reference internal" href="../pep-0343/" title="PEP 343 – The “with” Statement">PEP 343</a>. <dl> <dt>The ‘synchronize’ Keyword</dt><dd>The concept of code synchronization in Python is too low-level. To synchronize code a programmer must be aware of the details of the following pseudo-code pattern:<div class="highlight-default notranslate"><div class="highlight"><pre>initialize_lock() ... acquire_lock() try: change_shared_data() finally: release_lock() </pre></div> </div> This synchronized block pattern is not the only pattern (more discussed below) but it is very common. This PEP proposes replacing the above code with the following equivalent: <div class="highlight-default notranslate"><div class="highlight"><pre>synchronize: change_shared_data() </pre></div> </div> The advantages of this scheme are simpler syntax and less room for user error. Currently users are required to write code about acquiring and releasing thread locks in ‘try/finally’ blocks; errors in this code can cause notoriously difficult concurrent thread locking issues. </dd> <dt>The ‘asynchronize’ Keyword</dt><dd>While executing a ‘synchronize’ block of code a programmer may want to “drop back” to running asynchronously momentarily to run blocking input/output routines or something else that might take an indeterminate amount of time and does not require synchronization. This code usually follows the pattern:<div class="highlight-default notranslate"><div class="highlight"><pre>initialize_lock() ... acquire_lock() try: change_shared_data() release_lock() # become async do_blocking_io() acquire_lock() # sync again change_shared_data2() finally: release_lock() </pre></div> </div> The asynchronous section of the code is not very obvious visually, so it is marked up with comments. Using the proposed ‘asynchronize’ keyword this code becomes much cleaner, easier to understand, and less prone to error: <div class="highlight-default notranslate"><div class="highlight"><pre>synchronize: change_shared_data() asynchronize: do_blocking_io() change_shared_data2() </pre></div> </div> Encountering an ‘asynchronize’ keyword inside a non-synchronized block can raise either an error or issue a warning (as all code blocks are implicitly asynchronous anyway). It is important to note that the above example is not the same as: <div class="highlight-default notranslate"><div class="highlight"><pre>synchronize: change_shared_data() do_blocking_io() synchronize: change_shared_data2() </pre></div> </div> Because both synchronized blocks of code may be running inside the same iteration of a loop, Consider: <div class="highlight-default notranslate"><div class="highlight"><pre>while in_main_loop(): synchronize: change_shared_data() asynchronize: do_blocking_io() change_shared_data2() </pre></div> </div> Many threads may be looping through this code. Without the ‘asynchronize’ keyword one thread cannot stay in the loop and release the lock at the same time while blocking IO is going on. This pattern of releasing locks inside a main loop to do blocking IO is used extensively inside the CPython interpreter itself. </dd> </dl> </section> <section id="synchronization-targets"> <h2><a class="toc-backref" href="#synchronization-targets" role="doc-backlink">Synchronization Targets</a></h2> As proposed the ‘synchronize’ and ‘asynchronize’ keywords synchronize a block of code. However programmers may want to specify a target object that threads synchronize on. Any object can be a synchronization target. Consider a two-way queue object: two different objects are used by the same ‘synchronize’ code block to synchronize both queues separately in the ‘get’ method: <div class="highlight-default notranslate"><div class="highlight"><pre>class TwoWayQueue: def __init__(self): self.front = [] self.rear = [] def putFront(self, item): self.put(item, self.front) def getFront(self): item = self.get(self.front) return item def putRear(self, item): self.put(item, self.rear) def getRear(self): item = self.get(self.rear) return item def put(self, item, queue): synchronize queue: queue.append(item) def get(self, queue): synchronize queue: item = queue[0] del queue[0] return item </pre></div> </div> Here is the equivalent code in Python as it is now without a ‘synchronize’ keyword: <div class="highlight-default notranslate"><div class="highlight"><pre>import thread class LockableQueue: def __init__(self): self.queue = [] self.lock = thread.allocate_lock() class TwoWayQueue: def __init__(self): self.front = LockableQueue() self.rear = LockableQueue() def putFront(self, item): self.put(item, self.front) def getFront(self): item = self.get(self.front) return item def putRear(self, item): self.put(item, self.rear) def getRear(self): item = self.get(self.rear) return item def put(self, item, queue): queue.lock.acquire() try: queue.append(item) finally: queue.lock.release() def get(self, queue): queue.lock.acquire() try: item = queue[0] del queue[0] return item finally: queue.lock.release() </pre></div> </div> The last example had to define an extra class to associate a lock with the queue where the first example the ‘synchronize’ keyword does this association internally and transparently. </section> <section id="other-patterns-that-synchronize"> <h2><a class="toc-backref" href="#other-patterns-that-synchronize" role="doc-backlink">Other Patterns that Synchronize</a></h2> There are some situations where the ‘synchronize’ and ‘asynchronize’ keywords cannot entirely replace the use of lock methods like <code class="docutils literal notranslate">acquire</code> and <code class="docutils literal notranslate">release</code>. Some examples are if the programmer wants to provide arguments for <code class="docutils literal notranslate">acquire</code> or if a lock is acquired in one code block but released in another, as shown below. Here is a class from Zope modified to use both the ‘synchronize’ and ‘asynchronize’ keywords and also uses a pool of explicit locks that are acquired and released in different code blocks and thus don’t use ‘synchronize’: <div class="highlight-default notranslate"><div class="highlight"><pre>import thread from ZServerPublisher import ZServerPublisher class ZRendevous: def __init__(self, n=1): pool=[] self._lists=pool, [], [] synchronize: while n > 0: l=thread.allocate_lock() l.acquire() pool.append(l) thread.start_new_thread(ZServerPublisher, (self.accept,)) n=n-1 def accept(self): synchronize: pool, requests, ready = self._lists while not requests: l=pool[-1] del pool[-1] ready.append(l) asynchronize: l.acquire() pool.append(l) r=requests[0] del requests[0] return r def handle(self, name, request, response): synchronize: pool, requests, ready = self._lists requests.append((name, request, response)) if ready: l=ready[-1] del ready[-1] l.release() </pre></div> </div> Here is the original class as found in the ‘Zope/ZServer/PubCore/ZRendevous.py’ module. The “convenience” of the ‘_a’ and ‘_r’ shortcut names obscure the code: <div class="highlight-default notranslate"><div class="highlight"><pre>import thread from ZServerPublisher import ZServerPublisher class ZRendevous: def __init__(self, n=1): sync=thread.allocate_lock() self._a=sync.acquire self._r=sync.release pool=[] self._lists=pool, [], [] self._a() try: while n > 0: l=thread.allocate_lock() l.acquire() pool.append(l) thread.start_new_thread(ZServerPublisher, (self.accept,)) n=n-1 finally: self._r() def accept(self): self._a() try: pool, requests, ready = self._lists while not requests: l=pool[-1] del pool[-1] ready.append(l) self._r() l.acquire() self._a() pool.append(l) r=requests[0] del requests[0] return r finally: self._r() def handle(self, name, request, response): self._a() try: pool, requests, ready = self._lists requests.append((name, request, response)) if ready: l=ready[-1] del ready[-1] l.release() finally: self._r() </pre></div> </div> In particular the asynchronize section of the <code class="docutils literal notranslate">accept</code> method is not very obvious. To beginner programmers, ‘synchronize’ and ‘asynchronize’ remove many of the problems encountered when juggling multiple <code class="docutils literal notranslate">acquire</code> and <code class="docutils literal notranslate">release</code> methods on different locks in different <code class="docutils literal notranslate">try/finally</code> blocks. </section> <section id="formal-syntax"> <h2><a class="toc-backref" href="#formal-syntax" role="doc-backlink">Formal Syntax</a></h2> Python syntax is defined in a modified BNF grammar notation described in the Python Language Reference <a class="footnote-reference brackets" href="#id2" id="id1">[1]</a>. This section describes the proposed synchronization syntax using this grammar: <div class="highlight-default notranslate"><div class="highlight"><pre>synchronize_stmt: 'synchronize' [test] ':' suite asynchronize_stmt: 'asynchronize' [test] ':' suite compound_stmt: ... | synchronized_stmt | asynchronize_stmt </pre></div> </div> (The ‘…’ indicates other compound statements elided). </section> <section id="proposed-implementation"> <h2><a class="toc-backref" href="#proposed-implementation" role="doc-backlink">Proposed Implementation</a></h2> The author of this PEP has not explored an implementation yet. There are several implementation issues that must be resolved. The main implementation issue is what exactly gets locked and unlocked during a synchronized block. During an unqualified synchronized block (the use of the ‘synchronize’ keyword without a target argument) a lock could be created and associated with the synchronized code block object. Any threads that are to execute the block must first acquire the code block lock. When an ‘asynchronize’ keyword is encountered in a ‘synchronize’ block the code block lock is unlocked before the inner block is executed and re-locked when the inner block terminates. When a synchronized block target is specified the object is associated with a lock. How this is implemented cleanly is probably the highest risk of this proposal. Java Virtual Machines typically associate a special hidden lock object with target object and use it to synchronized the block around the target only. </section> <section id="backward-compatibility"> <h2><a class="toc-backref" href="#backward-compatibility" role="doc-backlink">Backward Compatibility</a></h2> Backward compatibility is solved with the new <code class="docutils literal notranslate">from __future__</code> Python syntax (<a class="pep reference internal" href="../pep-0236/" title="PEP 236 – Back to the __future__">PEP 236</a>), and the new warning framework (<a class="pep reference internal" href="../pep-0230/" title="PEP 230 – Warning Framework">PEP 230</a>) to evolve the Python language into phasing out any conflicting names that use the new keywords ‘synchronize’ and ‘asynchronize’. To use the syntax now, a developer could use the statement: <div class="highlight-default notranslate"><div class="highlight"><pre>from __future__ import threadsync # or whatever </pre></div> </div> In addition, any code that uses the keyword ‘synchronize’ or ‘asynchronize’ as an identifier will be issued a warning from Python. After the appropriate period of time, the syntax would become standard, the above import statement would do nothing, and any identifiers named ‘synchronize’ or ‘asynchronize’ would raise an exception. </section> <section id="pep-310-reliable-acquisition-release-pairs"> <h2><a class="toc-backref" href="#pep-310-reliable-acquisition-release-pairs" role="doc-backlink">PEP 310 Reliable Acquisition/Release Pairs</a></h2> <a class="pep reference internal" href="../pep-0310/" title="PEP 310 – Reliable Acquisition/Release Pairs">PEP 310</a> proposes the ‘with’ keyword that can serve the same function as ‘synchronize’ (but no facility for ‘asynchronize’). The pattern: <div class="highlight-default notranslate"><div class="highlight"><pre>initialize_lock() with the_lock: change_shared_data() </pre></div> </div> is equivalent to the proposed: <div class="highlight-default notranslate"><div class="highlight"><pre>synchronize the_lock: change_shared_data() </pre></div> </div> <a class="pep reference internal" href="../pep-0310/" title="PEP 310 – Reliable Acquisition/Release Pairs">PEP 310</a> must synchronize on an existing lock, while this PEP proposes that unqualified ‘synchronize’ statements synchronize on a global, internal, transparent lock in addition to qualified ‘synchronize’ statements. The ‘with’ statement also requires lock initialization, while the ‘synchronize’ statement can synchronize on any target object including locks. While limited in this fashion, the ‘with’ statement is more abstract and serves more purposes than synchronization. For example, transactions could be used with the ‘with’ keyword: <div class="highlight-default notranslate"><div class="highlight"><pre>initialize_transaction() with my_transaction: do_in_transaction() # when the block terminates, the transaction is committed. </pre></div> </div> The ‘synchronize’ and ‘asynchronize’ keywords cannot serve this or any other general acquire/release pattern other than thread synchronization. </section> <section id="how-java-does-it"> <h2><a class="toc-backref" href="#how-java-does-it" role="doc-backlink">How Java Does It</a></h2> Java defines a ‘synchronized’ keyword (note the grammatical tense different between the Java keyword and this PEP’s ‘synchronize’) which must be qualified on any object. The syntax is: <div class="highlight-default notranslate"><div class="highlight"><pre>synchronized (Expression) Block </pre></div> </div> Expression must yield a valid object (null raises an error and exceptions during ‘Expression’ terminate the ‘synchronized’ block for the same reason) upon which ‘Block’ is synchronized. </section> <section id="how-jython-does-it"> <h2><a class="toc-backref" href="#how-jython-does-it" role="doc-backlink">How Jython Does It</a></h2> Jython uses a ‘synchronize’ class with the static method ‘make_synchronized’ that accepts one callable argument and returns a newly created, synchronized, callable “wrapper” around the argument. </section> <section id="summary-of-proposed-changes-to-python"> <h2><a class="toc-backref" href="#summary-of-proposed-changes-to-python" role="doc-backlink">Summary of Proposed Changes to Python</a></h2> Adding new ‘synchronize’ and ‘asynchronize’ keywords to the language. </section> <section id="risks"> <h2><a class="toc-backref" href="#risks" role="doc-backlink">Risks</a></h2> This PEP proposes adding two keywords to the Python language. This may break code. There is no implementation to test. It’s not the most important problem facing Python programmers today (although it is a fairly notorious one). The equivalent Java keyword is the past participle ‘synchronized’. This PEP proposes the present tense, ‘synchronize’ as being more in spirit with Python (there being less distinction between compile-time and run-time in Python than Java). </section> <section id="dissenting-opinion"> <h2><a class="toc-backref" href="#dissenting-opinion" role="doc-backlink">Dissenting Opinion</a></h2> This PEP has not been discussed on python-dev. </section> <section id="references"> <h2><a class="toc-backref" href="#references" role="doc-backlink">References</a></h2> <aside class="footnote-list brackets"> <aside class="footnote brackets" id="id2" role="doc-footnote"> <dt class="label" id="id2">[<a href="#id1">1</a>]</dt> <dd>The Python Language Reference <a class="reference external" href="http://docs.python.org/reference/">http://docs.python.org/reference/</a></aside> </aside> </section> <section id="copyright"> <h2><a class="toc-backref" href="#copyright" role="doc-backlink">Copyright</a></h2> This document has been placed in the public domain. </section> </section> <hr class="docutils" /> Source: <a class="reference external" href="https://github.com/python/peps/blob/main/peps/pep-0319.rst">https://github.com/python/peps/blob/main/peps/pep-0319.rst</a> Last modified: <a class="reference external" href="https://github.com/python/peps/commits/main/peps/pep-0319.rst">2025-02-01 08:59:27 GMT</a> </article> <nav id="pep-sidebar"> <h2>Contents</h2> <ul> <li><a class="reference internal" href="#abstract">Abstract</a></li> <li><a class="reference internal" href="#pronouncement">Pronouncement</a></li> <li><a class="reference internal" href="#synchronization-targets">Synchronization Targets</a></li> <li><a class="reference internal" href="#other-patterns-that-synchronize">Other Patterns that Synchronize</a></li> <li><a class="reference internal" href="#formal-syntax">Formal Syntax</a></li> <li><a class="reference internal" href="#proposed-implementation">Proposed Implementation</a></li> <li><a class="reference internal" href="#backward-compatibility">Backward Compatibility</a></li> <li><a class="reference internal" href="#pep-310-reliable-acquisition-release-pairs">PEP 310 Reliable Acquisition/Release Pairs</a></li> <li><a class="reference internal" href="#how-java-does-it">How Java Does It</a></li> <li><a class="reference internal" href="#how-jython-does-it">How Jython Does It</a></li> <li><a class="reference internal" href="#summary-of-proposed-changes-to-python">Summary of Proposed Changes to Python</a></li> <li><a class="reference internal" href="#risks">Risks</a></li> <li><a class="reference internal" href="#dissenting-opinion">Dissenting Opinion</a></li> <li><a class="reference internal" href="#references">References</a></li> <li><a class="reference internal" href="#copyright">Copyright</a></li> </ul> <a id="source" href="https://github.com/python/peps/blob/main/peps/pep-0319.rst">Page Source (GitHub)</a> </nav> </section> <script src="../_static/colour_scheme.js"></script> <script src="../_static/wrap_tables.js"></script> <script src="../_static/sticky_banner.js"></script> </body> </html>