Multithreading with the Python GIL

sample1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyPcq5QorxjJJPeC+Kh6T54c",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/gist/ioluwayo/12b141bc1f581aa6e5269e77999bfb2b/sample1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        },
        "id": "Lo8TRHRLr-OD",
        "outputId": "cc76d7c6-5064-4271-a179-0df2dcf26b65"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "\"\"\"\n",
        "To demonstrate the effect of the GIL we perform a CPU intensive task in sequence vs in parallel using Threads.\n",
        "Doing the task in Sequence is surprisingly faster. Because of the GIL.  \n",
        "\"\"\"\n",
        "from time import time\n",
        "from threading import Thread\n",
        "import math\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "\n",
        "def is_prime(n):\n",
        "    for i in range(2, int(math.sqrt(n)) + 1):\n",
        "        if (n % i) == 0:\n",
        "            return False\n",
        "    return True\n",
        "\n",
        "\n",
        "def get_prime_factors(num):\n",
        "    \"\"\"\n",
        "    CPU intensive task\n",
        "    Takes a number and returns a list of its factors that are prime\n",
        "    :param num:\n",
        "    :return:\n",
        "    \"\"\"\n",
        "    factors = []\n",
        "    for n in range(2, num + 1):\n",
        "        if num % n == 0:\n",
        "            if is_prime(n):\n",
        "                factors.append(n)\n",
        "    return factors\n",
        "\n",
        "\n",
        "class CustomThread(Thread):\n",
        "    def __init__(self, n):\n",
        "        self.n = n\n",
        "        Thread.__init__(self)\n",
        "        self.result = None\n",
        "\n",
        "    def run(self):\n",
        "        self.result = get_prime_factors(self.n)\n",
        "\n",
        "\n",
        "def get_prime_factors_without_threads(numbers_list):\n",
        "    start_time = time()\n",
        "    series_results = []\n",
        "    for num in numbers_list:\n",
        "        series_results.append(get_prime_factors(num))\n",
        "    return series_results, time() - start_time\n",
        "\n",
        "\n",
        "def get_prime_factors_with_threads(numbers_list):\n",
        "    start_time = time()\n",
        "    threads_results = []\n",
        "    threads = []\n",
        "    for n in numbers_list:\n",
        "        thread = CustomThread(n)\n",
        "        thread.start()\n",
        "        threads.append(thread)\n",
        "    for thread in threads:\n",
        "        thread.join()\n",
        "        threads_results.append(thread.result)\n",
        "    return threads_results, time() - start_time\n",
        "\n",
        "\n",
        "numbers = [i for i in range(1, 30)]\n",
        "without_threads_result, without_threads_duration = get_prime_factors_without_threads(numbers)\n",
        "with_threads_result, with_threads_duration = get_prime_factors_with_threads(numbers)\n",
        "\n",
        "plt.barh([\"Without Threads\", \"With Threads\"], [without_threads_duration, with_threads_duration])\n",
        "plt.xlabel('Duration (seconds)')\n",
        "plt.ylabel('Method')\n",
        "plt.show()"
      ]
    }
  ]
}