Kotlinでプロパティをスレッド安全に操作する方法を徹底解説

Kotlinでマルチスレッド環境下においてデータやプロパティを安全に管理することは、プログラムの安定性や信頼性を高めるために不可欠です。特に複数のスレッドが同一のプロパティにアクセスする場合、競合状態（Race Condition）やデータ破壊が発生するリスクが高まります。

本記事では、Kotlinを使ってプロパティをスレッド安全に操作するための方法について解説します。基本的なスレッド安全性の概念から、@Synchronizedやsynchronizedブロック、Atomicクラスの活用、Kotlin Coroutinesを用いたデータ管理、さらにはLazy初期化のオプションや応用例まで、具体的な実装方法をコード例とともに紹介します。

これにより、Kotlinでのマルチスレッドプログラミングにおけるスレッド安全なプロパティ管理を習得し、より安全で効率的なアプリケーション開発が可能になります。

スレッド安全性とは何か

スレッド安全性とは、複数のスレッドが同じデータやリソースに同時アクセスしても、プログラムの動作が一貫して正しく保たれる性質を指します。スレッド安全性が確保されていない場合、データの不整合や予期しない動作が発生し、深刻なバグやシステムクラッシュにつながる可能性があります。

スレッド安全性が必要な理由

マルチスレッドプログラミングにおいては、複数のスレッドが並行して実行されるため、同じプロパティやデータを同時に更新すると競合状態（Race Condition）が発生することがあります。具体的なリスクとして以下の点が挙げられます：

• データの不整合：複数スレッドによる書き込み競合で値が破壊される。
• 予期しない動作：読み取り中に他スレッドが値を変更し、不正な状態になる。
• パフォーマンス低下：適切な制御がないと、データ競合で処理が遅延する。

シングルスレッドとマルチスレッドの違い

• シングルスレッド：1つのスレッドが順番に処理を行うため、データの競合が発生しません。
• マルチスレッド：複数スレッドが同時に動作し、共有データへのアクセス管理が必要です。

スレッド安全性の例

例えば、以下のコードはマルチスレッド環境で問題を引き起こす可能性があります。

var counter = 0

fun increment() {
    counter++
}

複数のスレッドがincrement関数を同時に呼び出すと、counterの値が正しく増加しないことがあります。これは、counterの読み取りと書き込みが複数スレッドで競合するためです。

スレッド安全性を確保する目的

スレッド安全性を確保することで、以下の利点が得られます：

• データの一貫性を保つ
• プログラムの予測可能な動作を保証する
• バグの発生を防ぎ、安定したシステムを提供する

Kotlinでは、これらの問題を解決するための機能やテクニックが豊富に用意されています。次のセクションでは、Kotlinにおけるスレッド安全性の問題例とその対策方法について詳しく見ていきます。

Kotlinで発生するスレッド安全性の問題例

マルチスレッド環境下では、複数のスレッドが同時にプロパティやデータにアクセスすることで、競合状態（Race Condition）やデータの不整合が発生します。Kotlinでも、スレッド安全性を考慮しないと以下のような問題が起こる可能性があります。

データ競合（Race Condition）の発生

複数のスレッドが同時に1つの変数を読み書きする際に、データの一貫性が保たれなくなる状態をデータ競合と呼びます。例えば、以下のコードではcounterの値が正しく更新されません。

var counter = 0

fun increment() {
    counter++ // 同時アクセスによる競合
}

• 複数のスレッドがcounterを同時にインクリメントする場合、読み取りと書き込みのタイミングが重なり、結果として一部の加算操作が無視されることがあります。

不正な状態（Inconsistent State）の発生

オブジェクトの状態が不完全なまま他のスレッドに読み取られることで、不正な状態が発生することがあります。例えば、次のコードのように、オブジェクトの初期化が複数スレッドから行われた場合、未完全な状態でアクセスされる可能性があります。

class SharedResource {
    var data: String? = null
}

val resource = SharedResource()

fun updateResource() {
    resource.data = "Updated"
}

上記のresourceオブジェクトに別スレッドが同時アクセスした場合、dataの更新が不完全なまま他のスレッドに読み取られ、プログラムの動作に影響を与えることがあります。

遅延初期化（Lazy Initialization）による競合

