Python 3. Многопоточность

Как заставить Python делать несколько дел одновременно и почему этому мешает GIL. Разбираем модуль threading, потоки, таймеры, блокировки Lock и RLock, пул потоков и сборку Python 3.14 без GIL.

Введение

Когда мы запускаем обычную (однопоточную) программу, создаётся один процесс, внутри которого работает один поток. Именно поток выполняет полезную работу на процессоре. В одном процессе может работать сразу несколько потоков, и они могут выполняться на разных ядрах процессора одновременно. Включив в Python коде многопоточность, мы можем распараллелить некоторые задачи, но не все из-за ограничений GIL.

В Python 3.14 появилась официальная поддержка сборки интерпретатора без GIL. О ней мы поговорим в конце статьи, а сначала разберёмся, как всё работает в обычной сборке. Статья написана для Python 3.14 и стандартного интерпретатора CPython.

Ограничения GIL

Python 3 позволяет писать многопоточные приложения с помощью модуля threading. Но потоки подвержены блокировкам GIL (Global Interpreter Lock, глобальная блокировка интерпретатора). GIL позволяет работать с интерпретатором только одному потоку в один момент времени.

Представьте что у вас запущено 2 потока одного приложения. Первый поток начинает работать с ЦПУ и GIL блокирует интерпретатор для второго потока. Второй поток хочет поработать с ЦПУ, но GIL его туда не пускает. Через промежуток времени первый поток ставит свою работу на паузу и GIL разрешает поработать второму потоку.

Так как такие промежутки времени очень малы (по умолчанию 5 миллисекунд, посмотреть значение можно через sys.getswitchinterval()), то мы думаем что потоки работают параллельно. Но на самом деле, они работают по очереди.

И даже, если потоки работают на разных ядрах процессора, то всё равно из-за GIL они работают по очереди.

Но даже в этом случае иногда применяют многопоточность в коде Python 3, например в одном потоке работает основная программа, а во втором проверяется её лицензионный ключ. Нам не важно что эти потоки будут работать по очереди. Мы даже не заметим переключения между потоками.

Потоки в разных процессах могут работать параллельно на разных ядрах процессора, потому что для каждого процесса создаётся свой GIL. Но процессы потребляют больше ресурсов. О многопроцессорном программировании я напишу отдельную статью.

Что GIL не блокирует

Настоящая многопоточность в Python 3 всё же присутствует. Потоки могут обращаться не только к центральному процессору, но и к подсистеме ввода вывода (работа с файлами и сетью, например http-запросы). Пока поток ждёт ответ от диска или сервера, он отпускает GIL и другие потоки спокойно работают. Также GIL отпускают многие расширения, написанные на C. Именно в этих случаях потоки действительно работают параллельно.

Но есть важный момент: GIL защищает только внутренности самого интерпретатора, а не нашу логику. Даже простая операция value += 1 состоит из нескольких шагов (прочитать значение, прибавить единицу, записать результат), и интерпретатор может переключиться на другой поток между этими шагами. Поэтому, когда несколько потоков работают с одним объектом, нам придётся самим управлять блокировками. Ниже мы это разберём на примере.

Дополнительные потоки

Для создания дополнительных потоков используется модуль threading. А сам поток создаётся с помощью класса Thread. Для демонстрации создания дополнительных потоков напишем демо-программу. Здесь я буду писать код частями, а ниже покажу как этот код отработает.

Начнем мы с импорта необходимых модулей. Из модуля time нам понадобятся функции sleep (позволяет программе уснуть на указанное время) и time (для получения текущего времени). А из модуля threading мы возьмём класс Thread (для создания потоков).

from time import sleep, time
from threading import Thread

Напишем функцию, которая будет выводить информацию о том что она запустилась, ждать указанное число секунд и писать что она остановилась.

def my_sleep(sec, name):
    print("Запустился", name, "ждём", sec, "сек")
    sleep(sec)
    print("Остановился", name)

Создаём новый объект класса Thread (то есть новый поток). Ему нужно передать в параметр target функцию, которую мы хотим запустить в дополнительном потоке. А в параметре args — передать кортеж аргументов функции.

t1 = Thread(target=my_sleep, args=(10, 'Поток t1'))

Дальше запомним в переменной a1 текущее время и запустим наш поток с помощью метода start().

a1 = time()
t1.start()

Теперь выполним функцию в основном потоке программы:

my_sleep(5, 'Основной поток программы')

В переменной a2 запомним текущее время и узнаем сколько времени работала программа. Затем выведем этот результат:

a2 = time()
res = round(a2 - a1)
print("Работа основной программы завершена за", res, "сек")

Результат выполнения нашей программы:

Запустился Поток t1 ждём 10 сек
Запустился Основной поток программы ждём 5 сек
Остановился Основной поток программы
Работа основной программы завершена за 5 сек
Остановился Поток t1

