Полное руководство параллельного программирования на python куан нгуен скачать

Манифест

1. Учиться нужно асинхронно: в работу нужно брать не огромную тему (например изучить весь Python или теорию баз данных),
   а набирать из разных направлений понемногу маленьких тем / вопросов в проработку: чуть-чуть из Python, чуть-чуть из
   SQL и так далее.
2. Обязательно освоить работу с Git, Debugger и научиться писать простейшие тесты.
3. Заниматься регулярно!
4. Решать (или пытаться решить) в день хотя бы 1 задачку с leetcode или аналогичного сайта.
5. Соблюдать режим труда и отдыха.
6. Не бояться просить помощи во всех доступных источниках, если пришлось столкнуться с проблемой, которую не получается
   решить за вменяемое время.

Избранные статьи на Хабр

• Почему твоя мама ещё не прогает? — Хабр
• Хватит клепать псевдопрограммистов, или «Горшочек — не в IT!» — Хабр
• Генераторы для самых маленьких — Хабр
• Введение в асинхронное программирование на Python — Хабр
• Асинхронный Python: различные формы конкурентности — Хабр
• Типовые ошибки Python-разработчиков на собеседованиях — Хабр
• Как работает память в Python — Хабр
• Рецепт полезного код-ревью от разработчика из Яндекса — Хабр
• Как устроен GIL? — Хабр
• Действительно ли Python GIL уже мёртв? — Хабр

Переводы на Хабр по технологиям

• Pytest — Хабр
• RabbitMQ — Хабр
• Docker — Хабр

Избранные курсы

• Погружение в Python — https://ru.coursera.org/learn/diving-in-python
• SQL — https://www.coursera.org/specializations/learn-sql-basics-data-science
• Postgresql — https://www.udemy.com/course/bestpostgres/
• Advanced Python — https://www.pluralsight.com/courses/advanced-python
• Канал про Python высокого качества — https://www.pluralsight.com/authors/robert-smallshire
• Elasticsearch — https://www.udemy.com/course/elasticsearch-complete-guide/

Избранные книги

• Ч.Петцольд — Код. Тайный язык информатики — базовая книга для понимания того, как работают компьютеры.
• М.Лутц — Изучаем Python (2 тома) — базовые книги по Python
• М.Лутц — Программирование на Python — читать только после базовых томов
• А.Бхаргава — Грокаем алгоритмы — базовая книга по алгоритмам и структурам данных
• А.Швец — Погружение в паттерны проектирования — базовая книга по паттернам для новичков. Читать только после книг по алгоритмам и программированию.
• Л.Ромальо — Python. К вершинам мастерства — читать только после книг по программированию.
• С.Дасгупта, Х.Пападимитриу, У.Вазирани — Алгоритмы — жёсткая книга про алгоритмы, но очень крутая. Читать только после всего остального.
• Python для сетевых инженеров — Документация Python для сетевых инженеров 3.0
• Э.Шоу — Внутреннее устройство CPython
• К. Нгуен — Полное руководство параллельного программирования на Python http://onreader.mdl.ru/MasteringConcurrencyInPython/content/index.html
• Д.Хеллман — Стандартная библиотека Python

Избранные видео

• А. Кузьмин — Память и Python https://www.youtube.com/watch?v=D0vbuIDOV4c

Избранные сайты для решения задач

• https://codeforces.com/
• https://codewars.com/
• https://leetcode.com/

Вопросы, часто встречающиеся на собеседованиях

Python:

1. Что такое интерпретируемый язык? Что такое интерпретатор и как он работает в Python?
2. Что такое статическая и динамическая типизация и в чем это проявляется в Python?
3. Какие типы данных в Python вам известны?
4. Чем кортеж отличается от списка?
5. В каких случаях лучше использовать кортеж, а в каких — список?
6. Как вы объясните человеку, что такое множество?
7. Что такое словари и как они работают?
8. Как работают типы данных хэшмап, связанный список, двусвязный список, массив?
9. Что такое О (о-большое)? Зачем и как используется?
10. Какая сложность вставки, извлечения, поиска элементов в словаре и списке?
11. Что такое функции и зачем они нужны?
12. Какие бывают аргументы у функций?
13. Что такое распаковка коллекций?
14. Что такое исключения? Какие они бывают? Как их использовать?
15. Что такое ООП? На каких концепциях стоит ООП?
16. Объяснить понятие класса и объекта (экземпляра).
17. Что такое инкапсуляция? Накодить пример.
18. Что такое наследование? Накодить пример.
19. Бывает ли в Python множественное наследование? Как ты относишься к этому факту?
20. Если у нескольких классов-родителей есть методы с одинаковыми названиями, то какой из них будет вызван в наследнике?
21. Что такое полиморфизм? Накодить пример.
22. Что такое staticmethod?
23. Чем staticmethod отличается от простой функции?
24. Когда будем использовать staticmethod, а когда простую функцию?
25. Что такое classmethod? В чём его особенности? Когда применяется?
26. Что такое магические методы и за что они отвечают?
27. Что такое конструктор объектов в Python и из чего он состоит и как работает?
28. Почему в методе init есть аргумент self?
29. Что такое приватные и защищенные атрибуты? Как они работают?
30. Можно ли получить доступ к приватным атрибутам в Python?
31. Что такое менеджер контекста, зачем он нужен?
32. Какие способы конкурентного выполнения программ в Python бывают?
33. Что такое GIL и как он работает?
34. В каких случаях GIL не работает?
35. Что такое сборщик мусора и как он работает?
36. Что такое потоки и процессы? Чем отличается поток от процесса?
37. Что такое системный вызов fork?
38. Какие существуют способы синхронизации процессов и потоков?
39. Как передавать информацию из одного процесса в другой?
40. Что такое эффект гонок? Как с ним бороться?
41. Что такое асинхронность?
42. Что такое event loop и как он работает?
43. Сколько потоков и процессов работает во время асинхронного выполнения кода?
44. Для каких задач стоит использовать потоки, для каких — процессы, а для каких — асинхронность?

Git

1. Что это такое и зачем он нужен?
2. Что такое local и remote репозитории?
3. Что такое commit?
4. Что такое ветка?
5. Что такое pull-request / merge-request?
6. Что такое merge?
7. Что такое rebase?
8. Что такое pull?
9. Чем rebase отличается от merge?
10. Что такое конфликты? Почему они возникают и как их разрешать?
11. Уметь пользоваться командами: clone, commit, push, pull, merge, rebase

Docker

1. Что такое контейнеризация? Зачем она нужна?
2. Чем контейнер отличается от виртуальной машины?
3. Что такое образ?
4. Что такое том?
5. Что такое сеть контейнера?
6. Какие виды сетей бывают?
7. Зачем нужен docker-compose?

Базы данных

1. Что такое базы данных и для чего они нужны?
2. Какие типы баз данных бывают?
3. Чем РСУБД отличаются от NoSQL БД?
4. Какие достоинства и недостатки есть у РСУБД и NoSQL?
5. Приведите примеры РСУБД и NoSQL БД.
6. Что такое BASE и ACID?
7. Как понять, какую базу данных нужно использовать в проекте?
8. Что такое индексы? Зачем они нужны? Как они работают?
9. Какие популярные виды индексов существуют?
10. Что такое транзакции? Зачем они нужны?
11. Какие виды изолирования транзакций бывают?
12. Что такое профилирование запросов?

SQL

1. Что такое JOIN’ы и какие они бывают?
2. Что такое оконные функции и как они работают?

Backend

1. Что такое протокол передачи данных?
2. Что такое HTTP? Чем отличается HTTPS?
3. Какие другие протоколы передачи данных, кроме HTTP(S) вы знаете? Как они работают?
4. Что такое API?
5. Что такое REST и RESTfull API?

Тестирование

1. Что такое тестирование и зачем оно нужно?
2. Какие виды тестов вы знаете? Что каждый из видов тестов подразумевает под собой?
3. Какие библиотеки для написания тестов используются?
4. Что такое фикстура в pytest?

Кодинг:

1. Написать пример произвольного менеджера контекста.
2. Реализовать паттерн проектирования синглтон.
3. Реализовать паттерн проектирования декоратор.
4. Решить несколько задач.Уметь оценить алгоритмическую сложность решения.

Задача на временные метки

Есть список событий:

[
            {
                "dt": "2022-02-23 04:35:27.353366",
                "event": "start"
            },
            {
                "dt": "2022-02-23 04:35:34.654153",
                "event": "stop"
            },
            {
                "dt": "2022-02-23 04:38:34.382548",
                "event": "start"
            },
            {
                "dt": "2022-02-23 04:38:39.637583",
                "event": "stop"
            }
]

