updated mutex lock

Author: Rakibul73

mutex_lock.ipynb

@@ -1,5 +1,12 @@
 {
  "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "                                                One Example"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -11,7 +18,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "illustrates a race condition: Output will vary 10 & 20 each time you run , depending race"
+    "illustrates a race condition problem: Output will vary 10 & 20 each time you run , depending race"
    ]
   },
   {
@@ -62,6 +69,7 @@
    "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",
@@ -195,7 +203,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Alternative"
+    "### Alternative (same but reworked code)"
    ]
   },
   {
@@ -264,6 +272,100 @@
     "    # 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": {