2. Thread Data & Race Conditions.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import threading\n",
    "from threading import Thread\n",
    "import random\n",
    "import sys"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Shared Data and Synchronization\n",
    "\n",
    "As we saw in our previous notebook, threads can access to share data. This is useful to communicate things and access common variables. But it'll also introduce problems, mainly [**Race Conditions**](https://en.wikipedia.org/wiki/Race_condition). Let's see an example of a Race Condition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "COUNTER = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "def increment(n):\n",
    "    global COUNTER\n",
    "    for _ in range(n):\n",
    "        COUNTER += 1\n",
    "        time.sleep(0.001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "ITERATIONS = 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "threads = [Thread(target=increment, args=(ITERATIONS,)) for _ in range(10)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "[t.start() for t in threads];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "Invalid value for counter: 4376",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-99-a643dbe60da1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mCOUNTER\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mthreads\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mITERATIONS\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34mf\"Invalid value for counter: {COUNTER}\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m: Invalid value for counter: 4376"
     ]
    }
   ],
   "source": [
    "assert COUNTER == (len(threads) * ITERATIONS), f\"Invalid value for counter: {COUNTER}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What's happening here is that the operation `+=` is not **atomic**. Which means that, behind the scenes, `+=` runs 2 (or more) operations:\n",
    "\n",
    "```python\n",
    "aux = COUNTER + 1\n",
    "COUNTER = aux\n",
    "```\n",
    "\n",
    "Both threads are executing concurrently (potentially at the same time) and they're reading outdated values of `COUNTER`, which results in a race condition."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Thread Synchronization\n",
    "\n",
    "How can we fix then this race condition? Basically, we need a way to keep the threads from stepping onto each other's data, some signal that the given resource _\"is busy\"_:\n",
    "\n",
    "<img src=\"img/recording_studio_light.png\" width=400/>\n",
    "\n",
    "*(Example of INEs studios, a recording light is on, the studio is busy, nobody will enter the room)*\n",
    "\n",
    "The easiest synchronization mechanism is a [_Lock_](https://en.wikipedia.org/wiki/Lock_(computer_science)), or a _Mutex_ (mutual exclusion lock). Python includes the very intuitive `threading.Lock` class. Let's see how a Lock works."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A Lock works in the same way as the Studio Light from the picture. The first one that \"arrives\" to that given resource \"turns on the light\", or, formally, \"acquires the lock\". Any other threads reaching that point, if they want to acquire the lock, they have to wait for the first thread to \"release it\". Let's see an example:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Locking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "lock = threading.Lock()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lock_hogger(lock, sleep=10):\n",
    "    print(\"\\t\\tThread: Acquiring lock.\")\n",
    "    lock.acquire()\n",
    "    print(\"\\t\\tThread: Lock acquired, sleeping\")\n",
    "    if sleep:\n",
    "        time.sleep(sleep)\n",
    "    print(\"\\t\\tThread: Woke up, releasing lock\")\n",
    "    lock.release()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = Thread(target=lock_hogger, args=(lock, ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\t\tThread: Acquiring lock.\n",
      "\t\tThread: Lock acquired, sleeping\n"
     ]
    }
   ],
   "source": [
    "t.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trying to acquire the lock here will probably block for a few seconds:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lock.locked()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lock acquired!\n"
     ]
    }
   ],
   "source": [
    "lock.acquire()\n",
    "print(\"Lock acquired!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once the lock has been acquired, any other thread that tries to acquire it will block:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = Thread(target=lock_hogger, args=(lock, 0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\t\tThread: Acquiring lock.\n"
     ]
    }
   ],
   "source": [
    "t.start()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "lock.release()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Time to fix our counter!\n",
    "\n",
    "Now that we know about locks, we can use them to fix our counter example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [],
   "source": [
    "COUNTER = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [],
   "source": [
    "def increment(n, lock):\n",
    "    global COUNTER\n",
    "    for _ in range(n):\n",
    "        lock.acquire()\n",
    "        COUNTER += 1\n",
    "        lock.release()\n",
    "        time.sleep(0.001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [],
   "source": [
    "ITERATIONS = 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [],
   "source": [
    "lock = threading.Lock()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [],
   "source": [
    "threads = [Thread(target=increment, args=(ITERATIONS, lock)) for _ in range(10)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [],
   "source": [
    "[t.start() for t in threads];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [],
   "source": [
    "[t.join() for t in threads];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10000"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "COUNTER"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert COUNTER == (len(threads) * ITERATIONS), f\"Invalid value for counter: {COUNTER}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It doesn't matter how many times we run the example, our code will always be synchronized!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Problems with synchronization\n",
    "\n",
    "Locks are acquired before accessing what we call \"Critical Sections\"; important sections in our code that can potentially introduce race conditions. The usual process is:\n",
    "\n",
    "```python\n",
    "lock = threading.Lock() # Problem [1]\n",
    "\n",
    "# before entering critical section\n",
    "lock.acquire()          # Problem [2]\n",
    "\n",
    "# critical section\n",
    "do_your_thing()         # Problem [3]\n",
    "\n",
    "# after we're done with it\n",
    "lock.release()          # Problem [4]\n",
    "```\n",
    "\n",
    "The problem is that locks (and many other synchronization mechanisms) are \"cooperative\". You're cooperating by using locks, but you're not obliged to use them. In a team of n developers, just one of them screws up with their lock management, everybody loses.\n",
    "\n",
    "These are the things that can potentially go wrong with cooperative, manual synchronization mechanisms:\n",
    "\n",
    "1. You might forget to use locks at all! You might have failed to recognize the situation as having a \"critical section\".\n",
    "2. You might forget to acquire the lock, getting directly into the critical section.\n",
    "3. Your critical section might be using resources NOT protected by the lock you're using, so other threads can be stepping onto that.\n",
    "4. You might forget to release the lock, or your code could break before you're able to release the lock (next example)\n",
    "5. Deadlocks! (more on later)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Problem *No.4* is very common, let's see an example of it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "lock = threading.Lock()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def faulty_lock_handler(lock, sleep=10):\n",
    "    print(\"\\t\\tThread: Acquiring lock.\")\n",
    "    lock.acquire()\n",
    "    print(\"\\t\\tThread: Lock acquired\")\n",
    "    if sleep:\n",
    "        time.sleep(sleep)\n",
    "    print(\"\\t\\tThread: Woke up, releasing lock\")\n",
    "    lock.release()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = Thread(target=faulty_lock_handler, args=(lock, 'x'))  # The `sleep` param is incorrect, should be a number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\t\tThread: Acquiring lock.\n",
      "\t\tThread: Lock acquired\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Exception in thread Thread-4:\n",
      "Traceback (most recent call last):\n",
      "  File \"/Users/santiagobasulto/.pyenv/versions/3.8.0/lib/python3.8/threading.py\", line 932, in _bootstrap_inner\n",
      "    self.run()\n",
      "  File \"/Users/santiagobasulto/.pyenv/versions/3.8.0/lib/python3.8/threading.py\", line 870, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"<ipython-input-11-40265bd9d4c2>\", line 6, in faulty_lock_handler\n",
      "TypeError: an integer is required (got type str)\n"
     ]
    }
   ],
   "source": [
    "t.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trying to acquire the lock will block **FOREVER**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-14-7d28dc795612>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mlock\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0macquire\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "lock.acquire()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could potentially add a _timeout_ to our acquire method, it will block for `n` seconds and if it hasn't acquired the lock, it'll return `False`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lock.acquire(timeout=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or we can even make it non-blocking, if it's not able to acquire the lock, it'll release it immediately:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lock.acquire(blocking=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Thankfully, we have a handle on the lock variable, so we can release it from here, but this is cheating:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "lock.release()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lock.acquire(blocking=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The way to solve this is to use Locks as Context Managers, so we're sure we'll release the lock EVEN if something goes wrong within the critical section:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "lock = threading.Lock()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fixed_lock_handler(lock, sleep=10):\n",
    "    print(\"\\t\\tThread: Acquiring lock.\")\n",
    "    with lock:\n",
    "        print(\"\\t\\tThread: Lock acquired\")\n",
    "        if sleep:\n",
    "            time.sleep(sleep)\n",
    "    print(\"\\t\\tThread: Woke up, releasing lock\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = Thread(target=fixed_lock_handler, args=(lock, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\t\tThread: Acquiring lock.\n",
      "\t\tThread: Lock acquired\n"
     ]
    }
   ],
   "source": [
    "t.start()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\t\tThread: Woke up, releasing lock"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "lock.acquire()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "lock.release()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = Thread(target=fixed_lock_handler, args=(lock, 'x'))  # The `sleep` param is incorrect, should be a number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\t\tThread: Acquiring lock."
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Exception in thread Thread-8:\n",
      "Traceback (most recent call last):\n",
      "  File \"/Users/santiagobasulto/.pyenv/versions/3.8.0/lib/python3.8/threading.py\", line 932, in _bootstrap_inner\n",
      "    "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\t\tThread: Lock acquired\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "self.run()\n",
      "  File \"/Users/santiagobasulto/.pyenv/versions/3.8.0/lib/python3.8/threading.py\", line 870, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"<ipython-input-25-9d5dd1ab9e64>\", line 6, in fixed_lock_handler\n",
      "TypeError: an integer is required (got type str)\n"
     ]
    }
   ],
   "source": [
    "t.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Is the lock still acquired?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lock.locked()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lock.acquire()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "lock.release()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, the critical section failed with an exception, but the lock was released before exiting. As a reference, the `with` context manager is syntactic sugar for the pattern:\n",
    "\n",
    "```python\n",
    "lock.acquire()\n",
    "try:\n",
    "    critical_section()\n",
    "finally:\n",
    "    lock.release()  # We'll release the lock no matter what\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Fixing our counter using `with`\n",
    "\n",
    "The last touch for our counter should be to use the context manager protocol of the lock object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [],
   "source": [
    "COUNTER = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [],
   "source": [
    "def increment(n, lock):\n",
    "    global COUNTER\n",
    "    for _ in range(n):\n",
    "        with lock:\n",
    "            COUNTER += 1\n",
    "        time.sleep(0.001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [],
   "source": [
    "ITERATIONS = 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [],
   "source": [
    "lock = threading.Lock()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [],
   "source": [
    "threads = [Thread(target=increment, args=(ITERATIONS, lock)) for _ in range(10)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [],
   "source": [
    "[t.start() for t in threads];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [],
   "source": [
    "[t.join() for t in threads];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10000"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "COUNTER"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert COUNTER == (len(threads) * ITERATIONS), f\"Invalid value for counter: {COUNTER}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perfect!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summary:\n",
    "\n",
    "We've seen the importance of keeping our critical sections safe, to avoid race conditions. But there's no free lunch. To prevent race conditions we have to use synchronization mechanisms, and as we saw, that can carry other issues.\n",
    "\n",
    "In the next section we'll explore one of the many things that can go wrong with manual synchronization: one of the the scariest words in computer science: **Deadlocks**."
   ]
  }
 ],
 "metadata": {
  "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}