В этом списке последовательно лежат события типа START и STOP, а также их временные метки. События лежат
последовательно: после START всегда идёт STOP и наоборот. Задача:

1. Написать функцию, которая возвращает количество часов, выпадающее на промежуток соответствующих событий
   START — STOP за указанную дату.
2. Возвращать количество часов за диапазон дат.
3. Возвращать количество часов за текущий день, неделю, месяц, год.

Python Parallel Programming Cookbook — Second Edition

This is the code repository for Python Parallel Programming Cookbook — Second Edition , published by Packt.

Over 70 recipes to solve challenges in multithreading and distributed system with Python 3

What is this book about?

Nowadays, it has become extremely important for programmers to understand the link between the software and the parallel nature of their hardware so that their programs run efficiently on computer architectures. Applications based on parallel programming are fast, robust, and easily scalable.

This book covers the following exciting features:

• Synchronize multiple threads and processes to manage parallel tasks
• Use message passing techniques to establish communication between processes to build parallel applications
• Program your own GPU cards to address complex problems
• Manage computing entities to execute distributed computational task
• Write efficient programs by adopting the event-driven programming model
• Explore cloud technology with Django and Google App Engine
• Apply parallel programming techniques that can lead to performance improvements

If you feel this book is for you, get your copy today!

Instructions and Navigations

All of the code is organized into folders. For example, Chapter02.

The code will look like the following:

class Pdb_test(object):
    def __init__(self, parameter):
    self.counter = parameter

Following is what you need for this book:
The Python Parallel Programming Cookbook is for software developers who are well-versed with Python and want to use parallel programming techniques to write powerful and efficient code. This book will help you master the basics and the advanced of parallel computing.

With the following software and hardware list you can run all code files present in the book (Chapter 01-09).

Software and Hardware List

No	Software required	OS required
1	Python 3.7	Any

We also provide a PDF file that has color images of the screenshots/diagrams used in this book. Click here to download it.

Related products

• Mastering GUI Programming with Python [Packt] [Amazon]

• Expert Python Programming — Third Edition [Packt] [Amazon]

Get to Know the Author

Giancarlo Zaccone
Giancarlo Zaccone has over fifteen years’ experience of managing research projects in the scientific and industrial domains. He is a software and systems engineer at the European Space Agency (ESTEC), where he mainly deals with the cybersecurity of satellite navigation systems.

Giancarlo holds a master’s degree in physics and an advanced master’s degree in scientific computing.

Giancarlo has already authored the following titles, available from Packt: Python Parallel Programming Cookbook (First Edition), Getting Started with TensorFlow, Deep Learning with TensorFlow (First Edition), and Deep Learning with TensorFlow (Second Edition).

Other books by the authors

Python Parallel Programming Cookbook

Suggestions and Feedback

Click here if you have any feedback or suggestions.

Глава 21 Объект процесса

Понимание процесса

• определение: Программа, которая находится в процессе (работает), процесс, выполняемый программой, и состояние. (По сравнению с потоками это большая задача, охватывающая всю программу,На самом деле, процесс выполнения является основным потоком в процессе выполнения), Основной поток фактически представляет этот процесс.
• Процесс генерации процессаПосле выполнения фрагмента программного кода операционная система запрашивает фрагмент пространства памяти для помещения кода и данных в процесс. Программа (код / ​​файл) изначально представляет собой файл, размещенный на жестком диске.При запуске программы прикладная программа отправляет операционной системе инструкции для вызова аппаратного обеспечения для считывания программы с жесткого диска в память. Затем операционная система вызывает ЦП для выполнения программы (прикладная программа запрашивает отправку).
• Основной метод создания процесса: Инициализация системы (запуск, выборка данных программы с жесткого диска), подпроцесс вызова процесса (выборка из памяти или жесткого диска), запрос взаимодействия с пользователем (открытие приложения, выборка данных программы с жесткого диска), инициализация пакетного задания (требуется для подготовки пакетной программы) Ресурсы).
• Различия между различными системными процессами, вызывающими подпроцессы: Система UNIX (Система Linux и система MacOS являются ядром UNIXДочерний процесс непосредственно копирует всю информацию о пространстве памяти родительского процесса в качестве начального состояния программы, и система Windows инициализирует некоторые уникальные данные дочернего процесса в информации о родительском пространстве памяти. Вызовите подпроцесс на основе процесса (откройте pycharm для извлечения данных с жесткого диска, запустите программу py в процессе pycharm для извлечения данных программы из памяти).
• Три состояния запуска процесса: Состояние выполнения (выполняется ЦП), состояние блокировки (в случае ввода-вывода или подготовки ресурса, для завершения ввода-вывода и передачи состояния готовности, если вы хотите восстановить полномочия на выполнение ЦП), состояние готовности (все вещи должны только ЦП, для планирования ЦП на выбор: Запуск процесса переключения в соответствии с«Операция IO, время выполнения, приоритет»Поменяй на запуск или готов).
• нота: Процесс (процесс выполнения программы) контролируется операционной системой (планирование), и параллельное программирование трудно понять, а не кодировать.
  
• Просмотр атрибутов процессаКаждый процесс имеет уникальный PID.Программа, запускаемая несколько раз, состоит из нескольких процессов, регистрируется в нескольких qq нескольких процессах или даже больше, программа может запускать несколько процессов.
• Конкретные команды: Просмотр выполнения process-linux / MacOSps auxКоманда, выполнение окнаtasklistВы можете увидеть информацию обо всех процессах в операционной системе. Добавьте указанное имя программы после этих команд, чтобы просмотреть указанный процесс. Если вы просматриваете фильтр Python для других, реализация Linux / MacOSps aux|grep pythonКоманда, выполнение окнаtasklist |findstr python, Завершение процесса использования под Linux / MacOSkill -9 PIDИспользуется окнамиtaskkill /F /PID PID
• Пример работы с командой процесса: Выполните код в pycharm для создания процесса.После фильтрации процесса, чтобы получить PID процесса, PID каждого выполнения кода различен, но PPID родительского процесса одинаков, потому что PPID — это процесс pycharm. Поскольку интерпретатор Python вызывается pycharm, если интерпретатор вызывается в терминале для выполнения только что написанного Python, PPID родительского процесса изменяется.
  

---

Операционная система

• определение: Операционная система расположена между компьютерным оборудованием и прикладным программным обеспечением и используется для координации, управления и контроля аппаратных и программных ресурсов.управляющая программа。
• Две роли операционной системы1. Инкапсулируйте сложные аппаратные операции в простой интерфейс для использования приложения, такой как open (), socket (). 2. Упорядочите конкуренцию процесса с аппаратным обеспечением, например, Word и Excel выполнили операцию печати одновременно, совместное использование приносит конкуренцию, а конкуренция приносит хаос.

---

История ОС

1. Первое поколение: Вакуумная трубка (легко прожигается) и перфокарта — программист напрямую управляет оборудованием, и только один человек использует его одновременно. В момент объединения в памяти выполняется только одна программа, одна за другой. Серийный режим работы.
2. Второе поколение: Транзистор и система пакетной обработки — модернизация небольшого оборудования, участие VIP или серийный.
3. Третье поколение: Интегральная микросхема и многопрограммное проектирование — для ЦП невозможно достичь параллелизма, но он может позволить ЦПУ переключаться между несколькими процессами для достижения параллелизма (многопрограммная технология), как если бы он делал это одновременно.

• Многоканальная технологияВ случае одноядерного ЦП несколько процессов могут выполняться одновременно. 1. Повторное использование пространства памяти (разделите память на несколько частей и поместите их в программу, чтобы процессор мог переключаться между процессами памяти на высокой скорости.) 2. Повторное использование времени процессора (когда один процесс ожидает переключения на другой процесс) ).
• Эффективность выполнения программы: Сокращение операций ввода-вывода при написании программы (поскольку процесс находится в состоянии блокировки, он будет выделять меньше полномочий на выполнение ЦП, то есть время ЦП), что может занять больше времени работы ЦП и повысить эффективность выполнения программы.
• нота: Последовательное выполнение ожидает, пока другие процессы не имеют ничего общего с блокировкой, потому что последовательная программа занимает процессор, а блокировка здесь не занимает процессор. Каждое состояние имеет различную вероятность назначения полномочий на выполнение ЦП.
• Операционная система с разделением времени: Знаменует новую эру для компьютеров.
• Краткое изложение концепции: Параллелизм — один человек, выполняющий дождь и росу, все выполняет четыре работы, параллельно — четыре человека отвечают за четыре работы, серийный — один человек выполняет четыре работы и по одной работе каждый; блокирование — когда задача нуждается в помощи других Стоп; Готовность: ожидание продолжения выполнения остальных после помощи других; Выполнение работы в процессе; Неблокирующее ожидание выполнения задачи и переключения задачи вперед и назад, не завершены, состояние готовности и состояние работы переключаются.

