Перейти к содержимому

Что такое синхронность и асинхронность

  • автор:

Синхронность и асинхронность процессов

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

Любому программисту понятно, что такое синхронность и асинхронность. Вот насколько это понятно программисту, настолько это непонятно и обычным разработчикам процессов.

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

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

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

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

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

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

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

Конечно, юристы могут возмутиться – чего это мы будем оценивать поставщика, если вы там еще четко не решили, будете ли у него заказывать? Что им ответить?

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

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

В асинхронности обычно пугает отсутствие гарантий, то есть риск негативного результата в одной из параллельных ветвей процесса. Что делать, если согласование закончится неудачей?

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

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

Типичный пример: «я буду согласовывать только после того, как согласует вот он». Или «я посмотрю на этот договор только после финансистов». Хотя, если верить статистике и здравому смыслу, подобные постановки не имеют под собой оснований, и являются лишь способом переложить ответственность.

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

Например, пусть финансовый отдел, стоящий в цепочке согласования договора, смотрит только на условия оплаты. Пусть у него будут свои, понятные критерии оценки. Лучше, если они будут формализованы в виде типового договора – например, 100% постоплата для поставщиков, 100 % предоплата для покупателей. В таком случае договоры, удовлетворяющие критериям, будут проскакивать на раз. И у финансистов не останется повода ждать оценки от тех же юристов.

Единственное, что важно: асинхронные процессы очень сложно реализовать без автоматизации. Если процессы, их исполнение и отслеживание реализованы только на бумаге, то добавление параллельных ветвей превратит их в хаос. Нужна автоматизация.

Лучше всего для такой автоматизации подходит принцип «Автозадачи». Хотя, можно обойтись и стандартными средствами рисования процессов, которые есть в современных платформах, только придется повозиться.

Стандартные «рисовалки» процессов потребуют от вас обозначить весь процесс, все ветви и взаимосвязи. Если процесс сложный и длинный, то вы столкнетесь с проблемой – он банально перестанет влезать на экран, в ширину. Если вы учились в институте на программиста, то помните такое правило оформления алгоритмов: не более трех параллельных вертикальных ветвей. Правило придумано не просто так – если ветвей будет больше, понять схему алгоритма будет проблематично.

Автозадачи от этой проблемы избавляют – там изображения процесса нет вообще, т.к. отсутствует такая сущность – процесс. Есть задачи. Если очень хочется, можно из них собрать процесс. Но не наоборот. Эдакий дедуктивный метод рисования процессов.

Кроме асинхронности, есть еще более мощный метод оптимизации – буферизация процессов. О нем – в другой раз.

  • Анализ и проектирование систем
  • Управление персоналом

Асинхронность в программировании

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

Обложка поста Асинхронность в программировании

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

while (true) < std::string data; auto socket = Socket(localhost, port); socket.wait_connection(); while (!socket.end_of_connection()) < data = socket.read(); // Блокировка socket.write(data); // Блокировка >> 

При вызове методов read() и write() текущий поток исполнения будет прерван в ожидании ввода-вывода по сети. Причём большую часть времени программа будет просто ждать. В высоконагруженных системах чаще всего так и происходит — почти всё время программа чего-то ждёт: диска, СУБД, сети, UI, в общем, какого-то внешнего, независимого от самой программы события. В малонагруженных системах это можно решить созданием нового потока для каждого блокирующего действия. Пока один поток спит, другой работает.

Но что делать, когда пользователей очень много? Если создавать на каждого хотя бы один поток, то производительность такого сервера резко упадёт из-за того, что контекст исполнения потока постоянно сменяется. Также на каждый поток создаётся свой контекст исполнения, включая память для стека, которая имеет минимальный размер в 4 КБ. Эту проблему может решить асинхронное программирование.

Асинхронность

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

Callbacks

Для написания асинхронной программы можно использовать callback-функции (от англ. callback — обратный вызов) — функции, которые будут вызваны асинхронно каким-либо обработчиком событий после завершения задачи. Переписанный пример сервера на callback-функциях:

