semaphore_producer_consumer.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import threading\n",
    "import time\n",
    "\n",
    "# Declare three semaphore variables: mutex, full, and empty.\n",
    "# mutex is used to ensure mutual exclusion when accessing shared variables.\n",
    "# full represents the number of full slots in the buffer.\n",
    "# empty represents the number of empty slots in the buffer.\n",
    "mutex = threading.Semaphore(1)\n",
    "full = threading.Semaphore(0)\n",
    "empty = threading.Semaphore(3)\n",
    "\n",
    "# Variable to keep track of the item count.\n",
    "x = 0\n",
    "\n",
    "# The producer function, responsible for producing items.\n",
    "def producer():\n",
    "    global mutex, full, empty, x\n",
    "\n",
    "    # Acquire an empty slot in the buffer.\n",
    "    empty.acquire()\n",
    "\n",
    "    # Acquire the mutex to ensure mutual exclusion when accessing shared variables.\n",
    "    mutex.acquire()\n",
    "\n",
    "    # Increment the item count.\n",
    "    x += 1\n",
    "\n",
    "    # Print a message indicating the item is produced.\n",
    "    print(f\"Producer produces item {x}\\n\")\n",
    "\n",
    "    # Release the mutex to allow other threads to access shared variables.\n",
    "    mutex.release()\n",
    "\n",
    "    # Release a full slot in the buffer.\n",
    "    full.release()\n",
    "\n",
    "# The consumer function, responsible for consuming items.\n",
    "def consumer():\n",
    "    global mutex, full, empty, x\n",
    "\n",
    "    # Acquire a full slot in the buffer.\n",
    "    full.acquire()\n",
    "\n",
    "    # Acquire the mutex to ensure mutual exclusion when accessing shared variables.\n",
    "    mutex.acquire()\n",
    "\n",
    "    # Print a message indicating the item is consumed.\n",
    "    print(f\"Consumer consumes item {x}\\n\")\n",
    "\n",
    "    # Decrement the item count.\n",
    "    x -= 1\n",
    "\n",
    "    # Release the mutex to allow other threads to access shared variables.\n",
    "    mutex.release()\n",
    "\n",
    "    # Release an empty slot in the buffer.\n",
    "    empty.release()\n",
    "\n",
    "# The main function to start the producer-consumer simulation.\n",
    "def main():\n",
    "    while True:\n",
    "        # Display the menu for user selection.\n",
    "        print(\"1. PRODUCER\\n2. CONSUMER\\n3. EXIT\")\n",
    "        n = int(input(\"ENTER YOUR CHOICE: \\n\"))\n",
    "\n",
    "        if n == 1:\n",
    "            # If the buffer is not full, start a new producer thread.\n",
    "            if empty._value != 0:\n",
    "                producer_thread = threading.Thread(target=producer)\n",
    "                producer_thread.start()\n",
    "            else:\n",
    "                print(\"BUFFER IS FULL\")\n",
    "\n",
    "        elif n == 2:\n",
    "            # If the buffer is not empty, start a new consumer thread.\n",
    "            if full._value != 0:\n",
    "                consumer_thread = threading.Thread(target=consumer)\n",
    "                consumer_thread.start()\n",
    "            else:\n",
    "                print(\"BUFFER IS EMPTY\")\n",
    "\n",
    "        elif n == 3:\n",
    "            # Exit the program.\n",
    "            break\n",
    "\n",
    "        else:\n",
    "            print(\"Invalid choice. Please try again.\")\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Altenative"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import threading\n",
    "import time\n",
    "import random\n",
    "\n",
    "# Buffer size\n",
    "BUFFER_SIZE = 5\n",
    "\n",
    "# Semaphore to control access to the buffer\n",
    "mutex = threading.Semaphore(1)\n",
    "\n",
    "# Semaphore to count the empty slots in the buffer\n",
    "empty = threading.Semaphore(BUFFER_SIZE)\n",
    "\n",
    "# Semaphore to count the number of items in the buffer\n",
    "full = threading.Semaphore(0)\n",
    "\n",
    "# Buffer to store items\n",
    "buffer = []\n",
    "\n",
    "# The producer function, responsible for producing items\n",
    "def producer():\n",
    "    for _ in range(10):\n",
    "        # Generate a random item to be produced\n",
    "        item = random.randint(1, 100)\n",
    "\n",
    "        # Acquire an empty slot in the buffer\n",
    "        empty.acquire()\n",
    "\n",
    "        # Acquire the mutex to ensure mutual exclusion when accessing the buffer\n",
    "        mutex.acquire()\n",
    "\n",
    "        # Add the item to the buffer\n",
    "        buffer.append(item)\n",
    "\n",
    "        # Print a message indicating the item is produced and the current buffer contents\n",
    "        print(f\"Producer: Produced item {item}. Buffer: {buffer}\")\n",
    "\n",
    "        # Release the mutex to allow other threads to access the buffer\n",
    "        mutex.release()\n",
    "\n",
    "        # Release a full slot in the buffer to signal that an item is available\n",
    "        full.release()\n",
    "\n",
    "        # Introduce a random delay to simulate variable production time\n",
    "        time.sleep(random.uniform(0.1, 0.5))\n",
    "\n",
    "# The consumer function, responsible for consuming items\n",
    "def consumer():\n",
    "    for _ in range(10):\n",
    "        # Acquire a full slot in the buffer to check if an item is available for consumption\n",
    "        full.acquire()\n",
    "\n",
    "        # Acquire the mutex to ensure mutual exclusion when accessing the buffer\n",
    "        mutex.acquire()\n",
    "\n",
    "        # Remove the first item from the buffer\n",
    "        item = buffer.pop(0)\n",
    "\n",
    "        # Print a message indicating the item is consumed and the current buffer contents\n",
    "        print(f\"Consumer: Consumed item {item}. Buffer: {buffer}\")\n",
    "\n",
    "        # Release the mutex to allow other threads to access the buffer\n",
    "        mutex.release()\n",
    "\n",
    "        # Release an empty slot in the buffer to signal that a slot is available for production\n",
    "        empty.release()\n",
    "\n",
    "        # Introduce a random delay to simulate variable consumption time\n",
    "        time.sleep(random.uniform(0.1, 0.5))\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    # Create producer and consumer threads\n",
    "    producer_thread = threading.Thread(target=producer)\n",
    "    consumer_thread = threading.Thread(target=consumer)\n",
    "\n",
    "    # Start the threads\n",
    "    producer_thread.start()\n",
    "    consumer_thread.start()\n",
    "\n",
    "    # Wait for the threads to complete\n",
    "    producer_thread.join()\n",
    "    consumer_thread.join()\n",
    "\n",
    "    # Print a message indicating that the simulation is completed\n",
    "    print(\"Producer-Consumer simulation completed.\")\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
}