---

Глава 22 Процесс параллелизма

Принцип параллелизма процесса

• Природа параллелизма: Переключение процесса + сохранение состояния процесса. Условия для переключения состояния: высокоприоритетное включение процесса, время выполнения текущего процесса истекло, и текущий процесс требует операции ввода-вывода.

---

Процесс параллельного программирования

• Два способа запуска дочерних процессов: Родительский процесс будет ожидать завершения дочернего процесса, прежде чем завершится.
• Python вызывает функцию подпроцесса:

# coding=utf-8
# @Time   : 2019/10/9 17:58
# @Author: алюминиевый сплав
# @File   : Create_Sub_Process.py

from multiprocessing import  Process
import time

def task(name):
    print('Процесс 2% запущен'%name)
    time.sleep(3)
    print('3% s процесс завершен'%name)

if __name__ == '__main__':
    # Создать класс подпроцесса (функция подпроцесса и параметры, требуемые функцией: args = тип данных кортеж, по порядку;
    # kwargs = {'name': 'lhj'} может использовать словарь для передачи параметров, не зависящих от порядка)
    # p = Process (target = task, args = ('Алюминиевый дочерний процесс',))
    p=Process(target=task,kwargs={'name':«Подпроцесс алюминиевого сплава»})
    
    # Приложение отправляет инструкции операционной системе, чтобы подать заявку на аппаратные ресурсы
    # (Подать заявку на пространство памяти; скопировать данные памяти родительского процесса; создать дочерний процесс)
    p.start()
    
    # В этот раз он был выполнен одновременно
    time.sleep(2)
    print(«1 Это основной процесс»)
    
#windows система должна запустить дочерний процесс в главном
# В противном случае он будет бесконечно долго создавать свой собственный процесс

• Python переписать многопроцессорный класс и создать ссылку на экземпляр:

# coding = utf-8
# @Time   : 2019/10/9 19:10
# @Author: алюминиевый сплав
# @File   : Refactor_Process.py

from multiprocessing import Process
import time

class MyProcess(Process):
    def __init__(self,name):
        # Инициализация родительского класса (класс выполнения, параметры)
        super (Process,self).__init__()
        self.name=name

    def run(self):
        print('Процесс 2% запущен'%self.name)
        time.sleep(3)
        print(«Процесс 3% запущен» % self.name)

if __name__ == '__main__':
    p=MyProcess('Алюминиевый сплав')
    p.start() #start наконец вызывает метод run
    print(«1 Это основной процесс»)

---

• Пространство памяти родительского процесса и дочернего процесса изолированы друг от друга：

# coding = utf-8
# @Time   : 2019/10/9 19:23
# @Author: алюминиевый сплав
# @File   : Process_RAM.py

from multiprocessing import Process
import time
x=10 # Глобальная переменная x родительского пространства памяти
def task():
    time.sleep(3)
    global x #Call является дочерним пространством памяти, потому что оно копируется из родительского пространства памяти, поэтому значение то же самое, но адрес другой
    print(«Значение дочернего процесса x», x, «Начался дочерний процесс»)
    x=5 # Изменена глобальная переменная x в области под-памяти
    print(«Значение дочернего процесса x»,x,«Дочерний процесс завершен»)

if __name__ == '__main__':
    p=Process(target=task,)
    p.start() # Изменить глобальную переменную x в области памяти дочернего процесса
    time.sleep(5)
    print(x) #X глобальная переменная родительского процесса

• Родительский процесс ожидает завершения дочернего процесса: Используется в сценариях связи, если tcp дочернего процесса не установлен, родительский процесс не может перейти к следующему шагу. Здесь динамический метод мониторинга join () используется для контроля завершения дочернего процесса (внутренний принцип объединения заключается в том, чтобы спрашивать, заканчивается ли дочерний процесс через определенные промежутки времени).

# coding = utf-8
# @Time   : 2019/10/9 19:32
# @Author: алюминиевый сплав
# @File   : Super_Wait_Sub_Down.py

from multiprocessing import Process
import time
x=10
def task(id):
     print(id,«Номер дочернего процесса запущен»,x)
     time.sleep(id)

if __name__ == '__main__':
    start_time=time.time()
    list_process=[]
    for i in range(10):
        p=Process(target=task,kwargs={'id':i})
        list_process.append(p)
        p.start()# Отправить инструкции в os для выделения аппаратных ресурсов для создания дочерних процессов
    for p in list_process:
        p.join() # Динамический мониторинг, завершается ли процесс, прежде чем продолжать ввод следующей итерации
    end_time = time.time()

    # Идентификатор выходных данных не обязательно равен 0-9, что быстрее и выполняется первым в соответствии с процессом создания операционной системы.
    print(«Мониторинг завершения всех дочерних процессов, завершения родительского процесса, общий трудоемкий процесс»,end_time-start_time,
          «Самый длинный подпроцесс занимает 9 секунд, а затраты на переключение процессов»,end_time-start_time-9)

---

Зомби-процесс и процесс-сирота (система Linux)

• нота: Следующий пример основан на системе Linux в качестве стандарта, а механизм процесса полностью отличается от системы Windows. Все дочерние процессы перейдут в состояние зомби, а затем родительский процесс завершит сбор.
• Зомби процесс: Есть родительский процесс, за исключением init в Linux. После завершения процесса (очищает занятую область памяти, закрывает и открывает файлы, восстанавливает ресурсы), некоторые вещи будут оставлены (сохранить PID процесса, занять время процессора и выйти из состояния) в работе Система позволяет родительскому процессу просматривать последний вызов waitpid собственного интерфейса Linux, когда родительский процесс подходит к концу (Объединение в Python инкапсулирует waitpid) Восстановить данные дочернего процесса (собрать труп).
• Сиротский процесс: Если родительский процесс завершается, но дочерний процесс не завершается, дочерний процесс становится потерянным процессом и входит в состояние восстановления зомби и другого правительства (init) после выполнения.
• Вред зомби-процесса и сиротского процесса: Потерянный процесс безвреден, потому что init был переработан сзади, и большое количество зомби-процессов будет, если родительский процесс вызывает большое количество дочерних процессов и не завершает себя, он никогда не будет обрабатывать большое количество зомби-процессов из-за операционной системы. Количество PID ограничено, поэтому большое количество закрытых процессов зомби будет влиять на открытие новых процессов.

---

демон

• определение: Защита основной программы, выполняющей код. Демон (дочерний процесс) защищает основной процесс.Если основной процесс, который должен быть защищен, завершается, процесс демона должен завершиться до завершения родительского процесса.

# coding = utf-8
# @Time   : 2019/10/9 20:31
# @Author: алюминиевый сплав
# @File   : Guard_Process.py

from multiprocessing import Process
import time,os
def task(name):
    print('%s is running'%name)
    time.sleep(10)

if __name__ == '__main__':
    p=Process(target=task,kwargs={'name':'Алюминиевый сплав'})
    p.daemon=True # Этот дочерний процесс установлен как процесс-демон, родительский процесс должен завершиться, как только завершится дочерний процесс
    p.start()
    print(«Конец основного процесса»)

---

Mutex

• Сцены: Три задачи должны одновременно выводить данные на консоль, но есть только одна консоль. Если вы хотите, чтобы данные не пересекались и не портились, вы должны превратить параллельное выполнение в последовательное выполнение, одно за другим. В это время требуется блокировка взаимного исключения.
• Mutex: Все процессы, подлежащие сериализации, совместно используют объект взаимного исключения. Эта блокировка является общедоступной и была ограблена и не разблокирована. Следующее ограбление недоступно. Два робота подряд, а второе не должно быть ограблено, поскольку программа в первый раз зависает без разблокировки.

# coding = utf-8
# @Time   : 2019/10/9 21:23
# @Author: алюминиевый сплав
# @File   : Lock_Process.py
'''
 Обработка мьютекса: превращение параллельных программ в последовательное выполнение,
 Используйте метод join () для управления важным человеком, чтобы решить порядок использования ресурса
 Не нужно блокировать через мьютекс
'''
from multiprocessing import Process,Lock
import time,random

mutex=Lock() # Создание объекта блокировки