Kotlinでは遅延初期化にlazyを使用できますが、デフォルト設定ではスレッド安全です。しかし、LazyThreadSafetyMode.NONEを指定するとスレッド安全性は保証されません。

val lazyValue: String by lazy(LazyThreadSafetyMode.NONE) {
    println("Lazy Initialization")
    "Initialized"
}

• 複数のスレッドがlazyValueに同時アクセスすると、初期化が複数回実行される可能性があります。

問題の影響

Kotlinでスレッド安全性を考慮しないと、以下の問題が発生します：

• 予測不可能な動作：プログラムの実行結果が異なる。
• データ破壊：共有データが不正な状態になる。
• デバッグ困難：並行処理の問題は再現しにくく、修正が難しい。

これらの問題を解決するためには、Kotlinに備わっているスレッド安全を実現する機能を適切に活用する必要があります。次のセクションでは、基本的な解決方法について詳しく解説します。

スレッド安全を実現する基本的な方法

Kotlinでスレッド安全性を確保するためには、いくつかの基本的なアプローチがあります。ここでは、@Synchronizedアノテーションやvolatileキーワードを活用する方法について解説します。

@Synchronizedアノテーション

Kotlinでは、@Synchronizedアノテーションを使用することで、メソッドや関数を同期化し、同時実行を防ぐことができます。これにより、複数のスレッドが同じメソッドを同時に実行することを防ぎ、データの競合を回避できます。

var counter = 0

@Synchronized
fun increment() {
    counter++
}

• 仕組み：@Synchronizedを付与したメソッドは、単一のスレッドのみがアクセス可能になります。
• 注意点：同期化によってパフォーマンスが低下することがあるため、必要な範囲にのみ使用することが重要です。

volatileキーワード

volatileは、変数をメインメモリに直接読み書きするよう指示するキーワードです。これにより、複数のスレッドが変数を共有する際に、キャッシュによる値の不一致を防ぎます。

@Volatile
var isRunning = true

fun stop() {
    isRunning = false
}

• 仕組み：@Volatileを付けた変数は、スレッドがキャッシュせず、常にメインメモリから最新の値を読み取るようになります。
• 使用場面：フラグのようなシンプルな変数の同期に適していますが、複雑な操作には不向きです。

synchronizedブロックの利用

@Synchronizedがメソッド全体をロックするのに対し、synchronizedブロックを使用すれば特定のコードブロックのみを同期化できます。

var counter = 0
val lock = Any()

fun increment() {
    synchronized(lock) {
        counter++
    }
}

• 仕組み：synchronized(lock)を使用することで、指定したオブジェクト（lock）に対してロックを取得します。
• 利点：必要最小限の範囲を同期化するため、パフォーマンスへの影響を抑えられます。

基本的なスレッド安全性の選択指針

• データが単純な場合：@Volatileを使用する。
• メソッド全体を同期する場合：@Synchronizedを使用する。
• 限定的な範囲の同期化が必要な場合：synchronizedブロックを使用する。

これらの基本テクニックを使うことで、Kotlinにおけるスレッド安全性を実現し、データの不整合や競合状態を防ぐことができます。次のセクションでは、より高度なAtomicクラスの活用方法について紹介します。

synchronizedブロックの使い方

Kotlinにおけるsynchronizedブロックは、特定のコードブロックの排他制御（スレッド間でのアクセス制限）を行うための重要な機能です。共有リソースへの同時アクセスを防ぎ、データ競合や不整合を防止します。

synchronizedブロックの基本構文

KotlinではJavaのsynchronizedを直接利用できます。コードの一部を同期化し、複数のスレッドが同じデータにアクセスしないようにします。

val lock = Any() // 排他制御用のロックオブジェクト

var counter = 0

fun increment() {
    synchronized(lock) {
        counter++ // ロック内で安全にカウンタを更新
    }
}

• synchronized(lock)：ロックオブジェクトlockを使い、特定のスレッドのみがsynchronizedブロックにアクセスできるようにします。
• ロックオブジェクト：必ず1つのオブジェクトをロックとして指定し、全てのスレッドがそのオブジェクトを使用する必要があります。

なぜsynchronizedブロックが必要か

複数のスレッドが同時にデータにアクセスすると、予期しない不整合が発生します。synchronizedブロックを使用することで、次の問題を防ぐことができます：

