🕷️ Crawler Inspector

URL Lookup

Direct Parameter Lookup

Raw Queries and Responses

1. Shard Calculation

Query:

Response:

Calculated Shard: 134 (from laksa021)

2. Crawled Status Check

Query:

curl -X POST \
  'http://laksa134.int.ahrefs:8124/' \
  -H 'Content-Type: text/plain' \
  -H 'X-ClickHouse-Database: crawler3' \
  -H 'Authorization: Basic YXBpOg==' \
  -d 'SELECT getAhrefsURLFromUnparsed(src_unparsed) AS found_url, ifNull(toUnixTimestamp(download_stamp), 0) AS crawl_time, ifNull(toUnixTimestamp(props_url_first_seen), 0) AS first_indexed_time, download_http_code AS http_code, src_unparsed AS src_unparsed, src_root_hash AS src_root_hash, history_drop_reason AS history_drop_reason, meta_title AS meta_title, meta_descriptions AS meta_descriptions, attrs_boilerpipe_text AS attrs_boilerpipe_text, attrs_markdown AS attrs_markdown, attrs_readable_markdown AS attrs_readable_markdown, meta_canonical AS meta_canonical FROM crawler3.page_info_local FINAL PREWHERE (src_root_hash, src_unparsed) IN ((getAhrefsRootHashFromUnparsed(getAhrefsUnparsedNoserviceFromURL(\'https://habr.com/ru/companies/otus/articles/769448/\')), getAhrefsUnparsedNoserviceFromURL(\'https://habr.com/ru/companies/otus/articles/769448/\'))) FORMAT JSONEachRow'

Response:

