Чем пользуешься для создания потока?

Создание потоков в Java: подходы и инструменты

При разработке многопоточных приложений я использую различные подходы в зависимости от задачи. Это не просто new Thread() — существует множество более эффективных способов.

1. Низкоуровневый подход: Thread

Прямое создание потока (редко используется):

// ❌ Плохой подход - неэффективен для множества потоков
public class DirectThreadExample {
    public static void main(String[] args) {
        // Создаем и запускаем поток
        Thread thread = new Thread(() -> {
            System.out.println("Работа в отдельном потоке");
        });
        
        thread.start(); // start(), не run()!
        thread.setName("MyWorker");
        thread.setPriority(Thread.NORM_PRIORITY);
        
        try {
            thread.join(); // Ждем завершения
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

// Проблемы:
// - Создание потока дорого (memory, CPU context switching)
// - Нет переиспользования потоков
// - Сложное управление

2. ExecutorService и Thread Pools

Рекомендуемый подход: управляемые потоки

@Service
public class ThreadPoolExample {
    private final ExecutorService executor;
    
    public ThreadPoolExample() {
        // Пул из 10 потоков для обработки задач
        this.executor = Executors.newFixedThreadPool(10);
    }
    
    public void processData(List<String> items) {
        for (String item : items) {
            executor.execute(() -> {
                // Работа выполнится в одном из потоков пула
                processItem(item);
            });
        }
    }
    
    public void shutdown() {
        // Graceful shutdown
        executor.shutdown();
        try {
            if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                executor.shutdownNow();
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
    
    private void processItem(String item) {
        // Длительная операция
    }
}

Различные типы ExecutorService:

public class ExecutorTypes {
    // 1. FixedThreadPool - фиксированное количество потоков
    ExecutorService fixed = Executors.newFixedThreadPool(10);
    // Идеален для CPU-bound задач
    // Размер обычно = количество CPU cores
    
    // 2. CachedThreadPool - создает потоки по необходимости
    ExecutorService cached = Executors.newCachedThreadPool();
    // Для I/O-bound операций
    // Потоки перезаиспользуются, неиспользуемые удаляются
    
    // 3. SingleThreadExecutor - один поток
    ExecutorService single = Executors.newSingleThreadExecutor();
    // Гарантирует последовательное выполнение
    // Полезно для операций с shared state
    
    // 4. ScheduledExecutorService - отложенное выполнение
    ScheduledExecutorService scheduled = Executors.newScheduledThreadPool(5);
    // Для периодических или отложенных задач
}

3. Future и Callable

Когда нужен результат из потока:

@Service
public class FutureExample {
    private final ExecutorService executor = Executors.newFixedThreadPool(5);
    
    // Callable - task который возвращает результат
    public Future<String> fetchDataAsync(String url) {
        return executor.submit(() -> {
            // Callable
            return httpClient.get(url);
        });
    }
    
    // Получение результата
    public void example() throws ExecutionException, InterruptedException {
        Future<String> future = fetchDataAsync("https://api.example.com/data");
        
        // Способ 1: блокирующее ожидание
        String result = future.get(); // Ждет результат
        
        // Способ 2: с timeout
        String resultWithTimeout = future.get(5, TimeUnit.SECONDS);
        
        // Способ 3: проверка готовности
        if (future.isDone()) {
            String ready = future.get();
        }
        
        // Способ 4: отмена
        future.cancel(true); // true = interrupt если уже выполняется
    }
}

4. CompletableFuture

Современный и удобный способ (Java 8+):

@Service
public class CompletableFutureExample {
    private final HttpClient httpClient;
    
    // Асинхронная цепочка операций
    public void complexAsyncFlow() {
        CompletableFuture.supplyAsync(() -> {
                // 1. Fetch user data
                return fetchUser(123);
            })
            .thenApplyAsync(user -> {
                // 2. Fetch user orders (зависит от результата #1)
                return fetchOrders(user.getId());
            })
            .thenApplyAsync(orders -> {
                // 3. Process orders
                return orders.stream()
                    .map(this::enrichOrder)
                    .collect(Collectors.toList());
            })
            .thenAccept(enrichedOrders -> {
                // 4. Сохраняем результат (без возврата)
                saveToCache(enrichedOrders);
            })
            .exceptionally(ex -> {
                // Обработка ошибок
                logger.error("Failed to process user data", ex);
                return null;
            })
            .join(); // Ждем завершения
    }
    
    // Параллельное выполнение
    public void parallelRequests() {
        CompletableFuture<User> userFuture = 
            CompletableFuture.supplyAsync(this::fetchUser);
        CompletableFuture<List<Order>> ordersFuture = 
            CompletableFuture.supplyAsync(this::fetchOrders);
        CompletableFuture<List<Review>> reviewsFuture = 
            CompletableFuture.supplyAsync(this::fetchReviews);
        
        // Ждем ВСЕ результаты
        CompletableFuture.allOf(userFuture, ordersFuture, reviewsFuture)
            .thenRun(() -> {
                User user = userFuture.join();
                List<Order> orders = ordersFuture.join();
                List<Review> reviews = reviewsFuture.join();
                
                processAll(user, orders, reviews);
            })
            .join();
    }
    
    private User fetchUser(long id) { return null; }
    private List<Order> fetchOrders(long userId) { return null; }
    private List<Review> fetchReviews() { return null; }
    private Order enrichOrder(Order order) { return order; }
    private void saveToCache(Object data) {}
    private void processAll(User u, List<Order> o, List<Review> r) {}
}

5. Virtual Threads (Project Loom)

Новое в Java 21 — легкие потоки:

@Service
public class VirtualThreadsExample {
    // Старый способ: 10,000 потоков - большой overhead
    // Новый способ: 10,000 virtual threads - очень эффективно
    
    public void processMillionRequests() throws InterruptedException {
        ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
        
        for (int i = 0; i < 1_000_000; i++) {
            executor.submit(() -> {
                // Каждый request в отдельном virtual thread
                // Но реально работает на маленьком количестве OS threads
                handleRequest();
            });
        }
        
        executor.shutdown();
        executor.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
    }
    
    // Virtual thread как Thread
    public void createVirtualThread() {
        Thread vt = Thread.ofVirtual()
            .name("virtual-worker-", 0)
            .start(() -> {
                System.out.println("Running in virtual thread");
            });
    }
    
    private void handleRequest() {}
}

// Преимущества virtual threads:
// - Миллионы потоков без проблем
// - Автоматическое переключение при I/O
// - Простой code style (как обычные threads)
// - Огромная scalability

6. Reactive Programming (WebFlux)

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

@RestController
public class ReactiveController {
    @Autowired
    private WebClient webClient;
    
    // Не блокирует поток при I/O
    @GetMapping("/data/{id}")
    public Mono<ResponseEntity<Data>> getData(@PathVariable String id) {
        return webClient.get()
            .uri("/api/data/" + id)
            .retrieve()
            .bodyToMono(Data.class)
            .map(data -> ResponseEntity.ok(data))
            .onErrorReturn(ResponseEntity.notFound().build());
    }
    
    // Множество запросов параллельно
    @GetMapping("/batch")
    public Mono<List<Data>> getBatch(@RequestParam List<String> ids) {
        return Flux.fromIterable(ids)
            .flatMap(id -> webClient.get()
                .uri("/api/data/" + id)
                .retrieve()
                .bodyToMono(Data.class))
            .collectList();
    }
}

7. Thread Naming и Debugging

Важно для troubleshooting:

@Configuration
public class ThreadNaming {
    @Bean
    public ExecutorService namedThreadPool() {
        ThreadFactory factory = r -> {
            Thread t = new Thread(r);
            t.setName("payment-processor-" + t.getId());
            t.setUncaughtExceptionHandler((thread, ex) -> {
                logger.error("Uncaught exception in " + thread.getName(), ex);
            });
            return t;
        };
        
        return Executors.newFixedThreadPool(10, factory);
    }
}

// Логирование для debugging
public class ThreadAwareLogging {
    private static final Logger logger = LoggerFactory.getLogger(ThreadAwareLogging.class);
    
    public void logWithThreadInfo() {
        String threadName = Thread.currentThread().getName();
        long threadId = Thread.currentThread().getId();
        logger.info("Processing [thread={}, id={}]", threadName, threadId);
    }
}

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

┌─────────────────┬──────────────────┬──────────┬─────────────┐
│ Подход          │ Использование    │ Сложность│ Performance │
├─────────────────┼──────────────────┼──────────┼─────────────┤
│ new Thread      │ Простые случаи   │ Низкая   │ Плохая      │
│ ExecutorService │ Большинство      │ Средняя  │ Хорошая     │
│ CompletableFuture│ Async chains    │ Средняя  │ Хорошая     │
│ Virtual Threads │ High concurrency │ Низкая   │ Отличная    │
│ Reactive        │ Event-driven     │ Высокая  │ Отличная    │
└─────────────────┴──────────────────┴──────────┴─────────────┘

Best Practices

public class ThreadingBestPractices {
    /**
     * 1. Никогда не используй new Thread() для production
     * 2. Всегда используй ExecutorService или CompletableFuture
     * 3. Устанавливай thread names для debugging
     * 4. Обрабатывай InterruptedException правильно
     * 5. Используй timeout для операций
     * 6. Избегай busy-waiting, используй synchronization primitives
     * 7. Monitor thread pools: active threads, queue size
     * 8. Правильно shutdown'и executor'ы
     * 9. Ловись race conditions: synchronized, volatile, atomics
     * 10. Рассмотри virtual threads для новых проектов (Java 21+)
     */
}

Заключение

Для создания потоков в Java я использую:

1. ExecutorService — для большинства cases
2. CompletableFuture — для асинхронных цепочек
3. Virtual Threads — для высокой конкурентности (Java 21+)
4. Reactive (WebFlux) — для event-driven систем
5. Прямые потоки (new Thread) — никогда для production

Ключевое правило: забудь про new Thread() и используй правильные инструменты для управления потоками.