15. Threads, Processes, Parallelism, and Concurrency.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*********************************************************************************************************\n",
    "# A Tour of Python 3  \n",
    "version 1.0.1  \n",
    "Authors: Phil Pfeiffer, Zack Bunch, and Feyisayo Oyeniyi  \n",
    "East Tennessee State University  \n",
    "Last updated June 2021  \n",
    "\n",
    "Chapter 15: author Shayne Parker, ed. Phil Pfeiffer  \n",
    "*********************************************************************************************************"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 15. Threads, Processes, Parallelism, and Concurrency  \n",
    " 15.1 [Conceptual Overview](#Threads-Conceptual-Overview)  \n",
    " &ensp; 15.1.1 [Differentiating Concurrency and Parallelism](#Threads-Differentiating-Concurrency-and-Parallelism)  \n",
    " &ensp; 15.1.2 [Differentiating Threads and Processes](#Threads-Differentiating-Threads-and-Processes)  \n",
    " 15.2 [Working with Threads](#Threads-Working-with-Threads)  \n",
    " 15.3 [Working with Processes](#Threads-Working-with-Processes)  \n",
    " 15.4 [Managing Access to Shared Resources](#Threads-Managing-Access-to-Shared-Resources)  \n",
    " &ensp; 15.4.1 [Race Conditions](#Threads-Race-Conditions)  \n",
    " &ensp; 15.4.2 [Mutexes and Semaphores](#Threads-Mutexes-and-Semaphores)  \n",
    " &ensp; 15.4.3 [Deadlock](#Threads-Deadlock)  \n",
    " &ensp; 15.4.4 [Locks and Semaphores in Lib/threading.py](#Threads-Locks-and-Semaphores-in-Lib-threading.py)  \n",
    " &ensp; 15.4.5 [Locks and Semaphores in Lib/multiprocessing.py](#Threads-Locks-and-Semaphores-in-Lib-multiprocessing.py)  \n",
    " 15.5 [Concurrent.futures](#Threads-Concurrent-Futures)  \n",
    " &ensp; 15.5.1 [Executor](#Threads-Executor)  \n",
    " &ensp; 15.5.2 [ThreadPoolExecutor](#Threads-ThreadPoolExecutor)  \n",
    " &ensp; 15.5.3 [ProcessPoolExecutor](#Threads-ProcessPoolExecutor)  \n",
    " &ensp; 15.5.4 [Future Objects](#Threads-Future-Objects)  \n",
    " &ensp; 15.5.5 [Working with Concurrent Futures](#Threads-Working-with-Concurrent-Futures)  \n",
    " 15.6 [Python Interpreter (CPython) Limitations](#Threads-Python-Interpreter-(CPython)-Limitations)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 15.1 Conceptual Overview <a name='Threads-Conceptual-Overview'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 15.1.1 Differentiating Concurrency and Parallelism <a name='Threads-Differentiating-Concurrency-and-Parallelism'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parallelism and concurrency are standard techniques for improving a system's performance and usability. ",
    "Since both involve doing two or more things in a common time frame, these terms are often used interchangeably. ",
    "The techniques, however, entail different ways of managing computations:  \n",
    "\n",
    "- **Concurrency**: Making progress on more than one thing at a time. ",
    "This can include alternating among the things being done; it does not necessarily imply doing them at the same time. \n",
    "- **Parallelism**: Executing more than one thing at the same time.  \n",
    "\n",
    "To visualize the difference, consider two scenarios involving two painters at a common site. ",
    "In one, the painters bring one brush, which they share. ",
    "Regardless of whether this need to share the brush slows their work - ",
    "at times, each may need to wait for one coat of paint to dry before applying a second - ",
    "they cannot both paint at once. ",
    "In the other, each has their own paint brush. ",
    "While they may have to pause at times in their work, neither ever has to wait on the other to resume painting."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 15.1.1.1:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the first of the two following markdown cells, ",
    "tell which scenario is concurrency and which scenario is parallelism. ",
    "Then, in the second, create your own example that illustrates the differences between concurrency and parallelism.",
    "</span>\n",
    "***\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  \n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  \n",
    "   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 15.1.2 Differentiating Threads and Processes <a name='Threads-Differentiating-Threads-and-Processes'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As is true for concurrency and parallelism, the two basic strategies for implementing parallel and concurrent logic, ",
    "threading and multiprocessing, are sometimes confused. ",
    "While both strategies provide scaffolding for managing multiple computations, they do so in decidedly different ways:  \n",
    "- *Threads* are paths of execution within a process.  \n",
    "- *Processes* are individual programs that are in the process of executing. \n",
    "\n",
    "In short, systems house processes, which in turn, house threads. ",
    "\n",
    "In systems that support multithreading and multiprocessing, users *can* organize computations as one or more cooperating process, ",
    " each of which has one or more cooperating threads. ",
    "How a computation *should* be organized depends on its users' requirements for speed and computational resiliency.\n",
    "\n",
    "- Characteristics of threads  \n",
    "    - Threads depend on their parent process.\n",
    "        - Threads, by default, share data with their parent process and therefore each other.\n",
    "            - Contemporary thread APIs, as a rule, also allow threads to have private data areas.\n",
    "        - As a rule, terminating a process terminates its threads.  \n",
    "            - Python's thread API has a setting that allows threads to persist after process termination.  \n",
    "\n",
    "    - Different operating systems use different strategies to manage thread executions.  \n",
    "        - In some systems, processes are responsible for managing how and when their threads run.\n",
    "        - In others, the operating system manages thread execution directly.\n",
    "        - In both, when a thread blocks - i.e., suspends execution while waiting on another computation to complete or a resource to become available - ",
    "          control passes to another thread or process, depending on the policies for scheduling.  \n",
    "        \n",
    "    - Advantages\n",
    "        - Threads can be used to structure a program in a way that clarifies its design.  \n",
    "        - Creating and terminating threads is fast, compared to creating and terminating processes.  \n",
    "        - Switching between a process's threads is fast, compared to switching between processes.  \n",
    "        - Exchanging data between a process's threads is fast, compared to exchanging data between processes.\n",
    "        \n",
    "    - Disadvantages\n",
    "        - Threaded logic requires skill to write, due to the sharing of memory and other process resources.  \n",
    "        - Threaded logic can be difficult to debug, due to the sharing of memory and other process resources.  \n",
    "        \n",
    "        \n",
    "        \n",
    "- Characteristics of processes\n",
    "    - Processes, by default, have independent address spaces.\n",
    "    \n",
    "    - Processes are managed by the operating system.\n",
    "    \n",
    "    - Advantages  \n",
    "        - Interactions among communicating processes can be easier to design than comparable interactions among communicating threads, due to\n",
    "            - Operating systems support for process interaction, in the form of (e.g.) pipes and filters architectures  \n",
    "            - Language support for process interaction, in the form of (e.g.) Ada's rendezvous statement  \n",
    "        - Interactions among communicating processes can be easier to debug than comparable interactions among communicating threads, ",
    "          when processes don't share memory.  \n",
    "          \n",
    "    - Disadvantages\n",
    "       - Creating and terminating processes is slow, compared to creating and terminating threads.\n",
    "       - Switching between processes is slow, compared to switching between a process's threads.\n",
    "       - Exchanging data between processes is slow, compared to exchanging data between a process's threads.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 15.2 Working with Threads <a name='Threads-Working-with-Threads'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The library for working with threads, Lib/threading.py, is an interface to Python's lower level `_thread` module. ",
    "To create a thread, use `threading.Thread`:\n",
    "\n",
    " &ensp;&ensp;&ensp;&ensp; `threading.Thread(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)`\n",
    "- *group* should be `None`; it's reserved for future extension when a ThreadGroup class is implemented\n",
    "- *target* is the callable object invoked by the thread's `run()` method\n",
    "- *name* is the thread's name\n",
    "- *args* is a tuple containing arguments for *target*\n",
    "- *kwargs* is a dictionary of keyword arguments for *target*\n",
    "- *daemon* threads are a special case; if *daemon* is not `None`, the thread is a daemon thread\n",
    "\n",
    "The `Thread` class manages an activity that runs in its own thread of control. ",
    "Once a thread object is created, its activity must be started by calling the thread's `start()` method. ",
    "Once started, a thread is considered *alive* until the `run()` method completes.  \n",
    "\n",
    "The following is a list of selected thread object methods:  \n",
    "\n",
    "- `start()` - Start a thread's activity  \n",
    "- `run()` - Invokes the *target* argument from the thread constructor, which presumably causes the thread to run. Must be called after `start()`. \n",
    "- `join(timeout=None)` - blocks the calling thread until the thread whose `join()` was called is terminated. ",
    " When the *timeout* argument is present and not `None`, it should be a floating point number specifying a timeout in seconds.\n",
    "- `is_alive()` - returns `True` iff the thread is alive.\n",
    "\n",
    "The following is a list of selected thread object attributes:\n",
    "\n",
    "- `name` - string used for identification purposes only. Multiple threads may have the same name.  \n",
    "- `ident` - a nonzero integer. Its value has no direct meaning.   \n",
    "- `native_id` - a non-negative integer that serves as a unique, system-wide identifier for this thread.\n",
    "- `daemon` - a boolean that, if `True`, directs Python to allow the thread to continue running after its host program terminates. ",
    "Must be set before `start()` is called. Inherited from the creating thread.\n",
    "\n",
    "The entire Python program exits when the last non-daemon thread ceases execution.\n",
    "\n",
    "The following is a partial list of Lib/threading functions characterizing the status of a program's set of threads:  \n",
    "\n",
    "- `threading.enumerate()`- returns a list of all Thread objects currently alive.  \n",
    "- `threading.active_count()` - returns the number of Thread objects currently alive. ",
    "The returned count is equal to the length of the list returned by enumerate().  \n",
    "- `threading.main_thread()` - returns the process’s main Thread object. ",
    "In normal conditions, the main thread is the thread from which the Python interpreter was started.  \n",
    "- `threading.current_thread()` - returns the current Thread object, corresponding to the caller's thread of control. ",
    "If the caller's thread of control was not created through the threading module, a dummy thread object with limited functionality is returned.  \n",
    "- `threading.get_ident()`- returns the current thread’s \"thread identifier\"  \n",
    "- `threading.get_native_id()` - returns the native integral Thread ID of the current thread assigned by the kernel.  \n",
    "- `threading.excepthook(args,/)` - handles uncaught exception raised by Thread.run().  \n",
    "\n",
    "Lib/threading.py also defines `threading.TIMEOUT_MAX`. ",
    "This constant is the maximum value allowed for the timeout parameter of blocking functions. ",
    "Specifying a timeout greater than this value will raise an OverflowError."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following examples illustrate the use of threads. Detailed information can be found in the official documentation [here](https://docs.python.org/3/library/threading.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 15.2.a Creating a thread with default parameters\n",
    "import threading\n",
    "\n",
    "def thread_info(thread):\n",
    "  print(\"Thread name:\\t\\t\",thread.getName())\n",
    "  print(\"Thread id:\\t\\t\",thread.ident)\n",
    "  print(\"Thread native id:\\t\",thread.native_id)\n",
    "  print(\"Thread running?\\t\\t\",thread.is_alive())\n",
    "  print(\"Thread is daemon?\\t\",thread.isDaemon())\n",
    "  print(\"Thread timeout:\\t\\t\",threading.TIMEOUT_MAX)\n",
    "  print()\n",
    "\n",
    "thread = threading.Thread()\n",
    "print(\"Thread created. Displaying info...\")\n",
    "thread_info(thread)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 15.2.b Creating a thread with a programmer-specified name\n",
    "import threading\n",
    "\n",
    "def thread_info(thread):\n",
    "  print(\"Thread name:\\t\\t\",thread.getName())\n",
    "  print(\"Thread id:\\t\\t\",thread.ident)\n",
    "  print(\"Thread native id:\\t\",thread.native_id)\n",
    "  print(\"Thread running?\\t\\t\",thread.is_alive())\n",
    "  print(\"Thread is daemon?\\t\",thread.isDaemon())\n",
    "  print(\"Thread timeout:\\t\\t\",threading.TIMEOUT_MAX)\n",
    "  print()\n",
    "\n",
    "thread = threading.Thread(name='Example Thread')\n",
    "print(\"Thread created. Displaying info...\")\n",
    "thread_info(thread)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 15.2.c Manipulating a thread's attributes\n",
    "import threading\n",
    "\n",
    "def thread_info(thread):\n",
    "  print(\"Thread name:\\t\\t\",thread.getName())\n",
    "  print(\"Thread id:\\t\\t\",thread.ident)\n",
    "  print(\"Thread native id:\\t\",thread.native_id)\n",
    "  print(\"Thread running?\\t\\t\",thread.is_alive())\n",
    "  print(\"Thread is daemon?\\t\",thread.isDaemon())\n",
    "  print(\"Thread timeout:\\t\\t\",threading.TIMEOUT_MAX)\n",
    "  print()\n",
    "\n",
    "thread = threading.Thread(name='Example Thread')\n",
    "print(\"Thread created. Displaying info...\")\n",
    "thread_info(thread)\n",
    "\n",
    "thread.name = 'Modified Thread Name'\n",
    "print(\"Thread modified. Displaying info...\")\n",
    "thread_info(thread)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 15.2.d Creating a local data area\n",
    "import threading\n",
    "\n",
    "def thread_info(thread):\n",
    "  print(\"Thread name:\\t\\t\",thread.getName())\n",
    "  print(\"Thread id:\\t\\t\",thread.ident)\n",
    "  print(\"Thread native id:\\t\",thread.native_id)\n",
    "  print(\"Thread running?\\t\\t\",thread.is_alive())\n",
    "  print(\"Thread is daemon?\\t\",thread.isDaemon())\n",
    "  print(\"Thread timeout:\\t\\t\",threading.TIMEOUT_MAX)\n",
    "  print()\n",
    "\n",
    "def show_local(p,val, val2):\n",
    "  try:\n",
    "    print(\"Original val: \",p.val)\n",
    "    print(\"Original val2: \",p.val2)\n",
    "  except AttributeError:\n",
    "    print(\"This thread has nothing in its local data yet.\")\n",
    "  p.val = val\n",
    "  p.val2 = val2\n",
    "  print(p.val)\n",
    "  print(p.val2)\n",
    "  print()\n",
    "\n",
    "mydata = threading.local()\n",
    "mydata.val = 99\n",
    "mydata.val2 = \"snozberries\"\n",
    "\n",
    "print(\"Main thread val: \",mydata.val)\n",
    "print(\"Main thread val2: \",mydata.val2)\n",
    "print()\n",
    "\n",
    "thread1 = threading.Thread(target=show_local,args=(mydata,3,\"blueberries\"))\n",
    "thread2 = threading.Thread(target=show_local,args=(mydata,17,\"blackberries\"))\n",
    "thread1.start()\n",
    "thread2.start()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 15.2.e Creating and running a thread with a callable\n",
    "import threading\n",
    "\n",
    "def thread_info(thread):\n",
    "  print(\"Thread name:\\t\\t\",thread.getName())\n",
    "  print(\"Thread id:\\t\\t\",thread.ident)\n",
    "  print(\"Thread native id:\\t\",thread.native_id)\n",
    "  print(\"Thread running?\\t\\t\",thread.is_alive())\n",
    "  print(\"Thread is daemon?\\t\",thread.isDaemon())\n",
    "  print(\"Thread timeout:\\t\\t\",threading.TIMEOUT_MAX)\n",
    "  print()\n",
    "\n",
    "def example_callable(p):\n",
    "  print(\"Hello from a callable. Your parameter is \",p)\n",
    "\n",
    "thread = threading.Thread(target=example_callable,args=(\"Bologna\",))\n",
    "print(\"Thread created. Displaying info...\")\n",
    "print()\n",
    "thread_info(thread)\n",
    "\n",
    "thread.start()\n",
    "print(\"Thread started. Displaying info...\")\n",
    "thread_info(thread)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 15.2.1:**\n\n",
    "</span>",
    "<span style='color:navy' >",
    "In the following markdown cell, ",
    "discuss the output from the last example. ",
    "Is it what you would expect, looking at the code? If not, why do you think that is? ",
    "Run the last example a few more times and observe the output. What happens?",
    "</span>\n",
    "***\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  \n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n"
   ]
  },  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 15.3 Working with Processes <a name='Threads-Working-with-Processes'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The library for working with processes is Lib/multiprocessing.py. ",
    "Lib/multiprocessing.py's API is similar to the `threading` module's API, which makes it easier to use both libraries. ",
    "The following are a few examples of these similarities.\n",
    "\n",
    " &ensp;&ensp;&ensp;&ensp;`multiprocessing.Process(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)`\n",
    "\n",
    "- `start()` - starts a process's activity  \n",
    "- `run()` - invokes the *target* argument from the process constructor, which presumably causes the thread to run. Must be called after `start()`. \n",
    "- `join([timeout])` - if *timeout* is `None` (default), blocks until the process whose `join()` method is called terminates. ",
    " If *timeout* is a positive number, it blocks at most *timeout* seconds.  \n",
    "    - A process can be joined many times.  \n",
    "    - A process cannot join itself - this would cause deadlock (more on deadlock later).  \n",
    "    - Do not attempt to join a process before it has started.  \n",
    "- `is_alive()` - returns `True` iff the process is alive.\n",
    "    \n",
    "Processes have similar attributes as threads, as well, including `name`, `daemon`, and `pid`, ",
    " the process's operating-system-specified ID. Before the process is spawned, `pid` is `None`.  \n",
    " \n",
    "The following methods and attributes are specific to the `multiprocessing` API.  \n",
    "\n",
    "- `exitcode` - the exit code returned by a process's *child process* - i.e., a process that the current process has created. ",
    "  This value is `None` if the child has not terminated. ",
    "  A negative value, -N, indicates termination by signal N.\n",
    "- `authkey` - When `multiprocessing` is initialized, the OS assigns to it a random byte string. ",
    "   When a process object is created, it inherits the authentication key (the byte string) from its parent. ",
    "   This value can be changed. \n",
    "- `terminate()` - requests the current process to terminate, using `TerminateProcess()` on Windows and `SIGTERM` on Unix. ",
    " Termination can be blocked using a signal handler, in order (e.g.) to allow the process to release its resources before exiting.  \n",
    "    - Termination orphans descendant processes: i.e., relieves them of having to return an exit code to their parent process before being reclaimed.\n",
    "    - Does not trigger exit handlers, finally clauses, etc.\n",
    "- `kill()` - terminates the process. Uses `SIGKILL` on Unix instead of `SIGTERM`.\n",
    "- `close()` - releases all resources associated with a process and closes the process. \n",
    "\n",
    "A `multiprocessing` module object that lacks a documented counterpart in the `threading` module, ",
    " `multiprocessing.Pool` supports methods for managing groups of processes, including methods for reusing terminated process objects. ",
    " This lack of a comparable thread pool object is due to Python reference implementation's lack of support for true thread-level parallelism.\n",
    "\n",
    "Detailed information can be found in the official documentation [here](https://docs.python.org/3/library/multiprocessing.html). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 15.3.a Creating a process with default parameters\n",
    "import multiprocessing\n",
    "\n",
    "def process_info(process):\n",
    "  print(\"Process name:\\t\\t\",process.name)\n",
    "  print(\"Process id:\\t\\t\",process.ident)\n",
    "  print(\"Process authkey:\\t\",process.authkey)\n",
    "  print(\"Process native id:\\t\",process.pid)\n",
    "  print(\"Process running?\\t\",process.is_alive())\n",
    "  print(\"Process is daemon?\\t\",process.daemon)\n",
    "  print()\n",
    "\n",
    "process = multiprocessing.Process()\n",
    "print(\"Process created. Displaying info...\")\n",
    "process_info(process)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 15.3.b Creating a process with programmer-specified name\n",
    "import multiprocessing\n",
    "\n",
    "def process_info(process):\n",
    "  print(\"Process name:\\t\\t\",process.name)\n",
    "  print(\"Process id:\\t\\t\",process.ident)\n",
    "  print(\"Process authkey:\\t\",process.authkey)\n",
    "  print(\"Process native id:\\t\",process.pid)\n",
    "  print(\"Process running?\\t\",process.is_alive())\n",
    "  print(\"Process is daemon?\\t\",process.daemon)\n",
    "  print()\n",
    "\n",
    "process = multiprocessing.Process(name='Example Process')\n",
    "print(\"Process created. Displaying info...\")\n",
    "process_info(process)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 15.3.c Manipulating a process's attributes\n",
    "import multiprocessing\n",
    "import os\n",
    "\n",
    "def process_info(process):\n",
    "  print(\"Process name:\\t\\t\",process.name)\n",
    "  print(\"Process id:\\t\\t\",process.ident)\n",
    "  print(\"Process authkey:\\t\",process.authkey)\n",
    "  print(\"Process native id:\\t\",process.pid)\n",
    "  print(\"Process running?\\t\",process.is_alive())\n",
    "  print(\"Process is daemon?\\t\",process.daemon)\n",
    "  print()\n",
    "\n",
    "process = multiprocessing.Process(name='Example Process')\n",
    "print(\"Process created. Displaying info...\")\n",
    "process_info(process)\n",
    "\n",
    "process.name = 'Modified Process Name'\n",
    "process.authkey = os.urandom(8)\n",
    "print(\"Process created. Displaying info...\")\n",
    "process_info(process)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 15.3.d Creating and running a process with a callable\n",
    "import subprocess, os\n",
    "\n",
    "program_file_name = \"test.py\"\n",
    "program_content = [\n",
    "  \"import multiprocessing\\n\",\n",
    "  \"\\n\",\n",
    "  \"def process_info(process):\\n\",\n",
    "  \"  print('Process name:\\t\\t',process.name)\\n\",\n",
    "  \"  print('Process id:\\t\\t',process.ident)\\n\",\n",
    "  \"  print('Process authkey:\\t',process.authkey)\\n\",\n",
    "  \"  print('Process native id:\\t',process.pid)\\n\",\n",
    "  \"  print('Process running?\\t',process.is_alive())\\n\",\n",
    "  \"  print('Process is daemon?\\t',process.daemon)\\n\",\n",
    "  \"  print()\\n\",\n",
    "  \"\\n\",\n",
    "  \"def example_callable(p):\\n\",\n",
    "  \"  print('Hello from the callable. Your parameter is ',p)\\n\",\n",
    "  \"\\n\",\n",
    "  \"if __name__ == '__main__':\\n\",\n",
    "  \"  process = multiprocessing.Process(target=example_callable,args=('Pineapple Pizza',))\\n\",\n",
    "  \"  print('Process created. Displaying info...')\\n\",\n",
    "  \"  process_info(process)\\n\",\n",
    "  \"  process.start()\\n\",\n",
    "  \"  print('Process started. Displaying info...')\\n\",\n",
    "  \"  process_info(process)\\n\",\n",
    "  \"  process.join()\\n\",\n",
    "  \"  process.close()\\n\"\n",
    "]\n",
    "\n",
    "# The following code writes the above text strings as a file that is then executed.\n",
    "# This is necessary to get output from the process.\n",
    "# This code is sourced from Dr. Pfeiffer, from other Tour of Python units, and has been modified to suit this example.\n",
    "\n",
    "CREATE_NEW_FILE = 'x'   # python open mode\n",
    "FAILURE_EXIT = 1        # POSIX error code for program failure\n",
    "# ## supporting functions ##\n",
    "byte_seq_to_string = lambda byteseq: ''.join( chr(byte) for byte in byteseq )\n",
    "if os.path.exists( program_file_name ):\n",
    "  print( f'{program_file_name} already exists; please remove or rename it and rerun the example' )\n",
    "else:\n",
    "  with open( program_file_name, CREATE_NEW_FILE ) as program_fd:\n",
    "   for line in program_content:\n",
    "     program_fd.write( line )\n",
    "  print( '>Executing<\\n')\n",
    "  program_status = subprocess.run( [ 'python', program_file_name ], capture_output=True )\n",
    "  print( '>return code is', program_status.returncode,\"<\\n\" )\n",
    "  standard_output = byte_seq_to_string( program_status.stdout )\n",
    "  print( '> no standard output returned <' if standard_output == '' else 'standard output: ' + standard_output )\n",
    "  error_output = byte_seq_to_string( program_status.stderr )\n",
    "  print( '> no error output returned <' if error_output == '' else 'error output: ' + error_output )\n",
    "  os.remove( program_file_name )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 15.3.e Using Pool\n",
    "import subprocess, os\n",
    "\n",
    "program_file_name = \"test.py\"\n",
    "program_content = [\n",
    "  \"from multiprocessing import Pool\\n\",\n",
    "  \"\\n\",\n",
    "  \"def example_callable(p):\\n\",\n",
    "  \"  print('Hello from the callable. Your parameter is ',p)\\n\",\n",
    "  \"\\n\",\n",
    "  \"if __name__ == '__main__':\\n\",\n",
    "  \"  with Pool(5) as pool:\\n\",\n",
    "  \"    pool.map(example_callable,[3])\\n\"\n",
    "]\n",
    "\n",
    "# The following code writes the above text strings as a file that is then executed.\n",
    "# This is necessary to get output from the process.\n",
    "# This code is sourced from Dr. Pfeiffer, from other Tour of Python units, and has been modified to suit this example.\n",
    "CREATE_NEW_FILE = 'x'   # python open mode\n",
    "FAILURE_EXIT = 1        # POSIX error code for program failure\n",
    "# ## supporting functions ##\n",
    "byte_seq_to_string = lambda byteseq: ''.join( chr(byte) for byte in byteseq )\n",
    "if os.path.exists( program_file_name ):\n",
    "  print( f'{program_file_name} already exists; please remove or rename it and rerun the example' )\n",
    "else:\n",
    "  with open( program_file_name, CREATE_NEW_FILE ) as program_fd:\n",
    "   for line in program_content:\n",
    "     program_fd.write( line )\n",
    "  print( '>Executing<\\n')\n",
    "  program_status = subprocess.run( [ 'python', program_file_name ], capture_output=True )\n",
    "  print( '>return code is', program_status.returncode,\"<\\n\" )\n",
    "  standard_output = byte_seq_to_string( program_status.stdout )\n",
    "  print( '> no standard output returned <' if standard_output == '' else 'standard output: ' + standard_output )\n",
    "  error_output = byte_seq_to_string( program_status.stderr )\n",
    "  print( '> no error output returned <' if error_output == '' else 'error output: ' + error_output )\n",
    "  os.remove( program_file_name )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 15.4 Managing Access to Shared Resources <a name='Threads-Managing-Access-to-Shared-Resources'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Two major, recurring issues related to shared, concurrent and/or parallel access to computational resources are race conditions and deadlock. ",
    "Both arise from attempts by multiple threads or processes to access the same resource(s) at the same time."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 15.4.1 Race Conditions <a name='Threads-Race-Conditions'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A *race condition* is a scenario where a computation's outcome varies in an unpredictable way due to interference from other, concurrently executing computations. ",
    "Race conditions usually involve an attempt by at least one computation to alter content ",
    "at the same time that another computation is attempting to read or write that content.  \n",
    "\n",
    "A classic example of a race condition involving a database involves an attempt to withdraw \\\\$10 from a \\\\$100 bank account ",
    "while another person is depositing \\\\$10 to the same account. Consider the following scenario:  \n",
    "- The program that processes the deposit determines that the account currently holds \\\\$100.  \n",
    "- This program temporarily gives way to the other program, which deducts \\\\$10 from the account, leaving \\\\$90 in the account.  \n",
    "- The first program then adds \\\\$10 to \\\\$100 and updates the balance to \\\\$110.  \n",
    "\n",
    "The net result is that the account has \\\\$10 more in it than it should. ",
    " Reversing this scenario would leave the individual \\\\$10 poorer rather than richer.  \n",
    "\n",
    "The common method of preventing race conditions is to implement a mechanism that allows a process or thread to maintain control ",
    "over a resource until a sequence of atomic actions - actions that must execute as a unit - are complete. ",
    "The two most common such mechanisms are mutexes and semaphores."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 15.4.2 Mutexes and Semaphores <a name='Threads-Mutexes-and-Semaphores'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mutexes and semaphores are similar, but not identical. ",
    "As seems to be common when discussing concurrency and parallelism, these terms are often mistakenly used interchangeably.\n",
    "\n",
    "A **mutex** (**mut**ual **ex**clusion) is a locking mechanism. ",
    "When a process or thread *claims* the mutex, it locks access to that data. ",
    "When the mutex's owner is done with the resource, it *releases* the mutex, which allows another process or thread to claim the mutex.  \n",
    "\n",
    "A **semaphore** is a signaling mechanism. There are two kinds of semaphores: \n",
    "-  A counting semaphore initializes, typically, to the amount of the resource that is available: ",
    "   e.g., if a system has four cores, the semaphore is initialized to four.  \n",
    "-  A binary semaphore initializes to one.  \n",
    "\n",
    "Both kinds of semaphores operate in the same manner.  \n",
    "- When access is granted, the semaphore is decremented by one.  \n",
    "- When the thread or process is done, the semaphore is incremented by one.  \n",
    "\n",
    "The decrement/increment operations *signal* a resource's availability. ",
    "If the semaphore is at zero and a request for access comes in, the request is stored in a buffer. ",
    "When a resource is released, the increment signals that something from the buffer can be popped off and given access. \n",
    "\n",
    "Mutexes and semaphores help control access to prevent race conditions. However, they create a second issue."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 15.4.3 Deadlock <a name='Threads-Deadlock'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To visualize deadlock, consider the earlier example of the two painters. ",
    "Imagine that the one painter has the paint brush and the other has the can of paint. ",
    "The first painter needs the paint can to continue painting while the second needs the brush.  ",
    "Neither painter surrenders their respective resource. This is deadlock.\n",
    "\n",
    "Addressing deadlock usually involves reconsidering how access to the resource is granted."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 15.4.4 Locks and Semaphores in Lib/threading.py <a name='Threads-Locks-and-Semaphores-in-Lib-threading.py'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `threading` module provides several objects for coordinating access to shared resources.  \n",
    "\n",
    "- `threading.Lock` - a non-recursive mechanism for asserting ownership over a shared resource.\n",
    "    - Once a thread has acquired this lock, any other thread attempting to acquire it will block until the lock is released.  \n",
    "    \n",
    "    - `acquire(blocking=True, timeout=-1)` - attempt to acquire the lock, in a manner specified by the routine's two parameters\n",
    "        - If *blocking* is `False`, do not block. If a call where *blocking* set to `True` would block, return `False` immediately.\n",
    "        - If *timeout* is -1, it's an unbounded wait.\n",
    "        \n",
    "    - `release()`\n",
    "        - Any thread can call this for any Lock. As a rule, however, a lock should only be released by the thread that last acquired it.  \n",
    "        - If called for a lock that is not locked, raises a RuntimeError.\n",
    "    \n",
    "    \n",
    "- `threading.RLock` - a reentrant object that allows a thread to repeatedly acquire the lock.  \n",
    "    - The implementation uses the concepts of thread ownership and recursion levels to balance locking and unlocking operations.  \n",
    "    \n",
    "    - `acquire(blocking=True, timeout=-1)`  \n",
    "        - If the thread already owns the lock, increment the recursion level.  \n",
    "        - If another thread owns the lock, block until the lock is unlocked.  \n",
    "        \n",
    "    -`release()`  \n",
    "        - Decrements the recursion level. If the recursion level is zero after the decrement, the lock is set to unlocked.\n",
    "        \n",
    "\n",
    "- `threading.Semaphore(value=1)`\n",
    "    - Raises a ValueError if *value* is passed as a negative number.\n",
    "    - `acquire(blocking=True, timeout=None)`\n",
    "    - `release(n=1)`\n",
    "        - Increment the semaphores internal counter by *n*. Wakes up *n* blocking threads if the internal counter was zero on entry.\n",
    "        \n",
    "\n",
    "- `threading.BoundedSemaphore(value=1)`\n",
    "    - A bounded semaphore sets hard limits at 0 and *value*. If the internal counter exceeds *value*, it raises a ValueError."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 15.4.4.a Creating and using a Lock\n",
    "import subprocess, os\n",
    "\n",
    "program_file_name = \"test.py\"\n",
    "program_content = [\n",
    "  \"import threading\\n\",\n",
    "  \"import time\\n\",\n",
    "  \"def thread_info(thread):\\n\",\n",
    "  \"  print('Thread name:\\t\\t',thread.getName())\\n\",\n",
    "  \"  print('Thread id:\\t\\t',thread.ident)\\n\",\n",
    "  \"  print('Thread native id:\\t',thread.native_id)\\n\",\n",
    "  \"  print('Thread running?\\t\\t',thread.is_alive())\\n\",\n",
    "  \"  print('Thread is daemon?\\t',thread.isDaemon())\\n\",\n",
    "  \"  print('Thread timeout:\\t\\t',threading.TIMEOUT_MAX)\\n\",\n",
    "  \"  print()\\n\",\n",
    "  \"def increment(val):\\n\",\n",
    "  \"  lock = threading.Lock()\\n\",\n",
    "  \"  lock.acquire()\\n\",\n",
    "  \"  try:\\n\",\n",
    "  \"    time.sleep(2)\\n\",\n",
    "  \"    val += 1\\n\",\n",
    "  \"    print(val)\\n\",\n",
    "  \"  finally:\\n\",\n",
    "  \"    lock.release()\\n\",\n",
    "  \"  return val\\n\",\n",
    "\"\\n\",\n",
    "\"if __name__ == '__main__':\\n\",\n",
    "\"  data = 10\\n\",\n",
    "\"  thread1 = threading.Thread(target=increment,args=(data,))\\n\",\n",
    "\"  thread1.name = 'Thread 1'\\n\",\n",
    "\"  thread2 = threading.Thread(target=increment,args=(data,))    \\n\",\n",
    "\"  thread2.name = 'Thread 2'\\n\",\n",
    "\"  thread1.start()\\n\",\n",
    "\"  thread_info(thread1)\\n\",\n",
    "\"  thread2.start()\\n\",\n",
    "\"  thread_info(thread2)\\n\"\n",
    "]\n",
    "\n",
    "# The following code writes the above text strings as a file that is then executed.\n",
    "# This is necessary to get output from the process.\n",
    "# This code is sourced from Dr. Pfeiffer, from other Tour of Python units, and has been modified to suit this example.\n",
    "\n",
    "CREATE_NEW_FILE = 'x'   # python open mode\n",
    "FAILURE_EXIT = 1        # POSIX error code for program failure\n",
    "# ## supporting functions ##\n",
    "byte_seq_to_string = lambda byteseq: ''.join( chr(byte) for byte in byteseq )\n",
    "if os.path.exists( program_file_name ):\n",
    "  print( f'{program_file_name} already exists; please remove or rename it and rerun the example' )\n",
    "else:\n",
    "  with open( program_file_name, CREATE_NEW_FILE ) as program_fd:\n",
    "   for line in program_content:\n",
    "     program_fd.write( line )\n",
    "  print( '>Executing<\\n')\n",
    "  program_status = subprocess.run( [ 'python', program_file_name ], capture_output=True )\n",
    "  print( '>return code is', program_status.returncode,\"<\\n\" )\n",
    "  standard_output = byte_seq_to_string( program_status.stdout )\n",
    "  print( '> no standard output returned <' if standard_output == '' else 'standard output:\\n' + standard_output )\n",
    "  error_output = byte_seq_to_string( program_status.stderr )\n",
    "  print( '> no error output returned <' if error_output == '' else 'error output: ' + error_output )\n",
    "  os.remove( program_file_name )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 15.4.4.b Creating and using a Lock using the 'with' statement\n",
    "# 'with' releases the lock it acquires upon exit from the block\n",
    "\n",
    "import subprocess, os\n",
    "\n",
    "program_file_name = \"test.py\"\n",
    "program_content = [\n",
    "  \"import threading\\n\",\n",
    "  \"import time\\n\",\n",
    "  \"def thread_info(thread):\\n\",\n",
    "  \"  print('Thread name:\\t\\t',thread.getName())\\n\",\n",
    "  \"  print('Thread id:\\t\\t',thread.ident)\\n\",\n",
    "  \"  print('Thread native id:\\t',thread.native_id)\\n\",\n",
    "  \"  print('Thread running?\\t\\t',thread.is_alive())\\n\",\n",
    "  \"  print('Thread is daemon?\\t',thread.isDaemon())\\n\",\n",
    "  \"  print('Thread timeout:\\t\\t',threading.TIMEOUT_MAX)\\n\",\n",
    "  \"  print()\\n\",\n",
    "  \"def increment(val):\\n\",\n",
    "  \"  lock = threading.Lock()\\n\",\n",
    "  \"  with lock:\\n\",\n",
    "  \"    time.sleep(2)\\n\",\n",
    "  \"    val += 1\\n\",\n",
    "  \"    print(val)\\n\",\n",
    "  \"  return val\\n\",\n",
    "\"\\n\",\n",
    "\"if __name__ == '__main__':\\n\",\n",
    "\"  data = 10\\n\",\n",
    "\"  thread1 = threading.Thread(target=increment,args=(data,))\\n\",\n",
    "\"  thread1.name = 'Thread 1'\\n\",\n",
    "\"  thread2 = threading.Thread(target=increment,args=(data,))    \\n\",\n",
    "\"  thread2.name = 'Thread 2'\\n\",\n",
    "\"  thread1.start()\\n\",\n",
    "\"  thread_info(thread1)\\n\",\n",
    "\"  thread2.start()\\n\",\n",
    "\"  thread_info(thread2)\\n\"\n",
    "]\n",
    "\n",
    "# The following code writes the above text strings as a file that is then executed.\n",
    "# This is necessary to get output from the process.\n",
    "# This code is sourced from Dr. Pfeiffer, from other Tour of Python units, and has been modified to suit this example.\n",
    "\n",
    "CREATE_NEW_FILE = 'x'   # python open mode\n",
    "FAILURE_EXIT = 1        # POSIX error code for program failure\n",
    "# ## supporting functions ##\n",
    "byte_seq_to_string = lambda byteseq: ''.join( chr(byte) for byte in byteseq )\n",
    "if os.path.exists( program_file_name ):\n",
    "  print( f'{program_file_name} already exists; please remove or rename it and rerun the example' )\n",
    "else:\n",
    "  with open( program_file_name, CREATE_NEW_FILE ) as program_fd:\n",
    "   for line in program_content:\n",
    "     program_fd.write( line )\n",
    "  print( '>Executing<\\n')\n",
    "  program_status = subprocess.run( [ 'python', program_file_name ], capture_output=True )\n",
    "  print( '>return code is', program_status.returncode,\"<\\n\" )\n",
    "  standard_output = byte_seq_to_string( program_status.stdout )\n",
    "  print( '> no standard output returned <' if standard_output == '' else 'standard output:\\n' + standard_output )\n",
    "  error_output = byte_seq_to_string( program_status.stderr )\n",
    "  print( '> no error output returned <' if error_output == '' else 'error output: ' + error_output )\n",
    "  os.remove( program_file_name )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 15.4.4.c Showing any thread can release a lock, even if not the owning thread\n",
    "import subprocess, os\n",
    "\n",
    "program_file_name = \"test.py\"\n",
    "program_content = [\n",
    "  \"import threading\\n\",\n",
    "  \"import time\\n\",\n",
    "  \"def thread_info(thread):\\n\",\n",
    "  \"  print('Thread name:\\t\\t',thread.getName())\\n\",\n",
    "  \"  print('Thread id:\\t\\t',thread.ident)\\n\",\n",
    "  \"  print('Thread native id:\\t',thread.native_id)\\n\",\n",
    "  \"  print('Thread running?\\t\\t',thread.is_alive())\\n\",\n",
    "  \"  print('Thread is daemon?\\t',thread.isDaemon())\\n\",\n",
    "  \"  print('Thread timeout:\\t\\t',threading.TIMEOUT_MAX)\\n\",\n",
    "  \"  print()\\n\",\n",
    "\"\\n\",\n",
    "\"def example1(lock):\\n\",\n",
    "\"  print('Is this lock, locked? ', lock.locked())\\n\",\n",
    "\"  lock.acquire()\\n\",\n",
    "\"  print('Is this lock, locked? ', lock.locked())\\n\",\n",
    "\"\\n\",\n",
    "\"def example2(lock):\\n\",\n",
    "\"  print('Is this lock, locked? ', lock.locked())\\n\",\n",
    "\"  lock.release()\\n\",\n",
    "\"  print('Is this lock, locked? ', lock.locked())\\n\",\n",
    "\"\\n\",\n",
    "\"if __name__ == '__main__':\\n\",\n",
    "\"  lock = threading.Lock()\\n\",    \n",
    "\"  thread1 = threading.Thread(target=example1,args=(lock,))\\n\",\n",
    "\"  thread2 = threading.Thread(target=example2,args=(lock,))\\n\",\n",
    "\"  thread1.start()\\n\",\n",
    "\"  thread2.start()\\n\"\n",
    "]\n",
    "\n",
    "# The following code writes the above text strings as a file that is then executed.\n",
    "# This is necessary to get output from the process.\n",
    "# This code is sourced from Dr. Pfeiffer, from other Tour of Python units, and has been modified to suit this example.\n",
    "\n",
    "CREATE_NEW_FILE = 'x'   # python open mode\n",
    "FAILURE_EXIT = 1        # POSIX error code for program failure\n",
    "# ## supporting functions ##\n",
    "byte_seq_to_string = lambda byteseq: ''.join( chr(byte) for byte in byteseq )\n",
    "if os.path.exists( program_file_name ):\n",
    "  print( f'{program_file_name} already exists; please remove or rename it and rerun the example' )\n",
    "else:\n",
    "  with open( program_file_name, CREATE_NEW_FILE ) as program_fd:\n",
    "   for line in program_content:\n",
    "     program_fd.write( line )\n",
    "  print( '>Executing<\\n')\n",
    "  program_status = subprocess.run( [ 'python', program_file_name ], capture_output=True )\n",
    "  print( '>return code is', program_status.returncode,\"<\\n\" )\n",
    "  standard_output = byte_seq_to_string( program_status.stdout )\n",
    "  print( '> no standard output returned <' if standard_output == '' else 'standard output:\\n' + standard_output )\n",
    "  error_output = byte_seq_to_string( program_status.stderr )\n",
    "  print( '> no error output returned <' if error_output == '' else 'error output: ' + error_output )\n",
    "  os.remove( program_file_name )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 15.4.4.d Creating and using a Semaphore\n",
    "import subprocess, os\n",
    "\n",
    "program_file_name = \"test.py\"\n",
    "program_content = [\n",
    "  \"import threading\\n\",\n",
    "  \"import time\\n\",\n",
    "  \"def thread_info(thread):\\n\",\n",
    "  \"  print('Thread name:\\t\\t',thread.getName())\\n\",\n",
    "  \"  print('Thread id:\\t\\t',thread.ident)\\n\",\n",
    "  \"  print('Thread native id:\\t',thread.native_id)\\n\",\n",
    "  \"  print('Thread running?\\t\\t',thread.is_alive())\\n\",\n",
    "  \"  print('Thread is daemon?\\t',thread.isDaemon())\\n\",\n",
    "  \"  print('Thread timeout:\\t\\t',threading.TIMEOUT_MAX)\\n\",\n",
    "  \"  print()\\n\",\n",
    "  \"def increment(val):\\n\",\n",
    "  \"  semaphore = threading.Semaphore()\\n\",\n",
    "  \"  semaphore.acquire()\\n\",\n",
    "  \"  try:\\n\",\n",
    "  \"    time.sleep(2)\\n\",\n",
    "  \"    val += 1\\n\",\n",
    "  \"    print(val)\\n\",\n",
    "  \"  finally:\\n\",\n",
    "  \"    semaphore.release()\\n\",\n",
    "  \"  return val\\n\",\n",
    "\"\\n\",\n",
    "\"if __name__ == '__main__':\\n\",\n",
    "\"  data = 10\\n\",\n",
    "\"  thread1 = threading.Thread(target=increment,args=(data,))\\n\",\n",
    "\"  thread1.name = 'Thread 1'\\n\",\n",
    "\"  thread2 = threading.Thread(target=increment,args=(data,))    \\n\",\n",
    "\"  thread2.name = 'Thread 2'\\n\",\n",
    "\"  thread1.start()\\n\",\n",
    "\"  thread_info(thread1)\\n\",\n",
    "\"  thread2.start()\\n\",\n",
    "\"  thread_info(thread2)\\n\"\n",
    "]\n",
    "\n",
    "# The following code writes the above text strings as a file that is then executed.\n",
    "# This is necessary to get output from the process.\n",
    "# This code is sourced from Dr. Pfeiffer, from other Tour of Python units, and has been modified to suit this example.\n",
    "\n",
    "CREATE_NEW_FILE = 'x'   # python open mode\n",
    "FAILURE_EXIT = 1        # POSIX error code for program failure\n",
    "# ## supporting functions ##\n",
    "byte_seq_to_string = lambda byteseq: ''.join( chr(byte) for byte in byteseq )\n",
    "if os.path.exists( program_file_name ):\n",
    "  print( f'{program_file_name} already exists; please remove or rename it and rerun the example' )\n",
    "else:\n",
    "  with open( program_file_name, CREATE_NEW_FILE ) as program_fd:\n",
    "   for line in program_content:\n",
    "     program_fd.write( line )\n",
    "  print( '>Executing<\\n')\n",
    "  program_status = subprocess.run( [ 'python', program_file_name ], capture_output=True )\n",
    "  print( '>return code is', program_status.returncode,\"<\\n\" )\n",
    "  standard_output = byte_seq_to_string( program_status.stdout )\n",
    "  print( '> no standard output returned <' if standard_output == '' else 'standard output:\\n' + standard_output )\n",
    "  error_output = byte_seq_to_string( program_status.stderr )\n",
    "  print( '> no error output returned <' if error_output == '' else 'error output: ' + error_output )\n",
    "  os.remove( program_file_name )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 15.4.4.e Creating and using a Semaphore using the 'with' statement\n",
    "# 'with' releases the semaphore it acquires upon exit from the block\n",
    "\n",
    "import subprocess, os\n",
    "\n",
    "program_file_name = \"test.py\"\n",
    "program_content = [\n",
    "  \"import threading\\n\",\n",
    "  \"import time\\n\",\n",
    "  \"def thread_info(thread):\\n\",\n",
    "  \"  print('Thread name:\\t\\t',thread.getName())\\n\",\n",
    "  \"  print('Thread id:\\t\\t',thread.ident)\\n\",\n",
    "  \"  print('Thread native id:\\t',thread.native_id)\\n\",\n",
    "  \"  print('Thread running?\\t\\t',thread.is_alive())\\n\",\n",
    "  \"  print('Thread is daemon?\\t',thread.isDaemon())\\n\",\n",
    "  \"  print('Thread timeout:\\t\\t',threading.TIMEOUT_MAX)\\n\",\n",
    "  \"  print()\\n\",\n",
    "  \"def increment(val):\\n\",\n",
    "  \"  semaphore = threading.Semaphore()\\n\",\n",
    "  \"  with semaphore:\\n\",\n",
    "  \"    time.sleep(2)\\n\",\n",
    "  \"    val += 1\\n\",\n",
    "  \"    print(val)\\n\",\n",
    "  \"  return val\\n\",\n",
    "\"\\n\",\n",
    "\"if __name__ == '__main__':\\n\",\n",
    "\"  data = 10\\n\",\n",
    "\"  thread1 = threading.Thread(target=increment,args=(data,))\\n\",\n",
    "\"  thread1.name = 'Thread 1'\\n\",\n",
    "\"  thread2 = threading.Thread(target=increment,args=(data,))    \\n\",\n",
    "\"  thread2.name = 'Thread 2'\\n\",\n",
    "\"  thread1.start()\\n\",\n",
    "\"  thread_info(thread1)\\n\",\n",
    "\"  thread2.start()\\n\",\n",
    "\"  thread_info(thread2)\\n\"\n",
    "]\n",
    "\n",
    "# The following code writes the above text strings as a file that is then executed.\n",
    "# This is necessary to get output from the process.\n",
    "# This code is sourced from Dr. Pfeiffer, from other Tour of Python units, and has been modified to suit this example.\n",
    "\n",
    "CREATE_NEW_FILE = 'x'   # python open mode\n",
    "FAILURE_EXIT = 1        # POSIX error code for program failure\n",
    "# ## supporting functions ##\n",
    "byte_seq_to_string = lambda byteseq: ''.join( chr(byte) for byte in byteseq )\n",
    "if os.path.exists( program_file_name ):\n",
    "  print( f'{program_file_name} already exists; please remove or rename it and rerun the example' )\n",
    "else:\n",
    "  with open( program_file_name, CREATE_NEW_FILE ) as program_fd:\n",
    "   for line in program_content:\n",
    "     program_fd.write( line )\n",
    "  print( '>Executing<\\n')\n",
    "  program_status = subprocess.run( [ 'python', program_file_name ], capture_output=True )\n",
    "  print( '>return code is', program_status.returncode,\"<\\n\" )\n",
    "  standard_output = byte_seq_to_string( program_status.stdout )\n",
    "  print( '> no standard output returned <' if standard_output == '' else 'standard output:\\n' + standard_output )\n",
    "  error_output = byte_seq_to_string( program_status.stderr )\n",
    "  print( '> no error output returned <' if error_output == '' else 'error output: ' + error_output )\n",
    "  os.remove( program_file_name )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 15.4.5 Locks and Semaphores in Lib/multiprocessing.py <a name='Threads-Locks-and-Semaphores-in-Lib-multiprocessing.py'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `multiprocessing` module provides several classes that implement locks and semaphores. ",
    "These classes are similar to those provided by the threading API, with a number of small differences.  \n",
    "\n",
    "- `multiprocessing.Lock` - a non-recursive mechanism for asserting ownership over a shared resource.  \n",
    "    - Once a process has acquired a lock, any other process attempting to acquire it will block until the lock is released.  \n",
    "    - `acquire(block=True, timeout=None)`\n",
    "        - If *block* is `False`, do not block. If a call where *block* set to `True` would block, return `False` immediately. ",
    "          Note that in `threading` this is *blocking* but for `multiprocessing` it's *block*.\n",
    "        - If *timeout* is `None`, it's an unbounded wait. ",
    "          Note that in `threading` the default value is -1, but for `multiprocessing` it's `None`.  \n",
    "    - `release()`\n",
    "        - Any process can call this routine for any Lock. ",
    "          As a rule, however, a lock should only be released by the process that last acquired it.  \n",
    "        - If called for a lock that is not locked, raises a ValueError. Note that in `threading` this raises a RuntimeError instead.  \n",
    "\n\n",
    "- `multiprocessing.RLock` - a reentrant object that allows a process to repeatedly acquire the lock.  \n",
    "    - `acquire(block=True, timeout=None)`  \n",
    "        - In `threading` this is *blocking* but for `multiprocessing` it's *block*.\n",
    "        - In `threading` the default value for *timeout* is -1, but for `multiprocessing` it's `None`.  \n",
    "    -`release()` - Raise an AssertionError if called by any process that does not own the lock.\n",
    "\n\n",
    "- `multiprocessing.Semaphore([value])`\n",
    "- `multiprocessing.BoundedSemaphore([value])`\n",
    "    - The *value* argument is optional and has no default value for `multiprocessing` semaphores.\n",
    "\n",
    "The examples for `threading` work for `multiprocessing` since the code is nearly identical."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 15.5 Concurrent.futures <a name='Threads-Concurrent-Futures'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Concurrent.futures` provides a high-level interface for supporting the asynchronous execution of callable objects. ",
    "Calling a future invokes a callable object and returns a handle on a second object for managing the callable’s execution. ",
    "This includes checking to see if the callable has finished executing; waiting for the callable to finish and obtaining its result; ",
    "and cancelling the callable’s execution, if the callable has not yet been started.  \n",
    "Detailed information can be found in the [Python library documentation](https://docs.python.org/3/library/concurrent.futures.html).\n",
    "\n",
    "`Concurrent.futures` provides two functions for monitoring the status of a computation's futures.\n",
    "\n",
    "- `wait(fs, timeout=None, return_when=ALL_COMPLETED)` - waits for Future instances given by *fs* to complete, returning a named 2-tuple of sets.  \n",
    "    - The first set is named `done`. It contains the futures that completed (i.e., cancelled or finished) before the `wait` completed.\n",
    "    - The second set is named `not_done`. It contains the futures that did not complete (i.e., pending or running).\n",
    "    - *return_when* indicates when `wait()` returns.\n",
    "        - `FIRST_COMPLETED` returns when any future completes.\n",
    "        - `FIRST_EXCEPTION` returns when any future raises an exception. If no exception is raised, this is equivalent to the next option.\n",
    "        - `ALL_COMPLETED` returns when all futures complete.\n",
    "- `as_completed(fs,timeout=None)` - returns an iterator over the *fs* futures as they complete. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 15.5.1 Executor <a name='Threads-Executor'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Concurrent.futures` provides an abstract class, `concurrent.futures.Executor`, which serves as a base class for instantiating futures. ",
    "`Executor` defines three methods for its derived classes to implement.  \n",
    "\n",
    "- `submit(fn, /, *args, **kwargs)` - schedules *fn* to be executed using *args* and *kwargs*.\n",
    "    - Returns a `Future` object representing the callable execution.\n",
    "- `map(func, *iterables, timeout=None, chunksize=1)` - returns an iterator that applied *func* to instance of *iterables*.  \n",
    "    - *func* is executed asynchronously; multiple calls to *fun* may be executed concurrently.\n",
    "    - *iterables* are launched immediately, not lazily.  \n",
    "    - Returns an iterator.\n",
    "        - If the result isn't available *timeout* seconds after the original call to `map()`, ",
    "          this iterator raises a `concurrent.futures.TimeoutError` when `__next__()` is called.\n",
    "        - If *func* raises an error, this error is not raised until it's accessed through the iterator.\n",
    "    - *chunksize* specifies the size of a chunk used by the `ProcessPoolExecutor` concretion's iterator. ",
    "      There is no effect for the `ThreadPoolExecutor` concretion.\n",
    "- `shutdown(wait=True, *, cancel_futures=False)` - signals the executor to free any resources when currently pending futures are done executing.\n",
    "    - If *wait* is `True`, `shutdown()` does not return until all futures finish and resources freed. ",
    "      If `False`, `shutdown()` returns as soon as pending futures finish. \n",
    "    - If *cancel_futures* is `True`, cancel all pending futures that have not started running.\n",
    "    - Using a `with` statement avoids having to call `shutdown()` explicitly. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 15.5.2 ThreadPoolExecutor <a name='Threads-ThreadPoolExecutor'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`concurrent.futures.ThreadPoolExecutor` is a subclass of `Executor` that uses a thread pool for creating and managing futures.  \n",
    "\n",
    " &ensp;&ensp;&ensp;&ensp; `concurrent.futures.ThreadPoolExecutor(max_workers=None, thread_name_prefix='', initializer=None, initargs=())`  \n",
    "- *max_workers* indicates the number of threads in the pool\n",
    "    - Default value is the minimum of 32 or the number of processors in the system plus 4.\n",
    "    - 5 workers are preserved for IO-bound tasks.  \n",
    "- *initializer* is an optional callable, called at the start of each worker thread.\n",
    "    - *initargs* is a tuple of arguments for *initializer*.  \n",
    "Idle worker threads are reused before starting a new thread."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 15.5.3 ProcessPoolExecutor <a name='Threads-ProcessPoolExecutor'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`concurrent.futures.ThreadPoolExecutor` is a subclass of `Executor` that uses a process pool for creating and managing futures.\n",
    "\n",
    " &ensp;&ensp;&ensp;&ensp; `concurrent.futures.ProcessPoolExecutor(max_workers=None, mp_context=None, initializer=None, initargs=())`\n",
    "- *max_workers* must be 61 at most for Windows. If `None`, the default will be at most 61 even if more processors are present.  \n",
    "- *mp_context* can be a multiprocessing context or `None`. If it's not specified or is `None`, the default multiprocessing context is used."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 15.5.4 Future Objects <a name='Threads-Future-Objects'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A `Future` encapsulates the execution of a callable. Futures are created by `Executor.submit()`. ",
    "A `Future` object provides the following operations on its associated future:  \n",
    "\n",
    "- `cancel()` - attempts to cancel the call. If the call is already started or finished, returns `False`. ",
    "   Otherwise, the call is cancelled and returns `True`.\n",
    "- `cancelled()` - returns `True` iff the call was successfully canceled.\n",
    "- `running()` - returns `True` iff the call is currently executing and cannot be cancelled.\n",
    "- `done()` - returns `True` iff the call was either cancelled or finished normally.\n",
    "- `result(timeout=None)` - returns the value returned by the call.  \n",
    "    - If the call hasn't completed by *timeout* seconds, raises a `concurrent.futures.TimeoutError`.\n",
    "    - If the call is cancelled, raises a `CancelledError`.\n",
    "- `exception(timeout=None)` - returns the exception raised by the call.\n",
    "    - If the call hasn't completed by *timeout* seconds, raises a `concurrent.futures.TimeoutError`.\n",
    "    - If the call is cancelled, raises a `CancelledError`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 15.5.5 Working with Concurrent Futures <a name='Threads-Working-with-Concurrent-Futures'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 15.5.5.a Using a ProcessPoolExecutor and as_completed() to square integers 0-100\n",
    "import concurrent.futures as futures\n",
    "\n",
    "def sq(i):\n",
    "  return f'{i} squared is {i**2}'\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "  with futures.ThreadPoolExecutor() as tpe:\n",
    "    tasks = []\n",
    "    for i in range(100):\n",
    "      tasks.append(tpe.submit(sq,i))\n",
    "    for task in futures.as_completed(tasks):\n",
    "      print(task.result())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 15.6 Python Interpreter (CPython) Limitations <a name='Threads-Python-Interpreter-(CPython)-Limitations'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python's standard interpreter, CPython, inhibits thread-level parallelism with the aid of a lock, the Global Interpreter Lock (GIL), ",
    "that a thread must acquire in order to run and release in order to allow other threads to execute. ",
    "[According to Adjitsara](https://realpython.com/python-gil/), ",
    "preventing threads from executing in parallel ",
    "allowed Python 2’s developers to implement a simple, efficient strategy for reclaiming memory ",
    "used by objects that can no longer be referenced by a session’s variables. ",
    "This policy was retained for Python 3, because all strategies that have been proposed for ",
    "executing threads in parallel either require supporting libraries to be rewritten or degrade the performance of single-threaded Python programs. \n",
    "\n",
    "CPython’s use of the GIL has the following implications for exploiting concurrency and parallelism in Python programs:  \n",
    "- To speed the execution of an application that spends considerable time waiting on external requests to complete, ",
    "  use multithreading to implement concurrent execution. ",
    "  This would be the advisable, for example, for a web application that uses multiple simultaneous HTTP requests to obtain data from external hosts. \n",
    "- Otherwise, adopt one of two strategies to implement the application:\n",
    "    - If the application spends the bulk of its time processing data, use multiprocessing to parallelize the program’s operation. ",
    "      This would be the advisable, for example, for an application that renders a video, where each cell can be rendered in isolation from all others.\n",
    "    - Otherwise, use an implementation of a Python interpreter, like IronPython or PyPi, that does away with the GIL. ",
    "      This would be the advisable , for example, for an algorithm that allocates repeated, ",
    "      small computations to codes that then interact with one another, like matrix inversion."
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Raw Cell Format",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}