first commit

Author: SuperFastPython

.gitignore

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

README.md

@@ -0,0 +1,52 @@
+# Python Threading Jump-Start
+
+![Python Threading Jump-Start](cover.png)
+
+* <https://github.com/SuperFastPython/PythonThreadingJumpStart>
+
+This repository provides all source code for the book:
+
+* **Python Threading Jump-Start**: _Develop Concurrent IO-bound Programs And Work With The GIL_, Jason Brownlee, 2022.
+
+
+## Source Code
+You can access all Python .py files directly here:
+
+* [src/](src/)
+
+
+
+### Book Blurb
+
+> Unlock concurrency with Python threads (and run 100s or 1,000s of tasks simultaneously).
+>
+> The threading module provides easy-to-use thread-based concurrency in Python.
+>
+> Unlike Python multiprocessing, the threading module is limited by the infamous Global Interpreter Lock (GIL).
+>
+> Critically, the GIL is released when performing blocking I/O. Additionally, threads can share memory make them perfectly suited to I/O-bound tasks such as reading and writing from files and socket connections.
+>
+> This is the API you need to use to make your code run faster.
+>
+> Introducing: "Python Threading Jump-Start". A new book designed to teach you the threading module in Python, super fast!
+>
+> You will get a rapid-paced, 7-part course to get you started and make you awesome at using the threading API.
+>
+> Each of the 7 lessons was carefully designed to teach one critical aspect of the threading module, with explanations, code snippets and worked examples.
+>
+> You will discover:
+>
+> * How to choose tasks that are well suited to threads.
+> * How to create and run new threads.
+> * How to locate and query running threads.
+> * How to use locks, semaphores, barriers and more.
+> * How to share data between threads using queues.
+> * How to execute ad hoc tasks with reusable worker threads.
+> * How to gracefully stop and forcefully kill threads.
+>
+> Each lesson ends with an exercise for you to complete to confirm you understand 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,23 @@
+# SuperFastPython.com
+# example of extending the thread class
+from time import sleep
+from threading import Thread
+
+# custom thread class
+class CustomThread(Thread):
+    # override the run function
+    def run(self):
+        # block for a moment
+        sleep(1)
+        # report a message
+        print('This is another thread')
+
+# protect the entry point
+if __name__ == '__main__':
+    # create the thread
+    thread = CustomThread()
+    # start the thread
+    thread.start()
+    # wait for the thread to finish
+    print('Waiting for the thread to finish')
+    thread.join()

src/lesson02_extend_thread.py

@@ -0,0 +1,21 @@
+# SuperFastPython.com
+# example of running a function in a new thread
+from time import sleep
+from threading import Thread
+
+# custom function to be executed in a new thread
+def task():
+    # block for a moment
+    sleep(1)
+    # report a message
+    print('This is from another thread')
+
+# protect the entry point
+if __name__ == '__main__':
+    # create a new thread instance
+    thread = Thread(target=task)
+    # start executing the function in the new thread
+    thread.start()
+    # wait for the thread to finish
+    print('Waiting for the thread...')
+    thread.join()

src/lesson02_run_function.py

@@ -0,0 +1,31 @@
+# SuperFastPython.com
+# example of sharing thread-local storage
+from time import sleep
+from threading import Thread
+from threading import local
+
+# custom function executed in a new thread
+def task(shared_local):
+    # block for a moment to simulate work
+    sleep(1)
+    # store a private variable on the thread local
+    shared_local.value = 33
+    # report the stored value
+    print(f'Thread stored: {shared_local.value}')
+
+# protect the entry point
+if __name__ == '__main__':
+    # create a shared thread-local instance
+    local_storage = local()
+    # store a private variable on the thread local
+    local_storage.value = 100
+    # report the stored value
+    print(f'Main stored: {local_storage.value}')
+    # create a new thread to run the custom function
+    thread = Thread(target=task, args=(local_storage,))
+    # start the new thread
+    thread.start()
+    # wait for the thread to terminate
+    thread.join()
+    # report the stored value
+    print(f'Main sees: {local_storage.value}')

src/lesson02_thread_local.py

@@ -0,0 +1,10 @@
+# SuperFastPython.com
+# example of getting access to the current thread
+from threading import current_thread
+
+# protect the entry point
+if __name__ == '__main__':
+    # get the current thread
+    thread = current_thread()
+    # report details
+    print(thread)

src/lesson03_current_thread.py

@@ -0,0 +1,10 @@
+# SuperFastPython.com
+# example of creating a daemon thread
+from threading import Thread
+
+# protect the entry point
+if __name__ == '__main__':
+    # create a daemon thread
+    thread = Thread(daemon=True)
+    # report if the thread is a daemon
+    print(thread.daemon)

src/lesson03_daemon_thread.py

@@ -0,0 +1,25 @@
+# SuperFastPython.com
+# example of getting a list of active threads
+from time import sleep
+from threading import Thread
+import threading
+
+# custom function to be executed in a new thread
+def task():
+    # block for a moment
+    sleep(1)
+
+# protect the entry point
+if __name__ == '__main__':
+    # create a number of new threads
+    threads = [Thread(target=task) for _ in range(5)]
+    # start the new threads
+    for thread in threads:
+        thread.start()
+    # get a list of all running threads
+    running_threads = threading.enumerate()
+    # report a count of active threads
+    print(f'Active Threads: {len(running_threads)}')
+    # report each in turn
+    for thread in running_threads:
+        print(thread)

src/lesson03_enumerate_threads.py

@@ -0,0 +1,32 @@
+# SuperFastPython.com
+# example of handling a thread's unexpected exception
+from time import sleep
+from threading import Thread
+import threading
+
+# custom exception hook
+def custom_hook(args):
+    # report the failure
+    print(f'Thread failed: {args.exc_value}')
+
+# target function that raises an exception
+def task():
+    # report a message
+    print('Working...')
+    # block for a moment
+    sleep(1)
+    # rise an "unexpected" exception
+    raise Exception('Something bad happened')
+
+# protect the entry point
+if __name__ == '__main__':
+    # register the exception hook function
+    threading.excepthook = custom_hook
+    # create a thread
+    thread = Thread(target=task)
+    # run the thread
+    thread.start()
+    # wait for the thread to finish
+    thread.join()
+    # report that the main thread is not dead
+    print('Continuing on...')