Конкурентность и Параллелизм

в Python

Игорь Кальницкий

Конкурентность

• Выполнение задач логически параллельно.
• Каждая задача получает квант времени на исполнение.
• Задача не обязательно выполняется до конца.

Параллелизм

• Выполнение задач физически параллельно.
• Необходима аппаратная составляющая:
  • многоядерные процессоры
  • многопроцессорные системы
  • вычислительные кластера
• Частный случай конкурентности.

2 вычислителя

Потоки

• Могут исполняться параллельно на многоядерных системах.
• На одноядерных системах исполняются конкурентно.
• В Python имеем настоящие потоки операционной системы.

from threading import Thread

def sqr(x):
    return x * x

Thread(target=sqr, args=(42, )).start()

from concurrent.futures import ThreadPoolExecutor

def sqr(x):
    return x * x

with ThreadPoolExecutor(max_workers=3) as executor:
    result = list(executor.map(sqr, [1, 2, 3, 4, 5]))

А как же GIL?

Global Interpreter Lock (GIL)

• Для простоты можно считать мьютексом.
• Ограничивает использование интерпретатора одним потоком.
• Не является частью языка, и существует не во всех реализациях.
• Отпускается и захватывается по I/O.
• Отпускается и захватывается каждые N выполненных инструкций байт-кода.

from concurrent.futures import ThreadPoolExecutor

def sqr(x):
    return x * x

with ThreadPoolExecutor(max_workers=3) as executor:
    result = list(executor.map(sqr, [1, 2, 3, 4, 5]))

Процессы

• (!) Могут исполняться параллельно на многоядерных системах.
• (!) На одноядерных системах исполняются конкурентно.
• GIL не ограничивает параллельное выполнение.

import os
os.fork()

from multiprocessing import Process

def sqr(x):
    return x * x

Process(target=sqr, args=(42, )).start()

from concurrent.futures import ProcessPoolExecutor

def sqr(x):
    return x * x

with ProcessPoolExecutor(max_workers=3) as executor:
    result = list(executor.map(sqr, [1, 2, 3, 4, 5]))

Процессы или Потоки?

Зеленые потоки

• В основе лежат неблокирующие операции по работе с сокетами.
• Выполняются конкуретно и работают в контексте одного реального потока.
• Переключение между потоками происходит только по I/O. Потоки без I/O захватят управление навсегда.
• Представлены в виде библиотек gevent и eventlet.
• Позволяют экономить системные ресурсы.

import eventlet; eventlet.monkey_patch()

from threading import Thread

def sqr(x):
    return x * x

Thread(target=sqr, args=(42, )).start()

Зеленые потоки или Потоки?

asyncio

• В основе лежат неблокирующие операции по работе с сокетами.
• Развивает идею зеленых потоков, и заставляет разработчика проектировать приложение с применением явных асинхронных абстракций.
• Корутины вместо зеленых потоков.
• Переключение между корутинами осуществляется явно при вызове оператора await.
• Требует использование специальных версий драйверов и библиотек.

import asyncio

async def sqr(x):
    return x * x

loop = asyncio.get_event_loop()
result = loop.run_until_complete(sqr(42))

Зеленые потоки или asyncio?

Существует мнение, что асинхронное программирование работает быстрее для I/O приложений за счет отсутствия необходимости переходить в kernel space для переключения между потоками.

Эхо-сервер на Потоках

from socket import *
from threading import Thread

def echo_server(conn):
    while True:
        data = conn.recv(100)
        if not data: break
        conn.send(data)

s = socket(AF_INET, SOCK_STREAM)
s.bind(('127.0.0.1', 5000))
s.listen(1000)

while True:
    conn, addr = s.accept()
    Thread(target=echo_server, args=(conn, )).start()

Эхо-сервер на Корутинах

import asyncio

async def echo_server(reader, writer):
    while True:
        data = await reader.read(100)
        if not data: break
        writer.write(data)

loop = asyncio.get_event_loop()
coro = asyncio.start_server(echo_server, '127.0.0.1', 5000, loop=loop)
server = loop.run_until_complete(coro)

loop.run_forever()

Результат

o_O

Исследование

Python медленный :'(

Зато потоки умеют параллельно исполняться :)

Хм.. А что в реальном мире?

Результат

Что надо усвоить?

• Конкурентность != Параллелизм
• Потоки не могут исполняться параллельно на уровне интерпретатора.
• Для параллельного вычисления - используем процессы.
• Зеленые потоки и Корутины подходят только для I/O приложений.
• Для сетевых приложений с высокой нагрузкой хорошим решением станет комбинация процессов и корутин/зеленых потоков.

Материалы по теме

• David Beazley - Inside the New Python GIL
• David Beazley – Python Concurrency From the Ground Up
• Mike Bayer – Asynchronous Python and Databases

ihor@kalnytskyi.com