• データの破壊：複数のスレッドが変数を書き換えることによる不整合。
• 競合状態：データ更新の順番が不確定になり、予期しない動作が発生する。

実用例：スレッド安全なカウンタ

以下は、複数スレッドで安全にカウンタを更新するサンプルです。

class SafeCounter {
    private val lock = Any()
    private var count = 0

    fun increment() {
        synchronized(lock) {
            count++
        }
    }

    fun getCount(): Int {
        synchronized(lock) {
            return count
        }
    }
}

fun main() {
    val counter = SafeCounter()
    val threads = List(100) {
        Thread {
            repeat(1000) {
                counter.increment()
            }
        }
    }

    threads.forEach { it.start() }
    threads.forEach { it.join() }

    println("Final count: ${counter.getCount()}")
}

出力例

Final count: 100000

• 解説：
  • synchronizedブロックでcountの読み書きを保護することで、複数スレッドによる競合を回避しています。
  • 100個のスレッドがそれぞれ1000回incrementを呼び出し、最終的に正しいカウント数（100,000）が得られます。

注意点とベストプラクティス

• ロックオブジェクトの一貫性：異なるロックオブジェクトを使用すると、排他制御が機能しないため注意が必要です。
• 最小限の同期範囲：同期化範囲を必要最小限にすることで、パフォーマンス低下を防ぎます。
• デッドロック防止：複数のロックを使用する場合、取得順序を一貫させることでデッドロックを回避します。

まとめ

synchronizedブロックは、Kotlinで安全に共有リソースにアクセスするための基本的な方法です。ロックオブジェクトを利用し、必要なコードのみを同期化することで、スレッド間の競合やデータ不整合を防ぎ、プログラムの安全性を向上させます。次のセクションでは、さらに効率的なAtomic型を使ったスレッド安全なデータ管理について解説します。

Atomic型を活用したスレッド安全な操作

KotlinではAtomic型を使用することで、低コストでスレッド安全なデータ操作を実現できます。Atomic型はJavaのjava.util.concurrent.atomicパッケージを基盤としており、ロックを使用せずにデータの一貫性を保つことが可能です。

Atomic型とは何か

Atomic型は、特定のデータ型に対する操作をアトミック（分割不可能な操作）として提供します。これにより、複数スレッドが同時に操作しても競合状態が発生しません。

主なAtomic型の種類は以下の通りです：

• AtomicInteger：整数のアトミック操作
• AtomicLong：長整数のアトミック操作
• AtomicBoolean：ブール値のアトミック操作
• AtomicReference：オブジェクト参照のアトミック操作

AtomicIntegerを用いた例

以下は、AtomicIntegerを使用してスレッド安全なカウンタを実装する例です。

import java.util.concurrent.atomic.AtomicInteger

class SafeCounter {
    private val counter = AtomicInteger(0)

    fun increment() {
        counter.incrementAndGet()
    }

    fun getCount(): Int {
        return counter.get()
    }
}

fun main() {
    val counter = SafeCounter()
    val threads = List(100) {
        Thread {
            repeat(1000) {
                counter.increment()
            }
        }
    }

    threads.forEach { it.start() }
    threads.forEach { it.join() }

    println("Final count: ${counter.getCount()}")
}

出力例

Final count: 100000

解説：

• incrementAndGet()メソッドは、カウンタの値をアトミックに1増加させます。
• AtomicIntegerを使用することで、競合状態を防ぎつつ効率的にカウンタを操作できます。

AtomicReferenceを用いた例

AtomicReferenceは、オブジェクト参照をアトミックに操作するためのクラスです。以下の例では、スレッド安全にオブジェクトの更新を行います。

import java.util.concurrent.atomic.AtomicReference

data class User(var name: String, var age: Int)

fun main() {
    val userRef = AtomicReference(User("Alice", 25))

    val threads = List(10) {
        Thread {
            repeat(100) {
                userRef.updateAndGet { currentUser ->
                    currentUser.copy(age = currentUser.age + 1)
                }
            }
        }
    }

    threads.forEach { it.start() }
    threads.forEach { it.join() }

    println("Final user state: ${userRef.get()}")
}

出力例

Final user state: User(name=Alice, age=1025)

解説：

