Різниця між ниткою та спільною програмою в Котліні

Question 1

Чи існує якась конкретна мовна реалізація в Котліні, яка відрізняє її від інших мовних програм?

Що означає, що співучасть подібна легкій нитці?
Яка різниця?
Чи насправді програми kotlin працюють паралельно / одночасно?
Навіть у багатоядерній системі в будь-який момент часу працює лише одна програма (чи правильно?)

Ось я починаю 100000 підпрограм, що відбувається за цим кодом?

for(i in 0..100000){
   async(CommonPool){
    //run long running operations
  }
}

Question 2

Оскільки я використовував підпрограми лише на JVM, я буду говорити про бекенд JVM, є також Kotlin Native та Kotlin JavaScript, але ці серверні програми для Kotlin виходять за межі мого обсягу.

Отже, почнемо з порівняння котлінських програм Котліна та інших мов. По суті, ви повинні знати, що існує два типи корутинів: безстаровий і штабельний. Kotlin реалізує безпроблемні програми - це означає, що програма не має власного стеку, і це трохи обмежує можливості, які може зробити програма. Ви можете прочитати хороше пояснення тут .

Приклади:

Бездоганні: C #, Scala, Kotlin
Складені: Quasar, Javaflow

Що це означає, що програма є схожою на легку нитку?

Це означає, що програма в Kotlin не має власного стека, вона не відображається у власному потоці, не вимагає перемикання контексту на процесорі.

Яка різниця?

Потік - попереджувально багатозадачність. ( зазвичай ). Coroutine - спільна багатозадачність.

Потік - управляється ОС (зазвичай). Coroutine - керується користувачем.

Чи насправді програми Kotlin працюють паралельно / одночасно?

Це залежить, ви можете запустити кожну підпрограму у своєму потоці, або ви можете запустити всі підпрограми в одному потоці або якомусь фіксованому пулі потоків.

Детальніше про те, як виконуються програми тут .

Навіть у багатоядерній системі в будь-який момент часу працює лише одна програма (чи правильно?)

Ні, див. Попередню відповідь.

Ось я починаю 100000 підпрограм, що відбувається за цим кодом?

Насправді це залежить. Але припустимо, що ви пишете такий код:

fun main(args: Array<String>) {
    for (i in 0..100000) {
        async(CommonPool) {
            delay(1000)
        }
    }
}

Цей код виконується миттєво.

Тому що нам потрібно почекати результатів asyncдзвінка.

Тож давайте виправимо це:

fun main(args: Array<String>) = runBlocking {
    for (i in 0..100000) {
        val job = async(CommonPool) {
            delay(1)
            println(i)
        }

        job.join()
    }
}

Під час запуску цієї програми kotlin створить 2 * 100000 екземплярів Continuation, що займе кілька десятків Мб оперативної пам'яті, а в консолі ви побачите цифри від 1 до 100000.

Тож давайте перепишемо цей код таким чином:

fun main(args: Array<String>) = runBlocking {

    val job = async(CommonPool) {
        for (i in 0..100000) {
            delay(1)
            println(i)
        }
    }

    job.join()
}

Чого ми зараз досягаємо? Зараз ми створюємо лише 100001 екземплярів Continuation, і це набагато краще.

Кожне створене Продовження буде відправлене та виконане на CommonPool (який є статичним екземпляром ForkJoinPool).

Question 3

Що означає, що співучасть подібна легкій нитці?

Спільна програма, як і нитка, являє собою послідовність дій, що виконуються одночасно з іншими підпрограмами (потоками).

Яка різниця?

Потік безпосередньо пов’язаний із власним потоком у відповідній ОС (операційна система) і споживає значну кількість ресурсів. Зокрема, він споживає багато пам'яті для свого стека. Ось чому ви не можете просто створити 100k потоків. Ймовірно, у вас закінчиться пам’ять. Переключення між потоками включає диспетчер ядра ОС, і це досить дорога операція з точки зору споживаних циклів процесора.

З іншого боку, корутина - це суто абстракція мови на рівні користувача. Він не пов’язує жодних власних ресурсів і, у найпростішому випадку, використовує лише один відносно невеликий об’єкт у купі JVM. Ось чому легко створити 100 тис. Програм. Переключення між програмами взагалі не передбачає ядра ОС. Це може бути настільки дешево, як виклик звичайної функції.

Чи насправді програми Kotlin працюють паралельно / одночасно? Навіть у багатоядерній системі в будь-який момент часу працює лише одна програма (чи правильно?)

Програма може бути як запущеною, так і призупиненою. Призупинена програма не пов'язана з яким-небудь конкретним потоком, але запущена програма працює на якомусь потоці (використання потоку - єдиний спосіб виконати що-небудь усередині процесу ОС). Чи всі різні програми працюють в одному потоці (а, отже, можуть використовувати лише один процесор у багатоядерній системі), або в різних потоках (і, отже, можуть використовувати кілька центральних процесорів), виключно в руках програміста, який використовує програми.

У Котліні розподіл спільних програм контролюється за допомогою відповідного контексту . Детальніше про це ви можете прочитати у Керівництві по kotlinx.coroutines

Ось я починаю 100000 підпрограм, що відбувається за цим кодом?

Припускаючи, що ви використовуєте launchфункцію та CommonPoolконтекст з kotlinx.coroutinesпроекту (який є відкритим кодом), ви можете вивчити їх вихідний код тут:

launchвизначається тут https://github.com/Kotlin/kotlinx.coroutines/blob/master/core/kotlinx-coroutines-core/src/main/kotlin/kotlinx/coroutines/experimental/Builders.kt
CommonPoolвизначається тут https://github.com/Kotlin/kotlinx.coroutines/blob/master/core/kotlinx-coroutines-core/src/main/kotlin/kotlinx/coroutines/experimental/CommonPool.kt

launchПросто створює нову співпрограми, а CommonPoolдепеші співпрограми , ForkJoinPool.commonPool()який робить використання декількох потоків і , таким чином , виконуються на декількох процесорах в цьому прикладі.

Код, що слідує за launchвикликом у {...}, називається призупиненою лямбда . Що це і як суспендуючі лямбда і функції реалізовані (укладач), а також стандартні бібліотечні функції і класи , як startCoroutines, suspendCoroutineі CoroutineContextпояснюється в відповідному Котлин співпрограми дизайн документа .