Find out whose threads you are using

import java.util.*;
import java.util.concurrent.*;
import java.util.stream.*;

/**
 * Warm-up: whose threads are these?
 *
 * parallelStream() does not create threads. Finding out which threads it does
 * use, by printing their names, answers most of this topic on its own.
 */
public class Starter {

    public static void main(String[] args) throws Exception {

        // TODO 1: predict the thread names before running. Then look at the
        // prefix — it names the pool, and the pool is the whole point.
        Set<String> threads = ConcurrentHashMap.newKeySet();
        IntStream.range(0, 10_000).parallel()
            .forEach(i -> threads.add(Thread.currentThread().getName()));

        System.out.println("distinct threads : " + threads.size());
        System.out.println("names            : " + new TreeSet<>(threads));

        // TODO 2: one of those names is not a worker. Which, and what does its
        // presence tell you about whether parallelStream is asynchronous?

        // TODO 3: print ForkJoinPool.getCommonPoolParallelism() and
        // Runtime.getRuntime().availableProcessors(). State the relationship,
        // then say what happens in a container limited to one core.

        // TODO 4: run two parallel streams from two different threads at the
        // same time and collect the names from both. Do they share workers?
        // That answer is the reason this entry exists.

        // TODO 5: now run the same stream inside your own pool:
        //
        //     ForkJoinPool mine = new ForkJoinPool(2);
        //     Set<String> names = mine.submit(() -> ...).get();
        //
        // The names change. Note that you did not pass the pool to the stream
        // — say where the stream found it, and why there is no overload that
        // takes one.

        // TODO 6: in one sentence, explain to a colleague why adding
        // .parallelStream() to a slow remote call can make an unrelated
        // endpoint time out.
    }
}