public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        Set<Thread> threads = new HashSet<>();
        CountDownLatch countDownLatch = new CountDownLatch(5);
        for (int i = 0; i < 5; i++) {
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    threads.add(Thread.currentThread());
                    countDownLatch.countDown();

                }
            });
        }
        executorService.shutdown();
        countDownLatch.await();
        System.out.println("result: " + threads.size());
    }

 public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        Set<Thread> threads = new ConcurrentSkipListSet<>();
        CountDownLatch countDownLatch = new CountDownLatch(5);
        for (int i = 0; i < 5; i++) {
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    threads.add(Thread.currentThread());
                    countDownLatch.countDown();

                }
            });
        }
        executorService.shutdown();
        countDownLatch.await();
        System.out.println("result: " + threads.size());
    }

public class ThreadPoolTest {
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10000; i++) {
            if (test() != 5000) {
                throw new RuntimeException("main");
            }
        }
    }

    private static long test() throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        CountDownLatch countDownLatch = new CountDownLatch(1000 * 5);
        Set<Thread> threads = Collections.synchronizedSet(new HashSet<>());
        AtomicLong atomicLong = new AtomicLong();
        for (int i = 0; i < 5 * 1000; i++) {
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        threads.add(Thread.currentThread());
                        atomicLong.incrementAndGet();
                        countDownLatch.countDown();
                    } catch (Exception e) {
                        System.out.println(e);
                    }


                }
            });
        }
        executorService.shutdown();
        countDownLatch.await();
        if (threads.size() != 2) {
            throw new RuntimeException("test");
        }
        return atomicLong.get();
    }
}

ExecutorService executor = Executors.newFixedThreadPool(2);
        Set<Thread> threads = new ConcurrentSkipListSet<>();
        CountDownLatch cdl = new CountDownLatch(5);
        for(int i = 0; i < 5; i++) {
            executor.execute(() -> {
                try {
                    threads.add(Thread.currentThread()); //(1)
                } finally {
                    cdl.countDown();
                }
            });
        }
        executor.shutdown();
        cdl.await();
        System.out.println(threads.size());

    public static void main(String[] args) throws InterruptedException {
        ThreadLocal<Integer> number = new ThreadLocal<Integer>() {
            private final AtomicInteger values = new AtomicInteger();

            @Override
            protected Integer initialValue() {
                return values.getAndIncrement();
            }
        };
        ExecutorService threadPool = Executors.newFixedThreadPool(100);


        for (int i = 0; i < 500; i++) {
            final int count = i;

            threadPool.submit(() -> System.out.printf("%-4s : %-20s - %s\n", count, Thread.currentThread().getName(), number.get()));
        }

        threadPool.shutdown();
        threadPool.awaitTermination(100, TimeUnit.SECONDS);

        System.out.println(number.get().intValue());
    }