mutex_lock.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "                                                One Example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://www.pythontutorial.net/python-concurrency/python-threading-lock/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "illustrates a race condition problem: Output will vary 10 & 20 each time you run , depending race"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from threading import Thread\n",
    "from time import sleep\n",
    "\n",
    "\n",
    "counter = 0\n",
    "\n",
    "# define a function that increases the value of the counter variable by a number:\n",
    "def increase(by):\n",
    "    global counter\n",
    "\n",
    "    local_counter = counter\n",
    "    local_counter += by\n",
    "\n",
    "    sleep(0.1)\n",
    "\n",
    "    counter = local_counter\n",
    "    print(f'counter={counter}\\n')\n",
    "\n",
    "\n",
    "# create two threads. \n",
    "# first thread increases the counter by 10 \n",
    "# second thread increases the counter by 20:\n",
    "t1 = Thread(target=increase, args=(10,))\n",
    "t2 = Thread(target=increase, args=(20,))\n",
    "\n",
    "# start the threads\n",
    "t1.start()\n",
    "t2.start()\n",
    "\n",
    "\n",
    "# wait for the threads to complete\n",
    "t1.join()\n",
    "t2.join()\n",
    "\n",
    "\n",
    "print(f'The final counter is {counter}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Solution using mutext lock\n",
    "#### Using a threading lock to prevent the race condition\n",
    "\n",
    "In Python, you can use the `Lock` class from the `threading` module to create a lock object:\n",
    "\n",
    "First, create an instance the Lock class:\n",
    "\n",
    "```python\n",
    "lock = Lock()\n",
    "```\n",
    "\n",
    "By default, the lock is unlocked until a thread acquires it.\n",
    "\n",
    "Second, acquire a lock by calling the acquire() method:\n",
    "\n",
    "```python\n",
    "lock.acquire()\n",
    "```\n",
    "\n",
    "Third, release the lock once the thread completes changing the shared variable:\n",
    "\n",
    "```python\n",
    "lock.release()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from threading import Thread, Lock\n",
    "from time import sleep\n",
    "\n",
    "# Initialize the global counter variable\n",
    "counter = 0\n",
    "\n",
    "# Define the thread function to increase the counter by a given value using a lock\n",
    "def increase(by, lock):\n",
    "    global counter\n",
    "\n",
    "    # Acquire the lock to ensure exclusive access to the shared counter\n",
    "    lock.acquire()\n",
    "\n",
    "    # Create a local copy of the counter to perform the update\n",
    "    local_counter = counter\n",
    "    local_counter += by\n",
    "\n",
    "    # Simulate some time-consuming work using sleep\n",
    "    sleep(0.1)\n",
    "\n",
    "    # Update the global counter with the new value\n",
    "    counter = local_counter\n",
    "    print(f'counter={counter}')\n",
    "\n",
    "    # Release the lock to allow other threads to access the shared counter\n",
    "    lock.release()\n",
    "\n",
    "# Create a Lock object to synchronize access to the shared counter\n",
    "lock = Lock()\n",
    "\n",
    "# Create two threads, each incrementing the counter by a different value\n",
    "t1 = Thread(target=increase, args=(10, lock))\n",
    "t2 = Thread(target=increase, args=(20, lock))\n",
    "\n",
    "# Start the threads\n",
    "t1.start()\n",
    "t2.start()\n",
    "\n",
    "# Wait for the threads to complete their execution\n",
    "t1.join()\n",
    "t2.join()\n",
    "\n",
    "# Print the final value of the counter\n",
    "print(f'The final counter is {counter}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It’s easier to use the lock object with the with statement to acquire and release the lock within a block of code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from threading import Thread, Lock\n",
    "from time import sleep\n",
    "\n",
    "counter = 0\n",
    "\n",
    "def increase(by, lock):\n",
    "    global counter\n",
    "\n",
    "    # Use the 'with' statement to acquire and release the lock automatically\n",
    "    with lock:\n",
    "        # Create a local copy of the counter to perform the update\n",
    "        local_counter = counter\n",
    "        local_counter += by\n",
    "\n",
    "        # Simulate some time-consuming work using sleep\n",
    "        sleep(0.1)\n",
    "\n",
    "        # Update the global counter with the new value\n",
    "        counter = local_counter\n",
    "        print(f'counter={counter}')\n",
    "\n",
    "lock = Lock()\n",
    "\n",
    "# create threads\n",
    "t1 = Thread(target=increase, args=(10, lock))\n",
    "t2 = Thread(target=increase, args=(20, lock))\n",
    "\n",
    "# start the threads\n",
    "t1.start()\n",
    "t2.start()\n",
    "\n",
    "# wait for the threads to complete\n",
    "t1.join()\n",
    "t2.join()\n",
    "\n",
    "# Print the final value of the counter\n",
    "print(f'The final counter is {counter}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Alternative (same but reworked code)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternative code follows a more structured and object-oriented approach by encapsulating the shared counter and lock within a class. This approach is more modular and reusable, allowing you to easily create multiple instances of the Counter class with their own separate counters and locks, each capable of independent synchronization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from threading import Thread, Lock\n",
    "from time import sleep\n",
    "\n",
    "# Define a class to encapsulate the shared counter and lock\n",
    "class Counter:\n",
    "    def __init__(self):\n",
    "        # Initialize the counter value to 0\n",
    "        self.value = 0\n",
    "        # Create a lock object to synchronize access to the counter\n",
    "        self.lock = Lock()\n",
    "\n",
    "    # Method to increase the counter by a specified value\n",
    "    def increase(self, by):\n",
    "        # Acquire the lock to ensure exclusive access to the shared counter\n",
    "        with self.lock:\n",
    "            # Create a local variable to perform the update operation\n",
    "            current_value = self.value\n",
    "            # Increment the local variable by the specified value\n",
    "            current_value += by\n",
    "\n",
    "            # Simulate some time-consuming work using sleep\n",
    "            sleep(0.1)\n",
    "\n",
    "            # Update the shared counter with the new value\n",
    "            self.value = current_value\n",
    "            # Print the updated value of the counter\n",
    "            print(f'counter={self.value}')\n",
    "\n",
    "# Main function\n",
    "def main():\n",
    "    # Create an instance of the Counter class to manage the shared counter\n",
    "    counter = Counter()\n",
    "\n",
    "    # Create two threads with different increment values\n",
    "    t1 = Thread(target=counter.increase, args=(10, ))\n",
    "    t2 = Thread(target=counter.increase, args=(20, ))\n",
    "\n",
    "    # Start the threads\n",
    "    t1.start()\n",
    "    t2.start()\n",
    "\n",
    "    # Wait for the threads to complete their work\n",
    "    t1.join()\n",
    "    t2.join()\n",
    "\n",
    "    # Print the final value of the counter after both threads have finished\n",
    "    print(f'The final counter is {counter.value}')\n",
    "\n",
    "# Check if the script is run directly (not imported as a module)\n",
    "if __name__ == '__main__':\n",
    "    # Call the main function to start the threads and perform the synchronization\n",
    "    main()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "                                                Another Example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Synchronization Errors\n",
    "We will create two threads and give each of them a pointer towards a variable in the main containing an unsigned integer, count. Each thread will iterate a certain number of times (defined in the TIMES_TO_COUNT macro) and increment the count at each iteration. Since there are two threads, we will of course expect the final count to be exactly twice TIMES_TO_COUNT."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Solution using mutext lock"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import threading\n",
    "import time\n",
    "\n",
    "# Each thread will count TIMES_TO_COUNT times\n",
    "TIMES_TO_COUNT = 21000\n",
    "\n",
    "class Counter:\n",
    "    def __init__(self):\n",
    "        self.count = 0\n",
    "        self.lock = threading.Lock()\n",
    "\n",
    "    def increment(self):\n",
    "        with self.lock:\n",
    "            self.count += 1\n",
    "\n",
    "def thread_routine(counter):\n",
    "    # Each thread starts here\n",
    "    tid = threading.current_thread().ident\n",
    "    # Print the count before this thread starts iterating.\n",
    "    # In order to read the value of count, we lock the mutex:\n",
    "    with counter.lock:\n",
    "        print(f\"Thread [{tid}]: Count at thread start = {counter.count}\")\n",
    "    for i in range(TIMES_TO_COUNT):\n",
    "        # Iterate TIMES_TO_COUNT times\n",
    "        # Increment the counter at each iteration\n",
    "        # Lock the mutex for the duration of the incrementation\n",
    "        counter.increment()\n",
    "    # Print the final count when this thread finishes its own count,\n",
    "    # without forgetting to lock the mutex:\n",
    "    with counter.lock:\n",
    "        print(f\"Thread [{tid}]: Final count = {counter.count}\")\n",
    "\n",
    "def main():\n",
    "    # Structure containing the threads' total count:\n",
    "    counter = Counter()\n",
    "\n",
    "    # Since each thread counts TIMES_TO_COUNT times and that\n",
    "    # we have 2 threads, we expect the final count to be\n",
    "    # 2 * TIMES_TO_COUNT:\n",
    "    print(f\"Main: Expected count is {2 * TIMES_TO_COUNT}\")\n",
    "    # Thread creation:\n",
    "    t1 = threading.Thread(target=thread_routine, args=(counter,))\n",
    "    print(f\"Main: Created first thread [{t1.ident}]\")\n",
    "    t2 = threading.Thread(target=thread_routine, args=(counter,))\n",
    "    print(f\"Main: Created second thread [{t2.ident}]\")\n",
    "    # Thread starting:\n",
    "    t1.start()\n",
    "    t2.start()\n",
    "    # Thread joining:\n",
    "    t1.join()\n",
    "    print(f\"Main: Joined first thread [{t1.ident}]\")\n",
    "    t2.join()\n",
    "    print(f\"Main: Joined second thread [{t2.ident}]\")\n",
    "    # Final count evaluation:\n",
    "    # (Here we can read the count without worrying about\n",
    "    # the lock because all threads have been joined and\n",
    "    # there can be no data race between threads)\n",
    "    if counter.count != (2 * TIMES_TO_COUNT):\n",
    "        print(f\"Main: ERROR! Total count is {counter.count}\")\n",
    "    else:\n",
    "        print(f\"Main: OK. Total count is {counter.count}\")\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()\n"
   ]
  }
 ],
 "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.11.0"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}