<Queue> = queue.Queue(maxsize=0) # A thread-safe FIFO queue. Also LifoQueue.

<Queue>.put(<el>) # Blocks until queue stops being full.

<Queue>.put_nowait(<el>) # Raises queue.Full exception if full.

<el> = <Queue>.get() # Blocks until queue stops being empty.

<el> = <Queue>.get_nowait() # Raises queue.Empty exception if empty.

<Exec> = ThreadPoolExecutor(max_workers=None) # Or: `with ThreadPoolExecutor() as <name>: …`

<iter> = <Exec>.map(<func>, <args_1>, ...) # A multithreaded non-lazy map(). Keeps order.

<Exec>.shutdown(wait=True) # Blocks until all threads finish executing.

<bool> = <Future>.done() # Checks if the thread has finished executing.

<obj> = <Future>.result(timeout=None) # Waits for thread to finish and returns result.

<bool> = <Future>.cancel() # Returns False if thread is already running.

<iter> = as_completed(<coll_of_Futures>) # Each Future is yielded as it completes.

* **Map() and as_completed() also accept 'timeout' argument that causes TimeoutError if result isn't available in 'timeout' seconds after next() is called.**

* **Exceptions that happen inside threads are raised when next() is called on map's iterator or when result() is called on a Future. It's exception() method returns exception or None.**

* **An object with the same interface called ProcessPoolExecutor provides true parallelism by running a separate interpreter in each process. Arguments and results must be [pickable](#pickle).**

<aside>May 27, 2023</aside>

<div><h3 id="queue">Queue</h3><pre><code class="python language-python hljs">&lt;Queue&gt; = queue.Queue(maxsize=<span class="hljs-number">0</span>) <span class="hljs-comment"># A thread-safe FIFO queue. Also LifoQueue.</span>

&lt;Queue&gt;.put(&lt;el&gt;) <span class="hljs-comment"># Blocks until queue stops being full.</span>

&lt;el&gt; = &lt;Queue&gt;.get() <span class="hljs-comment"># Blocks until queue stops being empty.</span>

&lt;el&gt; = &lt;Queue&gt;.get_nowait() <span class="hljs-comment"># Raises queue.Empty exception if empty.</span>

&lt;iter&gt; = &lt;Exec&gt;.map(&lt;func&gt;, &lt;args_1&gt;, ...) <span class="hljs-comment"># A multithreaded non-lazy map(). Keeps order.</span>

&lt;Exec&gt;.shutdown(wait=<span class="hljs-keyword">True</span>) <span class="hljs-comment"># Blocks until all threads finish executing.</span>

<pre><code class="python language-python hljs">&lt;bool&gt; = &lt;Future&gt;.done() <span class="hljs-comment"># Checks if the thread has finished executing.</span>

&lt;obj&gt; = &lt;Future&gt;.result(timeout=<span class="hljs-keyword">None</span>) <span class="hljs-comment"># Waits for thread to finish and returns result.</span>

&lt;bool&gt; = &lt;Future&gt;.cancel() <span class="hljs-comment"># Returns False if thread is already running.</span>

&lt;iter&gt; = as_completed(&lt;coll_of_Futures&gt;) <span class="hljs-comment"># Each Future is yielded as it completes.</span>

<li><strong>Map() and as_completed() also accept 'timeout' argument that causes TimeoutError if result isn't available in 'timeout' seconds after next() is called.</strong></li>

<li><strong>Exceptions that happen inside threads are raised when next() is called on map's iterator or when result() is called on a Future. It's exception() method returns exception or None.</strong></li>

<li><strong>An object with the same interface called ProcessPoolExecutor provides true parallelism by running a separate interpreter in each process. Arguments and results must be <a href="#pickle">pickable</a>.</strong></li>

<aside>May 27, 2023</aside>