В чем разница приложения с многопоточностью между Java и Kotlin?

# Многопоточность в Java и Kotlin: различия и сходства

Котлин и Java работают на одной платформе (JVM), но каждый язык предоставляет разные инструменты для работы с многопоточностью. Давайте разберемся в их отличиях и подходах.

1. Низкоуровневые потоки (Thread API)

Java — классический подход

// Способ 1: Наследование Thread
public class MyThread extends Thread {
  @Override
  public void run() {
    System.out.println("Thread: " + Thread.currentThread().getName());
  }
}

MyThread thread = new MyThread();
thread.start();

// Способ 2: Реализация Runnable (рекомендуется)
public class MyRunnable implements Runnable {
  @Override
  public void run() {
    System.out.println("Running in thread");
  }
}

Thread thread = new Thread(new MyRunnable());
thread.start();

// Способ 3: Лямбда (Java 8+)
Thread thread = new Thread(() -> {
  System.out.println("Running in lambda");
});
thread.start();

Kotlin — похожий подход с удобством

// Способ 1: Функция thread() из stdlib
thread {
  println("Running in thread: ${Thread.currentThread().name}")
}

// Способ 2: Явно через Thread и Runnable
Thread(Runnable {
  println("Running in thread")
}).start()

// Способ 3: Lambda с методом thread() (самый идиоматичный)
thread(start = true) {
  println("Thread started automatically")
}

// Способ 4: Daemon потоки просто
thread(isDaemon = true) {
  println("Daemon thread")
}

Главное отличие: Kotlin имеет удобную функцию thread() из стандартной библиотеки, которая автоматически управляет жизненным циклом потока.

2. Корутины (Coroutines)

Java — Project Loom (Virtual Threads)

Java 19+ предоставляет виртуальные потоки (Project Loom) как альтернативу тяжёлым системным потокам.

public class VirtualThreadsExample {
  
  public static void main(String[] args) throws InterruptedException {
    // Создание виртуального потока (Java 21+)
    var virtualThread = Thread.ofVirtual()
      .name("vt-", 1)
      .start(() -> {
        System.out.println("Virtual thread: " + Thread.currentThread().getName());
        try {
          Thread.sleep(1000);
        } catch (InterruptedException e) {
          Thread.currentThread().interrupt();
        }
      });
    
    virtualThread.join();
  }
}

// Или с Executor
ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
executor.submit(() -> {
  System.out.println("Task in virtual thread");
});
executor.shutdown();

Kotlin — Structured Concurrency с Coroutines

Котлин предоставляет встроенные корутины через library kotlinx.coroutines, с концепцией Structured Concurrency.

import kotlinx.coroutines.*

suspend fun fetchData(url: String): String {
  // suspend функция может быть заморожена без блокировки потока
  return withContext(Dispatchers.IO) {
    // I/O операция на Dispatchers.IO
    "Data from $url"
  }
}

fun main() = runBlocking {
  // Запуск корутины в текущем потоке
  launch {
    println("Launch: Корутина в одном потоке")
  }
  
  // Запуск нескольких параллельных корутин
  repeat(100000) {
    launch {
      delay(1000)  // Suspend функция (не блокирует поток!)
      println("Coroutine $it completed")
    }
  }
}

// Async для получения результата
fun main() = runBlocking {
  val deferred = async {
    fetchData("https://api.example.com")
  }
  
  val result = deferred.await()  // Ждём результата
  println("Result: $result")
}

3. Синхронизация и Locks

Java — synchronized и Locks

public class SynchronizationExample {
  
  private Object monitor = new Object();
  private int counter = 0;
  
  // Способ 1: synchronized метод
  public synchronized void incrementSync() {
    counter++;
  }
  
  // Способ 2: synchronized блок
  public void incrementBlock() {
    synchronized (monitor) {
      counter++;
    }
  }
  
  // Способ 3: ReentrantLock (рекомендуется)
  private final Lock lock = new ReentrantLock();
  
  public void incrementLock() {
    lock.lock();
    try {
      counter++;
    } finally {
      lock.unlock();
    }
  }
}

Kotlin — Thread-safe коллекции и Mutex

import kotlinx.coroutines.sync.Mutex

class CounterKotlin {
  private var counter = 0
  private val mutex = Mutex()
  
  // Способ 1: Thread-safe коллекции
  val threadSafeList = Collections.synchronizedList(mutableListOf<String>())
  