{"found_url":"https:\/\/habr.com\/ru\/companies\/otus\/articles\/769448\/","crawl_time":1775730386,"first_indexed_time":1698146845,"http_code":200,"src_unparsed":"com,habr!\/ru\/companies\/otus\/articles\/769448\/ s443","src_root_hash":"14843476518697139734","history_drop_reason":null,"meta_title":"Как устроен GIL (Global Interpreter Lock) в Python: влияние на многозадачность и производительность \/ Хабр","meta_descriptions":["Привет, уважаемые читатели! GIL, или Global Interpreter Lock десятилетиями оставался темой обсуждения и дебатов среди питонистов. Что такое GIL ? GIL, сокращение от Global Interpreter Lock,..."],"attrs_boilerpipe_text":"Уровень сложности\nПростой\nВремя на прочтение\n9 мин\nОхват и читатели\n48K\nОбзор\nПривет, уважаемые читатели!\nGIL, или Global Interpreter Lock десятилетиями оставался темой обсуждения и дебатов среди питонистов.\nЧто такое\nGIL\n? GIL, сокращение от Global Interpreter Lock, представляет собой важную концепцию в Python. Он представляет собой мьютекс, который блокирует доступ к объекту Python interpreter в многопоточных средах, разрешая выполнять лишь одну инструкцию за раз. Этот механизм, хоть и заботится о безопасности и целостности данных, одновременно становится камнем преткновения для тех, кто стремится максимально задействовать многозадачность и использовать полностью потенциал многоядерных процессоров.\nКогда мы говорим о многозадачности в Python, имеется в виду использование множества потоков или процессов для выполнения различных задач. Это особенно актуально в приложениях, которые требуют обработки данных в реальном времени или одновременного выполнения большого числа задач. Однако GIL вносит ограничения в этот процесс, так как только один поток имеет доступ к интерпретатору Python в определенный момент времени.\nВ начальных версиях Python, GIL не существовал. Однако, когда Python начал использоваться для многопоточных приложений, стало очевидным, что возникают проблемы с одновременным доступом к общим ресурсам. Поэтому Гвидо ван Россум и команда разработчиков внедрили GIL, чтобы обеспечить безопасность работы с памятью и объектами Python.\nGIL был введен не как намеренное ограничение, а скорее как необходимая мера для обеспечения безопасности в среде многозадачности.\nPython создавался с упором на простоту и удобство разработки, и многие внутренние структуры данных Python, такие как списки и словари, могут быть изменены в процессе выполнения программы. Это делает Python удобным для использования, но также создает потенциальные проблемы в многопоточной среде. Без GIL, множество потоков могли бы одновременно изменять и взаимодействовать с этими структурами данных, что привело бы к непредсказуемому поведению и разнообразным гонкам данных.\nВажным этапом было внедрение GIL в версии 1.5 Python. От этого момента GIL оставался фундаментальной частью ядра Python. Со временем, по мере развития языка, разработчики предпринимали попытки улучшить многозадачность и сделать GIL менее ограничивающим.\nВ версии Python 3.2 была внедрена система, позволяющая разделить блокировки GIL на несколько частей, что дало небольшой прирост производительности в определенных случаях.\nКак работает GIL\nGIL - это мьютекс, который действует как ограничитель, позволяющий только одному потоку выполнять байткод Python в один момент времени. Это означает, что в многозадачной среде Python, в один и тот же момент времени только один поток может активно выполнять Python-код.\nПример:\nimport threading\n\ndef worker():\n    for _ in range(1000000):\n        pass\n\n# Создаем два потока\nthread1 = threading.Thread(target=worker)\nthread2 = threading.Thread(target=worker)\n\n# Запускаем потоки\nthread1.start()\nthread2.start()\n\n# Ждем, пока оба потока завершатся\nthread1.join()\nthread2.join()\nВ приведенном примере два потока выполняют функцию\nworker\n, которая просто выполняет цикл. Однако из-за GIL только один из потоков будет активен в определенный момент времени. Это ограничение может существенно влиять на производительность, особенно в многозадачных приложениях.\nPython предоставляет встроенный модуль\nthreading\nдля работы с потоками. Важно отметить, что GIL существует на уровне интерпретатора Python и не зависит от операционной системы. Поэтому, даже если ваша операционная система поддерживает многозадачность, GIL может ограничивать использование нескольких ядер процессора.\nЧтобы работать с потоками в Python, вы можете создавать экземпляры класса\nThread\nиз модуля\nthreading\nи запускать их. Важно помнить, что GIL ограничивает многозадачность на уровне интерпретатора, поэтому потоки в Python подходят для задач, которые больше связаны с ожиданием ввода-вывода, чем с интенсивной обработкой данных.\nПример:\nimport threading\n\ndef print_numbers():\n    for i in range(1, 6):\n        print(f\"Number: {i}\")\n\ndef print_letters():\n    for letter in 'abcde':\n        print(f\"Letter: {letter}\")\n\n# Создаем два потока\nthread1 = threading.Thread(target=print_numbers)\nthread2 = threading.Thread(target=print_letters)\n\n# Запускаем потоки\nthread1.start()\nthread2.start()\n\n# Ждем, пока оба потока завершатся\nthread1.join()\nthread2.join()\nВ этом примере мы создаем два потока для вывода чисел и букв. Обратите внимание, что блокировка GIL не влияет на этот пример, так как он включает ожидание вывода на экране, что является операцией ввода-вывода.\nВзаимодействие потоков с GIL может привести к неожиданным результатам, особенно если не учитывать блокировки и многозадачность. Когда несколько потоков пытаются изменить одни и те же данные, могут возникнуть гонки данных (race conditions).\nПример:\nimport threading\n\ncounter = 0\n\ndef increment():\n    global counter\n    for _ in range(1000000):\n        counter += 1\n\n# Создаем два потока\nthread1 = threading.Thread(target=increment)\nthread2 = threading.Thread(target=increment)\n\n# Запускаем потоки\nthread1.start()\nthread2.start()\n\n# Ждем, пока оба потока завершатся\nthread1.join()\nthread2.join()\n\nprint(\"Counter:\", counter)\nВ этом примере два потока пытаются инкрементировать общий счетчик. Вследствие блокировки GIL, результат этой операции может быть неопределенным и зависит от того, какой поток получит доступ к счетчику в данный момент.\nСпособы обхода GIL\nОдин из наиболее эффективных способов обойти GIL - это использование многопроцессорной обработки вместо многозадачных потоков. Поскольку каждый процесс имеет свой собственный интерпретатор Python и собственный GIL, они могут параллельно выполняться на разных ядрах процессора.\nПример использования многопроцессинга в Python с использованием модуля\nmultiprocessing\n:\nimport multiprocessing\n\ndef worker(data):\n    # Здесь происходит обработка данных\n    result = data * 2\n    return result\n\ndata = [1, 2, 3, 4, 5]\n\n# Создаем пул процессов\npool = multiprocessing.Pool(processes=multiprocessing.cpu_count())\n\n# Используем многопроцессорный пул для обработки данных\nresults = pool.map(worker, data)\n\n# Завершаем пул\npool.close()\npool.join()\n\nprint(\"Результаты:\", results)\nЭтот код создает пул процессов и использует его для параллельной обработки данных. Это позволяет эффективно использовать многозадачность и обойти ограничения GIL.\nПомимо\nmultiprocessing\n, существует несколько библиотек и фреймворков, которые предоставляют более высокоуровневый доступ к многопроцессорной обработке. Например,\nconcurrent.futures\nпозволяет использовать пулы потоков и процессов, предоставляя удобный интерфейс для выполнения параллельных задач.\nПример использования\nconcurrent.futures\nс пулом потоков:\nimport concurrent.futures\n\ndef worker(data):\n    # Здесь происходит обработка данных\n    result = data * 2\n    return result\n\ndata = [1, 2, 3, 4, 5]\n\n# Создаем пул потоков\nwith concurrent.futures.ThreadPoolExecutor() as executor:\n    results = list(executor.map(worker, data))\n\nprint(\"Результаты:\", results)\nИспользуя\nconcurrent.futures\n, вы можете легко переключаться между пулами потоков и процессов в зависимости от требований вашего приложения.\nЕще одним способом обойти GIL является использование C-расширений. Python позволяет создавать расширения на C, которые могут выполнять интенсивные операции без блокировки GIL. Эти расширения могут взаимодействовать напрямую с системными вызовами операционной системы и использовать все преимущества многозадачности.\nПример создания C-расширения для Python:\n#include <Python.h>\n\nstatic PyObject* my_extension_function(PyObject* self, PyObject* args) {\n    \/\/ Здесь можно выполнять интенсивные вычисления\n    int result = 0;\n    \/\/ ...\n    return Py_BuildValue(\"i\", result);\n}\n\nstatic PyMethodDef my_extension_methods[] = {\n    {\"my_extension_function\", my_extension_function, METH_VARARGS, \"Описание функции\"},\n    {NULL, NULL, 0, NULL}\n};\n\nstatic struct PyModuleDef my_extension_module = {\n    PyModuleDef_HEAD_INIT,\n    \"my_extension\",\n    \"Описание модуля\",\n    -1,\n    my_extension_methods\n};\n\nPyMODINIT_FUNC PyInit_my_extension(void) {\n    return PyModule_Create(&my_extension_module);\n}\nЗатем этот C-расширение можно использовать в Python, обеспечивая более эффективное выполнение интенсивных операций.\nСоветы по оптимизации производительности\nЕсли ваши потоки часто блокируются, например, из-за операций ввода-вывода, это может значительно ухудшить производительность. Вместо блокировки потока, можно использовать неблокирующие операции ввода-вывода или асинхронный код, чтобы избежать простоя потоков.\nПример использования неблокирующих операций ввода-вывода:\nimport socket\n\ndef non_blocking_network_operation():\n    # Создание неблокирующего сокета\n    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n    sock.setblocking(0)\n    \n    try:\n        # Попытка подключения без блокировки\n        sock.connect((\"example.com\", 80))\n    except BlockingIOError:\n        pass\n    \n    # Продолжение выполнения кода без блокировки\nДля оптимизации производительности можно разбить код на независимые задачи и выполнять их параллельно. Вместо использования потоков Python, которые могут столкнуться с GIL, рассмотрите использование более низкоуровневых механизмов, таких как процессы или асинхронное программирование.\nПример использования асинхронного кода с библиотекой\nasyncio\n:\nimport asyncio\n\nasync def async_task():\n    await asyncio.sleep(1)\n    print(\"Выполнение асинхронной задачи\")\n\nasync def main():\n    tasks = [async_task() for _ in range(10)]\n    await asyncio.gather(*tasks)\n\nif __name__ == \"__main__\":\n    asyncio.run(main())\nАсинхронное программирование позволяет эффективно управлять задачами без блокировки потоков.\nСоветы по оптимизации производительности\nИспользуйте встроенные функции и методы:\nВ Python существует множество встроенных функций и методов, которые оптимизированы и быстрее, чем ручные аналоги. Например, вместо обхода списка циклом\nfor\n, используйте функции\nmap()\n,\nfilter()\n,\nsum()\nи другие.\nnumbers = [1, 2, 3, 4, 5]\n\n# Плохой способ\ntotal = 0\nfor num in numbers:\n    total += num\n\n# Хороший способ\ntotal = sum(numbers)\nИспользуйте генераторы:\nГенераторы в Python позволяют лениво генерировать значения и могут сэкономить память и увеличить производительность.\n# Плохой способ\nsquares = []\nfor num in range(1, 1000000):\n    squares.append(num ** 2)\n\n# Хороший способ\nsquares = (num ** 2 for num in range(1, 1000000))\nИзбегайте избыточных вычислений:\nЕсли вы выполняете одни и те же вычисления несколько раз, сохраните результат и используйте его повторно.\n# Плохой способ\nresult1 = complex_computation(data)\nresult2 = complex_computation(data)\n\n# Хороший способ\nresult = complex_computation(data)\nresult1 = result\nresult2 = result\nИспользуйте set вместо списка для быстрого поиска:\nЕсли вам часто приходится искать элементы в коллекции, используйте множества (set), которые имеют гораздо более быстрое время доступа, чем списки.\n# Плохой способ\nitems = [1, 2, 3, 4, 5]\nif 3 in items:\n    print(\"Найден!\")\n\n# Хороший способ\nitems = {1, 2, 3, 4, 5}\nif 3 in items:\n    print(\"Найден!\")\nОптимизируйте работу с файлами:\nПри работе с файлами используйте контекстные менеджеры для автоматического закрытия файлов. Кроме того, читайте и записывайте данные порциями, чтобы уменьшить использование памяти.\n# Плохой способ\nfile = open(\"data.txt\", \"r\")\ndata = file.read()\nfile.close()\n\n# Хороший способ\nwith open(\"data.txt\", \"r\") as file:\n    data = file.read(1024)\nИспользуйте функции из стандартной библиотеки:\nPython имеет множество функций и модулей в стандартной библиотеке для обработки данных, парсинга XML, работы с JSON и других задач. Вместо написания собственных решений, используйте уже существующие.\n# Плохой способ\nimport my_custom_parser\ndata = my_custom_parser.parse_xml(xml_data)\n\n# Хороший способ\nimport xml.etree.ElementTree as ET\nroot = ET.fromstring(xml_data)\nИзбегайте многократных операций I\/O:\nОперации ввода-вывода, такие как чтение и запись файлов или сетевые запросы, могут быть затратными. При выполнении множества таких операций объединяйте их и выполняйте одним запросом.\n# Плохой способ\nfor url in urls:\n    response = requests.get(url)\n    process_data(response.text)\n\n# Хороший способ\nresponses = [requests.get(url) for url in urls]\nfor response in responses:\n    process_data(response.text)\nИспользуйте алгоритмы с линейным временем выполнения:\nПри выборе алгоритмов старайтесь использовать те, которые имеют линейное время выполнения (O(n)), чтобы избежать долгих операций.\n# Плохой способ\n\n\ndef find_max(numbers):\n    max_num = numbers[0]\n    for num in numbers:\n        if num > max_num:\n            max_num = num\n    return max_num\n\n# Хороший способ\nmax_num = max(numbers)\nИспользуйте профилирование:\nПрофилирование вашего кода помогает выявить места, где тратится больше всего времени, и сосредоточить усилия на оптимизации важных частей.\nПример использования модуля\ncProfile\n:\nimport cProfile\n\ndef my_function():\n    # Код для профилирования\n\ncProfile.run(\"my_function()\")\nИзбегайте использования глобальных переменных:\nГлобальные переменные могут сделать код менее читаемым и управляемым. Вместо них используйте передачу параметров в функции и возвращение результатов.\n# Плохой способ\ncount = 0\n\ndef increment_count():\n    global count\n    count += 1\n\n# Хороший способ\ndef increment_count(count):\n    return count + 1\n\ncount = increment_count(count)\nЗаключение\nGIL - это особенность интерпретатора Python, которая ограничивает одновременное выполнение нескольких потоков Python-кода в одном процессе. Это ограничение может стать вызовом для разработчиков, особенно тех, кто сталкивается с многозадачностью и параллельной обработкой данных.\nЕсли вы уже уверенно пишете на Python и хотите выйти за рамки «скриптов для себя», курс\nPython Developer. Professional\nдаст системное понимание промышленной разработки: от асинхронности и метапрограммирования до веб‑фреймворков и анализа данных. Живые вебинары, практика и код‑ревью от специалистов помогут прокачаться до уровня middle+ или senior.\nА в \nкаталоге курсов\nвы найдете еще больше обучающих программ по разным ЯП и уровням подготовки.","attrs_markdown":"[Все потоки](https:\/\/habr.com\/ru\/articles\/)\n\n[Войти](https:\/\/habr.com\/kek\/v1\/auth\/habrahabr\/?back=\/ru\/companies\/otus\/articles\/769448\/&hl=ru)\n\n[![](https:\/\/habrastorage.org\/getpro\/habr\/company\/a65\/525\/4fe\/a655254feebb0b25a027b5e276ea6489.png)](https:\/\/habr.com\/ru\/companies\/otus\/profile\/)\n\n512K+\n\nОхват за 30 дней\n\n[OTUS](https:\/\/habr.com\/ru\/companies\/otus\/profile\/)\n\nРазвиваем технологии, обучая их создателей\n\n710,29\n\nРейтинг\n\n185 396\n\nПодписчики\n\nПодписаться\n\n[![](https:\/\/habrastorage.org\/r\/w48\/getpro\/habr\/avatars\/206\/581\/b2f\/206581b2ffb082e2150bed36b72e71d9.jpeg)](https:\/\/habr.com\/ru\/users\/badcasedaily1\/)\n\n[badcasedaily1](https:\/\/habr.com\/ru\/users\/badcasedaily1\/)\n\n24 окт 2023 в 10:48\n# Как устроен GIL (Global Interpreter Lock) в Python: влияние на многозадачность и производительность\nПростой\n\n9 мин\n\n48K\n\n[Блог компании OTUS](https:\/\/habr.com\/ru\/companies\/otus\/articles\/)[Python \\*](https:\/\/habr.com\/ru\/hubs\/python\/) [Программирование \\*](https:\/\/habr.com\/ru\/hubs\/programming\/)\n\nОбзор\n\n![](https:\/\/habrastorage.org\/r\/w1560\/getpro\/habr\/upload_files\/7ca\/0ac\/0c1\/7ca0ac0c1746170648cccffdec4155b8.jpg)\n\n*Привет, уважаемые читатели\\!*\n\nGIL, или Global Interpreter Lock десятилетиями оставался темой обсуждения и дебатов среди питонистов.\n\nЧто такое **GIL**? GIL, сокращение от Global Interpreter Lock, представляет собой важную концепцию в Python. Он представляет собой мьютекс, который блокирует доступ к объекту Python interpreter в многопоточных средах, разрешая выполнять лишь одну инструкцию за раз. Этот механизм, хоть и заботится о безопасности и целостности данных, одновременно становится камнем преткновения для тех, кто стремится максимально задействовать многозадачность и использовать полностью потенциал многоядерных процессоров.\n\nКогда мы говорим о многозадачности в Python, имеется в виду использование множества потоков или процессов для выполнения различных задач. Это особенно актуально в приложениях, которые требуют обработки данных в реальном времени или одновременного выполнения большого числа задач. Однако GIL вносит ограничения в этот процесс, так как только один поток имеет доступ к интерпретатору Python в определенный момент времени.\n\nВ начальных версиях Python, GIL не существовал. Однако, когда Python начал использоваться для многопоточных приложений, стало очевидным, что возникают проблемы с одновременным доступом к общим ресурсам. Поэтому Гвидо ван Россум и команда разработчиков внедрили GIL, чтобы обеспечить безопасность работы с памятью и объектами Python.\n\nGIL был введен не как намеренное ограничение, а скорее как необходимая мера для обеспечения безопасности в среде многозадачности.\n\nPython создавался с упором на простоту и удобство разработки, и многие внутренние структуры данных Python, такие как списки и словари, могут быть изменены в процессе выполнения программы. Это делает Python удобным для использования, но также создает потенциальные проблемы в многопоточной среде. Без GIL, множество потоков могли бы одновременно изменять и взаимодействовать с этими структурами данных, что привело бы к непредсказуемому поведению и разнообразным гонкам данных.\n\nВажным этапом было внедрение GIL в версии 1.5 Python. От этого момента GIL оставался фундаментальной частью ядра Python. Со временем, по мере развития языка, разработчики предпринимали попытки улучшить многозадачность и сделать GIL менее ограничивающим.\n\nВ версии Python 3.2 была внедрена система, позволяющая разделить блокировки GIL на несколько частей, что дало небольшой прирост производительности в определенных случаях.\n\n## Как работает GIL\nGIL - это мьютекс, который действует как ограничитель, позволяющий только одному потоку выполнять байткод Python в один момент времени. Это означает, что в многозадачной среде Python, в один и тот же момент времени только один поток может активно выполнять Python-код.\n\n**Пример:**\n```\n\n```\nВ приведенном примере два потока выполняют функцию `worker`, которая просто выполняет цикл. Однако из-за GIL только один из потоков будет активен в определенный момент времени. Это ограничение может существенно влиять на производительность, особенно в многозадачных приложениях.\n\nPython предоставляет встроенный модуль `threading` для работы с потоками. Важно отметить, что GIL существует на уровне интерпретатора Python и не зависит от операционной системы. Поэтому, даже если ваша операционная система поддерживает многозадачность, GIL может ограничивать использование нескольких ядер процессора.\n\nЧтобы работать с потоками в Python, вы можете создавать экземпляры класса `Thread` из модуля `threading` и запускать их. Важно помнить, что GIL ограничивает многозадачность на уровне интерпретатора, поэтому потоки в Python подходят для задач, которые больше связаны с ожиданием ввода-вывода, чем с интенсивной обработкой данных.\n\n**Пример:**\n```\n\n```\nВ этом примере мы создаем два потока для вывода чисел и букв. Обратите внимание, что блокировка GIL не влияет на этот пример, так как он включает ожидание вывода на экране, что является операцией ввода-вывода.\n\nВзаимодействие потоков с GIL может привести к неожиданным результатам, особенно если не учитывать блокировки и многозадачность. Когда несколько потоков пытаются изменить одни и те же данные, могут возникнуть гонки данных (race conditions).\n\n**Пример:**\n```\n\n```\nВ этом примере два потока пытаются инкрементировать общий счетчик. Вследствие блокировки GIL, результат этой операции может быть неопределенным и зависит от того, какой поток получит доступ к счетчику в данный момент.\n\n### Способы обхода GIL\nОдин из наиболее эффективных способов обойти GIL - это использование многопроцессорной обработки вместо многозадачных потоков. Поскольку каждый процесс имеет свой собственный интерпретатор Python и собственный GIL, они могут параллельно выполняться на разных ядрах процессора.\n\nПример использования многопроцессинга в Python с использованием модуля `multiprocessing`:\n```\n\n```\nЭтот код создает пул процессов и использует его для параллельной обработки данных. Это позволяет эффективно использовать многозадачность и обойти ограничения GIL.\n\nПомимо `multiprocessing`, существует несколько библиотек и фреймворков, которые предоставляют более высокоуровневый доступ к многопроцессорной обработке. Например, `concurrent.futures` позволяет использовать пулы потоков и процессов, предоставляя удобный интерфейс для выполнения параллельных задач.\n\nПример использования `concurrent.futures` с пулом потоков:\n```\n\n```\nИспользуя `concurrent.futures`, вы можете легко переключаться между пулами потоков и процессов в зависимости от требований вашего приложения.\n\nЕще одним способом обойти GIL является использование C-расширений. Python позволяет создавать расширения на C, которые могут выполнять интенсивные операции без блокировки GIL. Эти расширения могут взаимодействовать напрямую с системными вызовами операционной системы и использовать все преимущества многозадачности.\n\nПример создания C-расширения для Python:\n```\n\n```\nЗатем этот C-расширение можно использовать в Python, обеспечивая более эффективное выполнение интенсивных операций.\n\n#### Советы по оптимизации производительности\nЕсли ваши потоки часто блокируются, например, из-за операций ввода-вывода, это может значительно ухудшить производительность. Вместо блокировки потока, можно использовать неблокирующие операции ввода-вывода или асинхронный код, чтобы избежать простоя потоков.\n\n**Пример использования неблокирующих операций ввода-вывода:**\n```\n\n```\nДля оптимизации производительности можно разбить код на независимые задачи и выполнять их параллельно. Вместо использования потоков Python, которые могут столкнуться с GIL, рассмотрите использование более низкоуровневых механизмов, таких как процессы или асинхронное программирование.\n\n**Пример использования асинхронного кода с библиотекой** `asyncio`:\n```\n\n```\nАсинхронное программирование позволяет эффективно управлять задачами без блокировки потоков.\n\n## Советы по оптимизации производительности\n1. **Используйте встроенные функции и методы:**  \n   В Python существует множество встроенных функций и методов, которые оптимизированы и быстрее, чем ручные аналоги. Например, вместо обхода списка циклом `for`, используйте функции `map()`, `filter()`, `sum()` и другие.\n   ```\n   \n   ```\n2. **Используйте генераторы:**  \n   Генераторы в Python позволяют лениво генерировать значения и могут сэкономить память и увеличить производительность.\n   ```\n   \n   ```\n3. **Избегайте избыточных вычислений:**  \n   Если вы выполняете одни и те же вычисления несколько раз, сохраните результат и используйте его повторно.\n   ```\n   \n   ```\n4. **Используйте set вместо списка для быстрого поиска:**  \n   Если вам часто приходится искать элементы в коллекции, используйте множества (set), которые имеют гораздо более быстрое время доступа, чем списки.\n   ```\n   \n   ```\n5. **Оптимизируйте работу с файлами:**  \n   При работе с файлами используйте контекстные менеджеры для автоматического закрытия файлов. Кроме того, читайте и записывайте данные порциями, чтобы уменьшить использование памяти.\n   ```\n   \n   ```\n6. **Используйте функции из стандартной библиотеки:**  \n   Python имеет множество функций и модулей в стандартной библиотеке для обработки данных, парсинга XML, работы с JSON и других задач. Вместо написания собственных решений, используйте уже существующие.\n   ```\n   \n   ```\n7. **Избегайте многократных операций I\/O:**  \n   Операции ввода-вывода, такие как чтение и запись файлов или сетевые запросы, могут быть затратными. При выполнении множества таких операций объединяйте их и выполняйте одним запросом.\n   ```\n   \n   ```\n8. **Используйте алгоритмы с линейным временем выполнения:**  \n   При выборе алгоритмов старайтесь использовать те, которые имеют линейное время выполнения (O(n)), чтобы избежать долгих операций.\n   ```\n   \n   ```\n9. **Используйте профилирование:**  \n   Профилирование вашего кода помогает выявить места, где тратится больше всего времени, и сосредоточить усилия на оптимизации важных частей.\n   Пример использования модуля `cProfile`:\n   ```\n   \n   ```\n10. **Избегайте использования глобальных переменных:**  \n    Глобальные переменные могут сделать код менее читаемым и управляемым. Вместо них используйте передачу параметров в функции и возвращение результатов.\n    ```\n    \n    ```\n## Заключение\nGIL - это особенность интерпретатора Python, которая ограничивает одновременное выполнение нескольких потоков Python-кода в одном процессе. Это ограничение может стать вызовом для разработчиков, особенно тех, кто сталкивается с многозадачностью и параллельной обработкой данных.\n***\nЕсли вы уже уверенно пишете на Python и хотите выйти за рамки «скриптов для себя», курс [Python Developer. Professional](https:\/\/otus.pw\/5mJE\/) даст системное понимание промышленной разработки: от асинхронности и метапрограммирования до веб‑фреймворков и анализа данных. Живые вебинары, практика и код‑ревью от специалистов помогут прокачаться до уровня middle+ или senior.\n\nА в [каталоге курсов](https:\/\/otus.pw\/htbgi\/) вы найдете еще больше обучающих программ по разным ЯП и уровням подготовки.\n\nТеги:\n\n- [python](https:\/\/habr.com\/ru\/search\/?target_type=posts&order=relevance&q=[python])\n- [GIL](https:\/\/habr.com\/ru\/search\/?target_type=posts&order=relevance&q=[GIL])\n\nХабы:\n\n- [Блог компании OTUS](https:\/\/habr.com\/ru\/companies\/otus\/articles\/)\n- [Python](https:\/\/habr.com\/ru\/hubs\/python\/)\n- [Программирование](https:\/\/habr.com\/ru\/hubs\/programming\/)\n\n\\+9\n\n122\n\n[17](https:\/\/habr.com\/ru\/companies\/otus\/articles\/769448\/comments\/)\n\n[![](https:\/\/habrastorage.org\/getpro\/habr\/company\/a65\/525\/4fe\/a655254feebb0b25a027b5e276ea6489.png)](https:\/\/habr.com\/ru\/companies\/otus\/profile\/)\n\n512K+\n\nОхват за 30 дней\n\n[OTUS](https:\/\/habr.com\/ru\/companies\/otus\/profile\/)\n\nРазвиваем технологии, обучая их создателей\n\n[Сайт](https:\/\/otus.ru\/)[ВКонтакте](https:\/\/vk.com\/club145052891)[Telegram](https:\/\/telegram.me\/Otusjava)\n\n[![](https:\/\/habrastorage.org\/getpro\/habr\/avatars\/206\/581\/b2f\/206581b2ffb082e2150bed36b72e71d9.jpeg)](https:\/\/habr.com\/ru\/users\/badcasedaily1\/)\n\n128K+\n\nОхват за 30 дней\n\n144\n\nКарма\n\nartem[@badcasedaily1](https:\/\/habr.com\/ru\/users\/badcasedaily1\/)\n\nMotion – Peter Sandberg\n\nПодписаться\n\nПоток Бэкенд доступен 24\/7 благодаря поддержке друзей Хабра\n\n![Хабр Карьера Курсы](https:\/\/habrastorage.org\/webt\/qq\/ey\/pn\/qqeypn-py71suynxbusbakjdfjw.png)\n\nХабр Курсы для бэкендеров\n\nРЕКЛАМА\n\nПрактикум, Хекслет, SkyPro, авторские курсы — собрали всех и попросили скидки. Осталось выбрать\\!\n\n[Перейти](https:\/\/career.habr.com\/courses\/programmirovanie\/backend-razrabotka\/?erid=2VSb5zFkQ3T&utm_source=habr&utm_medium=sponsorship_hub)\n\n[Перейти в поток Бэкенд](https:\/\/habr.com\/ru\/flows\/backend\/)\n\n[Комментарии 17](https:\/\/habr.com\/ru\/companies\/otus\/articles\/769448\/comments\/)\n\n## Публикации\nЛучшие за сутки\n\nПохожие\n\n## Информация\nСайт\n\n[otus.ru](https:\/\/otus.ru\/)\n\nДата регистрации\n\n22 марта 2017\n\nДата основания\n\n1 апреля 2017\n\nЧисленность\n\n101–200 человек\n\nМестоположение\n\nРоссия\n\nПредставитель\n\n[OTUS](https:\/\/habr.com\/ru\/users\/MaxRokatansky\/)\n\nВаш аккаунт\n\n- [Войти](https:\/\/habr.com\/kek\/v1\/auth\/habrahabr\/?back=\/ru\/companies\/otus\/articles\/769448\/&hl=ru)\n- [Регистрация](https:\/\/habr.com\/kek\/v1\/auth\/habrahabr-register\/?back=\/ru\/companies\/otus\/articles\/769448\/&hl=ru)\n\nРазделы\n\n- [Статьи](https:\/\/habr.com\/ru\/articles\/)\n- [Новости](https:\/\/habr.com\/ru\/news\/)\n- [Хабы](https:\/\/habr.com\/ru\/hubs\/)\n- [Компании](https:\/\/habr.com\/ru\/companies\/)\n- [Авторы](https:\/\/habr.com\/ru\/users\/)\n- [Песочница](https:\/\/habr.com\/ru\/sandbox\/)\n\nИнформация\n\n- [Устройство сайта](https:\/\/habr.com\/ru\/docs\/help\/)\n- [Для авторов](https:\/\/habr.com\/ru\/docs\/authors\/codex\/)\n- [Для компаний](https:\/\/habr.com\/ru\/docs\/companies\/corpblogs\/)\n- [Документы](https:\/\/habr.com\/ru\/docs\/docs\/transparency\/)\n- [Соглашение](https:\/\/account.habr.com\/info\/agreement\/?hl=ru_RU)\n- [Конфиденциальность](https:\/\/account.habr.com\/info\/confidential\/?hl=ru_RU)\n\nУслуги\n\n- [Корпоративный блог](https:\/\/company.habr.com\/ru\/corporate-blogs\/)\n- [Медийная реклама](https:\/\/company.habr.com\/ru\/advertising\/)\n- [Нативные проекты](https:\/\/company.habr.com\/ru\/native-special\/)\n- [Образовательные программы](https:\/\/company.habr.com\/ru\/education-programs\/)\n- [Стартапам](https:\/\/company.habr.com\/ru\/hello-startup\/)\n\nНастройка языка\n\n[Техническая поддержка](https:\/\/habr.com\/ru\/feedback\/)\n\n© 2006–2026, [Habr](https:\/\/company.habr.com\/)","attrs_readable_markdown":"Простой\n\n9 мин\n\n48K\n\nОбзор\n\n![](https:\/\/habrastorage.org\/r\/w1560\/getpro\/habr\/upload_files\/7ca\/0ac\/0c1\/7ca0ac0c1746170648cccffdec4155b8.jpg)\n\n*Привет, уважаемые читатели\\!*\n\nGIL, или Global Interpreter Lock десятилетиями оставался темой обсуждения и дебатов среди питонистов.\n\nЧто такое **GIL**? GIL, сокращение от Global Interpreter Lock, представляет собой важную концепцию в Python. Он представляет собой мьютекс, который блокирует доступ к объекту Python interpreter в многопоточных средах, разрешая выполнять лишь одну инструкцию за раз. Этот механизм, хоть и заботится о безопасности и целостности данных, одновременно становится камнем преткновения для тех, кто стремится максимально задействовать многозадачность и использовать полностью потенциал многоядерных процессоров.\n\nКогда мы говорим о многозадачности в Python, имеется в виду использование множества потоков или процессов для выполнения различных задач. Это особенно актуально в приложениях, которые требуют обработки данных в реальном времени или одновременного выполнения большого числа задач. Однако GIL вносит ограничения в этот процесс, так как только один поток имеет доступ к интерпретатору Python в определенный момент времени.\n\nВ начальных версиях Python, GIL не существовал. Однако, когда Python начал использоваться для многопоточных приложений, стало очевидным, что возникают проблемы с одновременным доступом к общим ресурсам. Поэтому Гвидо ван Россум и команда разработчиков внедрили GIL, чтобы обеспечить безопасность работы с памятью и объектами Python.\n\nGIL был введен не как намеренное ограничение, а скорее как необходимая мера для обеспечения безопасности в среде многозадачности.\n\nPython создавался с упором на простоту и удобство разработки, и многие внутренние структуры данных Python, такие как списки и словари, могут быть изменены в процессе выполнения программы. Это делает Python удобным для использования, но также создает потенциальные проблемы в многопоточной среде. Без GIL, множество потоков могли бы одновременно изменять и взаимодействовать с этими структурами данных, что привело бы к непредсказуемому поведению и разнообразным гонкам данных.\n\nВажным этапом было внедрение GIL в версии 1.5 Python. От этого момента GIL оставался фундаментальной частью ядра Python. Со временем, по мере развития языка, разработчики предпринимали попытки улучшить многозадачность и сделать GIL менее ограничивающим.\n\nВ версии Python 3.2 была внедрена система, позволяющая разделить блокировки GIL на несколько частей, что дало небольшой прирост производительности в определенных случаях.\n\n## Как работает GIL\nGIL - это мьютекс, который действует как ограничитель, позволяющий только одному потоку выполнять байткод Python в один момент времени. Это означает, что в многозадачной среде Python, в один и тот же момент времени только один поток может активно выполнять Python-код.\n\n**Пример:**\n```\nimport threading\n\ndef worker():\n    for _ in range(1000000):\n        pass\n\n# Создаем два потока\nthread1 = threading.Thread(target=worker)\nthread2 = threading.Thread(target=worker)\n\n# Запускаем потоки\nthread1.start()\nthread2.start()\n\n# Ждем, пока оба потока завершатся\nthread1.join()\nthread2.join()\n```\nВ приведенном примере два потока выполняют функцию `worker`, которая просто выполняет цикл. Однако из-за GIL только один из потоков будет активен в определенный момент времени. Это ограничение может существенно влиять на производительность, особенно в многозадачных приложениях.\n\nPython предоставляет встроенный модуль `threading` для работы с потоками. Важно отметить, что GIL существует на уровне интерпретатора Python и не зависит от операционной системы. Поэтому, даже если ваша операционная система поддерживает многозадачность, GIL может ограничивать использование нескольких ядер процессора.\n\nЧтобы работать с потоками в Python, вы можете создавать экземпляры класса `Thread` из модуля `threading` и запускать их. Важно помнить, что GIL ограничивает многозадачность на уровне интерпретатора, поэтому потоки в Python подходят для задач, которые больше связаны с ожиданием ввода-вывода, чем с интенсивной обработкой данных.\n\n**Пример:**\n```\nimport threading\n\ndef print_numbers():\n    for i in range(1, 6):\n        print(f\"Number: {i}\")\n\ndef print_letters():\n    for letter in 'abcde':\n        print(f\"Letter: {letter}\")\n\n# Создаем два потока\nthread1 = threading.Thread(target=print_numbers)\nthread2 = threading.Thread(target=print_letters)\n\n# Запускаем потоки\nthread1.start()\nthread2.start()\n\n# Ждем, пока оба потока завершатся\nthread1.join()\nthread2.join()\n```\nВ этом примере мы создаем два потока для вывода чисел и букв. Обратите внимание, что блокировка GIL не влияет на этот пример, так как он включает ожидание вывода на экране, что является операцией ввода-вывода.\n\nВзаимодействие потоков с GIL может привести к неожиданным результатам, особенно если не учитывать блокировки и многозадачность. Когда несколько потоков пытаются изменить одни и те же данные, могут возникнуть гонки данных (race conditions).\n\n**Пример:**\n```\nimport threading\n\ncounter = 0\n\ndef increment():\n    global counter\n    for _ in range(1000000):\n        counter += 1\n\n# Создаем два потока\nthread1 = threading.Thread(target=increment)\nthread2 = threading.Thread(target=increment)\n\n# Запускаем потоки\nthread1.start()\nthread2.start()\n\n# Ждем, пока оба потока завершатся\nthread1.join()\nthread2.join()\n\nprint(\"Counter:\", counter)\n```\nВ этом примере два потока пытаются инкрементировать общий счетчик. Вследствие блокировки GIL, результат этой операции может быть неопределенным и зависит от того, какой поток получит доступ к счетчику в данный момент.\n\n### Способы обхода GIL\nОдин из наиболее эффективных способов обойти GIL - это использование многопроцессорной обработки вместо многозадачных потоков. Поскольку каждый процесс имеет свой собственный интерпретатор Python и собственный GIL, они могут параллельно выполняться на разных ядрах процессора.\n\nПример использования многопроцессинга в Python с использованием модуля `multiprocessing`:\n```\nimport multiprocessing\n\ndef worker(data):\n    # Здесь происходит обработка данных\n    result = data * 2\n    return result\n\ndata = [1, 2, 3, 4, 5]\n\n# Создаем пул процессов\npool = multiprocessing.Pool(processes=multiprocessing.cpu_count())\n\n# Используем многопроцессорный пул для обработки данных\nresults = pool.map(worker, data)\n\n# Завершаем пул\npool.close()\npool.join()\n\nprint(\"Результаты:\", results)\n```\nЭтот код создает пул процессов и использует его для параллельной обработки данных. Это позволяет эффективно использовать многозадачность и обойти ограничения GIL.\n\nПомимо `multiprocessing`, существует несколько библиотек и фреймворков, которые предоставляют более высокоуровневый доступ к многопроцессорной обработке. Например, `concurrent.futures` позволяет использовать пулы потоков и процессов, предоставляя удобный интерфейс для выполнения параллельных задач.\n\nПример использования `concurrent.futures` с пулом потоков:\n```\nimport concurrent.futures\n\ndef worker(data):\n    # Здесь происходит обработка данных\n    result = data * 2\n    return result\n\ndata = [1, 2, 3, 4, 5]\n\n# Создаем пул потоков\nwith concurrent.futures.ThreadPoolExecutor() as executor:\n    results = list(executor.map(worker, data))\n\nprint(\"Результаты:\", results)\n```\nИспользуя `concurrent.futures`, вы можете легко переключаться между пулами потоков и процессов в зависимости от требований вашего приложения.\n\nЕще одним способом обойти GIL является использование C-расширений. Python позволяет создавать расширения на C, которые могут выполнять интенсивные операции без блокировки GIL. Эти расширения могут взаимодействовать напрямую с системными вызовами операционной системы и использовать все преимущества многозадачности.\n\nПример создания C-расширения для Python:\n```\n#include <Python.h>\n\nstatic PyObject* my_extension_function(PyObject* self, PyObject* args) {\n    \/\/ Здесь можно выполнять интенсивные вычисления\n    int result = 0;\n    \/\/ ...\n    return Py_BuildValue(\"i\", result);\n}\n\nstatic PyMethodDef my_extension_methods[] = {\n    {\"my_extension_function\", my_extension_function, METH_VARARGS, \"Описание функции\"},\n    {NULL, NULL, 0, NULL}\n};\n\nstatic struct PyModuleDef my_extension_module = {\n    PyModuleDef_HEAD_INIT,\n    \"my_extension\",\n    \"Описание модуля\",\n    -1,\n    my_extension_methods\n};\n\nPyMODINIT_FUNC PyInit_my_extension(void) {\n    return PyModule_Create(&my_extension_module);\n}\n```\nЗатем этот C-расширение можно использовать в Python, обеспечивая более эффективное выполнение интенсивных операций.\n\n#### Советы по оптимизации производительности\nЕсли ваши потоки часто блокируются, например, из-за операций ввода-вывода, это может значительно ухудшить производительность. Вместо блокировки потока, можно использовать неблокирующие операции ввода-вывода или асинхронный код, чтобы избежать простоя потоков.\n\n**Пример использования неблокирующих операций ввода-вывода:**\n```\nimport socket\n\ndef non_blocking_network_operation():\n    # Создание неблокирующего сокета\n    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n    sock.setblocking(0)\n    \n    try:\n        # Попытка подключения без блокировки\n        sock.connect((\"example.com\", 80))\n    except BlockingIOError:\n        pass\n    \n    # Продолжение выполнения кода без блокировки\n```\nДля оптимизации производительности можно разбить код на независимые задачи и выполнять их параллельно. Вместо использования потоков Python, которые могут столкнуться с GIL, рассмотрите использование более низкоуровневых механизмов, таких как процессы или асинхронное программирование.\n\n**Пример использования асинхронного кода с библиотекой** `asyncio`:\n```\nimport asyncio\n\nasync def async_task():\n    await asyncio.sleep(1)\n    print(\"Выполнение асинхронной задачи\")\n\nasync def main():\n    tasks = [async_task() for _ in range(10)]\n    await asyncio.gather(*tasks)\n\nif __name__ == \"__main__\":\n    asyncio.run(main())\n```\nАсинхронное программирование позволяет эффективно управлять задачами без блокировки потоков.\n\n## Советы по оптимизации производительности\n1. **Используйте встроенные функции и методы:**  \n   В Python существует множество встроенных функций и методов, которые оптимизированы и быстрее, чем ручные аналоги. Например, вместо обхода списка циклом `for`, используйте функции `map()`, `filter()`, `sum()` и другие.\n   ```\n   numbers = [1, 2, 3, 4, 5]\n\n# Плохой способ\ntotal = 0\nfor num in numbers:\n    total += num\n\n# Хороший способ\ntotal = sum(numbers)\n   ```\n2. **Используйте генераторы:**  \n   Генераторы в Python позволяют лениво генерировать значения и могут сэкономить память и увеличить производительность.\n   ```\n   # Плохой способ\nsquares = []\nfor num in range(1, 1000000):\n    squares.append(num ** 2)\n\n# Хороший способ\nsquares = (num ** 2 for num in range(1, 1000000))\n   ```\n3. **Избегайте избыточных вычислений:**  \n   Если вы выполняете одни и те же вычисления несколько раз, сохраните результат и используйте его повторно.\n   ```\n   # Плохой способ\nresult1 = complex_computation(data)\nresult2 = complex_computation(data)\n\n# Хороший способ\nresult = complex_computation(data)\nresult1 = result\nresult2 = result\n   ```\n4. **Используйте set вместо списка для быстрого поиска:**  \n   Если вам часто приходится искать элементы в коллекции, используйте множества (set), которые имеют гораздо более быстрое время доступа, чем списки.\n   ```\n   # Плохой способ\nitems = [1, 2, 3, 4, 5]\nif 3 in items:\n    print(\"Найден!\")\n\n# Хороший способ\nitems = {1, 2, 3, 4, 5}\nif 3 in items:\n    print(\"Найден!\")\n   ```\n5. **Оптимизируйте работу с файлами:**  \n   При работе с файлами используйте контекстные менеджеры для автоматического закрытия файлов. Кроме того, читайте и записывайте данные порциями, чтобы уменьшить использование памяти.\n   ```\n   # Плохой способ\nfile = open(\"data.txt\", \"r\")\ndata = file.read()\nfile.close()\n\n# Хороший способ\nwith open(\"data.txt\", \"r\") as file:\n    data = file.read(1024)\n   ```\n6. **Используйте функции из стандартной библиотеки:**  \n   Python имеет множество функций и модулей в стандартной библиотеке для обработки данных, парсинга XML, работы с JSON и других задач. Вместо написания собственных решений, используйте уже существующие.\n   ```\n   # Плохой способ\nimport my_custom_parser\ndata = my_custom_parser.parse_xml(xml_data)\n\n# Хороший способ\nimport xml.etree.ElementTree as ET\nroot = ET.fromstring(xml_data)\n   ```\n7. **Избегайте многократных операций I\/O:**  \n   Операции ввода-вывода, такие как чтение и запись файлов или сетевые запросы, могут быть затратными. При выполнении множества таких операций объединяйте их и выполняйте одним запросом.\n   ```\n   # Плохой способ\nfor url in urls:\n    response = requests.get(url)\n    process_data(response.text)\n\n# Хороший способ\nresponses = [requests.get(url) for url in urls]\nfor response in responses:\n    process_data(response.text)\n   ```\n8. **Используйте алгоритмы с линейным временем выполнения:**  \n   При выборе алгоритмов старайтесь использовать те, которые имеют линейное время выполнения (O(n)), чтобы избежать долгих операций.\n   ```\n   # Плохой способ\n\n\ndef find_max(numbers):\n    max_num = numbers[0]\n    for num in numbers:\n        if num > max_num:\n            max_num = num\n    return max_num\n\n# Хороший способ\nmax_num = max(numbers)\n   ```\n9. **Используйте профилирование:**  \n   Профилирование вашего кода помогает выявить места, где тратится больше всего времени, и сосредоточить усилия на оптимизации важных частей.\n   Пример использования модуля `cProfile`:\n   ```\n   import cProfile\n\ndef my_function():\n    # Код для профилирования\n\ncProfile.run(\"my_function()\")\n   ```\n10. **Избегайте использования глобальных переменных:**  \n    Глобальные переменные могут сделать код менее читаемым и управляемым. Вместо них используйте передачу параметров в функции и возвращение результатов.\n    ```\n    # Плохой способ\ncount = 0\n\ndef increment_count():\n    global count\n    count += 1\n\n# Хороший способ\ndef increment_count(count):\n    return count + 1\n\ncount = increment_count(count)\n    ```\n## Заключение\nGIL - это особенность интерпретатора Python, которая ограничивает одновременное выполнение нескольких потоков Python-кода в одном процессе. Это ограничение может стать вызовом для разработчиков, особенно тех, кто сталкивается с многозадачностью и параллельной обработкой данных.\n***\nЕсли вы уже уверенно пишете на Python и хотите выйти за рамки «скриптов для себя», курс [Python Developer. Professional](https:\/\/otus.pw\/5mJE\/) даст системное понимание промышленной разработки: от асинхронности и метапрограммирования до веб‑фреймворков и анализа данных. Живые вебинары, практика и код‑ревью от специалистов помогут прокачаться до уровня middle+ или senior.\n\nА в [каталоге курсов](https:\/\/otus.pw\/htbgi\/) вы найдете еще больше обучающих программ по разным ЯП и уровням подготовки.","meta_canonical":null}