В итоге у нас запускается функция в дополнительном потоке, она должна ждать 10 секунд. И пока она ждёт 10 секунд запускается функция в основном потоке программы. Функция из основного потока ждёт 5 секунд (а в это время, в дополнительном потоке, функция ждёт 10 секунд). Через 5 секунд завершается работа функции из основного потока (мы видим об этом сообщение). Дальше завершается работа основной программы, но через 10 секунд мы видим что функция в дополнительном потоке выполнила свою работу. То есть реальное время работы программы 10 секунд, вместо 15.

Обратите внимание, что потоки стартуют почти одновременно, поэтому порядок первых двух строк может отличаться от запуска к запуску.

Потоки демоны

Потоки можно создавать как демоны. Такие потоки будут завершаться сразу как завершится основной поток программы.

Для создания такого потока нужно добавить опцию daemon=True при создании потока:

t1 = Thread(target=my_sleep, args=(10, 'Поток t1'), daemon=True)

Изменим предыдущую программу и выполним её:

Запустился Поток t1 ждём 10 сек
Запустился Основной поток программы ждём 5 сек
Остановился Основной поток программы
Работа основной программы завершена за 5 сек

Здесь дополнительный поток не успел доработать и был убит пока спал. Поэтому демонов стоит использовать только для фоновых задач, которые не страшно оборвать на полуслове. Если поток пишет в файл или в базу, лучше так не делать.

Ожидание завершения потока

Еще мы можем указать что нужно дожидаться выполнения дополнительного потока и только потом выполнять код основного потока, делается это с помощью метода join(), который нужно вызвать в том месте программы, где мы хотим дождаться выполнения.

Например, если мы запустим поток (в этом примере он снова обычный, не демон) и сразу же скажем ожидать его выполнения:

t1.start() # эта строчка уже была, после неё добавим join()
t1.join()

То код отработает так:

Запустился Поток t1 ждём 10 сек
Остановился Поток t1
Запустился Основной поток программы ждём 5 сек
Остановился Основной поток программы
Работа основной программы завершена за 15 сек

Или можем поместить метод join() после запуска функции из основного потока (здесь поток t1 снова запущен как демон):

my_sleep(5, 'Основной поток программы') # эта строчка уже была, после неё добавим join()
t1.join()

Выполнение программы изменится:

Запустился Поток t1 ждём 10 сек
Запустился Основной поток программы ждём 5 сек
Остановился Основной поток программы
Остановился Поток t1
Работа основной программы завершена за 10 сек

Хоть поток запущен как демон и должен был умереть вместе с основным потоком, но мы его подождали с помощью join().

В метод join() можно передать время ожидания в секундах, например t1.join(3). Тогда основной поток подождёт не дольше 3 секунд и пойдёт дальше, даже если дополнительный поток ещё не закончил. Узнать, работает ли поток до сих пор, можно с помощью метода is_alive().

Таймеры

Таймер это объект, который запускает дополнительный поток, но с отсрочкой по времени. Для демонстрации таймера можно использовать предыдущий пример кода. Но будем создавать не поток, а таймер.

Для этого вместо импорта Thread, импортируем Timer. И создадим объект класса Timer. А запускается таймер также как и Thread, с помощью метода start().

Вот переделанный код программы:

from time import sleep, time
from threading import Timer

def my_sleep(sec, name):
    print("Запустился", name, "ждём", sec, "сек")
    sleep(sec)
    print("Остановился", name)

t1 = Timer(2, my_sleep, args=(10, 'Поток t1'))

a1 = time()
t1.start()

my_sleep(5, 'Основной поток программы')
t1.join()

a2 = time()
res = round(a2 - a1)
print("Работа основной программы завершена за", res, "сек")

Создавая объект класса Timer ему нужно указать задержку (в моём примере 2 секунды), и функцию вместе с параметрами.

Результат выполнения данной программы:

Запустился Основной поток программы ждём 5 сек
Запустился Поток t1 ждём 10 сек
Остановился Основной поток программы
Остановился Поток t1
Работа основной программы завершена за 12 сек

То есть таймер, это как поток, но запускается через указанный промежуток времени. Пока таймер не сработал, его можно отменить методом cancel().

Блокировки

До сих пор мы работали с функцией sleep(). Пока поток спит, он отпускает GIL, поэтому ждать потоки могут параллельно. А так как при ожидании мы не меняем никакие общие объекты, то и думать о блокировках нам не приходилось.

Но потоки работают в одной области памяти и могут обращаться к одним и тем же переменным. И если два потока одновременно читают и меняют одну переменную, то получается состояние гонки (race condition): результат зависит от того, в каком порядке потоки успели что-то сделать. GIL нас от этого не спасает, потому что он следит только за внутренностями интерпретатора, а не за нашей логикой. Поэтому нам самим нужно думать о блокировке общего объекта.

