Python/experiment_11.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Experiment 11"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 1\n",
    "#### Write a program, which can run two-thread simultaneously. One thread will print odd numbers and another thread will print even number. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Theory\n",
    "A thread represents a separate path of execution of a group of statements<br>\n",
    "\n",
    "In every python program, there is always a thread running internally which is appointed by the PVM to execute the program statements<br>\n",
    "\n",
    "In Python program, we need to import **'threading'** module which is needed while dealing with threads. <br>\n",
    "\n",
    "#### **Creating Threads in Python**\n",
    "\n",
    "Python provides **'Thread'** class of **threading** module that is useful to create threads<br>\n",
    "\n",
    "To create user defined thread, we need to create an object of Thread class.<br>\n",
    "\n",
    "There are different ways of creating threads in Python as:<br>\n",
    "\n",
    "*   Creating a thread without using a class\n",
    "*   Creating a thread by creating a sub class to Thread Class\n",
    "*   Creating a thread without creating sub class to Thread Class\n",
    "\n",
    "#### **Creating Thread without using Sub class**<br>\n",
    "\n",
    "The purpose of a thread is to execute a group of statement like a function.<br>\n",
    "\n",
    "We can create a thread by creating an object of Thread class and pass the function name as target for the thread as:\n",
    "<br>\n",
    "```\n",
    "t = Thread(target = functionname, [args = (arg1, arg2, ...)]\n",
    "```\n",
    "Here,<br> \n",
    "> 't' represents objects of Thread class.\n",
    "\n",
    "> 'target' represents the function on which thread will act\n",
    "\n",
    "> 'args' represents a tuple of arguments which are passed to the function\n",
    "\n",
    "Thread can be started by calling start( ) method as<br>\n",
    "```\n",
    "t.start()\n",
    "```\n",
    "Then thread will jump to the target function and execute the code \n",
    "<br>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Odd Numbers: 1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 \n",
      "Even Numbers: 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 \n"
     ]
    }
   ],
   "source": [
    "from threading import *\n",
    "\n",
    "def even():\n",
    "    print('Even Numbers: ', end='')\n",
    "    for i in range(0, 30, 2):\n",
    "        print(i, end = ' ')\n",
    "    print()\n",
    "    \n",
    "def odd():\n",
    "    print('Odd Numbers: ', end = '')\n",
    "    for i in range(1, 30, 2):\n",
    "        print(i, end =' ')\n",
    "    print()\n",
    "        \n",
    "t1 = Thread(target=odd)\n",
    "t2 = Thread(target=even)\n",
    "\n",
    "t1.start()\n",
    "t2.start()\n",
    "\n",
    "t1.join()\n",
    "t2.join()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 2\n",
    "\n",
    "### Write a program to show deadlock of threads and resolve it\n",
    "\n",
    "#### Theory\n",
    "#### **Thread Synchronization**\n",
    "\n",
    "When a thread is already acting on object preventing any other thread from acting on the same object is called **Thread Synchronization**\n",
    "\n",
    "**Synchronized Object/ Mutex (Mutually Exclusive Lock):** The object on which threads are synchronized<br>\n",
    "\n",
    "Thread synchronization is recommended when multiple threads are acting on same object simultaneously<br>\n",
    "\n",
    "It is implemented using following techniques:<br>\n",
    "\n",
    "1.  Using Locks\n",
    "2.  Using Semaphores\n",
    "\n",
    "#### **Locks**\n",
    "\n",
    "It can be used to lock the object on which thread is acting.<br>\n",
    "\n",
    "When thread enters the object, it locks the object.<br>\n",
    "\n",
    "When execution gets completed, it will unlock the object and it will comes out of it<br>\n",
    "\n",
    "We can create lock by creating an object of lock class as\n",
    "```\n",
    "l = Lock()\n",
    "```\n",
    "\n",
    "To lock the current object, we should use acquire() method as\n",
    "```\n",
    "l.acquire()\n",
    "```\n",
    "To unlock or release the object, we can use release () method as\n",
    "```\n",
    "l.release()\n",
    "``` \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Deadlock: \n",
      "Hello from lock 1\n",
      "Goodbye from lock 2\n",
      "\n",
      "Avoiding Deadlock: \n",
      "Hello from lock 3\n",
      "Hello from lock 4\n",
      "Exiting Hello command\n",
      "Goodbye from lock 4\n",
      "Goodbye from lock 3\n",
      "Exiting GoodBye command\n"
     ]
    }
   ],
   "source": [
    "from threading import *\n",
    "from time import *\n",
    "l1 = Lock()\n",
    "l2 = Lock()\n",
    "l3 = Lock()\n",
    "l4 = Lock()\n",
    "\n",
    "def hello():\n",
    "    l1.acquire()\n",
    "    print('Hello from lock 1')\n",
    "    sleep(1.5)\n",
    "    l2.acquire()\n",
    "    print('Hello from lock 2')\n",
    "    l2.release()\n",
    "    l1.release()\n",
    "    print('Exiting hello')\n",
    "\n",
    "\n",
    "def goodbye():\n",
    "    l2.acquire()\n",
    "    print('Goodbye from lock 2')\n",
    "    sleep(1.5)\n",
    "    l1.acquire()\n",
    "    print('Goodbye from lock 1')\n",
    "    l1.release()\n",
    "    l2.release()\n",
    "    print('Exiting goodbye')\n",
    "\n",
    "def hello1():\n",
    "    l3.acquire()\n",
    "    print('Hello from lock 3')\n",
    "    l4.acquire()\n",
    "    print('Hello from lock 4')\n",
    "    l4.release()\n",
    "    l3.release()\n",
    "    print('Exiting Hello command')\n",
    "\n",
    "\n",
    "def goodbye1():\n",
    "    l4.acquire()\n",
    "    print('Goodbye from lock 4')\n",
    "    l3.acquire()\n",
    "    print('Goodbye from lock 3')\n",
    "    l3.release()\n",
    "    l4.release()\n",
    "    print('Exiting GoodBye command')\n",
    "\n",
    "print(\"Deadlock: \")\n",
    "t1 = Thread(target=hello)\n",
    "t2 = Thread(target=goodbye)\n",
    "\n",
    "t1.start()\n",
    "t2.start()\n",
    "print(\"\\nAvoiding Deadlock: \")\n",
    "t3 = Thread(target=hello1)\n",
    "t4 = Thread(target=goodbye1)\n",
    "\n",
    "t3.start()\n",
    "t4.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 3\n",
    "#### Write a program to demonstrate communication between threads."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Food Items You Want to Order: Pizza PavBhaji Lasagna FriedRice\n",
      "Pizza is Being Prepared..\n",
      "PavBhaji is Being Prepared..\n",
      "Lasagna is Being Prepared..\n",
      "FriedRice is Being Prepared..\n",
      "Pizza PavBhaji Lasagna FriedRice  are prepared\n"
     ]
    }
   ],
   "source": [
    "from threading import *\n",
    "class Food:\n",
    "    def __init__(self, items):\n",
    "        self.items = items\n",
    "        self.lock = Condition()\n",
    "\n",
    "    def prepare(self):\n",
    "        self.lock.acquire()\n",
    "        foodstr = ''\n",
    "        for item in self.items:\n",
    "            sleep(1)\n",
    "            print(f'{item} is Being Prepared..')\n",
    "            foodstr  = item   ' '\n",
    "        self.lock.notify()                \n",
    "        print(f'{foodstr} are prepared')\n",
    "        self.lock.release()\n",
    "\n",
    "\n",
    "class Customer:\n",
    "    def __init__(self, food):\n",
    "        self.food = food \n",
    "\n",
    "    def waiting(self):\n",
    "        self.food.lock.acquire()\n",
    "        self.food.lock.wait(timeout=0)\n",
    "        self.food.lock.release()\n",
    "        \n",
    "items = list(input(\"Enter Food Items You Want to Order: \").strip().split())        \n",
    "\n",
    "f1 = Food(items)\n",
    "\n",
    "c1 = Customer(f1)\n",
    "\n",
    "\n",
    "t1 = Thread(target=f1.prepare)\n",
    "t2 = Thread(target=c1.waiting)\n",
    "\n",
    "t1.start()\n",
    "t2.start()\n",
    "\n",
    "t1.join()\n",
    "t2.join()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}