while (true) < auto socket = Socket(localhost, port); socket.wait_connection(); // Всё ещё есть блокировка socket.async_read([](auto &data) /* * Поток не блокируется, лямбда-функция будет вызвана * каждый раз после получения новых данных из сокета, * а основной поток пойдёт создавать новый сокет и * ждать новое соединение. */ < socket.async_write(data, [](auto &socket) < if (socket.end_of_connection()) socket.close(); >); >); > 

В wait_connection() мы всё ещё ждём чего-то, но теперь вместе с этим внутри функции wait_connection() может быть реализовано подобие планировщика ОС, но с callback-функциями (пока мы ждём нового соединения, почему бы не обработать старые? Например, через очередь). Callback-функция вызывается, если в сокете появились новые данные — лямбда в async_read() , либо данные были записаны — лямбда в async_write() .

В результате мы получили асинхронную работу нескольких соединений в одном единственном потоке, который намного реже будет ждать. Эту асинхронность можно также распараллелить, чтобы получить полный профит от утилизации процессорного времени.

У такого подхода есть несколько проблем. Первую в шутку называют callback hell. Достаточно погуглить картинки на эту тему, чтобы понять, насколько это нечитаемо и некрасиво. В нашем примере всего две вложенные callback-функции, но их может быть намного больше.

Вторая проблема заключается в том, что код перестал выглядеть как синхронный: появились «прыжки» из wait_connection() в лямбды, например лямбда, переданная в async_write() , что нарушает последовательность кода, из-за чего становится невозможно предсказать, в каком порядке будут вызваны лямбды. Это усложняет чтение и понимание кода.

Async/Await

Попробуем сделать асинхронный код так, чтобы он выглядел как синхронный. Для большего понимания немного поменяем задачу: теперь нам необходимо прочитать данные из СУБД и файла по ключу, переданному по сети, и отправить результат обратно по сети.

public async void work() < var db_conn = Db_connection(localhost); var socket = Socket(localhost, port); socket.wait_connection(); var data = socket.async_read(); var db_data = db_conn.async_get(await data); var file_data = File(await data).async_read(); await socket.async_write($””); socket.close(); > 

Пройдём по программе построчно:

  • Ключевое слово async в заголовке функции говорит компилятору, что функция асинхронная и её нужно компилировать по-другому. Каким именно образом он будет это делать, написано ниже.
  • Первые три строки функции: создание и ожидание соединения.
  • Следующая строка делает асинхронное чтение, не прерывая основной поток исполнения.
  • Следующие две строки делают асинхронный запрос в базу данных и чтение файла. Оператор await приостанавливает текущую функцию, пока не завершится выполнение асинхронной задачи чтения из БД и файла.
  • В последних строках производится асинхронная запись в сокет, но лишь после того, как мы дождёмся асинхронного чтения из БД и файла.

Это быстрее, чем последовательное ожидание сначала БД, затем файла. Во многих реализациях производительность async / await лучше, чем у классических callback-функций, при этом такой код читается как синхронный.

Корутины

Описанный выше механизм называется сопрограммой. Часто можно услышать вариант «корутина» (от англ. coroutine — сопрограмма).

Далее будут описаны различные виды и способы организации сопрограмм.

Несколько точек входа

По сути корутинами называются функции, имеющие несколько точек входа и выхода. У обычных функций есть только одна точка входа и несколько точек выхода. Если вернуться к примеру выше, то первой точкой входа будет сам вызов функции оператором asynс , затем функция прервёт своё выполнение вместо ожидания БД или файла. Все последующие await будут не запускать функцию заново, а продолжать её исполнение в точке предыдущего прерывания. Да, во многих языках в корутине может быть несколько await ’ов.

Для большего понимания рассмотрим код на языке Python:

def async_factorial(): result = 1 while True: yield result result *= i fac = async_factorial() for i in range(42): print(next(fac)) 

Программа выведет всю последовательность чисел факториала с номерами от 0 до 41.

Функция async_factorial() вернёт объект-генератор, который можно передать в функцию next() , а она продолжит выполнение корутины до следующего оператора yield с сохранением состояния всех локальных переменных функции. Функция next() возвращает то, что передаёт оператор yield внутри корутины. Таким образом, функция async_factorial() в теории имеет несколько точек входа и выхода.

