first commit

Author: SuperFastPython

.gitignore

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

README.md

@@ -0,0 +1,41 @@
+# Python Multiprocessing Jump-Start
+
+![Python Multiprocessing Jump-Start](cover.png)
+
+* <https://github.com/SuperFastPython/PythonMultiprocessingJumpStart>
+
+This repository provides all source code for the book:
+
+* **Python Multiprocessing Jump-Start**: _Develop Parallel Programs, Side-Step the GIL, and Use All CPU Cores_, Jason Brownlee, 2022.
+
+
+## Source Code
+You can access all Python .py files directly here:
+
+* [src/](src/)
+
+### Book Blurb
+
+> Unlock parallel Python programming (and run your code on all CPUs).
+>
+> The multiprocessing module provides easy-to-use process-based concurrency in Python.
+>
+> Unlike Python threading, multiprocessing side-steps the infamous Global Interpreter Lock (GIL), allowing full parallelism in Python.
+>
+> This is not some random third-party library, this is an API provided in the Python standard library (already installed on your system).
+>
+> This is the API you need to use to make your code run faster.
+>
+> There's just one problem. Few developers know about it (or how to use it well).
+>
+> Introducing: "Python Multiprocessing Jump-Start". A new book designed to teach you the multiprocessing module in Python, super fast!
+>
+> You will get a fast-paced, 7-part course to get you started and make you awesome at using the multiprocessing API.
+>
+> Each of the 7 lessons was carefully designed to teach one critical aspect of the multiprocessing module, with explanations, code snippets and worked examples.
+>
+> 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,21 @@
+# SuperFastPython.com
+# example of running a function in a new child process
+from time import sleep
+from multiprocessing import Process
+
+# custom function to be executed in a child process
+def task():
+    # block for a moment
+    sleep(1)
+    # report a message
+    print('This is from another process', flush=True)
+
+# protect the entry point
+if __name__ == '__main__':
+    # create a new process instance
+    process = Process(target=task)
+    # start executing the function in the process
+    process.start()
+    # wait for the process to finish
+    print('Waiting for the process...')
+    process.join()

src/lesson02_custom_function.py

@@ -0,0 +1,23 @@
+# SuperFastPython.com
+# example of extending the process class
+from time import sleep
+from multiprocessing import Process
+
+# custom process class
+class CustomProcess(Process):
+    # override the run function
+    def run(self):
+        # block for a moment
+        sleep(1)
+        # report a message
+        print('This is another process', flush=True)
+
+# protect the entry point
+if __name__ == '__main__':
+    # create the process
+    process = CustomProcess()
+    # start the process
+    process.start()
+    # wait for the process to finish
+    print('Waiting for the process to finish')
+    process.join()

src/lesson02_extend_process.py

@@ -0,0 +1,25 @@
+# SuperFastPython.com
+# example of getting a list of active child processes
+from time import sleep
+from multiprocessing import active_children
+from multiprocessing import Process
+
+# custom function to be executed in a child process
+def task():
+    # block for a moment
+    sleep(1)
+
+# protect the entry point
+if __name__ == '__main__':
+    # create a number of child processes
+    processes = [Process(target=task) for _ in range(5)]
+    # start the child processes
+    for process in processes:
+        process.start()
+    # get a list of all active child processes
+    children = active_children()
+    # report a count of active children
+    print(f'Active Children Count: {len(children)}')
+    # report each in turn
+    for child in children:
+        print(child)

src/lesson03_active_children.py

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

src/lesson03_current_process.py

@@ -0,0 +1,10 @@
+# SuperFastPython.com
+# example of setting a process to be a daemon
+from multiprocessing import Process
+
+# protect the entry point
+if __name__ == '__main__':
+    # create a daemon process
+    process = Process(daemon=True)
+    # report if the process is a daemon
+    print(process.daemon)

src/lesson03_daemon.py

@@ -0,0 +1,24 @@
+# SuperFastPython.com
+# example of checking the exit status of a child process
+from time import sleep
+from multiprocessing import Process
+
+# custom function to be executed in a child process
+def task():
+    # block for a moment
+    sleep(1)
+
+# protect the entry point
+if __name__ == '__main__':
+    # create the process
+    process = Process(target=task)
+    # report the exit status
+    print(process.exitcode)
+    # start the process
+    process.start()
+    # report the exit status
+    print(process.exitcode)
+    # wait for the process to finish
+    process.join()
+    # report the exit status
+    print(process.exitcode)

src/lesson03_exitcode.py

@@ -0,0 +1,10 @@
+# SuperFastPython.com
+# example of assessing whether a process is alive
+from multiprocessing import Process
+
+# protect the entry point
+if __name__ == '__main__':
+    # create the process
+    process = Process()
+    # report the process is alive
+    print(process.is_alive())