public interface Spliterator<T> {
    Spliterator<T> trySplit();  // Возвращает новый Spliterator для части данных или null
    void forEachRemaining(Consumer<? super T> action);
    boolean tryAdvance(Consumer<? super T> action);
    long estimateSize();
    int characteristics();
}

List<Result> results = urls.parallelStream()
    .map(url -> {
        try {
            return httpClient.fetch(url);  // Блокирующий HTTP-запрос, 500мс
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    })
    .collect(toList());

// Имитация тяжёлой работы
IntStream.range(0, 1000).parallel()
    .map(i -> {
        try { Thread.sleep(100); } catch (InterruptedException e) { }
        return i * 2;
    })
    .collect(toList());

ExecutorService ioPool = Executors.newFixedThreadPool(50);  // Много потоков, не боится блокировок

List<CompletableFuture<Result>> futures = urls.stream()
    .map(url -> CompletableFuture.supplyAsync(() -> fetch(url), ioPool))
    .collect(toList());

List<Result> results = futures.stream()
    .map(CompletableFuture::join)
    .collect(toList());

ioPool.shutdown();
Virtual Threads (Java 21+):
java
Copy
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    List<StructuredTaskScope.Subtask<Result>> subtasks = urls.stream()
        .map(url -> scope.fork(() -> fetch(url)))
        .collect(toList());
    
    scope.join().throwIfFailed();
    
    return subtasks.stream()
        .map(StructuredTaskScope.Subtask::get)
        .collect(toList());
}

// При запуске JVM
-Djava.util.concurrent.ForkJoinPool.common.parallelism=16

// Или программно, но только до первого использования пула
System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism", "16");

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;

public class Task180326 {
    public static void main(String[] args) {
        ForkJoinPool pool = ForkJoinPool.commonPool();
        int result = pool.invoke(new Task(10));
        System.out.println(result);
    }
    
    static class Task extends RecursiveTask<Integer> {
        int n;
        Task(int n) { this.n = n; }
        
        @Override
        protected Integer compute() {
            if (n <= 1) return n;
            
            Task t1 = new Task(n - 1);
            Task t2 = new Task(n - 2);
            
            t1.fork();
            return t2.compute() + t1.join();
        }
    }
}

public class ConcurrentModificationExample {
    
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("a", "b", "c", "d"));
        
        //Антипаттерн: удаление в for-each
        try {
            for (String item : list) {
                if (item.equals("b")) {
                    list.remove(item); //ConcurrentModificationException!
                }
            }
        } catch (ConcurrentModificationException e) {
            System.out.println("Ошибка: " + e);
        }
        
        //Явный Iterator.remove()
        list = new ArrayList<>(Arrays.asList("a", "b", "c", "d"));
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String item = iterator.next();
            if (item.equals("b")) {
                iterator.remove(); // Безопасно
            }
        }
        System.out.println("После iterator.remove(): " + list);
        
        //removeIf()
        list = new ArrayList<>(Arrays.asList("a", "b", "c", "d"));
        list.removeIf(item -> item.equals("b")); // Самый лаконичный способ
        System.out.println("После removeIf(): " + list);
        
        //Сбор элементов для удаления
        list = new ArrayList<>(Arrays.asList("a", "b", "c", "d"));
        List<String> toRemove = new ArrayList<>();
        for (String item : list) {
            if (item.equals("b")) {
                toRemove.add(item); //Отмечаем на удаление
            }
        }
        list.removeAll(toRemove); //Удаляем после итерации
        System.out.println("После removeAll(): " + list);
    }
}

import java.util.*;

public class Task190326 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C", "D", "E"));
        
        for (String s : list) {
            if (s.equals("C")) {
                list.remove(s);
            }
            System.out.print(s + " ");
        }
    }
}

// ArrayList: O(1) разделение, равномерная нагрузка
List<Book> books = new ArrayList<>(100000);
books.parallelStream()  // Эффективен
    .map(this::expensiveAnalysis)
    .collect(toList());

// LinkedList: разделение O(n), часто деградирует к последовательному
LinkedList<Book> linkedBooks = new LinkedList<>();
linkedBooks.parallelStream()  // Нет выигрыша, возможен проигрыш
    .map(this::expensiveAnalysis)
    .collect(toList());

// Stream.iterate: не делится, parallel бесполезен
Stream.iterate(0, n -> n + 1)
    .parallel()  // Игнорируется
    .limit(1000)
    .map(this::expensiveComputation)
    .collect(toList());

// Слишком дёшево: параллелизм замедлит
List<Integer> doubled = numbers.parallelStream()
    .map(n -> n * 2)  // Одна инструкция процессора
    .collect(toList());

// Достаточно дорого: параллелизм ускорит
List<Result> analyzed = documents.parallelStream()
    .map(doc -> nlpPipeline.analyze(doc))  // 50-100 мс на документ
    .collect(toList());

// Антипаттерн: общий счётчик
AtomicInteger counter = new AtomicInteger(0);

List<Result> results = data.parallelStream()
    .map(d -> {
        counter.incrementAndGet();  // Потокобезопасен, но не бесплатен
        return process(d);
    })
    .collect(toList());

// Катастрофа: ArrayList не потокобезопасен
List<Result> results = data.parallelStream()
    .map(this::process)
    .collect(ArrayList::new, List::add, List::addAll);  // Race condition!

// Опасность: изменяемый ключ после группировки
Map<MutableAuthor, List<Book>> byAuthor = books.parallelStream()
    .collect(groupingBy(MutableAuthor::new));

// Позже в другом потоке...
byAuthor.keySet().iterator().next().setName("New");  // Непредсказуемое поведение

// Барьер: локальная сортировка + глобальное слияние
List<Book> sorted = books.parallelStream()
    .sorted(comparing(Book::year))  // Накладные расходы на merge
    .collect(toList());

// Плохо: упорядоченный источник + findFirst в parallel
Optional<Book> first = books.parallelStream()
    .filter(b -> b.year() > 2000)
    .findFirst();  // Требует проверки всех предшествующих сегментов

// Лучше: findAny для неупорядоченных задач
Optional<Book> any = books.parallelStream()
    .filter(b -> b.year() > 2000)
    .findAny();  // Первый найденный в любом сегменте

// JMH-бенчмарк для сравнения
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public class StreamBenchmark {
    
    @State(Scope.Thread)
    public static class Data {
        List<Book> books = generateBooks(100000);
    }
    
    @Benchmark
    public List<Result> sequential(Data d) {
        return d.books.stream()
            .map(this::expensiveTransform)
            .collect(toList());
    }
    
    @Benchmark
    public List<Result> parallel(Data d) {
        return d.books.parallelStream()
            .map(this::expensiveTransform)
            .collect(toList());
    }
}

import java.util.*;

public class Task200326 {
    public static void main(String[] args) {
        List<Integer> list1 = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8));
        List<Integer> list2 = new LinkedList<>(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8));
        
        long count1 = list1.parallelStream()
            .map(x -> {
                try { Thread.sleep(10); } catch (InterruptedException e) {}
                return x * 2;
            })
            .count();
            
        long count2 = list2.parallelStream()
            .map(x -> {
                try { Thread.sleep(10); } catch (InterruptedException e) {}
                return x * 2;
            })
            .count();
            
        System.out.println(count1 == count2);
        System.out.println(list1.parallelStream().isParallel());
        System.out.println(list2.parallelStream().isParallel());
    }
}