Чтобы показать проблему отсутствия блокировок, напишем код. Для начала импортируем необходимые модули:

Код:

from time import sleep
from threading import Thread

Установим начальное значение для переменной value:

value = 0

Напишем функцию которая будет менять значение глобальной переменной (value). Пока значение переменной меньше 10, увеличиваем это значение на 1, ждём 1 секунду и выводим значение переменной.

def inc_value():
    global value
    while value < 10:
        value += 1
        sleep(1)
        print(value)

Создадим два потока и запустим их:

t1 = Thread(target=inc_value)
t2 = Thread(target=inc_value)
t1.start()
t2.start()

Результат работы этой программы:

2
3
4
5
6
7
8
9
10
10

Результат получился странным. Единицу мы так и не увидели, а десятка выведена дважды. Это происходит потому что первый поток меняет 0 на 1, а второй поток почти сразу меняет 1 на 2. Затем первый поток просыпается и выводит 2. И так в цикле до 10: каждый поток выводит не то значение, которое записал сам, а то, которое лежит в переменной к моменту вывода. При другом порядке переключения потоков результат может отличаться от запуска к запуску, в этом и проблема гонки.

Чтобы потоки не мешали друг другу, используют блокировки. Пока один поток держит блокировку, другой ждёт в очереди.

Lock и RLock

В модуле threading есть два вида блокировок:

  • Lock — простая блокировка. Её захватывают методом acquire() и освобождают методом release(). Освободить блокировку может любой поток, даже не тот, который её захватил. Если поток попытается захватить свою же блокировку второй раз, то он заблокирует сам себя и программа зависнет.
  • RLock (реентерабельная блокировка) — позволяет одному и тому же потоку захватывать блокировку несколько раз подряд. Освобождать её нужно столько же раз, и делать это должен тот поток, который её захватил.

Покажем разницу на примере. Чтобы программа не зависла, во втором захвате укажем таймаут в 1 секунду. Метод acquire() вернёт True, если блокировку удалось захватить, и False, если время ожидания вышло.

from threading import Lock, RLock

lock = Lock()
lock.acquire()
print("Lock, второй захват:", lock.acquire(timeout=1))

rlock = RLock()
rlock.acquire()
print("RLock, второй захват:", rlock.acquire(timeout=1))

Исполнение:

Lock, второй захват: False
RLock, второй захват: True

В примерах ниже будем использовать простой Lock, потому что один поток не захватывает блокировку дважды. Вместо парных вызовов acquire() и release() лучше использовать оператор with. Он сам захватит блокировку при входе в блок и обязательно освободит её при выходе, даже если внутри блока возникнет ошибка.

Блокировка в действии

Полный код программы с блокировкой:

from time import sleep
from threading import Thread, Lock

value = 0

lock = Lock()

def inc_value():
    global value
    while value < 10:
        with lock:
            value += 1
            sleep(1)
            print(value)

t1 = Thread(target=inc_value)
t2 = Thread(target=inc_value)
t1.start()
t2.start()

То есть мы дополнительно импортировали класс Lock, создали объект lock этого класса. И внутри цикла меняем переменную только внутри блока with lock.

Результат работы этой программы:

1
2
3
4
5
6
7
8
9
10
11

Почему мы дошли до 11? Да потому что оба потока зашли в цикл, когда значение переменной было 9. Дальше первый поток захватил блокировку, увеличил число до 10 и снял блокировку. Второй поток уже находился в цикле и, не выполняя повторную проверку (value < 10), захватил блокировку, увеличил число до 11 и снял блокировку.

Мы защитили изменение переменной, но проверка value < 10 осталась снаружи блокировки. Правило такое: проверку и действие, которое от неё зависит, нужно выполнять под одной и той же блокировкой. Исправим код:

from time import sleep
from threading import Thread, Lock

value = 0

lock = Lock()

def inc_value():
    global value
    while True:
        with lock:
            if value >= 10:
                break
            value += 1
            sleep(1)
            print(value)

t1 = Thread(target=inc_value)
t2 = Thread(target=inc_value)
t1.start()
t2.start()

Теперь проверка выполняется внутри блокировки, и пока один поток проверяет и меняет значение, второй ждёт.

Результат работы этой программы:

1
2
3
4
5
6
7
8
9
10

Обратите внимание, что здесь я вызываю sleep() прямо под блокировкой, но только чтобы наглядно показать работу. В реальных программах под блокировкой стоит держать как можно меньше кода, иначе остальные потоки будут долго ждать.

Пул потоков