def task1(lock):
    lock.acquire() #Замок
    print(«Word Printer Task 1»)
    time.sleep(random.randint(1,3))
    print(«Word Printer Task 2»)
    time.sleep(random.randint(1,3))
    print(«Word Printer Task 3»)
    lock.release() #Unlock

def task2(lock):
    lock.acquire()  # Замок
    print(«Задание принтера 1 из wps»)
    time.sleep(random.randint(1,3))
    print(«Задание принтера 2 из wps»)
    time.sleep(random.randint(1,3))
    print(«Задание принтера 3 из wps»)
    lock.release() #Unlock

def task3(lock):
    lock.acquire()  # Замок
    print(«Задача принтера блокнота 1»)
    time.sleep(random.randint(1,3))
    print(«Блокнот принтера Задача 2»)
    time.sleep(random.randint(1,3))
    print(«Задача принтера блокнота 3»)
    lock.release() #Unlock


if __name__ == '__main__':
    # При поступлении объекта блокировки процесс блокируется, как только процесс выполняется, и ресурсы принтера заняты, пока процесс не завершится, чтобы разблокировать
    p1=Process(target=task1,args=(mutex,))
    p2 = Process(target=task2,args=(mutex,))
    p3 = Process(target=task3,args=(mutex,))
    # Когда последний дочерний процесс завершится, перейдите к следующему и измените его на последовательный
    p1.start()
    p2.start()
    p3.start()
    print(«Основной процесс»)

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

---

Механизм IPC (связь между процессами-механизмом очереди находится в центре внимания)

• Проблемы с процессом общения: Средняя скорость совместного использования жесткого диска низкая, вы можете использовать общее пространство памяти для совместного использования. Что нужно механизму IPC (пространство памяти, совместно используемое процессами, которые могут автоматически решать проблему блокировки, существует конкуренция за совместное использование и требуется взаимное исключение).
• Дефект метод-менеджер класса: Класс Manager имеет недостатки проектирования. (Класс Manager) не решает проблему блокировки. Весьма вероятно, что ошибка возникнет и не рекомендуется. Разработка баз данных более сложна, потому что программное обеспечение баз данных имеет дело со многими блокировками.
• Общие методы (механизм очереди): Очередь является очередью «первым пришел — первым обслужена» и соответствует всем условиям, требуемым механизмом IPC.
• нота: Очередь очереди (связь между очередями также называется очередью сообщений) используется для хранения сообщений, передаваемых между процессами, объем данных не должен быть слишком большим, параметр связи — это размер очереди, а диапазон настроек ограничен ограничением памяти.Очередь распределяется между процессами.
• Практика программирования: Значение блока, который может войти в очередь, не имеет значения, потому что оно не используется, и если оно больше, чем очередь за пределами очереди, если установлена ​​блокировка и не задано время ожидания (будет продолжаться ожидание) или блок не заблокирован, он будет напрямую сообщать об ошибке, поскольку очередь заполнена Тоже.

# coding = utf-8
# @Time   : 2019/10/9 22:15
# @Author: алюминиевый сплав
# @File   : IPC_Queue_Process.py
from multiprocessing import Process,Queue
import random

def task1(q):
    print(q.get())

if __name__ == '__main__':
    q=Queue(3)
    p=Process(target=task1,kwargs={'q':q})
    # Первые три блока не имеют значения, заблокированы они или нет, потому что в очереди три пустых слота.
    q.put('1',block=True)
    q.put('2',block=True)
    q.put('3',block=True)
    # p.start () # Распределить ресурсы и создать процессы
    # p.join () # Дождаться завершения дочернего процесса
    q.put('4', block=False) # Ввод не блокируется, независимо от того, заполнен он или нет, он будет заблокирован напрямую. Если очередь заполнена, об ошибке будет сообщено напрямую.

---

Производитель потребительской модели

• Определение производителя и потребителя: Производитель (отвечает за задачу по генерации данных), Потребитель (отвечает за обработку данных, созданных производителем). Модели процессов производителя и процесса потребления реализуют разделение программы.
• Метафора изображения: Производитель (бармен); очередь (барная стойка); потребитель (клиент)
• Сценарий приложения: Когда в программе очевидно есть два типа задач (один тип производственных данных и один тип данных обработки). Например, сочетание сканеров (производители) и анализа данных (потребители).
• выгода: Осуществить разделение производителей и потребителей, сбалансировать производительность и энергопотребление посредством связи в очереди вместо прямой связи, и эти два процесса всегда могут работать.
• Реализация программы：

# coding = utf-8
# @Time   : 2019/10/10 12:49
# @Author: алюминиевый сплав
# @File   : Producer_Consumer_Process.py

import time
import random
from multiprocessing import Process,Queue
def consumer(name,q):
    while True:
        res=q.get()
        time.sleep(random.randint(1,3)) # Случайный сон длиннее производственного, чтобы избежать пустого рабочего цикла.
        print(f'{name} drink {res}')

def producer(name,q,food):
    for i in range(5):
        time.sleep(random.randint(1,2))
        res=fНапиток "{я}: {еда}"
        q.put(res)
        print(f'{имя} вызвал {res}')

if __name__ == '__main__':
    # Общий бар
    q=Queue()

    # Процессы производителя
    p1=Process(target=producer,kwargs={'name':'Бармен 1','q':q,'food':'Красный бык'})
    p2=Process(target=producer,kwargs={'name':'Бармен 2','q':q,'food':'Бренди'})
    p3=Process(target=producer,kwargs={'name':'Бармен 3','q':q,'food':«Зеленый дьявол»})

    # Потребительские процессы
    c1=Process(target=consumer,kwargs={'name':«Потребитель 1»,'q':q})
    c2=Process(target=consumer,kwargs={'name':«Потребитель 2»,'q':q})

    p1.start();p2.start();p3.start();
    c1.start();c2.start()

---

Приложение-демон