• updateAndGet関数を使って、オブジェクトをアトミックに更新しています。
• データの一貫性が保たれ、競合状態を回避できます。

Atomic型を利用する利点

• 高速な処理：ロックを使用しないため、パフォーマンスが高い。
• 簡単な実装：複雑な同期ブロックを記述せずに済む。
• スレッド安全：アトミック操作により競合状態を防止する。

注意点

• 単一の変数にのみ有効：Atomic型は単一の変数操作をスレッド安全にするため、複数の変数や複雑な状態管理には適していません。
• 複雑な操作には不向き：Atomic型では加算や参照の変更など単純な操作のみサポートしています。

まとめ

Atomic型を活用することで、低コストかつ簡単にスレッド安全なデータ操作が実現できます。AtomicIntegerやAtomicReferenceは、Kotlinでマルチスレッド環境において高速なスレッド安全操作を提供します。次のセクションでは、Kotlin Coroutinesを利用した非同期かつ安全なデータ管理方法について解説します。

Kotlin Coroutinesでのスレッド安全なデータ操作

KotlinのCoroutinesは、非同期プログラミングをシンプルに実現する強力な機能です。従来のマルチスレッドプログラミングとは異なり、Coroutinesではスレッドを効率的に利用しながら安全にデータを操作できます。ここでは、スレッド安全性を保ちながらCoroutinesを活用する方法を解説します。

Coroutinesによる並行処理の特徴

• 軽量スレッド：Coroutinesはスレッドよりもはるかに軽量で、大量のタスクを効率的に並行実行できます。
• 状態管理：スレッド間で共有するデータを安全に操作する仕組みが提供されています。
• シンプルな構文：非同期コードを従来の同期コードのように書くことができます。

スレッド安全なデータ操作：Mutexの利用

Kotlinでは、Coroutines内でMutex（相互排他ロック）を使用することで、共有リソースへのアクセスをスレッド安全に制御できます。

import kotlinx.coroutines.*
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

var counter = 0
val mutex = Mutex() // 相互排他用のロック

suspend fun increment() {
    mutex.withLock {
        counter++ // Mutexで保護された安全な更新
    }
}

fun main() = runBlocking {
    val jobs = List(100) {
        launch {
            repeat(1000) {
                increment()
            }
        }
    }
    jobs.forEach { it.join() }

    println("Final counter value: $counter")
}

出力例

Final counter value: 100000

解説：

• Mutex：Mutexは複数のCoroutinesが同時にデータへアクセスすることを防ぎ、排他的なアクセスを提供します。
• withLock：withLock関数を使用することで、安全にデータを保護しながら操作できます。

スレッド安全な状態管理：StateFlowの活用

Kotlin CoroutinesのStateFlowを利用すると、状態の変化を安全に管理し、複数のコレクターが同時にデータを受け取ることができます。

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

val counterFlow = MutableStateFlow(0)

fun main() = runBlocking {
    val job = launch {
        counterFlow.collect { value ->
            println("Counter: $value")
        }
    }

    repeat(5) {
        counterFlow.value++ // スレッド安全に状態を更新
        delay(100)
    }

    job.cancel()
}

出力例

Counter: 1
Counter: 2
Counter: 3
Counter: 4
Counter: 5

解説：

• StateFlow：最新の状態を保持し、変更があるたびに新しい値を発行します。
• スレッド安全：StateFlowはスレッド安全に状態の更新を行い、複数のコレクターが同時にデータを監視できます。

スレッド安全なデータ操作の選択指針

• 排他的アクセスが必要な場合：Mutexを使用する。
• 状態管理が必要な場合：StateFlowまたはSharedFlowを使用する。
• データの一貫性が重要な場合：Coroutines内で適切にwithContextを使用し、特定のディスパッチャー上で安全に処理を行う。

まとめ

Kotlin Coroutinesを活用することで、非同期環境でもシンプルにスレッド安全なデータ操作が実現できます。Mutexを使用した排他制御やStateFlowによる状態管理は、共有データの競合や不整合を回避し、安全かつ効率的にデータを操作するための強力な手段です。次のセクションでは、Lazyプロパティのスレッド安全オプションについて解説します。

Lazyプロパティのスレッド安全オプション