Создавать потоки вручную удобно для простых задач. Но если нужно выполнить много однотипных задач, то удобнее использовать пул потоков. Для этого есть класс ThreadPoolExecutor из модуля concurrent.futures.

Пул создаёт заданное число потоков (параметр max_workers) и раздаёт им задачи. Когда поток освобождается, он берёт следующую задачу из очереди. А метод map() запускает функцию для каждого значения из списка и возвращает результаты в том же порядке, в каком мы передали задачи. Оператор with дождётся завершения всех задач и сам остановит потоки.

from concurrent.futures import ThreadPoolExecutor
from time import sleep, time

def work(sec):
    sleep(sec)
    return f"ждали {sec} сек"

a1 = time()
with ThreadPoolExecutor(max_workers=3) as pool:
    for result in pool.map(work, [3, 2, 1, 2]):
        print(result)

res = round(time() - a1)
print("Всё выполнено за", res, "сек")

Исполнение:

ждали 3 сек
ждали 2 сек
ждали 1 сек
ждали 2 сек
Всё выполнено за 3 сек

Задач у нас 4, а потоков только 3. Первые три задачи стартуют сразу. Через секунду освобождается поток, который ждал 1 секунду, и он берёт четвёртую задачу. Она выполняется 2 секунды, поэтому общее время получилось 3 секунды, а не 8.

Если нужно запускать задачи по одной и получать результат позже, используйте метод submit(). Он возвращает объект Future, у которого есть метод result().

Python без GIL

Начиная с Python 3.13 появилась экспериментальная сборка без GIL, которую называют free-threaded. В Python 3.14 она получила официальную поддержку (PEP 779) и перестала быть экспериментальной. Но по умолчанию вы всё равно получите обычную сборку с GIL. Сборка без GIL ставится отдельно, и запускается она командой python3.14t. Получить её можно, например, через uv:

uv python install 3.14t

Также free-threaded сборку можно выбрать как дополнительный компонент в официальных установщиках для Windows и macOS.

Проверить, включён ли GIL в текущем интерпретаторе, можно функцией sys._is_gil_enabled(). Покажем разницу на примере с вычислениями. Каждая задача просто считает в цикле, то есть полностью нагружает процессор. Сначала выполним 4 задачи подряд в одном потоке, а затем запустим 4 потока.

Код:

import sys
from threading import Thread
from time import perf_counter

N = 20_000_000

def count(n):
    while n > 0:
        n -= 1

print("GIL включён:", sys._is_gil_enabled())

start = perf_counter()
for _ in range(4):
    count(N)
print("Один поток, 4 задачи подряд:", round(perf_counter() - start, 1), "сек")

start = perf_counter()
threads = [Thread(target=count, args=(N,)) for _ in range(4)]
for t in threads:
    t.start()
for t in threads:
    t.join()
print("Четыре потока:", round(perf_counter() - start, 1), "сек")

Результат на обычной сборке (время зависит от вашего процессора):

Исполнение:

GIL включён: True
Один поток, 4 задачи подряд: 2.8 сек
Четыре потока: 3.2 сек

Видим, что четыре потока не ускорили работу, а даже немного замедлили её, потому что из-за GIL они работали по очереди и тратили время на переключения. На сборке python3.14t этот же код выведет GIL включён: False, а потоки будут выполняться на разных ядрах одновременно. Поэтому четыре потока отработают заметно быстрее, чем один поток (насколько именно, зависит от числа ядер).

Но у сборки без GIL есть и минусы:

  • Однопоточные программы работают чуть медленнее, чем на обычной сборке.
  • Не все расширения на C готовы работать без GIL. Если вы импортируете такое расширение, интерпретатор может включить GIL обратно. Управлять этим можно переменной окружения: PYTHON_GIL=0 отключает GIL, а PYTHON_GIL=1 включает.
  • Состояния гонки без GIL проявляются намного чаще. Поэтому блокировки, о которых мы говорили выше, в таком коде становятся ещё важнее.

Если же вам нужна настоящая параллельность без free-threaded сборки, то остаются процессы (модуль multiprocessing и класс ProcessPoolExecutor). А в Python 3.14 появился ещё и InterpreterPoolExecutor, который запускает код в отдельных интерпретаторах внутри одного процесса, и у каждого из них свой GIL.

Итог

Мы познакомились с многопоточным программированием. Поняли что в некоторых случаях потоки блокируются GIL, а в некоторых не блокируются. А иногда нам нужно самим следить за блокировками, потому что GIL не защищает нашу логику.

Узнали про классы Thread, Timer, Lock и RLock модуля threading. Научились создавать объекты этих классов и использовать блокировки. Познакомились с пулом потоков ThreadPoolExecutor и узнали, что в Python 3.14 можно запускать интерпретатор без GIL.


Если понравилась статья, подпишись на мой канал в VK или Telegram .