  // Способ 2: Mutex для корутин (не блокирует поток!)
  suspend fun incrementMutex() {
    mutex.withLock {
      counter++
    }
  }
  
  // Способ 3: AtomicInteger для примитивов
  val atomicCounter = AtomicInteger(0)
  
  fun incrementAtomic() {
    atomicCounter.incrementAndGet()
  }
}

4. Практический пример: загрузка множества данных

Java с Virtual Threads (Project Loom)

public class JavaConcurrency {
  
  public static void main(String[] args) throws InterruptedException {
    List<String> urls = List.of(
      "https://api.github.com/repos/openjdk/jdk",
      "https://api.github.com/repos/google/guava",
      // ... 10000 URL
    );
    
    // Virtual threads позволяют создать 10000+ потоков без проблем
    ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
    
    for (String url : urls) {
      executor.submit(() -> {
        try {
          String response = fetchUrl(url);  // Блокирующий I/O
          System.out.println("Fetched: " + url);
        } catch (Exception e) {
          e.printStackTrace();
        }
      });
    }
    
    executor.shutdown();
    executor.awaitTermination(60, TimeUnit.SECONDS);
  }
  
  private static String fetchUrl(String url) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(new URI(url))
      .timeout(Duration.ofSeconds(10))
      .build();
    HttpResponse<String> response = client.send(request,
      HttpResponse.BodyHandlers.ofString());
    return response.body();
  }
}

Kotlin с Coroutines

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.Channel

suspend fun fetchUrlSuspend(url: String): String {
  return withContext(Dispatchers.IO) {
    // Реальный HTTP запрос (блокирует Dispatchers.IO поток, но не основной)
    "Response from $url"
  }
}

fun main() = runBlocking {
  val urls = listOf(
    "https://api.github.com/repos/openjdk/jdk",
    "https://api.github.com/repos/google/guava",
    // ... 10000 URL
  )
  
  // Способ 1: launch для fire-and-forget
  urls.forEach { url ->
    launch {
      val result = fetchUrlSuspend(url)
      println("Fetched: $url")
    }
  }
  
  // Способ 2: async для получения результатов
  val results = urls.map { url ->
    async {
      fetchUrlSuspend(url)
    }
  }.awaitAll()  // Ждём все корутины
  
  println("All done, got ${results.size} results")
}

5. Главные отличия

6. CompletableFuture в Java vs async в Kotlin

Java — CompletableFuture

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
  return fetchData();
}).thenApply(data -> {
  return "Processed: " + data;
}).exceptionally(ex -> {
  return "Error: " + ex.getMessage();
});

String result = future.get();  // Блокирует поток!

Kotlin — suspend функции

suspend fun asyncFetch(): String {
  return withContext(Dispatchers.IO) {
    try {
      val data = fetchData()
      return@withContext "Processed: $data"
    } catch (ex: Exception) {
      return@withContext "Error: ${ex.message}"
    }
  }
}

fun main() = runBlocking {
  val result = asyncFetch()  // Не блокирует!
  println(result)
}

7. Обработка ошибок

Java

ExecutorService executor = Executors.newFixedThreadPool(10);

Future<?> future = executor.submit(() -> {
  try {
    // код
  } catch (Exception e) {
    // обработка
  }
});

try {
  future.get();  // Блокирует и может выбросить исключение
} catch (ExecutionException e) {
  // обработка ошибки из потока
}

Kotlin

fun main() = runBlocking {
  try {
    val result = async {
      throw Exception("Something went wrong")
    }.await()
  } catch (ex: Exception) {
    println("Caught: ${ex.message}")
  }
}

Выводы

1. Java предоставляет:

   • Классические потоки (Thread API)
   • Virtual Threads (Project Loom) для облегчённых потоков
   • CompletableFuture для асинхронных операций

2. Kotlin предоставляет:

   • Встроенные корутины через kotlinx.coroutines
   • Structured Concurrency (лучший контроль над жизненным циклом)
   • suspend функции для более естественного асинхронного кода

3. Рекомендации:

   • Java 19+: используй Virtual Threads для простоты
   • Java < 19: используй Executor Framework с ReentrantLock
   • Kotlin: используй корутины везде — это стандарт де-факто

Котлин выглядит проще и читабельнее благодаря синтаксису корутин и встроенной поддержке, тогда как Java требует больше настройки, но обеспечивает большую гибкость при работе с низкоуровневыми потоками.