Kotlin コルーチンの同時実行性/並列および直列切り替え、CoroutineScope および await

import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import java.time.LocalTime

fun main(args: Array<String>) {
    println("${LocalTime.now()} - main start")

    CoroutineScope(Dispatchers.Default).launch {
        // 并发执行
        this.launch {
            println("${LocalTime.now()} A start")
            delay(1000)
            println("${LocalTime.now()} A end")
        }

        this.launch {
            println("${LocalTime.now()} B start")
            delay(1500)
            println("${LocalTime.now()} B end")
        }
    }

    println("${LocalTime.now()} - main end")
}

出力は、メイン終了後に A と B に出力がないことが示されています。CoroutineScope(Dispatchers.IO).launch 新しいタスクは、メインの main タスクの実行プロセスをブロックしません。

runBlocking(Dispatchers.IO) に変更した場合:

import kotlinx.coroutines.*
import java.time.LocalTime

fun main(args: Array<String>) {
    println("${LocalTime.now()} - main start")

    runBlocking(Dispatchers.IO) {
        // 并发执行
        this.launch {
            println("${LocalTime.now()} A start")
            delay(1000)
            println("${LocalTime.now()} A end")
        }

        this.launch {
            println("${LocalTime.now()} B start")
            delay(1500)
            println("${LocalTime.now()} B end")
        }
    }

    println("${LocalTime.now()} - main end")
}

非同期を見てください

import kotlinx.coroutines.*
import java.time.LocalTime

fun main(args: Array<String>) {
    println("${LocalTime.now()} - main start")

    CoroutineScope(Dispatchers.IO).launch() {
        // 并发执行
        this.async {
            println("${LocalTime.now()} A start")
            delay(1000)
            println("${LocalTime.now()} A end")
        }

        this.async {
            println("${LocalTime.now()} B start")
            delay(1500)
            println("${LocalTime.now()} B end")
        }
    }

    println("${LocalTime.now()} - main end")
}

メインスレッドが 1000 ミリ秒休止した場合:

import kotlinx.coroutines.*
import java.time.LocalTime

fun main(args: Array<String>) {
    println("${LocalTime.now()} - main start")

    CoroutineScope(Dispatchers.IO).launch() {
        // 并发执行
        this.async {
            println("${LocalTime.now()} A start")
            delay(1000)
            println("${LocalTime.now()} A end")
        }

        this.async {
            println("${LocalTime.now()} B start")
            delay(1500)
            println("${LocalTime.now()} B end")
        }
    }

    Thread.sleep(1000)
    println("${LocalTime.now()} - main end")
}

import kotlinx.coroutines.*
import java.time.LocalTime

fun main(args: Array<String>) {
    println("${LocalTime.now()} - main start")

    runBlocking {
        CoroutineScope(Dispatchers.IO).launch() {
            val task1 = this.async {
                println("${LocalTime.now()} A start")
                delay(1000)
                println("${LocalTime.now()} A end")

                "task1 return"
            }

            val task2 = this.async {
                println("${LocalTime.now()} B start")
                delay(1500)
                println("${LocalTime.now()} B end")

                "task2 return"
            }

            val t1 = task1.await()
            println("${LocalTime.now()} $t1")

            val t2 = task2.await()
            println("${LocalTime.now()} $t2")
        }
    }

    println("${LocalTime.now()} - main end")
}

一般に、CoroutineScope(Dispatchers.IO).launch() の重要性は、メインのメインスレッドをブロックせずに新しいスレッドを開始することです。

理解して待ってください

import kotlinx.coroutines.*
import java.time.LocalTime

fun main(args: Array<String>) {
    println("${LocalTime.now()} - main start")

    runBlocking {
        //launch() {
            val task1 = this.async {
                println("${LocalTime.now()} A start")
                delay(3000)
                println("${LocalTime.now()} A end")

                "task1 return"
            }

            val task2 = this.async {
                println("${LocalTime.now()} B start")
                delay(1000)
                println("${LocalTime.now()} B end")

                "task2 return"
            }

            val t1 = task1.await()
            println("${LocalTime.now()} $t1")

            val t2 = task2.await()
            println("${LocalTime.now()} $t2")
        //}
    }

    println("${LocalTime.now()} - main end")
}

task2 はすぐに完了しますが、await があるため、task1 が戻るまで待つ必要があります。

kotlin コルーチン async と await_zhangphil のブログ - CSDN ブログrunBlocking は、時間のかかる操作を行うために内部的に 3 つのコルーチンを開始します。出力から、3 つのコルーチンが同時に実行されていることがわかります。RunBlocking は、3 つのコルーチンの実行が完了するまで待機します。出力結果には明確な順序があります。一般的なプログラミング手法、たとえば Android では、関数がメインスレッドに実装されているとしますが、この関数は時間のかかる操作であり、この関数の実装を非メインスレッドに分割する必要があることは間違いありません。操作のために、マネージド関数内でダーティな作業を実行し、処理が完了した後に結果をメインスレッドにスローするマネージド関数を設計できます。結果 1-a: 5 - tid: 22。結果 1-b: 5 - tid: 24。結果 2-a: 9 - tid: 22。https://blog.csdn.net/zhangphil/article/details/129268399

https://zhangphil.blog.csdn.net/article/details/129265638 https://zhangphil.blog.csdn.net/article/details/129265638

Kotlin コルーチン、スレッド切り替え、関数メソッドtrustment_zhangphil のブログ - CSDN ブログrunBlocking は時間のかかる操作を実行するために 3 つのコルーチンを内部的に開始します。出力から、3 つのコルーチンが相互に並行して実行されていることがわかります。runBlocking は 3 つのコルーチンが終了するまで待機します。実行が完了し、出力結果には明確な順序があります。一般的なプログラミング手法、たとえば Android では、関数がメインスレッドに実装されているとしますが、この関数は時間のかかる操作であり、この関数の実装を非メインスレッドに分割する必要があることは間違いありません。操作のために、マネージド関数内でダーティな作業を実行し、処理が完了した後に結果をメインスレッドにスローするマネージド関数を設計できます。結果 1-a: 5 - tid: 22。結果 1-b: 5 - tid: 24。結果 2-a: 9 - tid: 22。https://blog.csdn.net/zhangphil/article/details/130161705

https://zhangphil.blog.csdn.net/article/details/129250518 https://zhangphil.blog.csdn.net/article/details/129250518

Kotlin コルーチンの同時実行性/並列および直列切り替え、CoroutineScope および await

おすすめ