Stackful и Stackless

В зависимости от использования стека корутины делятся на stackful, где каждая из корутин имеет свой стек, и stackless, где все локальные переменные функции сохраняются в специальном объекте.

Так как в корутинах мы можем в любом месте поставить оператор yield , нам необходимо где-то сохранять весь контекст функции, который включает в себя фрейм на стеке (локальные переменные) и прочую метаинформацию. Это можно сделать, например, полной подменой стека, как это делается в stackful корутинах.

На рисунке ниже вызов async создаёт новый стек-фрейм и переключает исполнение потока на него. Это практически новый поток, только исполняться он будет асинхронно с основным.

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

Асинхронность в программировании 1

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

Более производительными, но вместе с тем и более ограниченными, являются stackless корутины. Они не используют стек, и компилятор преобразует функцию, содержащую корутины, в конечный автомат без корутин. Например, код:

def fib(): a = 0 b = 1 while True: yield a a += b yield b b += a 

Будет преобразован в следующий псевдокод:

class fib: def __init__(self): self.a = 0 self.b = 1 self.__result: int self.__state = 0 def __next__(self): while True: if self.__state == 0: self.a = 0 self.b = 1 if self.__state == 0 or self.__state == 3: self.__result = self.a self.__state = 1 return self.__result if self.__state == 1: self.a += self.b self.__result = self.b self.__state = 2 return self.__result if self.__state == 2: self.b += a self.__state = 3 break 

По сути здесь создаётся класс, который сохраняет всё состояние функции, а также последнюю точку вызова yield . У такого подхода есть проблема: yield может быть вызван только в теле функции-корутины, но не из вложенных функций.

Симметричные и асимметричные

Корутины также делятся на симметричные и асимметричные.

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

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

Вывод

Асинхронное программирование является очень мощным инструментом для оптимизации высоконагруженных программ с частым ожиданием системы. Но, как и любую сложную технологию, её нельзя использовать только потому, что она есть. Необходимо всегда задавать себе вопрос: а нужна ли мне эта технология? Какую практическую пользу она мне даст? Иначе разработчики рискуют потратить очень много сил, времени и денег, не получив никакого профита.

Что такое синхронность и асинхронность

В этой статье вы узнаете о том, что такое синхронное и асинхронное программирование в JavaScript и как применяя эти знания, работать с Async/Await .

Понимание синхронного и асинхронного JavaScript с Async/Await

JavaScript выполнение синхронного и асинхронного кода

Недавно мы вели беседу с несколькими начинающими JS разработчиками, относительно того, как JS распределяет память и как парсится код, а также выполняется. что одна из самых важных тем, которая никогда не являлась частью любой программы обучения и ни одну из них не обязательно знать, чтобы написать программу на JavaScript. Но такие темы очень важны для любопытных разработчиков, которые серьёзно относятся к своему делу. Я решил написать об этой теме, так как я нахожу её довольно неоднозначной, а люди имеют свойство сравнивать вещи, в особенности те, кто знаком с такими языками программирования, как PHP, C++, Java и т.д, но учтите, что JavaScript это дикий зверь и с самого начала у меня он забрал довольно прилично времени для того, чтобы осознать некоторые важные аспекты JS, например то, как Будучи однопоточным, JavaScript может быть синхронным и неблокируемым процессом?

Теперь перед тем как мы копнем глубже, давайте проясним основную концепцию и разницу между JavaScript Engine (движок) и JavaScript Run-time Enviroment.

Движок JavaScript это программа, которая используется для обработки заданного кода и конвертирования его в конкретные команды для выполнения.

С другой стороны, JavaScript Run-time Enviroment это среда отвечающая за создание экосистемы с возможностями, сервисами и поддержкой, такими как массивы, функции, ключевые библиотеки и тп, которые необходимы для того, чтобы код запустился верно.

Функциональная модель

Почти все бразуеры имеют JavaScript движок. Самые популярные это V8 в Google Chrome и Node.js, SpiderMonkey Мазилы, Chakra для IE и т.д. Хоть все эти браузеры и выполняют JavaScript по-разному, но под капотом, они все работают по старой доброй модели.

