first commit

Author: SuperFastPython

.gitignore

@@ -0,0 +1,3 @@
+# git ignore
+**/.DS_Store
+.DS_Store

README.md

@@ -0,0 +1,55 @@
+# Python ThreadPoolExecutor Jump-Start
+
+![Python ThreadPoolExecutor Jump-Start](cover.png)
+
+* <https://github.com/SuperFastPython/PythonThreadPoolExecutorJumpStart>
+
+This repository provides all source code for the book:
+
+* **Python ThreadPoolExecutor Jump-Start**: _Execute IO-Bound Tasks Asynchronously With Modern Thread Pools_, Jason Brownlee, 2022.
+
+
+## Source Code
+You can access all Python .py files directly here:
+
+* [src/](src/)
+
+## Get the Book
+
+You can learn more about the book here:
+
+* Soon...
+
+### Book Blurb
+
+> How much faster could your Python code run (if you used 100s of thread workers)?
+>
+> The ThreadPoolExecutor class provides modern thread pools for IO-bound tasks.
+>
+> This is not some random third-party library, this is a class provided in the Python standard library (already installed on your system).
+>
+> This is the class you need to make your code run faster.
+>
+> There's just one problem. No one knows about it (or how to use it well).
+>
+> Introducing: "Python ThreadPoolExecutor Jump-Start". A new book designed to teach you thread pools in Python, super fast!
+>
+> You will get a rapid-paced, 7-part course to get you started and make you awesome at using the ThreadPoolExecutor.
+>
+> Including:
+>
+> * How to create thread pools and when to use them.
+> * How to configure thread pools including the number of threads.
+> * How to execute tasks with worker threads and handle for results.
+> * How to execute tasks in the thread pool asynchronously.
+> * How to query and get results from handles on asynchronous tasks called futures.
+> * How to wait on and manage diverse collections of asynchronous tasks.
+> * How to develop a concurrent website status checker that is 5x faster than the sequential version.
+>
+> Each of the 7 lessons was carefully designed to teach one critical aspect of the ThreadPoolExecutor, with explanations, code snippets and worked examples.
+>
+> Each lesson ends with an exercise for you to complete to confirm you understood the topic, a summary of what was learned, and links for further reading if you want to go deeper.
+>
+> Stop copy-pasting code from StackOverflow answers.
+>
+> Learn Python concurrency correctly, step-by-step.

cover.png

@@ -0,0 +1,17 @@
+# SuperFastPython.com
+# example of running a function in a new thread
+from threading import Thread
+
+# custom function to be executed in a new thread
+def task():
+    # report a message
+    print('This is another thread')
+
+# protect the entry point
+if __name__ == '__main__':
+    # define a task to run in a new thread
+    thread = Thread(target=task)
+    # start the task in a new thread
+    thread.start()
+    # wait for the thread to terminate
+    thread.join()

src/lesson01_thread.py

@@ -0,0 +1,18 @@
+# SuperFastPython.com
+# example running a function in the thread pool
+from concurrent.futures import ThreadPoolExecutor
+
+# custom function to be executed in a worker thread
+def task():
+    # report a message
+    print('This is another thread')
+
+# protect the entry point
+if __name__ == '__main__':
+    # create the thread pool
+    with ThreadPoolExecutor() as exe:
+        # issue the task
+        future = exe.submit(task)
+        # wait for the task to finish
+        future.result()
+    # close the thread pool automatically

src/lesson01_threadpoolexecutor.py

@@ -0,0 +1,12 @@
+# SuperFastPython.com
+# example reporting the details of a default pool
+from concurrent.futures import ThreadPoolExecutor
+
+# protect the entry point
+if __name__ == '__main__':
+    # create a thread pool
+    exe = ThreadPoolExecutor()
+    # report the status of the thread pool
+    print(exe._max_workers)
+    # shutdown the thread pool
+    exe.shutdown()

src/lesson02_default_config.py

@@ -0,0 +1,23 @@
+# SuperFastPython.com
+# example initializing worker threads in the pool
+from time import sleep
+from concurrent.futures import ThreadPoolExecutor
+
+# custom function to be executed in a worker thread
+def task(number):
+    # report a message
+    print(f'Worker executing task {number}...')
+    # block for a moment
+    sleep(1)
+
+# initialize a worker in the thread pool
+def init():
+    # report a message
+    print('Initializing worker...')
+
+# protect the entry point
+if __name__ == '__main__':
+    # create and configure the thread pool
+    with ThreadPoolExecutor(2, initializer=init) as exe:
+        # issue tasks to the thread pool
+        _ = exe.map(task, range(4))

src/lesson02_initialize_threads.py

@@ -0,0 +1,19 @@
+# SuperFastPython.com
+# example of setting a large number number of workers
+from time import sleep
+from concurrent.futures import ThreadPoolExecutor
+
+# custom task function executed in the thread pool
+def task(number):
+    # block for a moment
+    sleep(1)
+    # report a message
+    if number % 100 == 0:
+        print(f'>task {number} done')
+
+# protect the entry point
+if __name__ == '__main__':
+    # create a thread pool
+    with ThreadPoolExecutor(1000) as exe:
+        # issue many tasks to the pool
+        _ = exe.map(task, range(1000))

src/lesson02_num_threads.py

@@ -0,0 +1,21 @@
+# SuperFastPython.com
+# example of setting the worker thread name prefix
+from time import sleep
+from concurrent.futures import ThreadPoolExecutor
+import threading
+
+# custom task function executed in the thread pool
+def task(number):
+    # block for a moment
+    sleep(1)
+
+# protect the entry point
+if __name__ == '__main__':
+    # create a thread pool
+    with ThreadPoolExecutor(4,
+        thread_name_prefix='Downloader') as exe:
+        # issue many tasks to the pool
+        _ = exe.map(task, range(20))
+        # report all thread names
+        for thread in threading.enumerate():
+            print(thread)

src/lesson02_thread_names.py

@@ -0,0 +1,25 @@
+# SuperFastPython.com
+# example executing tasks concurrently with multiple arg
+from random import random
+from time import sleep
+from concurrent.futures import ThreadPoolExecutor
+
+# custom function to be executed in a worker thread
+def task(number, value):
+    # report a message
+    print(f'Task using {value}')
+    # block for a moment to simulate work
+    sleep(value)
+    # return a new value
+    return number + value
+
+# protect the entry point
+if __name__ == '__main__':
+    # create the thread pool
+    with ThreadPoolExecutor(4) as exe:
+        # prepare random numbers between 0 and 1
+        values = [random() for _ in range(10)]
+        # issue tasks to execute concurrently
+        for result in exe.map(task, range(10), values):
+            # report results
+            print(result)