Kotlinでは遅延初期化をサポートするために、lazy関数が提供されています。遅延初期化とは、プロパティが最初にアクセスされた時点で初期化される仕組みです。lazy関数には複数のスレッド安全オプションが用意されており、用途に応じて選択することができます。

Lazy関数の基本構文

lazy関数は、プロパティの初期化処理を簡単に記述できる便利な機能です。以下のように定義します：

val lazyValue: String by lazy {
    println("Initializing...")
    "Hello, World!"
}

fun main() {
    println(lazyValue) // 初回アクセス時に初期化
    println(lazyValue) // 2回目以降はキャッシュされた値を使用
}

出力例：

Initializing...
Hello, World!
Hello, World!

• 動作：最初にlazyValueがアクセスされた際に初期化され、それ以降はキャッシュされた値を返します。

LazyThreadSafetyModeの種類

lazy関数では、LazyThreadSafetyModeを使ってスレッド安全性を制御できます。オプションには以下の3つがあります。

1. SYNCHRONIZED（デフォルト）

スレッド安全に初期化を行います。複数のスレッドが同時にアクセスしても、一度だけ初期化が実行されます。

val lazyValue: String by lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
    println("Initializing...")
    "Thread Safe Value"
}

• 特徴：複数のスレッドからアクセスされても安全。
• 用途：スレッド安全性が必要な場合。

2. PUBLICATION

複数のスレッドが同時に初期化を試みることを許可しますが、最終的にどれか1つの結果が適用されます。

val lazyValue: String by lazy(LazyThreadSafetyMode.PUBLICATION) {
    println("Initializing...")
    "Published Value"
}

• 特徴：複数のスレッドで初期化が行われる可能性がありますが、最終的に1つの結果が保持されます。
• 用途：初期化処理が冪等（何度実行しても結果が同じ）である場合に適しています。

3. NONE

スレッド安全性を保証しません。シングルスレッド環境でのみ安全に利用できます。スレッド安全なロックを省略するため、パフォーマンスが最も高くなります。

val lazyValue: String by lazy(LazyThreadSafetyMode.NONE) {
    println("Initializing...")
    "Non Thread Safe Value"
}

• 特徴：スレッド安全ではないため、マルチスレッド環境で使用すると競合が発生する可能性があります。
• 用途：シングルスレッド環境または初期化が確実に単一スレッドから行われる場合。

LazyThreadSafetyModeの選択基準

用途に応じて以下の基準で選択します：

• SYNCHRONIZED：スレッド安全性が必要な場合（デフォルト）。
• PUBLICATION：初期化処理が冪等な場合。
• NONE：シングルスレッド環境やパフォーマンスを重視する場合。

実用例：LazyThreadSafetyModeの違い

以下のコードで3つのモードの動作を比較します：

import kotlinx.coroutines.*

fun main() = runBlocking {
    println("=== SYNCHRONIZED ===")
    val lazySync = lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
        println("Initializing SYNCHRONIZED...")
        "Synchronized Value"
    }

    println("=== PUBLICATION ===")
    val lazyPub = lazy(LazyThreadSafetyMode.PUBLICATION) {
        println("Initializing PUBLICATION...")
        "Publication Value"
    }

    println("=== NONE ===")
    val lazyNone = lazy(LazyThreadSafetyMode.NONE) {
        println("Initializing NONE...")
        "None Value"
    }

    // 同時アクセスをシミュレート
    coroutineScope {
        repeat(3) {
            launch {
                println("Synchronized: ${lazySync.value}")
                println("Publication: ${lazyPub.value}")
                println("None: ${lazyNone.value}")
            }
        }
    }
}

まとめ

Kotlinのlazy関数は、遅延初期化を効率的に行う便利な仕組みです。LazyThreadSafetyModeを使うことで、用途に応じたスレッド安全性の設定が可能になります。

• SYNCHRONIZED：スレッド安全に初期化（デフォルト）。
• PUBLICATION：冪等性がある場合に適用。
• NONE：シングルスレッド環境で最速の初期化を実現。

次のセクションでは、スレッド安全なシングルトンの実装について具体的に解説します。

応用例：スレッド安全なシングルトンの実装

Kotlinでは、スレッド安全なシングルトンパターンを簡単に実装することができます。シングルトンはアプリケーション全体で一つのインスタンスだけを生成し、共有するデザインパターンです。マルチスレッド環境では競合を防ぎつつ、安全にシングルトンを生成する必要があります。