Функциональная модель

Call Stack, Web APIs, Event loop, асинхронная очередь заданий, очередь на рендер и т.д. Все мы слышали эти шумные термины в нашей ежедневной работе. В совокупности, все они работают вместе, чтобы перевести и выполнить синхронные и асинхронные блоки кода, которые мы пишем каждый день. Давайте заглянем глубже в эту модель и попытаемся понять, что они делают и что самое важное — как они это делают.

Синхронные задачи

Что означает синхронность? Скажем, что у нас есть 2 строки кода. Первая идет за второй. Синхронность означает то, что строка 2 не может запуститься до тех пор, пока строка 1 не закончит своё выполнение.

JavaScript сам по себе однопоточный, что означает то, что только один блок кода может запускаться за раз. Так как движок JS выполняет наш код, обрабатывая строку за строкой, он использует один стек вызова, чтобы продолжать отслеживать код, который выполняется в соответствии с установленным порядком. Тоже самое, что и делает стек — структура данных, которая записывает строки выполняемых инструкций и выполняет их в стиле LIFO , то есть Last In First Out , что переводится как, «последний пришел — первый обслужен”. Давайте посмотрим на живом примере, как это происходит и работает, вот function foo() < foo() отправляется в стек и затем, когда выполнение foo() доходит до return;>foo() прекращается и выкидывается из стека вызовов.

Синхронные задачи

Что происходит в Exercise 1: итак, схема выше показывает нам типичное линейное выполнение кода. Когда код из трех console.log объявлений отдается в JS.

Шаг 1: console.log(«Print 1») отправляется в стек вызовов и выполняется, после того, как процесс завершится, он будет выкинут из стека. Теперь стек пуст и готов к следующим инструкциям на выполнение.

Шаг 2: Следующей инстукцией на выполнение является console.log(«Print 2»); , который также отправляется в стек и после выполнения оттуда выкидывается. Всё повторяется до тех пор, пока не останется ничего для выполнения.
Давайте посмотрим на следующий пример:

Exercise 1

Exercise 2: что же тут происходит на самом деле:
Шаг 1: В стек вызовов попадает первое выполняемое объявление нашего скрипта — вызов функции First() . Во время выполнения в области видимости функции First() , наш движок встречает вызов ещё одной функции — Second() .

Шаг 2: Следовательно, вызов функции Second() отправляется в стек вызовов и движок начинает выполнение её содержимого, снова встречаясь с ещё одной функцией Third() внутри Second() .

Шаг 3: Функция Third() также отправляется в стек запросов и движок начинается её выполнение. Пока функции Second() и First() находятся в стеке и ждут своей очереди в соответствии с порядком.

Шаг 4: Когда движок сталкивается с return; внутри функции Third() , то это означает завершение Third() . Следовательно Third() выкидывается из стека, как завершенное исполнение. На этом моменте движок возвращается к выполнению Second() .

Шаг 5: итак, как только движок столкнется с return;, функция Second() будет выкинута из стека и начнется выполнение First() . Теперь тут нет объявления return внутри области видимости First() , так что выполнится только код до конца его области видимости и First() будет выкинут из стека на шаге 6.

Вот то, как браузер работает с синхронными задачами без привлечения чего-либо ещё, кроме «легендарного” стека вызовов. Но всё становится куда сложнее, когда JavaScript сталкивается с асинхронными задачами.

Асинхронные задачи

Что такое вообще — асинхронность? В отличие от синхронности, асинхронность это модель поведения. Предположим, что у нас есть две строчки кода, первая за второй. Первая строка это инструкция, для которой нужно время. итак, первая строка начинает запуск этой инструкции в фоновом режиме, позволяя второй строке запуститься без ожидания завершения первой строки.

Нам нужно такое поведение в случае, когда что-то тормозит. Синхронность может казаться прямолинейной и незатейливой, но всё же может быть медленной. Такие задачи, как обработка изображений, операции с файлами, создание запросов сети и ожидание ответа — всё это может тормозить и быть долгим, производя огромные расчеты в 100 миллионов циклов итераций. Так что такие вещи в стеке запросов превращаются в «задержку”, ну или «blocking” по-английски. Когда стек запросов заблокирован, браузер препятствует вмешательству пользователя и выполнению другого кода до тех пор, пока «задержка” не выполнится и не освободит стек запросов. Таким образом, асинхронные колбэки (callback) используются в таких ситуациях.

