Как безопасно использовать потоки Java без методов isFinite() и isOrdered()?

Существует вопрос о том, должны ли методы Java возвращать Коллекции или потоки, на который Брайан Гетц отвечает, что даже для конечных последовательностей обычно следует отдавать предпочтение потокам.

Но мне кажется, что в настоящее время многие операции над потоками, которые приходят из других мест, не могут быть безопасно выполнены, а защитные кодовые охранники невозможны, потому что потоки не раскрывают, являются ли они бесконечными или неупорядоченными.

Если параллельность была проблемой для операций, которые я хочу выполнить в Stream(), я могу вызвать isParallel() для проверки или последовательности, чтобы убедиться, что вычисления выполняются параллельно (если я не забыл).

Но если упорядоченность или конечность (размерность) имеют отношение к безопасности моей программы, я не могу писать меры безопасности.

Предполагая, что я использую библиотеку, реализующую этот фиктивный интерфейс:

public interface CoordinateServer {
    public Stream<Integer> coordinates();
    // example implementations:
    // finite, ordered, sequential
    // IntStream.range(0, 100).boxed()
    // final AtomicInteger atomic = new AtomicInteger();
    
    // // infinite, unordered, sequential
    // Stream.generate(() -> atomic2.incrementAndGet()) 

    // infinite, unordered, parallel
    // Stream.generate(() -> atomic2.incrementAndGet()).parallel()
    
    // finite, ordered, sequential, should-be-closed
    // Files.lines(Path.path("coordinates.txt")).map(Integer::parseInt)
}

Тогда какие операции я могу безопасно вызывать в этом потоке, чтобы написать правильный алгоритм?

Кажется, если я, возможно, захочу записать элементы в файл в качестве побочного эффекта, мне нужно беспокоиться о параллельности потока:

// if stream is parallel, which order will be written to file?
coordinates().peek(i -> {writeToFile(i)}).count();
// how should I remember to always add sequential() in  such cases?

А также, если он параллелен, на основе какого пула потоков он параллелен?

Если я хочу отсортировать поток (или другие операции без короткого замыкания), мне как-то нужно быть осторожным с тем, что он бесконечен:

coordinates().sorted().limit(1000).collect(toList()); // will this terminate?
coordinates().allMatch(x -> x > 0); // will this terminate?

Я могу ввести ограничение перед сортировкой, но какое это должно быть магическое число, если я ожидаю конечный поток неизвестного размера?

Наконец, может быть, я хочу вычислить параллельно, чтобы сэкономить время, а затем собрать результат:

// will result list maintain the same order as sequential?
coordinates().map(i -> complexLookup(i)).parallel().collect(toList());

Но если поток не упорядочен (в этой версии библиотеки), то результат может быть искажен из-за параллельной обработки. Но как я могу защититься от этого, кроме как не использовать параллель (что противоречит цели производительности)?

Коллекции явно указывают, являются ли они конечными или бесконечными, имеют порядок или нет, и они не несут с собой режим обработки или пулы потоков. Это кажется ценным свойством для API.

Кроме того, Потоки иногда нужно закрывать, но чаще всего нет. Если я использую поток из метода (или из параметра метода), должен ли я обычно вызывать close?

Кроме того, потоки могли быть уже потреблены, и было бы хорошо иметь возможность корректно обрабатывать этот случай, поэтому было бы хорошо использовать проверить, не был ли уже использован поток;

Я бы хотел, чтобы какой-нибудь фрагмент кода можно было использовать для проверки предположений о потоке перед его обработкой, например >

Stream<X> stream = fooLibrary.getStream();
Stream<X> safeStream = StreamPreconditions(
    stream, 
    /*maxThreshold or elements before IllegalArgumentException*/
    10_000,
    /* fail with IllegalArgumentException if not ordered */
    true
    )