1. オブジェクト宣言を使ったシングルトン

Kotlinではobject宣言を使うことで、簡単にシングルトンを作成できます。この方法はスレッド安全であり、複数のスレッドが同時にアクセスしても問題が発生しません。

object Singleton {
    val data: String = "This is a thread-safe Singleton"

    fun showData() {
        println(data)
    }
}

fun main() {
    val thread1 = Thread { Singleton.showData() }
    val thread2 = Thread { Singleton.showData() }

    thread1.start()
    thread2.start()
    thread1.join()
    thread2.join()
}

出力例：

This is a thread-safe Singleton
This is a thread-safe Singleton

解説：

• object宣言：Kotlinのobjectは自動的にスレッド安全に初期化されます。複数のスレッドが同時にアクセスしても、インスタンスが重複して生成されることはありません。
• 利点：シンプルな構文と高い安全性。

2. lazy関数を用いたシングルトン

遅延初期化を利用して、シングルトンを必要なタイミングで生成し、スレッド安全に管理することができます。

class Singleton private constructor() {
    companion object {
        val instance: Singleton by lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
            println("Initializing Singleton...")
            Singleton()
        }
    }

    fun showMessage() {
        println("Hello from Singleton!")
    }
}

fun main() {
    val thread1 = Thread { Singleton.instance.showMessage() }
    val thread2 = Thread { Singleton.instance.showMessage() }

    thread1.start()
    thread2.start()
    thread1.join()
    thread2.join()
}

出力例：

Initializing Singleton...
Hello from Singleton!
Hello from Singleton!

解説：

• LazyThreadSafetyMode.SYNCHRONIZED：インスタンスが初めて必要になった時に1度だけ初期化され、複数のスレッドから同時にアクセスされても安全です。
• 用途：初期化コストが高い場合や、遅延初期化が必要な場合に適しています。

3. Double-Checked Lockingによるシングルトン

Javaの「ダブルチェックロッキング」をKotlinで実装することで、効率的かつスレッド安全なシングルトンを構築できます。

class Singleton private constructor() {
    companion object {
        @Volatile
        private var instance: Singleton? = null

        fun getInstance(): Singleton {
            return instance ?: synchronized(this) {
                instance ?: Singleton().also { instance = it }
            }
        }
    }

    fun showMessage() {
        println("Singleton via Double-Checked Locking")
    }
}

fun main() {
    val thread1 = Thread { Singleton.getInstance().showMessage() }
    val thread2 = Thread { Singleton.getInstance().showMessage() }

    thread1.start()
    thread2.start()
    thread1.join()
    thread2.join()
}

出力例：

Singleton via Double-Checked Locking
Singleton via Double-Checked Locking

解説：

• @Volatile：instance変数をvolatileにすることで、メモリ可視性の問題を回避します。
• ダブルチェックロッキング：nullチェックとsychronizedブロックを組み合わせて、ロックのコストを最小限に抑えます。
• 用途：パフォーマンス重視でシングルトンをスレッド安全に生成する場合。

シングルトン実装の選択基準

1. 最も簡単な方法：object宣言（Kotlin標準のシングルトン）。
2. 遅延初期化が必要な場合：lazy関数（SYNCHRONIZEDオプション）。
3. パフォーマンスを重視する場合：ダブルチェックロッキングを用いたシングルトン。

まとめ

Kotlinでは、スレッド安全なシングルトンを簡単に実装できます。用途に応じて、object宣言、lazy関数、ダブルチェックロッキングを使い分けることで、マルチスレッド環境でも安全かつ効率的にシングルトンを利用できます。

次のセクションでは、本記事のまとめを行います。

まとめ

本記事では、Kotlinにおけるプロパティのスレッド安全な操作方法について詳しく解説しました。スレッド安全性の基本概念から、@SynchronizedやMutexの利用、Atomic型の活用、Kotlin Coroutinesによるデータ管理、Lazyプロパティのスレッド安全オプション、そしてシングルトンの実装までを網羅しました。

適切な方法を選択することで、競合状態やデータの不整合を防ぎ、マルチスレッド環境でも安全かつ効率的なプログラムを実現できます。Kotlinが提供する機能を活用し、信頼性の高いアプリケーションを構築していきましょう。