Пример: Видимо функция setTimeout() это простейший способ продемонстрировать основы асинхронного поведения.

Асинхронные задачи

Exercise 3: Давайте рассмотрим стек запросов, который только что увидели:
Шаг 1: Как и обычно console.log(«Hello «) отправляется в стек первым и сразу же из него выкидывается после выполнения.

Шаг 2: setTimeout() отправляется в стек, но обратите внимание на то, что console.log(«Siddhartha») не может сразу выполниться, так как стоит отсрочка на 2 секунды. Так что пока эта функция для нас исчезнет, но мы позже разберем этот вопрос.

Шаг 3: Само собой, следующая строка это console.log(» I am «) , которая отправляется в стек, выполняется и тут же выкидывается из него.

Шаг 4: Сейчас стек запросов пуст и в ожидании.

Шаг 5: Внезапно console.log( «Siddhartha» ) обнаруживается в стеке, после 2-х секунд задержки. Далее setTimeout() выполняется и сразу после этого выкидывается из стека. На 6-м шаге, наш стек оказывается пустым.

что говорит о том, что пусть даже JavaScript и однопоточный, мы можем достичь согласованности действий через асинхронное исполнение задач.

Теперь у нас осталось несколько вопросов:

Вопрос 1: Что случилось с setTimeout() ?
Вопрос 2: Откуда оно вернулось?
Вопрос 3: и как это вообще произошло?

и тут появляется Event Loop (или цикл обработки событий) и Web API. Давайте представим каждого из вышесказанных и ответим на эти три вопроса в нашей следующей схеме.

Exercise 3

Exercise 4: Давайте разберемся.
Шаг 2: С этого момента setTimeout(callback, 2000) отправляется в стек запросов. Как мы можем видеть, тут имеются компоненты callback и задержка в 2000ms. Теперь setTimeout() не является частью JavaScript движка, это по сути Web API включенное в среду браузера как дополнительный функционал.

Шаг 3: итак, Web API браузера берет на себя callback и запускает таймер в 2000ms, оставляя на фоне setTimeout() , которое сделало свою работу и выкинуто из стека. Вот и ответ на первый вопрос.

Шаг 4: Следующая строка в нашем скрипте это console.log( «I am» ) , отправленное в стек и выкинутое оттуда после выполнения.

Шаг 5: Теперь у нас есть callback в WebAPI, который собирается сработать по прошествии 2000ms. Но WebAPI не может напрямую как попало закидывать что-то в стек запросов, потому что это может создать прерывание для другого кода, выполняемого в JavaScript движке, именно в этот момент. Так что callback поставится в очередь выполнения задач после 2000ms. А теперь WebAPI пуст и свободен.

Шаг 6: Цикл событий или Event Loop — ответственный за взятие первого элемента из очереди задач и передачу его в стек запросов, только тогда, когда стек пуст и свободен. На этом шаге нашего уравнения, стек запросов пуст.

Шаг 7: итак, callback отправлен в стек запросов, так как он был пуст и свободен. и тут же выполнился. Так что ответ на второй вопрос готов.

Шаг 8: Далее идет выполнение кода console.log(«Siddhartha») , который находится в области видимости callback, следовательно, console.log(«Siddhartha») отправляется в стек запросов.

Шаг 9: После того, как console.log(«Siddhartha») выполнен, он выкидывается из стека запросов и JavaScript приходит к завершению выполнения callback. Который в свою очередь после своего завершения будет выкинут из стека запросов. А вот и ответ на вопрос как.

итак, это была довольно простая демонстрация происходящего, но всё может стать сложнее в некоторых ситуациях, например тогда, когда есть несколько setTimeout в очереди — в общем результаты разнятся, от того что обычно ожидается.

Теперь давайте посмотрим на пример с Async/Await.

