Project_5_3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "80fea7a1-0ac6-45df-9fe1-460889e5df63",
   "metadata": {},
   "source": [
    "## Q1). What is multithreading in python? Why is it used? Name the module used to handle threads in python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f1e4552-ce1e-4d40-af23-709e6b91e309",
   "metadata": {},
   "source": [
    "Multithreading in Python is a popular technique that enables multiple tasks to be executed simultaneously i.e the ability of a processor to execute multiple threads simultaneously is known as multithreading.\n",
    "\n",
    "Python multithreading facilitates sharing data space and resources of multiple threads with the main thread. It allows efficient and easy communication between the threads.\n",
    "\n",
    "The goal of multithreading is to complete multiple tasks at the same time, which improves application rendering and performance.\n",
    "\n",
    "Programmers can run multiple subtasks of an application at the same time by using multithreading. It lets threads talk to the same processor and share resources like files, data, and memory and it makes it easier for the user to continue running a program even when a portion of it is blocked or too long.\n",
    "\n",
    "The module used to handle threads in python is the threading and thread module but the thread module is discontinuted in python 3 and threading module has all the methods of thread module along with additional methods"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72d2b00f-a692-4eb4-883c-7b2c26af7d3a",
   "metadata": {},
   "source": [
    "## Q2) Why threading module used? Write the use of the following functions\n",
    "### a.)activeCount <br> b.)currentThread <br>c.)enumerate"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "426447c6-7c31-4e23-9001-873c0816230e",
   "metadata": {},
   "source": [
    "The threading module in Python is used for creating and managing threads in a multithreaded program. It provides a higher-level interface for working with threads, allowing you to create and control them effectively. Here's an explanation of the uses of the functions activeCount(), currentThread(), and enumerate() within the threading module:\n",
    "\n",
    "a.) **activeCount() Function**:\n",
    "   - **Use**: The activeCount() function is used to get the current number of active threads (Thread objects) in the current Python interpreter.\n",
    "   - **Purpose**: It helps you monitor and check how many threads are currently running or in a runnable state.\n",
    "\n",
    "b.) **currentThread() Function**:\n",
    "   - **Use**: The currentThread() function is used to obtain a reference to the currently executing Thread object.\n",
    "   - **Purpose**: It allows you to access information about the current thread, such as its name or other thread-specific data.\n",
    "\n",
    "c.) **enumerate() Function**:\n",
    "   - **Use**: The enumerate() function is used to obtain a list of all currently alive Thread objects.\n",
    "   - **Purpose**: It helps you inspect and interact with all active threads in your program.\n",
    "\n",
    "These functions within the threading module are essential tools for managing and monitoring threads in a multithreaded Python program, allowing you to gain control over concurrent execution and thread-related information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e1969b8a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thread 1 is running\n",
      "Thread 2 is running\n",
      "Number of active threads: 8\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/pt/19ssfcm95454p139wbpvht400000gn/T/ipykernel_38217/4202306684.py:19: DeprecationWarning: activeCount() is deprecated, use active_count() instead\n",
      "  num_active_threads = threading.activeCount()\n"
     ]
    }
   ],
   "source": [
    "#Example Implementation of activecount()\n",
    "\n",
    "import threading\n",
    "\n",
    "# Define functions to be used as thread targets\n",
    "def my_function1():\n",
    "    print(\"Thread 1 is running\")\n",
    "\n",
    "def my_function2():\n",
    "    print(\"Thread 2 is running\")\n",
    "    \n",
    "# Create and start multiple threads\n",
    "thread1 = threading.Thread(target=my_function1)\n",
    "thread2 = threading.Thread(target=my_function2)\n",
    "thread1.start()\n",
    "thread2.start()\n",
    "\n",
    "# Get the number of active threads\n",
    "num_active_threads = threading.activeCount()\n",
    "print(\"Number of active threads:\", num_active_threads)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3c755bf8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current thread name: Thread 1\n",
      "Current thread name: Thread 2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/pt/19ssfcm95454p139wbpvht400000gn/T/ipykernel_38217/439700827.py:5: DeprecationWarning: currentThread() is deprecated, use current_thread() instead\n",
      "  current_thread = threading.currentThread()\n"
     ]
    }
   ],
   "source": [
    "#Example Implementation of currentThread()\n",
    "import threading\n",
    "\n",
    "def print_current_thread_name():\n",
    "    current_thread = threading.currentThread()\n",
    "    print(\"Current thread name:\", current_thread.name)\n",
    "\n",
    "thread1 = threading.Thread(target=print_current_thread_name, name=\"Thread 1\")\n",
    "thread2 = threading.Thread(target=print_current_thread_name, name=\"Thread 2\")\n",
    "\n",
    "thread1.start()\n",
    "thread2.start()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c80039e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Active thread: MainThread\n",
      "Active thread: IOPub\n",
      "Active thread: Heartbeat\n",
      "Active thread: Thread-3 (_watch_pipe_fd)\n",
      "Active thread: Thread-4 (_watch_pipe_fd)\n",
      "Active thread: Control\n",
      "Active thread: IPythonHistorySavingThread\n",
      "Active thread: Thread-2\n"
     ]
    }
   ],
   "source": [
    "#Example Implementation of enumerate()\n",
    "import threading\n",
    "\n",
    "def my_function():\n",
    "    pass\n",
    "\n",
    "thread1 = threading.Thread(target=my_function)\n",
    "thread2 = threading.Thread(target=my_function)\n",
    "\n",
    "thread1.start()\n",
    "thread2.start()\n",
    "\n",
    "# Get a list of all currently active threads\n",
    "active_threads = threading.enumerate()\n",
    "for thread in active_threads:\n",
    "    print(\"Active thread:\", thread.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ba58d8b-b0e3-4dd9-8687-4f7529e56f30",
   "metadata": {},
   "source": [
    "## Q3. Explain the following functions\n",
    "#### run() <br> start() <br> join() <br> isAlive()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a46380c5-3eb4-42a8-af71-36b1267017c6",
   "metadata": {},
   "source": [
    "The functions run(), start(), join(), and isAlive() are related to working with threads in a multithreaded programming environment, often associated with languages like Python that provide support for multithreading. These functions are commonly used when working with threads to control their execution and query their states.\n",
    "\n",
    "1. **run()**:\n",
    "   - The run() method is not typically directly invoked by the programmer when working with threads. Instead, it is a method that can be overridden in a custom class that extends the Thread class (or implements the Runnable interface in Java). The custom class represents the thread's behavior.\n",
    "   - When the thread is started using the start() method (explained below), the run() method of the custom class is automatically executed in the new thread. It contains the code that defines the task or behavior of the thread.\n",
    "\n",
    "\n",
    "2. **start()**:\n",
    "   - The start() method is used to begin the execution of a thread.\n",
    "   - It allocates system resources for the new thread.\n",
    "   - It invokes the run() method of the thread's target, effectively starting the execution of the thread.\n",
    "   - It allows the thread to run concurrently with other threads.\n",
    "   - It's important to note that you should call start() on a thread object, not directly on the Thread class.\n",
    "\n",
    "\n",
    "3. **join()**:\n",
    "   - The join() method is used to wait for a thread to complete its execution. When you call join() on a thread, the program will block (pause) until the thread being joined finishes its task.\n",
    "   - This method is often used to ensure that the main program doesn't proceed further until the thread has completed its work. It's useful for synchronizing the execution of threads.\n",
    "\n",
    "\n",
    "4. **isAlive()**:\n",
    "   - The isAlive() method is used to check whether a thread is currently running or has completed its execution. It returns True if the thread is alive (running) and False if it has terminated.\n",
    "   - This method can be helpful for monitoring the state of threads and making decisions based on their status.\n",
    "\n",
    "\n",
    "These functions are essential for managing and controlling the execution of threads in multithreaded programs, enabling concurrent execution of tasks and synchronization when necessary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e8af32e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thread is running\n"
     ]
    }
   ],
   "source": [
    "#Example Implementation of run()\n",
    "import threading\n",
    "\n",
    "class MyThread(threading.Thread):\n",
    "    def run(self):\n",
    "        # Code to be executed in the thread\n",
    "        print(\"Thread is running\")\n",
    "\n",
    "my_thread = MyThread()\n",
    "my_thread.start()  # This starts the thread and invokes the run() method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "52be2b85",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thread is running\n"
     ]
    }
   ],
   "source": [
    "#Example Implementation of start()\n",
    "import threading\n",
    "\n",
    "def thread_function():\n",
    "    print(\"Thread is running\")\n",
    "\n",
    "my_thread = threading.Thread(target=thread_function)\n",
    "my_thread.start()  # This starts the thread."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "aa6c4d97",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thread is running\n",
      "Main program continues\n"
     ]
    }
   ],
   "source": [
    "#Example Implementation of join()\n",
    "import threading\n",
    "\n",
    "def thread_function():\n",
    "    print(\"Thread is running\")\n",
    "\n",
    "my_thread = threading.Thread(target=thread_function)\n",
    "my_thread.start()  # Start the thread\n",
    "my_thread.join()   # Wait for the thread to finish before proceeding\n",
    "print(\"Main program continues\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "046dbac8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thread is runningTrue\n",
      "\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#Example Implementation of isAlive()\n",
    "import threading\n",
    "\n",
    "def thread_function():\n",
    "    print(\"Thread is running\")\n",
    "\n",
    "my_thread = threading.Thread(target=thread_function)\n",
    "my_thread.start()  # Start the thread\n",
    "print(my_thread.is_alive())  # Check if the thread is alive (True)\n",
    "my_thread.join()   # Wait for the thread to finish\n",
    "print(my_thread.is_alive())  # Check if the thread is alive (False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb43a053-1fd7-472f-a875-1863989830b4",
   "metadata": {},
   "source": [
    "## Q4. Write a python program to create two threads. Thread one must print the list of squares and thread two must print the list of cubes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "12f311bf-10a8-4ce3-951f-87f9b84e578e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Square of the 1 is 1 \n",
      "Square of the 2 is 4 \n",
      "Square of the 3 is 9 \n",
      "Square of the 4 is 16 \n",
      "Square of the 5 is 25 \n",
      "Cube of the 1 is 1 \n",
      "Cube of the 2 is 8 \n",
      "Cube of the 3 is 27 \n",
      "Cube of the 4 is 64 \n",
      "Cube of the 5 is 125 \n",
      "Program completed\n"
     ]
    }
   ],
   "source": [
    "import threading \n",
    "\n",
    "def print_square(num):\n",
    "    for i in num:\n",
    "        sq=i**2\n",
    "        print(f\"Square of the {i} is {sq} \")\n",
    "        \n",
    "def print_cube(num):\n",
    "    for i in num:\n",
    "        cube=i**3\n",
    "        print(f\"Cube of the {i} is {cube} \")\n",
    "        \n",
    "list_num = [1,2,3,4,5]\n",
    "\n",
    "thread1=threading.Thread(target=print_square,args=(list_num,))\n",
    "thread1.start()\n",
    "\n",
    "thread2=threading.Thread(target=print_cube,args=(list_num,))\n",
    "thread2.start()\n",
    "        \n",
    "    \n",
    "thread1.join()\n",
    "thread2.join()\n",
    "\n",
    "print(\"Program completed\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9025eca6-e5e3-4b60-947d-65cc94d6b11e",
   "metadata": {},
   "source": [
    "## Q5. State advantages and disadvantages of multithreading"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5100ebc9-801f-4907-9afc-bbfa7b390897",
   "metadata": {},
   "source": [
    "### **Advantages of Multithreading:**\n",
    "\n",
    "1. Improved Performance: Enables concurrent execution, improving application speed.\n",
    "2. Responsiveness: Maintains a responsive user interface during background tasks.\n",
    "3. Resource Sharing: Efficiently shares resources among threads.\n",
    "4. Scalability: Enhances server applications' ability to handle multiple clients.\n",
    "5. Modularization: Organizes code into separate threads for readability.\n",
    "\n",
    "### **Disadvantages of Multithreading:**\n",
    "\n",
    "1. Complexity: Adds complexity to code design and debugging.\n",
    "2. Synchronization Overhead: Synchronization reduces performance gains.\n",
    "3. Race Conditions: Simultaneous data access can lead to unpredictable behavior.\n",
    "4. Deadlocks: Threads waiting for each other can freeze the program.\n",
    "5. Resource Contention: Competition for resources may degrade performance."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67906e7d-4e30-4875-85d8-d21eb51c9060",
   "metadata": {},
   "source": [
    "## Q6. Explain Deadlock and Race Conditions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b5b7460-f4d5-427f-bd11-d655e64ff3a5",
   "metadata": {},
   "source": [
    "#### Deadlock:\n",
    "Deadlock is a situation where two or more threads are blocked indefinitely, each waiting for a resource that is held by another thread within the same set. In other words, it is a state where two or more threads are unable to proceed because each is waiting for a resource that can only be released by another waiting thread. \n",
    "Deadlocks can occur when the following four conditions hold simultaneously:\n",
    "- Mutual Exclusion: At least one resource must be held in a non-sharable mode.\n",
    "- Hold and Wait: A process must be holding at least one resource and waiting for another resource.\n",
    "- No Preemption: Resources cannot be forcefully taken away from a thread; they must be released voluntarily.\n",
    "- Circular Wait: A circular chain of two or more threads, where each thread is waiting for a resource held by the next thread in the chain.\n",
    "\n",
    "Deadlocks can be quite challenging to debug and resolve since they require careful analysis and coordination of resource allocation to avoid the circular wait condition.\n",
    "\n",
    "#### Race Condition:\n",
    "A race condition occurs when two or more threads access shared data or resources simultaneously, resulting in unpredictable behavior or incorrect results. It happens when the correctness of the computation depends on the relative timing or interleaving of events between threads. Race conditions can occur due to the lack of proper synchronization mechanisms and can lead to data inconsistency, integrity issues, or program crashes.\n",
    "\n",
    "For example, consider two threads that are concurrently incrementing a shared counter variable. If the threads do not synchronize their access to the counter using locks or other synchronization primitives, a race condition can occur. The order in which the threads execute their increments and the interleaving of their operations can lead to incorrect results, such as lost updates or overwriting each other's changes.\n",
    "\n",
    "To prevent race conditions, proper synchronization techniques like locks, mutexes, or atomic operations should be used to ensure exclusive access to shared resources and maintain data consistency.\n",
    "\n",
    "Both deadlocks and race conditions are common concurrency issues that can occur in multithreaded or parallel programs. Understanding and addressing these issues is crucial for developing robust and correct concurrent software."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}