new Thread(() -> { /* ваш код */ }).start();. 

executor.execute(() -> { /* код */ });

ExecutorService executor = Executors.newFixedThreadPool(10); Future<String> future = executor.submit(() -> { Thread.sleep(1000); return "Привет"; });.

CompletableFuture.supplyAsync(() -> { return "Данные"; }).thenApply(data -> { return data.toUpperCase(); }).thenAccept(System.out::println);.

Здесь supplyAsync запускает задачу асинхронно, thenApply преобразует результат (например, переводит в верхний регистр), thenAccept выводит его. 

Mono<string> mono = Mono.just("Привет из реки");  // Создаём простой Mono с одним элементом
mono.subscribe(
   value -> System.out.println("Получено: " + value),    // onNext: реакция на элемент
   error -> System.err.println("Ошибка: " + error),        // onError
    () -> System.out.println("Завершено")                        // onComplete
);

Здесь subscribe — это подписка. Mono "течёт" асинхронно: если элемент готов — срабатывает onNext, потом onComplete. Нет блокировок: код continue после subscribe.

Flux<integer> flux = Flux.range(1, 5);   // Поток чисел от 1 до 5
flux.subscribe(
         value -> System.out.println("Элемент: " + value),
         error -> System.err.println("Ошибка: " + error),
         () -> System.out.println("Поток завершён")
);

Flux.fromIterable(List.of("яблоко", "банан", "вишня"))
        .filter(fruit -> fruit.startsWith("б")) // Фильтруем
        .map(String::toUpperCase)              // Преобразуем
        .subscribe(System.out::println);       // Подписываемся

Результат: "БАНАН". Всё течёт как конвейер, без callback-ада: код читаем, как последовательный, но работает асинхронно.

Flux<integer> fastFlux = Flux.range(1, 1000); // Быстрый источник
fastFlux.subscribe(new BaseSubscriber<integer>() {

@Override
protected void hookOnSubscribe(Subscription subscription) {
        request(10); // Запрашиваем только 10 элементов сначала
}

@Override
protected void hookOnNext(Integer value) {
          System.out.println(value);
          if (value % 10 == 0) request(10); // Запрашиваем ещё по мере обработки
          }
});

List<String> fruits = Arrays.asList("яблоко", "банан", "вишня");

Iterator<String> iterator = fruits.iterator();

while (iterator.hasNext()) {
    String fruit = iterator.next(); // "Вытягиваем" следующий элемент
    System.out.println(fruit.toUpperCase());
}

Flux<String> pushFlux = Flux.fromIterable(Arrays.asList("яблоко", "банан", "вишня"))
                    .map(String::toUpperCase); // Преобразование в потоке

pushFlux.subscribe(
               fruit -> System.out.println("Получено из push: " + fruit), // Реакция на толкание
               Throwable::printStackTrace, // Обработка ошибок
               () -> System.out.println("Push завершён")
);

WebClient.create()
     .get()
     .uri("https://api.example.com/fruits")
     .retrieve()
     .bodyToFlux(String.class) // Flux толкает строки из ответа
     .subscribe(fruit -> System.out.println("Push из API: " + fruit));

Flux.fromIterable(fruits)
     .map(String::toUpperCase)
     .flatMap(fruit -> sendToApi(fruit)) // flatMap толкает в асинхронный API
     .subscribe(result -> System.out.println("Ответ: " + result));

import reactor.core.publisher.Flux; // Flux реализует Publisher

Flux<Integer> publisher = Flux.range(1, 5); // Издатель: поток от 1 до 5

publisher.subscribe(new Subscriber<Integer>() {
    private Subscription subscription;

    @Override
    public void onSubscribe(Subscription s) {
        this.subscription = s;
        s.request(1); // Запрашиваем первый элемент
    }

    @Override
    public void onNext(Integer item) {
        System.out.println("Получено: " + item);
        subscription.request(1); // Запрашиваем следующий
    }

    @Override
    public void onError(Throwable t) {
        System.err.println("Ошибка: " + t);
    }

    @Override
    public void onComplete() {
        System.out.println("Завершено");
    }
});

import reactor.core.publisher.Flux;
import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;

Flux<Integer> fastPublisher = Flux.range(1, 1000); // Быстрый источник: 1000 элементов

fastPublisher.subscribe(new Subscriber<Integer>() {
    private Subscription sub;

    @Override
    public void onSubscribe(Subscription s) {
        sub = s;
        sub.request(5); // Сначала запрашиваем 5 элементов
    }

    @Override
    public void onNext(Integer item) {
        System.out.println("Обработано: " + item);
        // Симулируем медленную обработку: Thread.sleep(100); (но в реальности избегайте блокировок!)
        sub.request(1); // После каждого — запрашиваем следующий
    }

    @Override
    public void onError(Throwable t) { /* обработка */ }
    @Override
    public void onComplete() { System.out.println("Готово"); }
});

Здесь подписчик контролирует темп: запросил 5 — получил 5, обработал — запросил ещё. Если не request() — поток остановится. Это асинхронно: издатель не блокируется, а ждёт сигналов.