Далее мы попытаемся понять синтаксис async/await погружаясь ещё глубже в то, что же это на самом деле и как это работает.

итак, вы знаете что оно делает, но знаете ли вы как?

У большинства разработчиков неоднозначное отношение к JavaScript, отчасти из-за того, что они становятся жертвами одного из его лучших качеств: он легко учится, но тяжело применяется. что легко подметить посмотря на то, сколько разработчиков склонны полагать, что этот язык работает только в одном направлении, но на самом деле всё происходит по-другому, если взглянуть под капот. именно эта разница проявляется в деталях и вызывает разочарование.

Для примера, я не сомневаюсь в том, что изменения в стандартах вызвали у многих из вас недопонимание о поведении языка, например как с классами. В JavaScript нет классов, в реальности, JavaScript использует Prototypes, синглтон объекты, из которых наследуются другие объекты. По-факту, все объекты в JavaScript имеют прототип из которого они наследуются. что означает то, что классы в JS на самом деле не ведут себя как классы. Класс это схема для создания экземпляров объекта, а prototype это экземпляр, которому другие экземпляры объекта передают работу, prototype это не схема и не шаблон, он просто есть и всё.

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

 var someArray = [1, 2, 3]; Array.prototype.newMethod = function() < console.log('I am a new method!'); >; someArray.newMethod(); // I am a new method! // Код выше был бы невозможен с реальными классами, так как изменение схемы, не изменяет того, что было сделано с ним. 

В общем, классы в JavaScript это синтаксический сахар для прототипизирования.

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

Async/Await спецификации

Асинхронные функции это дополнение к языку, уже включенное в последний драфт EcmaScript. Вы можете смело их использовать с применением Babel.

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

На протяжении лет у нас было несколько способов работы с асинхронностью без всякого сумасшествия. В большинстве случаев, мы полагались на Callbacks :

 setTimeout(function() < console.log("This runs after 5 seconds"); >, 5000); console.log("This runs first"); 

