Какие элементы многопоточности предоставляет Kotlin?

Kotlin предоставляет следующие элементы многопоточности:

• Корутины: Легковесные потоки, основанные на приостанавливаемых функциях. Обеспечивают асинхронное и не блокирующее выполнение кода.
• Строители корутин: Функции, запускающие корутины. Основные: launch (запускает корутину без возврата значения), async (запускает корутину и возвращает Deferred, которое можно ожидать для получения результата).

  // Пример использования launch
  GlobalScope.launch {
      println("Привет из корутины ${Thread.currentThread().name}")
  }
  
  // Пример использования async
  val deferred = GlobalScope.async {
      delay(1000) // Имитируем долгую операцию
      "Результат"
  }
  val result = runBlocking { deferred.await() } // Ожидаем результат
  

• Dispatchers: Определяют, на каком пуле потоков будет выполняться корутина. Основные:
  • Dispatchers.Default: Общий пул потоков для CPU-интенсивных задач.
  • Dispatchers.IO: Пул потоков для блокирующих операций ввода/вывода (работа с файлами, сетью).
  • Dispatchers.Main: Диспетчер для потока пользовательского интерфейса в соответствующих платформах (Android, Swing).
  • Dispatchers.Unconfined: Корутина запускается в текущем потоке, но может возобновиться в любом потоке.

  GlobalScope.launch(Dispatchers.IO) {
      // Выполнение ввода/вывода
  }
  

• runBlocking: Функция-строитель корутины, которая блокирует текущий поток до завершения корутины. Используется для объединения блокирующего и неблокирующего кода, часто в тестах или main-функциях.

  runBlocking {
      launch {
          delay(500)
          println("Завершено в ${Thread.currentThread().name}")
      }
      println("Запущено в ${Thread.currentThread().name}")
  }
  

• suspend функции: Функции, выполнение которых может быть приостановлено и возобновлено. Могут быть вызваны только из других suspend функций или строителей корутин.

  suspend fun doSomething() {
      delay(100) // Пример приостановки
  }
  

• Job: Хэндл на запущенную корутину. Предоставляет методы для управления жизненным циклом корутины (отмена, ожидание завершения).

  val job = GlobalScope.launch {
     // Долгая операция
  }
  job.cancel() // Отмена корутины
  runBlocking { job.join() } // Ожидание завершения
  

• CoroutineScope: Определяет область видимости для корутин. Корутины, запущенные в определенной области видимости, автоматически отменяются при отмене области. Помогает управлять жизненным циклом корутин.

  val scope = CoroutineScope(Dispatchers.Default)
  scope.launch {
      // Корутина в этой области видимости
  }
  scope.cancel() // Отмена всех корутин в этой области
  

• Каналы (Channel): Примитивы для безопасной передачи данных между корутинами. Каналы могут быть односторонними (только для отправки или получения) или двусторонними.

  import kotlinx.coroutines.channels.Channel
  
  val channel = Channel<Int>()
  
  runBlocking {
      launch {
          for (x in 1..5) channel.send(x * x)
          channel.close() // Важно закрыть канал
      }
      launch {
          for (y in channel) println(y)
      }
  }
  

• Мьютексы (Mutex): Примитивы синхронизации для обеспечения эксклюзивного доступа к общему ресурсу. Обеспечивают потокобезопасность, позволяя только одной корутине владеть мьютексом в определенный момент времени.

  import kotlinx.coroutines.sync.Mutex
  import kotlinx.coroutines.sync.withLock
  
  val mutex = Mutex()
  var counter = 0
  
  suspend fun incrementCounter() {
      mutex.withLock {
          counter++
      }
  }
  

• Состояния (StateFlow, SharedFlow): Примитивы для работы с потоками данных в контексте реактивного программирования и многопоточности. StateFlow представляет собой "холодный" поток с текущим состоянием, а SharedFlow - "горячий" поток для широковещательной рассылки данных.