Почему в Kotlin нет ключевых слов для конкурентности (synchronized, volatile)?

Краткий ответ: Kotlin не поощряет использование низкоуровневых примитивов синхронизации

Создатели Kotlin (JetBrains) сознательно отказались от встроенных ключевых слов для конкурентности, таких как synchronized или volatile, по трем причинам:

• Философия языка: Kotlin продвигает безопасные и декларативные подходы. Низкоуровневые блокировки (как synchronized) считаются антипаттерном, так как они легко приводят к deadlock'ам, race condition и сложному для понимания коду.
• Корутины как основное средство: Kotlin создавался с корутинами в ядре (начиная с Kotlin 1.3). Корутины — это легковесные потоки, которые позволяют писать асинхронный код в последовательном стиле без блокировок.
• Аннотации как компромисс: Для совместимости с Java оставлены аннотации @Synchronized и @Volatile, но они используются только при взаимодействии с Java-кодом. В чистом Kotlin их применение считается плохой практикой.

Как правильно решать вашу задачу?

Для вашего примера со счетчиком есть два правильных пути:

1. Использовать атомарные типы (для простых операций)

Для инкремента счетчика не нужна блокировка — достаточно атомарного типа из пакета java.util.concurrent.atomic:

import java.util.concurrent.atomic.AtomicInteger

class Counter {
    private val count = AtomicInteger(0)

    fun increment() {
        count.incrementAndGet()
    }

    fun getCount(): Int = count.get()
}

2. Использовать корутины (для сложной логики)

Если ваш код работает с асинхронными операциями (сеть, файлы), используйте корутины и Mutex:

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

class Counter {
    private var count = 0
    private val mutex = Mutex()

    suspend fun increment() {
        mutex.withLock {
            count++
        }
    }
}

Mutex — это аналог synchronized, но для корутин. Он не блокирует поток, а приостанавливает корутину, что гораздо эффективнее.

Когда всё же нужна синхронизация потоков?

Если вы работаете с классическими потоками (Java Thread) и не можете перейти на корутины, используйте:

• @Synchronized — только для методов, которые будут вызываться из Java-кода.
• synchronized(lock) { ... } — стандартная Java-конструкция, доступна в Kotlin как функция высшего порядка.

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

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

Но помните: это наследие Java, в новом коде старайтесь избегать такого подхода.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.actor

fun CoroutineScope.counterActor() = actor<Unit> {
    var count = 0
    for (msg in channel) {
        count++
    }
}