Всё это хорошо, но что если мы столкнемся с последовательностью?

 doThingOne(function() < doThingTwo(function() < doThingThree(function() < doThingFour(function() < // Oh no >); >); >); >); 

То, что вы видите выше иногда называется Pyramid of Doom и Callback Hell.

Ппромисы

Промисы это очень мудрый и хороший способ работы с асинхронным кодом.

Промис это объект, который представляет собой асинхронный таск, который должен завершиться. При использовании это выглядит как-то так:

 function buyCoffee() < return new Promise((resolve, reject) =>< asyncronouslyGetCoffee(function(coffee) < resolve(coffee); >); >); > 

buyCoffee возвращает промис, который является процессом покупки кофе. Функция resolve указывает промису на то, что он выполнен. Он получает значение как аргумент, который будет доступен в промисе позже.

В самом экземпляре промиса есть два основных метода:

Then — запускает колбек, который вы передали, когда промис завершен.

Catch — запускает колбек, который вы передали, когда что-то идет не так, что вызывает reject вместо resolve. Reject вызывает как вручную, так и автоматически, если необработанное исключение появилось внутри кода промиса.
Важно: промисы, которые были выкинуты из-за исключения, поглотят это исключение. что означает то, что если ваши промисы не связаны должным образом или нет вызова catch в каком-либо промисе из цепочки, то вы обнаружите, что ваш код просто втихую порушится, что может быть очень разочаровывающе, так что избегайте таких ситуаций любой ценой.

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

 buyCoffee() .then(function() < return drinkCoffee(); >) .then(function() < return doWork(); >) .then(function() < return getTired(); >) .then(function() < return goToSleep(); >) .then(function() < return wakeUp(); >); 

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

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

 const firstPromise = new Promise(function(resolve) < return resolve("first"); >); const secondPromise = new Promise(function(resolve) < resolve("second"); >); const doAllThings = firstPromise.then(function() < return secondPromise; >); doAllThings.then(function(result) < console.log(result); // Выдаст: "second" >); 

Если вы хотите подробно понять промисы, то прочтите эту статью — Три способа понять промисы

итак, мы уже почти подошли к самому интересному.

Async функции, это функции, которые возвращают промисы. что так. Вот почему я выделил время, чтобы кратко объяснить, что же такое промисы, так как чтобы реально понять Async/Await , вам надо знать то, как работают эти самые промисы. что как с примером про классы в JavaScript, где вам нужно понимать прототипирование.

Как это работает

Вот Async функции. Которые объявляются добавлением слова async , например async function doAsyncStuff()

Ваш код может встать на паузу в ожидании Async функции с await

Await возвращает то, что асинхронная функция отдаёт при завершении.

Await может быть использовано только внутри async функции.

Если асинхронная функция выдает исключение, то оно поднимется к родительской функции, как в обычном JavaScript и может быть перехвачено с try/catch . Как и в промисах, исключения будут проглочены, если они не будут перехвачены где-нибудь в цепочке кода. что говорит о том, что вы всегда должны использовать try/catch , всякий раз когда запускается цепочка вызовов Async функций. Хорошей практикой является включение хотя бы одного try/catch в каждую цепочку, если только в игнорировании этого совета нет абсолютной необходимости. что даст одно единственное место для работы с ошибками во время работы async и сподвигнет вас правильно связать ваши запросы async функций.

Давайте посмотрим на код

 // Просто рандомные асинхронные функции, работающие со значением async function thingOne() < … >async function thingTwo(value) < … >async function thingThree(value) < … >async function doManyThings() < var result = await thingOne(); var resultTwo = await thingTwo(result); var finalResult = await thingThree(resultTwo); return finalResult; >// Вызовите doManyThings() 

что то, как выглядит async/await , он очень схож с синхронным кодом, а синхронный код куда проще понять.

итак, теперь doManyThings() это тоже асинхронная функция, как нам await (ожидать) её? Да никак. Не с нашим новым синтаксисом. У нас есть три варианта:

2. Запустите её внутри ещё одной асинхронной функции, обернутой в блок try/catch .

3. или используйте как промис.

 // Вариант 1: doManyThings(); // Вариант 2: (async function() < try < await doManyThings(); >catch (err) < console.error(err); >>)(); // Вариант 3: doManyThings().then((result) => < // Делаем штуки, которым нужно подождать нашей функции >).catch((err) => < throw err; >); 

Снова функции, которые возвращают промисы
итак, под конец я бы хотел показать несколько примеров того, как async/await приблизительно переходят в промисы. Я надеюсь, что это поможет вам увидеть то, как async функции выполняют роль синтаксического сахара для создания функций, которые отдают и ожидают промисы.

Простая async функция:

 // Async/Await version async function helloAsync() < return "hello"; >// Promises version function helloAsync() < return new Promise(function (resolve) < resolve("hello"); >); > 

Async функция, которая ожидает результат другой async функции:

 // == Async/Await version == async function multiply(a, b) < return a * b; >async function foo() < var result = await multiply(2, 5); return result; >// Errors will be swallowed here (async function () < var result = await foo(); console.log(result); // Logs 5 >)(); // == Promises version == function multiply(a, b) < return new Promise(function (resolve) < resolve(a * b); >); > function foo() < return new Promise(function(resolve) < multiply(2, 5).then(function(result) < resolve(result); >); ); > // Errors will be swallowed here new Promise(function() < foo().then(function(result) < console.log(result); // Logs 5 >); >); 

Пример, на который важно обратить внимание

Вот пример того, почему понимание того, как работает async/await реально важно.

 async function foo() < someArray.forEach(function (value) < doSomethingAsync(value); >); > 

Пока что всё хорошо, мы параллельно выполняем doSomethingAsync несколько раз, так как мы не используем await. Но как бы мы это выполнили с await?

 async function foo() < someArray.forEach(function (value) < await doSomethingAsync(value); >); > 

Пример выше выдаст синтаксическую ошибку, так как мы передаем forEach синхронную функцию.

Не проблема, верно? Нам всего-лишь надо передать ей async функцию. А вот и нет.

 async function foo() < someArray.forEach(async function (value) < await doSomethingAsync(value); >); > 

Что тут не так? Давайте посмотрим на то, как это интерпретируется. Я не будут многословным с промисами и объясню то, как это было бы в случае с ними:

 function foo() < someArray.forEach(function () < // this is returning a promise return doSomethingAsync(value); >); > 

Проблема в том, что forEach не await (ожидает) async функции или выражаясь промисами, она не ждет пока одна итерация вернет промис, чтобы завершить предыдущую.

Также, в наших примерах, нам не надо было ожидать вызова forEach .

Так как теперь решить эту проблему? К сожалению, мы не можем использовать forEach . По-факту, никакие синхронные итераторы не будут работать. Нам нужны итераторы, которые знают как работать с промисами.

и есть один, который будет. что современная версия цикла for, » for of ”, которая понимает await для промисов.

 for (item of someArray)

Если вы не можете использовать » for of ”, то вы можете применить итератор, который поддерживает промисы или использовать библиотеку, такую как bluebird Promise.each:

В общем, поймите промисы и вы поймете async/await .

Синхронное и асинхронное

По загадочным причинам, в сфере вычислительной техники слово «асинхронный» означает «синхронный». Например, «асинхронный запрос» — это когда синхронно (т. е. одновременно) с ним может выполняться другой. А вот если синхронность в выполнении отсутствует, и запросы выполняются последовательно друг за другом, то их с какого-то бодуна называют «синхронными».

Бывает, сделаешь страничку, а медленный скрипт блокирует её загрузку. Дописываешь в нужное место параметр async — и проблема решена, теперь страница и скрипт грузятся синхронно! У вас не взрывается от этого мозг?

У меня — в клочья.

Поделиться
Поделиться

38 комментариев
Илья Миськов 2011
Дмитрий 2011

Дизайнер никогда не поймет логику программиста, и наоборот.
(Ну Чикуёнок разве что)

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

Игорь 2011

Нет. Просто у программистов иная точка отсчета что называть синхронным и асинхронным

Илья Бирман 2011

Значение слова в словаре посмотреть перед тем, как точку отсчёта устанавливать — не вариант?

Илья Миськов 2011

Дмитрий, не понял тебя.

Павел Власов 2011

Кто станет объяснять «почему это так и не могло быть иначе» — тот программист! А мне понравился новый взгляд на привычные вещи 🙂

Leonid 2011

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

Илья Бирман 2011

Я конечно понимаю, что одновременность — понятие относительное, но какое релятивистские эффекты имеют отношение к этому вопросу — для меня загадка.

Юрий Корчёмкин 2011

У меня когда-то взрывался, потом я понял, что «асинхронно» проистекает из цифровой электроники и значит «не подчиняющийся генератору синхроимпульсов», и успокоился.

Виктор Глушенков 2011

Ни от каких точек зрения или технического образования это не зависит. Синхронное исполнение музыкальных партий (к примеру) и параллельное — не одно и то же. Кому как не дискжокею это знать.
Вообще похоже на троллинг в духе «опенсоса» в день программиста))

Денис Попов 2011

Илья, вы путаете.

Синхронные процессы — это не просто процессы, происходящие одновременно. Это ещё и процессы, каким-либо образом _связанные_ между собой, _синхронизированные_ по некоторым ключевым точкам.

Википедия сообщает нам: «In computer science, especially parallel computing, synchronization refers to the coordination of simultaneous threads or processes to complete a task; in order to obtain correct runtime order and avoid unexpected race conditions».

Аяксовый запрос нельзя проконтролировать. Есть только две точки, к которым возможно привязаться: начало запроса и его конец (успешный или неуспешный). Поэтому синхронизировать аяксовый запрос и основной процесс значит запустить аяксовый запрос, дойти в основном процессе до точки X и ждать, пока аяксовый запрос не дойдёт до точки своего окончания. Точка Х синхронизируется, оказывается одновременной с точкой окончания аяксового запроса.

А вот если отцепить аяксовый запрос, не делать никаких привязок к моменту его завершения, а только указать, чтобы он по завершению вызывал (синхронно для _себя_) некий обработчик события, тогда как основной процесс будет выполняться неизвестно с какой скоростью и неизвестно в какой точке будет находиться на момент окончания аяксового запроса — тогда это получится асинхронность, потому что процессы не синхронизированы.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *