Изучение возможностей и проблем Python без GIL
Делиться
Python 3.14, один из самых ожидаемых релизов последнего времени, наконец-то вышел. В нём реализовано несколько интересных улучшений, в том числе:
Подинтерпретаторы . Они доступны в Python уже 20 лет, но для их использования приходилось переходить к программированию на языке C. Теперь их можно использовать прямо из самого Python.
T-строки . Шаблонные строки — это новый метод пользовательской обработки строк. Они используют знакомый синтаксис f-строк, но, в отличие от f-строк, возвращают объект, представляющий как статическую, так и интерполированную части строки, а не простую строку.
Компилятор JIT. Это всё ещё экспериментальная функция, и её не следует использовать в производственных системах. Тем не менее, она обещает повышение производительности в определённых сценариях использования.
В Python 3.14 появилось еще множество улучшений, но эта статья не о них и не о тех, о которых мы упомянули выше.
Вместо этого мы обсудим, пожалуй, самую ожидаемую функцию этого релиза: Python со свободным потоком, также известный как Python без GIL. Обратите внимание, что обычная версия Python 3.14 по-прежнему будет работать с включённым GIL, но вы можете скачать (или собрать) отдельную версию со свободным потоком. Я покажу вам, как её скачать и установить, а также на нескольких примерах кода продемонстрирую сравнение времени выполнения обычной версии Python 3.14 и версии без GIL.
Что такое GIL?
Многие из вас знакомы с глобальной блокировкой интерпретатора (Global Interpreter Lock, GIL) в Python. GIL — это мьютекс (механизм блокировки), используемый для синхронизации доступа к ресурсам и гарантирующий в Python, что только один поток выполняет байт-код в каждый момент времени.
С одной стороны, это имеет ряд преимуществ, включая упрощение управления потоками и памятью, предотвращение состояний гонки и интеграцию Python с библиотеками C/C++.
С другой стороны, GIL может подавлять параллелизм. При использовании GIL настоящий параллелизм для задач, привязанных к процессору, на нескольких ядрах процессора в рамках одного процесса Python невозможен.
Почему это важно
Одним словом, «производительность».
Поскольку свободное многопоточное выполнение может одновременно использовать все доступные ядра вашей системы, код часто будет выполняться быстрее. Для специалистов по анализу данных, машинному обучению и инженеров данных это относится не только к вашему коду, но и к коду, который лежит в основе систем, фреймворков и библиотек, на которые вы опираетесь.
Многие задачи машинного обучения и анализа данных требуют значительных ресурсов процессора, особенно при обучении моделей и предварительной обработке данных. Удаление GIL может привести к значительному повышению производительности этих задач, требующих высокой производительности процессора.
Многие популярные библиотеки Python сталкиваются с ограничениями, связанными с необходимостью обхода GIL. Его удаление может привести к:
- Упрощенные и потенциально более эффективные реализации этих библиотек
- Новые возможности оптимизации в существующих библиотеках
- Разработка новых библиотек, которые могут в полной мере использовать преимущества параллельной обработки
Установка версии Python со свободным потоком
Если вы пользователь Linux, единственный способ получить бесплатный многопоточный Python — собрать его самостоятельно. Если вы, как и я, используете Windows (или macOS), вы можете установить его с помощью официальных установщиков с сайта Python. В процессе установки у вас будет возможность настроить установку. Найдите флажок, позволяющий включить двоичные файлы с поддержкой свободного многопоточности. Это установит отдельный интерпретатор, который можно использовать для запуска кода без GIL. Я покажу, как установка работает в 64-битной системе Windows.
Чтобы начать, щелкните следующий URL-адрес:
https://www.python.org/downloads/release/python-3140
И прокрутите страницу вниз, пока не увидите таблицу, которая выглядит примерно так.
Теперь нажмите на ссылку «Установщик Windows (64-разрядная версия)». После загрузки исполняемого файла откройте его и на первом экране установки нажмите на ссылку «Настроить установку» . Обратите внимание, что я также установил флажок «Добавить Python.exe в путь» .
На следующем экране выберите дополнительные компоненты, которые вы хотите добавить в установку, и снова нажмите «Далее» . На этом этапе вы увидите примерно такой экран:
Убедитесь, что установлен флажок «Загрузить свободнопоточные двоичные файлы» . Я также отметил опцию «Установить Python 3.14 для всех пользователей» .
Нажмите кнопку «Установить».
После завершения загрузки в папке установки найдите файл приложения Python с буквой «t» в конце имени. Это версия Python без GIL. Файл приложения, называемый Python, представляет собой обычный исполняемый файл Python. В моём случае версия Python без GIL называлась Python3.14t. Вы можете проверить правильность установки, введя это в командную строку.
C:Usersthoma>python3.14t Сборка Python 3.14.0 со свободной многопоточностью (tags/v3.14.0:ebf955d, 7 октября 2025 г., 10:13:09) [MSC v.1944 64 бит (AMD64)] на win32 Для получения дополнительной информации введите «help», «copyright», «credits» или «license». >>>
Если вы видите это, всё готово. В противном случае проверьте, что путь установки добавлен в переменную среды PATH, и/или перепроверьте шаги установки.
Поскольку мы будем сравнивать среды выполнения Python без GIL с обычными средами выполнения Python, нам также следует проверить, что они установлены правильно.
C:Usersthoma>python Python 3.14.0 (tags/v3.14.0:ebf955d, 7 октября 2025 г., 10:15:03) [MSC v.1944 64 бит (AMD64)] на win32 Введите «help», «copyright», «credits» или «license» для получения дополнительной информации. >>>
GIL против Python без GIL
Пример 1 — Нахождение простых чисел
Введите следующее в файл кода Python, например example1.py
# # example1.py # import threading import time import multiprocessing def is_prime(n): «»»Проверка числа на простоту.»»» if n < 2: return False for i in range(2, int(n**0.5) + 1): if n % i == 0: return False return True def find_primes(start, end): """Найти все простые числа в заданном диапазоне.""" primes = [] for num in range(start, end + 1): if is_prime(num): primes.append(num) return primes def worker(worker_id, start, end): """Функция Worker для поиска простых чисел в указанном диапазоне.""" print(f"Worker {worker_id} starting") primes = find_primes(start, end) print(f"Worker {worker_id} found {len(primes)} primes") def main(): """Основная функция для координации многопоточный поиск простых чисел.""" start_time = time.time() # Получить количество ядер ЦП num_cores = multiprocessing.cpu_count() print(f"Количество ядер ЦП: {num_cores}") # Определить диапазон для поиска простых чисел total_range = 2_000_000 chunk_size = total_range // num_cores threads = [] # Создать и запустить потоки, равные количеству ядер for i in range(num_cores): start = i * chunk_size + 1 end = (i + 1) * chunk_size if i < num_cores - 1 else total_range thread = threading.Thread(target=worker, args=(i, start, end)) threads.append(thread) thread.start() # Дождаться завершения всех потоков for thread in threads: thread.join() # Рассчитать и вывести общее время выполнения end_time = time.time() total_time = end_time - start_time print(f"Все рабочие процессы завершены за {total_time:.2f} секунд") if __name__ == "__main__": main()
Функция is_prime проверяет, является ли заданное число простым.
Функция find_primes находит все простые числа в заданном диапазоне.
Рабочая функция является целью каждого потока и находит простые числа в определенном диапазоне.
Основная функция координирует многопоточный поиск простых чисел:
- Он делит общий диапазон на количество фрагментов, соответствующее количеству ядер в системе (в моем случае 32).
- Создает и запускает 32 потока, каждый из которых просматривает небольшую часть диапазона.
- Ожидает завершения всех потоков.
- Рассчитывает и выводит общее время выполнения.
Результаты хронометража
Давайте посмотрим, сколько времени займет выполнение с использованием обычного Python.
C:Usersthomaprojectspython-gil>python example1.py Количество ядер ЦП: 32 Рабочий процесс 0 запускается Рабочий процесс 1 запускается Рабочий процесс 0 найдено 6275 простых чисел Рабочий процесс 2 запускается Рабочий процесс 3 запускается Рабочий процесс 1 найдено 5459 простых чисел Рабочий процесс 4 запускается Рабочий процесс 2 найдено 5230 простых чисел Рабочий процесс 3 найдено 5080 простых чисел … … Рабочий процесс 27 найдено 4346 простых чисел Рабочий процесс 15 запускается Рабочий процесс 22 найдено 4439 простых чисел Рабочий процесс 30 найдено 4338 простых чисел Рабочий процесс 28 найдено 4338 простых чисел Рабочий процесс 31 найдено 4304 простых числа Рабочий процесс 11 найдено 4612 простых чисел Рабочий процесс 15 найдено 4492 простых числа Рабочий процесс 25 найдено 4346 простых чисел Рабочий процесс 26 найдено 4377 простых чисел Все рабочие процессы завершены за 3,70 секунды
Теперь с версией без GIL:
C:Usersthomaprojectspython-gil>python3.14t example1.py Количество ядер ЦП: 32 Рабочий процесс 0 запускается Рабочий процесс 1 запускается Рабочий процесс 2 запускается Рабочий процесс 3 запускается … … Рабочий процесс 19 нашел 4430 простых чисел Рабочий процесс 29 нашел 4345 простых чисел Рабочий процесс 30 нашел 4338 простых чисел Рабочий процесс 18 нашел 4520 простых чисел Рабочий процесс 26 нашел 4377 простых чисел Рабочий процесс 27 нашел 4346 простых чисел Рабочий процесс 22 нашел 4439 простых чисел Рабочий процесс 23 нашел 4403 простых числа Рабочий процесс 31 нашел 4304 простых числа Рабочий процесс 28 нашел 4338 простых чисел Все рабочие процессы завершены за 0,35 секунды
Впечатляющее начало. Время работы увеличилось в 10 раз.
Пример 2 — Одновременное чтение нескольких файлов.
В этом примере мы будем использовать модель concurrent.futures для одновременного чтения нескольких текстовых файлов, а также подсчета и отображения количества строк и слов в каждом из них.
Прежде чем мы это сделаем, нам нужно обработать несколько файлов данных. Для этого можно использовать следующий код на Python. Он генерирует по 1 000 000 случайных бессмысленных предложений и записывает их в 20 отдельных текстовых файлов: sentences_01.txt, sentences_02.txt и т. д.
import os import random import time # — Конфигурация — NUM_FILES = 20 SENTENCES_PER_FILE = 1_000_000 WORDS_PER_SENTENCE_MIN = 8 WORDS_PER_SENTENCE_MAX = 20 OUTPUT_DIR = «fake_sentences» # Каталог для сохранения файлов # — 1. Сгенерируйте набор слов — # Используйте небольшой список распространенных слов для разнообразия. # В реальном сценарии вы можете загрузить гораздо больший словарь. word_pool = [ «the», «be», «to», «of», «and», «a», «in», «that», «have», «i», «it», «for», «not», «on», «with», «he», «as», «you», «do», «at», «this», «but», «his», «by», «from», «they», «we», «say», «her», «she», «or», «an», «will», «my», «one», «all», «would», «there», «there», «they», «what», «so», «up», «out», «if», «o», «who», «get», «which», «go», «me», «when», «make», «can», «like», «time», «no», «just», «him», «know», «take», «people», «into», «year», «you», «good», «some», «could», «them», «see», «other», » than», «then», «now», «look», «только», «прийти», «его», «над», «думать», «также», «назад», «после», «использовать», «два», «как», «наш», «работа», «первый», «хорошо», «путь», «даже», «новый», «хотеть», «потому что», «любой», «эти», «дать», «день», «большинство», «нас», «яблоко», «банан», «машина», «дом», «компьютер», «телефон», «кофе», «вода», «небо», «дерево», «счастливый», «грустный», «большой», «маленький», «быстрый», «медленный», «красный», «синий», «зеленый», «желтый» ] # Убедитесь, что выходной каталог существует os.makedirs(OUTPUT_DIR, exist_ok=True) print(f»Начинается генерация {NUM_FILES} файлов, каждый из которых содержит {SENTENCES_PER_FILE:,} предложений.») print(f»Всего генерируемых предложений: {NUM_FILES * SENTENCES_PER_FILE:,}») start_time = time.time() for file_idx in range(NUM_FILES): file_name = os.path.join(OUTPUT_DIR, f»sentences_{file_idx + 1:02d}.txt») print(f»nСоздание и запись в {file_name}…») file_start_time = time.time() with open(file_name, 'w', encoding='utf-8') as f: for sentence_idx in range(SENTENCES_PER_FILE): # 2. Построение фиктивных предложений num_words = random.randint(WORDS_PER_SENTENCE_MIN, WORDS_PER_SENTENCE_MAX) # Случайным образом выбрать слова sentence_words = random.choices(word_pool, k=num_words) # Объединить слова, начать с заглавной буквы, добавить точку sentence = » «.join(sentence_words).capitalize() + «.n» # 3. Запись в файл f.write(sentence) # Необязательно: вывод хода выполнения для больших файлов if (sentence_idx + 1) % 100_000 == 0: print(f» {sentence_idx + 1:,} предложений записано в {file_name}…») file_end_time = time.time() print(f»Завершено {file_name} через {file_end_time — file_start_time:.2f} секунд.») total_end_time = time.time() print(f»nВсе файлы созданы! Общее время: {total_end_time — start_time:.2f} секунд.») print(f»Файлы сохранены в каталоге '{OUTPUT_DIR}'.»)
Вот как выглядит начало sentences_01.txt,
Новый, затем кофе, у кого банан, его, их, как год, также там, я беру. Телефон идет или с кем-то, кто один в телефоне там на воле. С или как мой, нам, ему, наш печальный, как быть, взять хорошо, путь с зеленым маленьким этим. Не из двух, которые так хорошо, медленно, новый. Смотрите, посмотрите, вода, я делаю новую работу, новую, в, на котором быть дерево, как бы грустно. По быть, затем работать, в мы, они, небо, медленно, что все, кто также. Приходите, использовать, чтобы вернуться, как после, в обратно, он дает там красный также сначала увидеть. Только приходят так хорошо большой, в какой-то мой во время, его банан для прийти или какая работа. Как только кофе выходит, путь к просто дереву, когда там для работы компьютера люди небо этим в. Чем сказать на нем, как она, Apple, компьютер, нас, хорошо, тогда небо, небо, день, другие после не. Вы счастливы, знаете, медленно, для, счастливый, тогда также с яблоком, думаю, посмотрите, идите, когда. Как кто, чем два, мы любой может банан в. Кофе вверх из этих зеленых маленьких, это нам дать, мы. Эти мы делаем, потому что, как знаете, мне, компьютер банан обратно телефон путь время в чем.
Хорошо, теперь мы можем замерить время чтения этих файлов. Вот код, который мы будем тестировать. Он просто считывает каждый файл, подсчитывает количество строк и слов и выводит результаты.
import concurrent.futures import os import time def process_file(filename): «»» Обрабатывает один файл, возвращая количество строк и слов. «»» try: with open(filename, 'r') as file: content = file.read() lines = content.split('n') words = content.split() return filename, len(lines), len(words) except Exception as e: return filename, -1, -1 # Возвращает -1 для обоих значений, если возникла ошибка def main(): start_time = time.time() # Запускает таймер # Список для хранения наших файлов files = [f»./data/sentences_{i:02d}.txt» for i in range(1, 21)] # Предполагается 20 файлов с именами file_1.txt to file_20.txt # Использует ThreadPoolExecutor для параллельной обработки файлов с concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor: # Отправить все задачи по обработке файлов future_to_file = {executor.submit(process_file, file): file for file in files} # Обработать результаты по мере их завершения for future in concurrent.futures.as_completed(future_to_file): file = future_to_file[future] try: filename, line_count, word_count = future.result() if line_count == -1: print(f»Ошибка при обработке {filename}») else: print(f»{filename}: {line_count} строк, {word_count} слов») except Exception as exc: print(f'{file} сгенерировал исключение: {exc}') end_time = time.time() # Завершить таймер print(f»Общее время выполнения: {end_time — start_time:.2f} секунд») if __name__ == «__main__»: main()
Результаты хронометража
Сначала обычный Python.
C:Usersthomaprojectspython-gil>python example2.py ./data/sentences_09.txt: 1000001 строк, 14003319 слов ./data/sentences_01.txt: 1000001 строк, 13999989 слов ./data/sentences_05.txt: 1000001 строк, 13998447 слов ./data/sentences_07.txt: 1000001 строк, 14004961 слов ./data/sentences_02.txt: 1000001 строк, 14009745 слов ./data/sentences_10.txt: 1000001 строк, 14000166 слов ./data/sentences_06.txt: 1000001 строк, 13995223 слов ./data/sentences_04.txt: 1000001 строк, 14005683 слов ./data/sentences_03.txt: 1000001 строк, 14004290 слов ./data/sentences_12.txt: 1000001 строк, 13997193 слов ./data/sentences_08.txt: 1000001 строк, 13995506 слов ./data/sentences_15.txt: 1000001 строк, 13998555 слов ./data/sentences_11.txt: 1000001 строка, 14001299 слов ./data/sentences_14.txt: 1000001 строка, 13998347 слов ./data/sentences_13.txt: 1000001 строка, 13998035 слов ./data/sentences_19.txt: 1000001 строка, 13999642 слова ./data/sentences_20.txt: 1000001 строка, 14001696 слов ./data/sentences_17.txt: 1000001 строка, 14000184 слова ./data/sentences_18.txt: 1000001 строк, 13999968 слов ./data/sentences_16.txt: 1000001 строк, 14000771 слов Общее время выполнения: 18,77 секунд
Теперь версия без GIL
C:Usersthomaprojectspython-gil>python3.14t example2.py ./data/sentences_02.txt: 1000001 строк, 14009745 слов ./data/sentences_03.txt: 1000001 строк, 14004290 слов ./data/sentences_08.txt: 1000001 строк, 13995506 слов ./data/sentences_07.txt: 1000001 строк, 14004961 слов ./data/sentences_04.txt: 1000001 строк, 14005683 слов ./data/sentences_05.txt: 1000001 строки, 13998447 слов ./data/sentences_01.txt: 1000001 строка, 13999989 слов ./data/sentences_10.txt: 1000001 строка, 14000166 слов ./data/sentences_06.txt: 1000001 строка, 13995223 слова ./data/sentences_09.txt: 1000001 строка, 14003319 слов ./data/sentences_12.txt: 1000001 строка, 13997193 слова ./data/sentences_11.txt: 1000001 строка, 14001299 слов ./data/sentences_18.txt: 1000001 строк, 13999968 слов ./data/sentences_14.txt: 1000001 строк, 13998347 слов ./data/sentences_13.txt: 1000001 строк, 13998035 слов ./data/sentences_16.txt: 1000001 строк, 14000771 слов ./data/sentences_19.txt: 1000001 строк, 13999642 слов ./data/sentences_15.txt: 1000001 строк, 13998555 слов ./data/sentences_17.txt: 1000001 строка, 14000184 слова ./data/sentences_20.txt: 1000001 строка, 14001696 слов Общее время выполнения: 5,13 секунды
Не такой впечатляющий, как наш первый пример, но все равно очень хороший — улучшение более чем в 3 раза.
Пример 3 — умножение матриц
Для этого мы воспользуемся модулем потоковой обработки . Вот код, который мы запустим.
import threading import time import os def multiply_matrices(A, B, result, start_row, end_row): «»»Умножить подматрицу A и B и сохранить результат в соответствующей подматрице result.»»» for i in range(start_row, end_row): for j in range(len(B[0])): sum_val = 0 for k in range(len(B)): sum_val += A[i][k] * B[k][j] result[i][j] = sum_val def main(): «»»Основная функция для координации многопоточного умножения матриц.»»» start_time = time.time() # Определяем размер матриц size = 1000 A = [[1 for _ in range(size)] for _ in range(size)] B = [[1 for _ in range(size)] for _ in range(size)] result = [[0 for _ in range(size)] for _ in range(size)] # Получаем количество ядер ЦП для определения количества потоков num_threads = os.cpu_count() print(f»Количество ядер ЦП: {num_threads}») chunk_size = size // num_threads threads = [] # Создаём и запускаем потоки for i in range(num_threads): start_row = i * chunk_size end_row = size if i == num_threads — 1 else (i + 1) * chunk_size thread = threading.Thread(target=multiply_matrices, args=(A, B, result, start_row, end_row)) threads.append(thread) thread.start() # Дождёмся завершения всех потоков for thread in threads: thread.join() end_time = time.time() # Просто выведи небольшой уголок для проверки print(«Верхний левый угол 5×5 матрицы результата:») for r_idx in range(5): print(result[r_idx][:5]) print(f»Общее время выполнения (умножение матриц): {end_time — start_time:.2f} секунд») if __name__ == «__main__»: main()
Код выполняет параллельное умножение двух матриц размером 1000×1000, используя несколько ядер процессора. Он делит результирующую матрицу на фрагменты, назначает каждый фрагмент отдельному процессу (равному количеству ядер процессора), и каждый процесс независимо вычисляет назначенную ему часть результата умножения матриц. Затем он дожидается завершения всех процессов и выводит общее время выполнения, демонстрируя, как использовать многопроцессорную обработку для ускорения задач, ограниченных ресурсами процессора.
Результаты хронометража
Обычный Python:
C:Usersthomaprojectspython-gil>python example3.py Количество ядер ЦП: 32 Верхний левый угол 5×5 матрицы результата: [1000, 1000, 1000, 1000, 1000] [1000, 1000, 1000, 1000, 1000] [1000, 1000, 1000, 1000, 1000] [1000, 1000, 1000, 1000, 1000] [1000, 1000, 1000, 1000, 1000] Общее время выполнения (умножение матриц): 43,95 секунды
Python без GIL:
C:Usersthomaprojectspython-gil>python3.14t example3.py Количество ядер ЦП: 32 Верхний левый угол 5×5 матрицы результата: [1000, 1000, 1000, 1000, 1000] [1000, 1000, 1000, 1000, 1000] [1000, 1000, 1000, 1000, 1000] [1000, 1000, 1000, 1000, 1000] [1000, 1000, 1000, 1000, 1000] Общее время выполнения (умножение матриц): 4,56 секунды
И снова мы получаем почти десятикратное улучшение производительности при использовании Python без GIL. Неплохо.
Отсутствие GIL не всегда означает лучше.
Интересно отметить, что в этом последнем тесте я также протестировал многопроцессорную версию кода. Оказалось, что обычный Python был значительно быстрее (на 28%), чем Python без GIL. Я не буду показывать код, только результаты.
Тайминги
Сначала обычный Python (многопроцессорность).
C:Usersthomaprojectspython-gil>python example4.py Количество ядер ЦП: 32 Верхний левый угол 5×5 матрицы результата: [1000, 1000, 1000, 1000] [1000, 1000, 1000, 1000] [1000, 1000, 1000, 1000, 1000] [1000, 1000, 1000, 1000, 1000] [1000, 1000, 1000, 1000, 1000] Общее время выполнения (умножение матриц): 4,49 секунды
Версия без GIL (многопроцессорная)
C:Usersthomaprojectspython-gil>python3.14t example4.py Количество ядер ЦП: 32 Верхний левый угол 5×5 матрицы результата: [1000, 1000, 1000, 1000, 1000] [1000, 1000, 1000, 1000, 1000] [1000, 1000, 1000, 1000, 1000] [1000, 1000, 1000, 1000, 1000] [1000, 1000, 1000, 1000, 1000] Общее время выполнения (умножение матриц): 6,29 секунды
Как всегда в таких ситуациях, важно провести тщательное тестирование.
Имейте в виду, что последние примеры — всего лишь тесты, демонстрирующие разницу между GIL и Python без GIL. Использование внешней библиотеки, например, NumPy, для умножения матриц будет как минимум на порядок быстрее любого из этих вариантов.
Ещё один момент, на который стоит обратить внимание, если вы решите использовать Python с поддержкой свободной многопоточности в своих рабочих нагрузках: не все сторонние библиотеки, которые вам могут понадобиться, совместимы с ним. Список несовместимых библиотек невелик и сокращается с каждой версией, но об этом стоит помнить. Чтобы просмотреть их список, перейдите по ссылке ниже.
https://ft-checker.com
Краткое содержание
В этой статье мы обсуждаем потенциально революционную функцию последней версии Python 3.14: появление опциональной версии с «свободными потоками», которая снимает глобальную блокировку интерпретатора (GIL). GIL — это механизм в стандартном Python, который упрощает управление памятью, гарантируя, что только один поток выполняет байт-код Python одновременно. Хотя мы признаём, что это может быть полезно в некоторых случаях, это препятствует полноценной параллельной обработке ресурсоёмких задач на многоядерных процессорах.
Удаление GIL в свободно-поточной сборке в первую очередь направлено на повышение производительности. Это может быть особенно полезно для специалистов по работе с данными и инженеров машинного обучения, чья работа часто связана с операциями, требовательными к ресурсам процессора, такими как обучение моделей и предварительная обработка данных. Это изменение позволяет коду Python одновременно использовать все доступные ядра процессора в рамках одного процесса, что потенциально может привести к значительному повышению скорости.
Для демонстрации влияния в статье представлено несколько сравнений производительности:
- Нахождение простых чисел: производительность многопоточного скрипта возросла в 10 раз , а время выполнения сократилось с 3,70 секунд в стандартном Python до всего лишь 0,35 секунд в версии без GIL.
- Одновременное чтение нескольких файлов: задача, связанная с вводом-выводом и использующая пул потоков для обработки 20 больших текстовых файлов, была выполнена более чем в 3 раза быстрее , завершившись за 5,13 секунды по сравнению с 18,77 секундами со стандартным интерпретатором.
- Умножение матриц: пользовательский многопоточный код умножения матриц также продемонстрировал почти 10-кратное ускорение : версия без GIL завершилась за 4,56 секунды по сравнению с 43,95 секунды для стандартной версии.
Однако я также объяснил, что версия без GIL не является панацеей для разработки кода на Python. Удивительно, но многопроцессорная версия кода умножения матриц работала быстрее на стандартном Python (4,49 секунды), чем на сборке без GIL (6,29 секунды). Это подчёркивает важность тестирования и бенчмаркинга конкретных приложений, поскольку накладные расходы на управление процессами в версии без GIL иногда могут свести на нет её преимущества.
Я также упомянул о том, что не все сторонние библиотеки Python совместимы с Python без GIL, и дал URL-адрес, по которому можно просмотреть список несовместимых библиотек.
Источник: towardsdatascience.com
