Kotlinで非同期タスクの順序を制御する方法を完全解説

import kotlinx.coroutines.*

fun main() {
    GlobalScope.launch {
        delay(1000L)  // 1秒待機（非ブロッキング）
        println("Hello, World!")
    }
    println("Non-blocking execution")
    Thread.sleep(2000L)  // プログラムが終了しないように2秒待機
}

Non-blocking execution
Hello, World!

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        delay(1000L)
        println("Task with launch completed")
    }
    println("Main thread is not blocked")
}

Main thread is not blocked
Task with launch completed

import kotlinx.coroutines.*

fun main() = runBlocking {
    val result = async {
        delay(1000L)
        42  // 戻り値
    }
    println("The result is ${result.await()}")
}

The result is 42

import kotlinx.coroutines.*

fun main() = runBlocking {
    val deferred1 = async { task1() }
    val deferred2 = async { task2() }

    launch {
        println("Task1 result: ${deferred1.await()}")
        println("Task2 result: ${deferred2.await()}")
    }
}

suspend fun task1(): String {
    delay(1000L)
    return "Task 1 completed"
}

suspend fun task2(): String {
    delay(1500L)
    return "Task 2 completed"
}

Task1 result: Task 1 completed
Task2 result: Task 2 completed

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        println("Task 1 started")
        delay(1000L)
        println("Task 1 completed")

        println("Task 2 started")
        delay(500L)
        println("Task 2 completed")
    }
}

Task 1 started
Task 1 completed
Task 2 started
Task 2 completed

import kotlinx.coroutines.*

fun main() = runBlocking {
    val result1 = async {
        delay(1000L)
        "Result 1"
    }

    val result2 = async {
        delay(500L)
        "Result 2"
    }

    println(result1.await())  // Result 1を待つ
    println(result2.await())  // Result 2を待つ
}

Result 1
Result 2

import kotlinx.coroutines.*

fun main() = runBlocking {
    withContext(Dispatchers.IO) {
        println("Task 1 started on IO thread")
        delay(1000L)
        println("Task 1 completed")
    }

    withContext(Dispatchers.Default) {
        println("Task 2 started on Default thread")
        delay(500L)
        println("Task 2 completed")
    }
}

Task 1 started on IO thread
Task 1 completed
Task 2 started on Default thread
Task 2 completed

import kotlinx.coroutines.*

fun main() = runBlocking {
    val deferred1 = async { task1() }
    val deferred2 = async { task2() }

    println("Waiting for both tasks to complete...")
    println(deferred1.await())
    println(deferred2.await())
}

suspend fun task1(): String {
    delay(1000L)
    return "Task 1 finished"
}

suspend fun task2(): String {
    delay(500L)
    return "Task 2 finished"
}

Waiting for both tasks to complete...
Task 1 finished
Task 2 finished

withContext(ディスパッチャー) {
    // ここに実行したい処理を書く
}

import kotlinx.coroutines.*

fun main() = runBlocking {
    println("Main thread starts")

    withContext(Dispatchers.IO) {
        println("Starting I/O task on thread: ${Thread.currentThread().name}")
        delay(1000L)  // 模擬的なI/O操作
        println("I/O task completed")
    }

    withContext(Dispatchers.Default) {
        println("Starting computation on thread: ${Thread.currentThread().name}")
        val result = heavyComputation()
        println("Computation result: $result")
    }

    println("Main thread ends")
}

suspend fun heavyComputation(): Int {
    delay(500L)  // 模擬的な計算処理
    return 42
}

Main thread starts
Starting I/O task on thread: DefaultDispatcher-worker-1
I/O task completed
Starting computation on thread: DefaultDispatcher-worker-2
Computation result: 42
Main thread ends

import kotlinx.coroutines.*

fun main() = runBlocking {
    try {
        withContext(Dispatchers.IO) {
            println("Starting risky task")
            throw Exception("Something went wrong!")
        }
    } catch (e: Exception) {
        println("Caught an error: ${e.message}")
    }
}

Starting risky task
Caught an error: Something went wrong!

import kotlinx.coroutines.*

fun main() = runBlocking {
    val result1 = async { task1() }.await()
    val result2 = async { task2(result1) }.await()
    println("Final Result: $result2")
}

suspend fun task1(): String {
    delay(1000L)
    println("Task 1 completed")
    return "Result from Task 1"
}

suspend fun task2(input: String): String {
    delay(500L)
    println("Task 2 completed with input: $input")
    return "Result from Task 2"
}

Task 1 completed
Task 2 completed with input: Result from Task 1
Final Result: Result from Task 2

import kotlinx.coroutines.*

fun main() = runBlocking {
    val result = task1()
        .let { task2(it) }
        .let { task3(it) }

    println("Final Result: $result")
}

suspend fun task1(): String {
    delay(1000L)
    println("Task 1 completed")
    return "Result 1"
}

suspend fun task2(input: String): String {
    delay(500L)
    println("Task 2 completed with input: $input")
    return "Result 2"
}