3. Robots.txt Check

Query:

Response:

4. Spam/Ban Check

Query:

Response:

5. Seen Status Check

ℹ️ Skipped - page is already crawled

📄

INDEXABLE

✅

CRAWLED

10 days ago

🤖

ROBOTS ALLOWED

Page Info Filters

Filter	Status	Condition	Details
HTTP status	PASS	`download_http_code = 200`	HTTP 200
Age cutoff	PASS	`download_stamp > now() - 6 MONTH`	0.4 months ago
History drop	PASS	`isNull(history_drop_reason)`	No drop reason
Spam/ban	PASS	`fh_dont_index != 1 AND ml_spam_score = 0`	ml_spam_score=0
Canonical	PASS	`meta_canonical IS NULL OR = '' OR = src_unparsed`	Not set

Page Details

Property	Value
URL	https://habr.com/ru/companies/otus/articles/769448/
Last Crawled	2026-04-09 10:26:26 (10 days ago)
First Indexed	2023-10-24 11:27:25 (2 years ago)
HTTP Status Code	200
Meta Title	Как устроен GIL (Global Interpreter Lock) в Python: влияние на многозадачность и производительность / Хабр
Meta Description	Привет, уважаемые читатели! GIL, или Global Interpreter Lock десятилетиями оставался темой обсуждения и дебатов среди питонистов. Что такое GIL ? GIL, сокращение от Global Interpreter Lock,...
Meta Canonical	null
Boilerpipe Text	Уровень сложности Простой Время на прочтение 9 мин Охват и читатели 48K Обзор Привет, уважаемые читатели! GIL, или Global Interpreter Lock десятилетиями оставался темой обсуждения и дебатов среди питонистов. Что такое GIL ? GIL, сокращение от Global Interpreter Lock, представляет собой важную концепцию в Python. Он представляет собой мьютекс, который блокирует доступ к объекту Python interpreter в многопоточных средах, разрешая выполнять лишь одну инструкцию за раз. Этот механизм, хоть и заботится о безопасности и целостности данных, одновременно становится камнем преткновения для тех, кто стремится максимально задействовать многозадачность и использовать полностью потенциал многоядерных процессоров. Когда мы говорим о многозадачности в Python, имеется в виду использование множества потоков или процессов для выполнения различных задач. Это особенно актуально в приложениях, которые требуют обработки данных в реальном времени или одновременного выполнения большого числа задач. Однако GIL вносит ограничения в этот процесс, так как только один поток имеет доступ к интерпретатору Python в определенный момент времени. В начальных версиях Python, GIL не существовал. Однако, когда Python начал использоваться для многопоточных приложений, стало очевидным, что возникают проблемы с одновременным доступом к общим ресурсам. Поэтому Гвидо ван Россум и команда разработчиков внедрили GIL, чтобы обеспечить безопасность работы с памятью и объектами Python. GIL был введен не как намеренное ограничение, а скорее как необходимая мера для обеспечения безопасности в среде многозадачности. Python создавался с упором на простоту и удобство разработки, и многие внутренние структуры данных Python, такие как списки и словари, могут быть изменены в процессе выполнения программы. Это делает Python удобным для использования, но также создает потенциальные проблемы в многопоточной среде. Без GIL, множество потоков могли бы одновременно изменять и взаимодействовать с этими структурами данных, что привело бы к непредсказуемому поведению и разнообразным гонкам данных. Важным этапом было внедрение GIL в версии 1.5 Python. От этого момента GIL оставался фундаментальной частью ядра Python. Со временем, по мере развития языка, разработчики предпринимали попытки улучшить многозадачность и сделать GIL менее ограничивающим. В версии Python 3.2 была внедрена система, позволяющая разделить блокировки GIL на несколько частей, что дало небольшой прирост производительности в определенных случаях. Как работает GIL GIL - это мьютекс, который действует как ограничитель, позволяющий только одному потоку выполнять байткод Python в один момент времени. Это означает, что в многозадачной среде Python, в один и тот же момент времени только один поток может активно выполнять Python-код. Пример: import threading def worker(): for _ in range(1000000): pass # Создаем два потока thread1 = threading.Thread(target=worker) thread2 = threading.Thread(target=worker) # Запускаем потоки thread1.start() thread2.start() # Ждем, пока оба потока завершатся thread1.join() thread2.join() В приведенном примере два потока выполняют функцию worker , которая просто выполняет цикл. Однако из-за GIL только один из потоков будет активен в определенный момент времени. Это ограничение может существенно влиять на производительность, особенно в многозадачных приложениях. Python предоставляет встроенный модуль threading для работы с потоками. Важно отметить, что GIL существует на уровне интерпретатора Python и не зависит от операционной системы. Поэтому, даже если ваша операционная система поддерживает многозадачность, GIL может ограничивать использование нескольких ядер процессора. Чтобы работать с потоками в Python, вы можете создавать экземпляры класса Thread из модуля threading и запускать их. Важно помнить, что GIL ограничивает многозадачность на уровне интерпретатора, поэтому потоки в Python подходят для задач, которые больше связаны с ожиданием ввода-вывода, чем с интенсивной обработкой данных. Пример: import threading def print_numbers(): for i in range(1, 6): print(f"Number: {i}") def print_letters(): for letter in 'abcde': print(f"Letter: {letter}") # Создаем два потока thread1 = threading.Thread(target=print_numbers) thread2 = threading.Thread(target=print_letters) # Запускаем потоки thread1.start() thread2.start() # Ждем, пока оба потока завершатся thread1.join() thread2.join() В этом примере мы создаем два потока для вывода чисел и букв. Обратите внимание, что блокировка GIL не влияет на этот пример, так как он включает ожидание вывода на экране, что является операцией ввода-вывода. Взаимодействие потоков с GIL может привести к неожиданным результатам, особенно если не учитывать блокировки и многозадачность. Когда несколько потоков пытаются изменить одни и те же данные, могут возникнуть гонки данных (race conditions). Пример: import threading counter = 0 def increment(): global counter for _ in range(1000000): counter += 1 # Создаем два потока thread1 = threading.Thread(target=increment) thread2 = threading.Thread(target=increment) # Запускаем потоки thread1.start() thread2.start() # Ждем, пока оба потока завершатся thread1.join() thread2.join() print("Counter:", counter) В этом примере два потока пытаются инкрементировать общий счетчик. Вследствие блокировки GIL, результат этой операции может быть неопределенным и зависит от того, какой поток получит доступ к счетчику в данный момент. Способы обхода GIL Один из наиболее эффективных способов обойти GIL - это использование многопроцессорной обработки вместо многозадачных потоков. Поскольку каждый процесс имеет свой собственный интерпретатор Python и собственный GIL, они могут параллельно выполняться на разных ядрах процессора. Пример использования многопроцессинга в Python с использованием модуля multiprocessing : import multiprocessing def worker(data): # Здесь происходит обработка данных result = data * 2 return result data = [1, 2, 3, 4, 5] # Создаем пул процессов pool = multiprocessing.Pool(processes=multiprocessing.cpu_count()) # Используем многопроцессорный пул для обработки данных results = pool.map(worker, data) # Завершаем пул pool.close() pool.join() print("Результаты:", results) Этот код создает пул процессов и использует его для параллельной обработки данных. Это позволяет эффективно использовать многозадачность и обойти ограничения GIL. Помимо multiprocessing , существует несколько библиотек и фреймворков, которые предоставляют более высокоуровневый доступ к многопроцессорной обработке. Например, concurrent.futures позволяет использовать пулы потоков и процессов, предоставляя удобный интерфейс для выполнения параллельных задач. Пример использования concurrent.futures с пулом потоков: import concurrent.futures def worker(data): # Здесь происходит обработка данных result = data * 2 return result data = [1, 2, 3, 4, 5] # Создаем пул потоков with concurrent.futures.ThreadPoolExecutor() as executor: results = list(executor.map(worker, data)) print("Результаты:", results) Используя concurrent.futures , вы можете легко переключаться между пулами потоков и процессов в зависимости от требований вашего приложения. Еще одним способом обойти GIL является использование C-расширений. Python позволяет создавать расширения на C, которые могут выполнять интенсивные операции без блокировки GIL. Эти расширения могут взаимодействовать напрямую с системными вызовами операционной системы и использовать все преимущества многозадачности. Пример создания C-расширения для Python: #include <Python.h> static PyObject* my_extension_function(PyObject* self, PyObject* args) { // Здесь можно выполнять интенсивные вычисления int result = 0; // ... return Py_BuildValue("i", result); } static PyMethodDef my_extension_methods[] = { {"my_extension_function", my_extension_function, METH_VARARGS, "Описание функции"}, {NULL, NULL, 0, NULL} }; static struct PyModuleDef my_extension_module = { PyModuleDef_HEAD_INIT, "my_extension", "Описание модуля", -1, my_extension_methods }; PyMODINIT_FUNC PyInit_my_extension(void) { return PyModule_Create(&my_extension_module); } Затем этот C-расширение можно использовать в Python, обеспечивая более эффективное выполнение интенсивных операций. Советы по оптимизации производительности Если ваши потоки часто блокируются, например, из-за операций ввода-вывода, это может значительно ухудшить производительность. Вместо блокировки потока, можно использовать неблокирующие операции ввода-вывода или асинхронный код, чтобы избежать простоя потоков. Пример использования неблокирующих операций ввода-вывода: import socket def non_blocking_network_operation(): # Создание неблокирующего сокета sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.setblocking(0) try: # Попытка подключения без блокировки sock.connect(("example.com", 80)) except BlockingIOError: pass # Продолжение выполнения кода без блокировки Для оптимизации производительности можно разбить код на независимые задачи и выполнять их параллельно. Вместо использования потоков Python, которые могут столкнуться с GIL, рассмотрите использование более низкоуровневых механизмов, таких как процессы или асинхронное программирование. Пример использования асинхронного кода с библиотекой asyncio : import asyncio async def async_task(): await asyncio.sleep(1) print("Выполнение асинхронной задачи") async def main(): tasks = [async_task() for _ in range(10)] await asyncio.gather(tasks) if __name__ == "__main__": asyncio.run(main()) Асинхронное программирование позволяет эффективно управлять задачами без блокировки потоков. Советы по оптимизации производительности Используйте встроенные функции и методы: В Python существует множество встроенных функций и методов, которые оптимизированы и быстрее, чем ручные аналоги. Например, вместо обхода списка циклом for , используйте функции map() , filter() , sum() и другие. numbers = [1, 2, 3, 4, 5] # Плохой способ total = 0 for num in numbers: total += num # Хороший способ total = sum(numbers) Используйте генераторы: Генераторы в Python позволяют лениво генерировать значения и могут сэкономить память и увеличить производительность. # Плохой способ squares = [] for num in range(1, 1000000): squares.append(num * 2) # Хороший способ squares = (num ** 2 for num in range(1, 1000000)) Избегайте избыточных вычислений: Если вы выполняете одни и те же вычисления несколько раз, сохраните результат и используйте его повторно. # Плохой способ result1 = complex_computation(data) result2 = complex_computation(data) # Хороший способ result = complex_computation(data) result1 = result result2 = result Используйте set вместо списка для быстрого поиска: Если вам часто приходится искать элементы в коллекции, используйте множества (set), которые имеют гораздо более быстрое время доступа, чем списки. # Плохой способ items = [1, 2, 3, 4, 5] if 3 in items: print("Найден!") # Хороший способ items = {1, 2, 3, 4, 5} if 3 in items: print("Найден!") Оптимизируйте работу с файлами: При работе с файлами используйте контекстные менеджеры для автоматического закрытия файлов. Кроме того, читайте и записывайте данные порциями, чтобы уменьшить использование памяти. # Плохой способ file = open("data.txt", "r") data = file.read() file.close() # Хороший способ with open("data.txt", "r") as file: data = file.read(1024) Используйте функции из стандартной библиотеки: Python имеет множество функций и модулей в стандартной библиотеке для обработки данных, парсинга XML, работы с JSON и других задач. Вместо написания собственных решений, используйте уже существующие. # Плохой способ import my_custom_parser data = my_custom_parser.parse_xml(xml_data) # Хороший способ import xml.etree.ElementTree as ET root = ET.fromstring(xml_data) Избегайте многократных операций I/O: Операции ввода-вывода, такие как чтение и запись файлов или сетевые запросы, могут быть затратными. При выполнении множества таких операций объединяйте их и выполняйте одним запросом. # Плохой способ for url in urls: response = requests.get(url) process_data(response.text) # Хороший способ responses = [requests.get(url) for url in urls] for response in responses: process_data(response.text) Используйте алгоритмы с линейным временем выполнения: При выборе алгоритмов старайтесь использовать те, которые имеют линейное время выполнения (O(n)), чтобы избежать долгих операций. # Плохой способ def find_max(numbers): max_num = numbers[0] for num in numbers: if num > max_num: max_num = num return max_num # Хороший способ max_num = max(numbers) Используйте профилирование: Профилирование вашего кода помогает выявить места, где тратится больше всего времени, и сосредоточить усилия на оптимизации важных частей. Пример использования модуля cProfile : import cProfile def my_function(): # Код для профилирования cProfile.run("my_function()") Избегайте использования глобальных переменных: Глобальные переменные могут сделать код менее читаемым и управляемым. Вместо них используйте передачу параметров в функции и возвращение результатов. # Плохой способ count = 0 def increment_count(): global count count += 1 # Хороший способ def increment_count(count): return count + 1 count = increment_count(count) Заключение GIL - это особенность интерпретатора Python, которая ограничивает одновременное выполнение нескольких потоков Python-кода в одном процессе. Это ограничение может стать вызовом для разработчиков, особенно тех, кто сталкивается с многозадачностью и параллельной обработкой данных. Если вы уже уверенно пишете на Python и хотите выйти за рамки «скриптов для себя», курс Python Developer. Professional даст системное понимание промышленной разработки: от асинхронности и метапрограммирования до веб‑фреймворков и анализа данных. Живые вебинары, практика и код‑ревью от специалистов помогут прокачаться до уровня middle+ или senior. А в каталоге курсов вы найдете еще больше обучающих программ по разным ЯП и уровням подготовки.
Markdown	[Все потоки](https://habr.com/ru/articles/) [Войти](https://habr.com/kek/v1/auth/habrahabr/?back=/ru/companies/otus/articles/769448/&hl=ru) [![](https://habrastorage.org/getpro/habr/company/a65/525/4fe/a655254feebb0b25a027b5e276ea6489.png)](https://habr.com/ru/companies/otus/profile/) 512K+ Охват за 30 дней [OTUS](https://habr.com/ru/companies/otus/profile/) Развиваем технологии, обучая их создателей 710,29 Рейтинг 185 396 Подписчики Подписаться [![](https://habrastorage.org/r/w48/getpro/habr/avatars/206/581/b2f/206581b2ffb082e2150bed36b72e71d9.jpeg)](https://habr.com/ru/users/badcasedaily1/) [badcasedaily1](https://habr.com/ru/users/badcasedaily1/) 24 окт 2023 в 10:48 # Как устроен GIL (Global Interpreter Lock) в Python: влияние на многозадачность и производительность Простой 9 мин 48K [Блог компании OTUS](https://habr.com/ru/companies/otus/articles/)[Python \](https://habr.com/ru/hubs/python/) [Программирование \](https://habr.com/ru/hubs/programming/) Обзор ![](https://habrastorage.org/r/w1560/getpro/habr/upload_files/7ca/0ac/0c1/7ca0ac0c1746170648cccffdec4155b8.jpg) Привет, уважаемые читатели\! GIL, или Global Interpreter Lock десятилетиями оставался темой обсуждения и дебатов среди питонистов. Что такое GIL? GIL, сокращение от Global Interpreter Lock, представляет собой важную концепцию в Python. Он представляет собой мьютекс, который блокирует доступ к объекту Python interpreter в многопоточных средах, разрешая выполнять лишь одну инструкцию за раз. Этот механизм, хоть и заботится о безопасности и целостности данных, одновременно становится камнем преткновения для тех, кто стремится максимально задействовать многозадачность и использовать полностью потенциал многоядерных процессоров. Когда мы говорим о многозадачности в Python, имеется в виду использование множества потоков или процессов для выполнения различных задач. Это особенно актуально в приложениях, которые требуют обработки данных в реальном времени или одновременного выполнения большого числа задач. Однако GIL вносит ограничения в этот процесс, так как только один поток имеет доступ к интерпретатору Python в определенный момент времени. В начальных версиях Python, GIL не существовал. Однако, когда Python начал использоваться для многопоточных приложений, стало очевидным, что возникают проблемы с одновременным доступом к общим ресурсам. Поэтому Гвидо ван Россум и команда разработчиков внедрили GIL, чтобы обеспечить безопасность работы с памятью и объектами Python. GIL был введен не как намеренное ограничение, а скорее как необходимая мера для обеспечения безопасности в среде многозадачности. Python создавался с упором на простоту и удобство разработки, и многие внутренние структуры данных Python, такие как списки и словари, могут быть изменены в процессе выполнения программы. Это делает Python удобным для использования, но также создает потенциальные проблемы в многопоточной среде. Без GIL, множество потоков могли бы одновременно изменять и взаимодействовать с этими структурами данных, что привело бы к непредсказуемому поведению и разнообразным гонкам данных. Важным этапом было внедрение GIL в версии 1.5 Python. От этого момента GIL оставался фундаментальной частью ядра Python. Со временем, по мере развития языка, разработчики предпринимали попытки улучшить многозадачность и сделать GIL менее ограничивающим. В версии Python 3.2 была внедрена система, позволяющая разделить блокировки GIL на несколько частей, что дало небольшой прирост производительности в определенных случаях. ## Как работает GIL GIL - это мьютекс, который действует как ограничитель, позволяющий только одному потоку выполнять байткод Python в один момент времени. Это означает, что в многозадачной среде Python, в один и тот же момент времени только один поток может активно выполнять Python-код. Пример: ``` ``` В приведенном примере два потока выполняют функцию `worker`, которая просто выполняет цикл. Однако из-за GIL только один из потоков будет активен в определенный момент времени. Это ограничение может существенно влиять на производительность, особенно в многозадачных приложениях. Python предоставляет встроенный модуль `threading` для работы с потоками. Важно отметить, что GIL существует на уровне интерпретатора Python и не зависит от операционной системы. Поэтому, даже если ваша операционная система поддерживает многозадачность, GIL может ограничивать использование нескольких ядер процессора. Чтобы работать с потоками в Python, вы можете создавать экземпляры класса `Thread` из модуля `threading` и запускать их. Важно помнить, что GIL ограничивает многозадачность на уровне интерпретатора, поэтому потоки в Python подходят для задач, которые больше связаны с ожиданием ввода-вывода, чем с интенсивной обработкой данных. Пример: ``` ``` В этом примере мы создаем два потока для вывода чисел и букв. Обратите внимание, что блокировка GIL не влияет на этот пример, так как он включает ожидание вывода на экране, что является операцией ввода-вывода. Взаимодействие потоков с GIL может привести к неожиданным результатам, особенно если не учитывать блокировки и многозадачность. Когда несколько потоков пытаются изменить одни и те же данные, могут возникнуть гонки данных (race conditions). Пример: ``` ``` В этом примере два потока пытаются инкрементировать общий счетчик. Вследствие блокировки GIL, результат этой операции может быть неопределенным и зависит от того, какой поток получит доступ к счетчику в данный момент. ### Способы обхода GIL Один из наиболее эффективных способов обойти GIL - это использование многопроцессорной обработки вместо многозадачных потоков. Поскольку каждый процесс имеет свой собственный интерпретатор Python и собственный GIL, они могут параллельно выполняться на разных ядрах процессора. Пример использования многопроцессинга в Python с использованием модуля `multiprocessing`: ``` ``` Этот код создает пул процессов и использует его для параллельной обработки данных. Это позволяет эффективно использовать многозадачность и обойти ограничения GIL. Помимо `multiprocessing`, существует несколько библиотек и фреймворков, которые предоставляют более высокоуровневый доступ к многопроцессорной обработке. Например, `concurrent.futures` позволяет использовать пулы потоков и процессов, предоставляя удобный интерфейс для выполнения параллельных задач. Пример использования `concurrent.futures` с пулом потоков: ``` ``` Используя `concurrent.futures`, вы можете легко переключаться между пулами потоков и процессов в зависимости от требований вашего приложения. Еще одним способом обойти GIL является использование C-расширений. Python позволяет создавать расширения на C, которые могут выполнять интенсивные операции без блокировки GIL. Эти расширения могут взаимодействовать напрямую с системными вызовами операционной системы и использовать все преимущества многозадачности. Пример создания C-расширения для Python: ``` ``` Затем этот C-расширение можно использовать в Python, обеспечивая более эффективное выполнение интенсивных операций. #### Советы по оптимизации производительности Если ваши потоки часто блокируются, например, из-за операций ввода-вывода, это может значительно ухудшить производительность. Вместо блокировки потока, можно использовать неблокирующие операции ввода-вывода или асинхронный код, чтобы избежать простоя потоков. Пример использования неблокирующих операций ввода-вывода: ``` ``` Для оптимизации производительности можно разбить код на независимые задачи и выполнять их параллельно. Вместо использования потоков Python, которые могут столкнуться с GIL, рассмотрите использование более низкоуровневых механизмов, таких как процессы или асинхронное программирование. Пример использования асинхронного кода с библиотекой `asyncio`: ``` ``` Асинхронное программирование позволяет эффективно управлять задачами без блокировки потоков. ## Советы по оптимизации производительности 1. Используйте встроенные функции и методы: В Python существует множество встроенных функций и методов, которые оптимизированы и быстрее, чем ручные аналоги. Например, вместо обхода списка циклом `for`, используйте функции `map()`, `filter()`, `sum()` и другие. ``` ``` 2. Используйте генераторы: Генераторы в Python позволяют лениво генерировать значения и могут сэкономить память и увеличить производительность. ``` ``` 3. Избегайте избыточных вычислений: Если вы выполняете одни и те же вычисления несколько раз, сохраните результат и используйте его повторно. ``` ``` 4. Используйте set вместо списка для быстрого поиска: Если вам часто приходится искать элементы в коллекции, используйте множества (set), которые имеют гораздо более быстрое время доступа, чем списки. ``` ``` 5. Оптимизируйте работу с файлами: При работе с файлами используйте контекстные менеджеры для автоматического закрытия файлов. Кроме того, читайте и записывайте данные порциями, чтобы уменьшить использование памяти. ``` ``` 6. Используйте функции из стандартной библиотеки: Python имеет множество функций и модулей в стандартной библиотеке для обработки данных, парсинга XML, работы с JSON и других задач. Вместо написания собственных решений, используйте уже существующие. ``` ``` 7. Избегайте многократных операций I/O: Операции ввода-вывода, такие как чтение и запись файлов или сетевые запросы, могут быть затратными. При выполнении множества таких операций объединяйте их и выполняйте одним запросом. ``` ``` 8. Используйте алгоритмы с линейным временем выполнения: При выборе алгоритмов старайтесь использовать те, которые имеют линейное время выполнения (O(n)), чтобы избежать долгих операций. ``` ``` 9. Используйте профилирование: Профилирование вашего кода помогает выявить места, где тратится больше всего времени, и сосредоточить усилия на оптимизации важных частей. Пример использования модуля `cProfile`: ``` ``` 10. Избегайте использования глобальных переменных: Глобальные переменные могут сделать код менее читаемым и управляемым. Вместо них используйте передачу параметров в функции и возвращение результатов. ``` ``` ## Заключение GIL - это особенность интерпретатора Python, которая ограничивает одновременное выполнение нескольких потоков Python-кода в одном процессе. Это ограничение может стать вызовом для разработчиков, особенно тех, кто сталкивается с многозадачностью и параллельной обработкой данных. *** Если вы уже уверенно пишете на Python и хотите выйти за рамки «скриптов для себя», курс [Python Developer. Professional](https://otus.pw/5mJE/) даст системное понимание промышленной разработки: от асинхронности и метапрограммирования до веб‑фреймворков и анализа данных. Живые вебинары, практика и код‑ревью от специалистов помогут прокачаться до уровня middle+ или senior. А в [каталоге курсов](https://otus.pw/htbgi/) вы найдете еще больше обучающих программ по разным ЯП и уровням подготовки. Теги: - [python](https://habr.com/ru/search/?target_type=posts&order=relevance&q=[python]) - [GIL](https://habr.com/ru/search/?target_type=posts&order=relevance&q=[GIL]) Хабы: - [Блог компании OTUS](https://habr.com/ru/companies/otus/articles/) - [Python](https://habr.com/ru/hubs/python/) - [Программирование](https://habr.com/ru/hubs/programming/) \+9 122 [17](https://habr.com/ru/companies/otus/articles/769448/comments/) [![](https://habrastorage.org/getpro/habr/company/a65/525/4fe/a655254feebb0b25a027b5e276ea6489.png)](https://habr.com/ru/companies/otus/profile/) 512K+ Охват за 30 дней [OTUS](https://habr.com/ru/companies/otus/profile/) Развиваем технологии, обучая их создателей [Сайт](https://otus.ru/)[ВКонтакте](https://vk.com/club145052891)[Telegram](https://telegram.me/Otusjava) [![](https://habrastorage.org/getpro/habr/avatars/206/581/b2f/206581b2ffb082e2150bed36b72e71d9.jpeg)](https://habr.com/ru/users/badcasedaily1/) 128K+ Охват за 30 дней 144 Карма artem[@badcasedaily1](https://habr.com/ru/users/badcasedaily1/) Motion – Peter Sandberg Подписаться Поток Бэкенд доступен 24/7 благодаря поддержке друзей Хабра ![Хабр Карьера Курсы](https://habrastorage.org/webt/qq/ey/pn/qqeypn-py71suynxbusbakjdfjw.png) Хабр Курсы для бэкендеров РЕКЛАМА Практикум, Хекслет, SkyPro, авторские курсы — собрали всех и попросили скидки. Осталось выбрать\! [Перейти](https://career.habr.com/courses/programmirovanie/backend-razrabotka/?erid=2VSb5zFkQ3T&utm_source=habr&utm_medium=sponsorship_hub) [Перейти в поток Бэкенд](https://habr.com/ru/flows/backend/) [Комментарии 17](https://habr.com/ru/companies/otus/articles/769448/comments/) ## Публикации Лучшие за сутки Похожие ## Информация Сайт [otus.ru](https://otus.ru/) Дата регистрации 22 марта 2017 Дата основания 1 апреля 2017 Численность 101–200 человек Местоположение Россия Представитель [OTUS](https://habr.com/ru/users/MaxRokatansky/) Ваш аккаунт - [Войти](https://habr.com/kek/v1/auth/habrahabr/?back=/ru/companies/otus/articles/769448/&hl=ru) - [Регистрация](https://habr.com/kek/v1/auth/habrahabr-register/?back=/ru/companies/otus/articles/769448/&hl=ru) Разделы - [Статьи](https://habr.com/ru/articles/) - [Новости](https://habr.com/ru/news/) - [Хабы](https://habr.com/ru/hubs/) - [Компании](https://habr.com/ru/companies/) - [Авторы](https://habr.com/ru/users/) - [Песочница](https://habr.com/ru/sandbox/) Информация - [Устройство сайта](https://habr.com/ru/docs/help/) - [Для авторов](https://habr.com/ru/docs/authors/codex/) - [Для компаний](https://habr.com/ru/docs/companies/corpblogs/) - [Документы](https://habr.com/ru/docs/docs/transparency/) - [Соглашение](https://account.habr.com/info/agreement/?hl=ru_RU) - [Конфиденциальность](https://account.habr.com/info/confidential/?hl=ru_RU) Услуги - [Корпоративный блог](https://company.habr.com/ru/corporate-blogs/) - [Медийная реклама](https://company.habr.com/ru/advertising/) - [Нативные проекты](https://company.habr.com/ru/native-special/) - [Образовательные программы](https://company.habr.com/ru/education-programs/) - [Стартапам](https://company.habr.com/ru/hello-startup/) Настройка языка [Техническая поддержка](https://habr.com/ru/feedback/) © 2006–2026, [Habr](https://company.habr.com/)
Readable Markdown	Простой 9 мин 48K Обзор ![](https://habrastorage.org/r/w1560/getpro/habr/upload_files/7ca/0ac/0c1/7ca0ac0c1746170648cccffdec4155b8.jpg) Привет, уважаемые читатели\! GIL, или Global Interpreter Lock десятилетиями оставался темой обсуждения и дебатов среди питонистов. Что такое GIL? GIL, сокращение от Global Interpreter Lock, представляет собой важную концепцию в Python. Он представляет собой мьютекс, который блокирует доступ к объекту Python interpreter в многопоточных средах, разрешая выполнять лишь одну инструкцию за раз. Этот механизм, хоть и заботится о безопасности и целостности данных, одновременно становится камнем преткновения для тех, кто стремится максимально задействовать многозадачность и использовать полностью потенциал многоядерных процессоров. Когда мы говорим о многозадачности в Python, имеется в виду использование множества потоков или процессов для выполнения различных задач. Это особенно актуально в приложениях, которые требуют обработки данных в реальном времени или одновременного выполнения большого числа задач. Однако GIL вносит ограничения в этот процесс, так как только один поток имеет доступ к интерпретатору Python в определенный момент времени. В начальных версиях Python, GIL не существовал. Однако, когда Python начал использоваться для многопоточных приложений, стало очевидным, что возникают проблемы с одновременным доступом к общим ресурсам. Поэтому Гвидо ван Россум и команда разработчиков внедрили GIL, чтобы обеспечить безопасность работы с памятью и объектами Python. GIL был введен не как намеренное ограничение, а скорее как необходимая мера для обеспечения безопасности в среде многозадачности. Python создавался с упором на простоту и удобство разработки, и многие внутренние структуры данных Python, такие как списки и словари, могут быть изменены в процессе выполнения программы. Это делает Python удобным для использования, но также создает потенциальные проблемы в многопоточной среде. Без GIL, множество потоков могли бы одновременно изменять и взаимодействовать с этими структурами данных, что привело бы к непредсказуемому поведению и разнообразным гонкам данных. Важным этапом было внедрение GIL в версии 1.5 Python. От этого момента GIL оставался фундаментальной частью ядра Python. Со временем, по мере развития языка, разработчики предпринимали попытки улучшить многозадачность и сделать GIL менее ограничивающим. В версии Python 3.2 была внедрена система, позволяющая разделить блокировки GIL на несколько частей, что дало небольшой прирост производительности в определенных случаях. ## Как работает GIL GIL - это мьютекс, который действует как ограничитель, позволяющий только одному потоку выполнять байткод Python в один момент времени. Это означает, что в многозадачной среде Python, в один и тот же момент времени только один поток может активно выполнять Python-код. Пример: ``` import threading def worker(): for _ in range(1000000): pass # Создаем два потока thread1 = threading.Thread(target=worker) thread2 = threading.Thread(target=worker) # Запускаем потоки thread1.start() thread2.start() # Ждем, пока оба потока завершатся thread1.join() thread2.join() ``` В приведенном примере два потока выполняют функцию `worker`, которая просто выполняет цикл. Однако из-за GIL только один из потоков будет активен в определенный момент времени. Это ограничение может существенно влиять на производительность, особенно в многозадачных приложениях. Python предоставляет встроенный модуль `threading` для работы с потоками. Важно отметить, что GIL существует на уровне интерпретатора Python и не зависит от операционной системы. Поэтому, даже если ваша операционная система поддерживает многозадачность, GIL может ограничивать использование нескольких ядер процессора. Чтобы работать с потоками в Python, вы можете создавать экземпляры класса `Thread` из модуля `threading` и запускать их. Важно помнить, что GIL ограничивает многозадачность на уровне интерпретатора, поэтому потоки в Python подходят для задач, которые больше связаны с ожиданием ввода-вывода, чем с интенсивной обработкой данных. Пример: ``` import threading def print_numbers(): for i in range(1, 6): print(f"Number: {i}") def print_letters(): for letter in 'abcde': print(f"Letter: {letter}") # Создаем два потока thread1 = threading.Thread(target=print_numbers) thread2 = threading.Thread(target=print_letters) # Запускаем потоки thread1.start() thread2.start() # Ждем, пока оба потока завершатся thread1.join() thread2.join() ``` В этом примере мы создаем два потока для вывода чисел и букв. Обратите внимание, что блокировка GIL не влияет на этот пример, так как он включает ожидание вывода на экране, что является операцией ввода-вывода. Взаимодействие потоков с GIL может привести к неожиданным результатам, особенно если не учитывать блокировки и многозадачность. Когда несколько потоков пытаются изменить одни и те же данные, могут возникнуть гонки данных (race conditions). Пример: ``` import threading counter = 0 def increment(): global counter for _ in range(1000000): counter += 1 # Создаем два потока thread1 = threading.Thread(target=increment) thread2 = threading.Thread(target=increment) # Запускаем потоки thread1.start() thread2.start() # Ждем, пока оба потока завершатся thread1.join() thread2.join() print("Counter:", counter) ``` В этом примере два потока пытаются инкрементировать общий счетчик. Вследствие блокировки GIL, результат этой операции может быть неопределенным и зависит от того, какой поток получит доступ к счетчику в данный момент. ### Способы обхода GIL Один из наиболее эффективных способов обойти GIL - это использование многопроцессорной обработки вместо многозадачных потоков. Поскольку каждый процесс имеет свой собственный интерпретатор Python и собственный GIL, они могут параллельно выполняться на разных ядрах процессора. Пример использования многопроцессинга в Python с использованием модуля `multiprocessing`: ``` import multiprocessing def worker(data): # Здесь происходит обработка данных result = data * 2 return result data = [1, 2, 3, 4, 5] # Создаем пул процессов pool = multiprocessing.Pool(processes=multiprocessing.cpu_count()) # Используем многопроцессорный пул для обработки данных results = pool.map(worker, data) # Завершаем пул pool.close() pool.join() print("Результаты:", results) ``` Этот код создает пул процессов и использует его для параллельной обработки данных. Это позволяет эффективно использовать многозадачность и обойти ограничения GIL. Помимо `multiprocessing`, существует несколько библиотек и фреймворков, которые предоставляют более высокоуровневый доступ к многопроцессорной обработке. Например, `concurrent.futures` позволяет использовать пулы потоков и процессов, предоставляя удобный интерфейс для выполнения параллельных задач. Пример использования `concurrent.futures` с пулом потоков: ``` import concurrent.futures def worker(data): # Здесь происходит обработка данных result = data * 2 return result data = [1, 2, 3, 4, 5] # Создаем пул потоков with concurrent.futures.ThreadPoolExecutor() as executor: results = list(executor.map(worker, data)) print("Результаты:", results) ``` Используя `concurrent.futures`, вы можете легко переключаться между пулами потоков и процессов в зависимости от требований вашего приложения. Еще одним способом обойти GIL является использование C-расширений. Python позволяет создавать расширения на C, которые могут выполнять интенсивные операции без блокировки GIL. Эти расширения могут взаимодействовать напрямую с системными вызовами операционной системы и использовать все преимущества многозадачности. Пример создания C-расширения для Python: ``` #include <Python.h> static PyObject* my_extension_function(PyObject* self, PyObject* args) { // Здесь можно выполнять интенсивные вычисления int result = 0; // ... return Py_BuildValue("i", result); } static PyMethodDef my_extension_methods[] = { {"my_extension_function", my_extension_function, METH_VARARGS, "Описание функции"}, {NULL, NULL, 0, NULL} }; static struct PyModuleDef my_extension_module = { PyModuleDef_HEAD_INIT, "my_extension", "Описание модуля", -1, my_extension_methods }; PyMODINIT_FUNC PyInit_my_extension(void) { return PyModule_Create(&my_extension_module); } ``` Затем этот C-расширение можно использовать в Python, обеспечивая более эффективное выполнение интенсивных операций. #### Советы по оптимизации производительности Если ваши потоки часто блокируются, например, из-за операций ввода-вывода, это может значительно ухудшить производительность. Вместо блокировки потока, можно использовать неблокирующие операции ввода-вывода или асинхронный код, чтобы избежать простоя потоков. Пример использования неблокирующих операций ввода-вывода: ``` import socket def non_blocking_network_operation(): # Создание неблокирующего сокета sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.setblocking(0) try: # Попытка подключения без блокировки sock.connect(("example.com", 80)) except BlockingIOError: pass # Продолжение выполнения кода без блокировки ``` Для оптимизации производительности можно разбить код на независимые задачи и выполнять их параллельно. Вместо использования потоков Python, которые могут столкнуться с GIL, рассмотрите использование более низкоуровневых механизмов, таких как процессы или асинхронное программирование. Пример использования асинхронного кода с библиотекой `asyncio`: ``` import asyncio async def async_task(): await asyncio.sleep(1) print("Выполнение асинхронной задачи") async def main(): tasks = [async_task() for _ in range(10)] await asyncio.gather(tasks) if __name__ == "__main__": asyncio.run(main()) ``` Асинхронное программирование позволяет эффективно управлять задачами без блокировки потоков. ## Советы по оптимизации производительности 1. Используйте встроенные функции и методы:* В Python существует множество встроенных функций и методов, которые оптимизированы и быстрее, чем ручные аналоги. Например, вместо обхода списка циклом `for`, используйте функции `map()`, `filter()`, `sum()` и другие. ``` numbers = [1, 2, 3, 4, 5] # Плохой способ total = 0 for num in numbers: total += num # Хороший способ total = sum(numbers) ``` 2. Используйте генераторы: Генераторы в Python позволяют лениво генерировать значения и могут сэкономить память и увеличить производительность. ``` # Плохой способ squares = [] for num in range(1, 1000000): squares.append(num 2) # Хороший способ squares = (num 2 for num in range(1, 1000000)) ``` 3. Избегайте избыточных вычислений: Если вы выполняете одни и те же вычисления несколько раз, сохраните результат и используйте его повторно. ``` # Плохой способ result1 = complex_computation(data) result2 = complex_computation(data) # Хороший способ result = complex_computation(data) result1 = result result2 = result ``` 4. Используйте set вместо списка для быстрого поиска: Если вам часто приходится искать элементы в коллекции, используйте множества (set), которые имеют гораздо более быстрое время доступа, чем списки. ``` # Плохой способ items = [1, 2, 3, 4, 5] if 3 in items: print("Найден!") # Хороший способ items = {1, 2, 3, 4, 5} if 3 in items: print("Найден!") ``` 5. Оптимизируйте работу с файлами: При работе с файлами используйте контекстные менеджеры для автоматического закрытия файлов. Кроме того, читайте и записывайте данные порциями, чтобы уменьшить использование памяти. ``` # Плохой способ file = open("data.txt", "r") data = file.read() file.close() # Хороший способ with open("data.txt", "r") as file: data = file.read(1024) ``` 6. Используйте функции из стандартной библиотеки: Python имеет множество функций и модулей в стандартной библиотеке для обработки данных, парсинга XML, работы с JSON и других задач. Вместо написания собственных решений, используйте уже существующие. ``` # Плохой способ import my_custom_parser data = my_custom_parser.parse_xml(xml_data) # Хороший способ import xml.etree.ElementTree as ET root = ET.fromstring(xml_data) ``` 7. Избегайте многократных операций I/O: Операции ввода-вывода, такие как чтение и запись файлов или сетевые запросы, могут быть затратными. При выполнении множества таких операций объединяйте их и выполняйте одним запросом. ``` # Плохой способ for url in urls: response = requests.get(url) process_data(response.text) # Хороший способ responses = [requests.get(url) for url in urls] for response in responses: process_data(response.text) ``` 8. Используйте алгоритмы с линейным временем выполнения: При выборе алгоритмов старайтесь использовать те, которые имеют линейное время выполнения (O(n)), чтобы избежать долгих операций. ``` # Плохой способ def find_max(numbers): max_num = numbers[0] for num in numbers: if num > max_num: max_num = num return max_num # Хороший способ max_num = max(numbers) ``` 9. Используйте профилирование: Профилирование вашего кода помогает выявить места, где тратится больше всего времени, и сосредоточить усилия на оптимизации важных частей. Пример использования модуля `cProfile`: ``` import cProfile def my_function(): # Код для профилирования cProfile.run("my_function()") ``` 10. Избегайте использования глобальных переменных: Глобальные переменные могут сделать код менее читаемым и управляемым. Вместо них используйте передачу параметров в функции и возвращение результатов. ``` # Плохой способ count = 0 def increment_count(): global count count += 1 # Хороший способ def increment_count(count): return count + 1 count = increment_count(count) ``` ## Заключение GIL - это особенность интерпретатора Python, которая ограничивает одновременное выполнение нескольких потоков Python-кода в одном процессе. Это ограничение может стать вызовом для разработчиков, особенно тех, кто сталкивается с многозадачностью и параллельной обработкой данных. *** Если вы уже уверенно пишете на Python и хотите выйти за рамки «скриптов для себя», курс [Python Developer. Professional](https://otus.pw/5mJE/) даст системное понимание промышленной разработки: от асинхронности и метапрограммирования до веб‑фреймворков и анализа данных. Живые вебинары, практика и код‑ревью от специалистов помогут прокачаться до уровня middle+ или senior. А в [каталоге курсов](https://otus.pw/htbgi/) вы найдете еще больше обучающих программ по разным ЯП и уровням подготовки.
Shard	134 (laksa)
Root Hash	14843476518697139734
Unparsed URL	com,habr!/ru/companies/otus/articles/769448/ s443