Как GIL обеспечивает безопасность?

GIL (Global Interpreter Lock): Безопасность и механизм

GIL — это мьютекс в интерпретаторе CPython, который защищает доступ к объектам Python. Он гарантирует, что в один момент времени только один поток может выполнять Python байт-код.

Как GIL обеспечивает безопасность?

1. Atomicity байт-кодов

Каждый байт-код CPython выполняется как атомарная операция под GIL. Это значит, что если вы обращаетесь к объекту из одного потока, никакой другой поток не может одновременно модифицировать этот объект.

# Без GIL это был бы race condition
counter = 0

def increment():
    global counter
    for _ in range(1000000):
        counter += 1

import threading
threads = [threading.Thread(target=increment) for _ in range(4)]
for t in threads:
    t.start()
for t in threads:
    t.join()

print(counter)  # С GIL всегда 4000000

2. Reference counting безопасность

Python использует reference counting для управления памятью. Операция Py_INCREF(obj) и Py_DECREF(obj) не атомарна без GIL.

// Без GIL это опасно:
// Thread 1: читает refcount = 2
// Thread 2: уменьшает refcount до 1
// Thread 1: уменьшает refcount до 1 (ОШИБКА! должно быть 0)
// Объект не удаляется, когда должен

Py_DECREF(obj);  // Защищена GIL

3. Целостность структур данных

Делицитные структуры данных (списки, словари) требуют GIL для безопасности:

data = [1, 2, 3, 4, 5]

def modify():
    data.append(6)  # Изменение size и capacity

def read():
    return len(data)  # Чтение size

# GIL гарантирует, что операции не чередуются
# и не получим corrupted list

Механизм работы GIL

Как поток получает GIL:

# Примерный псевдокод интерпретатора
while True:
    # Попытка захватить GIL
    acquire_gil()  # Блокирует если GIL занят
    
    # Выполнить код
    execute_bytecode()
    
    # Проверка каждые N инструкций
    if check_interval_exceeded():
        release_gil()  # Даём шанс другим потокам

Interval checking (исторический подход):

import sys
print(sys.getswitchinterval())  # ~0.005 сек по умолчанию

# Можно изменить (НО это влияет на performance)
sys.setswitchinterval(0.001)  # Чаще переключаемся

Что защищено GIL?

✅ Защищено:

• Встроенные типы (list, dict, set)
• Reference counting
• Модификация объектов
• Вызовы функций C API

❌ НЕ защищено:

• Пользовательские классы (если вы сами не синхронизируете)
• Атомарность нескольких операций

# GIL НЕ защищает это!
class BankAccount:
    def __init__(self, balance):
        self.balance = balance
    
    def transfer(self, amount):
        # Race condition! Есть gap между чтением и записью
        temp = self.balance  # Thread 1 читает 100
        # -> Thread 2 тоже читает 100
        self.balance = temp - amount  # Thread 1: 100 - 50 = 50
        # -> Thread 2: 100 - 30 = 70 (ОШИБКА!)

# Нужен явный Lock
import threading
class SafeBankAccount:
    def __init__(self, balance):
        self.balance = balance
        self.lock = threading.Lock()
    
    def transfer(self, amount):
        with self.lock:  # Явная синхронизация
            temp = self.balance
            self.balance = temp - amount

GIL и многопоточность

import threading
import time

def cpu_bound():
    total = 0
    for i in range(100000000):
        total += i
    return total

def io_bound():
    time.sleep(1)
    return "data"

# I/O операции выигрывают от многопоточности
# (GIL отпускается во время sleep)
start = time.time()
thread1 = threading.Thread(target=io_bound)
thread2 = threading.Thread(target=io_bound)
thread1.start()
thread2.start()
thread1.join()
thread2.join()
print(f"Threading I/O: {time.time() - start:.2f}s")  # ~1.0s

# CPU-bound операции НЕ выигрывают
# (GIL не отпускается часто)
start = time.time()
thread1 = threading.Thread(target=cpu_bound)
thread2 = threading.Thread(target=cpu_bound)
thread1.start()
thread2.start()
thread1.join()
thread2.join()
print(f"Threading CPU: {time.time() - start:.2f}s")  # ~3.0s (медленнее!)

Когда нужна явная синхронизация?

import threading

# 1. Обновление счётчика (несколько операций)
counter = 0
lock = threading.Lock()

def safe_increment():
    global counter
    with lock:
        counter += 1

# 2. Словари/списки извне CPython (numpy, pandas)
import numpy as np
array = np.array([1, 2, 3])
lock = threading.Lock()

def modify_numpy():
    with lock:  # НЕ защищено GIL!
        array[0] += 1

# 3. Работа с файлами
lock = threading.Lock()
def write_file():
    with lock:  # Гарантируем порядок записей
        with open('data.txt', 'a') as f:
            f.write('data\n')

Альтернативы многопоточности

multiprocessing — для CPU-bound:

from multiprocessing import Pool

def cpu_bound():
    total = 0
    for i in range(100000000):
        total += i
    return total

with Pool(processes=4) as pool:
    results = pool.map(cpu_bound, range(4))

asyncio — для I/O-bound:

import asyncio

async def fetch_data():
    await asyncio.sleep(1)
    return "data"

async def main():
    results = await asyncio.gather(
        fetch_data(),
        fetch_data(),
    )

asyncio.run(main())  # ~1s вместо 2s