suspend fun task3(input: String): String {
    delay(300L)
    println("Task 3 completed with input: $input")
    return "Result 3"
}

Task 1 completed
Task 2 completed with input: Result 1
Task 3 completed with input: Result 2
Final Result: Result 3

import kotlinx.coroutines.*

fun main() = runBlocking {
    try {
        val result = task1()
            .let { taskWithError(it) }
            .let { task3(it) }

        println("Final Result: $result")
    } catch (e: Exception) {
        println("Error occurred: ${e.message}")
    }
}

suspend fun task1(): String {
    delay(1000L)
    println("Task 1 completed")
    return "Result 1"
}

suspend fun taskWithError(input: String): String {
    delay(500L)
    throw Exception("Something went wrong in Task 2")
}

suspend fun task3(input: String): String {
    delay(300L)
    println("Task 3 completed with input: $input")
    return "Result 3"
}

Task 1 completed
Error occurred: Something went wrong in Task 2

import kotlinx.coroutines.*

fun main() = runBlocking {
    try {
        val result = async {
            riskyTask()
        }.await()
        println("Task result: $result")
    } catch (e: Exception) {
        println("Caught an error: ${e.message}")
    }
}

suspend fun riskyTask(): String {
    delay(1000L)
    throw Exception("Something went wrong in the task!")
}

Caught an error: Something went wrong in the task!

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        try {
            riskyTask()
        } catch (e: Exception) {
            println("Caught an error in launch: ${e.message}")
        }
    }
    delay(1500L)  // タスクが完了するまで待機
}

suspend fun riskyTask() {
    delay(1000L)
    throw Exception("Error in launch task!")
}

Caught an error in launch: Error in launch task!

import kotlinx.coroutines.*

fun main() = runBlocking {
    val supervisor = SupervisorJob()

    val scope = CoroutineScope(coroutineContext + supervisor)

    scope.launch {
        try {
            delay(500L)
            throw Exception("Task 1 failed")
        } catch (e: Exception) {
            println("Caught error in Task 1: ${e.message}")
        }
    }

    scope.launch {
        delay(1000L)
        println("Task 2 completed successfully")
    }

    delay(1500L)  // 全てのタスクが完了するまで待機
}

Caught error in Task 1: Task 1 failed
Task 2 completed successfully

import kotlinx.coroutines.*
import kotlin.coroutines.CoroutineContext

fun main() = runBlocking {
    val exceptionHandler = CoroutineExceptionHandler { _, exception ->
        println("Caught exception globally: ${exception.message}")
    }

    val scope = CoroutineScope(Job() + exceptionHandler)

    scope.launch {
        throw Exception("Unhandled error in coroutine!")
    }

    delay(1000L)  // ハンドラが動作するまで待機
}

Caught exception globally: Unhandled error in coroutine!

import kotlinx.coroutines.*
import java.net.URL

fun main() = runBlocking {
    val result = fetchDataFromNetwork()
    println("Data received: $result")
}

suspend fun fetchDataFromNetwork(): String {
    return withContext(Dispatchers.IO) {
        println("Fetching data from network...")
        delay(2000L)  // 模擬的なネットワーク遅延
        "Sample Data from API"
    }
}

Fetching data from network...
Data received: Sample Data from API

import kotlinx.coroutines.*

fun main() = runBlocking {
    val data = readFromDatabase()
    val updatedData = updateDatabase(data)
    println("Updated Data: $updatedData")
}

suspend fun readFromDatabase(): String {
    return withContext(Dispatchers.IO) {
        println("Reading data from database...")
        delay(1000L)
        "Initial Data"
    }
}

suspend fun updateDatabase(data: String): String {
    return withContext(Dispatchers.IO) {
        println("Updating database with: $data")
        delay(500L)
        "$data - Updated"
    }
}

Reading data from database...
Updating database with: Initial Data
Updated Data: Initial Data - Updated

import kotlinx.coroutines.*
import java.io.File

fun main() = runBlocking {
    val content = readFile("input.txt")
    writeFile("output.txt", content)
    println("File processing completed.")
}

suspend fun readFile(fileName: String): String {
    return withContext(Dispatchers.IO) {
        println("Reading from $fileName...")
        delay(1000L)  // 模擬的なファイル読み取りの遅延
        "File Content"
    }
}

suspend fun writeFile(fileName: String, content: String) {
    withContext(Dispatchers.IO) {
        println("Writing to $fileName with content: $content")
        delay(1000L)  // 模擬的なファイル書き込みの遅延
    }
}

Reading from input.txt...
Writing to output.txt with content: File Content
File processing completed.

import kotlinx.coroutines.*

fun main() = runBlocking {
    val deferred1 = async { task1() }
    val deferred2 = async { task2() }

    println("Waiting for tasks to complete...")
    println(deferred1.await())
    println(deferred2.await())
}

suspend fun task1(): String {
    delay(1000L)
    return "Task 1 completed"
}

suspend fun task2(): String {
    delay(1500L)
    return "Task 2 completed"
}

Waiting for tasks to complete...
Task 1 completed
Task 2 completed