• Сценарий приложения: Одна проблема с последней реализованной моделью производитель-потребитель заключается в том, что программа не закончилась. Поскольку подпроцесс потребителя не знает, закончено ли производство, когда очередь пуста, очередь потребителя всегда будет блокироваться и ждать.
• проблема: Потребительский процесс должен быть уведомлен о прекращении производства. 1 (После окончания всех производителей-использованияjoin()Судя по всему, есть несколько производителей, которые присоединяются к нескольким None, чтобы заставить потребителей добраться до None и сломаться 2 (Используйте объект-очередь JoinalbeQueue, после того, как все производители вызовутq.join()Чтобы заблокировать продолжение родительского процесса, если блок заканчивается, очередь пуста, и задача, удаленная дочерним процессом, выполненаq.task_done()Суждение.)
• подводить итоги: Родительский процесс присоединяетсяq.join()Чтобы заблокировать очередь, ожидающую обработки продукции и подпроцесса-потребителя для присоединенияq.task_done()Довести до сведенияq.join()Конец блокировки. После этого вы можете установить дочерний процесс-потребитель как процесс-демон, поскольку родительский процесс не должен был поесть в конце, поэтому дочернему процессу-потребителю не нужно ждать вслепую.
• Код：

# coding = utf-8
# @Time   : 2019/10/10 12:49
# @Author: алюминиевый сплав
# @File   : Producer_Consumer_Process.py

import time
import random
from multiprocessing import Process,JoinableQueue
def consumer(name,q):
    while True:
        res=q.get()
        time.sleep(random.randint(1,3)) # Случайный сон дольше, чем производство (не ешьте медленно), q.get () заблокирует, если данные не достигнуты, и не завершит процесс.
        print(f'{name} drink {res}')
        q.task_done()

def producer(name,q,food):
    for i in range(2):
        time.sleep(random.randint(1,2))
        res=f'Напитки: {еда}'
        q.put(res)
        print(f'{имя} вызвал {res}')

if __name__ == '__main__':
    # Общий бар
    q=JoinableQueue()

    # Процессы производителя
    p1=Process(target=producer,kwargs={'name':'Бармен 1','q':q,'food':'Красный бык'})
    p2=Process(target=producer,kwargs={'name':'Бармен 2','q':q,'food':'Бренди'})
    p3=Process(target=producer,kwargs={'name':'Бармен 3','q':q,'food':«Зеленый дьявол»})

    # Потребительские процессы
    c1=Process(target=consumer,kwargs={'name':«Потребитель 1»,'q':q})
    c2=Process(target=consumer,kwargs={'name':«Потребитель 2»,'q':q})

    c1.daemon=True;c2.daemon = True

    p1.start();p2.start();p3.start();
    c1.start();c2.start()
    p1.join();p2.join();p3.join();
    print(«Конец производства, блокировка ожидания потребителей потреблять продукты очереди»)
    q.join()
    print(«Потребительское потребление завершено, завершите процесс демона (потребительский процесс), родительский процесс завершится»)

• подводить итогиВажным моментом является то, что использование очереди является ядром взаимодействия с процессами. Шаблон проектирования потребительской модели производителя (идея решения проблемы) получен из Java, также известного как шаблон фабрики, что также очень важно. «Фабрика соответствует очереди, выньте бобы из фабричного контейнера»

---

Глава 23 Поток параллелизма

Нить

• определение: Поток — это реальная единица выполнения, а процесс — только единица ресурса, а основной поток включен в процесс. Только после того, как все дочерние потоки закончатся, основной поток завершит работу и очистит пространство памяти. Главный поток фактически представляет этот процесс.
• Метафора замещения: Процесс — это мастерская, а нить — это конвейер в мастерской, нить — это то, что действительно используется для производства.
• Преимущества нитокНесколько потоков внутри процесса совместно используют ресурсы внутри процесса, а ресурсы потоков различных процессов изолированы друг от друга. Затраты на создание меньше, чем 100-кратный процесс, потому что потоку создания здесь не нужно запрашивать пространство памяти.
• Сценарий приложения：Если мы пишем программу для обмена данными между некоторыми компонентами, рекомендуется использовать многопоточность, Например, напишите инструмент обработки текста. Рассматриваются как минимум четыре подфункции (получение информации о вводе пользователя; вывод информации о вводе пользователя на экран; сохранение информации о вводе пользователя на жесткий диск), если процесс является параллельным, обмен данными между процессами очень длинный и сложный, а потоки различны Данные в публичном пространстве памяти процесса.

---

Способ начать поток

• Поток создания функций: Определить функцию как объект потока. Потоки не имеют аргумента родительско-дочернего потока, но здесь для правильного позиционирования процесс, созданный основным процессом, является сначала дочерним потоком.
• нота: Основной поток, ожидающий дочерний поток, здесь отличается от родительского процесса, ожидающего дочерний процесс. Основной поток ожидает, пока дочерний поток завершит очистку пространства памяти, в то время как основной процесс ожидает, когда дочерний процесс соберет труп для дочернего процесса (PID информации о завершении процесса очистки и т. Д.). За исключением основного потока основного процесса, конец основного потока эквивалентен концу подпроцесса, а информация PID останется после окончания подпроцесса.
  

---

• Поток создания класса: Несколько потоков в одном процессе принадлежат процессу и совместно используют ресурсы в процессе.
  

# coding = utf-8
# @Time   : 2019/10/11 16:18
# @Author: алюминиевый сплав
# @File   : Create_Thread.py

from threading import Thread
import  time

def task(name):
    print(f'Создать дочернюю нить {имя}')

class MyThread(Thread):
    def run(self) -> None:
        print(f'{self.name} процесс запущен')
        time.sleep(3)

if __name__ == '__main__':
    t1=Thread(target=task,kwargs={'name':«Тема 1»})
    t2=MyThread()
    t1.start()
    t2.start()
    print(«Главный поток работает»)

---

Гнездовая связь объединяет несколько потоков

Другие методы объектов потока

• Метод объекта процесса: Определить, является ли он живым, количество активных потоков, получить имя текущего потока и т. Д.
  

Демоническая нить

• нота: Завершение работы основного потока означает, что завершение потока, не являющегося демоном, представляет конец основного потока (процесса). Основано на Linux (завершение основного процесса не связано с дочерним процессом. Он будет очищать только оставшуюся информацию о завершенном дочернем процессе в конце его.).
• Разница между демоном и потоком демона: ** 1. Затраты на создание потока меньше, чем у основного потока. 2. Главный поток должен дождаться завершения процесса, не являющегося демоном. ** Процесс демона не был запущен. Родительский процесс (основной поток) завершил работу, и поток демона запускается быстро, поэтому его можно запустить до завершения основного потока (процесс, не являющийся демоном).

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

• проблема: Параллельное выполнение приносит проблему незащищенности данных, и несколько потоков должны быть заблокированы. Если несколько потоков имеют общую переменную, а переменные обработки потоков зависят друг от друга, они должны быть взаимоисключающими. После того, как несколько потоков принимают одну и ту же переменную в памяти как временную переменную, а затем изменяют переменную памяти в соответствии с временной переменной, потому что задержка составляет 0,1 секунды, поэтому все временные значения равны 100.

x=100
def task():
    global  x
    temp=x
    time.sleep(0.1) # Смоделируйте задержку в задаче обработки потока.
    x=temp-1
# Выход составляет 99, потому что 0,1 сна делает температуру каждого дочернего потока одинаковой

if __name__ == '__main__':
    start_time=time.time()
    thread_list=[]
    for i in range(100):
        t=Thread(target=task)
        thread_list.append(t)
        t.start()
    for t in thread_list:
        t.join()
    print('Бог',x)
    print(time.time()-start_time)

• Блокировка обработки: 100 потоков по 0,1 секунды выполняются последовательно, а время выполнения процесса (основной поток) составляет около 10 секунд.

# coding = utf-8
# @Time   : 2019/10/11 16:38
# @Author: алюминиевый сплав
# @File   : Lock_Thread.py

from  threading import Thread,Lock
import time

# Параллельное выполнение заблокировано в последовательном исполнении
mutex=Lock()
x=100

def task():
    global  x
    mutex.acquire() #Замок
    temp=x
    time.sleep(0.1)
    x=temp-1
    mutex.release() #Unlock

if __name__ == '__main__':
    start_time=time.time()
    thread_list=[]
    for i in range(100):
        t=Thread(target=task)
        # Нет необходимости передавать блокировки, потому что в отличие от процессов потоки разделяют пространство памяти
        thread_list.append(t)
        t.start()
    for t in thread_list:
        t.join()
    print('Бог',x)
    print(time.time()-start_time)

Тупик и блокировка рекурсии

сигнал

• определение: Семафор — это особый замок. Чтобы решить проблему одиночной охраны с помощью блокировки мьютекса, используйте семафор для решения проблемы общественного туалета. Подобно рекурсии блокировки, все они являются пакетами блокировки: один может войти только тогда, когда он пуст, а другой может войти, когда он свободен.
  

Глобальная блокировка интерпретатора GIL (важная концепция, только проблемы компилятора CPython)

• определениеЧтобы упорядочить интерпретатор конфликтов потоков, CPython контролирует его, добавляя к интерпретатору блокировку GIL. Роль GIL заключается в том, чтобы гарантировать, что в процессе одновременно работает только один поток (ваш интерпретатор py и py).
• Процесс выполнения кода Python：После выполнения процесса написанный вами код py-файла и код интерпретатора py находятся в одном и том же пространстве памяти. Сначала запустите код интерпретатора python, а затем интерпретируйте ваш файл py как строку. Когда в вашем строковом коде появляется какой-то интерпретатор ключевых слов python, он вызывает ваш собственный код, чтобы помочь вам завершить его. Py файл будет несколько потоков для переводчика
• жизненный опыт: GIL не является функцией Python, но уникален для среды компиляции по умолчанию CPython. Pthon не полностью зависит от GIL. Существует много способов реализации интерпретатора Python, то есть существует несколько компиляторов, написанных на языке ассемблера (например, язык C представляет собой набор стандартов грамматики, существуют компиляторы, такие как Visual C ++, и один и тот же фрагмент кода Python можно передавать через CPython, PyPy, Psyco Подождите, пока среда выполнения будет выполнена).Поточно--Потому что в Python есть поток для сборки мусора, поток сбора мусора периодически запускается интерпретатором в фоновом режиме для одновременного выполнения с написанной вами программой.Если GIL отсутствует, параллельная обработка данных будет происходить в случае многоядерных процессоров. Данные удаляются потоком сборки мусора до того, как поток будет связан. Поскольку управление памятью интерпретатора CPython не является потокобезопасным, требуется поток, который блокирует несколько собственных объектов.
• нотаGIL — это безопасность данных на уровне интерпретатора, а безопасность данных на уровне потоков гарантируется добавлением блокировок мьютекса.
• Преимущества и недостатки GIL: Гарантированные преимущества — Потокобезопасность управления памятью интерпретатора CPython. Недостатки — потоки в одном и том же процессе нельзя распараллелить (нельзя использовать преимущества многоядерного процессора), а поток сталкивается с io или не имеет проблем с параллелизмом

---

CPython под влиянием GIL, выбор одноядерного многопоточного параллельного и многоядерного многопараллельного исполнения (важно, важно)

• Выбор приложенияЕсли программа интенсивно использует ввод-вывод, эффективность одноядерного параллелизма и многоядерного параллелизма примерно одинакова, поскольку большую часть времени используется для обработки запросов ввода-вывода. Если он требует значительных вычислительных ресурсов (как указано в GIL), в процессе может работать только один поток, поэтому требуются многопроцессорные и многоядерные вычисления.
• Как показано
  

Пул процессов и пул потоков (пул играет роль буферизации)

• Причина существования: Бесконечное открытие потоков и процессов приведет к парализации сервера, поэтому верхний предел числа параллельных / параллельных задач должен контролироваться пулом, а количество процессов / потоков должно быть ограничено в пределах диапазона машины.
• определение: Пул — это идея, пул процессов и пул потоков одинаковы
• Выбор сцены: Используйте пул процессов, когда задача требует больших вычислительных ресурсов, и используйте пул потоков, когда задача интенсивно использует ввод-вывод.
  

Синхронный и асинхронный (сотрудничество, взаимодействие между процессами)

Очередь потоков

---

Поток Событие

Глава 24 Контроль сопрограмм

Глава 25 Модель I_O

Ускорение вычислений — это цель, которой хотят достичь все. Что, если у вас есть сценарий, который может работать в десять раз быстрее, чем его текущее время выполнения? В этой статье мы рассмотрим многопроцессорность Python и библиотеку под названием multiprocessing. Мы поговорим о том, что такое многопроцессорность, о ее преимуществах и о том, как улучшить время выполнения ваших программ на Python с помощью параллельного программирования.

Введение в параллелизм

Прежде чем мы погрузимся в код Python, мы должны поговорить о параллельных вычислениях, которые являются важным понятием в информатике.

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

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

Не вдаваясь в подробности, идея параллелизма состоит в том, чтобы написать код таким образом, чтобы он мог использовать несколько ядер ЦП.

Чтобы упростить задачу, давайте рассмотрим пример.

Параллельные и последовательные вычисления

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

Что, если у вас есть трое друзей, хорошо разбирающихся в математике, которые готовы вам помочь? Каждый из них будет вычислять квадратный корень из двух чисел, и вам будет легче работать, потому что нагрузка распределяется поровну между вашими друзьями. Это означает, что ваша проблема будет решена быстрее.

Итак, все ясно? В этих примерах каждый друг представляет ядро ​​процессора. В первом примере вся задача последовательно решается вами. Это называется последовательными вычислениями. Во втором примере, поскольку вы работаете всего с четырьмя ядрами, вы используете параллельные вычисления. Параллельные вычисления включают использование параллельных процессов или процессов, которые разделены между несколькими ядрами процессора.

Модели для параллельного программирования

Мы установили, что такое параллельное программирование, но как мы его используем? Что ж, мы уже говорили ранее, что параллельные вычисления включают выполнение нескольких задач между несколькими ядрами процессора, что означает, что эти задачи выполняются одновременно. Есть несколько вопросов, которые вы должны рассмотреть, прежде чем приступать к распараллеливанию. Например, есть ли другие оптимизации, которые могли бы ускорить наши вычисления?

А пока примем как должное, что распараллеливание — лучшее решение для вас. Существуют в основном три модели параллельных вычислений:

• Идеально параллельно. Задачи могут выполняться независимо друг от друга, и им не нужно взаимодействовать друг с другом.
• Параллелизм с общей памятью. Процессам (или потокам) необходимо обмениваться данными, поэтому они совместно используют глобальное адресное пространство.
• Прохождение сообщений. Процессы должны обмениваться сообщениями, когда это необходимо.

В этой статье мы проиллюстрируем первую модель, которая также является самой простой.

Многопроцессорность Python: параллелизм на основе процессов в Python

Одним из способов достижения параллелизма в Python является использование модуля multiprocessing. Модуль multiprocessingпозволяет создавать несколько процессов, каждый из которых имеет собственный интерпретатор Python. По этой причине многопроцессорность Python реализует параллелизм на основе процессов.

Возможно, вы слышали о других библиотеках, таких как threading, которые также встроены в Python, но между ними есть существенные различия. Модуль multiprocessingсоздает новые процессы, threadingсоздавая новые потоки.

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

Преимущества использования многопроцессорности

Вот несколько преимуществ многопроцессорной обработки:

• лучшее использование ЦП при работе с задачами с высокой нагрузкой на ЦП
• больший контроль над дочерним элементом по сравнению с потоками
• легко кодировать

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

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

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

Начало работы с многопроцессорной обработкой Python

Наконец-то мы готовы написать код на Python!

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

• Процесс parent. Существует только один родительский процесс, у которого может быть несколько дочерних процессов.
• Процесс child. Это порождается родителем. У каждого ребенка также могут быть новые дети.

Мы собираемся использовать childпроцесс для выполнения определенной функции. Таким образом, parentможно продолжить его выполнение.

Простой пример многопроцессорной обработки Python

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

from multiprocessing import Process

def bubble_sort(array):
    check = True
    while check == True:
      check = False
      for i in range(0, len(array)-1):
        if array[i] > array[i+1]:
          check = True
          temp = array[i]
          array[i] = array[i+1]
          array[i+1] = temp
    print("Array sorted: ", array)

if __name__ == '__main__':
    p = Process(target=bubble_sort, args=([1,9,4,5,2,6,8,4],))
    p.start()
    p.join()

В этом фрагменте мы определили функцию с именем bubble_sort(array). Эта функция является действительно наивной реализацией алгоритма сортировки пузырьком. Если вы не знаете, что это такое, не волнуйтесь, потому что это не так важно. Важно знать, что это функция, которая выполняет некоторую работу.

Класс процесса

Из multiprocessing, мы импортируем класс Process. Этот класс представляет действие, которое будет выполняться в отдельном процессе. Действительно, вы можете видеть, что мы передали несколько аргументов:

• target=bubble_sort, что означает, что наш новый процесс будет запускать bubble_sortфункцию
• args=([1,9,4,52,6,8,4],), который представляет собой массив, переданный в качестве аргумента целевой функции

После того, как мы создали экземпляр класса Process, нам нужно только запустить процесс. Это делается письменно p.start(). В этот момент процесс запущен.

Перед выходом нам нужно дождаться, пока дочерний процесс завершит свои вычисления. Метод join()ожидает завершения процесса.

В этом примере мы создали только один дочерний процесс. Как вы можете догадаться, мы можем создать больше дочерних процессов, создав больше экземпляров в Processклассе.

Класс пула

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

Класс Poolпозволяет создать пул рабочих процессов, и в следующем примере мы рассмотрим, как мы можем его использовать. Это наш новый пример:

from multiprocessing import Pool
import time
import math

N = 5000000

def cube(x):
    return math.sqrt(x)

if __name__ == "__main__":
    with Pool() as pool:
      result = pool.map(cube, range(10,N))
    print("Program finished!")

В этом фрагменте кода у нас есть cube(x)функция, которая просто принимает целое число и возвращает его квадратный корень. Легко, верно?

Затем мы создаем экземпляр Poolкласса без указания какого-либо атрибута. Класс пула по умолчанию создает один процесс на ядро ​​ЦП. Далее мы запускаем mapметод с несколькими аргументами.

Метод mapприменяет cubeфункцию к каждому элементу предоставленного нами итерируемого объекта, который в данном случае представляет собой список всех чисел от 10до N.

Огромным преимуществом этого является то, что вычисления в списке выполняются параллельно!

Лучшее использование многопроцессорной обработки Python

Создание нескольких процессов и выполнение параллельных вычислений не обязательно более эффективно, чем последовательные вычисления. Для задач с низкой нагрузкой на ЦП последовательные вычисления выполняются быстрее, чем параллельные. По этой причине важно понимать, когда следует использовать многопроцессорность — это зависит от выполняемых задач.

Чтобы убедить вас в этом, давайте рассмотрим простой пример:

from multiprocessing import Pool
import time
import math

N = 5000000

def cube(x):
    return math.sqrt(x)

if __name__ == "__main__":
    # first way, using multiprocessing
    start_time = time.perf_counter()
    with Pool() as pool:
      result = pool.map(cube, range(10,N))
    finish_time = time.perf_counter()
    print("Program finished in {} seconds - using multiprocessing".format(finish_time-start_time))
    print("---")
    # second way, serial computation
    start_time = time.perf_counter()
    result = []
    for x in range(10,N):
      result.append(cube(x))
    finish_time = time.perf_counter()
    print("Program finished in {} seconds".format(finish_time-start_time))

Этот фрагмент основан на предыдущем примере. Мы решаем ту же задачу, что и вычисление квадратного корня из Nчисел, но двумя способами. Первый предполагает использование многопроцессорности Python, а второй — нет. Мы используем perf_counter()метод из timeбиблиотеки для измерения производительности по времени.

На моем ноутбуке я получаю такой результат:

> python code.py
Program finished in 1.6385094 seconds - using multiprocessing
---
Program finished in 2.7373942999999996 seconds

Как видите, разница больше секунды. Так что в этом случае многопроцессорность лучше.

Давайте изменим что-нибудь в коде, например, значение N. Давайте понизим его до N=10000и посмотрим, что произойдет.

Вот что я получаю сейчас:

> python code.py
Program finished in 0.3756742 seconds - using multiprocessing
---
Program finished in 0.005098400000000003 seconds

Что случилось? Кажется, что многопроцессорность сейчас плохой выбор. Почему?

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

Заключение

В этой статье мы говорили об оптимизации производительности кода Python с помощью многопроцессорной обработки Python.

Сначала мы кратко представили, что такое параллельные вычисления и основные модели их использования. Затем мы начали говорить о многопроцессорности и ее преимуществах. В итоге мы увидели, что распараллеливание вычислений не всегда лучший выбор, и multiprocessingмодуль следует использовать для распараллеливания задач, связанных с процессором. Как всегда, нужно рассмотреть конкретную проблему, с которой вы столкнулись, и оценить плюсы и минусы различных решений.

Манифест

1. Учиться нужно асинхронно: в работу нужно брать не огромную тему (например изучить весь Python или теорию баз данных),
   а набирать из разных направлений понемногу маленьких тем / вопросов в проработку: чуть-чуть из Python, чуть-чуть из
   SQL и так далее.
2. Обязательно освоить работу с Git, Debugger и научиться писать простейшие тесты.
3. Заниматься регулярно!
4. Решать (или пытаться решить) в день хотя бы 1 задачку с leetcode или аналогичного сайта.
5. Соблюдать режим труда и отдыха.
6. Не бояться просить помощи во всех доступных источниках, если пришлось столкнуться с проблемой, которую не получается
   решить за вменяемое время.

Избранные статьи на Хабр

• Почему твоя мама ещё не прогает? — Хабр
• Хватит клепать псевдопрограммистов, или «Горшочек — не в IT!» — Хабр
• Генераторы для самых маленьких — Хабр
• Введение в асинхронное программирование на Python — Хабр
• Асинхронный Python: различные формы конкурентности — Хабр
• Типовые ошибки Python-разработчиков на собеседованиях — Хабр
• Как работает память в Python — Хабр
• Рецепт полезного код-ревью от разработчика из Яндекса — Хабр
• Как устроен GIL? — Хабр
• Действительно ли Python GIL уже мёртв? — Хабр

Переводы на Хабр по технологиям

• Pytest — Хабр
• RabbitMQ — Хабр
• Docker — Хабр

Избранные курсы

• Погружение в Python — https://ru.coursera.org/learn/diving-in-python
• SQL — https://www.coursera.org/specializations/learn-sql-basics-data-science
• Postgresql — https://www.udemy.com/course/bestpostgres/
• Advanced Python — https://www.pluralsight.com/courses/advanced-python
• Канал про Python высокого качества — https://www.pluralsight.com/authors/robert-smallshire
• Elasticsearch — https://www.udemy.com/course/elasticsearch-complete-guide/

Избранные книги

• Ч.Петцольд — Код. Тайный язык информатики — базовая книга для понимания того, как работают компьютеры.
• М.Лутц — Изучаем Python (2 тома) — базовые книги по Python
• М.Лутц — Программирование на Python — читать только после базовых томов
• А.Бхаргава — Грокаем алгоритмы — базовая книга по алгоритмам и структурам данных
• А.Швец — Погружение в паттерны проектирования — базовая книга по паттернам для новичков. Читать только после книг по алгоритмам и программированию.
• Л.Ромальо — Python. К вершинам мастерства — читать только после книг по программированию.
• С.Дасгупта, Х.Пападимитриу, У.Вазирани — Алгоритмы — жёсткая книга про алгоритмы, но очень крутая. Читать только после всего остального.
• Python для сетевых инженеров — Документация Python для сетевых инженеров 3.0
• Э.Шоу — Внутреннее устройство CPython
• К. Нгуен — Полное руководство параллельного программирования на Python http://onreader.mdl.ru/MasteringConcurrencyInPython/content/index.html
• Д.Хеллман — Стандартная библиотека Python

Избранные видео

• А. Кузьмин — Память и Python https://www.youtube.com/watch?v=D0vbuIDOV4c

Избранные сайты для решения задач

• https://codeforces.com/
• https://codewars.com/
• https://leetcode.com/

Вопросы, часто встречающиеся на собеседованиях

1. Что такое интерпретируемый язык? Что такое интерпретатор и как он работает в Python?
2. Что такое статическая и динамическая типизация и в чем это проявляется в Python?
3. Какие типы данных в Python вам известны?
4. Чем кортеж отличается от списка?
5. В каких случаях лучше использовать кортеж, а в каких — список?
6. Как вы объясните человеку, что такое множество?
7. Что такое словари и как они работают?
8. Как работают типы данных хэшмап, связанный список, двусвязный список, массив?
9. Что такое О (о-большое)? Зачем и как используется?
10. Какая сложность вставки, извлечения, поиска элементов в словаре и списке?
11. Что такое функции и зачем они нужны?
12. Какие бывают аргументы у функций?
13. Что такое распаковка коллекций?
14. Что такое исключения? Какие они бывают? Как их использовать?
15. Что такое ООП? На каких концепциях стоит ООП?
16. Объяснить понятие класса и объекта (экземпляра).
17. Что такое инкапсуляция? Накодить пример.
18. Что такое наследование? Накодить пример.
19. Бывает ли в Python множественное наследование? Как ты относишься к этому факту?
20. Если у нескольких классов-родителей есть методы с одинаковыми названиями, то какой из них будет вызван в наследнике?
21. Что такое полиморфизм? Накодить пример.
22. Что такое staticmethod?
23. Чем staticmethod отличается от простой функции?
24. Когда будем использовать staticmethod, а когда простую функцию?
25. Что такое classmethod? В чём его особенности? Когда применяется?
26. Что такое магические методы и за что они отвечают?
27. Что такое конструктор объектов в Python и из чего он состоит и как работает?
28. Почему в методе init есть аргумент self?
29. Что такое приватные и защищенные атрибуты? Как они работают?
30. Можно ли получить доступ к приватным атрибутам в Python?
31. Что такое менеджер контекста, зачем он нужен?
32. Какие способы конкурентного выполнения программ в Python бывают?
33. Что такое GIL и как он работает?
34. В каких случаях GIL не работает?
35. Что такое сборщик мусора и как он работает?
36. Что такое потоки и процессы? Чем отличается поток от процесса?
37. Что такое системный вызов fork?
38. Какие существуют способы синхронизации процессов и потоков?
39. Как передавать информацию из одного процесса в другой?
40. Что такое эффект гонок? Как с ним бороться?
41. Что такое асинхронность?
42. Что такое event loop и как он работает?
43. Сколько потоков и процессов работает во время асинхронного выполнения кода?
44. Для каких задач стоит использовать потоки, для каких — процессы, а для каких — асинхронность?

Git

1. Что это такое и зачем он нужен?
2. Что такое local и remote репозитории?
3. Что такое commit?
4. Что такое ветка?
5. Что такое pull-request / merge-request?
6. Что такое merge?
7. Что такое rebase?
8. Что такое pull?
9. Чем rebase отличается от merge?
10. Что такое конфликты? Почему они возникают и как их разрешать?
11. Уметь пользоваться командами: clone, commit, push, pull, merge, rebase

Docker

1. Что такое контейнеризация? Зачем она нужна?
2. Чем контейнер отличается от виртуальной машины?
3. Что такое образ?
4. Что такое том?
5. Что такое сеть контейнера?
6. Какие виды сетей бывают?
7. Зачем нужен docker-compose?

Базы данных

1. Что такое базы данных и для чего они нужны?
2. Какие типы баз данных бывают?
3. Чем РСУБД отличаются от NoSQL БД?
4. Какие достоинства и недостатки есть у РСУБД и NoSQL?
5. Приведите примеры РСУБД и NoSQL БД.
6. Что такое BASE и ACID?
7. Как понять, какую базу данных нужно использовать в проекте?
8. Что такое индексы? Зачем они нужны? Как они работают?
9. Какие популярные виды индексов существуют?
10. Что такое транзакции? Зачем они нужны?
11. Какие виды изолирования транзакций бывают?
12. Что такое профилирование запросов?

SQL

1. Что такое JOIN’ы и какие они бывают?
2. Что такое оконные функции и как они работают?

Backend

1. Что такое протокол передачи данных?
2. Что такое HTTP? Чем отличается HTTPS?
3. Какие другие протоколы передачи данных, кроме HTTP(S) вы знаете? Как они работают?
4. Что такое API?
5. Что такое REST и RESTfull API?

Тестирование

1. Что такое тестирование и зачем оно нужно?
2. Какие виды тестов вы знаете? Что каждый из видов тестов подразумевает под собой?
3. Какие библиотеки для написания тестов используются?
4. Что такое фикстура в pytest?

Кодинг:

1. Написать пример произвольного менеджера контекста.
2. Реализовать паттерн проектирования синглтон.
3. Реализовать паттерн проектирования декоратор.
4. Решить несколько задач.Уметь оценить алгоритмическую сложность решения.

Задача на временные метки

Есть список событий:

[
            {
                "dt": "2022-02-23 04:35:27.353366",
                "event": "start"
            },
            {
                "dt": "2022-02-23 04:35:34.654153",
                "event": "stop"
            },
            {
                "dt": "2022-02-23 04:38:34.382548",
                "event": "start"
            },
            {
                "dt": "2022-02-23 04:38:39.637583",
                "event": "stop"
            }
]

В этом списке последовательно лежат события типа START и STOP, а также их временные метки. События лежат
последовательно: после START всегда идёт STOP и наоборот. Задача:

1. Написать функцию, которая возвращает количество часов, выпадающее на промежуток соответствующих событий
   START — STOP за указанную дату.
2. Возвращать количество часов за диапазон дат.
3. Возвращать количество часов за текущий день, неделю, месяц, год.

Python Parallel Programming Cookbook — Second Edition

This is the code repository for Python Parallel Programming Cookbook — Second Edition , published by Packt.

Over 70 recipes to solve challenges in multithreading and distributed system with Python 3

What is this book about?

Nowadays, it has become extremely important for programmers to understand the link between the software and the parallel nature of their hardware so that their programs run efficiently on computer architectures. Applications based on parallel programming are fast, robust, and easily scalable.

This book covers the following exciting features:

• Synchronize multiple threads and processes to manage parallel tasks
• Use message passing techniques to establish communication between processes to build parallel applications
• Program your own GPU cards to address complex problems
• Manage computing entities to execute distributed computational task
• Write efficient programs by adopting the event-driven programming model
• Explore cloud technology with Django and Google App Engine
• Apply parallel programming techniques that can lead to performance improvements

If you feel this book is for you, get your copy today!

Instructions and Navigations

All of the code is organized into folders. For example, Chapter02.

The code will look like the following:

class Pdb_test(object):
    def __init__(self, parameter):
    self.counter = parameter

Following is what you need for this book:
The Python Parallel Programming Cookbook is for software developers who are well-versed with Python and want to use parallel programming techniques to write powerful and efficient code. This book will help you master the basics and the advanced of parallel computing.

With the following software and hardware list you can run all code files present in the book (Chapter 01-09).

Software and Hardware List

No	Software required	OS required
1	Python 3.7	Any

We also provide a PDF file that has color images of the screenshots/diagrams used in this book. Click here to download it.

Related products

• Mastering GUI Programming with Python [Packt] [Amazon]

• Expert Python Programming — Third Edition [Packt] [Amazon]

Get to Know the Author

Giancarlo Zaccone
Giancarlo Zaccone has over fifteen years’ experience of managing research projects in the scientific and industrial domains. He is a software and systems engineer at the European Space Agency (ESTEC), where he mainly deals with the cybersecurity of satellite navigation systems.

Giancarlo holds a master’s degree in physics and an advanced master’s degree in scientific computing.

Giancarlo has already authored the following titles, available from Packt: Python Parallel Programming Cookbook (First Edition), Getting Started with TensorFlow, Deep Learning with TensorFlow (First Edition), and Deep Learning with TensorFlow (Second Edition).

Other books by the authors

Python Parallel Programming Cookbook

Suggestions and Feedback

Click here if you have any feedback or suggestions.

Аннотация

The study of computer science should cover not only the principles on which computational processing is based, but should also ref l ect the current state of knowledge of these fi elds.
Today, the technology requires that professionals from all branches of computer science know both the software and hardware whose interaction at all levels is the key to understanding the basics of computational processing.
For this reason, in this book, a special focus is given on the relationship between hardware architectures and software.
Until recently, programmers could rely on the work of the hardware designers, compilers, and chip manufacturers to make their software programs faster or more eff i cient without the need for changes.
This era is over. So now, if a program is to run faster, it must become a parallel program.
Although the goal of many researchers is to ensure that programmers are not aware of the parallel nature of the hardware for which they write their programs, it will take many years before this actually becomes possible. Nowadays, most programmers need to thoroughly understand the link between hardware and software so that the programs can be run eff i ciently on modern computer architectures.
To introduce the concepts of parallel programming, the Python programming language has been adopted. Python is fun and easy to use, and its popularity has grown steadily in recent years. Python was developed more than 10 years ago by Guido van Rossum, who derived Python’s syntax simplicity and ease of use largely from ABC, which is a teaching language that was developed in the 80s.

In addition to this specif i c context, Python was created to solve real-life problems, and it borrows a wide variety of typical characteristics of programming languages, such as C ++, Java, and Scheme. This is one of its most remarkable features, which has led to its broad appeal among professional software developers, the scientif i c research industry, and computer science educators. One of the reasons why Python is liked so much is because it provides the best balance between the practical and conceptual approaches. It is an interpreted language, so you can start doing things immediately without getting lost in the problems of compilation and linking. Python also provides an extensive software library that can be used in all sorts of tasks ranging from the Web, graphics, and of course, parallel computing. This practical aspect is a great way to engage readers and allow them to carry out projects that are important in this book.
This book contains a wide variety of examples that are inspired by many situations, and these offer you the opportunity to solve real-life problems. This book examines the principles of software design for parallel architectures, insisting on the importance of clarity of the programs and avoiding the use of complex terminology in favor of clear and direct examples.
Each topic is presented as part of a complete, working Python program, which is followed by the output of the program in question.
The modular organization of the various chapters provides a proven path to move from the simplest arguments to the most advanced ones, but this is also suitable for those who only want to learn a few specif i c issues.
I hope that the settings and content of this book are able to provide you with a useful contribution for your better understanding and dissemination of parallel programming techniques.

Master efficient parallel programming to build powerful applications using Python

About This Book

• Design and implement efficient parallel software
• Master new programming techniques to address and solve complex programming problems
• Explore the world of parallel programming with this book, which is a go-to resource for different kinds of parallel computing tasks in Python, using examples and topics covered in great depth

Who This Book Is For

Python Parallel Programming Cookbook is intended for software developers who are well versed with Python and want to use parallel programming techniques to write powerful and efficient code. This book will help you master the basics and the advanced of parallel computing.

What You Will Learn

• Synchronize multiple threads and processes to manage parallel tasks
• Implement message passing communication between processes to build parallel applications
• Program your own GPU cards to address complex problems
• Manage computing entities to execute distributed computational tasks
• Write efficient programs by adopting the event-driven programming model
• Explore the cloud technology with DJango and Google App Engine
• Apply parallel programming techniques that can lead to performance improvements

In Detail

This book will teach you parallel programming techniques using examples in Python and will help you explore the many ways in which you can write code that allows more than one process to happen at once. Starting with introducing you to the world of parallel computing, it moves on to cover the fundamentals in Python. This is followed by exploring the thread-based parallelism model using the Python threading module by synchronizing threads and using locks, mutex, semaphores queues, GIL, and the thread pool.

Next you will be taught about process-based parallelism where you will synchronize processes using message passing along with learning about the performance of MPI Python Modules. You will then go on to learn the asynchronous parallel programming model using the Python asyncio module along with handling exceptions. Moving on, you will discover distributed computing with Python, and learn how to install a broker, use Celery Python Module, and create a worker.

You will understand anche Pycsp, the Scoop framework, and disk modules in Python. Further on, you will learnGPU programming withPython using the PyCUDA module along with evaluating performance limitations.

Style and approach

A step-by-step guide to parallel programming using Python, with recipes accompanied by one or more programming examples. It is a practically oriented book and has all the necessary underlying parallel computing concepts.