Чем реализуется асинхронное программирование в Java Core?

Асинхронное программирование в Java Core

Основные механизмы

Асинхронное программирование в Java реализуется несколькими способами:

1. Многопоточность (Threading)

Визначительный основной способ:

// Запуск кода в отдельном потоке
Thread thread = new Thread(() -> {
    System.out.println("Асинхронный код в новом потоке");
});
thread.start();  // НЕ thread.run()!

// ExecutorService для управления потоками
ExecutorService executor = Executors.newFixedThreadPool(10);
Executor.submit(() -> {
    // Код выполняется асинхронно
});
executor.shutdown();

Проблемы потоков:

• Дорого (каждый поток ≈ 1MB памяти)
• Медленное переключение контекста
• Максимум несколько тысяч потоков
• Сложная синхронизация

2. Future и Callback

Future — представление результата, который будет доступен позже:

ExecutorService executor = Executors.newFixedThreadPool(2);

// Запускаем асинхронную задачу
Future<Integer> future = executor.submit(() -> {
    Thread.sleep(1000);
    return 42;
});

// Текущий поток продолжает работать
System.out.println("Ждём результат...");

// Блокирующее ожидание результата
Integer result = future.get();  // Блокирует до результата
System.out.println("Результат: " + result);

// Проверка готовности без блокировки
if (future.isDone()) {
    result = future.get(0, TimeUnit.SECONDS);  // С timeout
}

Callback подход (более старый):

public interface AsyncCallback<T> {
    void onSuccess(T result);
    void onFailure(Exception e);
}

public void fetchUserAsync(Long userId, AsyncCallback<User> callback) {
    new Thread(() -> {
        try {
            User user = fetchUserFromDB(userId);
            callback.onSuccess(user);
        } catch (Exception e) {
            callback.onFailure(e);
        }
    }).start();
}

// Использование
fetchUserAsync(1L, new AsyncCallback<User>() {
    @Override
    public void onSuccess(User user) {
        System.out.println("User: " + user.getName());
    }
    
    @Override
    public void onFailure(Exception e) {
        System.err.println("Error: " + e.getMessage());
    }
});

Проблема callback'ов: Callback Hell (нестинг становится невообразимым)

3. CompletableFuture (Java 8+)

Самый мощный встроенный инструмент:

// Создание асинхронной задачи
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("Вычисляем асинхронно в пуле потоков...");
    return 42;
});

// Обработка результата
future.thenAccept(result -> {
    System.out.println("Результат получен: " + result);
});

// Трансформация результата
CompletableFuture<String> stringFuture = future
    .thenApply(n -> "Число: " + n);

// Цепирование операций
CompletableFuture<String> chain = CompletableFuture
    .supplyAsync(() -> fetchUser(1L))
    .thenApply(user -> user.getName())
    .thenApply(String::toUpperCase);

// Обработка ошибок
future.exceptionally(ex -> {
    System.err.println("Ошибка: " + ex.getMessage());
    return -1;
});

// Ожидание результата
String result = chain.get();  // Блокирующее
String result2 = chain.get(5, TimeUnit.SECONDS);  // С timeout
String result3 = chain.getNow("default");  // Non-blocking

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

CompletableFuture<User> userFuture = CompletableFuture
    .supplyAsync(() -> fetchUser(1L));

CompletableFuture<List<Post>> postsFuture = CompletableFuture
    .supplyAsync(() -> fetchPosts(1L));

// Ждём обе операции
CompletableFuture<Void> combined = CompletableFuture.allOf(
    userFuture, postsFuture
);

// Или возвращаем результат первой завершённой
CompletableFuture<Object> first = CompletableFuture.anyOf(
    userFuture, postsFuture
);

4. Virtual Threads (Java 19+, Project Loom)

Революция в асинхронности:

// Раньше (с обычными потоками): максимум 10k потоков
// Теперь (с virtual threads): миллионы потоков!

try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 1_000_000; i++) {
        executor.submit(() -> {
            // Выполняется в virtual thread
            performBlockingIO();
        });
    }
}

// Virtual threads решают проблему дороговизны потоков
// Можно писать простой блокирующий код
// А virtual threads справляются эффективно

5. Structured Concurrency (Java 19+, Preview)

Правильная иерархия асинхронных задач:

public <T> T fetchDataWithCancellation() throws Exception {
    try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
        // Запускаем две операции параллельно
        var userTask = scope.fork(() -> fetchUser(1L));
        var postTask = scope.fork(() -> fetchPosts(1L));
        
        scope.join();  // Ждём обе задачи
        
        // Если одна упала, остальные отменяются
        return combine(userTask.resultNow(), postTask.resultNow());
    }
}

Сравнение подходов

Практический пример: Spring WebFlux

// Асинхронный REST контроллер
@RestController
public class UserController {
    @Autowired
    private UserService userService;
    
    // CompletableFuture в Spring автоматически обрабатывается
    @GetMapping("/users/{id}")
    public CompletableFuture<User> getUser(@PathVariable Long id) {
        return userService.findUserAsync(id);
    }
}

// Сервис с асинхронностью
@Service
public class UserService {
    public CompletableFuture<User> findUserAsync(Long id) {
        return CompletableFuture.supplyAsync(() -> {
            return userRepository.findById(id)
                .orElse(null);
        });
    }
}

Ошибки при асинхронном программировании

❌ Ошибка 1: Блокирование в асинхронном коде

CompletableFuture<Data> future = CompletableFuture.supplyAsync(() -> {
    Thread.sleep(1000);  // ❌ Блокируем поток из пула!
    return fetchData();
});

✅ Правильно:

CompletableFuture<Data> future = CompletableFuture.supplyAsync(() -> {
    return fetchDataAsync();  // Не блокируем
});

❌ Ошибка 2: Забыть обработать исключение

CompletableFuture.supplyAsync(() -> {
    throw new RuntimeException("Oops!");
}).get();  // Выбросит ExecutionException, которую нужно ловить

✅ Правильно:

CompletableFuture.supplyAsync(() -> {
    throw new RuntimeException("Oops!");
}).exceptionally(ex -> {
    log.error("Error", ex);
    return null;
}).get();

Итог

В Java Core асинхронность реализуется:

1. Многопоточностью — базовый механизм
2. Future — простое представление результата
3. CompletableFuture — мощный инструмент для композиции
4. Virtual Threads — революция (Java 19+)
5. Structured Concurrency — правильная иерархия (Java 19+)

Выбирай в зависимости от версии Java:

• Java 8-18: CompletableFuture
• Java 19+: Virtual Threads + Structured Concurrency
• Legacy: Thread + Future

Главное правило: Не блокируй потоки из пула выполнения!