{"draftJsState":{"blocks":[{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":8,"offset":0,"style":"BOLD"}],"text":"1. Обзор","type":"header-two","key":"5a55r"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"unstyled","key":"epc8o"},{"data":{},"depth":0,"entityRanges":[{"key":0,"length":28,"offset":182}],"inlineStyleRanges":[{"length":66,"offset":68,"style":"BOLD"},{"length":29,"offset":182,"style":"ITALIC"}],"text":"В этой статье мы рассмотрим сопрограммы языка Kotlin. Проще говоря, сопрограммы позволяют нам свободно создавать асинхронные программы , и они основаны на концепции программирования в стиле передачи продолжения .","type":"unstyled","key":"a6ben"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":23,"offset":127,"style":"ITALIC"}],"text":"Язык Kotlin предоставляет нам базовые конструкции, но может получить доступ к более полезным сопрограммам с помощью библиотеки kotlinx-coroutines-core . Мы рассмотрим эту библиотеку, как только поймем основные строительные блоки языка Kotlin.","type":"unstyled","key":"gfr5"},{"data":{"image":{"id":"65b81100ca8d3441b2c2da65"}},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"atomic:image","key":"bo00v"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"unstyled","key":"fgh1f"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":47,"offset":0,"style":"BOLD"},{"length":13,"offset":34,"style":"ITALIC"}],"text":"2. Создание сопрограммы с помощью BuildSequence","type":"header-two","key":"10ep4"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"unstyled","key":"e88kr"},{"data":{},"depth":0,"entityRanges":[{"key":1,"length":13,"offset":55}],"inlineStyleRanges":[{"length":14,"offset":55,"style":"ITALIC"}],"text":"Давайте создадим первую сопрограмму, используя функцию buildSequence .","type":"unstyled","key":"f3bbc"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"И давайте реализуем генератор последовательности Фибоначчи, используя эту функцию:","type":"unstyled","key":"d7p2d"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"val fibonacciSeq = sequence {\n var a = 0\n var b = 1\n\n yield(1)\n\n while (true) {\n yield(a + b)\n\n val tmp = a + b\n a = b\n b = tmp\n }\n}","type":"blockquote","key":"6934a"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":10,"offset":18,"style":"ITALIC"}],"text":"Сигнатура функции доходности:","type":"unstyled","key":"c0aeb"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"public abstract suspend fun yield(value: T)","type":"blockquote","key":"4m286"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":7,"offset":15,"style":"ITALIC"},{"length":13,"offset":119,"style":"ITALIC"}],"text":"Ключевое слово suspend означает, что эта функция может быть блокирующей. Такая функция может приостановить сопрограмму buildSequence .","type":"unstyled","key":"6p4o1"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":148,"offset":0,"style":"BOLD"}],"text":"Приостанавливающие функции могут быть созданы как стандартные функции Kotlin, но мы должны помнить, что мы можем вызывать их только из сопрограммы. В противном случае мы получим ошибку компилятора.","type":"unstyled","key":"22nu2"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":1,"offset":49,"style":"ITALIC"}],"text":"Если мы приостановили вызов внутри buildSequence , этот вызов будет преобразован в выделенное состояние в конечном автомате. Сопрограмму можно передать и назначить переменной, как и любую другую функцию.","type":"unstyled","key":"a1odb"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":12,"offset":14,"style":"ITALIC"},{"length":9,"offset":87,"style":"ITALIC"},{"length":11,"offset":128,"style":"ITALIC"}],"text":"В сопрограмме fibonacciSeq у нас есть две точки подвески. Во-первых, когда мы вызываем выход(1), а во-вторых, когда мы вызываем выход(a+b).","type":"unstyled","key":"6qd9l"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":10,"offset":17,"style":"ITALIC"},{"length":12,"offset":266,"style":"ITALIC"}],"text":"Если эта функция доходности приводит к некоторому блокирующему вызову, текущий поток не будет блокироваться на ней. Он сможет выполнить какой-то другой код. Как только приостановленная функция завершит свое выполнение, поток может возобновить выполнение сопрограммы fibonacciSeq .","type":"unstyled","key":"2a5q3"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Мы можем протестировать наш код, взяв некоторые элементы из последовательности Фибоначчи:","type":"unstyled","key":"82c6p"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"val res = fibonacciSeq\n .take(5)\n .toList()\n\nassertEquals(res, listOf(1, 1, 2, 3, 5))","type":"blockquote","key":"co8vi"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":54,"offset":0,"style":"BOLD"},{"length":18,"offset":36,"style":"ITALIC"}],"text":"3. Добавление зависимости Maven для сопрограмм kotlinx","type":"header-two","key":"cneg1"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"unstyled","key":"e5a1p"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":18,"offset":32,"style":"ITALIC"}],"text":"Давайте посмотрим на библиотеку kotlinx-coroutines , в которой есть полезные конструкции, построенные на основе базовых сопрограмм.","type":"unstyled","key":"3om6p"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":23,"offset":41,"style":"ITALIC"}],"text":"Давайте добавим зависимость в библиотеку kotlinx-coroutines-core.","type":"unstyled","key":"bnhp9"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"\n org.jetbrains.kotlinx\n kotlinx-coroutines-core\n 1.3.9\n","type":"blockquote","key":"2vvhk"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":67,"offset":0,"style":"BOLD"},{"length":8,"offset":59,"style":"ITALIC"}],"text":"4. Асинхронное программирование с использованием процедуры launch()","type":"header-two","key":"8ov5v"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"unstyled","key":"2vsep"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":18,"offset":11,"style":"ITALIC"},{"length":1,"offset":201,"style":"ITALIC"}],"text":"Библиотека kotlinx-coroutines добавляет множество полезных конструкций, позволяющих создавать асинхронные программы. Допустим, у нас есть дорогостоящая вычислительная функция, которая добавляет строку в список ввода:","type":"unstyled","key":"su39"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"suspend fun expensiveComputation(res: MutableList) {\n delay(1000L)\n res.add(\"word!\")\n}","type":"blockquote","key":"cdf0v"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":7,"offset":34,"style":"ITALIC"}],"text":"Мы можем использовать сопрограмму запуска , которая будет выполнять функцию приостановки неблокирующим способом.","type":"unstyled","key":"drapd"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"@Test\nfun givenAsyncCoroutine_whenStartIt_thenShouldExecuteItInTheAsyncWay() {\n //given\n val res = mutableListOf()\n\n //when\n runBlocking {\n launch { expensiveComputation(res) }\n res.add(\"Hello,\")\n }\n\n //then\n assertEquals(res, listOf(\"Hello,\", \"word!\"))\n}","type":"blockquote","key":"f0n3p"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":11,"offset":85,"style":"ITALIC"},{"length":20,"offset":149,"style":"ITALIC"},{"length":13,"offset":223,"style":"ITALIC"}],"text":"Чтобы иметь возможность протестировать наш код, мы передаем всю логику в сопрограмму runBlocking , которая является блокирующим вызовом. Поэтому наш метод AssertEquals() может выполняться синхронно после кода внутри метода runBlocking() .","type":"unstyled","key":"3bpjk"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":8,"offset":50,"style":"ITALIC"},{"length":14,"offset":143,"style":"ITALIC"}],"text":"Обратите внимание, что в этом примере, хотя метод launch() запускается первым, это вычисление с задержкой. Основной поток продолжит добавление строки «Hello» в список результатов.","type":"unstyled","key":"4rsfd"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":20,"offset":50,"style":"ITALIC"},{"length":8,"offset":79,"style":"ITALIC"},{"length":9,"offset":116,"style":"ITALIC"}],"text":"После односекундной задержки, введенной в функции дорогойComputation() , слово «word!» К результату будет добавлена строка.","type":"unstyled","key":"gs48"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":27,"offset":0,"style":"BOLD"}],"text":"5. Сопрограммы очень легкие","type":"header-two","key":"1v5m8"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"unstyled","key":"a58ak"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":21,"offset":186,"style":"ITALIC"}],"text":"Давайте представим ситуацию, в которой мы хотим выполнить 100000 операций асинхронно. Создание такого большого количества потоков будет очень дорогостоящим и может привести к исключению OutOfMemoryException.","type":"unstyled","key":"s7s0"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"К счастью, при использовании сопрограмм это не так. Мы можем выполнить столько операций блокировки, сколько захотим. «Под капотом» эти операции будут обрабатываться фиксированным количеством потоков без чрезмерного создания потоков:","type":"unstyled","key":"2cqc9"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"@Test\nfun givenHugeAmountOfCoroutines_whenStartIt_thenShouldExecuteItWithoutOutOfMemory() {\n runBlocking {\n //given\n val counter = AtomicInteger(0)\n val numberOfCoroutines = 100_000\n\n //when\n val jobs = List(numberOfCoroutines) {\n launch {\n delay(1L)\n counter.incrementAndGet()\n }\n }\n jobs.forEach { it.join() }\n\n //then\n assertEquals(counter.get(), numberOfCoroutines)\n }\n}","type":"blockquote","key":"1tile"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":1,"offset":272,"style":"ITALIC"}],"text":"Обратите внимание, что мы выполняем 100 000 сопрограмм, и каждый запуск добавляет существенную задержку. Тем не менее, нет необходимости создавать слишком много потоков, поскольку эти операции выполняются асинхронно с использованием потоков из общего фонового пула потоков.","type":"unstyled","key":"5k0o0"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":21,"offset":0,"style":"BOLD"}],"text":"6. Отмена и тайм-ауты","type":"header-two","key":"1r57k"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"unstyled","key":"bvril"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":149,"offset":0,"style":"BOLD"}],"text":"Иногда, после того как мы запустили какое-то длительное асинхронное вычисление, мы хотим отменить его, потому что результат нас больше не интересует.","type":"unstyled","key":"8530q"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":8,"offset":67,"style":"ITALIC"},{"length":8,"offset":102,"style":"ITALIC"},{"length":8,"offset":204,"style":"ITALIC"},{"length":1,"offset":233,"style":"ITALIC"}],"text":"Когда мы запускаем наше асинхронное действие с помощью сопрограммы launch() , мы можем проверить флаг isActive . Этот флаг устанавливается в значение false всякий раз, когда основной поток вызывает метод cancel() в экземпляре задания:","type":"unstyled","key":"los7"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"@Test\nfun givenCancellableJob_whenRequestForCancel_thenShouldQuit() {\n runBlocking {\n //given\n val job = launch(Dispatchers.Default) {\n while (isActive) {\n //println(\"is working\")\n }\n }\n\n delay(1300L)\n\n //when\n job.cancel()\n\n //then cancel successfully\n }\n}","type":"blockquote","key":"rbm4"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":45,"offset":23,"style":"BOLD"},{"length":8,"offset":136,"style":"ITALIC"},{"length":5,"offset":154,"style":"ITALIC"}],"text":"Это очень элегантный и простой способ использования механизма отмены . В асинхронном действии нам нужно только проверить, равен ли флаг isActive значению false , и отменить нашу обработку.","type":"unstyled","key":"fgoh9"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Когда мы запрашиваем некоторую обработку и не уверены, сколько времени займет это вычисление, рекомендуется установить тайм-аут для такого действия. Если обработка не завершится в течение заданного таймаута, мы получим исключение и сможем отреагировать на него соответствующим образом.","type":"unstyled","key":"u7af"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Например, мы можем повторить действие:","type":"unstyled","key":"7eg9s"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"@Test(expected = CancellationException::class)\nfun givenAsyncAction_whenDeclareTimeout_thenShouldFinishWhenTimedOut() {\n runBlocking {\n withTimeout(1300L) {\n repeat(1000) { i ->\n println(\"Some expensive computation $i ...\")\n delay(500L)\n }\n }\n }\n}","type":"blockquote","key":"9oa5l"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Если мы не определим тайм-аут, возможно, что наш поток будет заблокирован навсегда из-за зависания вычислений. Мы не сможем обработать этот случай в нашем коде, если тайм-аут не определен.","type":"unstyled","key":"7rb69"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":48,"offset":0,"style":"BOLD"}],"text":"7. Одновременное выполнение асинхронных действий","type":"header-two","key":"aj7l6"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"unstyled","key":"34bp2"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Допустим, нам нужно одновременно запустить два асинхронных действия и потом дождаться их результатов. Если наша обработка занимает одну секунду и нам нужно выполнить эту обработку дважды, время выполнения синхронного выполнения блокировки составит две секунды.","type":"unstyled","key":"3aptk"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Было бы лучше, если бы мы могли запускать оба этих действия в отдельных потоках и ждать результатов в основном потоке.","type":"unstyled","key":"1ces4"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":51,"offset":0,"style":"BOLD"},{"length":7,"offset":44,"style":"ITALIC"}],"text":"Для этого мы можем использовать сопрограмму async() , начав обработку в двух отдельных потоках одновременно:","type":"unstyled","key":"fcacs"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"@Test\nfun givenHaveTwoExpensiveAction_whenExecuteThemAsync_thenTheyShouldRunConcurrently() {\n runBlocking {\n val delay = 1000L\n val time = measureTimeMillis {\n //given\n val one = async(Dispatchers.Default) { someExpensiveComputation(delay) }\n val two = async(Dispatchers.Default) { someExpensiveComputation(delay) }\n\n //when\n runBlocking {\n one.await()\n two.await()\n }\n }\n\n //then\n assertTrue(time < delay * 2)\n }\n}","type":"blockquote","key":"86rik"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":13,"offset":105,"style":"ITALIC"},{"length":4,"offset":143,"style":"ITALIC"},{"length":3,"offset":150,"style":"ITALIC"}],"text":"После того как мы отправим два дорогостоящих вычисления, мы приостанавливаем сопрограмму, выполнив вызов runBlocking() . Как только результаты один и два будут доступны, сопрограмма возобновит работу и вернет результаты. Выполнение двух задач таким образом должно занять около одной секунды.","type":"unstyled","key":"4f32o"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":19,"offset":18,"style":"ITALIC"},{"length":7,"offset":74,"style":"ITALIC"},{"length":11,"offset":243,"style":"ITALIC"},{"length":11,"offset":281,"style":"ITALIC"},{"length":12,"offset":332,"style":"ITALIC"}],"text":"Мы можем передать CoroutineStart.LAZY в качестве второго аргумента метода async() , но это будет означать, что асинхронные вычисления не будут запущены до тех пор, пока они не будут запрошены. Поскольку мы запрашиваем вычисления в сопрограмме runBlocking , это означает, что вызов two.await() будет выполнен только после завершения one.await():","type":"unstyled","key":"3fvm5"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"fun givenTwoExpensiveAction_whenExecuteThemLazy_thenTheyShouldNotConcurrently() {\n runBlocking {\n val delay = 1000L\n val time = measureTimeMillis {\n //given\n val one = async(Dispatchers.Default, CoroutineStart.LAZY) { someExpensiveComputation(delay) }\n val two = async(Dispatchers.Default, CoroutineStart.LAZY) { someExpensiveComputation(delay) }\n\n //when\n runBlocking {\n one.await()\n two.await()\n }\n }\n\n //then\n assertTrue(time > delay * 2)\n }\n}","type":"blockquote","key":"dk96e"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":97,"offset":0,"style":"BOLD"},{"length":7,"offset":142,"style":"ITALIC"},{"length":6,"offset":206,"style":"ITALIC"},{"length":14,"offset":232,"style":"ITALIC"}],"text":"Ленивое выполнение в этом конкретном примере приводит к тому, что наш код выполняется синхронно. Это происходит потому, что когда мы вызываем await() , основной поток блокируется, и только после завершения первой задачи запускается вторая задача.","type":"unstyled","key":"19iba"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Нам необходимо помнить о ленивом выполнении асинхронных действий, поскольку они могут выполняться блокирующим образом.","type":"unstyled","key":"605c5"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":13,"offset":0,"style":"BOLD"}],"text":"8. Заключение","type":"header-two","key":"7eqfi"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"unstyled","key":"5f99a"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"В этой статье мы рассмотрели основы сопрограмм Kotlin.","type":"unstyled","key":"66m5n"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":18,"offset":15,"style":"ITALIC"}],"text":"Мы видели, что последовательность является основным строительным блоком каждой сопрограммы. Мы описали, как выглядит поток выполнения в этом стиле программирования с передачей продолжения.","type":"unstyled","key":"12luf"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":18,"offset":35,"style":"ITALIC"}],"text":"Наконец, мы рассмотрели библиотеку kotlinx-coroutines , которая содержит множество очень полезных конструкций для создания асинхронных программ.","type":"unstyled","key":"8vs7q"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"unstyled","key":"5uh5d"},{"data":{},"depth":0,"entityRanges":[{"key":2,"length":42,"offset":17}],"inlineStyleRanges":[],"text":"Оригинал статьи: https://www.baeldung.com/kotlin/coroutines","type":"unstyled","key":"286nh"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"marker","key":"EQDQSPzd9cslMR0qx8Ce"}],"entityMap":{"0":{"data":{"href":"https://en.wikipedia.org/wiki/Continuation-passing_style","url":"https://en.wikipedia.org/wiki/Continuation-passing_style"},"mutability":"MUTABLE","type":"LINK"},"1":{"data":{"href":"https://kotlinlang.org/docs/reference/coroutines/composing-suspending-functions.html","url":"https://kotlinlang.org/docs/reference/coroutines/composing-suspending-functions.html"},"mutability":"MUTABLE","type":"LINK"},"2":{"data":{"url":"https://www.baeldung.com/kotlin/coroutines"},"mutability":"MUTABLE","type":"LINK"}}},"mentions":[]}