Введение в

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

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

@ikalnitsky

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

... о работе с несколькими задачами одновременно.

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

Параллелизм

... о выполнении нескольких вычислений одновременно.

• Необходима аппаратная составляющая.
  • многоядерные/многопроцессорные системы
  • SIMD расширения процессора
• Наличие потоков управления не обязательно.

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

Параллелизм

Конкурентность + параллелизм = ?

Потоки

• Всегда исполняются конкурентно, но могут исполняться еще и параллельно, в зависимости от наличия аппаратной составляющей.
• В Python используются настоящие потоки операционной системы.

from threading import Thread

def sqr(x):
    return x * x

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

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.
• (CPython < 3.2) Отпускается каждые N выполненных инструкций байт-кода.
• (CPython >= 3.2) Отпускается каждые 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]))

• Только один поток будет вычислять квадрат принятого числа в единицу времени.
• Общая производительность будет хуже, чем при последовательных вызовах из-за дополнительной работы по созданию и коммуникации потоков. Например, для 10000 чисел медленнее в 135 раз (0.005с vs 0.680с).

Процессы

• Как и потоки, всегда исполняются конкурентно, но могут исполняться еще и параллельно, в зависимости от наличия аппаратной составляющей.
• GIL не ограничивает параллельное выполнение.

import os
os.fork()

from multiprocessing import Process

def sqr(x):
    return x * x

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

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 await send_sqr(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(10000)

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

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

(на 100 клиентах)

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

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

По процессу на каждое ядро!

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

Результат

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

• Конкурентность и Параллелизм являются разными понятиями, хотя и могут быть использованы вместе.
• Потоки не могут исполняться параллельно на уровне интерпретатора, но могут исполняться параллельно когда речь заходит о I/O.
• При большом количестве потоков начинается «Война за GIL», и производительность существенно проседает.
• Тем не менее, это не должно быть причиной отказа от потоков. Потоки являются удобным инструментом для решения разного рода проблем с конкурентостью.

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

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

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

• Rob Pike – Concurrency is not Parallelism
• David Beazley - Understanding the Python GIL
• David Beazley – Python Concurrency From the Ground Up
• Mike Bayer – Asynchronous Python and Databases

Вопросы?

(спасибо за внимание)